/*
 * (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 "cconversionsmtoooxml.h"
#include "../../../../DesktopEditor/common/File.h"
#include <fstream>
namespace StarMath {

	CConversionSMtoOOXML::CConversionSMtoOOXML(): m_pXmlWrite(nullptr)
	{
	}
	CConversionSMtoOOXML::~CConversionSMtoOOXML()
	{
		if (m_pXmlWrite)
			delete m_pXmlWrite;
	}
	//check XMLWrite(if not nullptr == delete)
	void CConversionSMtoOOXML::StartConversion(std::vector<StarMath::CElement*> arPars, const unsigned int& iAlignment)
	{
		m_pXmlWrite = new XmlUtils::CXmlWriter;
		if(!arPars.empty())
		{
			std::wstring wsNodeMath(L"m:oMath"),wsNodeMathPara(L"m:oMathPara"),wsAlignment;
			switch(iAlignment)
			{
			case 0:
			wsAlignment = L"left";
			break;
			case 1:
			wsAlignment = L"center";
			break;
			case 2:
			wsAlignment = L"right";
			break;
			default:
			wsAlignment = L"center";
			break;
			}
			if(arPars[0]->GetTypeConversion() == TypeConversion::pptx || arPars[0]->GetTypeConversion() == TypeConversion::xlsx)
			{
				wsNodeMath += L" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\"";
				wsNodeMathPara += L" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\"";
				wsAlignment += L"Group";
			}
			m_pXmlWrite->WriteNodeBegin(wsNodeMathPara,false);
			if(iAlignment>= 0 && iAlignment <= 2)
			{
				m_pXmlWrite->WriteNodeBegin(L"m:oMathParaPr",false);
				m_pXmlWrite->WriteNodeBegin(L"m:jc",true);
				m_pXmlWrite->WriteAttribute(L"m:val",wsAlignment);
				m_pXmlWrite->WriteNodeEnd(L"",true,true);
				m_pXmlWrite->WriteNodeEnd(L"m:oMathParaPr",false,false);
			}
			m_pXmlWrite->WriteNodeBegin(wsNodeMath,false);
			for(CElement* oTempElement:arPars)
			{
				if(oTempElement != nullptr)
				{
					if(CParserStarMathString::CheckNewline(oTempElement))
					{
						m_pXmlWrite->WriteNodeBegin(L"m:r",false);
						m_pXmlWrite->WriteNodeBegin(L"w:br",true);
						m_pXmlWrite->WriteNodeEnd(L"",true,true);
						m_pXmlWrite->WriteNodeEnd(L"m:r",false,false);
						m_pXmlWrite->WriteNodeEnd(L"m:oMath",false,false);
						m_pXmlWrite->WriteNodeBegin(L"m:oMath",false);
					}
					else
						oTempElement->ConversionToOOXML(m_pXmlWrite);
				}
			}
		}
		else
		{
			m_pXmlWrite->WriteNodeBegin(L"m:oMathPara",false);
			m_pXmlWrite->WriteNodeBegin(L"m:oMath",false);
		}
		m_pXmlWrite->WriteNodeEnd(L"m:oMath",false,false);
		m_pXmlWrite->WriteNodeEnd(L"m:oMathPara",false,false);
	}
	void CConversionSMtoOOXML::StandartProperties(XmlUtils::CXmlWriter* pXmlWrite,CAttribute* pAttribute,const TypeConversion &enTypeConversion)
	{
		if(TypeConversion::docx == enTypeConversion || TypeConversion::undefine == enTypeConversion)
		{
			if(pAttribute == nullptr)
			{
				pXmlWrite->WriteNodeBegin(L"w:rPr",false);
				pXmlWrite->WriteNodeBegin(L"w:rFonts",true);
				pXmlWrite->WriteAttribute(L"w:hAnsi",L"Cambria Math");
				pXmlWrite->WriteAttribute(L"w:ascii",L"Cambria Math");
				pXmlWrite->WriteNodeEnd(L"w",true,true);
				pXmlWrite->WriteNodeBegin(L"w:sz",true);
				pXmlWrite->WriteAttribute(L"w:val",L"30");
				pXmlWrite->WriteNodeEnd(L"w",true,true);
				pXmlWrite->WriteNodeBegin(L"w:szCs",true);
				pXmlWrite->WriteAttribute(L"w:val",L"30");
				pXmlWrite->WriteNodeEnd(L"w",true,true);
				pXmlWrite->WriteNodeEnd(L"w:rPr",false,false);
			}
			else
			{
				std::wstring wsNameFont = pAttribute->GetFontName();
				pXmlWrite->WriteNodeBegin(L"w:rPr",false);
				pXmlWrite->WriteNodeBegin(L"w:rFonts",true);
				if(!wsNameFont.empty())
				{
					pXmlWrite->WriteAttribute(L"w:hAnsi",wsNameFont);
					pXmlWrite->WriteAttribute(L"w:ascii",wsNameFont);
				}
				else
				{
					pXmlWrite->WriteAttribute(L"w:hAnsi",L"Cambria Math");
					pXmlWrite->WriteAttribute(L"w:ascii",L"Cambria Math");
				}
				pXmlWrite->WriteNodeEnd(L"w",true,true);
				if(pAttribute->GetSize() == 0)
				{
					pXmlWrite->WriteNodeBegin(L"w:sz",true);
					pXmlWrite->WriteAttribute(L"w:val",L"30");
					pXmlWrite->WriteNodeEnd(L"w",true,true);
					pXmlWrite->WriteNodeBegin(L"w:szCs",true);
					pXmlWrite->WriteAttribute(L"w:val",L"30");
					pXmlWrite->WriteNodeEnd(L"w",true,true);
				}
				else if(pAttribute->GetSize() != 0)
				{
					pXmlWrite->WriteNodeBegin(L"w:sz",true);
					pXmlWrite->WriteAttribute(L"w:val",std::to_wstring(pAttribute->GetSize()));
					pXmlWrite->WriteNodeEnd(L"w",true,true);
					pXmlWrite->WriteNodeBegin(L"w:szCs",true);
					pXmlWrite->WriteAttribute(L"w:val",std::to_wstring(pAttribute->GetSize()));
					pXmlWrite->WriteNodeEnd(L"w",true,true);
				}
				if(!pAttribute->EmptyColor())
				{
					pXmlWrite->WriteNodeBegin(L"w:color",true);
					pXmlWrite->WriteAttribute(L"w:val",pAttribute->GetColor());
					pXmlWrite->WriteNodeEnd(L"w",true,true);
				}
				if(pAttribute->GetBold() && pAttribute->GetItal())
				{
					WriteStyNode(pXmlWrite,L"bi");
				}
				else if(pAttribute->GetBold())
				{
					pXmlWrite->WriteNodeBegin(L"m:sty", true);
					pXmlWrite->WriteAttribute(L"m:val",L"b");
					pXmlWrite->WriteNodeEnd(L"w",true,true);
					pXmlWrite->WriteNodeBegin(L"w:b",true);
					pXmlWrite->WriteNodeEnd(L"w",true,true);
					pXmlWrite->WriteNodeBegin(L"w:bCs",true);
					pXmlWrite->WriteNodeEnd(L"w",true,true);
				}
				else if(pAttribute->GetItal())
				{
					pXmlWrite->WriteNodeBegin(L"w:i",true);
					pXmlWrite->WriteNodeEnd(L"w",true,true);
				}
				if(pAttribute->GetStrike())
				{
					pXmlWrite->WriteNodeBegin(L"w:strike",true);
					pXmlWrite->WriteNodeEnd(L"w",true,true);
				}
				pXmlWrite->WriteNodeEnd(L"w:rPr",false,false);
			}
		}
		else if(TypeConversion::pptx == enTypeConversion || TypeConversion::xlsx == enTypeConversion)
		{
			if(pAttribute !=nullptr)
			{
				pXmlWrite->WriteNodeBegin(L"a:rPr",true);
				if(pAttribute->GetSize()!=0)
				{
					int iSize = pAttribute->GetSize();
					iSize = iSize*50;
					pXmlWrite->WriteAttribute(L"sz",iSize);
				}
				else
					pXmlWrite->WriteAttribute(L"sz",L"1500");
				if(pAttribute->GetBold())
					pXmlWrite->WriteAttribute(L"b",L"1");
				if(pAttribute->GetItal())
					pXmlWrite->WriteAttribute(L"i",L"1");
				if(pAttribute->GetStrike())
					pXmlWrite->WriteAttribute(L"strike",L"sngStrike");
				pXmlWrite->WriteAttribute(L"spc", -150);
				pXmlWrite->WriteNodeEnd(L"w",true,false);
				if(!pAttribute->GetColor().empty())
				{
				  pXmlWrite->WriteNodeBegin(L"a:solidFill",false);
				  pXmlWrite->WriteNodeBegin(L"a:srgbClr",true);
				  pXmlWrite->WriteAttribute(L"val",pAttribute->GetColor());
				  pXmlWrite->WriteNodeEnd(L"w",true,true);
				  pXmlWrite->WriteNodeEnd(L"a:solidFill",false,false);
				}
				pXmlWrite->WriteNodeBegin(L"a:latin",true);
				if(!pAttribute->GetFontName().empty())
					pXmlWrite->WriteAttribute(L"typeface",pAttribute->GetFontName());
				else
					pXmlWrite->WriteAttribute(L"typeface",L"Cambria Math");
				pXmlWrite->WriteNodeEnd(L"w",true,true);
				pXmlWrite->WriteNodeEnd(L"a:rPr",false);
			}
			else
			{
				pXmlWrite->WriteNodeBegin(L"a:rPr",true);
				pXmlWrite->WriteAttribute(L"sz",L"1500");
				pXmlWrite->WriteNodeEnd(L"w",true,false);
				pXmlWrite->WriteNodeBegin(L"a:latin",true);
				pXmlWrite->WriteAttribute(L"typeface",L"Cambria Math");
				pXmlWrite->WriteNodeEnd(L"w",true,true);
				pXmlWrite->WriteNodeEnd(L"a:rPr",false);
			}
		}
	}
	void CConversionSMtoOOXML::PropertiesMFPR(const std::wstring &wsType, XmlUtils::CXmlWriter* pXmlWrite, CAttribute* pAttribute, const TypeConversion &enTypeConversion)
	{
		pXmlWrite->WriteNodeBegin(L"m:fPr",false);
		if(!wsType.empty())
		{
			pXmlWrite->WriteNodeBegin(L"m:type",true);
			pXmlWrite->WriteAttribute(L"m:val",wsType);
			pXmlWrite->WriteNodeEnd(L"w",true,true);
		}
		WriteCtrlPrNode(pXmlWrite,pAttribute,enTypeConversion);
		pXmlWrite->WriteNodeEnd(L"m:fPr",false,false);
	}
	void CConversionSMtoOOXML::PropertiesNaryPr(const TypeElement& enTypeOp,bool bEmptySub,bool bEmptySup,XmlUtils::CXmlWriter* pXmlWrite,CAttribute* pAttribute,const TypeConversion &enTypeConversion)
	{
		pXmlWrite->WriteNodeBegin(L"m:naryPr",false);
		switch(enTypeOp)
		{
		case TypeElement::sum:
		{
		WriteChrNode(L"\u2211",pXmlWrite);
		break;
		}
		case TypeElement::prod:
		WriteChrNode(L"\u220F",pXmlWrite);
		break;
		case TypeElement::coprod:
		WriteChrNode(L"\u2210",pXmlWrite);
		break;
		case TypeElement::iint:
		WriteChrNode(L"\u222C",pXmlWrite);
		break;
		case TypeElement::iiint:
		WriteChrNode(L"\u222D",pXmlWrite);
		break;
		case TypeElement::lint:
		WriteChrNode(L"\u222E",pXmlWrite);
		break;
		case TypeElement::llint:
		WriteChrNode(L"\u222F",pXmlWrite);
		break;
		case TypeElement::lllint:
		WriteChrNode(L"\u2230",pXmlWrite);
		break;
		default:
		break;
		}
		WriteLimLocNode(L"undOvr",pXmlWrite);
		if(bEmptySub)
		{
			pXmlWrite->WriteNodeBegin(L"m:subHide",true);
			pXmlWrite->WriteAttribute(L"m:val",L"1");
			pXmlWrite->WriteNodeEnd(L"w",true,true);
		}
		if(bEmptySup)
		{
			pXmlWrite->WriteNodeBegin(L"m:supHide",true);
			pXmlWrite->WriteAttribute(L"m:val",L"1");
			pXmlWrite->WriteNodeEnd(L"w",true,true);
		}
		WriteCtrlPrNode(pXmlWrite,pAttribute,enTypeConversion);
		pXmlWrite->WriteNodeEnd(L"m:naryPr",false,false);
	}
	void CConversionSMtoOOXML::WriteNodeConversion(const std::wstring &wsNameBlock, CElement *pValueBlock,XmlUtils::CXmlWriter* pXmlWrite)
	{
		if(pValueBlock != nullptr)
		{
			pXmlWrite->WriteNodeBegin(wsNameBlock,false);
			pValueBlock->ConversionToOOXML(pXmlWrite);
			pXmlWrite->WriteNodeEnd(wsNameBlock,false,false);
		}
		else
		{
			pXmlWrite->WriteNodeBegin(wsNameBlock,true);
			pXmlWrite->WriteNodeEnd(L"",true,true);
		}
	}
	std::wstring CConversionSMtoOOXML::GetOOXML()
	{
		return m_pXmlWrite->GetXmlString();
	}
	void CConversionSMtoOOXML::EndConversion()
	{
		m_pXmlWrite->WriteNodeEnd(L"m:oMath",false,false);
		m_pXmlWrite->WriteNodeEnd(L"m:oMathPara",false,false);
	}
	void CConversionSMtoOOXML::PropertiesFuncPr(XmlUtils::CXmlWriter* pXmlWrite,CAttribute* pAttribute,const TypeConversion &enTypeConversion)
	{
		pXmlWrite->WriteNodeBegin(L"m:funcPr", false);
		pXmlWrite->WriteNodeBegin(L"m:ctrlPr", false);
		StandartProperties(pXmlWrite,pAttribute,enTypeConversion);
		pXmlWrite->WriteNodeEnd(L"m:ctrlPr", false,false);
		pXmlWrite->WriteNodeEnd(L"m:funcPr",false,false);
	}

	void CConversionSMtoOOXML::PropertiesDPr(XmlUtils::CXmlWriter *pXmlWrite, const std::wstring &wsOpenBracket,const std::wstring &wsCloseBracket, CAttribute* pAttribute, const TypeConversion &enTypeConversion, const TypeElement &enTypeBracket)
	{
		pXmlWrite->WriteNodeBegin(L"m:dPr",false);
		BracketTypeNotation(wsOpenBracket,wsCloseBracket,pXmlWrite);
		pXmlWrite->WriteNodeBegin(L"m:ctrlPr");
		StandartProperties(pXmlWrite,pAttribute,enTypeConversion);
		pXmlWrite->WriteNodeEnd(L"m:ctrlPr",false,false);
		pXmlWrite->WriteNodeEnd(L"m:dPr",false,false);
	}
	void CConversionSMtoOOXML::BracketTypeNotation(const std::wstring &wsOpenBracket, const std::wstring &wsCloseBracket, XmlUtils::CXmlWriter *pXmlWrite)
	{
		if(!wsOpenBracket.empty())
		{
			pXmlWrite->WriteNodeBegin(L"m:begChr", true);
			if(wsOpenBracket == L"none")
				pXmlWrite->WriteAttribute(L"m:val",L"");
			else
				pXmlWrite->WriteAttribute(L"m:val",wsOpenBracket);
			pXmlWrite->WriteNodeEnd(L"w",true,true);
		}
		if(!wsCloseBracket.empty())
		{
			pXmlWrite->WriteNodeBegin(L"m:endChr", true);
			if(wsCloseBracket == L"none")
				pXmlWrite->WriteAttribute(L"m:val",L"");
			else
				pXmlWrite->WriteAttribute(L"m:val", wsCloseBracket);
			pXmlWrite->WriteNodeEnd(L"w",true,true);
		}
	}
	void CConversionSMtoOOXML::PropertiesMPr(XmlUtils::CXmlWriter *pXmlWrite, const TypeElement &enTypeMatrix, CAttribute* pAttribute, const TypeConversion &enTypeConversion, const unsigned int &iDimension)
	{
		pXmlWrite->WriteNodeBegin(L"m:mPr",false);
		pXmlWrite->WriteNodeBegin(L"m:mcs",false);
		pXmlWrite->WriteNodeBegin(L"m:mc",false);
		pXmlWrite->WriteNodeBegin(L"m:mcPr",false);
		pXmlWrite->WriteNodeBegin(L"m:count",true);
		const std::wstring wsNumber = std::to_wstring(iDimension);
		pXmlWrite->WriteAttribute(L"m:val",wsNumber);
		pXmlWrite->WriteNodeEnd(L"w",true,true);
		pXmlWrite->WriteNodeBegin(L"m:mcJc",true);
		pXmlWrite->WriteAttribute(L"m:val",L"center");
		pXmlWrite->WriteNodeEnd(L"w",true,true);
		pXmlWrite->WriteNodeEnd(L"m:mcPr",false,false);
		pXmlWrite->WriteNodeEnd(L"m:mc",false,false);
		pXmlWrite->WriteNodeEnd(L"m:mcs",false,false);
		pXmlWrite->WriteNodeBegin(L"m:ctrlPr",false);
		StandartProperties(pXmlWrite,pAttribute,enTypeConversion);
		pXmlWrite->WriteNodeEnd(L"m:ctrlPr",false,false);
		pXmlWrite->WriteNodeEnd(L"m:mPr",false,false);
	}
	void CConversionSMtoOOXML::NodeGrade(XmlUtils::CXmlWriter *pXmlWrite,CElement* pValueGrade,CAttribute* pAttribute)
	{
		pXmlWrite->WriteNodeBegin(L"m:d",false);
		pXmlWrite->WriteNodeBegin(L"m:dPr",false);
		pXmlWrite->WriteNodeBegin(L"m:begChr",true);
		pXmlWrite->WriteAttribute(L"m:val",L"");
		pXmlWrite->WriteNodeEnd(L"w",true,true);
		pXmlWrite->WriteNodeBegin(L"m:endChr",true);
		pXmlWrite->WriteAttribute(L"m:val",L"\u23AA");
		pXmlWrite->WriteNodeEnd(L"w",true,true);
		pXmlWrite->WriteNodeBegin(L"m:ctrlPr",false);
		StandartProperties(pXmlWrite,pAttribute,pValueGrade->GetTypeConversion());
		pXmlWrite->WriteNodeEnd(L"m:ctrlPr",false);
		pXmlWrite->WriteNodeEnd(L"m:dPr",false,false);
		CConversionSMtoOOXML::WriteNodeConversion(L"m:e",pValueGrade,pXmlWrite);
		pXmlWrite->WriteNodeEnd(L"m:d",false,false);
	}
	void CConversionSMtoOOXML::WriteCtrlPrNode(XmlUtils::CXmlWriter *pXmlWrite, CAttribute *pAttribute,const TypeConversion &enTypeConversion)
	{
		pXmlWrite->WriteNodeBegin(L"m:ctrlPr",false);
		StandartProperties(pXmlWrite,pAttribute,enTypeConversion);
		pXmlWrite->WriteNodeEnd(L"m:ctrlPr",false,false);
	}
	void CConversionSMtoOOXML::WriteChrNode(const std::wstring &wsTypeOp,XmlUtils::CXmlWriter* pXmlWrite)
	{
		pXmlWrite->WriteNodeBegin(L"m:chr",true);
		pXmlWrite->WriteAttribute(L"m:val",wsTypeOp);
		pXmlWrite->WriteNodeEnd(L"w",true,true);
	}
	void CConversionSMtoOOXML::WriteLimLocNode(const std::wstring &wsTypeLimLock,XmlUtils::CXmlWriter* pXmlWrite)
	{
		pXmlWrite->WriteNodeBegin(L"m:limLoc",true);
		pXmlWrite->WriteAttribute(L"m:val",wsTypeLimLock);
		pXmlWrite->WriteNodeEnd(L"w",true,true);
	}
	void CConversionSMtoOOXML::WriteRPrFName(const TypeElement &enTypeOp, XmlUtils::CXmlWriter *pXmlWrite,CAttribute* pAttribute,const std::wstring& wsNameOp,const TypeConversion &enTypeConversion)
	{
		pXmlWrite->WriteNodeBegin(L"m:r",false);
		pXmlWrite->WriteNodeBegin(L"m:rPr",false);
		pXmlWrite->WriteNodeBegin(L"m:sty",true);
		pXmlWrite->WriteAttribute(L"m:val",L"p");
		pXmlWrite->WriteNodeEnd(L"w",true,true);
		pXmlWrite->WriteNodeEnd(L"m:rPr",false,false);
		CConversionSMtoOOXML::StandartProperties(pXmlWrite,pAttribute,enTypeConversion);
		pXmlWrite->WriteNodeBegin(L"m:t",false);
		switch(enTypeOp)
		{
		case TypeElement::lim:
		pXmlWrite->WriteString(L"lim");
		break;
		case TypeElement::liminf:
		pXmlWrite->WriteString(L"lim inf");
		break;
		case TypeElement::limsup:
		pXmlWrite->WriteString(L"lim sup");
		break;
		case TypeElement::oper:
		pXmlWrite->WriteString(wsNameOp);
		break;
		default:
		break;
		}
		pXmlWrite->WriteNodeEnd(L"m:t",false,false);
		pXmlWrite->WriteNodeEnd(L"m:r",false,false);
	}
	void CConversionSMtoOOXML::WriteStyNode(XmlUtils::CXmlWriter *pXmlWrite, const std::wstring &wsAttributeNode)
	{
		pXmlWrite->WriteNodeBegin(L"m:sty", true);
		pXmlWrite->WriteAttribute(L"m:val",wsAttributeNode);
		pXmlWrite->WriteNodeEnd(L"w",true,true);
	}
	void CConversionSMtoOOXML::WritePreserveBlock(XmlUtils::CXmlWriter *pXmlWrite,CAttribute* pAttribute,const TypeConversion &enTypeConversion)
	{
		pXmlWrite->WriteNodeBegin(L"m:r",false);
		StandartProperties(pXmlWrite,pAttribute,enTypeConversion);
		pXmlWrite->WriteNodeBegin(L"m:t",true);
		pXmlWrite->WriteAttribute(L"xml:space",L"preserve");
		pXmlWrite->WriteNodeEnd(L"w",true,false);
		pXmlWrite->WriteNodeEnd(L"m:t",false,false);
		pXmlWrite->WriteNodeEnd(L"m:r",false,false);
	}
	void CConversionSMtoOOXML::WriteLimUpOrLowNode(XmlUtils::CXmlWriter *pXmlWrite, const std::wstring& wsNameNode, CElement* pValue, const TypeElement& enType, CAttribute* pAttribute, const TypeConversion &enTypeConvers, const std::wstring& wsName, CElement* pIndex)
	{
		pXmlWrite->WriteNodeBegin(wsNameNode,false);
		pXmlWrite->WriteNodeBegin(wsNameNode+L"Pr",false);
		CConversionSMtoOOXML::WriteCtrlPrNode(pXmlWrite,nullptr,enTypeConvers);
		pXmlWrite->WriteNodeEnd(wsNameNode+L"Pr",false,false);
		pXmlWrite->WriteNodeBegin(L"m:e",false);
		CConversionSMtoOOXML::WriteRPrFName(enType,pXmlWrite,pAttribute,wsName,enTypeConvers);
		pXmlWrite->WriteNodeEnd(L"m:e",false,false);
		if(pValue!= nullptr && pIndex != nullptr)
		{
			pXmlWrite->WriteNodeBegin(L"m:lim",false);
			pIndex->ConversionToOOXML(pXmlWrite);
			pValue->ConversionToOOXML(pXmlWrite);
			pXmlWrite->WriteNodeEnd(L"m:lim",false,false);
		}
		else if(pValue!=nullptr && pIndex == nullptr)
			WriteNodeConversion(L"m:lim",pValue,pXmlWrite);
		else if(pValue == nullptr && pIndex !=nullptr)
			WriteNodeConversion(L"m:lim",pIndex,pXmlWrite);
		pXmlWrite->WriteNodeEnd(wsNameNode,false,false);
	}
	void CConversionSMtoOOXML::ElementConversion(XmlUtils::CXmlWriter *pXmlWrite, CElement *pElement)
	{
		if(pElement!= nullptr)
			pElement->ConversionToOOXML(pXmlWrite);
	}
}