2030 lines
78 KiB
C++
2030 lines
78 KiB
C++
/*
|
||
* (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 "Ppt2PptxShapeConverter.h"
|
||
|
||
namespace NSGuidesVML
|
||
{
|
||
CSlicePath::CSlicePath(RulesType rule, LONG x, LONG y) : m_lX(x), m_lY(y), m_eRuler(rule)
|
||
{
|
||
m_nCountElementsPoint = 0;
|
||
}
|
||
void CSlicePath::AddParam(LONG lParam, ParamType eParType)
|
||
{
|
||
long lPoint = m_nCountElementsPoint % 2;
|
||
if (0 == lPoint)
|
||
{
|
||
Aggplus::POINT point;
|
||
SPointType pointType;
|
||
|
||
point.x = lParam;
|
||
if (m_eRuler != rtRMoveTo && m_eRuler != rtRLineTo && m_eRuler != rtRCurveTo)
|
||
{
|
||
point.x -= m_lX;
|
||
}
|
||
point.y = 0;
|
||
pointType.x = eParType;
|
||
pointType.y = ptValue;
|
||
m_arPoints.push_back(point);
|
||
m_arPointsType.push_back(pointType);
|
||
}
|
||
else
|
||
{
|
||
m_arPoints.back().y = lParam;
|
||
if (m_eRuler != rtRMoveTo && m_eRuler != rtRLineTo && m_eRuler != rtRCurveTo)
|
||
{
|
||
m_arPoints.back().y -= m_lY;
|
||
}
|
||
|
||
m_arPointsType.back().y = eParType;
|
||
}
|
||
++m_nCountElementsPoint;
|
||
}
|
||
|
||
CFormulaConverter::CFormulaConverter()
|
||
{
|
||
m_lIndexDst = 0;
|
||
m_lIndexSrc = -1;
|
||
|
||
//m_lWidth = 0;
|
||
//m_lHeight = 0;
|
||
m_lWidth = ShapeSizeVML;
|
||
m_lHeight = ShapeSizeVML;
|
||
|
||
m_lX = 0;
|
||
m_lY = 0;
|
||
|
||
m_lMaxAdjUse = -1;
|
||
}
|
||
void CFormulaConverter::ConvertCoef(NSGuidesVML::CFormParam pCoef)
|
||
{
|
||
if (pCoef.m_eType == ptValue)
|
||
ConvertVal(pCoef.m_lParam, pCoef.m_eType, false, m_oCoef);
|
||
else if (pCoef.m_eType == ptFormula)
|
||
{
|
||
ConvertProd(22, ptValue, 1, ptValue, 7, ptValue, false, false, false, m_oCoef);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, 1, ptValue, 180, ptValue, true, false, false, m_oCoef);
|
||
}
|
||
m_oParam.m_lParam = m_lIndexDst-1;
|
||
m_oParam.m_eType = ptFormula;
|
||
m_oParam.m_lCoef = pCoef.m_lCoef;
|
||
}
|
||
void CFormulaConverter::ConvertCoef2(NSGuidesVML::CFormParam pCoef)
|
||
{
|
||
if (pCoef.m_eType == ptValue)
|
||
ConvertVal(pCoef.m_lParam, pCoef.m_eType, false, m_oGuidsRes);
|
||
else if (pCoef.m_eType == ptFormula)
|
||
{
|
||
ConvertProd(22, ptValue, 1, ptValue, 7, ptValue, false, false, false, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, 1, ptValue, 180, ptValue, true, false, false, m_oGuidsRes);
|
||
}
|
||
m_oParam.m_lParam = m_lIndexDst-1;
|
||
m_oParam.m_eType = ptFormula;
|
||
m_oParam.m_lCoef = pCoef.m_lCoef;
|
||
}
|
||
void CFormulaConverter::ConvertAdj(const std::vector<LONG>& arAdj)
|
||
{
|
||
for (int i = 0; i < (int)arAdj.size(); ++i)
|
||
{
|
||
m_oAdjRes.WriteString(L"<a:gd name=\"adj");
|
||
m_oAdjRes.WriteINT(i);
|
||
m_oAdjRes.WriteString(L"\" fmla=\"val ");
|
||
m_oAdjRes.WriteINT(arAdj[i]);
|
||
m_oAdjRes.WriteString(L"\"/>");
|
||
}
|
||
for (int i = (int)arAdj.size(); i <= m_lMaxAdjUse; ++i)
|
||
{
|
||
m_oAdjRes.WriteString(L"<a:gd name=\"adj");
|
||
m_oAdjRes.WriteINT(i);
|
||
m_oAdjRes.WriteString(L"\" fmla=\"val ");
|
||
m_oAdjRes.WriteINT(0);
|
||
m_oAdjRes.WriteString(L"\"/>");
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertFormula(const std::vector<CFormula>& arFormulas)
|
||
{
|
||
for (size_t i = 0; i < arFormulas.size(); ++i)
|
||
{
|
||
const CFormula& pFormula = arFormulas[i];
|
||
m_lIndexSrc++;
|
||
|
||
switch (pFormula.m_eFormulaType)
|
||
{
|
||
case ftVal:
|
||
{
|
||
ConvertVal(pFormula.m_lParam1, pFormula.m_eType1, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftSum:
|
||
{
|
||
ConvertSum(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam2, pFormula.m_eType2, pFormula.m_lParam3, pFormula.m_eType3, false, false, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftProduct:
|
||
{
|
||
ConvertProd(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam2, pFormula.m_eType2, pFormula.m_lParam3, pFormula.m_eType3, false, false, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftMid:
|
||
{
|
||
// TODO: +/ ???
|
||
ConvertSum(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam2, pFormula.m_eType2, 0, ptValue, false, false, false, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, 1, ptValue, 2, ptValue, true, false, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftAbsolute:
|
||
{
|
||
ConvertAbs (pFormula.m_lParam1, pFormula.m_eType1, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftMin:
|
||
{
|
||
ConvertMin(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam2, pFormula.m_eType2, false, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftMax:
|
||
{
|
||
ConvertMax(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam2, pFormula.m_eType2, false, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftIf:
|
||
{
|
||
ConvertIf(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam2, pFormula.m_eType2, pFormula.m_lParam3, pFormula.m_eType3, false, false, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftMod:
|
||
{
|
||
ConvertMod(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam2, pFormula.m_eType2, pFormula.m_lParam3, pFormula.m_eType3, false, false, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftAtan2:
|
||
{
|
||
ConvertAt2(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam2, pFormula.m_eType2, false, false, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_oParam.m_lParam, m_oParam.m_eType, pow3_16, ptValue, true, true, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftSin:
|
||
{
|
||
ConvertProd(pFormula.m_lParam2, pFormula.m_eType2, pow3_16, ptValue, m_oParam.m_lParam, m_oParam.m_eType, false, false, true, m_oGuidsRes);
|
||
ConvertSin(pFormula.m_lParam1, pFormula.m_eType1, m_lIndexDst-1, ptFormula, false, true, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftCos:
|
||
{
|
||
ConvertProd(pFormula.m_lParam2, pFormula.m_eType2, pow3_16, ptValue, m_oParam.m_lParam, m_oParam.m_eType, false, false, true, m_oGuidsRes);
|
||
ConvertCos(pFormula.m_lParam1, pFormula.m_eType1, m_lIndexDst-1, ptFormula, false, true, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftCosatan2:
|
||
{
|
||
ConvertCat2(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam2, pFormula.m_eType2, pFormula.m_lParam3, pFormula.m_eType3, false, false, false, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_oParam.m_lParam, m_oParam.m_eType, pow3_16, ptValue, true, true, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftSinatan2:
|
||
{
|
||
ConvertSat2(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam2, pFormula.m_eType2, pFormula.m_lParam3, pFormula.m_eType3, false, false, false, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_oParam.m_lParam, m_oParam.m_eType, pow3_16, ptValue, true, true, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftSqrt:
|
||
{
|
||
ConvertSqrt(pFormula.m_lParam1, pFormula.m_eType1, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftTan:
|
||
{
|
||
ConvertTag(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam2, pFormula.m_eType2, false, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftSumangle:
|
||
{
|
||
ConvertProd(pFormula.m_lParam1, pFormula.m_eType1, pow3_16, ptValue, m_oParam.m_lParam, m_oParam.m_eType, false, false, true, m_oGuidsRes);
|
||
ConvertProd(pow3_16, ptValue, pFormula.m_lParam2, pFormula.m_eType2, 1, ptValue, false, false, false, m_oGuidsRes);
|
||
ConvertProd(pow3_16, ptValue, pFormula.m_lParam3, pFormula.m_eType3, 1, ptValue, false, false, false, m_oGuidsRes);
|
||
ConvertSum(m_lIndexDst-3, ptFormula, m_lIndexDst-2, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_oParam.m_lParam, m_oParam.m_eType, pow3_16, ptValue, true, true, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
case ftEllipse:
|
||
{
|
||
ConvertProd(pFormula.m_lParam1, pFormula.m_eType1, pFormula.m_lParam1, pFormula.m_eType1, 1, ptValue , false, false, false, m_oGuidsRes);
|
||
ConvertProd(pFormula.m_lParam2, pFormula.m_eType2, pFormula.m_lParam2, pFormula.m_eType2, 1, ptValue , false, false, false, m_oGuidsRes);
|
||
ConvertProd(1, ptValue, m_lIndexDst-2, ptFormula, m_lIndexDst-1, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertSum(0, ptValue, 1, ptValue, m_lIndexDst-1, ptFormula, false, false, true, m_oGuidsRes);
|
||
ConvertSqrt(m_lIndexDst-1, ptFormula, true, m_oGuidsRes);
|
||
ConvertProd(pFormula.m_lParam3, pFormula.m_eType3, m_lIndexDst-1, ptFormula, 1, ptValue, false, true, false, m_oGuidsRes);
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertPath(std::wstring strPath, const ODRAW::CPath& oPath)
|
||
{
|
||
m_arParts.clear();
|
||
std::vector<std::wstring> oArray;
|
||
boost::algorithm::split(oArray, strPath, boost::algorithm::is_any_of(L"e"), boost::algorithm::token_compress_on);
|
||
|
||
for (size_t nIndex = 0; nIndex < oArray.size(); ++nIndex)
|
||
{
|
||
//if (oPath.m_arParts.size() <= nIndex)
|
||
// break;
|
||
|
||
if (oArray[nIndex].empty()) continue;
|
||
|
||
if (nIndex < (int)oPath.m_arParts.size() )
|
||
{
|
||
const CPartPath& oPart = oPath.m_arParts[nIndex];
|
||
|
||
m_lWidth = oPart.width;
|
||
m_lHeight = oPart.height;
|
||
|
||
m_lX = oPart.x;
|
||
m_lY = oPart.y;
|
||
}
|
||
|
||
bool bFill = false;
|
||
bool bStroke = false;
|
||
std::wstring strValue;
|
||
FromXML(oArray[nIndex], bFill, bStroke);
|
||
|
||
m_oPathRes.StartNode(L"a:path");
|
||
m_oPathRes.StartAttributes();
|
||
m_oPathRes.WriteAttribute(L"w", m_lWidth);
|
||
m_oPathRes.WriteAttribute(L"h", m_lHeight);
|
||
|
||
/*if (!bStroke)
|
||
m_oPathRes.WriteAttribute(L"stroke", (std::wstring)L"false");
|
||
if (!bFill)
|
||
m_oPathRes.WriteAttribute(L"fill", (std::wstring)L"none");*/
|
||
|
||
m_oPathRes.WriteAttribute(L"fill" , std::wstring(bFill ? L"norm" : L"none"));
|
||
m_oPathRes.WriteAttribute(L"stroke" , bStroke ? 1 : 0);
|
||
m_oPathRes.WriteAttribute(L"extrusionOk", 0);
|
||
|
||
m_oPathRes.EndAttributes();
|
||
|
||
for (size_t i = 0; i < m_arSlicesPath.size(); ++i)
|
||
{
|
||
CSlicePath& oSlice = m_arSlicesPath[i];
|
||
|
||
//m_lIndexDst-1 - номер последней записанной формулы
|
||
//m_lIndexSrc - номер последнего блока формул
|
||
//m_arIndexDst[n] - возвращает номер последней формулы в блоке n
|
||
//m_arIndexDst[m_lIndexSrc] = m_lIndexDst
|
||
|
||
switch (oSlice.m_eRuler)
|
||
{
|
||
case rtMoveTo:
|
||
{
|
||
ConvertSlice_MoveTo(oSlice);
|
||
break;
|
||
}
|
||
case rtRMoveTo:
|
||
{
|
||
ConvertSlice_RMoveTo(oSlice);
|
||
break;
|
||
}
|
||
case rtClose:
|
||
{
|
||
m_oPathRes.WriteString(L"<a:close/>");
|
||
break;
|
||
}
|
||
case rtLineTo:
|
||
{
|
||
ConvertSlice_LineTo(oSlice);
|
||
break;
|
||
}
|
||
case rtRLineTo:
|
||
{
|
||
ConvertSlice_RLineTo(oSlice);
|
||
break;
|
||
}
|
||
case rtArcTo:
|
||
case rtArc:
|
||
{
|
||
ConvertSlice_ArcTo(oSlice);
|
||
break;
|
||
}
|
||
case rtClockwiseArcTo:
|
||
case rtClockwiseArc:
|
||
{
|
||
ConvertSlice_ClockwiseTo(oSlice);
|
||
break;
|
||
}
|
||
case rtQuadrBesier:
|
||
{
|
||
ConvertSlice_QuadrBesier(oSlice);
|
||
break;
|
||
}
|
||
case rtCurveTo:
|
||
{
|
||
ConvertSlice_CurveTo(oSlice);
|
||
break;
|
||
}
|
||
case rtRCurveTo:
|
||
{
|
||
ConvertSlice_RCurveTo(oSlice);
|
||
break;
|
||
}
|
||
case rtAngleEllipse:
|
||
case rtAngleEllipseTo:
|
||
{
|
||
ConvertSlice_AngleEllipse(oSlice);
|
||
break;
|
||
}
|
||
case rtEllipticalQuadrX:
|
||
{
|
||
ConvertSlice_EllipticalQuadrX(oSlice);
|
||
break;
|
||
}
|
||
case rtEllipticalQuadrY:
|
||
{
|
||
ConvertSlice_EllipticalQuadrY(oSlice);
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
m_oPathRes.WriteString(L"</a:path>");
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertHandle(const std::vector<CHandle_>& arHandles, std::vector<long>& arAdj, PPTShapes::ShapeType oSType)
|
||
{
|
||
size_t nHandlesCount = arHandles.size();
|
||
if (oSType == 19) // в пптх не реализована функция изменения размера шейпа при изменении handle
|
||
nHandlesCount = 0;
|
||
for (size_t i = 0; i < nHandlesCount; ++i)
|
||
{
|
||
const CHandle_& pHnPoint = arHandles[i];
|
||
std::vector<std::wstring> arPos;
|
||
|
||
std::wstring sPos0 = L"";
|
||
std::wstring sPos1 = L"";
|
||
|
||
SHandle oHandle;
|
||
ParamType ptType;
|
||
|
||
if (pHnPoint.position != L"")
|
||
{
|
||
boost::algorithm::split(arPos, pHnPoint.position, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
|
||
sPos0 = arPos[0];
|
||
sPos1 = arPos[1];
|
||
|
||
oHandle.gdRef.x = GetHandleValue(sPos0, m_lWidth, ptType);
|
||
oHandle.gdRefType.x = ptType;
|
||
if (oHandle.gdRefType.x == ptAdjust)
|
||
oHandle.bRefExist.x = true;
|
||
|
||
oHandle.gdRef.y = GetHandleValue(sPos1, m_lWidth, ptType);
|
||
oHandle.gdRefType.y = ptType;
|
||
if (oHandle.gdRefType.y == ptAdjust)
|
||
oHandle.bRefExist.y = true;
|
||
|
||
if (pHnPoint.polar != L"")
|
||
{
|
||
//пришел полярный угол
|
||
oHandle.bRefExist.y = false;
|
||
|
||
oHandle.bRefPolarExist.y = true;
|
||
oHandle.bMinPolarExist.y = true;
|
||
|
||
boost::algorithm::split(arPos, pHnPoint.polar, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
|
||
|
||
oHandle.PolarCentre.x = GetHandleValue(arPos[0], m_lWidth, ptType);
|
||
oHandle.PolarCentreType.x = ptType;
|
||
|
||
oHandle.PolarCentre.y = GetHandleValue(arPos[1], m_lWidth, ptType);
|
||
oHandle.PolarCentreType.y = ptType;
|
||
|
||
if (oHandle.gdRefType.y == ptAdjust)
|
||
{
|
||
//угол должен храниться в pptx формате, поэтому придётся его везде заменить
|
||
std::wstring strNewFmla = GetValue2(m_lIndexDst, ptFormula, true);
|
||
std::wstring strOldFmla = GetValue2(oHandle.gdRef.y, oHandle.gdRefType.y, false);
|
||
LONG nIndex = m_lIndexDst;
|
||
|
||
// TODO: !!! тут медленный код.
|
||
m_oGuidsRes.ReplaceString(strOldFmla, strNewFmla);
|
||
|
||
m_lIndexSrc++;
|
||
|
||
// TODO: !!! тут медленный код.
|
||
NSBinPptxRW::CXmlWriter memGuidsRes;
|
||
ConvertProd(oHandle.gdRef.y, oHandle.gdRefType.y, m_oParam.m_lCoef, ptValue, pow3_16, ptValue, false, true, false, memGuidsRes);
|
||
m_oGuidsRes.m_oWriter.WriteBefore(memGuidsRes.m_oWriter);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
if (oHandle.gdRefType.y == ptAdjust)
|
||
{
|
||
double dScale = (double)pow3_16 / m_oParam.m_lCoef;
|
||
|
||
if (oHandle.gdRef.y >= (int)arAdj.size())
|
||
{
|
||
// дурацкий код. надо память перевыделить, а старую скопировать
|
||
// пока сделаю так, чтобы наверняка
|
||
int nNewSize = (int)oHandle.gdRef.y + 1;
|
||
while ((int)arAdj.size() < nNewSize)
|
||
arAdj.push_back(0);
|
||
}
|
||
|
||
int lVal = (int)(dScale * arAdj[oHandle.gdRef.y]);
|
||
arAdj[oHandle.gdRef.y] = lVal;
|
||
}
|
||
|
||
//рассчитаем координаты точки handle
|
||
|
||
m_lIndexSrc++;
|
||
ConvertCos(oHandle.gdRef.x, oHandle.gdRefType.x, oHandle.gdRef.y, oHandle.gdRefType.y, false, false, m_oGuidsRes);
|
||
ConvertSin(oHandle.gdRef.x, oHandle.gdRefType.x, oHandle.gdRef.y, oHandle.gdRefType.y, false, false, m_oGuidsRes);
|
||
ConvertSum(oHandle.PolarCentre.x, oHandle.PolarCentreType.x, m_lIndexDst-2, ptFormula, 0, ptValue, false, true, false, m_oGuidsRes);
|
||
ConvertSum(oHandle.PolarCentre.y, oHandle.PolarCentreType.y, m_lIndexDst-2, ptFormula, 0, ptValue, false, true, false, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
std::wstring strMem = L"&" + std::to_wstring(m_lIndexDst-2);
|
||
oHandle.Pos.x = GetHandlePos(strMem, L"w", m_lWidth);
|
||
oHandle.PosType.x = ptFormula;
|
||
|
||
strMem = L"&" + std::to_wstring(m_lIndexDst-2); //?????
|
||
oHandle.Pos.y = GetHandlePos(strMem, L"h", m_lHeight);
|
||
oHandle.PosType.y = ptFormula;
|
||
}
|
||
|
||
}
|
||
else//если пришли обычные координаты
|
||
{
|
||
if ((pHnPoint.xrange != L"" && oHandle.gdRefType.x != ptAdjust && oHandle.gdRefType.y == ptAdjust) ||
|
||
(pHnPoint.yrange != L"" && oHandle.gdRefType.x == ptAdjust && oHandle.gdRefType.y != ptAdjust))
|
||
{
|
||
oHandle.Pos.x = GetHandlePos(sPos1, L"w", m_lWidth);
|
||
oHandle.PosType.x = ptFormula;
|
||
|
||
oHandle.Pos.y = GetHandlePos(sPos0, L"h", m_lHeight);
|
||
oHandle.PosType.y = ptFormula;
|
||
}
|
||
else
|
||
{
|
||
oHandle.Pos.x = GetHandlePos(sPos0, L"w", m_lWidth);
|
||
oHandle.PosType.x = ptFormula;
|
||
|
||
oHandle.Pos.y = GetHandlePos(sPos1, L"h", m_lHeight);
|
||
oHandle.PosType.y = ptFormula;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pHnPoint.xrange != L"")
|
||
{
|
||
if ( oHandle.gdRefType.x != ptAdjust && oHandle.gdRefType.y == ptAdjust)
|
||
{
|
||
oHandle.gdRef.x = GetHandleValue(sPos1, m_lWidth, ptType);
|
||
oHandle.gdRefType.x = ptType;
|
||
oHandle.bRefExist.x = true;
|
||
|
||
oHandle.gdRef.y = GetHandleValue(sPos0, m_lHeight, ptType);
|
||
oHandle.gdRefType.y = ptType;
|
||
oHandle.bRefExist.y = false;
|
||
}
|
||
|
||
boost::algorithm::split(arPos, pHnPoint.xrange, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
|
||
|
||
oHandle.Min.x = GetHandleValue(arPos[0], m_lWidth, ptType);
|
||
oHandle.MinType.x = ptType;
|
||
if ( oHandle.bRefExist.x)
|
||
oHandle.bMinExist.x = true;
|
||
|
||
oHandle.Max.x = GetHandleValue(arPos[1], m_lWidth, ptType);
|
||
oHandle.MaxType.x = ptType;
|
||
if ( oHandle.bRefExist.x)
|
||
oHandle.bMaxExist.x = true;
|
||
}
|
||
|
||
if (pHnPoint.yrange != L"")
|
||
{
|
||
if (oHandle.gdRefType.x == ptAdjust && oHandle.gdRefType.y != ptAdjust)
|
||
{
|
||
oHandle.gdRef.x = GetHandleValue(sPos1, m_lWidth, ptType);
|
||
oHandle.gdRefType.x = ptType;
|
||
oHandle.bRefExist.x = false;
|
||
|
||
oHandle.gdRef.y = GetHandleValue(sPos0, m_lHeight, ptType);
|
||
oHandle.gdRefType.y = ptType;
|
||
oHandle.bRefExist.y = true;
|
||
}
|
||
boost::algorithm::split(arPos, pHnPoint.yrange, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
|
||
|
||
oHandle.Min.y = GetHandleValue(arPos[0], m_lHeight, ptType);
|
||
oHandle.MinType.y = ptType;
|
||
if ( oHandle.bRefExist.y )
|
||
oHandle.bMinExist.y = true;
|
||
|
||
oHandle.Max.y = GetHandleValue(arPos[1], m_lHeight, ptType);
|
||
oHandle.MaxType.y = ptType;
|
||
if ( oHandle.bRefExist.y )
|
||
oHandle.bMaxExist.y = true;
|
||
}
|
||
|
||
if (pHnPoint.radiusrange != L"")
|
||
{
|
||
boost::algorithm::split(arPos, pHnPoint.radiusrange, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
|
||
|
||
oHandle.Min.x = GetHandleValue(arPos[0], m_lHeight, ptType);
|
||
oHandle.MinType.x = ptType;
|
||
oHandle.bMinPolarExist.x = true;
|
||
|
||
oHandle.Max.x = GetHandleValue(arPos[1], m_lHeight, ptType);
|
||
oHandle.MaxType.x = ptType;
|
||
oHandle.bMinPolarExist.y = true;
|
||
|
||
if (oHandle.gdRefType.x == ptAdjust)
|
||
{
|
||
oHandle.bRefPolarExist.x = true;
|
||
oHandle.bRefExist.x = false;
|
||
}
|
||
}
|
||
|
||
CreateHandle(oHandle);
|
||
|
||
}
|
||
ConvertAdj(arAdj);
|
||
}
|
||
void CFormulaConverter::SetTextRectDefault()
|
||
{
|
||
m_lIndexSrc++;
|
||
|
||
ConvertProd(L"w", L"0", m_lWidth, m_oGuidsRes);
|
||
ConvertProd(L"h", L"0", m_lHeight, m_oGuidsRes);
|
||
ConvertProd(L"w", std::to_wstring(m_lWidth), m_lWidth, m_oGuidsRes);
|
||
ConvertProd(L"h", std::to_wstring(m_lHeight), m_lHeight, m_oGuidsRes);
|
||
|
||
m_arIndexDst.push_back(m_lIndexDst);
|
||
|
||
m_oTextRect.WriteString(L"<a:rect l=\"");
|
||
GetValue(m_lIndexDst - 4, ptFormula, true, m_oTextRect);
|
||
m_oTextRect.WriteString(L"\" t=\"");
|
||
GetValue(m_lIndexDst - 3, ptFormula, true, m_oTextRect);
|
||
m_oTextRect.WriteString(L"\" r=\"");
|
||
GetValue(m_lIndexDst - 2, ptFormula, true, m_oTextRect);
|
||
m_oTextRect.WriteString(L"\" b=\"");
|
||
GetValue(m_lIndexDst - 1, ptFormula, true, m_oTextRect);
|
||
m_oTextRect.WriteString(L"\" />");
|
||
}
|
||
void CFormulaConverter::ConvertTextRect ( std::wstring strRect)
|
||
{
|
||
if (strRect.empty())
|
||
return;
|
||
|
||
std::vector<std::wstring> arBorder;
|
||
boost::algorithm::split(arBorder, strRect, boost::algorithm::is_any_of(L","), boost::algorithm::token_compress_on);
|
||
|
||
m_lIndexSrc++;
|
||
if (arBorder.size() > 0 && !arBorder[0].empty())
|
||
ConvertProd(L"w", arBorder[0], m_lWidth, m_oGuidsRes);
|
||
else
|
||
ConvertProd(L"w", L"0", m_lWidth, m_oGuidsRes);
|
||
|
||
if (arBorder.size() > 1 && !arBorder[1].empty())
|
||
ConvertProd(L"h", arBorder[1], m_lHeight, m_oGuidsRes);
|
||
else
|
||
ConvertProd(L"h", L"0", m_lHeight, m_oGuidsRes);
|
||
|
||
if (arBorder.size() > 2 && !arBorder[2].empty())
|
||
ConvertProd(L"w", arBorder[2], m_lWidth, m_oGuidsRes);
|
||
else
|
||
ConvertProd(L"w", std::to_wstring(m_lWidth), m_lWidth, m_oGuidsRes);
|
||
|
||
if (arBorder.size() > 3 && !arBorder[3].empty())
|
||
ConvertProd(L"h", arBorder[3], m_lHeight, m_oGuidsRes);
|
||
else
|
||
ConvertProd(L"h", std::to_wstring(m_lHeight), m_lHeight, m_oGuidsRes);
|
||
|
||
m_arIndexDst.push_back(m_lIndexDst);
|
||
|
||
m_oTextRect.WriteString(L"<a:rect l=\"");
|
||
GetValue(m_lIndexDst-4, ptFormula, true, m_oTextRect);
|
||
m_oTextRect.WriteString(L"\" t=\"");
|
||
GetValue(m_lIndexDst-3, ptFormula, true, m_oTextRect);
|
||
m_oTextRect.WriteString(L"\" r=\"");
|
||
GetValue(m_lIndexDst-2, ptFormula, true, m_oTextRect);
|
||
m_oTextRect.WriteString(L"\" b=\"");
|
||
GetValue(m_lIndexDst-1, ptFormula, true, m_oTextRect);
|
||
m_oTextRect.WriteString(L"\" />");
|
||
}
|
||
void CFormulaConverter::GetValue(const LONG& lParam, const ParamType& eParamType, const bool& bExtShape, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
oWriter.m_oWriter.AddSize(15);
|
||
switch (eParamType)
|
||
{
|
||
case ptFormula:
|
||
if (bExtShape || lParam < (int)m_arIndexDst.size())
|
||
{
|
||
oWriter.m_oWriter.AddCharNoCheck((WCHAR)'g');
|
||
oWriter.m_oWriter.AddCharNoCheck((WCHAR)'d');
|
||
|
||
if (bExtShape)
|
||
oWriter.m_oWriter.AddIntNoCheck(lParam);
|
||
else
|
||
oWriter.m_oWriter.AddIntNoCheck(m_arIndexDst[lParam]);
|
||
}
|
||
break;
|
||
case ptAdjust:
|
||
{
|
||
oWriter.m_oWriter.AddCharNoCheck((WCHAR)'a');
|
||
oWriter.m_oWriter.AddCharNoCheck((WCHAR)'d');
|
||
oWriter.m_oWriter.AddCharNoCheck((WCHAR)'j');
|
||
oWriter.m_oWriter.AddIntNoCheck(lParam);
|
||
|
||
if (lParam > m_lMaxAdjUse)
|
||
m_lMaxAdjUse = lParam;
|
||
|
||
break;
|
||
}
|
||
case ptValue:
|
||
{
|
||
oWriter.m_oWriter.AddIntNoCheck(lParam);
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
std::wstring CFormulaConverter::GetValue2(const LONG& lParam, const ParamType& eParamType, const bool& bExtShape)
|
||
{
|
||
std::wstring strValue;
|
||
switch (eParamType)
|
||
{
|
||
case ptFormula:
|
||
{
|
||
if (bExtShape)
|
||
strValue = std::to_wstring(lParam);
|
||
else
|
||
strValue = std::to_wstring(m_arIndexDst[lParam]);
|
||
strValue = L"gd" + strValue;
|
||
break;
|
||
}
|
||
case ptAdjust:
|
||
{
|
||
strValue = std::to_wstring(lParam);
|
||
strValue = L"adj" + strValue;
|
||
break;
|
||
}
|
||
case ptValue:
|
||
{
|
||
strValue = std::to_wstring(lParam);
|
||
strValue = strValue;
|
||
break;
|
||
}
|
||
default:
|
||
break;
|
||
}
|
||
return strValue;
|
||
}
|
||
|
||
void CFormulaConverter::ConvertVal(const LONG& lParam1, const ParamType& eType1, const bool& bExtShape1, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_1(val)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertSum(const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const LONG& lParam3, const ParamType& eType3, const bool& bExtShape1, const bool& bExtShape2, const bool& bExtShape3, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_3(sum)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertProd(const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const LONG& lParam3, const ParamType& eType3, const bool& bExtShape1, const bool& bExtShape2, const bool& bExtShape3, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_3(prod)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertAbs(const LONG& lParam1, const ParamType& eType1, const bool& bExtShape1, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_1(abs)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertMin(const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const bool& bExtShape1, const bool& bExtShape2, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_2(min)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertMax (const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const bool& bExtShape1, const bool& bExtShape2, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_2(max)
|
||
}
|
||
void CFormulaConverter::ConvertIf(const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const LONG& lParam3, const ParamType& eType3, const bool& bExtShape1, const bool& bExtShape2, const bool& bExtShape3, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_3(_if)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertSqrt(const LONG& lParam1, const ParamType& eType1, const bool& bExtShape1, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_1(sqrt)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertAt2 (const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const bool& bExtShape1, const bool& bExtShape2, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_2(at2)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertSin (const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const bool& bExtShape1, const bool& bExtShape2, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_2(sin)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertCos (const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const bool& bExtShape1, const bool& bExtShape2, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_2(cos)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertCat2(const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const LONG& lParam3, const ParamType& eType3, const bool& bExtShape1, const bool& bExtShape2, const bool& bExtShape3, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_3(cat2)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertSat2(const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const LONG& lParam3, const ParamType& eType3, const bool& bExtShape1, const bool& bExtShape2, const bool& bExtShape3, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_3(sat2)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertMod(const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const LONG& lParam3, const ParamType& eType3, const bool& bExtShape1, const bool& bExtShape2, const bool& bExtShape3, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_3(mod)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertTag (const LONG& lParam1, const ParamType& eType1, const LONG& lParam2, const ParamType& eType2,
|
||
const bool& bExtShape1, const bool& bExtShape2, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
GUIDE_PARAM_2(tag)
|
||
}
|
||
|
||
void CFormulaConverter::ConvertProd(const std::wstring& strParam1, const std::wstring& strParam2, const LONG& lParam3, NSBinPptxRW::CXmlWriter& oWriter)
|
||
{
|
||
oWriter.m_oWriter.AddSize(g_guide_max_len);
|
||
oWriter.m_oWriter.WriteStringNoSafe(g_guide_string1, g_guide_string1_len);
|
||
oWriter.m_oWriter.AddIntNoCheck(m_lIndexDst);
|
||
oWriter.m_oWriter.WriteStringNoSafe(g_guide_string_prod, g_guide_string_prod_len);
|
||
oWriter.WriteString(strParam1);
|
||
oWriter.m_oWriter.AddSpaceNoCheck();
|
||
|
||
if ('#' == strParam2[0])
|
||
{
|
||
LONG lRes = (LONG)XmlUtils::GetInteger(strParam2.substr(1));
|
||
GetValue(lRes, ptAdjust, false, oWriter);
|
||
}
|
||
else if ('@' == strParam2[0])
|
||
{
|
||
LONG lRes = (LONG)XmlUtils::GetInteger(strParam2.substr(1));
|
||
GetValue(lRes, ptFormula, false, oWriter);
|
||
}
|
||
else
|
||
oWriter.WriteString(strParam2);
|
||
|
||
oWriter.m_oWriter.AddSpaceNoCheck();
|
||
GetValue(lParam3, ptValue, false, oWriter);
|
||
|
||
++m_lIndexDst;
|
||
oWriter.m_oWriter.WriteStringNoSafe(g_guide_string2, g_guide_string2_len);
|
||
}
|
||
|
||
void CFormulaConverter::FromXML(std::wstring strPath, bool &m_bFill, bool &m_bStroke)
|
||
{
|
||
m_arSlicesPath.clear();
|
||
NSStringUtils::CheckPathOn_Fill_Stroke(strPath, m_bFill, m_bStroke);
|
||
std::vector<std::wstring> oArray;
|
||
|
||
NSStringUtils::ParsePath2(strPath, &oArray);
|
||
|
||
ParamType eParamType = ptValue;
|
||
RulesType eRuler = rtEnd;
|
||
LONG lValue;
|
||
bool bRes = true;
|
||
|
||
for (size_t nIndex = 0; nIndex < oArray.size(); ++nIndex)
|
||
{
|
||
std::wstring str = oArray[nIndex];
|
||
lValue = NSGuidesVML::GetValue(oArray[nIndex], eParamType, bRes);
|
||
if (bRes)
|
||
{
|
||
if (0 != m_arSlicesPath.size())
|
||
{
|
||
if ( lValue >= 0x7fffff00 || lValue <= -0x7fffff00)
|
||
{
|
||
lValue = 0; //process(2).ppt - todooo разобраться что за хрень это ваще приплыла
|
||
}
|
||
|
||
m_arSlicesPath[m_arSlicesPath.size() - 1].AddParam(lValue, eParamType);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
eRuler = GetRuler(oArray[nIndex], bRes);
|
||
if (bRes)
|
||
{
|
||
if (rtNoFill == eRuler)
|
||
{
|
||
m_bFill = false;
|
||
}
|
||
else if (rtNoStroke == eRuler)
|
||
{
|
||
m_bStroke = false;
|
||
}
|
||
else
|
||
{
|
||
CSlicePath oSlice(eRuler, m_lX, m_lY);
|
||
|
||
m_arSlicesPath.push_back(oSlice);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
void CFormulaConverter::CreateHandle ( SHandle oHnd )
|
||
{
|
||
std::wstring strRes = L"";
|
||
if (oHnd.bRefPolarExist.x || oHnd.bRefPolarExist.y)
|
||
m_oHandleRes.WriteString(L"<a:ahPolar");
|
||
else if (oHnd.bRefExist.x || oHnd.bRefExist.y)
|
||
m_oHandleRes.WriteString(L"<a:ahXY");
|
||
else
|
||
return;
|
||
|
||
if (oHnd.bRefExist.x)
|
||
{
|
||
m_oHandleRes.WriteString(L" gdRefX=\"");
|
||
GetValue(oHnd.gdRef.x, oHnd.gdRefType.x, false, m_oHandleRes);
|
||
m_oHandleRes.WriteString(L"\"");
|
||
}
|
||
if (oHnd.bRefExist.y)
|
||
{
|
||
m_oHandleRes.WriteString(L" gdRefY=\"");
|
||
GetValue(oHnd.gdRef.y, oHnd.gdRefType.y, false, m_oHandleRes);
|
||
m_oHandleRes.WriteString(L"\"");
|
||
}
|
||
if (oHnd.bRefPolarExist.x)
|
||
{
|
||
m_oHandleRes.WriteString(L" gdRefR=\"");
|
||
GetValue(oHnd.gdRef.x, oHnd.gdRefType.x, false, m_oHandleRes);
|
||
m_oHandleRes.WriteString(L"\"");
|
||
}
|
||
if (oHnd.bRefPolarExist.y)
|
||
{
|
||
m_oHandleRes.WriteString(L" gdRefAng=\"");
|
||
GetValue(oHnd.gdRef.y, oHnd.gdRefType.y, true, m_oHandleRes);
|
||
m_oHandleRes.WriteString(L"\"");
|
||
}
|
||
|
||
//min max 1го параметра
|
||
if (oHnd.bMinExist.x)
|
||
{
|
||
m_oHandleRes.WriteString(L" minX=\"");
|
||
GetValue(oHnd.Min.x, oHnd.MinType.x, false, m_oHandleRes);
|
||
m_oHandleRes.WriteString(L"\" maxX=\"");
|
||
GetValue(oHnd.Max.x, oHnd.MaxType.x, false, m_oHandleRes);
|
||
m_oHandleRes.WriteString(L"\"");
|
||
}
|
||
else if (oHnd.bRefExist.x)
|
||
{
|
||
m_oHandleRes.WriteString(L" minX=\"-21474836\" maxX=\"21474836\"");
|
||
}
|
||
|
||
if (oHnd.bMinPolarExist.x)
|
||
{
|
||
m_oHandleRes.WriteString(L" minR=\"");
|
||
GetValue(oHnd.Min.x, oHnd.MinType.x, false, m_oHandleRes);
|
||
m_oHandleRes.WriteString(L"\" maxR=\"");
|
||
GetValue(oHnd.Max.x, oHnd.MaxType.x, false, m_oHandleRes);
|
||
m_oHandleRes.WriteString(L"\"");
|
||
}
|
||
|
||
//min max 2го параметра
|
||
if (oHnd.bMinExist.y)
|
||
{
|
||
m_oHandleRes.WriteString(L" minY=\"");
|
||
GetValue(oHnd.Min.y, oHnd.MinType.y, false, m_oHandleRes);
|
||
m_oHandleRes.WriteString(L"\" maxY=\"");
|
||
GetValue(oHnd.Max.y, oHnd.MaxType.y, false, m_oHandleRes);
|
||
m_oHandleRes.WriteString(L"\"");
|
||
}
|
||
else if (oHnd.bRefExist.y)
|
||
{
|
||
m_oHandleRes.WriteString(L" minY=\"-21474836\" maxY=\"21474836\"");
|
||
}
|
||
|
||
if (oHnd.bMinPolarExist.y)
|
||
{
|
||
m_oHandleRes.WriteString(L" minAng=\"0\" maxAng=\"21600000\"");
|
||
}
|
||
|
||
m_oHandleRes.WriteString(L"><a:pos x=\"");
|
||
GetValue(oHnd.Pos.x, oHnd.PosType.x, true, m_oHandleRes);
|
||
m_oHandleRes.WriteString(L"\" y=\"");
|
||
GetValue(oHnd.Pos.y, oHnd.PosType.y, true, m_oHandleRes);
|
||
|
||
if (oHnd.bRefPolarExist.x || oHnd.bRefPolarExist.y)
|
||
m_oHandleRes.WriteString(L"\"/></a:ahPolar>");
|
||
else if (oHnd.bRefExist.x || oHnd.bRefExist.y)
|
||
m_oHandleRes.WriteString(L"\"/></a:ahXY>");
|
||
}
|
||
|
||
LONG CFormulaConverter::GetHandlePos(const std::wstring& strParam, const std::wstring& strBase, LONG lSize)
|
||
{
|
||
LONG lRes;
|
||
std::wstring strSize = L" " + std::to_wstring(lSize);
|
||
std::wstring strIndex;
|
||
|
||
if ('#' == strParam[0])
|
||
{
|
||
lRes = (LONG)XmlUtils::GetInteger(strParam.substr(1));
|
||
strFrmla = GetValue2(lRes, ptAdjust, false) + strSize;
|
||
}
|
||
else if ('&' == strParam[0])
|
||
{
|
||
lRes = (LONG)XmlUtils::GetInteger(strParam.substr(1));
|
||
strFrmla = GetValue2(lRes, ptFormula, true) + strSize;
|
||
}
|
||
else if ('@' == strParam[0])
|
||
{
|
||
lRes = (LONG)XmlUtils::GetInteger(strParam.substr(1));
|
||
strFrmla = GetValue2(lRes, ptFormula, false) + strSize;
|
||
}
|
||
else if (!NSStringUtils::IsNumber(strParam))
|
||
{
|
||
if (L"center" == strParam)
|
||
strFrmla = L"1 2";
|
||
else if (L"topLeft" == strParam)
|
||
strFrmla = L"0 1";
|
||
else if ( L"bottomRight" == strParam)
|
||
strFrmla = L"1 1";
|
||
}
|
||
else
|
||
{
|
||
lRes = (LONG)XmlUtils::GetInteger(strParam);
|
||
strFrmla = GetValue2(lRes, ptValue, false) + strSize;
|
||
}
|
||
|
||
m_lIndexSrc++;
|
||
m_arIndexDst.push_back(m_lIndexDst);
|
||
strIndex = std::to_wstring(m_lIndexDst);
|
||
|
||
m_oGuidsRes.WriteString(L"<a:gd name=\"gd");
|
||
m_oGuidsRes.WriteString(strIndex);
|
||
m_oGuidsRes.WriteString(L"\" fmla=\"*/ ");
|
||
m_oGuidsRes.WriteString(strBase);
|
||
m_oGuidsRes.WriteString(L" ");
|
||
m_oGuidsRes.WriteString(strFrmla);
|
||
m_oGuidsRes.WriteString(L"\"/>");
|
||
|
||
m_lIndexDst++;
|
||
|
||
return m_lIndexDst-1;
|
||
}
|
||
LONG CFormulaConverter::GetHandleValue(const std::wstring& strParam, const LONG& lVal, ParamType& ptType)
|
||
{
|
||
ptType = ptValue;
|
||
if ('#' == strParam[0])
|
||
{
|
||
ptType = ptAdjust;
|
||
return (LONG)XmlUtils::GetInteger(strParam.substr(1));
|
||
}
|
||
else if ('@' == strParam[0])
|
||
{
|
||
ptType = ptFormula;
|
||
return (LONG)XmlUtils::GetInteger(strParam.substr(1));
|
||
}
|
||
else if (!NSStringUtils::IsNumber(strParam))
|
||
{
|
||
if (L"center" == strParam)
|
||
return lVal/2;
|
||
else if (L"bottomRight" == strParam)//Demo-Hayden-Management-v2.docx
|
||
return lVal;
|
||
else
|
||
return 0; //???
|
||
//todooo прописать все варианты правильно
|
||
}
|
||
else
|
||
{
|
||
ptType = ptValue;
|
||
return (LONG)XmlUtils::GetInteger(strParam);
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertQuadrX(Aggplus::POINT pPoint, SPointType pPointType)
|
||
{
|
||
LONG nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
|
||
ConvertSum(pPoint.x, pPointType.x, 0, ptValue, nIndex-1, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertSum(pPoint.y, pPointType.y, 0, ptValue, nIndex, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-2, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-4, ptFormula, 16200000, ptValue, 5400000, ptValue, true, true, true, m_oGuidsRes); //stAng
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 5400000, ptValue, -5400000, ptValue, true, true, true, m_oGuidsRes); //swAng
|
||
ConvertProd(m_lIndexDst-7, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-7, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-9, ptFormula, m_lIndexDst-9, ptFormula, m_lIndexDst-2, ptFormula, true, true, true, m_oGuidsRes);//wR
|
||
ConvertIf(m_lIndexDst-9, ptFormula, m_lIndexDst-9, ptFormula, m_lIndexDst-2, ptFormula, true, true, true, m_oGuidsRes);//hR
|
||
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_oPathRes.WriteString(L"<a:arcTo wR=\"");
|
||
GetValue(nIndex-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" hR=\"");
|
||
GetValue(nIndex, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" stAng=\"");
|
||
GetValue(nIndex-5, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" swAng=\"");
|
||
GetValue(nIndex-4, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" />");
|
||
|
||
m_lIndexSrc++;
|
||
ConvertVal(pPoint.x, pPointType.x, false, m_oGuidsRes);
|
||
ConvertVal(pPoint.y, pPointType.y, false, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
return;
|
||
}
|
||
|
||
void CFormulaConverter::ConvertQuadrY(Aggplus::POINT pPoint, SPointType pPointType)
|
||
{
|
||
LONG nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
|
||
ConvertSum(pPoint.x, pPointType.x, 0, ptValue, nIndex-1, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertSum(pPoint.y, pPointType.y, 0, ptValue, nIndex, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-2, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-5, ptFormula, 10800000, ptValue, 0, ptValue, true, true, true, m_oGuidsRes); //stAng
|
||
ConvertIf(m_lIndexDst-2, ptFormula, -5400000, ptValue, 5400000, ptValue, true, true, true, m_oGuidsRes); //swAng
|
||
ConvertProd(m_lIndexDst-7, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-7, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-9, ptFormula, m_lIndexDst-9, ptFormula, m_lIndexDst-2, ptFormula, true, true, true, m_oGuidsRes);//wR
|
||
ConvertIf(m_lIndexDst-9, ptFormula, m_lIndexDst-9, ptFormula, m_lIndexDst-2, ptFormula, true, true, true, m_oGuidsRes);//hR
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_oPathRes.WriteString(L"<a:arcTo wR=\"");
|
||
GetValue(nIndex-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" hR=\"");
|
||
GetValue(nIndex, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" stAng=\"");
|
||
GetValue(nIndex-5, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" swAng=\"");
|
||
GetValue(nIndex-4, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" />");
|
||
|
||
m_lIndexSrc++;
|
||
ConvertVal(pPoint.x, pPointType.x, false, m_oGuidsRes);
|
||
ConvertVal(pPoint.y, pPointType.y, false, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
return;
|
||
}
|
||
void CFormulaConverter::ConvertSlice_MoveTo(const CSlicePath& oSlice)
|
||
{
|
||
for (size_t j = 0; j < oSlice.m_arPoints.size(); ++j)
|
||
{
|
||
pCurPoint = oSlice.m_arPoints[j];
|
||
pCurPointType = oSlice.m_arPointsType[j];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertVal(pCurPoint.x, pCurPointType.x, false, m_oGuidsRes);
|
||
ConvertVal(pCurPoint.y, pCurPointType.y, false, m_oGuidsRes);
|
||
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
m_oPathRes.WriteString(L"<a:moveTo><a:pt x=\"");
|
||
GetValue(m_lIndexDst-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(m_lIndexDst-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:moveTo>");
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertSlice_RMoveTo(const CSlicePath& oSlice)
|
||
{
|
||
for (size_t j = 0; j < oSlice.m_arPoints.size(); j++)
|
||
{
|
||
pCurPoint = oSlice.m_arPoints[j];
|
||
pCurPointType = oSlice.m_arPointsType[j];
|
||
|
||
m_lIndexSrc ++;
|
||
ConvertSum(m_lIndexDst-2, ptFormula, pCurPoint.x, pCurPointType.x, 0, ptValue, true, false, true, m_oGuidsRes);
|
||
ConvertSum(m_lIndexDst-2, ptFormula, pCurPoint.y, pCurPointType.y, 0, ptValue, true, false, true, m_oGuidsRes);
|
||
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
m_oPathRes.WriteString(L"<a:moveTo><a:pt x=\"");
|
||
GetValue(m_lIndexDst-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(m_lIndexDst-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:moveTo>");
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertSlice_LineTo(const CSlicePath& oSlice)
|
||
{
|
||
for (size_t j = 0; j < oSlice.m_arPoints.size(); j++)
|
||
{
|
||
pCurPoint = oSlice.m_arPoints[j];
|
||
pCurPointType = oSlice.m_arPointsType[j];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertVal(pCurPoint.x, pCurPointType.x, false, m_oGuidsRes);
|
||
ConvertVal(pCurPoint.y, pCurPointType.y, false, m_oGuidsRes);
|
||
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
m_oPathRes.WriteString(L"<a:lnTo><a:pt x=\"");
|
||
GetValue(m_lIndexDst-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(m_lIndexDst-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:lnTo>");
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertSlice_RLineTo(const CSlicePath& oSlice)
|
||
{
|
||
for (size_t j = 0; j < oSlice.m_arPoints.size(); j++)
|
||
{
|
||
pCurPoint = oSlice.m_arPoints[j];
|
||
pCurPointType = oSlice.m_arPointsType[j];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertSum(m_lIndexDst-2, ptFormula, pCurPoint.x, pCurPointType.x, 0, ptValue, true, false, true, m_oGuidsRes);
|
||
ConvertSum(m_lIndexDst-2, ptFormula, pCurPoint.y, pCurPointType.y, 0, ptValue, true, false, true, m_oGuidsRes);
|
||
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
m_oPathRes.WriteString(L"<a:lnTo><a:pt x=\"");
|
||
GetValue(m_lIndexDst-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(m_lIndexDst-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:lnTo>");
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertSlice_ArcTo(const CSlicePath& oSlice)
|
||
{
|
||
LONG nIndex = 0;
|
||
LONG nIndex1 = 0;
|
||
LONG nIndex2 = 0;
|
||
|
||
size_t nSlicePointsCount = oSlice.m_arPoints.size();
|
||
size_t nSlicePointStep = 4;
|
||
for (size_t j = 0; j < nSlicePointsCount; j+=nSlicePointStep)
|
||
{
|
||
if ((j + nSlicePointStep) > nSlicePointsCount)
|
||
break;
|
||
|
||
pCurPoint = oSlice.m_arPoints[j];
|
||
pCurPointType = oSlice.m_arPointsType[j];
|
||
pCurPoint1 = oSlice.m_arPoints[j+1];
|
||
pCurPointType1 = oSlice.m_arPointsType[j+1];
|
||
|
||
//длина сторон
|
||
m_lIndexSrc++;
|
||
ConvertSum(pCurPoint1.x, pCurPointType1.x, 0, ptValue, pCurPoint.x, pCurPointType.x, false, true, false, m_oGuidsRes);
|
||
ConvertSum(pCurPoint1.y, pCurPointType1.y, 0, ptValue, pCurPoint.y, pCurPointType.y, false, true, false, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//координаты центра
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex-1, ptFormula, 1, ptValue, 2, ptValue, true, true, true, m_oGuidsRes); //a=wR
|
||
ConvertProd(nIndex, ptFormula, 1, ptValue, 2, ptValue, true, true, true, m_oGuidsRes); //b=hR
|
||
|
||
ConvertSum(pCurPoint.x, pCurPointType.x, m_lIndexDst-2, ptFormula, 0, ptValue, false, true, true, m_oGuidsRes);
|
||
ConvertSum(pCurPoint.y, pCurPointType.y, m_lIndexDst-2, ptFormula, 0, ptValue, false, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//рассчет для stAng---------------------------
|
||
//расположение текущей точки по четвертям 3 4
|
||
// 2 1
|
||
|
||
pCurPoint = oSlice.m_arPoints[j+2];
|
||
pCurPointType = oSlice.m_arPointsType[j+2];
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertSum(pCurPoint.x, pCurPointType.x, 0, ptValue, nIndex-1, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertSum(pCurPoint.y, pCurPointType.y, 0, ptValue, nIndex, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//угол между Ох и радиус-вектором к точке
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex-2, ptFormula, 1, ptValue, nIndex-3, ptFormula, true, true, true, m_oGuidsRes);
|
||
ConvertAt2(1, ptValue, m_lIndexDst-1, ptFormula, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//радиус к точке
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-2];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertCos(1, ptValue, nIndex, ptFormula, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-2, ptFormula, nIndex1-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//(b*cos(u))^2
|
||
|
||
ConvertSin(1, ptValue, nIndex, ptFormula, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-3, ptFormula, nIndex1-3, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//(a*sin(u))^2
|
||
|
||
ConvertSum(m_lIndexDst-1, ptFormula, m_lIndexDst-5, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSqrt(m_lIndexDst-1, ptFormula, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-3, ptFormula, nIndex1-2, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//r
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//если точка во 2 и 3 четвертях, прибавляем по 180grad
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertIf(nIndex-3, ptFormula, 0, ptValue, 10800000, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//угол до 1 точки (stAngle)
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];//угол между ох и радиусом
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-3];//расположение точки по четвертям
|
||
nIndex2 = m_arIndexDst[m_lIndexSrc];//прибавка 180 или 0
|
||
|
||
m_lIndexSrc ++;
|
||
ConvertProd(nIndex1-1, ptFormula, nIndex1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//знак у угла
|
||
ConvertProd(nIndex, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(nIndex, ptFormula, nIndex, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//угол всегда положительный
|
||
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-3, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//u с нужным знаком
|
||
|
||
ConvertSum(m_lIndexDst-1, ptFormula, nIndex2, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//координаты стартовой точки
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-4];
|
||
nIndex2 = m_arIndexDst[m_lIndexSrc-5];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex, ptFormula, nIndex-10, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//r*cos(a)
|
||
ConvertProd(nIndex1-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSum(nIndex2-1, ptFormula, m_lIndexDst-1, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes); //x
|
||
|
||
ConvertProd(nIndex-6, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(nIndex-6, ptFormula, nIndex-6, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//sin теперь всегда>0
|
||
|
||
ConvertProd(nIndex, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//r*sin
|
||
ConvertProd(nIndex1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSum(nIndex2, ptFormula, m_lIndexDst-1, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);//y
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//рассчет для swAng---------------------------
|
||
//расположение текущей точки по четвертям 3 4
|
||
// 2 1
|
||
|
||
pCurPoint = oSlice.m_arPoints[j+3];
|
||
pCurPointType = oSlice.m_arPointsType[j+3];
|
||
|
||
nIndex = m_arIndexDst[m_lIndexSrc-6];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertSum(pCurPoint.x, pCurPointType.x, 0, ptValue, nIndex-1, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertSum(pCurPoint.y, pCurPointType.y, 0, ptValue, nIndex, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//угол между Ох и радиус-вектором к точке
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex-2, ptFormula, 1, ptValue, nIndex-3, ptFormula, true, true, true, m_oGuidsRes);
|
||
ConvertAt2(1, ptValue, m_lIndexDst-1, ptFormula, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//радиус к точке
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-8];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertCos(1, ptValue, nIndex, ptFormula, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-2, ptFormula, nIndex1-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
|
||
ConvertSin(1, ptValue, nIndex, ptFormula, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-3, ptFormula, nIndex1-3, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
|
||
ConvertSum(m_lIndexDst-1, ptFormula, m_lIndexDst-5, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSqrt(m_lIndexDst-1, ptFormula, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-3, ptFormula, nIndex1-2, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//если точка во 2 и 3 четвертях, прибавляем по 180grad
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertIf(nIndex-3, ptFormula, 0, ptValue, 10800000, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//угол до 2 точки
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];//угол между ох и радиусом
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-3];//расположение точки по четвертям
|
||
nIndex2 = m_arIndexDst[m_lIndexSrc];//прибавка 180 или 0
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex1-1, ptFormula, nIndex1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//знак у угла
|
||
ConvertProd(nIndex, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(nIndex, ptFormula, nIndex, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//угол всегда положительный
|
||
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-3, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//u с нужным знаком
|
||
|
||
ConvertSum(m_lIndexDst-1, ptFormula, nIndex2, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//координаты конечной точки
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-4];
|
||
nIndex2 = m_arIndexDst[m_lIndexSrc-11];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex, ptFormula, nIndex-10, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//r*cos(a)
|
||
ConvertProd(nIndex1-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSum(nIndex2-1, ptFormula, m_lIndexDst-1, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);//x
|
||
|
||
ConvertProd(nIndex-6, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(nIndex-6, ptFormula, nIndex-6, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//sin теперь всегда>0
|
||
|
||
ConvertProd(nIndex, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//r*sin(a)
|
||
ConvertProd(nIndex1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSum(nIndex2, ptFormula, m_lIndexDst-1, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);//y
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//swAngle
|
||
nIndex = m_arIndexDst[m_lIndexSrc-1]; //2 угол
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-7]; //1 угол
|
||
|
||
m_lIndexSrc++;
|
||
ConvertSum(nIndex1, ptFormula, 0, ptValue, nIndex, ptFormula, true, true, true, m_oGuidsRes); // (1)-(2), если отрицательный то берем его, иначе пересчитываем
|
||
ConvertProd(m_lIndexDst-1, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
|
||
ConvertSum(nIndex1, ptFormula, 21600000, ptValue, nIndex, ptFormula, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes); // -1*((1)+360-(2))
|
||
|
||
ConvertIf(m_lIndexDst-4, ptFormula, m_lIndexDst-3, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);
|
||
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//wR,hR
|
||
nIndex = m_arIndexDst[m_lIndexSrc-14];
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex-1, ptFormula, 1, ptValue, 2, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex, ptFormula, 1, ptValue, 2, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
//---------------------------------------------------------
|
||
nIndex = m_arIndexDst[m_lIndexSrc-8];//координаты стартовой точки
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-9];//stAng
|
||
nIndex2 = m_arIndexDst[m_lIndexSrc-1];//swAng
|
||
|
||
if (oSlice.m_eRuler == rtArc && j == 0)
|
||
strFrmla = L"moveTo";
|
||
else
|
||
strFrmla = L"lnTo";
|
||
|
||
if (oSlice.m_eRuler == rtArc && j == 0)
|
||
{
|
||
m_oPathRes.WriteString(L"<a:moveTo><a:pt x=\"");
|
||
GetValue(nIndex-5, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(nIndex, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:moveTo><a:arcTo wR=\"");
|
||
GetValue(m_lIndexDst-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" hR=\"");
|
||
GetValue(m_lIndexDst-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" stAng=\"");
|
||
GetValue(nIndex1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" swAng=\"");
|
||
GetValue(nIndex2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" />");
|
||
}
|
||
else
|
||
{
|
||
m_oPathRes.WriteString(L"<a:lnTo><a:pt x=\"");
|
||
GetValue(nIndex-5, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(nIndex, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:lnTo><a:arcTo wR=\"");
|
||
GetValue(m_lIndexDst-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" hR=\"");
|
||
GetValue(m_lIndexDst-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" stAng=\"");
|
||
GetValue(nIndex1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" swAng=\"");
|
||
GetValue(nIndex2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" />");
|
||
}
|
||
|
||
//старт
|
||
/*
|
||
LONG nIndex3 = m_arIndexDst[m_lIndexSrc-14];
|
||
strPathRes += L"<a:moveTo><a:pt x=\"0\" y=\"0\" /></a:moveTo><a:lnTo><a:pt x=\"") + GetValue(nIndex3-1, ptFormula, true) + L"\" y=\"") + GetValue(nIndex3, ptFormula, true) +
|
||
+ L"\" /></a:lnTo>");
|
||
*/
|
||
|
||
//текущая точка
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];
|
||
ConvertVal(nIndex-5, ptFormula, true, m_oGuidsRes);
|
||
ConvertVal(nIndex, ptFormula, true, m_oGuidsRes);
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertSlice_ClockwiseTo(const CSlicePath& oSlice)
|
||
{
|
||
LONG nIndex = 0;
|
||
LONG nIndex1 = 0;
|
||
LONG nIndex2 = 0;
|
||
|
||
size_t nSlicePointsCount = oSlice.m_arPoints.size();
|
||
size_t nSlicePointStep = 4;
|
||
for (size_t j = 0; j < nSlicePointsCount; j+=nSlicePointStep)
|
||
{
|
||
if ((j + nSlicePointStep) > nSlicePointsCount)
|
||
break;
|
||
|
||
pCurPoint = oSlice.m_arPoints[j];
|
||
pCurPointType = oSlice.m_arPointsType[j];
|
||
pCurPoint1 = oSlice.m_arPoints[j+1];
|
||
pCurPointType1 = oSlice.m_arPointsType[j+1];
|
||
|
||
//длина сторон
|
||
m_lIndexSrc++;
|
||
ConvertSum(pCurPoint1.x, pCurPointType1.x, 0, ptValue, pCurPoint.x, pCurPointType.x, false, true, false, m_oGuidsRes);
|
||
ConvertSum(pCurPoint1.y, pCurPointType1.y, 0, ptValue, pCurPoint.y, pCurPointType.y, false, true, false, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//координаты центра
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex-1, ptFormula, 1, ptValue, 2, ptValue, true, true, true, m_oGuidsRes); //a=wR
|
||
ConvertProd(nIndex, ptFormula, 1, ptValue, 2, ptValue, true, true, true, m_oGuidsRes); //b=hR
|
||
|
||
ConvertSum(pCurPoint.x, pCurPointType.x, m_lIndexDst-2, ptFormula, 0, ptValue, false, true, true, m_oGuidsRes);
|
||
ConvertSum(pCurPoint.y, pCurPointType.y, m_lIndexDst-2, ptFormula, 0, ptValue, false, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//рассчет для stAng---------------------------
|
||
//расположение текущей точки по четвертям 3 4
|
||
// 2 1
|
||
|
||
pCurPoint = oSlice.m_arPoints[j+2];
|
||
pCurPointType = oSlice.m_arPointsType[j+2];
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertSum(pCurPoint.x, pCurPointType.x, 0, ptValue, nIndex-1, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertSum(pCurPoint.y, pCurPointType.y, 0, ptValue, nIndex, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//угол между Ох и радиус-вектором к точке
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex-2, ptFormula, 1, ptValue, nIndex-3, ptFormula, true, true, true, m_oGuidsRes);
|
||
ConvertAt2(1, ptValue, m_lIndexDst-1, ptFormula, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//радиус к точке
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-2];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertCos(1, ptValue, nIndex, ptFormula, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-2, ptFormula, nIndex1-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//(b*cos(u))^2
|
||
|
||
ConvertSin(1, ptValue, nIndex, ptFormula, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-3, ptFormula, nIndex1-3, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//(a*sin(u))^2
|
||
|
||
ConvertSum(m_lIndexDst-1, ptFormula, m_lIndexDst-5, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSqrt(m_lIndexDst-1, ptFormula, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-3, ptFormula, nIndex1-2, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//r
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//если точка во 2 и 3 четвертях, прибавляем по 180grad
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertIf(nIndex-3, ptFormula, 0, ptValue, 10800000, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//угол до 1 точки (stAngle)
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];//угол между ох и радиусом
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-3];//расположение точки по четвертям
|
||
nIndex2 = m_arIndexDst[m_lIndexSrc];//прибавка 180 или 0
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex1-1, ptFormula, nIndex1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//знак у угла
|
||
ConvertProd(nIndex, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(nIndex, ptFormula, nIndex, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//угол всегда положительный
|
||
|
||
ConvertProd ( m_lIndexDst-1, ptFormula, m_lIndexDst-3, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//u с нужным знаком
|
||
|
||
ConvertSum ( m_lIndexDst-1, ptFormula, nIndex2, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//координаты стартовой точки
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-4];
|
||
nIndex2 = m_arIndexDst[m_lIndexSrc-5];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex, ptFormula, nIndex-10, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//r*cos(a)
|
||
ConvertProd(nIndex1-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSum(nIndex2-1, ptFormula, m_lIndexDst-1, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes); //x
|
||
|
||
ConvertProd(nIndex-6, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(nIndex-6, ptFormula, nIndex-6, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//sin теперь всегда>0
|
||
|
||
ConvertProd(nIndex, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//r*sin
|
||
ConvertProd(nIndex1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSum(nIndex2, ptFormula, m_lIndexDst-1, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);//y
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//рассчет для swAng---------------------------
|
||
//расположение текущей точки по четвертям 3 4
|
||
// 2 1
|
||
|
||
pCurPoint = oSlice.m_arPoints[j+3];
|
||
pCurPointType = oSlice.m_arPointsType[j+3];
|
||
|
||
nIndex = m_arIndexDst[m_lIndexSrc-6];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertSum(pCurPoint.x, pCurPointType.x, 0, ptValue, nIndex-1, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertSum(pCurPoint.y, pCurPointType.y, 0, ptValue, nIndex, ptFormula, false, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, 1, ptValue, -1, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//угол между Ох и радиус-вектором к точке
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex-2, ptFormula, 1, ptValue, nIndex-3, ptFormula, true, true, true, m_oGuidsRes);
|
||
ConvertAt2(1, ptValue, m_lIndexDst-1, ptFormula, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//радиус к точке
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-8];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertCos(1, ptValue, nIndex, ptFormula, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-2, ptFormula, nIndex1-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
|
||
ConvertSin(1, ptValue, nIndex, ptFormula, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-3, ptFormula, nIndex1-3, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
|
||
ConvertSum(m_lIndexDst-1, ptFormula, m_lIndexDst-5, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSqrt(m_lIndexDst-1, ptFormula, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-3, ptFormula, nIndex1-2, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//если точка во 2 и 3 четвертях, прибавляем по 180grad
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertIf(nIndex-3, ptFormula, 0, ptValue, 10800000, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//угол до 2 точки
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];//угол между ох и радиусом
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-3];//расположение точки по четвертям
|
||
nIndex2 = m_arIndexDst[m_lIndexSrc];//прибавка 180 или 0
|
||
|
||
m_lIndexSrc ++;
|
||
ConvertProd(nIndex1-1, ptFormula, nIndex1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//знак у угла
|
||
ConvertProd(nIndex, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(nIndex, ptFormula, nIndex, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//угол всегда положительный
|
||
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-3, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//u с нужным знаком
|
||
|
||
ConvertSum(m_lIndexDst-1, ptFormula, nIndex2, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//координаты конечной точки
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-4];
|
||
nIndex2 = m_arIndexDst[m_lIndexSrc-11];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex, ptFormula, nIndex-10, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//r*cos(a)
|
||
ConvertProd(nIndex1-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSum(nIndex2-1, ptFormula, m_lIndexDst-1, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);//x
|
||
|
||
ConvertProd(nIndex-6, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(nIndex-6, ptFormula, nIndex-6, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//sin теперь всегда>0
|
||
|
||
ConvertProd(nIndex, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//r*sin(a)
|
||
ConvertProd(nIndex1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSum(nIndex2, ptFormula, m_lIndexDst-1, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);//y
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//swAngle
|
||
nIndex = m_arIndexDst[m_lIndexSrc-1];
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-7];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertSum(nIndex, ptFormula, 0, ptValue, nIndex1, ptFormula, true, true, true, m_oGuidsRes);
|
||
ConvertSum(21600000, ptValue, m_lIndexDst-1, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertIf(m_lIndexDst-2, ptFormula, m_lIndexDst-2, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//swAng
|
||
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//wR,hR
|
||
nIndex = m_arIndexDst[m_lIndexSrc-14];
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex-1, ptFormula, 1, ptValue, 2, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex, ptFormula, 1, ptValue, 2, ptValue, true, true, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
//---------------------------------------------------------
|
||
nIndex = m_arIndexDst[m_lIndexSrc-8];//координаты стартовой точки
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-9];//stAng
|
||
nIndex2 = m_arIndexDst[m_lIndexSrc-1];//swAng
|
||
|
||
if (oSlice.m_eRuler == rtClockwiseArc && j == 0)
|
||
{
|
||
m_oPathRes.WriteString(L"<a:moveTo><a:pt x=\"");
|
||
GetValue(nIndex-5, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(nIndex, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:moveTo><a:arcTo wR=\"");
|
||
GetValue(m_lIndexDst-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" hR=\"");
|
||
GetValue(m_lIndexDst-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" stAng=\"");
|
||
GetValue(nIndex1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" swAng=\"");
|
||
GetValue(nIndex2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" />");
|
||
}
|
||
else
|
||
{
|
||
m_oPathRes.WriteString(L"<a:lnTo><a:pt x=\"");
|
||
GetValue(nIndex-5, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(nIndex, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:lnTo><a:arcTo wR=\"");
|
||
GetValue(m_lIndexDst-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" hR=\"");
|
||
GetValue(m_lIndexDst-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" stAng=\"");
|
||
GetValue(nIndex1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" swAng=\"");
|
||
GetValue(nIndex2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" />");
|
||
}
|
||
|
||
//текущая точка
|
||
nIndex = m_arIndexDst[m_lIndexSrc-2];
|
||
ConvertVal(nIndex-5, ptFormula, true, m_oGuidsRes);
|
||
ConvertVal(nIndex, ptFormula, true, m_oGuidsRes);
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertSlice_QuadrBesier(const CSlicePath& oSlice)
|
||
{
|
||
for (size_t j = 0; j < oSlice.m_arPoints.size(); j += 2)
|
||
{
|
||
int l = (int)(oSlice.m_arPoints.size() - j - 3);
|
||
if (l >= 0)
|
||
{
|
||
m_oPathRes.WriteString(L"<a:quadBezTo>");
|
||
for (int k = 0; k < 2; ++k)
|
||
{
|
||
pCurPoint = oSlice.m_arPoints[j+k];
|
||
pCurPointType = oSlice.m_arPointsType[j+k];
|
||
|
||
m_oPathRes.WriteString(L"<a:pt x=\"");
|
||
GetValue(pCurPoint.x, pCurPointType.x, false, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(pCurPoint.y, pCurPointType.y, false, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" />");
|
||
}
|
||
m_oPathRes.WriteString(L"</a:quadBezTo>");
|
||
}
|
||
else
|
||
{
|
||
for (size_t k = 0; k < oSlice.m_arPoints.size() - j; ++k)
|
||
{
|
||
pCurPoint = oSlice.m_arPoints[j+k];
|
||
pCurPointType = oSlice.m_arPointsType[j+k];
|
||
|
||
m_oPathRes.WriteString(L"<a:lnTo><a:pt x=\"");
|
||
GetValue(pCurPoint.x, pCurPointType.x, false, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(pCurPoint.y, pCurPointType.y, false, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:lnTo>");
|
||
}
|
||
}
|
||
|
||
m_lIndexSrc++;
|
||
ConvertVal(pCurPoint.x, pCurPointType.x, false, m_oGuidsRes);
|
||
ConvertVal(pCurPoint.y, pCurPointType.y, false, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertSlice_CurveTo(const CSlicePath& oSlice)
|
||
{
|
||
LONG nIndex = 0;
|
||
for (size_t j = 0; j < oSlice.m_arPoints.size(); j += 3)
|
||
{
|
||
int l = (int)(oSlice.m_arPoints.size() - j - 3);
|
||
if ( l >= 0 )
|
||
{
|
||
m_oPathRes.WriteString(L"<a:cubicBezTo>");
|
||
for (int k = 0; k < 3; ++k)
|
||
{
|
||
pCurPoint = oSlice.m_arPoints[j+k];
|
||
pCurPointType = oSlice.m_arPointsType[j+k];
|
||
|
||
m_oPathRes.WriteString(L"<a:pt x=\"");
|
||
GetValue(pCurPoint.x, pCurPointType.x, false, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(pCurPoint.y, pCurPointType.y, false, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" />");
|
||
}
|
||
m_oPathRes.WriteString(L"</a:cubicBezTo>");
|
||
}
|
||
else
|
||
{
|
||
for (size_t k = 0; k < oSlice.m_arPoints.size() - j; ++k)
|
||
{
|
||
m_oPathRes.WriteString(L"<a:lnTo><a:pt x=\"");
|
||
GetValue(pCurPoint.x, pCurPointType.x, false, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(pCurPoint.y, pCurPointType.y, false, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:lnTo>");
|
||
}
|
||
}
|
||
|
||
m_lIndexSrc++;
|
||
ConvertVal(pCurPoint.x, pCurPointType.x, false, m_oGuidsRes);
|
||
ConvertVal(pCurPoint.y, pCurPointType.y, false, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertSlice_RCurveTo(const CSlicePath& oSlice)
|
||
{
|
||
LONG nIndex = 0;
|
||
for (size_t j = 0; j < oSlice.m_arPoints.size(); j += 3)
|
||
{
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
int l = (int)(oSlice.m_arPoints.size() - j - 3);
|
||
if (l >= 0)
|
||
{
|
||
m_oPathRes.WriteString(L"<a:cubicBezTo>");
|
||
for (int k = 0; k < 3; ++k)
|
||
{
|
||
pCurPoint = oSlice.m_arPoints[j+k];
|
||
pCurPointType = oSlice.m_arPointsType[j+k];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertSum(nIndex-1, ptFormula, pCurPoint.x, pCurPointType.x, 0, ptValue, true, false, true, m_oGuidsRes);
|
||
ConvertSum(nIndex, ptFormula, pCurPoint.y, pCurPointType.y, 0, ptValue, true, false, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
m_oPathRes.WriteString(L"<a:pt x=\"");
|
||
GetValue(m_lIndexDst-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(m_lIndexDst-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" />");
|
||
}
|
||
m_oPathRes.WriteString(L"</a:cubicBezTo>");
|
||
}
|
||
else
|
||
{
|
||
for (size_t k=0; k < oSlice.m_arPoints.size() - j; ++k)
|
||
{
|
||
pCurPoint = oSlice.m_arPoints[j+k];
|
||
pCurPointType = oSlice.m_arPointsType[j+k];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertSum(nIndex-1, ptFormula, pCurPoint.x, pCurPointType.x, 0, ptValue, true, false, true, m_oGuidsRes);
|
||
ConvertSum(nIndex, ptFormula, pCurPoint.y, pCurPointType.y, 0, ptValue, true, false, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
m_oPathRes.WriteString(L"<a:lnTo><a:pt x=\"");
|
||
GetValue(m_lIndexDst-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(m_lIndexDst-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:lnTo>");
|
||
}
|
||
}
|
||
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertVal(nIndex-1, ptFormula, true, m_oGuidsRes);
|
||
ConvertVal(nIndex, ptFormula, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertSlice_AngleEllipse(const CSlicePath& oSlice)
|
||
{
|
||
LONG nIndex = 0;
|
||
LONG nIndex1 = 0;
|
||
LONG nIndex2 = 0;
|
||
|
||
size_t nSlicePointsCount = oSlice.m_arPoints.size();
|
||
size_t nSlicePointStep = 3;
|
||
for (size_t j = 0; j < nSlicePointsCount; j+=nSlicePointStep)
|
||
{
|
||
if ((j + nSlicePointStep) > nSlicePointsCount)
|
||
break;
|
||
|
||
pCurPoint = oSlice.m_arPoints[j+1];
|
||
pCurPointType = oSlice.m_arPointsType[j+1];
|
||
pCurPoint1 = oSlice.m_arPoints[j+2];
|
||
pCurPointType1 = oSlice.m_arPointsType[j+2];
|
||
|
||
//конвертация углов в pptx формат
|
||
m_lIndexSrc++;
|
||
ConvertProd(pCurPoint1.x, pCurPointType1.x, pow3_16, ptValue, m_oParam.m_lParam, m_oParam.m_eType, false, true, true, m_oGuidsRes); //1 угол
|
||
ConvertProd(pCurPoint1.y, pCurPointType1.y, pow3_16, ptValue, m_oParam.m_lParam, m_oParam.m_eType, false, true, true, m_oGuidsRes); //2 угол
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
//wR и hR
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertVal(pCurPoint.x, pCurPointType.x, false, m_oGuidsRes);//wr=a
|
||
ConvertVal(pCurPoint.y, pCurPointType.y, false, m_oGuidsRes);//hr=b
|
||
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
//stAng и swAng
|
||
nIndex = m_arIndexDst[m_lIndexSrc-1];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertProd(nIndex-1, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes); //stAng
|
||
ConvertSum(nIndex-1, ptFormula, nIndex, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex, ptFormula, -1, ptValue, 1, ptValue, true, true, true, m_oGuidsRes);//swAng
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
//радиус до стартовой точки
|
||
|
||
nIndex = m_arIndexDst[m_lIndexSrc]; //stang
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-1]; //wr hr
|
||
|
||
m_lIndexSrc++;
|
||
ConvertCos(1, ptValue, nIndex-2, ptFormula, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1, ptFormula, nIndex1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//(b*cos(u))^2
|
||
|
||
ConvertSin(1, ptValue, nIndex-2, ptFormula, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1-1, ptFormula, nIndex1-1, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertProd(m_lIndexDst-1, ptFormula, m_lIndexDst-2, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);//(a*sin(u))^2
|
||
|
||
ConvertSum(m_lIndexDst-1, ptFormula, m_lIndexDst-5, ptFormula, 0, ptValue, true, true, true, m_oGuidsRes);
|
||
ConvertSqrt(m_lIndexDst-1, ptFormula, true, m_oGuidsRes);
|
||
ConvertProd(nIndex1, ptFormula, nIndex1-1, ptFormula, m_lIndexDst-1, ptFormula, true, true, true, m_oGuidsRes);//r
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
|
||
//координаты конечной точки (она же начальная для эллипса)
|
||
|
||
pCurPoint1 = oSlice.m_arPoints[j];//коорд центра
|
||
pCurPointType1 = oSlice.m_arPointsType[j];
|
||
|
||
nIndex = m_arIndexDst[m_lIndexSrc-1]; //stang
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc]; //r
|
||
|
||
m_lIndexSrc++;
|
||
|
||
ConvertProd(nIndex1, ptFormula, nIndex1-10, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes); //r*cos
|
||
ConvertSum(pCurPoint1.x, pCurPointType1.x, m_lIndexDst-1, ptFormula, 0, ptValue, false, true, true, m_oGuidsRes);//x
|
||
|
||
ConvertProd(nIndex1, ptFormula, nIndex1-6, ptFormula, 1, ptValue, true, true, true, m_oGuidsRes);// r*sin
|
||
ConvertSum(pCurPoint1.y, pCurPointType1.y, m_lIndexDst-1, ptFormula, 0, ptValue, false, true, true, m_oGuidsRes);//y
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
//---------------------
|
||
|
||
nIndex = m_arIndexDst[m_lIndexSrc];//текущая точка
|
||
nIndex1 = m_arIndexDst[m_lIndexSrc-2];//stAng и swAng
|
||
nIndex2 = m_arIndexDst[m_lIndexSrc-3];//wR и hR
|
||
|
||
if (j == 0)
|
||
strFrmla = L"moveTo";
|
||
else
|
||
strFrmla = L"lnTo";
|
||
|
||
if (j == 0)
|
||
{
|
||
m_oPathRes.WriteString(L"<a:moveTo><a:pt x=\"");
|
||
GetValue(nIndex-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(nIndex, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:moveTo><a:arcTo wR=\"");
|
||
GetValue(nIndex2-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" hR=\"");
|
||
GetValue(nIndex2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" stAng=\"");
|
||
GetValue(nIndex1-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" swAng=\"");
|
||
GetValue(nIndex1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" />");
|
||
}
|
||
else
|
||
{
|
||
m_oPathRes.WriteString(L"<a:lnTo><a:pt x=\"");
|
||
GetValue(nIndex-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" y=\"");
|
||
GetValue(nIndex, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" /></a:lnTo><a:arcTo wR=\"");
|
||
GetValue(nIndex2-1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" hR=\"");
|
||
GetValue(nIndex2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" stAng=\"");
|
||
GetValue(nIndex1-2, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" swAng=\"");
|
||
GetValue(nIndex1, ptFormula, true, m_oPathRes);
|
||
m_oPathRes.WriteString(L"\" />");
|
||
}
|
||
|
||
//текущая точка
|
||
|
||
nIndex = m_arIndexDst[m_lIndexSrc];
|
||
|
||
m_lIndexSrc++;
|
||
ConvertVal(nIndex-2, ptFormula, true, m_oGuidsRes);
|
||
ConvertVal(nIndex, ptFormula, true, m_oGuidsRes);
|
||
m_arIndexDst.push_back(m_lIndexDst-1);
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertSlice_EllipticalQuadrX(const CSlicePath& oSlice)
|
||
{
|
||
for (size_t j = 0; j < oSlice.m_arPoints.size(); j += 2)
|
||
{
|
||
pCurPoint = oSlice.m_arPoints[j];
|
||
pCurPointType = oSlice.m_arPointsType[j];
|
||
|
||
ConvertQuadrX(pCurPoint, pCurPointType);
|
||
|
||
if (j + 1 < oSlice.m_arPoints.size())
|
||
{
|
||
pCurPoint1 = oSlice.m_arPoints[j+1];
|
||
pCurPointType1 = oSlice.m_arPointsType[j+1];
|
||
ConvertQuadrY(pCurPoint1, pCurPointType1);
|
||
}
|
||
}
|
||
}
|
||
void CFormulaConverter::ConvertSlice_EllipticalQuadrY(const CSlicePath& oSlice)
|
||
{
|
||
for (size_t j = 0; j < oSlice.m_arPoints.size(); j += 2)
|
||
{
|
||
pCurPoint = oSlice.m_arPoints[j];
|
||
pCurPointType = oSlice.m_arPointsType[j];
|
||
ConvertQuadrY(pCurPoint, pCurPointType);
|
||
|
||
if (j + 1 < oSlice.m_arPoints.size())
|
||
{
|
||
pCurPoint1 = oSlice.m_arPoints[j+1];
|
||
pCurPointType1 = oSlice.m_arPointsType[j+1];
|
||
ConvertQuadrX(pCurPoint1, pCurPointType1);
|
||
}
|
||
}
|
||
}
|
||
}
|