570 lines
20 KiB
C++
570 lines
20 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 "Pptx2PptShapeConverter.h"
|
|
|
|
namespace NSGuidesVML
|
|
{
|
|
CConverterPPTXPPT::CConverterPPTXPPT()
|
|
{
|
|
m_lPPTX2PPT = -1;
|
|
m_lPPT2PPTX = -1;
|
|
m_lIndexDst = -1;
|
|
m_lIndexAdj = -1;
|
|
pPPTShape = new CPPTShape();
|
|
}
|
|
void CConverterPPTXPPT::Convert ( CPPTXShape* pPPTXShape )
|
|
{
|
|
ConvertAdjastments ( pPPTXShape->m_arAdjustments, pPPTXShape->FManager.mapAdjustments );
|
|
AddSizeGuides ((LONG)pPPTXShape->FManager.GetWidth(), (LONG)pPPTXShape->FManager.GetHeight());
|
|
ConvertGuides ( pPPTXShape->FManager.strGuides, pPPTXShape->FManager.mapGuides);
|
|
ConvertPath( pPPTXShape->m_strPath, pPPTXShape->FManager.strGuides, pPPTXShape->FManager.mapGuides);
|
|
|
|
//TODO текстовые поля
|
|
//ConvertTextRects ( pPPTXShape->m_arStringTextRects );
|
|
ConvertHandles ( pPPTXShape->m_arHandles );
|
|
|
|
//ConvertType ( pPPTXShape->m_eType );
|
|
//------------------------------------
|
|
int i=0;
|
|
}
|
|
void CConverterPPTXPPT::ConvertHandles (std::vector<CHandle_>& arHnd)
|
|
{
|
|
|
|
for (size_t nIndex=0; nIndex<arHnd.size(); nIndex++)
|
|
{
|
|
CHandle_ oHandle;
|
|
//TODO переименовать названия формул и прокинуть текстовые атрибуты topleft, rightbottom в полях хендла
|
|
|
|
pPPTShape->m_arHandles.push_back(oHandle);
|
|
}
|
|
|
|
return;
|
|
}
|
|
void CConverterPPTXPPT::ConvertAdjastments( std::vector<long> &arAdj, std::map<std::wstring, long> &mapAdj )
|
|
{
|
|
int i=0;
|
|
for( std::map<std::wstring, long>::iterator pPair = mapAdj.begin(); pPair != mapAdj.end(); i++, ++pPair)
|
|
{
|
|
m_arMapAdj.insert(std::pair<std::wstring, LONG>(pPair->first, ++m_lIndexAdj));
|
|
pPPTShape->m_arAdjustments.push_back(arAdj[i]);
|
|
}
|
|
//это аджасменты для перевода углов tan(angle, adj)
|
|
//тк все угла в формулах считаются в pptx
|
|
//pptx->ppt
|
|
pPPTShape->m_arAdjustments.push_back(3114601);
|
|
m_lPPTX2PPT = ++m_lIndexAdj;
|
|
//ppt->pptx
|
|
pPPTShape->m_arAdjustments.push_back(2783638);
|
|
m_lPPT2PPTX = ++m_lIndexAdj;
|
|
return;
|
|
}
|
|
void CConverterPPTXPPT::ConvertTextRects (std::vector<std::wstring> &arTextRects)
|
|
{
|
|
pPPTShape->m_arStringTextRects.insert( pPPTShape->m_arStringTextRects.end(), arTextRects.begin(), arTextRects.end());
|
|
return;
|
|
}
|
|
void CConverterPPTXPPT::ConvertType (OOXMLShapes::ShapeType eType)
|
|
{
|
|
switch (eType)
|
|
{
|
|
case OOXMLShapes::sptCRect:
|
|
pPPTShape->m_eType = PPTShapes::sptCRect;
|
|
break;
|
|
case OOXMLShapes::sptCArc:
|
|
pPPTShape->m_eType = PPTShapes::sptCRect;
|
|
break;
|
|
default:
|
|
pPPTShape->m_eType = PPTShapes::sptCustom;
|
|
}
|
|
return;
|
|
}
|
|
void CConverterPPTXPPT::AddSizeGuides (LONG lWidth, LONG lHeight)
|
|
{
|
|
//TODO прокинуть w и h в формулах
|
|
NSGuidesVML::CFormula pNewFmla3;
|
|
pNewFmla3.m_eFormulaType = ftVal;
|
|
pNewFmla3.m_lIndex = ++m_lIndexDst;
|
|
pNewFmla3.m_eType1 = ptValue;
|
|
pNewFmla3.m_lParam1 = 21600;// lWidth;
|
|
pPPTShape->m_oManager.m_arFormulas.push_back(pNewFmla3);
|
|
m_arMapFormula.insert(std::pair<std::wstring, LONG>(_T("w"), m_lIndexDst));
|
|
|
|
pNewFmla3.m_lIndex = ++m_lIndexDst;
|
|
pNewFmla3.m_eType1 = ptValue;
|
|
pNewFmla3.m_lParam1 = 21600;//lHeight;
|
|
|
|
pPPTShape->m_oManager.m_arFormulas.push_back(pNewFmla3);
|
|
|
|
m_arMapFormula.insert(std::pair<std::wstring, LONG>(_T("h"), m_lIndexDst));
|
|
|
|
return;
|
|
}
|
|
LONG CConverterPPTXPPT::ConvertFmlaParam (std::wstring strParam, NSGuidesVML::ParamType &eType, std::wstring strKey, std::vector<NSGuidesOOXML::CFormula> &strGuides, std::map<std::wstring, long> &mapGuides)
|
|
{
|
|
LONG lVal = 0;
|
|
|
|
std::map<std::wstring, long>::iterator NumFmla = m_arMapFormula.find(strParam);
|
|
std::map<std::wstring, long>::iterator NumAdj = m_arMapAdj.find(strParam);
|
|
std::map<std::wstring, long>::iterator NumGuides = mapGuides.find(strParam);
|
|
|
|
if (NumAdj != m_arMapAdj.end())
|
|
{
|
|
eType = ptAdjust;
|
|
lVal = NumAdj->second;
|
|
}
|
|
else if (NumFmla == m_arMapFormula.end())
|
|
{
|
|
//пришло число
|
|
if (NumGuides == mapGuides.end())
|
|
{
|
|
lVal = (LONG)XmlUtils::GetInteger(strParam);
|
|
if (lVal > 65535)
|
|
{
|
|
ConvertFmla( ftSumangle, lVal%65536, ptValue, (int)lVal/65536, ptValue, 0, ptValue);
|
|
eType = ptFormula;
|
|
lVal = m_lIndexDst;
|
|
}
|
|
else if (lVal < 0)
|
|
{
|
|
ConvertFmla( ftSum, 0, ptValue, 0, ptValue, abs(lVal), ptValue);
|
|
eType = ptFormula;
|
|
lVal = m_lIndexDst;
|
|
}
|
|
else
|
|
eType = ptValue;
|
|
}
|
|
else //пришла стандартная формула из набора, которую надо теперь добавить
|
|
{
|
|
LONG lNumGuides = NumGuides->second;
|
|
|
|
NSGuidesOOXML::CFormula pFormula = strGuides[lNumGuides];
|
|
|
|
//strKey = mapGuides.GetKeyAt(lNumGuides);
|
|
int ind =0;
|
|
for (std::map<std::wstring, long>::iterator p = mapGuides.begin(); p!= mapGuides.end(); ++p)
|
|
{
|
|
if (ind == lNumGuides)
|
|
{
|
|
strKey = p->first;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ConvertGuid(pFormula, strKey, strGuides, mapGuides);
|
|
eType = ptFormula;
|
|
lVal = m_lIndexDst;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
eType = ptFormula;
|
|
std::map<std::wstring, LONG>::iterator Val = m_arMapFormula.find(strParam);
|
|
lVal = Val->second;
|
|
}
|
|
return lVal;
|
|
}
|
|
void CConverterPPTXPPT::ConvertFmla ( FormulaType eFmlaType, LONG lParam1, ParamType eType1, LONG lParam2, ParamType eType2, LONG lParam3, ParamType eType3 )
|
|
{
|
|
NSGuidesVML::CFormula pNewFmla;
|
|
pNewFmla.m_lIndex = ++m_lIndexDst;
|
|
pNewFmla.m_eFormulaType = eFmlaType;
|
|
|
|
pNewFmla.m_eType1 = eType1;
|
|
pNewFmla.m_lParam1 = lParam1;
|
|
|
|
pNewFmla.m_eType2 = eType2;
|
|
pNewFmla.m_lParam2 = lParam2;
|
|
|
|
pNewFmla.m_eType3 = eType3;
|
|
pNewFmla.m_lParam3 = lParam3;
|
|
|
|
pPPTShape->m_oManager.m_arFormulas.push_back(pNewFmla);
|
|
return;
|
|
}
|
|
void CConverterPPTXPPT::ConvertFmla ( FormulaType eFmlaType, LONG lParam1, ParamType eType1, LONG lParam2, ParamType eType2 )
|
|
{
|
|
CFormula pNewFmla;
|
|
pNewFmla.m_lIndex = ++m_lIndexDst;
|
|
pNewFmla.m_eFormulaType = eFmlaType;
|
|
|
|
pNewFmla.m_eType1 = eType1;
|
|
pNewFmla.m_lParam1 = lParam1;
|
|
|
|
pNewFmla.m_eType2 = eType2;
|
|
pNewFmla.m_lParam2 = lParam2;
|
|
|
|
pPPTShape->m_oManager.m_arFormulas.push_back(pNewFmla);
|
|
return;
|
|
}
|
|
void CConverterPPTXPPT::ConvertFmla ( FormulaType eFmlaType, LONG lParam1, ParamType eType1 )
|
|
{
|
|
CFormula pNewFmla;
|
|
pNewFmla.m_lIndex = ++m_lIndexDst;
|
|
pNewFmla.m_eFormulaType = eFmlaType;
|
|
|
|
pNewFmla.m_eType1 = eType1;
|
|
pNewFmla.m_lParam1 = lParam1;
|
|
|
|
pPPTShape->m_oManager.m_arFormulas.push_back(pNewFmla);
|
|
return;
|
|
}
|
|
void CConverterPPTXPPT::ConvertGuid ( NSGuidesOOXML::CFormula pFormula, std::wstring strKey, std::vector<NSGuidesOOXML::CFormula> &strGuides, std::map<std::wstring, long> &mapGuides)
|
|
{
|
|
LONG lParam1, lParam2, lParam3;
|
|
NSGuidesVML::ParamType eType1, eType2, eType3;
|
|
|
|
lParam1 = ConvertFmlaParam(pFormula.m_lParam1, eType1, strKey, strGuides, mapGuides);
|
|
lParam2 = ConvertFmlaParam(pFormula.m_lParam2, eType2, strKey, strGuides, mapGuides);
|
|
lParam3 = ConvertFmlaParam(pFormula.m_lParam3, eType3, strKey, strGuides, mapGuides);
|
|
|
|
switch (pFormula.m_eFormulaType)
|
|
{
|
|
case NSGuidesOOXML::CFormula::ftOOXMLSum:
|
|
ConvertFmla( ftSum, lParam1, eType1, lParam2, eType2, lParam3, eType3);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLProduct:
|
|
ConvertFmla( ftProduct, lParam1, eType1, lParam2, eType2, lParam3, eType3);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLIf:
|
|
ConvertFmla( ftIf, lParam1, eType1, lParam2, eType2, lParam3, eType3);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLAbsolute:
|
|
ConvertFmla( ftAbsolute, lParam1, eType1);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLAtan2:
|
|
ConvertFmla( ftAtan2, lParam1, eType1, lParam2, eType2);
|
|
ConvertFmla( ftTan, m_lIndexDst, ptFormula, m_lPPT2PPTX, ptAdjust);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLCos:
|
|
ConvertFmla( ftCos, lParam1, eType1, lParam2, eType2);
|
|
ConvertFmla( ftTan, m_lIndexDst, ptFormula, m_lPPT2PPTX, ptAdjust);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLMax:
|
|
ConvertFmla( ftMax, lParam1, eType1, lParam2, eType2);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLMin:
|
|
ConvertFmla( ftMin, lParam1, eType1, lParam2, eType2);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLMod:
|
|
ConvertFmla( ftMod, lParam1, eType1, lParam2, eType2, lParam3, eType3);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLSinatan2:
|
|
ConvertFmla( ftSinatan2, lParam1, eType1, lParam2, eType2, lParam3, eType3);
|
|
ConvertFmla( ftTan, m_lIndexDst, ptFormula, m_lPPT2PPTX, ptAdjust);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLCosatan2:
|
|
ConvertFmla( ftCosatan2, lParam1, eType1, lParam2, eType2, lParam3, eType3);
|
|
ConvertFmla( ftTan, m_lIndexDst, ptFormula, m_lPPT2PPTX, ptAdjust);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLSin:
|
|
ConvertFmla( ftSin, lParam1, eType1, lParam2, eType2);
|
|
ConvertFmla( ftTan, m_lIndexDst, ptFormula, m_lPPT2PPTX, ptAdjust);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLSqrt:
|
|
ConvertFmla( ftSqrt, lParam1, eType1);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLTan:
|
|
ConvertFmla( ftTan, lParam1, eType1, lParam2, eType2);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLVal:
|
|
ConvertFmla( ftVal, lParam1, eType1);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLAddDivide:
|
|
ConvertFmla( ftSum, lParam1, eType1, lParam2, eType2, 0, ptValue);
|
|
ConvertFmla( ftProduct, m_lIndexDst, ptFormula, 1, ptValue, lParam3, eType3);
|
|
break;
|
|
case NSGuidesOOXML::CFormula::ftOOXMLPin:
|
|
ConvertFmla( ftSum, lParam1, eType1, 0, ptValue, lParam2, eType2);
|
|
ConvertFmla( ftSum, lParam2, eType2, 0, ptValue, lParam3, eType3);
|
|
ConvertFmla( ftIf, m_lIndexDst, ptFormula, lParam3, eType3, lParam2, eType2);
|
|
ConvertFmla( ftIf, m_lIndexDst-2, ptFormula, lParam1, eType1, m_lIndexDst, ptFormula);
|
|
break;
|
|
}
|
|
m_arMapFormula.insert(std::pair<std::wstring, LONG>(strKey, m_lIndexDst));
|
|
return;
|
|
}
|
|
void CConverterPPTXPPT::ConvertGuides ( std::vector<NSGuidesOOXML::CFormula> &strGuides, std::map<std::wstring, long> &mapGuides )
|
|
{
|
|
//стандартные формулы для пптх будем добавлять, если только они встретятся
|
|
for (size_t nIndex=32; nIndex < strGuides.size(); ++nIndex)
|
|
{
|
|
NSGuidesOOXML::CFormula pFormula = strGuides[nIndex];
|
|
|
|
std::wstring strKey;// = mapGuides.GetKeyAt(nIndex);
|
|
int ind =0;
|
|
for (std::map<std::wstring, long>::iterator p = mapGuides.begin(); p!= mapGuides.end(); ++p)
|
|
{
|
|
if (ind == nIndex)
|
|
{
|
|
strKey = p->first;
|
|
break;
|
|
}
|
|
}
|
|
ConvertGuid(pFormula, strKey, strGuides, mapGuides);
|
|
}
|
|
}
|
|
void CConverterPPTXPPT::ConvertPath(const std::wstring& xml, std::vector<NSGuidesOOXML::CFormula> &strGuides, std::map<std::wstring, long> &mapGuides)
|
|
{
|
|
XmlUtils::CXmlNode pathLst;
|
|
if(pathLst.FromXmlString(xml))
|
|
{
|
|
std::vector<XmlUtils::CXmlNode> list;
|
|
if (pathLst.GetNodes(_T("path"), list))
|
|
{
|
|
size_t nPathCount = list.size();
|
|
for (size_t i=0; i<nPathCount; i++)
|
|
{
|
|
XmlUtils::CXmlNode & PathNode = list[i];
|
|
if(PathNode.IsValid())
|
|
{
|
|
std::vector<XmlUtils::CXmlNode> listNode;
|
|
PathNode.GetNodes(_T("*"), listNode);
|
|
|
|
bool bFill = PathNode.GetAttribute(_T("fill"), _T("norm")) != _T("none");
|
|
std::wstring stroke = PathNode.GetAttribute(_T("stroke"), _T("true"));
|
|
bool bStroke = (stroke == _T("true")) || (stroke == _T("1"));
|
|
|
|
size_t nNodeCount = listNode.size();
|
|
for (size_t j=0; j<nNodeCount; j++)
|
|
{
|
|
XmlUtils::CXmlNode & node = listNode[i];
|
|
if(node.IsValid())
|
|
{
|
|
bool bNum = false; //управляем запятыми
|
|
|
|
std::wstring strName = node.GetName();
|
|
if (strName == _T("moveTo"))
|
|
pPPTShape->m_strPath += _T("m");
|
|
else if (strName == _T("lnTo"))
|
|
pPPTShape->m_strPath += _T("l");
|
|
else if (strName == _T("arcTo"))
|
|
pPPTShape->m_strPath += _T("ae");
|
|
else if (strName == _T("cubicBezTo"))
|
|
pPPTShape->m_strPath += _T("c");
|
|
else if (strName == _T("quadBezTo"))
|
|
pPPTShape->m_strPath += _T("qb");
|
|
else
|
|
pPPTShape->m_strPath += _T("x");
|
|
|
|
if (strName == _T("arcTo"))
|
|
{
|
|
LONG lStartX = m_lIndexDst-1, lStartY = m_lIndexDst;
|
|
LONG lParam1, lParam2, lParam3, lParam4;
|
|
NSGuidesVML::ParamType eType1, eType2, eType3, eType4;
|
|
|
|
lParam1 = ConvertFmlaParam(node.GetAttribute(_T("wR")), eType1, node.GetAttribute(_T("wR")), strGuides, mapGuides);
|
|
lParam2 = ConvertFmlaParam(node.GetAttribute(_T("hR")), eType2, node.GetAttribute(_T("hR")), strGuides, mapGuides);
|
|
lParam3 = ConvertFmlaParam(node.GetAttribute(_T("stAng")), eType3, node.GetAttribute(_T("stAng")), strGuides, mapGuides);
|
|
lParam4 = ConvertFmlaParam(node.GetAttribute(_T("swAng")), eType4, node.GetAttribute(_T("swAng")), strGuides, mapGuides);
|
|
|
|
//stAng
|
|
ConvertFmla( ftTan, lParam3, eType3, m_lPPTX2PPT, ptAdjust);
|
|
//swAng
|
|
ConvertFmla( ftTan, lParam4, eType4, m_lPPTX2PPT, ptAdjust);
|
|
//a
|
|
ConvertFmla( ftVal, lParam1, eType1);
|
|
//b
|
|
ConvertFmla( ftVal, lParam2, eType2);
|
|
LONG lstAng = m_lIndexDst-3, lswAng = m_lIndexDst-2, la = m_lIndexDst-1, lb = m_lIndexDst;
|
|
//радиус эллипса в stAng--------------------
|
|
//(b*cos)^2
|
|
ConvertFmla( ftCos, m_lIndexDst, ptFormula, m_lIndexDst-3, ptFormula);
|
|
ConvertFmla( ftProduct, m_lIndexDst, ptFormula, m_lIndexDst, ptFormula, 1, ptValue);
|
|
//(a*sin)^2
|
|
ConvertFmla( ftSin, m_lIndexDst-3, ptFormula, m_lIndexDst-5, ptFormula);
|
|
ConvertFmla( ftProduct, m_lIndexDst, ptFormula, m_lIndexDst, ptFormula, 1, ptValue);
|
|
ConvertFmla( ftSum, m_lIndexDst-2, ptFormula, m_lIndexDst, ptFormula, 0, ptValue);
|
|
ConvertFmla( ftSqrt, m_lIndexDst, ptFormula);
|
|
//r
|
|
ConvertFmla( ftProduct, la, ptFormula, lb, ptFormula, m_lIndexDst, ptFormula);
|
|
|
|
//r*cos(stAng)
|
|
ConvertFmla( ftCos, m_lIndexDst, ptFormula, lstAng, ptFormula);
|
|
//xc
|
|
ConvertFmla( ftSum, lStartX, ptFormula, 0, ptValue, m_lIndexDst, ptFormula);
|
|
//r*sin(stAng)
|
|
ConvertFmla( ftSin, m_lIndexDst-2, ptFormula, lstAng, ptFormula);
|
|
//yc
|
|
ConvertFmla( ftSum, lStartY, ptFormula, 0, ptValue, m_lIndexDst, ptFormula);
|
|
//endAng
|
|
ConvertFmla( ftSum, lstAng, ptFormula, lswAng, ptFormula, 0, ptValue);
|
|
|
|
//радиус эллипса в endAng--------------------
|
|
//(b*cos)^2
|
|
ConvertFmla( ftCos, lb, ptFormula, m_lIndexDst, ptFormula);
|
|
ConvertFmla( ftProduct, m_lIndexDst, ptFormula, m_lIndexDst, ptFormula, 1, ptValue);
|
|
//(a*sin)^2
|
|
ConvertFmla( ftSin, la, ptFormula, m_lIndexDst-2, ptFormula);
|
|
ConvertFmla( ftProduct, m_lIndexDst, ptFormula, m_lIndexDst, ptFormula, 1, ptValue);
|
|
ConvertFmla( ftSum, m_lIndexDst-2, ptFormula, m_lIndexDst, ptFormula, 0, ptValue);
|
|
ConvertFmla( ftSqrt, m_lIndexDst, ptFormula);
|
|
//r
|
|
ConvertFmla( ftProduct, la, ptFormula, lb, ptFormula, m_lIndexDst, ptFormula);
|
|
|
|
//r*cos(endAng)
|
|
ConvertFmla( ftCos, m_lIndexDst, ptFormula, m_lIndexDst-7, ptFormula);
|
|
//xEnd
|
|
ConvertFmla( ftSum, m_lIndexDst-11, ptFormula, m_lIndexDst, ptFormula, 0, ptValue);
|
|
//r*sin(endAng)
|
|
ConvertFmla( ftSin, m_lIndexDst-2, ptFormula, m_lIndexDst-9, ptFormula);
|
|
//yEnd
|
|
ConvertFmla( ftSum, m_lIndexDst-11, ptFormula, m_lIndexDst, ptFormula, 0, ptValue );
|
|
|
|
std::wstring xC = L"@" + std::to_wstring( m_lIndexDst-14);
|
|
std::wstring yC = L"@" + std::to_wstring( m_lIndexDst-12);
|
|
std::wstring wR = L"@" + std::to_wstring( la);
|
|
std::wstring hR = L"@" + std::to_wstring( lb);
|
|
|
|
//360
|
|
ConvertFmla( ftSumangle, 0, ptValue, 360, ptValue, 0, ptValue );
|
|
//360-stAng
|
|
ConvertFmla( ftSum, m_lIndexDst, ptFormula, 0, ptValue, lstAng, ptFormula);
|
|
//-1
|
|
ConvertFmla( ftSum, 0, ptValue, 0, ptValue, 1, ptValue);
|
|
//-1*swAng
|
|
ConvertFmla( ftProduct, lswAng, ptFormula, m_lIndexDst, ptFormula, 1, ptValue);
|
|
|
|
std::wstring stAng = L"@" + std::to_wstring( m_lIndexDst-2);
|
|
std::wstring swAng = L"@" + std::to_wstring( m_lIndexDst);
|
|
//std::wstring xEnd = _T(""); xEnd.Format(_T("@%d"), m_lIndexDst-5);
|
|
//std::wstring yEnd = _T(""); yEnd.Format(_T("@%d"), m_lIndexDst-4);
|
|
|
|
pPPTShape->m_strPath += xC + yC + wR + hR + stAng + swAng;
|
|
|
|
ConvertFmla( ftVal, m_lIndexDst - 6, ptFormula);
|
|
ConvertFmla( ftVal, m_lIndexDst - 5, ptFormula);
|
|
|
|
}
|
|
else
|
|
{
|
|
std::vector<XmlUtils::CXmlNode> ptList;
|
|
node.GetNodes(_T("pt"), ptList);
|
|
size_t nPtCount = ptList.size();
|
|
|
|
for (size_t k=0; k<nPtCount; k++)
|
|
{
|
|
bool bLastPount = false;
|
|
if ( k == nPtCount-1)
|
|
bLastPount = true;
|
|
|
|
XmlUtils::CXmlNode & ptNode = ptList[i];
|
|
if(ptNode.IsValid())
|
|
{
|
|
std::wstring ptX = ptNode.GetAttribute(_T("x"));
|
|
std::wstring ptY = ptNode.GetAttribute(_T("y"));
|
|
|
|
pPPTShape->m_strPath += ConvertPathPoint( ptX, ptY, bNum, strGuides, mapGuides, bLastPount);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (!bFill)
|
|
pPPTShape->m_strPath += _T("nf");
|
|
if (!bStroke)
|
|
pPPTShape->m_strPath += _T("ns");
|
|
}
|
|
pPPTShape->m_strPath += _T("e");
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
LONG CConverterPPTXPPT::ConvertArcParam (std::wstring strParam, NSGuidesVML::ParamType &eType)
|
|
{
|
|
LONG lVal = 0;
|
|
|
|
std::map<std::wstring, LONG>::iterator NumFmla = m_arMapFormula.find(strParam);
|
|
std::map<std::wstring, LONG>::iterator NumAdj = m_arMapAdj.find(strParam);
|
|
|
|
if (NumAdj != m_arMapAdj.end())
|
|
{
|
|
eType = ptAdjust;
|
|
lVal = NumAdj->second; //индекс в map ???
|
|
}
|
|
else if (NumFmla == m_arMapFormula.end())
|
|
{
|
|
eType = ptValue;
|
|
lVal = (LONG)XmlUtils::GetInteger(strParam);
|
|
|
|
}
|
|
else
|
|
{
|
|
eType = ptFormula;
|
|
lVal = m_arMapFormula.find(strParam)->second;
|
|
}
|
|
return lVal;
|
|
}
|
|
std::wstring CConverterPPTXPPT::ConvertPathPoint (std::wstring strX, std::wstring strY, bool &bNum, std::vector<NSGuidesOOXML::CFormula> &strGuides, std::map<std::wstring, long> &mapGuides, bool bLPoint)
|
|
{
|
|
std::wstring strRes = _T("");
|
|
ParamType eType1, eType2;
|
|
LONG lParam1, lParam2;
|
|
|
|
if (bNum)
|
|
strRes += _T(",");
|
|
lParam1 = ConvertFmlaParam(strX, eType1, strX, strGuides, mapGuides);
|
|
strRes += ConvertPathParam (lParam1, eType1, bNum);
|
|
|
|
if (bNum)
|
|
strRes += _T(",");
|
|
|
|
lParam2 = ConvertFmlaParam(strY, eType2, strY, strGuides, mapGuides);
|
|
strRes += ConvertPathParam (lParam2, eType2, bNum);
|
|
|
|
if (bLPoint)
|
|
{
|
|
ConvertFmla( ftVal, lParam1, eType1);
|
|
ConvertFmla( ftVal, lParam2, eType2);
|
|
}
|
|
return strRes;
|
|
}
|
|
std::wstring CConverterPPTXPPT::ConvertPathParam (LONG lParam, ParamType eType, bool &bNum)
|
|
{
|
|
std::wstring strRes;
|
|
|
|
if (eType == ptAdjust)
|
|
strRes = L"#";
|
|
else if (eType == ptValue)
|
|
{
|
|
bNum = true;
|
|
}
|
|
else
|
|
strRes = L"@";
|
|
|
|
strRes += std::to_wstring(lParam);
|
|
|
|
return strRes;
|
|
}
|
|
}
|