/*
 * (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 "ReaderClasses.h"

namespace BinDocxRW {

	docRGB::docRGB()
	{
		R = 255;
		G = 255;
		B = 255;
	}
	std::wstring docRGB::ToString()
	{
		return XmlUtils::ToString(R, L"%02X") + XmlUtils::ToString(G, L"%02X") + XmlUtils::ToString(B, L"%02X");
	}

	CThemeColor::CThemeColor()
	{
		Reset();
	}
	void CThemeColor::Reset()
	{
		bShade = false;
		bTint = false;
		bColor = false;
		Auto = false;
	}
	bool CThemeColor::IsNoEmpty()
	{
		return bShade || bTint || bColor || Auto;
	}
	std::wstring CThemeColor::ToStringColor()
	{
		std::wstring sRes;
		if (bColor)
		{
			switch(Color)
			{
			case 0: sRes = _T("accent1");break;
			case 1: sRes = _T("accent2");break;
			case 2: sRes = _T("accent3");break;
			case 3: sRes = _T("accent4");break;
			case 4: sRes = _T("accent5");break;
			case 5: sRes = _T("accent6");break;
			case 6: sRes = _T("background1");break;
			case 7: sRes = _T("background2");break;
			case 8: sRes = _T("dark1");break;
			case 9: sRes = _T("dark2");break;
			case 10: sRes = _T("followedHyperlink");break;
			case 11: sRes = _T("hyperlink");break;
			case 12: sRes = _T("light1");break;
			case 13: sRes = _T("light2");break;
			case 14: sRes = _T("none");break;
			case 15: sRes = _T("text1");break;
			case 16: sRes = _T("text2");break;
			default : sRes = _T("none");break;
			}
		}
		return sRes;
	}
	std::wstring CThemeColor::ToStringTint()
	{
		std::wstring sRes;
		if (bTint)
		{
			sRes = XmlUtils::ToString(Tint, L"%02X");
		}
		return sRes;
	}
	std::wstring CThemeColor::ToStringShade()
	{
		std::wstring sRes;
		if (bShade)
		{
			sRes = XmlUtils::ToString(Shade, L"%02X");
		}
		return sRes;
	}
	void CThemeColor::ToCThemeColor( nullable<SimpleTypes::CHexColor>& oColor,
												nullable<SimpleTypes::CThemeColor>& oThemeColor,
												nullable<SimpleTypes::CUcharHexNumber>& oThemeTint,
												nullable<SimpleTypes::CUcharHexNumber>& oThemeShade)
	{
		if (Auto)
		{
			if (!oColor.IsInit())
				oColor.Init();
			oColor->SetValue(SimpleTypes::hexcolorAuto);
		}
		if (bColor)
		{
			oThemeColor.Init();
			oThemeColor->SetValue((SimpleTypes::EThemeColor)Color);
		}
		if (bTint)
		{
			oThemeTint.Init();
			oThemeTint->SetValue(Tint);
		}
		if (bShade)
		{
			oThemeShade.Init();
			oThemeShade->SetValue(Shade);
		}
	}


	Background::Background() : bColor (false), bThemeColor(false) {}
	std::wstring Background::Write()
	{
		std::wstring sBackground =  L"<w:background";

		if (bColor)
		{
		   sBackground += L" w:color=\"" + Color.ToString() + L"\"";
		}

		if (bThemeColor && ThemeColor.IsNoEmpty())
		{
			if (ThemeColor.bColor)
				sBackground += L" w:themeColor=\"" + ThemeColor.ToStringColor() + L"\"";
			if (ThemeColor.bTint)
				sBackground += L" w:themeTint=\"" + ThemeColor.ToStringTint() + L"\"";
			if (ThemeColor.bShade)
				sBackground += L" w:themeShade=\"" + ThemeColor.ToStringShade() + L"\"";
		}

		if (!bColor && !bThemeColor)
		{
			sBackground += L" w:color=\"ffffff\"";
		}
		sBackground += L">";

		sBackground += sObject;

		sBackground += L"</w:background>";
		return sBackground;
	}

	docStyle::docStyle()
	{
		byteType = styletype_Paragraph;
		bDefault = false;
		bCustom = false;

		bqFormat = false;
		buiPriority = false;
		bhidden = false;
		bsemiHidden = false;
		bunhideWhenUsed = false;
		bautoRedefine = false;
		blocked = false;
		bpersonal = false;
		bpersonalCompose = false;
		bpersonalReply = false;
	}
	void docStyle::Write(NSStringUtils::CStringBuilder*  pCStringWriter)
	{
		std::wstring sType;
		switch(byteType)
		{
			case styletype_Character: sType = _T("character");break;
			case styletype_Numbering: sType = _T("numbering");break;
			case styletype_Table: sType = _T("table");break;
			default: sType = _T("paragraph");break;
		}
		if (!Id.empty())
		{
			std::wstring sStyle = L"<w:style w:type=\"" + sType + L"\" w:styleId=\"" + Id + L"\"";
			if (bDefault)
			{
				if (Default)
					sStyle += L" w:default=\"1\"";
				else
					sStyle += L" w:default=\"0\"";
			}
			if (bCustom)
			{
				if (Custom)
					sStyle += L" w:customStyle=\"1\"";
				else
					sStyle += L" w:customStyle=\"0\"";
			}

			sStyle += L">";
			pCStringWriter->WriteString(sStyle);

			if (!Name.empty())
			{
				pCStringWriter->WriteString(L"<w:name w:val=\"" + Name + L"\"/>");
			}
			if (!Aliases.empty())
			{
				pCStringWriter->WriteString(L"<w:aliases w:val=\"");
				pCStringWriter->WriteEncodeXmlString(Aliases);
				pCStringWriter->WriteString(L"\"/>");
			}
			if (!BasedOn.empty())
			{
				pCStringWriter->WriteString(L"<w:basedOn w:val=\"" + BasedOn + L"\"/>");
			}
			if (!NextId.empty())
			{
				pCStringWriter->WriteString(L"<w:next w:val=\"" + NextId + L"\"/>");
			}
			if (!Link.empty())
			{
				pCStringWriter->WriteString(L"<w:link w:val=\"");
				pCStringWriter->WriteEncodeXmlString(Link);
				pCStringWriter->WriteString(L"\"/>");
			}
			if (bautoRedefine)
			{
				if (autoRedefine)
					pCStringWriter->WriteString(L"<w:autoRedefine/>");
				else
					pCStringWriter->WriteString(L"<w:autoRedefine val=\"false\"/>");
			}
			if (bhidden)
			{
				if (hidden)
					pCStringWriter->WriteString(L"<w:hidden/>");
				else
					pCStringWriter->WriteString(L"<w:hidden val=\"false\"/>");
			}
			if (buiPriority)
			{
				pCStringWriter->WriteString(L"<w:uiPriority w:val=\"" + std::to_wstring(uiPriority) + L"\"/>");
			}
			if (bsemiHidden)
			{
				if (semiHidden)
					pCStringWriter->WriteString(L"<w:semiHidden/>");
				else
					pCStringWriter->WriteString(L"<w:semiHidden val=\"false\"/>");
			}
			if (bunhideWhenUsed)
			{
				if (unhideWhenUsed)
					pCStringWriter->WriteString(L"<w:unhideWhenUsed/>");
				else
					pCStringWriter->WriteString(L"<w:unhideWhenUsed val=\"false\"/>");
			}
			if (bqFormat)
			{
				if (qFormat)
					pCStringWriter->WriteString(L"<w:qFormat/>");
				else
					pCStringWriter->WriteString(L"<w:qFormat val=\"false\"/>");
			}
			if (blocked)
			{
				if (locked)
					pCStringWriter->WriteString(L"<w:locked/>");
				else
					pCStringWriter->WriteString(L"<w:locked val=\"false\"/>");
			}
			if (bpersonal)
			{
				if (personal)
					pCStringWriter->WriteString(L"<w:personal/>");
				else
					pCStringWriter->WriteString(L"<w:personal val=\"false\"/>");
			}
			if (bpersonalCompose)
			{
				if (personalCompose)
					pCStringWriter->WriteString(L"<w:personalCompose/>");
				else
					pCStringWriter->WriteString(L"<w:personalCompose val=\"false\"/>");
			}
			if (bpersonalReply)
			{
				if (personalReply)
					pCStringWriter->WriteString(L"<w:personalReply/>");
				else
					pCStringWriter->WriteString(L"<w:personalReply val=\"false\"/>");
			}
			if (!ParaPr.empty())
			{
				pCStringWriter->WriteString(ParaPr);
			}
			if (!TextPr.empty())
			{
				pCStringWriter->WriteString(TextPr);
			}
			if (!TablePr.empty())
			{
				pCStringWriter->WriteString(TablePr);
			}
			if (!RowPr.empty())
			{
				pCStringWriter->WriteString(L"<w:trPr>");
				pCStringWriter->WriteString(RowPr);
				pCStringWriter->WriteString(L"</w:trPr>");
			}
			if (!CellPr.empty())
			{
				pCStringWriter->WriteString(L"<w:tcPr>");
				pCStringWriter->WriteString(CellPr);
				pCStringWriter->WriteString(L"</w:tcPr>");
			}
			for(_INT32 i = 0, length = (_INT32)TblStylePr.size(); i < length; ++i)
			{
				pCStringWriter->WriteString(TblStylePr[i]);
			}
			pCStringWriter->WriteString(L"</w:style>");
		}
	}

	tblStylePr::tblStylePr()
	{
		bType = false;
	}

	PaddingsToWrite::PaddingsToWrite()
	{
		bLeft = false;
		bTop = false;
		bRight = false;
		bBottom = false;
	}

	PaddingsToWriteMM::PaddingsToWriteMM()
	{
		bLeft = false;
		bTop = false;
		bRight = false;
		bBottom = false;
	}

	docImg::docImg(_INT32 nDocPr)
	{
		m_nDocPr = nDocPr;
		bMediaId = false;
		bType = false;
		bX = false;
		bY = false;
		bWidth = false;
		bHeight = false;
		bPaddings = false;
	}
	void docImg::Write(NSStringUtils::CStringBuilder*  pCStringWriter)
	{
		if (bType)
		{
			if (c_oAscWrapStyle::Inline == Type)
			{
				if (bWidth && bHeight)
				{
					_INT64 nWidth = (_INT64)(g_dKoef_mm_to_emu * Width);
					_INT64 nHeight = (_INT64)(g_dKoef_mm_to_emu * Height);
					std::wstring sDrawing = L"<w:drawing><wp:inline distT=\"0\" distB=\"0\" distL=\"0\" distR=\"0\"><wp:extent cx=\"" +
							std::to_wstring(nWidth) + L"\" cy=\"" + std::to_wstring(nHeight) + L"\"/><wp:effectExtent l=\"0\" t=\"0\" r=\"0\" b=\"0\"/><wp:docPr id=\"" +
							std::to_wstring(m_nDocPr) + L"\" name=\"Image\"/><wp:cNvGraphicFramePr><a:graphicFrameLocks xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" noChangeAspect=\"1\"/></wp:cNvGraphicFramePr><a:graphic xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\"><a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/picture\"><pic:pic xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\"><pic:nvPicPr><pic:cNvPr id=\"0\" name=\"Image\"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed=\"" +
							srId + L"\"><a:extLst><a:ext uri=\"{28A0092B-C50C-407E-A947-70E740481C1C}\"><a14:useLocalDpi xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" val=\"0\"/></a:ext></a:extLst></a:blip><a:stretch><a:fillRect/></a:stretch></pic:blipFill><pic:spPr><a:xfrm><a:off x=\"0\" y=\"0\"/><a:ext cx=\"" +
							std::to_wstring(nWidth) + L"\" cy=\"" + std::to_wstring(nHeight) + L"\"/></a:xfrm><a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing>";
					pCStringWriter->WriteString(sDrawing);
				}
			}
			else if (c_oAscWrapStyle::Flow == Type)
			{
				if (bX && bY && bWidth && bHeight)
				{
					_INT64 nX = (_INT64)(g_dKoef_mm_to_emu * X);
					_INT64 nY = (_INT64)(g_dKoef_mm_to_emu * Y);
					_INT64 nWidth = (_INT64)(g_dKoef_mm_to_emu * Width);
					_INT64 nHeight = (_INT64)(g_dKoef_mm_to_emu * Height);
					_UINT32 nPaddingLeft = 0;
					_UINT32 nPaddingTop = 0;
					_UINT32 nPaddingRight = 0;
					_UINT32 nPaddingBottom = 0;
					if (bPaddings)
					{
						if (Paddings.bLeft)		nPaddingLeft	= (_UINT32)(g_dKoef_mm_to_emu * Paddings.Left);
						if (Paddings.bTop)		nPaddingTop		= (_UINT32)(g_dKoef_mm_to_emu * Paddings.Top);
						if (Paddings.bRight)		nPaddingRight	= (_UINT32)(g_dKoef_mm_to_emu * Paddings.Right);
						if (Paddings.bBottom)	nPaddingBottom	= (_UINT32)(g_dKoef_mm_to_emu * Paddings.Bottom);

					}
					std::wstring sDrawing = L"<w:drawing><wp:anchor distT=\"" + std::to_wstring(nPaddingTop) + L"\" distB=\"" + std::to_wstring(nPaddingBottom)
							+ L"\" distL=\"" + std::to_wstring(nPaddingLeft) + L"\" distR=\"" + std::to_wstring(nPaddingRight)
							+ L"\" simplePos=\"0\" relativeHeight=\"1\" behindDoc=\"0\" locked=\"0\" layoutInCell=\"1\" allowOverlap=\"1\"><wp:simplePos x=\"0\" y=\"0\"/><wp:positionH relativeFrom=\"page\"><wp:posOffset>"
							+ std::to_wstring(nX) + L"</wp:posOffset></wp:positionH><wp:positionV relativeFrom=\"page\"><wp:posOffset>"
							+ std::to_wstring(nY) + L"</wp:posOffset></wp:positionV><wp:extent cx=\"" + std::to_wstring(nWidth) + L"\" cy=\"" + std::to_wstring(nHeight)
							+ L"\"/><wp:effectExtent l=\"0\" t=\"0\" r=\"0\" b=\"0\"/><wp:wrapSquare wrapText=\"bothSides\"/><wp:docPr id=\""
							+ std::to_wstring(m_nDocPr) + L"\" name=\"Image\"/><wp:cNvGraphicFramePr><a:graphicFrameLocks xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" noChangeAspect=\"1\"/>\
</wp:cNvGraphicFramePr><a:graphic xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\"><a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/picture\"><pic:pic xmlns:pic=\"http://schemas.openxmlformats.org/drawingml/2006/picture\"><pic:nvPicPr><pic:cNvPr id=\"0\" name=\"Image\"/><pic:cNvPicPr/></pic:nvPicPr><pic:blipFill><a:blip r:embed=\""
							+ srId + L"\"><a:extLst><a:ext uri=\"{28A0092B-C50C-407E-A947-70E740481C1C}\"><a14:useLocalDpi xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" val=\"0\"/></a:ext></a:extLst></a:blip><a:stretch><a:fillRect/></a:stretch></pic:blipFill>\
<pic:spPr><a:xfrm><a:off x=\"0\" y=\"0\"/><a:ext cx=\"" + std::to_wstring(nWidth) + L"\" cy=\"" + std::to_wstring(nHeight) + L"\"/></a:xfrm><a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom></pic:spPr></pic:pic></a:graphicData></a:graphic></wp:anchor></w:drawing>";

					pCStringWriter->WriteString(sDrawing);
				}
			}
		}
	}

	docW::docW()
	{
		bType = false;
		bW = false;
		bWDocx = false;
	}
	void docW::Write(NSStringUtils::CStringBuilder& pCStringWriter, const std::wstring& sName)
	{
		pCStringWriter.WriteString(Write(sName));
	}
	std::wstring docW::Write(const std::wstring& sName)
	{
		std::wstring sXml;
		if (bW || (bType && bWDocx))
		{
			std::wstring sType;
			_INT32 nVal;
			if (bW)
			{
				sType = _T("dxa");
				nVal = SerializeCommon::Round( g_dKoef_mm_to_twips * W);
			}
			else
			{
				switch(Type)
				{
				case 0: sType = _T("auto"); break;
				case 1: sType = _T("dxa");  break;
				case 2: sType = _T("nil");  break;
				case 3: sType = _T("pct");  break;
				}
				nVal = WDocx;
			}
			sXml = L"<" + sName + L" w:w=\"" + std::to_wstring(nVal) + L"\" w:type=\"" + sType + L"\"/>";
		}
		return sXml;
	}

	rowPrAfterBefore::rowPrAfterBefore(std::wstring name)
	{
		sName = name;
		bGridAfter = false;
	}
	void rowPrAfterBefore::Write(NSStringUtils::CStringBuilder& writer)
	{
		if (bGridAfter && nGridAfter > 0)
		{
			writer.WriteString(L"<w:grid" + sName + L" w:val=\"" + std::to_wstring(nGridAfter) + L"\"/>");
		}
		if (oAfterWidth.bW)
			oAfterWidth.Write(writer, _T("w:w") + sName);
	}

	WriteHyperlink* WriteHyperlink::Parse(std::wstring fld)
	{
		WriteHyperlink* res = NULL;
		if (-1 != fld.find(L"HYPERLINK"))
		{
			std::wstring sLink;
			std::wstring sTooltip;
			bool bNextLink = false;
			bool bNextTooltip = false;
			//разбиваем по пробелам, но с учетом кавычек
			std::vector<std::wstring> aItems;
			std::wstring sCurItem;
			bool bDQuot = false;

			for(size_t i = 0, length = fld.length(); i < length; ++i)
			{
				wchar_t sCurLetter = fld[i];
				if ('\"' == sCurLetter)
					bDQuot = !bDQuot;
				else if ('\\' == sCurLetter && true == bDQuot && i + 1 < length && '\"' == fld[i + 1])
				{
					i++;
					sCurItem += fld[i];
				}
				else if (' ' == sCurLetter && false == bDQuot)
				{
					if (sCurItem.length() > 0)
					{
						aItems.push_back(sCurItem);
						sCurItem = _T("");
					}
				}
				else
					sCurItem += sCurLetter;
			}
			if (sCurItem.length() > 0)
				aItems.push_back(sCurItem);

			for(size_t i = 0, length = aItems.size(); i < length; ++i)
			{
				std::wstring item = aItems[i];
				if (bNextLink)
				{
					bNextLink = false;
					sLink = item;
				}
				if (bNextTooltip)
				{
					bNextTooltip = false;
					sTooltip = item;
				}

				if (L"HYPERLINK" == item)
					bNextLink = true;
				else if (L"\\o" == item)
					bNextTooltip = true;
			}
			if (false == sLink.empty())
			{
				res = new WriteHyperlink();
				boost::algorithm::trim(sLink);

				_INT32 nAnchorIndex = (_INT32)sLink.find(L"#");
				if (-1 != nAnchorIndex)
				{
					res->href   = sLink.substr(0, nAnchorIndex);
					res->anchor = sLink.substr(nAnchorIndex);
				}
				else
					res->href = sLink;
				if (false == sTooltip.empty())
				{
					res->tooltip = boost::algorithm::trim_copy(sTooltip);
				}
			}
		}
		return res;
	}
	void WriteHyperlink::Write(NSStringUtils::CStringBuilder& wr)
	{
		if (false == rId.empty())
		{
			std::wstring sCorrect_rId = XmlUtils::EncodeXmlString(rId);
			std::wstring sCorrect_tooltip = XmlUtils::EncodeXmlString(tooltip);
			std::wstring sCorrect_anchor = XmlUtils::EncodeXmlString(anchor);
			std::wstring sStart = L"<w:hyperlink r:id=\"" + sCorrect_rId + L"\"";

			if (false == tooltip.empty())
			{
				sStart += L" w:tooltip=\"";
				sStart += sCorrect_tooltip;
				sStart += L"\"";
			}
			if (false == anchor.empty())
			{
				sStart += L" w:anchor=\"";
				sStart += sCorrect_anchor;
				sStart += L"\"";
			}
			sStart += L" w:history=\"1\">";
			wr.WriteString(sStart);
			wr.Write(writer);
			wr.WriteString(L"</w:hyperlink>");
		}
	}

	IdCounter::IdCounter(_INT32 nStart)
	{
		m_nId = nStart;
	}
	_INT32 IdCounter::getNextId(_INT32 nCount)
	{
		_INT32 nRes = m_nId;
		m_nId += nCount;
		return nRes;
	}
	_INT32 IdCounter::getCurrentId()
	{
		return m_nId;
	}

	CComment::CComment(IdCounter& oParaIdCounter, IdCounter& oFormatIdCounter) : m_oParaIdCounter(oParaIdCounter),m_oFormatIdCounter(oFormatIdCounter)
	{
		bIdOpen = false;
		bIdFormat = false;
		bSolved = false;
		bDurableId = false;
	}
	CComment::~CComment()
	{
		for(size_t i = 0; i <replies.size(); ++i)
		{
			delete replies[i];
		}
		replies.clear();
	}
	_INT32 CComment::getCount()
	{
		return (_INT32)replies.size() + 1;
	}
	void CComment::setFormatStart(_INT32 IdFormatStart)
	{
		bIdFormat = true;
		IdFormat = IdFormatStart;

		for(size_t i = 0; i < replies.size(); ++i)
		{
			CComment* pComment	= replies[i];
			pComment->bIdFormat = true;
			pComment->IdFormat	= (_INT32)(IdFormatStart + i + 1);
		}
	}
	std::wstring CComment::writeRef(const std::wstring& sBefore, const std::wstring& sRef, const std::wstring& sAfter)
	{
		std::wstring sRes;
		sRes += (writeRef(this, sBefore, sRef, sAfter));

		for(size_t i = 0; i< replies.size(); ++i)
		{
			sRes += (writeRef(replies[i], sBefore, sRef, sAfter));
		}
		return sRes;
	}
	std::wstring CComment::writeRef(CComment* pComment, const std::wstring& sBefore, const std::wstring& sRef, const std::wstring& sAfter)
	{
		std::wstring sRes;
		if (!pComment->bIdFormat)
		{
			pComment->bIdFormat = true;
			pComment->IdFormat = pComment->m_oFormatIdCounter.getNextId();
		}
		sRes += (sBefore);
		sRes += L"<" + sRef + L" w:id=\"" + std::to_wstring(pComment->IdFormat) + L"\"/>";
		sRes += (sAfter);
		return sRes;
	}
	void CComment::writeContentWritePart(CComment* pComment, std::wstring& sText, _INT32 nPrevIndex, _INT32 nCurIndex, std::wstring& sRes)
	{
		std::wstring sPart;
		if (nPrevIndex < nCurIndex)
			sPart = XmlUtils::EncodeXmlString(sText.substr(nPrevIndex, nCurIndex - nPrevIndex));

		_INT32 nId = pComment->m_oParaIdCounter.getNextId();

		pComment->sParaId = XmlUtils::ToString(nId, L"%08X");
		sRes += L"<w:p w14:paraId=\"" + pComment->sParaId + L"\" w14:textId=\"" + pComment->sParaId + L"\">";
		sRes += L"<w:pPr><w:spacing w:line=\"240\" w:after=\"0\" w:lineRule=\"auto\" w:before=\"0\"/><w:ind w:firstLine=\"0\" w:left=\"0\" w:right=\"0\"/><w:jc w:val=\"left\"/></w:pPr><w:r><w:rPr><w:rFonts w:eastAsia=\"Arial\" w:ascii=\"Arial\" w:hAnsi=\"Arial\" w:cs=\"Arial\"/><w:sz w:val=\"22\"/></w:rPr><w:t xml:space=\"preserve\">";
		sRes += sPart;
		sRes += L"</w:t></w:r></w:p>";
	}
	std::wstring CComment::writeContent(CComment* pComment)
	{
		std::wstring sRes;
		if (!pComment->bIdFormat)
		{
			pComment->bIdFormat = true;
			pComment->IdFormat = pComment->m_oFormatIdCounter.getNextId();
		}
		sRes += L"<w:comment w:id=\"" + std::to_wstring(pComment->IdFormat) + L"\"";
		if (false == pComment->UserName.empty())
		{
			std::wstring sUserName = XmlUtils::EncodeXmlString(pComment->UserName);
			sRes += L" w:author=\"";
			sRes += XmlUtils::EncodeXmlString(sUserName);
			sRes += L"\"";
		}
		if (false == pComment->Date.empty())
		{
			std::wstring sDate = XmlUtils::EncodeXmlString(pComment->Date);
			sRes += L" w:date=\"";
			sRes += sDate;
			sRes += L"\"";
		}
		if (false == pComment->Initials.empty())
		{
			sRes += L" w:initials=\"";
			sRes += XmlUtils::EncodeXmlString(pComment->Initials);
			sRes += L"\"";
		}
		sRes += L">";

		if (false == pComment->sContent.empty())
		{
			sRes += pComment->sContent;
		}
		else
		{
	//old comments
			std::wstring sText = pComment->Text;

			XmlUtils::replace_all(sText, L"\r", L"");

			_INT32 nPrevIndex = 0;
			for (size_t i = 0; i < sText.length(); i++)
			{
				wchar_t cToken = sText[i];
				if ('\n' == cToken)
				{
					writeContentWritePart(pComment, sText, nPrevIndex, i, sRes);
					nPrevIndex = i + 1;
				}
			}
			writeContentWritePart(pComment, sText, nPrevIndex, (_INT32)sText.length(), sRes);
		}
		sRes += L"</w:comment>";
		return sRes;
	}
	std::wstring CComment::writeContentExt(CComment* pComment)
	{
		std::wstring sRes;
		if (false == pComment->sParaId.empty())
		{
			std::wstring sDone(L"0");
			if (pComment->bSolved && pComment->Solved)
				sDone = _T("1");
			if (!pComment->sParaIdParent.empty())
				sRes += L"<w15:commentEx w15:paraId=\"" + pComment->sParaId + L"\" \
w15:paraIdParent=\"" + pComment->sParaIdParent + L"\" w15:done=\"" + sDone + L"\"/>";
			else
				sRes += L"<w15:commentEx w15:paraId=\"" + pComment->sParaId + L"\" w15:done=\"" + sDone + L"\"/>";
			//расставляем paraIdParent
			for(size_t i = 0; i < pComment->replies.size(); i++)
				pComment->replies[i]->sParaIdParent = pComment->sParaId;
		}
		return sRes;
	}
	std::wstring CComment::writeContentExtensible(CComment* pComment)
	{
		std::wstring sRes;
		if (pComment->bDurableId && !pComment->DateUtc.empty())
		{
			sRes += L"<w16cex:commentExtensible w16cex:durableId=\"" + XmlUtils::ToString(pComment->DurableId, L"%08X") + L"\" w16cex:dateUtc=\"" + pComment->DateUtc + L"\"/>";
		}
		return sRes;
	}
	std::wstring CComment::writeContentUserData(CComment* pComment)
	{
		std::wstring sRes;
		if (pComment->bDurableId && !pComment->UserData.empty())
		{
			sRes += L"<w16cex:commentExtensible w16cex:durableId=\"" + XmlUtils::ToString(pComment->DurableId, L"%08X") + L"\">";
			sRes += L"<w16cex:extLst><w16cex:ext uri=\"{19B8F6BF-5375-455C-9EA6-DF929625EA0E}\"><p15:presenceInfo xmlns:p15=\"http://schemas.microsoft.com/office/powerpoint/2012/main\" userId=\"";
			sRes += XmlUtils::EncodeXmlStringExtend(pComment->UserData);
			sRes += L"\" providerId=\"AD\"/></w16cex:ext></w16cex:extLst></w16cex:commentExtensible>";
		}
		return sRes;
	}
	std::wstring CComment::writeContentsIds(CComment* pComment)
	{
		std::wstring sRes;
		if (!pComment->sParaId.empty() && pComment->bDurableId)
		{
			sRes += L"<w16cid:commentId w16cid:paraId=\"" + pComment->sParaId + L"\" w16cid:durableId=\"" + XmlUtils::ToString(pComment->DurableId, L"%08X") + L"\"/>";
		}
		return sRes;
	}
	std::wstring CComment::writePeople(CComment* pComment)
	{
		std::wstring sRes;
		if (false == pComment->UserName.empty())
		{
			sRes += L"<w15:person w15:author=\"";
			sRes += XmlUtils::EncodeXmlString(pComment->UserName);
			sRes += L"\">";
			if (!pComment->ProviderId.empty() && !pComment->UserId.empty())
			{
				sRes += L"<w15:presenceInfo w15:providerId=\"";
				sRes += XmlUtils::EncodeXmlString(pComment->ProviderId);
				sRes += L"\" w15:userId=\"";
				sRes += XmlUtils::EncodeXmlString(pComment->UserId);
				sRes += L"\"/>";
			}
			sRes += L"</w15:person>";
		}
		return sRes;
	}

	CComments::CComments() : m_oParaIdCounter(1)
	{
	}
	CComments::~CComments()
	{
		for (boost::unordered_map<_INT32, CComment*>::const_iterator it = m_mapComments.begin(); it != m_mapComments.end(); ++it)
		{
			delete it->second;
		}
		m_mapComments.clear();
	}
	void CComments::add(CComment* pComment)
	{
		if (pComment->bIdOpen)
		{
			m_mapComments[pComment->IdOpen] = pComment;
			addAuthor(pComment);
			for(size_t i = 0; i < pComment->replies.size(); i++)
				addAuthor(pComment->replies[i]);
		}
	}
	void CComments::addAuthor(CComment* pComment)
	{
		if (false == pComment->UserName.empty() && false == pComment->UserId.empty())
			m_mapAuthors[pComment->UserName] = pComment;
	}
	CComment* CComments::get(_INT32 nInd)
	{
		CComment* pRes = NULL;
		boost::unordered_map<_INT32, CComment*>::const_iterator pair = m_mapComments.find(nInd);
		if (m_mapComments.end() != pair)
			pRes = pair->second;
		return pRes;
	}
	_INT32 CComments::getNextId(_INT32 nCount)
	{
		return m_oFormatIdCounter.getNextId(nCount);
	}
	std::wstring CComments::writeContent()
	{
		std::wstring sRes;
		for (boost::unordered_map<_INT32, CComment*>::const_iterator it = m_mapComments.begin(); it != m_mapComments.end(); ++it)
		{
			sRes += CComment::writeContent(it->second);
			for(size_t i = 0; i < it->second->replies.size(); ++i)
				sRes += CComment::writeContent(it->second->replies[i]);
		}
		return sRes;
	}
	std::wstring CComments::writeContentExt()
	{
		std::wstring sRes;
		for (boost::unordered_map<_INT32, CComment*>::const_iterator it = m_mapComments.begin(); it != m_mapComments.end(); ++it)
		{
			sRes += CComment::writeContentExt(it->second);
			for(size_t i = 0; i < it->second->replies.size(); ++i)
				sRes += CComment::writeContentExt(it->second->replies[i]);
		}
		return sRes;
	}
	std::wstring CComments::writeContentExtensible()
	{
		std::wstring sRes;
		for (boost::unordered_map<_INT32, CComment*>::const_iterator it = m_mapComments.begin(); it != m_mapComments.end(); ++it)
		{
			sRes += CComment::writeContentExtensible(it->second);
			for(size_t i = 0; i < it->second->replies.size(); ++i)
				sRes += CComment::writeContentExtensible(it->second->replies[i]);
		}
		return sRes;
	}
	std::wstring CComments::writeContentUserData()
	{
		std::wstring sRes;
		for (boost::unordered_map<_INT32, CComment*>::const_iterator it = m_mapComments.begin(); it != m_mapComments.end(); ++it)
		{
			sRes += CComment::writeContentUserData(it->second);
			for(size_t i = 0; i < it->second->replies.size(); ++i)
				sRes += CComment::writeContentUserData(it->second->replies[i]);
		}
		return sRes;
	}
	std::wstring CComments::writeContentsIds()
	{
		std::wstring sRes;
		for (boost::unordered_map<_INT32, CComment*>::const_iterator it = m_mapComments.begin(); it != m_mapComments.end(); ++it)
		{
			sRes += CComment::writeContentsIds(it->second);
			for(size_t i = 0; i < it->second->replies.size(); ++i)
				sRes += CComment::writeContentsIds(it->second->replies[i]);
		}
		return sRes;
	}
	std::wstring CComments::writePeople()
	{
		std::wstring sRes;
		for (boost::unordered_map<std::wstring, CComment*>::const_iterator it = m_mapAuthors.begin(); it != m_mapAuthors.end(); ++it)
		{
			sRes += (it->second->writePeople(it->second));
		}
		return sRes;
	}

	CDrawingPropertyWrapPoint::CDrawingPropertyWrapPoint()
	{
		bX = false;
		bY = false;
	}

	CDrawingPropertyWrap::CDrawingPropertyWrap()
	{
		bWrappingType = false;
		bEdited = false;
		bStart = false;
	}
	CDrawingPropertyWrap::~CDrawingPropertyWrap()
	{
		for(size_t i = 0; i < Points.size(); ++i)
			delete Points[i];
		Points.clear();
	}

	CDrawingProperty::CDrawingProperty(_INT32 nDocPr)
	{
		m_nDocPr    = nDocPr;

		bObject		= false;
		nObjectType	= 0;
		nObjectId	= 0;
		bDataPos    = false;
		bDataLength = false;
		bType       = false;
		bBehindDoc  = false;
		bDistL      = false;
		bDistT      = false;
		bDistR      = false;
		bDistB      = false;
		bLayoutInCell   = false;
		bRelativeHeight = false;
		bBSimplePos     = false;
		bEffectExtentL  = false;
		bEffectExtentT  = false;
		bEffectExtentR  = false;
		bEffectExtentB  = false;
		bWidth          = false;
		bHeight         = false;
		bPositionHRelativeFrom = false;
		bPositionHAlign     = false;
		bPositionHPosOffset = false;
		bPositionHPctOffset = false;
		bPositionVRelativeFrom = false;
		bPositionVAlign     = false;
		bPositionVPosOffset = false;
		bPositionVPctOffset = false;
		bSimplePosX         = false;
		bSimplePosY         = false;
		bDrawingPropertyWrap = false;
	}
	bool CDrawingProperty::IsGraphicFrameContent()
	{
		return false == sGraphicFrameContent.empty();
	}
	std::wstring CDrawingProperty::Write()
	{
		if (!bType) return L"";

		std::wstring sXml;

		bool bGraphicFrameContent = IsGraphicFrameContent();

		if (c_oAscWrapStyle::Inline == Type)
		{
			if (bWidth && bHeight)
			{
				if (bGraphicFrameContent)
				{
					sXml += L"<w:drawing><wp:inline distT=\"0\" distB=\"0\" distL=\"0\" distR=\"0\">\
<wp:extent cx=\"" + std::to_wstring(Width) + L"\" cy=\"" + std::to_wstring(Height) + L"\"/>";
				}
				else
				{
					sXml += L"<wp:inline \
xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" \
distT=\"0\" distB=\"0\" distL=\"0\" distR=\"0\"><wp:extent cx=\"" + std::to_wstring(Width) + L"\" cy=\"" + std::to_wstring(Height) + L"\"/>";
				}

				if (bEffectExtentL && bEffectExtentT && bEffectExtentR && bEffectExtentB)
				{
					sXml += L"<wp:effectExtent l=\"" + std::to_wstring(EffectExtentL) + L"\" t=\"" + std::to_wstring(EffectExtentT) +
							 L"\" r=\"" + std::to_wstring(EffectExtentR) + L"\" b=\"" + std::to_wstring(EffectExtentB) + L"\"/>";
				}

				if (!sDocPr.empty())
				{
					sXml += sDocPr;
				}
				else
				{
					sXml += L"<wp:docPr id=\"" + std::to_wstring(m_nDocPr) + L"\" name=\"\"/>";
				}
				if (!sGraphicFramePr.empty())
				{
					sXml += sGraphicFramePr;
				}
				else
				{
					sXml += L"<wp:cNvGraphicFramePr/>";
				}
				if (bGraphicFrameContent)
				{
					sXml += sGraphicFrameContent + L"</wp:inline></w:drawing>";
				}
				else
				{
					sXml += L"</wp:inline>";
				}
			}
		}
		else
		{
			if (bWidth && bHeight	&& ((bPositionHRelativeFrom && (bPositionHAlign || bPositionHPosOffset || bPositionHPctOffset)
										 && bPositionVRelativeFrom && (bPositionVAlign || bPositionVPosOffset || bPositionVPctOffset))
										|| (bBSimplePos && bSimplePosX && bSimplePosY)))
			{
				_INT64 emuDistL = 0;
				_INT64 emuDistT = 0;
				_INT64 emuDistR = 0;
				_INT64 emuDistB = 0;

				if (bDistL)
					emuDistL = DistL;
				if (bDistT)
					emuDistT = DistT;
				if (bDistR)
					emuDistR = DistR;
				if (bDistB)
					emuDistB = DistB;
				_INT32 nSimplePos = 0;
				if (bBSimplePos && BSimplePos)
					nSimplePos = 1;
				_UINT32 nRelativeHeight = 0;
				if (bRelativeHeight)
					nRelativeHeight = RelativeHeight;
				_INT32 nBehindDoc = 0;
				if (bBehindDoc && BehindDoc)
					nBehindDoc = 1;
				_INT32 nLayoutInCell = 1;
				if (bLayoutInCell && false == LayoutInCell)
					nLayoutInCell = 0;

				if (bGraphicFrameContent)
				{
					sXml += L"<w:drawing>";
				}
				sXml += L"<wp:anchor \
xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" \
xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" \
distT=\"" + std::to_wstring(emuDistT) + L"\" \
distB=\"" + std::to_wstring(emuDistB) + L"\" \
distL=\"" + std::to_wstring(emuDistL) + L"\" \
distR=\"" + std::to_wstring(emuDistR) + L"\" \
simplePos=\"" + std::to_wstring(nSimplePos) + L"\" \
relativeHeight=\"" + std::to_wstring(nRelativeHeight) + L"\" \
behindDoc=\"" + std::to_wstring(nBehindDoc) + L"\" \
locked=\"0\" \
layoutInCell=\"" + std::to_wstring(nLayoutInCell) + L"\" \
allowOverlap=\"1\">";

				_INT64 emuX = 0;
				if (bSimplePosX)
					emuX = SimplePosX;
				_INT64 emuY = 0;
				if (bSimplePosY)
					emuY = SimplePosY;
				sXml += L"<wp:simplePos x=\"" + std::to_wstring(emuX) + L"\" y=\"" + std::to_wstring(emuY) + L"\"/>";

				if (bPositionHRelativeFrom && (bPositionHAlign || bPositionHPosOffset || bPositionHPctOffset))
				{
					std::wstring sRelativeFrom;
					switch(PositionHRelativeFrom)
					{
					case 0: sRelativeFrom = _T("character");break;
					case 1: sRelativeFrom = _T("column");break;
					case 2: sRelativeFrom = _T("insideMargin");break;
					case 3: sRelativeFrom = _T("leftMargin");break;
					case 4: sRelativeFrom = _T("margin");break;
					case 5: sRelativeFrom = _T("outsideMargin");break;
					case 6: sRelativeFrom = _T("page");break;
					case 7: sRelativeFrom = _T("rightMargin");break;
					}
					std::wstring sContent;
					if (bPositionHAlign)
					{
						switch(PositionHAlign)
						{
						case 0: sContent = _T("<wp:align>center</wp:align>");   break;
						case 1: sContent = _T("<wp:align>inside</wp:align>");   break;
						case 2: sContent = _T("<wp:align>left</wp:align>");     break;
						case 3: sContent = _T("<wp:align>outside</wp:align>");  break;
						case 4: sContent = _T("<wp:align>right</wp:align>");    break;
						}
					}
					else if (bPositionHPosOffset)
					{
						sContent = L"<wp:posOffset>" + std::to_wstring(PositionHPosOffset) + L"</wp:posOffset>";
					}
					else if (bPositionHPctOffset)
					{
						_INT32 pctOffset = (_INT32)(1000 * PositionHPctOffset);
						sContent = L"<wp14:pctPosHOffset>" + std::to_wstring(pctOffset) + L"</wp14:pctPosHOffset>";
					}
					sXml += L"<wp:positionH relativeFrom=\"" + sRelativeFrom + L"\">" + sContent + L"</wp:positionH>";
				}
				if (bPositionVRelativeFrom && (bPositionVAlign || bPositionVPosOffset || bPositionVPctOffset))
				{
					std::wstring sRelativeFrom;
					switch(PositionVRelativeFrom)
					{
					case 0: sRelativeFrom = _T("bottomMargin");break;
					case 1: sRelativeFrom = _T("insideMargin");break;
					case 2: sRelativeFrom = _T("line");break;
					case 3: sRelativeFrom = _T("margin");break;
					case 4: sRelativeFrom = _T("outsideMargin");break;
					case 5: sRelativeFrom = _T("page");break;
					case 6: sRelativeFrom = _T("paragraph");break;
					case 7: sRelativeFrom = _T("topMargin");break;
					}
					std::wstring sContent;
					if (bPositionVAlign)
					{
						switch(PositionVAlign)
						{
						case 0: sContent = _T("<wp:align>bottom</wp:align>");break;
						case 1: sContent = _T("<wp:align>center</wp:align>");break;
						case 2: sContent = _T("<wp:align>inside</wp:align>");break;
						case 3: sContent = _T("<wp:align>outside</wp:align>");break;
						case 4: sContent = _T("<wp:align>top</wp:align>");break;
						}
					}
					else if (bPositionVPosOffset)
					{
						sContent = L"<wp:posOffset>" + std::to_wstring(PositionVPosOffset) + L"</wp:posOffset>";
					}
					else if (bPositionVPctOffset)
					{
						_INT32 pctOffset = (_INT32)(1000 * PositionVPctOffset);
						sContent = L"<wp14:pctPosVOffset>" + std::to_wstring(pctOffset) + L"</wp14:pctPosVOffset>";
					}
					sXml += L"<wp:positionV relativeFrom=\"" + sRelativeFrom + L"\">" + sContent + L"</wp:positionV>";
				}
				sXml += L"<wp:extent cx=\"" + std::to_wstring(Width) + L"\" cy=\"" + std::to_wstring(Height)+ L"\"/>";

				if (bEffectExtentL && bEffectExtentT && bEffectExtentR && bEffectExtentB)
				{
					sXml += L"<wp:effectExtent l=\"" + std::to_wstring(EffectExtentL) +
										  L"\" t=\"" + std::to_wstring(EffectExtentT) + L"\" r=\"" + std::to_wstring(EffectExtentR) +
										  L"\" b=\"" + std::to_wstring(EffectExtentB) + L"\"/>";
				}
				if (bDrawingPropertyWrap && DrawingPropertyWrap.bWrappingType)
				{
					std::wstring sTagName;
					switch(DrawingPropertyWrap.WrappingType)
					{
						case c_oSerImageType2::WrapNone:sTagName        = _T("wrapNone");           break;
						case c_oSerImageType2::WrapSquare:sTagName      = _T("wrapSquare");         break;
						case c_oSerImageType2::WrapThrough:sTagName     = _T("wrapThrough");        break;
						case c_oSerImageType2::WrapTight:sTagName       = _T("wrapTight");          break;
						case c_oSerImageType2::WrapTopAndBottom:sTagName = _T("wrapTopAndBottom");  break;
					}
					if (DrawingPropertyWrap.bStart || DrawingPropertyWrap.Points.size() > 0)
					{
						if ( c_oSerImageType2::WrapSquare	== DrawingPropertyWrap.WrappingType		||
							c_oSerImageType2::WrapThrough	== DrawingPropertyWrap.WrappingType		||
							c_oSerImageType2::WrapTight		== DrawingPropertyWrap.WrappingType)
						{
							sXml += L"<wp:" + sTagName + L" wrapText=\"bothSides\">";
						}
						else
							sXml += L"<wp:" + sTagName + L">";

						_INT32 nEdited = 0;
						if (DrawingPropertyWrap.bEdited && DrawingPropertyWrap.Edited)
							nEdited = 1;
						sXml += L"<wp:wrapPolygon edited=\"" + std::to_wstring(nEdited) + L"\">";

						if (DrawingPropertyWrap.bStart && DrawingPropertyWrap.Start.bX && DrawingPropertyWrap.Start.bY)
						{
							sXml += L"<wp:start x=\"" + std::to_wstring(DrawingPropertyWrap.Start.X) + L"\" y=\"" + std::to_wstring(DrawingPropertyWrap.Start.Y) + L"\"/>";
						}

						for(size_t i = 0; i < DrawingPropertyWrap.Points.size(); ++i)
						{
							CDrawingPropertyWrapPoint* pWrapPoint = DrawingPropertyWrap.Points[i];
							if (pWrapPoint->bX && pWrapPoint->bY)
							{
								sXml += L"<wp:lineTo x=\"" + std::to_wstring(pWrapPoint->X) + L"\" y=\"" + std::to_wstring(pWrapPoint->Y) + L"\"/>";
							}
						}
						sXml += L"</wp:wrapPolygon>";
						sXml += L"</wp:" + sTagName + L">";
					}
					else
					{
						//для wrapThrough и wrapTight wrapPolygon обязательное поле, если его нет - меняем тип.
						if ( c_oSerImageType2::WrapSquare	== DrawingPropertyWrap.WrappingType		||
								c_oSerImageType2::WrapThrough	== DrawingPropertyWrap.WrappingType		||
								c_oSerImageType2::WrapTight		== DrawingPropertyWrap.WrappingType)
						{
							sXml += L"<wp:wrapSquare wrapText=\"bothSides\"/>";
						}
						else
							sXml += L"<wp:" + sTagName + L"/>";
					}
				}
				else
					sXml += L"<wp:wrapNone/>";

				if (!sDocPr.empty())
				{
					sXml += sDocPr;
				}
				else
				{
					sXml += L"<wp:docPr id=\"" + std::to_wstring(m_nDocPr) + L"\" name=\"\"/>";
				}
				if (!sGraphicFramePr.empty())
				{
					sXml += sGraphicFramePr;
				}
				else
				{
					sXml += L"<wp:cNvGraphicFramePr/>";
				}
				if (bGraphicFrameContent)
				{
					sXml += sGraphicFrameContent;
				}

				if (!sSizeRelH.empty())
				{
					sXml += sSizeRelH;
				}
				if (!sSizeRelV.empty())
				{
					sXml += sSizeRelV;
				}

				sXml += L"</wp:anchor>";

				if (bGraphicFrameContent)
					sXml += L"</w:drawing>";
			}
		}
		return sXml;
	}

	bool CWiterTblPr::IsEmpty()
	{
		return Style.empty() && Props.empty() && tblPrChange.empty() && Caption.empty() && Description.empty();
	}
	std::wstring CWiterTblPr::Write()
	{
		std::wstring sRes;
		sRes += L"<w:tblPr>";
		
		sRes += Style; // first
		sRes += Props;

		if (!Caption.empty())
		{
			sRes += L"<w:tblCaption w:val=\"";
			sRes += XmlUtils::EncodeXmlString(Caption);
			sRes += L"\"/>";
		}
		if (!Description.empty())
		{
			sRes += L"<w:tblDescription w:val=\"";
			sRes += XmlUtils::EncodeXmlString(Description);
			sRes += L"\"/>";
		}

		sRes += tblPrChange;
		sRes += L"</w:tblPr>";
		return sRes;
	}

	CHyperlink::CHyperlink()
	{
		bHistory = false;
	}
	void CHyperlink::Write(NSStringUtils::CStringBuilder& wr)
	{
		wr.WriteString(L"<w:hyperlink");
		if (!rId.empty())
		{
			wr.WriteString(L" r:id=\"");
			wr.WriteEncodeXmlString(rId);
			wr.WriteString(L"\"");
		}
		if (!sTooltip.empty())
		{
			wr.WriteString(L" w:tooltip=\"");
			wr.WriteEncodeXmlString(sTooltip);
			wr.WriteString(L"\"");
		}
		if (!sAnchor.empty())
		{
			wr.WriteString(L" w:anchor=\"");
			wr.WriteEncodeXmlString(sAnchor);
			wr.WriteString(L"\"");
		}
		if (bHistory)
		{
			if (History)
			{
				wr.WriteString(L" w:history=\"1\"");
			}
			else
			{
				wr.WriteString(L" w:history=\"0\"");
			}
		}
		if (!sDocLocation.empty())
		{
			wr.WriteString(L" w:docLocation=\"");
			wr.WriteEncodeXmlString(sDocLocation);
			wr.WriteString(L"\"");
		}
		if (!sTgtFrame.empty())
		{
			wr.WriteString(L" w:tgtFrame=\"");
			wr.WriteEncodeXmlString(sTgtFrame);
			wr.WriteString(L"\"");
		}
		wr.WriteString(L">");
		wr.Write(writer);
		wr.WriteString(L"</w:hyperlink>");
	}

	CFldSimple::CFldSimple()
	{
	}
	void CFldSimple::Write(NSStringUtils::CStringBuilder& wr)
	{
		if (false == sInstr.empty())
		{
			std::wstring sCorrect_Instr = XmlUtils::EncodeXmlString(sInstr);
			std::wstring sStart(L"<w:fldSimple w:instr=\"");
			sStart += sCorrect_Instr;
			sStart += L"\">";
			wr.WriteString(sStart);
			wr.Write(writer);
			wr.WriteString(L"</w:fldSimple>");
		}
	}

	TrackRevision::TrackRevision()
	{
		Id = NULL;
		vMerge = NULL;
		vMergeOrigin = NULL;
		tblPr = NULL;
		tblGridChange = NULL;
		trPr = NULL;
		tcPr = NULL;
		content = NULL;
		contentRun = NULL;
	}
	TrackRevision::~TrackRevision()
	{
		RELEASEOBJECT(Id);
		RELEASEOBJECT(vMerge);
		RELEASEOBJECT(vMergeOrigin);
		RELEASEOBJECT(tblPr);
		RELEASEOBJECT(tblGridChange);
		RELEASEOBJECT(trPr);
		RELEASEOBJECT(tcPr);
		RELEASEOBJECT(content);
		RELEASEOBJECT(contentRun);
	}
	void TrackRevision::Write(NSStringUtils::CStringBuilder*  pCStringWriter, std::wstring sName)
	{
		if (IsNoEmpty())
		{
			pCStringWriter->WriteString(L"<");
			pCStringWriter->WriteString(sName);
			if (NULL != Id)
			{
				pCStringWriter->WriteString(L" w:id=\"" + std::to_wstring(*Id) + L"\"");
			}
			if (!Author.empty())
			{
				pCStringWriter->WriteString(L" w:author=\"");
				pCStringWriter->WriteEncodeXmlString(Author);
				pCStringWriter->WriteString(L"\"");
			}
			if (!Date.empty())
			{
				pCStringWriter->WriteString(L" w:date=\"");
				pCStringWriter->WriteEncodeXmlString(Date);
				pCStringWriter->WriteString(L"\"");
			}
			if (!UserId.empty())
			{
				pCStringWriter->WriteString(L" oouserid=\"");
				pCStringWriter->WriteEncodeXmlString(UserId);
				pCStringWriter->WriteString(L"\"");
			}
			if (NULL != vMerge)
			{
				pCStringWriter->WriteString(L" w:vMerge=\"" + std::to_wstring(*vMerge) + L"\"");
			}
			if ( NULL != vMergeOrigin )
			{
				pCStringWriter->WriteString(L" w:vMergeOrig=\"" + std::to_wstring(*vMergeOrigin) + L"\"");
			}
			if ( NULL != tblPr || NULL != tblGridChange || NULL != trPr || NULL != tcPr || NULL != content || NULL != contentRun)
			{
				pCStringWriter->WriteString(L">");

				if (NULL != tblPr)
				{
					pCStringWriter->WriteString(tblPr->Write());
				}
				if (NULL != tblGridChange)
				{
					pCStringWriter->WriteString(L"<w:tblGrid>");
					pCStringWriter->Write(*tblGridChange);
					pCStringWriter->WriteString(L"</w:tblGrid>");
				}
				if (NULL != trPr)
				{
					pCStringWriter->WriteString(L"<w:trPr>");
					pCStringWriter->Write(*trPr);
					pCStringWriter->WriteString(L"</w:trPr>");
				}
				if (NULL != tcPr)
				{
					pCStringWriter->WriteString(L"<w:tcPr>");
					pCStringWriter->Write(*tcPr);
					pCStringWriter->WriteString(L"</w:tcPr>");
				}
				if (NULL != content)
				{
					pCStringWriter->Write(*content);
				}
				if (NULL != contentRun)
				{
					pCStringWriter->Write(*contentRun);
				}

				pCStringWriter->WriteString(L"</");
				pCStringWriter->WriteString(sName);
				pCStringWriter->WriteString(L">");
			}
			else
			{
				pCStringWriter->WriteString(L"/>");
			}
		}
	}
	bool TrackRevision::IsNoEmpty()
	{
		return !Author.empty() || !Date.empty() || NULL != Id;
	}
	std::wstring TrackRevision::ToString(std::wstring sName)
	{
		NSStringUtils::CStringBuilder writer;
		Write(&writer, sName);
		return writer.GetData();
	}
}