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

#include "../../DesktopEditor/common/SystemUtils.h"
#include "../../DesktopEditor/common/Directory.h"
#include "../../DesktopEditor/raster/ImageFileFormatChecker.h"
#include "../../DesktopEditor/graphics/pro/Image.h"
#include "../../DesktopEditor/raster/BgraFrame.h"

#include "../Binary/Presentation/BinaryFileReaderWriter.h"
#include "../Binary/Presentation/XmlWriter.h"
#include "../Binary/Presentation/imagemanager.h"
#include "../DocxFormat/Media/OleObject.h"
#include "../DocxFormat/Media/Image.h"

#include "../../Common/OfficeFileFormatChecker.h"

namespace OOX
{
	namespace Draw
	{
		EElementType CRel::getType() const
		{
			return et_dr_Rel;
		}
		void CRel::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributes_Read_ifChar(oReader, "id", Rid)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CRel::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (!oReader.IsEmptyNode())
				oReader.ReadTillEnd();
		}
		void CRel::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"Rel");
			pWriter->StartAttributes();
			if (Rid.IsInit())
				pWriter->WriteAttribute2(L"r:id", Rid->ToString());
			pWriter->EndAttributes();
			pWriter->WriteNodeEnd(L"Rel");
		}
		EElementType CIcon::getType() const
		{
			return et_dr_Icon;
		}
		void CIcon::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			content = oReader.GetText2();
		}
		void CIcon::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteString1(0, content);
		}
		void CIcon::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			
			content = pReader->GetString2();
			
			pReader->Seek(_end_rec);
		}
		void CIcon::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"Icon");
			pWriter->EndAttributes();
			pWriter->WriteString(content);
			pWriter->WriteNodeEnd(L"Icon");
		}
		EElementType CForeignData::getType() const
		{
			return et_dr_ForeignData;
		}
		void CForeignData::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributes_Read_ifChar(oReader, "ForeignType", ForeignType)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "CompressionType", CompressionType)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "CompressionLevel", CompressionLevel)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ObjectType", ObjectType)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ShowAsIcon", ShowAsIcon)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ObjectWidth", ObjectWidth)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ObjectHeight", ObjectHeight)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ExtentX", ExtentX)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ExtentY", ExtentY)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		nullable<SimpleTypes::Draw::CCompressionType> CompressionType;
		nullable_double CompressionLevel;
		void CForeignData::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = oReader.GetName();

				if (L"Rel" == sName)
				{
					Rel = oReader;
				}
			}
		}
		void CForeignData::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			if (ForeignType.IsInit()) pWriter->WriteByte1(0, ForeignType->GetValue());
			pWriter->WriteUInt2(1, ObjectType);
			pWriter->WriteBool2(2, ShowAsIcon);
			pWriter->WriteDoubleReal2(3, ObjectWidth);
			pWriter->WriteDoubleReal2(4, ObjectHeight);
			pWriter->WriteDoubleReal2(5, ExtentX);
			pWriter->WriteDoubleReal2(6, ExtentY);
			if (CompressionType.IsInit()) pWriter->WriteByte1(7, CompressionType->GetValue());
			pWriter->WriteDoubleReal2(8, CompressionLevel);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);

			if (Rel.IsInit() && Rel->Rid.IsInit())
			{
				CPath out = pWriter->m_pCommon->m_pMediaManager->m_strDstMedia;

				smart_ptr<OOX::File> pFile = pWriter->GetRels()->Find(Rel->Rid->GetValue());
				OOX::OleObject* pOleObject = dynamic_cast<OOX::OleObject*>(pFile.GetPointer());

				CPath image_path;
				CPath ole_path;
				if (pOleObject)
				{
					image_path = pOleObject->filename_cache();
					ole_path = pOleObject->filename();
				}
				else
				{
					OOX::Media* pMedia = dynamic_cast<OOX::Media*>(pFile.GetPointer());
					if (pMedia)
					{
						image_path = pMedia->filename();
					}
				}
				std::wstring image_name_new;
				if (false == image_path.GetPath().empty())
				{
					//todooo check correct path inside container
					image_name_new = image_path.GetFilename();
					std::wstring image_ext_new = image_path.GetExtention();

					std::map<std::wstring, NSShapeImageGen::CMediaInfo>::iterator pFind = pWriter->m_pCommon->m_pMediaManager->m_mapMediaFiles.find(image_path.GetFilename());
					if (pFind == pWriter->m_pCommon->m_pMediaManager->m_mapMediaFiles.end())
					{
						NSShapeImageGen::CMediaInfo oInfo;
						oInfo.m_lID = ++pWriter->m_pCommon->m_pMediaManager->m_lNextIDImage;
						oInfo.m_sExt = image_path.GetExtention();
						image_name_new = oInfo.m_sName = L"image" + std::to_wstring(oInfo.m_lID);

						pWriter->m_pCommon->m_pMediaManager->m_mapMediaFiles.insert(std::make_pair(image_path.GetFilename(), oInfo));
					}
					else
					{
						image_name_new = pFind->second.m_sName;
					}

					NSFile::CFileBinary::Copy(image_path.GetPath(), out.GetPath() + FILE_SEPARATOR_STR + image_name_new + image_ext_new);

					pWriter->StartRecord(1);
					pWriter->WriteString(image_name_new + image_ext_new);
					pWriter->EndRecord();

					CImageFileFormatChecker checker;
					if (checker.isImageFile(image_path.GetPath()))
					{
						if (checker.eFileType == _CXIMAGE_FORMAT_WMF || checker.eFileType == _CXIMAGE_FORMAT_EMF)
						{
							MetaFile::IMetaFile* pMetafile = MetaFile::Create(pWriter->m_pCommon->m_pMediaManager->m_pFontManager->GetApplication());

							if (pMetafile->LoadFromFile(image_path.GetPath().c_str()))
							{
								double w = ExtentX.IsInit() ? *ExtentX : ObjectWidth.get_value_or(0);
								double h = ExtentY.IsInit() ? *ExtentY : ObjectHeight.get_value_or(0);

								std::wstring sInternalSvg = pMetafile->ConvertToSvg(w > 1 ? w : 0, h > 1 ? h : 0);

								if (!sInternalSvg.empty())
								{
									NSFile::CFileBinary::SaveToFile(out.GetPath() + FILE_SEPARATOR_STR + image_name_new + L".svg", sInternalSvg);
								}
								else
								{// не смогли сконвертировать в svg - пробуем в png									

									std::wstring strSaveItem = out.GetPath() + FILE_SEPARATOR_STR + image_name_new + L".png";
									pMetafile->ConvertToRaster(strSaveItem.c_str(), 4 /*CXIMAGE_FORMAT_PNG*/, 0, 0);
								}
							}
							RELEASEOBJECT(pMetafile);
						}
						else if (checker.eFileType != _CXIMAGE_FORMAT_JPG && checker.eFileType != _CXIMAGE_FORMAT_SVG && checker.eFileType != _CXIMAGE_FORMAT_PNG)
						{
							std::wstring strSaveItem = out.GetPath() + FILE_SEPARATOR_STR + image_name_new + L".png";

							CBgraFrame oFrame;
							if (true == oFrame.OpenFile(image_path.GetPath().c_str()))
							{
								oFrame.SaveFile(strSaveItem, 4); // png
							}
						}
					}
				}
				if (false == ole_path.GetPath().empty())
				{
					if (image_name_new.empty())
					{
						NSShapeImageGen::CMediaInfo oInfo;
						oInfo.m_lID = ++pWriter->m_pCommon->m_pMediaManager->m_lNextIDImage;
						image_name_new = oInfo.m_sName = L"image" + std::to_wstring(oInfo.m_lID);

						pWriter->m_pCommon->m_pMediaManager->m_mapMediaFiles.insert(std::make_pair(image_path.GetFilename(), oInfo));
					}
					std::wstring ole_name_new = image_name_new + ole_path.GetExtention();
					//todooo check correct path inside container
					NSFile::CFileBinary::Copy(ole_path.GetPath(), out.GetPath() + FILE_SEPARATOR_STR + ole_name_new);

					pWriter->StartRecord(2);
					pWriter->WriteString(ole_name_new);
					pWriter->EndRecord();
				}
			}
		}
		void CForeignData::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			std::wstring image_filename, ole_filename;

			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					ForeignType.Init();
					ForeignType->SetValueFromByte(pReader->GetUChar());
				}break;
				case 1:
				{
					ObjectType = pReader->GetULong();
				}break;
				case 2:
				{
					ShowAsIcon = pReader->GetBool();
				}break;
				case 3:
				{
					ObjectWidth = pReader->GetDoubleReal();
				}break;
				case 4:
				{
					ObjectHeight = pReader->GetDoubleReal();
				}break;
				case 5:
				{
					ExtentX = pReader->GetDoubleReal();
				}break;
				case 6:
				{
					ExtentY = pReader->GetDoubleReal();
				}break;
				case 7:
				{
					CompressionType.Init();
					CompressionType->SetValueFromByte(pReader->GetUChar());
				}break;
				case 8:
				{
					CompressionLevel = pReader->GetDoubleReal();
				}break;
				}
			}
			while (pReader->GetPos() < _end_rec)
			{
				BYTE _rec = pReader->GetUChar();
				switch (_rec)
				{
				case 1:
				{
					pReader->Skip(4);
					image_filename = pReader->GetString2();
				}break;
				case 2:
				{
					pReader->Skip(4);
					ole_filename = pReader->GetString2();
				}break;
				default:
				{
					pReader->SkipRecord();
				}break;
				}
			}
			pReader->Seek(_end_rec);

			if (ole_filename.empty() == false)
			{
				int idOle = pReader->m_nCountEmbedded++; //todoooo -> countEmbeddedObjects
				int idImage = pReader->m_nCountImage++; 

				std::wstring ole_filename_dst = L"oleObject" + std::to_wstring(idOle) + CPath(ole_filename).GetExtention();
				std::wstring image_filename_dst = L"image" + std::to_wstring(idImage) + CPath(image_filename).GetExtention();

				std::wstring srcMedia = pReader->m_strFolder + FILE_SEPARATOR_STR + L"media" + FILE_SEPARATOR_STR;

				NSFile::CFileBinary::Copy(srcMedia + ole_filename, pReader->m_pRels->m_pManager->GetDstEmbed() + FILE_SEPARATOR_STR + ole_filename_dst);
				NSFile::CFileBinary::Copy(srcMedia + image_filename, pReader->m_pRels->m_pManager->GetDstMedia() + FILE_SEPARATOR_STR + image_filename_dst);

				OleObject* pOle = new OleObject(NULL, false, false);
				pOle->set_filename(pReader->m_pRels->m_pManager->GetDstEmbed() + FILE_SEPARATOR_STR + ole_filename_dst, false);
				pOle->set_filename_cache(pReader->m_pRels->m_pManager->GetDstMedia() + FILE_SEPARATOR_STR + image_filename_dst);

				COfficeFileFormatChecker checker;
				if (checker.isOOXFormatFile(pOle->filename().GetPath()))
				{
					pOle->set_MsPackage(true);
				}
				
				smart_ptr<OOX::File> oFile(pOle);

				Rel.Init(); Rel->Rid.Init();
				Rel->Rid->SetValue(pReader->GetRels()->Add(oFile).get());

				if (image_filename_dst.empty() == false)
				{
					Image* pImage = new Image(NULL, false);
					pImage->set_filename(pReader->m_pRels->m_pManager->GetDstMedia() + FILE_SEPARATOR_STR + image_filename_dst, false);

					smart_ptr<OOX::File> oFileCache(pImage);
					pOle->Add(oFileCache);
				}
			}
			else
			{
				std::wstring srcMedia = pReader->m_strFolder + FILE_SEPARATOR_STR + L"media" + FILE_SEPARATOR_STR;
				int idImage = pReader->m_nCountImage++;
				std::wstring image_filename_dst = L"image" + std::to_wstring(idImage) + CPath(image_filename).GetExtention();


				NSFile::CFileBinary::Copy(srcMedia + image_filename, pReader->m_pRels->m_pManager->GetDstMedia() + FILE_SEPARATOR_STR + image_filename_dst);

				Image* pImage = new Image(NULL, false);
				pImage->set_filename(pReader->m_pRels->m_pManager->GetDstMedia() + FILE_SEPARATOR_STR + image_filename_dst, false);

				smart_ptr<OOX::File> oFile(pImage);
				Rel.Init(); Rel->Rid.Init();
				Rel->Rid->SetValue(pReader->GetRels()->Add(oFile).get());
			}
		}
		void CForeignData::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"ForeignData");
			pWriter->StartAttributes();
			if (ForeignType.IsInit()) pWriter->WriteAttribute(L"ForeignType", ForeignType->ToString());
			if (CompressionType.IsInit()) pWriter->WriteAttribute(L"CompressionType", CompressionType->ToString());
			pWriter->WriteAttribute(L"CompressionLevel", CompressionLevel);
			pWriter->WriteAttribute2(L"ObjectType", ObjectType);
			pWriter->WriteAttribute(L"ShowAsIcon", ShowAsIcon);
			pWriter->WriteAttribute(L"ObjectWidth", ObjectWidth);
			pWriter->WriteAttribute(L"ObjectHeight", ObjectHeight);
			pWriter->WriteAttribute(L"ExtentX", ExtentX);
			pWriter->WriteAttribute(L"ExtentY", ExtentY);
			pWriter->EndAttributes();

			if (Rel.IsInit())
				Rel->toXmlWriter(pWriter);

			pWriter->WriteNodeEnd(L"ForeignData");
		}
		EElementType CText::getType() const
		{
			return et_dr_Text;
		}
		void CText::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
		}
		void CText::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (oReader.IsEmptyNode())
				return;

			int nDepth = oReader.GetDepth();
			XmlUtils::XmlNodeType eNodeType = XmlUtils::XmlNodeType_EndElement;
		
			while (oReader.Read(eNodeType) && oReader.GetDepth() >= nDepth && XmlUtils::XmlNodeType_EndElement != eNodeType)
			{
				if (eNodeType == XmlUtils::XmlNodeType_Text
					|| eNodeType == XmlUtils::XmlNodeType_Whitespace
					|| eNodeType == XmlUtils::XmlNodeType_SIGNIFICANT_WHITESPACE
					|| eNodeType == XmlUtils::XmlNodeType_CDATA)
				{
					const char* pValue = oReader.GetTextChar();

					if ('\0' != pValue[0])
					{
						CText_text* pText = new CText_text();
						NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pValue, (LONG)strlen(pValue), pText->content);
						m_arrItems.push_back(pText);
					}
				}
				else if (eNodeType == XmlUtils::XmlNodeType_Element)
				{
					std::wstring sName = oReader.GetName();

					WritingElement* pItem = NULL;
					if (L"cp" == sName)
					{
						pItem = new CText_cp();
					}
					else if (L"pp" == sName)
					{
						pItem = new CText_pp();
					}
					else if (L"tp" == sName)
					{
						pItem = new CText_tp();
					}
					else if (L"fld" == sName)
					{
						pItem = new CText_fld();
					}
					if (pItem)
					{
						pItem->fromXML(oReader);
						m_arrItems.push_back(pItem);
					}
				}
			}
		}
		void CText::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			for (size_t i = 0; i < m_arrItems.size(); ++i)
			{
				int type = 0xff;					 
				switch (m_arrItems[i]->getType())
				{
					case et_dr_text_cp: type = 0; break;
					case et_dr_text_pp: type = 1; break;
					case et_dr_text_tp: type = 2; break;
					case et_dr_text_fld: type = 3; break;
					case et_dr_text_text: type = 4; break;
				}
				if (type != 0xff)
					pWriter->WriteRecord2(type, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
			}
		}
		void CText::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			while (pReader->GetPos() < _end_rec)
			{
				BYTE _rec = pReader->GetUChar();
				switch (_rec)
				{
				case 0:
				{
					m_arrItems.push_back(new CText_cp());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 1:
				{
					m_arrItems.push_back(new CText_pp());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 2:
				{
					m_arrItems.push_back(new CText_tp());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 3:
				{
					m_arrItems.push_back(new CText_fld());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 4:
				{
					m_arrItems.push_back(new CText_text());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				default:
				{
					pReader->SkipRecord();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CText::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"Text");
			pWriter->StartAttributes();
			pWriter->EndAttributes();

			for (size_t i = 0; i < m_arrItems.size(); ++i)
			{
				m_arrItems[i]->toXmlWriter(pWriter);
			}

			pWriter->WriteNodeEnd(L"Text");
		}
		EElementType CText_text::getType() const
		{
			return et_dr_text_text;
		}
		void CText_text::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteString1(0, content);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
		}
		void CText_text::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					content = pReader->GetString2();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CText_text::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->WriteStringXML(content);
		}
		EElementType CText_fld::getType() const
		{
			return et_dr_text_fld;
		}
		void CText_fld::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributes_Read_ifChar(oReader, "IX", IX)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CText_fld::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (oReader.IsEmptyNode())
				return;

			content = oReader.GetText2();
		}
		void CText_fld::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteUInt2(0, IX);
			pWriter->WriteString1(1, content);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
		}
		void CText_fld::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					IX = pReader->GetULong();
				}break;
				case 1:
				{
					content = pReader->GetString2();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CText_fld::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"fld");
			pWriter->StartAttributes();
			pWriter->WriteAttribute2(L"IX", IX);
			pWriter->EndAttributes();
			
			pWriter->WriteStringXML(content);
			
			pWriter->WriteNodeEnd(L"fld");
		}
		EElementType CText_tp::getType() const
		{
			return et_dr_text_tp;
		}
		void CText_tp::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributes_Read_ifChar(oReader, "IX", IX)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CText_tp::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (!oReader.IsEmptyNode())
				oReader.ReadTillEnd();
		}
		void CText_tp::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteUInt2(0, IX);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
		}
		void CText_tp::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					IX = pReader->GetULong();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CText_tp::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"tp");
			pWriter->StartAttributes();
			pWriter->WriteAttribute2(L"IX", IX);
			pWriter->EndAttributes();
			pWriter->WriteNodeEnd(L"tp");
		}
		EElementType CText_pp::getType() const
		{
			return et_dr_text_pp;
		}
		void CText_pp::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributes_Read_ifChar(oReader, "IX", IX)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CText_pp::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (!oReader.IsEmptyNode())
				oReader.ReadTillEnd();
		}
		void CText_pp::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteUInt2(0, IX);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
		}
		void CText_pp::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					IX = pReader->GetULong();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CText_pp::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"pp");
			pWriter->StartAttributes();
			pWriter->WriteAttribute2(L"IX", IX);
			pWriter->EndAttributes();
			pWriter->WriteNodeEnd(L"pp");
		}
		EElementType CText_cp::getType() const
		{
			return et_dr_text_cp;
		}
		void CText_cp::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributes_Read_ifChar(oReader, "IX", IX)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CText_cp::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (!oReader.IsEmptyNode())
				oReader.ReadTillEnd();
		}
		void CText_cp::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteUInt2(0, IX);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
		}
		void CText_cp::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					IX = pReader->GetULong();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CText_cp::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"cp");
			pWriter->StartAttributes();
			pWriter->WriteAttribute2(L"IX", IX);
			pWriter->EndAttributes();
			pWriter->WriteNodeEnd(L"cp");
		}
		EElementType CRow::getType() const
		{
			return et_dr_Row;
		}
		void CRow::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributes_Read_ifChar(oReader, "IX", IX)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Del", Del)
				WritingElement_ReadAttributesA_Read_else_ifChar(oReader, "N", N)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "LocalName", LocalName)
				WritingElement_ReadAttributesA_Read_else_ifChar(oReader, "T", T)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CRow::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = oReader.GetName();

				WritingElement* pItem = NULL;
				if (L"Cell" == sName)
				{
					pItem = new CCell();
				}
				else if (L"Trigger" == sName)
				{
					pItem = new CTrigger();
				}
				if (pItem)
				{
					pItem->fromXML(oReader);
					m_arrItems.push_back(pItem);
				}
			}
		}
		void CRow::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteUInt2(0, IX);
			pWriter->WriteString2(1, N);
			pWriter->WriteString2(2, LocalName);
			pWriter->WriteString2(3, T);
			pWriter->WriteBool2(4, Del);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);

			for (size_t i = 0; i < m_arrItems.size(); ++i)
			{
				int type = 0xff;					 //todooo predefine type for ???
				switch (m_arrItems[i]->getType())
				{
				case et_dr_Cell: type = 0; break;
				case et_dr_Trigger: type = 1; break;
				}
				if (type != 0xff)
					pWriter->WriteRecord2(type, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
			}
		}
		void CRow::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					IX = pReader->GetULong();
				}break;
				case 1:
				{
					N = pReader->GetString2A();
				}break;
				case 2:
				{
					LocalName = pReader->GetString2();
				}break;
				case 3:
				{
					T = pReader->GetString2A();
				}break;
				case 4:
				{
					Del = pReader->GetBool();
				}break;
				}
			}
			while (pReader->GetPos() < _end_rec)
			{
				BYTE _rec = pReader->GetUChar();
				switch (_rec)
				{
				case 0:
				{
					m_arrItems.push_back(new CCell());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 1:
				{
					m_arrItems.push_back(new CTrigger());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				default:
				{
					pReader->SkipRecord();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CRow::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"Row");
			pWriter->StartAttributes();
			pWriter->WriteAttribute2(L"N", N);
			pWriter->WriteAttribute2(L"LocalName", LocalName);
			pWriter->WriteAttribute2(L"T", T);
			pWriter->WriteAttribute2(L"IX", IX);
			pWriter->WriteAttribute(L"Del", Del);
			pWriter->EndAttributes();

			for (size_t i = 0; i < m_arrItems.size(); ++i)
				m_arrItems[i]->toXmlWriter(pWriter);

			pWriter->WriteNodeEnd(L"Row");
		}
		EElementType CSection::getType() const
		{
			return et_dr_Section;
		}
		void CSection::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributes_Read_ifChar(oReader, "IX", IX)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Del", Del)
				WritingElement_ReadAttributesA_Read_else_ifChar(oReader, "N", N)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CSection::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = oReader.GetName();

				WritingElement* pItem = NULL;
				if (L"Cell" == sName)
				{
					pItem = new CCell();
				}
				else if (L"Trigger" == sName)
				{
					pItem = new CTrigger();
				}
				else if (L"Row" == sName)
				{
					pItem = new CRow();
				}
				if (pItem)
				{
					pItem->fromXML(oReader);
					m_arrItems.push_back(pItem);
				}
			}
		}
		void CSection::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteUInt2(0, IX);
			pWriter->WriteString2(1, N);
			pWriter->WriteBool2(2, Del);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);

			for (size_t i = 0; i < m_arrItems.size(); ++i)
			{
				int type = 0xff;					 //todooo predefine type for ???
				switch (m_arrItems[i]->getType())
				{
				case et_dr_Cell: type = 0; break;
				case et_dr_Trigger: type = 1; break;
				case et_dr_Row: type = 6; break;
				}
				if (type != 0xff)
					pWriter->WriteRecord2(type, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
			}
		}
		void CSection::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					IX = pReader->GetULong();
				}break;
				case 1:
				{
					N = pReader->GetString2A();
				}break;
				case 2:
				{
					Del = pReader->GetBool();
				}break;
				}
			}
			while (pReader->GetPos() < _end_rec)
			{
				BYTE _rec = pReader->GetUChar();
				switch (_rec)
				{
				case 0:
				{
					m_arrItems.push_back(new CCell());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 1:
				{
					m_arrItems.push_back(new CTrigger());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 6:
				{
					m_arrItems.push_back(new CRow());
					m_arrItems.back()->fromPPTY(pReader);
				}break;

				default:
				{
					pReader->SkipRecord();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CSection::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"Section");
			pWriter->StartAttributes();
			pWriter->WriteAttribute2(L"N", N);
			pWriter->WriteAttribute2(L"IX", IX);
			pWriter->WriteAttribute(L"Del", Del);
			pWriter->EndAttributes();

			for (size_t i = 0; i < m_arrItems.size(); ++i)
				m_arrItems[i]->toXmlWriter(pWriter);

			pWriter->WriteNodeEnd(L"Section");
		}
		EElementType CRefBy::getType() const
		{
			return et_dr_RefBy;
		}
		void CRefBy::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributes_Read_ifChar(oReader, "ID", ID)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "T", T)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CRefBy::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (!oReader.IsEmptyNode())
				oReader.ReadTillEnd();
		}
		void CRefBy::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteUInt2(0, ID);
			pWriter->WriteString2(1, T);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
		}
		void CRefBy::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					ID = pReader->GetULong();
				}break;
				case 1:
				{
					T = pReader->GetString2();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CRefBy::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"RefBy");
			pWriter->StartAttributes();
			pWriter->WriteAttribute2(L"T", T);
			pWriter->WriteAttribute2(L"ID", ID);
			pWriter->EndAttributes();
			pWriter->WriteNodeEnd(L"RefBy");
		}
		EElementType CCell::getType() const
		{
			return et_dr_Cell;
		}
		void CCell::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributesA_Read_ifChar(oReader, "N", N)
				WritingElement_ReadAttributesA_Read_else_ifChar(oReader, "U", U)
				WritingElement_ReadAttributesA_Read_else_ifChar(oReader, "E", E)
				WritingElement_ReadAttributesA_Read_else_ifChar(oReader, "F", F)
				WritingElement_ReadAttributesA_Read_else_ifChar(oReader, "V", V)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CCell::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			
			if (oReader.IsEmptyNode())
				return;

			int nDepth = oReader.GetDepth();
			XmlUtils::XmlNodeType eNodeType = XmlUtils::XmlNodeType_EndElement;

			while (oReader.Read(eNodeType) && oReader.GetDepth() >= nDepth && XmlUtils::XmlNodeType_EndElement != eNodeType)
			{
				if (eNodeType == XmlUtils::XmlNodeType_Text
					|| eNodeType == XmlUtils::XmlNodeType_Whitespace
					|| eNodeType == XmlUtils::XmlNodeType_SIGNIFICANT_WHITESPACE
					|| eNodeType == XmlUtils::XmlNodeType_CDATA)
				{
					const char* pValue = oReader.GetTextChar();

					if ('\0' != pValue[0])
					{
						std::wstring val;
						NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pValue, (LONG)strlen(pValue), val);
						content += val;
					}
				}
				else if (eNodeType == XmlUtils::XmlNodeType_Element)
				{
					std::wstring sName = oReader.GetName();

					if (L"RefBy" == sName)
					{
						RefBy = oReader;
					}
				}
			}
		}
		void CCell::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteString2(0, N);
			pWriter->WriteString2(1, U);
			pWriter->WriteString2(2, E);
			pWriter->WriteString2(3, F);
			pWriter->WriteString2(4, V);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);

			pWriter->WriteRecord2(0, RefBy);
			
			if (false == content.empty())
			{
				pWriter->StartRecord(1);
				pWriter->WriteString(content);
				pWriter->EndRecord();
			}
		}
		void CCell::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					N = pReader->GetString2A();
				}break;
				case 1:
				{
					U = pReader->GetString2A();
				}break;
				case 2:
				{
					E = pReader->GetString2A();
				}break;
				case 3:
				{
					F = pReader->GetString2A();
				}break;
				case 4:
				{
					V = pReader->GetString2A();
				}break;
				}
			}
			while (pReader->GetPos() < _end_rec)
			{
				BYTE _rec = pReader->GetUChar();
				switch (_rec)
				{
				case 0:
				{
					RefBy.Init();
					RefBy->fromPPTY(pReader);
				}break;
				case 1:
				{
					content = pReader->GetString2();
				}break;
				default:
				{
					pReader->SkipRecord();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CCell::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"Cell");
			pWriter->StartAttributes();
			pWriter->WriteAttribute2(L"N", N);
			pWriter->WriteAttributeUtf8(L"V", V);
			pWriter->WriteAttribute2(L"U", U);
			pWriter->WriteAttribute2(L"E", E);
			pWriter->WriteAttributeUtf8(L"F", F);
			pWriter->EndAttributes();

			if (RefBy.IsInit())
				RefBy->toXmlWriter(pWriter);

			if (false == content.empty())
			{
				pWriter->WriteStringXML(content);
			}

			pWriter->WriteNodeEnd(L"Cell");
		}
		EElementType CTrigger::getType() const
		{
			return et_dr_Trigger;
		}
		void CTrigger::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributesA_Read_ifChar(oReader, "N", N)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CTrigger::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = oReader.GetName();

				if (L"RefBy" == sName)
				{
					RefBy = oReader;
				}
			}
		}
		void CTrigger::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteString2(0, N);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
			
			pWriter->WriteRecord2(0, RefBy);
		}
		void CTrigger::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
					case 0:
					{
						N = pReader->GetString2A();
					}break;
				}
			}
			while (pReader->GetPos() < _end_rec)
			{
				BYTE _rec = pReader->GetUChar();
				switch (_rec)
				{
					case 0:
					{
						RefBy.Init();
						RefBy->fromPPTY(pReader);
					}break;
					default:
					{
						pReader->SkipRecord();
					}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CTrigger::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"Trigger");
			pWriter->StartAttributes();
			pWriter->WriteAttribute2(L"N", N);

			pWriter->EndAttributes();
			
			if (RefBy.IsInit())
				RefBy->toXmlWriter(pWriter);

			pWriter->WriteNodeEnd(L"Trigger");
		}
		EElementType CShape::getType() const
		{
			return et_dr_Shape;
		}
		void CShape::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributes_Read_ifChar(oReader, "ID", ID)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "OriginalID", OriginalID)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Type", Type)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Del", Del)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "MasterShape", MasterShape)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "NameU", NameU)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "UniqueID", UniqueID)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Name", Name)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "IsCustomName", IsCustomName)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "IsCustomNameU", IsCustomNameU)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Master", Master)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "LineStyle", LineStyle)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "FillStyle", FillStyle)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "TextStyle", TextStyle)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CShape::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = oReader.GetName();

				WritingElement* pItem = NULL;
				if (L"Cell" == sName)
				{
					pItem = new CCell();
				}
				else if (L"Trigger" == sName)
				{
					pItem = new CTrigger();
				}
				else if (L"Section" == sName)
				{
					pItem = new CSection();
				}
				else if (L"Text" == sName)
				{
					pItem = new CText();
				}
				else if (L"ForeignData" == sName)
				{
					pItem = new CForeignData();
				}
				else if (L"Shapes" == sName)
				{
					pItem = new CShapes();
				}
				if (pItem)
				{
					pItem->fromXML(oReader);
					m_arrItems.push_back(pItem);
				}
			}
		}
		void CShape::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteUInt2(0, ID);
			if (Type.IsInit()) pWriter->WriteByte1(1, Type->GetValue());
			pWriter->WriteUInt2(2, OriginalID);
			pWriter->WriteBool2(3, Del);
			pWriter->WriteUInt2(4, MasterShape);
			pWriter->WriteString2(5, UniqueID);
			pWriter->WriteString2(6, NameU);
			pWriter->WriteString2(7, Name);
			pWriter->WriteBool2(8, IsCustomName);
			pWriter->WriteBool2(9, IsCustomNameU);
			pWriter->WriteUInt2(10, Master);
			pWriter->WriteUInt2(11, LineStyle);
			pWriter->WriteUInt2(12, FillStyle);
			pWriter->WriteUInt2(13, TextStyle);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);

			for (size_t i = 0; i < m_arrItems.size(); ++i)
			{
				int type = 0xff;					 //todooo predefine type for ???
				switch (m_arrItems[i]->getType())
				{
					case et_dr_Cell: type = 0; break;
					case et_dr_Trigger: type = 1; break;
					case et_dr_Section: type = 2; break;
					case et_dr_Text: type = 3; break;
					case et_dr_ForeignData: type = 4; break;
					case et_dr_Shapes: type = 5; break;
				}
				if (type != 0xff)
					pWriter->WriteRecord2(type, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
			}
		}
		void CShape::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					ID = pReader->GetULong();
				}break;
				case 1:
				{
					Type.Init(); Type->SetValueFromByte(pReader->GetUChar());
				}break;
				case 2:
				{
					OriginalID = pReader->GetULong();
				}break;
				case 3:
				{
					Del = pReader->GetBool();
				}break;
				case 4:
				{
					MasterShape = pReader->GetULong();
				}break;				
				case 5:
				{
					UniqueID = pReader->GetString2();
				}break;
				case 6:
				{
					NameU = pReader->GetString2();
				}break;
				case 7:
				{
					Name = pReader->GetString2();
				}break;
				case 8:
				{
					IsCustomName = pReader->GetBool();
				}break;
				case 9:
				{
					IsCustomNameU = pReader->GetBool();
				}break;
				case 10:
				{
					Master = pReader->GetULong();
				}break;
				case 11:
				{
					LineStyle = pReader->GetULong();
				}break;
				case 12:
				{
					FillStyle = pReader->GetULong();
				}break;
				case 13:
				{
					TextStyle = pReader->GetULong();
				}break;
				}
			}
			while (pReader->GetPos() < _end_rec)
			{
				BYTE _rec = pReader->GetUChar();
				switch (_rec)
				{
				case 0:
				{
					m_arrItems.push_back(new CCell());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 1:
				{
					m_arrItems.push_back(new CTrigger());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 2:
				{
					m_arrItems.push_back(new CSection());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 3:
				{
					m_arrItems.push_back(new CText());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 4:
				{
					m_arrItems.push_back(new CForeignData());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				case 5:
				{
					m_arrItems.push_back(new CShapes());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				default:
				{
					pReader->SkipRecord();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CShape::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"Shape");
			pWriter->StartAttributes();
			pWriter->WriteAttribute2(L"ID", ID);
			pWriter->WriteAttribute2(L"OriginalID", OriginalID);
			if (Type.IsInit()) pWriter->WriteAttribute2(L"Type", Type->ToString());
			pWriter->WriteAttribute(L"Del", Del);
			pWriter->WriteAttribute2(L"MasterShape", MasterShape);
			pWriter->WriteAttribute2(L"UniqueID", UniqueID);
			pWriter->WriteAttribute2(L"NameU", NameU);
			pWriter->WriteAttribute2(L"Name", Name);
			pWriter->WriteAttribute(L"IsCustomName", IsCustomName);
			pWriter->WriteAttribute(L"IsCustomNameU", IsCustomNameU);
			pWriter->WriteAttribute2(L"Master", Master);
			pWriter->WriteAttribute2(L"LineStyle", LineStyle);
			pWriter->WriteAttribute2(L"FillStyle", FillStyle);
			pWriter->WriteAttribute2(L"TextStyle", TextStyle);
			pWriter->EndAttributes();

			for (size_t i = 0; i < m_arrItems.size(); ++i)
				m_arrItems[i]->toXmlWriter(pWriter);

			pWriter->WriteNodeEnd(L"Shape");
		}
		EElementType CShapes::getType() const
		{
			return et_dr_Shapes;
		}
		void CShapes::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = oReader.GetName();

				if (L"Shape" == sName)
				{
					CShape* pItem = new CShape();
					*pItem = oReader;

					if (pItem)
						m_arrItems.push_back(pItem);
				}
			}
		}
		void CShapes::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
			while (pReader->GetPos() < end)
			{
				BYTE _rec = pReader->GetUChar();
				switch (_rec)
				{
				case 0:
				{
					m_arrItems.push_back(new CShape());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				default:
				{
					pReader->SkipRecord();
				}break;
				}
			}
			pReader->Seek(end);
		}
		void CShapes::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			for (size_t i = 0; i < m_arrItems.size(); ++i)
				pWriter->WriteRecord2(0, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
		}
		void CShapes::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"Shapes");
			pWriter->EndAttributes();

			for (size_t i = 0; i < m_arrItems.size(); ++i)
				m_arrItems[i]->toXmlWriter(pWriter);

			pWriter->WriteNodeEnd(L"Shapes");
		}
		EElementType CConnect::getType() const
		{
			return et_dr_Connect;
		}
		void CConnect::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_StartChar_No_NS(oReader)
				WritingElement_ReadAttributes_Read_ifChar(oReader, "FromSheet", FromSheet)
				WritingElement_ReadAttributesA_Read_else_ifChar(oReader, "FromCell", FromCell)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "FromPart", FromPart)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ToSheet", ToSheet)
				WritingElement_ReadAttributesA_Read_else_ifChar(oReader, "ToCell", ToCell)
				WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ToPart", ToPart)
			WritingElement_ReadAttributes_EndChar_No_NS(oReader)
		}
		void CConnect::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);
			if (!oReader.IsEmptyNode())
				oReader.ReadTillEnd();
		}
		void CConnect::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
			pWriter->WriteUInt2(0, FromSheet);
			pWriter->WriteString2(1, FromCell);
			pWriter->WriteInt2(2, FromPart);
			pWriter->WriteUInt2(3, ToSheet);
			pWriter->WriteString2(4, ToCell);
			pWriter->WriteInt2(5, ToPart);
			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
		}
		void CConnect::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
			pReader->Skip(1); // start attributes
			while (true)
			{
				BYTE _at = pReader->GetUChar_TypeNode();
				if (_at == NSBinPptxRW::g_nodeAttributeEnd)
					break;
				switch (_at)
				{
				case 0:
				{
					FromSheet = pReader->GetULong();
				}break;
				case 1:
				{
					FromCell = pReader->GetString2A();
				}break;
				case 2:
				{
					FromPart = pReader->GetLong();
				}break;
				case 3:
				{
					ToSheet = pReader->GetULong();
				}break;
				case 4:
				{
					ToCell = pReader->GetString2A();
				}break;
				case 5:
				{
					ToPart = pReader->GetLong();
				}break;
				}
			}
			pReader->Seek(_end_rec);
		}
		void CConnect::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"Connect");
			pWriter->StartAttributes();
			pWriter->WriteAttribute2(L"FromSheet", FromSheet);
			pWriter->WriteAttribute2(L"FromCell", FromCell);
			pWriter->WriteAttribute(L"FromPart", FromPart);
			pWriter->WriteAttribute2(L"ToSheet", ToSheet);
			pWriter->WriteAttribute2(L"ToCell", ToCell);
			pWriter->WriteAttribute(L"ToPart", ToPart);
			pWriter->EndAttributes();
			pWriter->WriteNodeEnd(L"Connect");
		}
		void CConnects::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = oReader.GetName();

				if (L"Connect" == sName)
				{
					CConnect* pItem = new CConnect();
					*pItem = oReader;

					if (pItem)
						m_arrItems.push_back(pItem);
				}
			}
		}
		EElementType CConnects::getType() const
		{
			return et_dr_Connects;
		}
		void CConnects::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
		{
			LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
			while (pReader->GetPos() < end)
			{
				BYTE _rec = pReader->GetUChar();
				switch (_rec)
				{
				case 0:
				{
					m_arrItems.push_back(new CConnect());
					m_arrItems.back()->fromPPTY(pReader);
				}break;
				default:
				{
					pReader->SkipRecord();
				}break;
				}
			}
			pReader->Seek(end);
		}
		void CConnects::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
		{
			for (size_t i = 0; i < m_arrItems.size(); ++i)
				pWriter->WriteRecord2(0, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
		}
		void CConnects::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
		{
			pWriter->StartNode(L"Connects");
			pWriter->EndAttributes();

			for (size_t i = 0; i < m_arrItems.size(); ++i)
				m_arrItems[i]->toXmlWriter(pWriter);

			pWriter->WriteNodeEnd(L"Connects");
		}
	}
} // namespace OOX