Yajbir-Malik/DocumentServer-v-9.2.0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5d1113a23ff5ae1ec4aaa54e253a4df9dae0a922
DocumentServer-v-9.2.0/core/MsBinaryFile/Common/Vml/GraphicsPath.cpp
T
Yajbir Singh f1b860b25c
check / markdownlint (push) Has been cancelled
Details
check / spellchecker (push) Has been cancelled
Details
updated
2025-12-11 19:03:17 +05:30

755 lines
20 KiB
C++
Raw Blame History

/*
* (c) Copyright Ascensio System SIA 2010-2023
*
* This program is a free software product. You can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License (AGPL)
* version 3 as published by the Free Software Foundation. In accordance with
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
* that Ascensio System SIA expressly excludes the warranty of non-infringement
* of any third-party rights.
*
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
*
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
* street, Riga, Latvia, EU, LV-1050.
*
* The interactive user interfaces in modified source and object code versions
* of the Program must display Appropriate Legal Notices, as required under
* Section 5 of the GNU AGPL version 3.
*
* Pursuant to Section 7(b) of the License you must retain the original Product
* logo when distributing the program. Pursuant to Section 7(e) we decline to
* grant you any rights under trademark law for use of our trademarks.
*
* All the Product's GUI elements, including illustrations and icon sets, as
* well as technical writing content are licensed under the terms of the
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
*
*/
#include "GraphicsPath.h"
namespace ODRAW
{
CDoublePoint::CDoublePoint()
{
dX = 0;
dY = 0;
}
CDoublePoint& CDoublePoint::operator= (const CDoublePoint& oSrc)
{
dX = oSrc.dX;
dY = oSrc.dY;
return *this;
}
CDoublePoint::CDoublePoint(const CDoublePoint& oSrc)
{
*this = oSrc;
}
void CGraphicPath::InternalFromXmlNode(XmlUtils::CXmlNode& oXmlNode)
{
Metric = XmlUtils::GetInteger(oXmlNode.GetAttributeOrValue(_T("metric"), _T("0")));
m_bStroke = (1 == XmlUtils::GetInteger(oXmlNode.GetAttributeOrValue(_T("stroke"), _T("0"))));
m_bFill = (1 == XmlUtils::GetInteger(oXmlNode.GetAttributeOrValue(_T("fill"), _T("0"))));
m_dAngle = XmlUtils::GetDouble(oXmlNode.GetAttributeOrValue(_T("angle"), _T("0")));
m_lFlags = XmlUtils::GetInteger(oXmlNode.GetAttributeOrValue(_T("flags"), _T("0")));
m_oBounds.left = XmlUtils::GetDouble(oXmlNode.GetAttributeOrValue(_T("bounds-left"), _T("0")));
m_oBounds.top = XmlUtils::GetDouble(oXmlNode.GetAttributeOrValue(_T("bounds-top"), _T("0")));
m_oBounds.right = XmlUtils::GetDouble(oXmlNode.GetAttributeOrValue(_T("bounds-right"), _T("0")));
m_oBounds.bottom = XmlUtils::GetDouble(oXmlNode.GetAttributeOrValue(_T("bounds-bottom"), _T("0")));
std::vector<XmlUtils::CXmlNode> oNodes;
oXmlNode.GetNodes(_T("part"), oNodes);
for (size_t nIndex = 0; nIndex < oNodes.size(); ++nIndex)
{
CPart oPart;
XmlUtils::CXmlNode & oNode = oNodes[nIndex];
oPart.FromXmlNode(oNode);
m_arParts.push_back(oPart);
}
//XmlUtils::CXmlNode oPenNode;
//if (oXmlNode.GetNode(_T("pen"), oPenNode))
//{
// Pen.FromXmlNode(oPenNode);
//}
//XmlUtils::CXmlNode oBrushNode;
//if (oXmlNode.GetNode(_T("brush"), oBrushNode))
//{
// Brush.FromXmlNode(oBrushNode);
//}
}
void CGraphicPath::InternalClear()
{
m_bFill = false;
m_bStroke = true;
m_dAngle = 0;
m_lFlags = 0;
}
CGraphicPath::CGraphicPath()
{
InternalClear();
}
void CGraphicPath::Draw(IRenderer* pRenderer)
{
if (NULL == pRenderer)
return;
// вообще можно каждый раз выставл¤ть pen/brush.
// но у нас сейчас pen и brush выставл¤ютс¤ в shape
pRenderer->SetCommandParams(m_dAngle, m_oBounds.left, m_oBounds.top, m_oBounds.GetWidth(), m_oBounds.GetHeight(), m_lFlags);
pRenderer->BeginCommand(c_nPathType);
CDoublePoint pointCur; pointCur.dX = 0; pointCur.dY = 0;
for (size_t nIndex = 0; nIndex < m_arParts.size(); ++nIndex)
{
m_arParts[nIndex].Draw(pRenderer, pointCur);
}
LONG lType = 0;
if (m_bStroke)
{
lType = 1;
}
if (m_bFill)
{
lType += c_nWindingFillMode;
}
pRenderer->DrawPath(lType);
pRenderer->SetCommandParams(0, -1, -1, -1, -1, 0);
pRenderer->PathCommandEnd();
pRenderer->EndCommand(c_nPathType);
}
void CGraphicPath::ConvertVector(IRenderer* pRenderer)
{
pRenderer->SetCommandParams(m_dAngle, m_oBounds.left, m_oBounds.top, m_oBounds.GetWidth(), m_oBounds.GetHeight(), m_lFlags);
pRenderer->BeginCommand(c_nPathType);
CDoublePoint pointCur; pointCur.dX = 0; pointCur.dY = 0;
for (size_t nIndex = 0; nIndex < m_arParts.size(); ++nIndex)
{
m_arParts[nIndex].Draw(pRenderer, pointCur);
}
LONG lType = 0;
if (m_bStroke)
{
lType = 1;
}
if (m_bFill)
{
lType += c_nWindingFillMode;
}
pRenderer->DrawPath(lType);
pRenderer->SetCommandParams(0, -1, -1, -1, -1, 0);
pRenderer->EndCommand(c_nPathType);
}
CGraphicPath::CPart::CPart() : m_eType(rtMoveTo), m_arPoints()
{
}
CGraphicPath::CPart& CGraphicPath::CPart::operator=(const CPart& oSrc)
{
m_eType = oSrc.m_eType;
this->m_arPoints.clear();
for (size_t nIndex = 0; nIndex < oSrc.m_arPoints.size(); ++nIndex)
{
this->m_arPoints.push_back(oSrc.m_arPoints[nIndex]);
}
return (*this);
}
CGraphicPath::CPart::~CPart()
{
this->m_arPoints.clear();
}
void CGraphicPath::CPart::FromXmlNode(XmlUtils::CXmlNode& oNode)
{
std::wstring strName = oNode.GetAttribute(_T("name"));
if (_T("moveto") == strName) m_eType = rtMoveTo;
else if (_T("lineto") == strName) m_eType = rtLineTo;
else if (_T("curveto") == strName) m_eType = rtCurveTo;
else if (_T("rmoveto") == strName) m_eType = rtRMoveTo;
else if (_T("rlineto") == strName) m_eType = rtRLineTo;
else if (_T("rcurveto") == strName) m_eType = rtRCurveTo;
else if (_T("ellipseto") == strName) m_eType = rtAngleEllipseTo;
else if (_T("ellipse") == strName) m_eType = rtAngleEllipse;
else if (_T("arc") == strName) m_eType = rtArc;
else if (_T("arcto") == strName) m_eType = rtArcTo;
else if (_T("clockwisearcto") == strName) m_eType = rtClockwiseArcTo;
else if (_T("clockwisearc") == strName) m_eType = rtClockwiseArc;
else if (_T("ellipticalx") == strName) m_eType = rtEllipticalQuadrX;
else if (_T("ellipticaly") == strName) m_eType = rtEllipticalQuadrY;
else if (_T("qbesier") == strName) m_eType = rtQuadrBesier;
else m_eType = rtClose;
std::wstring strPath = oNode.GetAttribute(_T("path"));
if (_T("") == strPath)
return;
std::vector<std::wstring> arStrNums;
boost::algorithm::split(arStrNums, strPath, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
bool bIsX = true;
int nCurPoint = 0;
for (size_t nIndex = 0; nIndex < arStrNums.size(); ++nIndex)
{
if (bIsX)
{
++nCurPoint;
CDoublePoint point;
this->m_arPoints.push_back(point);
this->m_arPoints[nCurPoint - 1].dX = XmlUtils::GetDouble(arStrNums[nIndex]);
}
else
{
this->m_arPoints[nCurPoint - 1].dY = XmlUtils::GetDouble(arStrNums[nIndex]);
}
bIsX = !bIsX;
}
}
void CGraphicPath::CPart::CheckLastPoint(IRenderer* pRenderer, CDoublePoint& pointCur)
{
if (NULL == pRenderer)
return;
pRenderer->PathCommandGetCurrentPoint(&pointCur.dX, &pointCur.dY);
}
double CGraphicPath::CPart::GetAngle(double fCentreX, double fCentreY, double fX, double fY)
{
// - + (.. )
double dX = fX - fCentreX;
double dY = fY - fCentreY;
double modDX = abs(dX);
double modDY = abs(dY);
if ((modDX < 0.01) && (modDY < 0.01))
{
return 0;
}
if ((modDX < 0.01) && (dY < 0))
{
return -90;
}
else if (modDX < 0.01)
{
return 90;
}
if ((modDY < 0.01) && (dX < 0))
{
return 180;
}
else if (modDY < 0.01)
{
return 0;
}
double fAngle = atan(dY / dX);
fAngle *= double(180 / M_PI);
if (dX > 0 && dY > 0)
{
return fAngle;
}
else if (dX > 0 && dY < 0)
{
return fAngle;
}
else if (dX < 0 && dY > 0)
{
//return fAngle + 180;
return 180 + fAngle;
}
else
{
//return fAngle + 180;
return fAngle - 180;
}
}
double CGraphicPath::CPart::GetSweepAngle(const double& angleStart, const double& angleEnd)
{
if (angleStart >= angleEnd)
return angleEnd - angleStart;
else
return angleEnd - angleStart - 360;
}
void CGraphicPath::CPart::ApplyElliptical(bool& bIsX, double& angleStart, double& angleSweet,
double& Left, double& Top, double& Width, double& Height, const CDoublePoint& pointCur)
{
// (x - y - x...)
if (bIsX)
{
angleStart = -90;
angleSweet = 90;
if ((Width < 0) && (Height < 0))
{
angleStart = 90;
Width *= -1;
Height *= -1;
Left = pointCur.dX - Width / 2;
Top = pointCur.dY - Height;
}
else if ((Width < 0) && (Height > 0))
{
angleStart = -90;
angleSweet = -90;
Width *= -1;
Left = pointCur.dX - Width / 2;
Top = pointCur.dY;
}
else if ((Width > 0) && (Height < 0))
{
angleStart = 90;
angleSweet = -90;
Height *= -1;
Left = pointCur.dX - Width / 2;
Top = pointCur.dY - Height;
}
else
{
Left = pointCur.dX - Width / 2;
Top = pointCur.dY;
}
}
else
{
angleStart = 180;
angleSweet = -90;
if ((Width < 0) && (Height < 0))
{
angleStart = 0;
Width *= -1;
Height *= -1;
Left = pointCur.dX - Width;
Top = pointCur.dY - Height / 2;
}
else if ((Width < 0) && (Height > 0))
{
angleStart = 0;
angleSweet = 90;
Width *= -1;
Left = pointCur.dX - Width;
Top = pointCur.dY - Height / 2;
}
else if ((Width > 0) && (Height < 0))
{
angleStart = 180;
angleSweet = 90;
Height *= -1;
Left = pointCur.dX;
Top = pointCur.dY - Height / 2;
}
else
{
Left = pointCur.dX;
Top = pointCur.dY - Height / 2;
}
}
bIsX = !bIsX;
}
void CGraphicPath::CPart::GetSafearrayPoints(IRenderer* pRenderer, double** ppArray, size_t& nCountOut, CDoublePoint& pointCur, bool bR)
{
if (NULL == ppArray)
return;
int nCount = (int)this->m_arPoints.size();
nCountOut = 2 * (nCount + 1);
double* pArray = new double [nCountOut];
double* pBuffer = pArray;
memset (pBuffer, 0, nCountOut * sizeof(double));
*pBuffer = pointCur.dX; ++pBuffer;
*pBuffer = pointCur.dY; ++pBuffer;
if (bR)
{
for (int nIndex = 0; nIndex < nCount; ++nIndex)
{
*pBuffer = (this->m_arPoints[nIndex].dX + pointCur.dX); ++pBuffer;
*pBuffer = (this->m_arPoints[nIndex].dY + pointCur.dY); ++pBuffer;
if (nIndex == (nCount - 1))
{
pointCur.dX += this->m_arPoints[nIndex].dX;
pointCur.dY += this->m_arPoints[nIndex].dY;
}
}
}
else
{
for (int nIndex = 0; nIndex < nCount; ++nIndex)
{
*pBuffer = this->m_arPoints[nIndex].dX; ++pBuffer;
*pBuffer = this->m_arPoints[nIndex].dY; ++pBuffer;
if (nIndex == (nCount - 1))
{
pointCur.dX = this->m_arPoints[nIndex].dX;
pointCur.dY = this->m_arPoints[nIndex].dY;
}
}
}
*ppArray = pArray;
}
void CGraphicPath::CPart::Draw(IRenderer* pRenderer, CDoublePoint& pointCur)
{
switch (m_eType)
{
case rtMoveTo:
{
if (0 < this->m_arPoints.size())
{
pointCur.dX = this->m_arPoints[0].dX;
pointCur.dY = this->m_arPoints[0].dY;
pRenderer->PathCommandMoveTo(this->m_arPoints[0].dX, this->m_arPoints[0].dY);
}
break;
}
case rtLineTo:
{
double* pArray = NULL;
size_t nCount = 0;
GetSafearrayPoints(pRenderer, &pArray, nCount, pointCur);
if (NULL != pArray)
{
pRenderer->PathCommandLinesTo(pArray, (int)nCount /*this->m_arPoints.size()*/);
}
break;
}
case rtCurveTo:
{
double* pArray = NULL;
size_t nCount = 0;
GetSafearrayPoints(pRenderer, &pArray, nCount, pointCur);
if (NULL != pArray)
{
pRenderer->PathCommandCurvesTo (pArray, (int)nCount/*this->m_arPoints.size()*/);
}
break;
}
case rtClose:
{
pRenderer->PathCommandClose();
break;
}
case rtRMoveTo:
{
if (0 < this->m_arPoints.size())
{
pointCur.dX = this->m_arPoints[0].dX + pointCur.dX;
pointCur.dY = this->m_arPoints[0].dY + pointCur.dY;
pRenderer->PathCommandMoveTo(pointCur.dX, pointCur.dY);
}
break;
}
case rtRLineTo:
{
double* pArray = NULL;
size_t nCount = 0;
GetSafearrayPoints(pRenderer, &pArray, nCount, pointCur, TRUE);
if (NULL != pArray)
{
pRenderer->PathCommandLinesTo(pArray, (int)nCount/*this->m_arPoints.size()*/);
}
break;
}
case rtRCurveTo:
{
double* pArray = NULL;
size_t nCount = 0;
GetSafearrayPoints(pRenderer, &pArray, nCount, pointCur, TRUE);
if (NULL != pArray)
{
pRenderer->PathCommandCurvesTo(pArray, (int)nCount/*this->m_arPoints.size()*/);
}
break;
}
case rtAngleEllipseTo:
{
size_t nFigure = 0;
while ((nFigure + 3) <= this->m_arPoints.size())
{
double nLeft = this->m_arPoints[nFigure].dX - this->m_arPoints[nFigure + 1].dX / 2;
double nTop = this->m_arPoints[nFigure].dY - this->m_arPoints[nFigure + 1].dY / 2;
pRenderer->PathCommandArcTo(nLeft, nTop,
this->m_arPoints[nFigure + 1].dX, this->m_arPoints[nFigure + 1].dY,
this->m_arPoints[nFigure + 2].dX, this->m_arPoints[nFigure + 2].dY);
nFigure += 3;
}
CheckLastPoint(pRenderer, pointCur);
break;
}
case rtAngleEllipse:
{
pRenderer->PathCommandStart();
size_t nFigure = 0;
while ((nFigure + 3) <= this->m_arPoints.size())
{
double nLeft = this->m_arPoints[nFigure].dX - this->m_arPoints[nFigure + 1].dX / 2;
double nTop = this->m_arPoints[nFigure].dY - this->m_arPoints[nFigure + 1].dY / 2;
pRenderer->PathCommandArcTo(nLeft, nTop,
this->m_arPoints[nFigure + 1].dX, this->m_arPoints[nFigure + 1].dY,
this->m_arPoints[nFigure + 2].dX, this->m_arPoints[nFigure + 2].dY);
nFigure += 3;
}
CheckLastPoint(pRenderer, pointCur);
break;
}
case rtArc:
{
pRenderer->PathCommandStart();
size_t nFigure = 0;
while ((nFigure + 4) <= this->m_arPoints.size())
{
double nCentreX = (this->m_arPoints[nFigure].dX + this->m_arPoints[nFigure + 1].dX) / 2;
double nCentreY = (this->m_arPoints[nFigure].dY + this->m_arPoints[nFigure + 1].dY) / 2;
double angleStart = GetAngle(nCentreX, nCentreY,
this->m_arPoints[nFigure + 2].dX, this->m_arPoints[nFigure + 2].dY);
double angleEnd = GetAngle(nCentreX, nCentreY,
this->m_arPoints[nFigure + 3].dX, this->m_arPoints[nFigure + 3].dY);
pRenderer->PathCommandArcTo(this->m_arPoints[nFigure].dX, this->m_arPoints[nFigure].dY,
this->m_arPoints[nFigure + 1].dX - this->m_arPoints[nFigure].dX,
this->m_arPoints[nFigure + 1].dY - this->m_arPoints[nFigure].dY,
angleStart, GetSweepAngle(angleStart, angleEnd));
nFigure += 4;
}
CheckLastPoint(pRenderer, pointCur);
break;
}
case rtArcTo:
{
size_t nFigure = 0;
while ((nFigure + 4) <= this->m_arPoints.size())
{
double nCentreX = (this->m_arPoints[nFigure].dX + this->m_arPoints[nFigure + 1].dX) / 2;
double nCentreY = (this->m_arPoints[nFigure].dY + this->m_arPoints[nFigure + 1].dY) / 2;
double angleStart = GetAngle(nCentreX, nCentreY,
this->m_arPoints[nFigure + 2].dX, this->m_arPoints[nFigure + 2].dY);
double angleEnd = GetAngle(nCentreX, nCentreY,
this->m_arPoints[nFigure + 3].dX, this->m_arPoints[nFigure + 3].dY);
pRenderer->PathCommandArcTo(this->m_arPoints[nFigure].dX, this->m_arPoints[nFigure].dY,
this->m_arPoints[nFigure + 1].dX - this->m_arPoints[nFigure].dX,
this->m_arPoints[nFigure + 1].dY - this->m_arPoints[nFigure].dY,
angleStart, GetSweepAngle(angleStart, angleEnd));
nFigure += 4;
}
CheckLastPoint(pRenderer, pointCur);
break;
}
case rtClockwiseArcTo:
{
size_t nFigure = 0;
while ((nFigure + 4) <= this->m_arPoints.size())
{
double nCentreX = (this->m_arPoints[nFigure].dX + this->m_arPoints[nFigure + 1].dX) / 2;
double nCentreY = (this->m_arPoints[nFigure].dY + this->m_arPoints[nFigure + 1].dY) / 2;
double angleStart = GetAngle(nCentreX, nCentreY,
this->m_arPoints[nFigure + 2].dX, this->m_arPoints[nFigure + 2].dY);
double angleEnd = GetAngle(nCentreX, nCentreY,
this->m_arPoints[nFigure + 3].dX, this->m_arPoints[nFigure + 3].dY);
pRenderer->PathCommandArcTo(this->m_arPoints[nFigure].dX, this->m_arPoints[nFigure].dY,
this->m_arPoints[nFigure + 1].dX - this->m_arPoints[nFigure].dX,
this->m_arPoints[nFigure + 1].dY - this->m_arPoints[nFigure].dY,
angleStart, 360 + GetSweepAngle(angleStart, angleEnd));
nFigure += 4;
}
CheckLastPoint(pRenderer, pointCur);
break;
}
case rtClockwiseArc:
{
pRenderer->PathCommandStart();
size_t nFigure = 0;
while ((nFigure + 4) <= this->m_arPoints.size())
{
double nCentreX = (this->m_arPoints[nFigure].dX + this->m_arPoints[nFigure + 1].dX) / 2;
double nCentreY = (this->m_arPoints[nFigure].dY + this->m_arPoints[nFigure + 1].dY) / 2;
double angleStart = GetAngle(nCentreX, nCentreY,
this->m_arPoints[nFigure + 2].dX, this->m_arPoints[nFigure + 2].dY);
double angleEnd = GetAngle(nCentreX, nCentreY,
this->m_arPoints[nFigure + 3].dX, this->m_arPoints[nFigure + 3].dY);
pRenderer->PathCommandArcTo(this->m_arPoints[nFigure].dX, this->m_arPoints[nFigure].dY,
this->m_arPoints[nFigure + 1].dX - this->m_arPoints[nFigure].dX,
this->m_arPoints[nFigure + 1].dY - this->m_arPoints[nFigure].dY,
angleStart, 360 + GetSweepAngle(angleStart, angleEnd));
nFigure += 4;
}
CheckLastPoint(pRenderer, pointCur);
break;
}
case rtEllipticalQuadrX:
{
bool bIsX = true;
CheckLastPoint(pRenderer, pointCur);
int nCount = (int)m_arPoints.size();
for (int nIndex = 0; nIndex < nCount; ++nIndex)
{
double x1 = pointCur.dX;
double y1 = pointCur.dY;
double x2 = this->m_arPoints[nIndex].dX;
double y2 = this->m_arPoints[nIndex].dY;
double dRadX = fabs(x1 - x2);
double dRadY = fabs(y1 - y2);
AddEllipticalQuadr(pRenderer, bIsX, x1, y1, x2, y2, dRadX, dRadY);
pointCur.dX = x2;
pointCur.dY = y2;
}
break;
}
case rtEllipticalQuadrY:
{
bool bIsX = false;
CheckLastPoint(pRenderer, pointCur);
int nCount = (int)m_arPoints.size();
for (int nIndex = 0; nIndex < nCount; ++nIndex)
{
double x1 = pointCur.dX;
double y1 = pointCur.dY;
double x2 = this->m_arPoints[nIndex].dX;
double y2 = this->m_arPoints[nIndex].dY;
double dRadX = fabs(x1 - x2);
double dRadY = fabs(y1 - y2);
AddEllipticalQuadr(pRenderer, bIsX, x1, y1, x2, y2, dRadX, dRadY);
pointCur.dX = x2;
pointCur.dY = y2;
}
break;
}
case rtQuadrBesier:
{
double* pArray = NULL;
size_t nCount = 0;
GetSafearrayPoints(pRenderer, &pArray, nCount, pointCur, TRUE);
if (NULL != pArray)
{
pRenderer->PathCommandLinesTo(pArray, (int)nCount/*this->m_arPoints.size()*/);
}
CheckLastPoint(pRenderer, pointCur);
break;
}
default: break;
};
}
void CGraphicPath::CPart::AddEllipticalQuadr(IRenderer*& pRenderer, bool& bIsX, double& x1, double& y1, double& x2, double& y2, double& dRadX, double& dRadY)
{
if (bIsX)
{
if ((x2 >= x1) && (y2 >= y1))
pRenderer->PathCommandArcTo(x1 - dRadX, y1, 2 * dRadX, 2 * dRadY, -90, 90);
else if ((x2 >= x1) && (y2 <= y1))
pRenderer->PathCommandArcTo(x1 - dRadX, y1 - 2 * dRadY, 2 * dRadX, 2 * dRadY, 90, -90);
else if ((x2 <= x1) && (y2 >= y1))
pRenderer->PathCommandArcTo(x1 - dRadX, y1, 2 * dRadX, 2 * dRadY, -90, -90);
else if ((x2 <= x1) && (y2 <= y1))
pRenderer->PathCommandArcTo(x1 - dRadX, y1 - 2 * dRadY, 2 * dRadX, 2 * dRadY, 90, 90);
}
else
{
if ((x2 >= x1) && (y2 >= y1))
pRenderer->PathCommandArcTo(x1, y1 - dRadY, 2 * dRadX, 2 * dRadY, 180, -90);
else if ((x2 >= x1) && (y2 <= y1))
pRenderer->PathCommandArcTo(x1, y1 - dRadY, 2 * dRadX, 2 * dRadY, 180, 90);
else if ((x2 <= x1) && (y2 >= y1))
pRenderer->PathCommandArcTo(x1 - 2 * dRadX, y1 - dRadY, 2 * dRadX, 2 * dRadY, 0, 90);
else if ((x2 <= x1) && (y2 <= y1))
pRenderer->PathCommandArcTo(x1 - 2 * dRadX, y1 - dRadY, 2 * dRadX, 2 * dRadY, 0, -90);
}
bIsX = !bIsX;
}
void CGraphicPath::AddRuler(const RulesType& eType)
{
int lCount = (int)m_arParts.size();
CPart oPart;
oPart.m_eType = eType;
m_arParts.push_back(oPart);
}
void CGraphicPath::AddPoint(const double& x, const double& y)
{
int lCount = (int)m_arParts.size();
if (0 != lCount)
{
CDoublePoint point;
point.dX = x;
point.dY = y;
m_arParts[lCount - 1].m_arPoints.push_back(point);
}
}
void CGraphicPath::Clear()
{
m_arParts.clear();
}
}
Reference in New Issue View Git Blame Copy Permalink