pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-07-16 04:01:31 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
da33dda7dcbaec0b55e690e942fef5e2eed273fe
core/MsBinaryFile/Common/ODraw/GraphicsPath.h
Vikulov Dmitry 4f19fca2ed Big refactoring 
new project scheme
2022-11-18 15:01:21 +03:00

919 lines
25 KiB
C++
Raw Blame History

/*
* (c) Copyright Ascensio System SIA 2010-2019
*
* 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-12 Ernesta Birznieka-Upisha
* 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
*
*/
#pragma once
#include <string>
#include <boost/algorithm/string.hpp>
#include "../../../DesktopEditor/graphics/GraphicsPath.h"
#define _USE_MATH_DEFINES
#include <math.h>//M_PI
#include <vector>
namespace NSCustomShapesConvert
{
const double c_dMasterUnitsToInchKoef = 1.0 / 576;
const double c_dInchToMillimetreKoef = 25.4;
const double c_dMasterUnitsToMillimetreKoef = c_dMasterUnitsToInchKoef * c_dInchToMillimetreKoef;
class CDoubleRect
{
public:
double left;
double top;
double right;
double bottom;
public:
CDoubleRect()
{
left = 0;
top = 0;
right = 0;
bottom = 0;
}
CDoubleRect& operator=(const CDoubleRect& oSrc)
{
left = oSrc.left;
top = oSrc.top;
right = oSrc.right;
bottom = oSrc.bottom;
return *this;
}
CDoubleRect(const CDoubleRect& oSrc)
{
*this = oSrc;
}
inline bool IsEqual(const CDoubleRect& oSrc, double dEps = 0.01)
{
return ((fabs(left - oSrc.left) < dEps) && (fabs(top - oSrc.top) < dEps) &&
(fabs(right - oSrc.right) < dEps) && (fabs(bottom - oSrc.bottom) < dEps));
}
inline double GetWidth() const
{
return right - left;
}
inline double GetHeight() const
{
return bottom - top;
}
inline void Scale(const double& dKoef)
{
left *= dKoef;
top *= dKoef;
right *= dKoef;
bottom *= dKoef;
}
};
class CGeomShapeInfo
{
public:
class CPointD
{
public:
double dX;
double dY;
public:
CPointD()
{
dX = 0;
dY = 0;
}
CPointD& operator= (const CPointD& oSrc)
{
dX = oSrc.dX;
dY = oSrc.dY;
return *this;
}
CPointD(const CPointD& oSrc)
{
*this = oSrc;
}
};
public:
double m_dLeft;
double m_dTop;
double m_dWidth;
double m_dHeight;
double m_dLimoX;
double m_dLimoY;
// нужен для регулировки по аспекту (limo)
CPointD m_oCurPoint;
double m_dRotate;
bool m_bFlipH;
bool m_bFlipV;
LONG m_lOriginalWidth;
LONG m_lOriginalHeight;
public:
CGeomShapeInfo()
{
m_dLeft = 0;
m_dTop = 0;
m_dWidth = 720;
m_dHeight = 576;
m_dLimoX = 0;
m_dLimoY = 0;
m_oCurPoint.dX = 0;
m_oCurPoint.dY = 0;
m_dRotate = 0.0;
m_bFlipH = false;
m_bFlipV = false;
m_lOriginalWidth = 0;
m_lOriginalHeight = 0;
}
~CGeomShapeInfo()
{
}
CGeomShapeInfo& operator =(const CGeomShapeInfo& oSrc)
{
m_dLeft = oSrc.m_dLeft;
m_dTop = oSrc.m_dTop;
m_dWidth = oSrc.m_dWidth;
m_dHeight = oSrc.m_dHeight;
m_dLimoX = oSrc.m_dLimoX;
m_dLimoY = oSrc.m_dLimoY;
m_oCurPoint = oSrc.m_oCurPoint;
m_dRotate = oSrc.m_dRotate;
m_bFlipH = oSrc.m_bFlipH;
m_bFlipV = oSrc.m_bFlipV;
m_lOriginalWidth = oSrc.m_lOriginalWidth;
m_lOriginalHeight = oSrc.m_lOriginalHeight;
return (*this);
}
inline void SetBounds(const CDoubleRect& oRect)
{
m_dLeft = oRect.left;
m_dTop = oRect.top;
m_dWidth = oRect.GetWidth();
m_dHeight = oRect.GetHeight();
}
inline LONG GetFlags()
{
LONG lFlags = 0;
if (m_bFlipH)
lFlags |= 0x0001;
if (m_bFlipV)
lFlags |= 0x0002;
return lFlags;
}
};
class CDoublePoint
{
public:
double dX;
double dY;
public:
CDoublePoint()
{
dX = 0;
dY = 0;
}
CDoublePoint& operator= (const CDoublePoint& oSrc)
{
dX = oSrc.dX;
dY = oSrc.dY;
return *this;
}
CDoublePoint(const CDoublePoint& oSrc)
{
*this = oSrc;
}
};
enum RulesType
{
// VML
rtLineTo = 0, // 2*
rtCurveTo = 1, // 6*
rtMoveTo = 2, // 2
rtClose = 3, // 0
rtEnd = 4, // 0
rtRMoveTo = 5, // 2*
rtRLineTo = 6, // 2*
rtRCurveTo = 7, // 6*
rtNoFill = 8, // 0
rtNoStroke = 9, // 0
rtAngleEllipseTo = 10, // 6*
rtAngleEllipse = 11, // 6*
rtArc = 12, // 8*
rtArcTo = 13, // 8*
rtClockwiseArcTo = 14, // 8*
rtClockwiseArc = 15, // 8*
rtEllipticalQuadrX = 16, // 2*
rtEllipticalQuadrY = 17, // 2*
rtQuadrBesier = 18, // 2 + 2*
rtFillColor = 20,
rtLineColor = 21,
// OOXML
rtOOXMLMoveTo = 0 + 100, // 2
rtOOXMLLineTo = 1 + 100, // 2*
rtOOXMLCubicBezTo = 2 + 100, // 6*
rtOOXMLArcTo = 3 + 100, // 8*
rtOOXMLQuadBezTo = 4 + 100, // 2 + 2*
rtOOXMLClose = 5 + 100, // 0
rtOOXMLEnd = 6 + 100 // 0
};
class CGraphicPath
{
public:
virtual void InternalClear()
{
m_lFlags = 0;
}
CGraphicPath()
{
InternalClear();
}
class CPart
{
public:
RulesType m_eType;
std::vector<CDoublePoint> m_arPoints;
public:
CPart() : m_eType(rtMoveTo), m_arPoints()
{
}
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);
}
~CPart()
{
this->m_arPoints.clear();
}
//void 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;
// ParseString(_T(" "), strPath, &arStrNums);
// bool bIsX = true;
// int nCurPoint = 0;
// for (int 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 ParseString(std::wstring strDelimeters, std::wstring strSource,
std::vector<std::wstring>& pArrayResults, bool bIsCleared = true)
{
if (bIsCleared)
pArrayResults.clear();
std::wstring resToken;
int curPos= 0;
boost::algorithm::split(pArrayResults, strSource, boost::algorithm::is_any_of(strDelimeters), boost::algorithm::token_compress_on);
}
void CheckLastPoint(IRenderer* pRenderer, CDoublePoint& pointCur)
{
if (NULL == pRenderer)
return;
pRenderer->PathCommandGetCurrentPoint(&pointCur.dX, &pointCur.dY);
}
double 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;
}
}
inline double GetSweepAngle(const double& angleStart, const double& angleEnd)
{
if (angleStart >= angleEnd)
return angleEnd - angleStart;
else
return angleEnd - angleStart - 360;
}
void 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 GetSafearrayPoints(IRenderer* pRenderer, double** ppArray, size_t& nCountOut, CDoublePoint& pointCur, bool bR = false)
{
if (NULL == ppArray)
return;
size_t nCount = 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 (size_t 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 (size_t 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 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:
{
int nFigure = 0;
while ((nFigure + 3) <= (int)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();
int nFigure = 0;
while ((nFigure + 3) <= (int)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();
int nFigure = 0;
while ((nFigure + 4) <= (int)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:
{
int nFigure = 0;
while ((nFigure + 4) <= (int)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:
{
int nFigure = 0;
while ((nFigure + 4) <= (int)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();
int nFigure = 0;
while ((nFigure + 4) <= (int)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);
size_t nCount = this->m_arPoints.size();
for (size_t 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);
size_t nCount = this->m_arPoints.size();
for (size_t 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;
};
}
inline void 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 AddRuler(const RulesType& eType)
{
size_t lCount = m_arParts.size();
CPart oPart;
oPart.m_eType = eType;
m_arParts.push_back(oPart);
}
void AddPoint(const double& x, const double& y)
{
size_t lCount = m_arParts.size();
if (0 != lCount)
{
CDoublePoint point;
point.dX = x;
point.dY = y;
m_arParts[lCount - 1].m_arPoints.push_back(point);
}
}
void Clear()
{
m_arParts.clear();
}
std::vector<CPart> m_arParts;
int m_lFlags;
};
}
Reference in New Issue View Git Blame Copy Permalink