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

#include "../Common.h"

#include "../SharedStrings/Text.h"
#include "../ComplexTypes_Spreadsheet.h"

#include "../../DocxFormat/Drawing/DrawingExt.h"

#include "../../XlsbFormat/Xlsb.h"
#include "../../XlsbFormat/ExternalLinkStream.h"

#include "../../XlsbFormat/Biff12_unions/EXTERNALLINK.h"
#include "../../XlsbFormat/Biff12_records/BeginSupBook.h"
#include "../../XlsbFormat/Biff12_unions/EXTERNALBOOK.h"
#include "../../XlsbFormat/Biff12_unions/DDEOLELINK.h"
#include "../../XlsbFormat/Biff12_records/SupTabs.h"
#include "../../XlsbFormat/Biff12_unions/EXTERNNAME.h"
#include "../../XlsbFormat/Biff12_records/SupNameStart.h"
#include "../../XlsbFormat/Biff12_records/SupNameFmla.h"
#include "../../XlsbFormat/Biff12_records/SupNameBits.h"
#include "../../XlsbFormat/Biff12_unions/EXTERNTABLE.h"
#include "../../XlsbFormat/Biff12_records/ExternTableStart.h"
#include "../../XlsbFormat/Biff12_unions/EXTERNROW.h"
#include "../../XlsbFormat/Biff12_records/ExternRowHdr.h"
#include "../../XlsbFormat/Biff12_unions/EXTERNVALUE.h"
#include "../../XlsbFormat/Biff12_records/ExternValueMeta.h"
#include "../../XlsbFormat/Biff12_unions/EXTERNVALUEDATA.h"
#include "../../XlsbFormat/Biff12_records/ExternCell.h"
#include "../../XlsbFormat/Biff12_unions/DDEOLEITEM.h"
#include "../../XlsbFormat/Biff12_unions/DDEOLEITEMVALUES.h"
#include "../../XlsbFormat/Biff12_unions/DDEOLEITEMVALUE.h"
#include "../../XlsbFormat/Biff12_records/SupNameValueStart.h"
#include "../../XlsbFormat/Biff12_records/SupName.h"

#include "../../../MsBinaryFile/XlsFile/Format/Logic/GlobalWorkbookInfo.h"
#include "../../../MsBinaryFile/XlsFile/Format/Logic/Biff_structures/BIFF12/CellRef.h"
#include "../../Binary/XlsbFormat/FileTypes_SpreadsheetBin.h"
#include <string>

namespace OOX
{
namespace Spreadsheet
{
	CExternalSheetNames::CExternalSheetNames()
	{
	}
	CExternalSheetNames::~CExternalSheetNames()
	{
	}
	void CExternalSheetNames::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CExternalSheetNames::getType() const
	{
		return et_x_ExternalSheetNames;
	}
	void CExternalSheetNames::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		if (oReader.IsEmptyNode())
			return;

		int nCurDepth = oReader.GetDepth();
		while (oReader.ReadNextSiblingNode(nCurDepth))
		{
			std::wstring sName = oReader.GetName();
			if (L"sheetName" == sName)
			{
				m_arrItems.push_back(PPTX::CreatePtrXmlContent<ComplexTypes::Spreadsheet::String>(oReader));
			}
		}
	}
	void CExternalSheetNames::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<sheetNames>");
		for (size_t i = 0; i < m_arrItems.size(); ++i)
		{
			if (m_arrItems[i])
			{
				writer.WriteString(L"<sheetName");
				WritingStringAttrEncodeXmlString(L"val", m_arrItems[i]->ToString2());
				writer.WriteString(L"/>");
			}
		}
		writer.WriteString(L"</sheetNames>");
	}
	std::wstring CExternalSheetNames::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	XLS::BaseObjectPtr CExternalSheetNames::toBin()
	{
		XLSB::SupTabsPtr supTabs(new XLSB::SupTabs);
		for (auto& item : m_arrItems)
		{
			XLSB::XLWideString str = *item->m_sVal;
			supTabs->sheetNames.push_back(str);
		}
		return supTabs;
	}
	void CExternalSheetNames::fromBin(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::SupTabs*>(obj.get());
		if (ptr != nullptr)
		{
			for (auto &item : ptr->sheetNames)
			{
				auto str = new ComplexTypes::Spreadsheet::String;
				str->m_sVal = item.value();
				m_arrItems.push_back(str);
			}
		}
	}

	CExternalDefinedName::CExternalDefinedName()
	{
	}
	CExternalDefinedName::~CExternalDefinedName()
	{
	}
	void CExternalDefinedName::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CExternalDefinedName::getType() const
	{
		return et_x_ExternalDefinedName;
	}
	void CExternalDefinedName::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (!oReader.IsEmptyNode())
			oReader.ReadTillEnd();
	}
	void CExternalDefinedName::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<definedName");
		WritingStringNullableAttrEncodeXmlString(L"name", m_oName, m_oName.get());
		WritingStringNullableAttrEncodeXmlString(L"refersTo", m_oRefersTo, m_oRefersTo.get());
		WritingStringNullableAttrInt(L"sheetId", m_oSheetId, m_oSheetId->GetValue());
		writer.WriteString(L"/>");
	}
	std::wstring CExternalDefinedName::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	void CExternalDefinedName::fromBin(XLS::BaseObjectPtr& obj)
	{
		ReadAttributes(obj);
	}
	XLS::BaseObjectPtr CExternalDefinedName::toBin()
	{
		XLSB::ExternalReferenceType type;
		type = XLSB::ExternalReferenceType::WORKBOOK;
		auto ptr(new XLSB::EXTERNNAME(type));
		XLS::BaseObjectPtr objectPtr(ptr);

		if(m_oName.IsInit())
		{
			auto nameStart(new XLSB::SupNameStart);
			nameStart->name = m_oName.get();
			ptr->m_BrtSupNameStart = XLS::BaseObjectPtr{nameStart};
		}
		if(m_oRefersTo.IsInit())
		{
			auto nameFmla(new XLSB::SupNameFmla);
			ptr->m_BrtSupNameFmla = XLS::BaseObjectPtr{nameFmla};
			nameFmla->fmla = m_oRefersTo.get();
		}
		if(m_oSheetId.IsInit())
		{
			auto supBits(new XLSB::SupNameBits(type));
			ptr->m_BrtSupNameBits = XLS::BaseObjectPtr{supBits};
			supBits->sbt = 0x0000;
			supBits->contentsExtName.iSheet = m_oSheetId->GetValue();
			supBits->contentsExtName.fBuiltIn = false;
		}
		return objectPtr;
	}
	void CExternalDefinedName::ReadAttributes(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::EXTERNNAME*>(obj.get());
		if (ptr != nullptr)
		{
			auto ptrSupNameStart = static_cast<XLSB::SupNameStart*>(ptr->m_BrtSupNameStart.get());
			if (ptrSupNameStart != nullptr)
			{
				if (!ptrSupNameStart->name.value().empty())
					m_oName = ptrSupNameStart->name.value();
			}

			auto ptrSupNameFmla = static_cast<XLSB::SupNameFmla*>(ptr->m_BrtSupNameFmla.get());
			if (ptrSupNameFmla != nullptr)
			{
				auto ref = ptrSupNameFmla->fmla.getAssembledFormula();
				if (!ref.empty())
					m_oRefersTo = ref;
			}

			auto ptrSupNameBits = static_cast<XLSB::SupNameBits*>(ptr->m_BrtSupNameBits.get());
			if (ptrSupNameBits != nullptr)
			{
				m_oSheetId = ptrSupNameBits->contentsExtName.iSheet;
			}

		}
	}
	void CExternalDefinedName::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_Read_if(oReader, (L"name"), m_oName)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"refersTo"), m_oRefersTo)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"sheetId"), m_oSheetId)
			WritingElement_ReadAttributes_End(oReader)
	}

	CExternalDefinedNames::CExternalDefinedNames()
	{
	}
	CExternalDefinedNames::~CExternalDefinedNames()
	{
	}
	void CExternalDefinedNames::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CExternalDefinedNames::getType() const
	{
		return et_x_ExternalDefinedNames;
	}
	void CExternalDefinedNames::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		if (oReader.IsEmptyNode())
			return;

		int nCurDepth = oReader.GetDepth();
		while (oReader.ReadNextSiblingNode(nCurDepth))
		{
			std::wstring sName = oReader.GetName();
			if (L"definedName" == sName)
			{
				CExternalDefinedName* pExternalDefinedName = new CExternalDefinedName();
				*pExternalDefinedName = oReader;
				m_arrItems.push_back(pExternalDefinedName);
			}
		}
	}
	void CExternalDefinedNames::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<definedNames>");
		for (size_t i = 0; i < m_arrItems.size(); ++i)
		{
			if (m_arrItems[i])
			{
				m_arrItems[i]->toXML(writer);
			}
		}
		writer.WriteString(L"</definedNames>");
	}
	std::wstring CExternalDefinedNames::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	void CExternalDefinedNames::fromBin(std::vector<XLS::BaseObjectPtr>& obj)
	{
		for (auto &item : obj)
		{
			m_arrItems.push_back(new CExternalDefinedName(item));
		}
	}
	std::vector<XLS::BaseObjectPtr> CExternalDefinedNames::toBin()
	{
		std::vector<XLS::BaseObjectPtr> objectVector;
		for(auto i:m_arrItems)
		{
			objectVector.push_back(i->toBin());
		}
		return objectVector;
	}
	CExternalCell::CExternalCell()
	{
	}
	CExternalCell::~CExternalCell()
	{
	}
	void CExternalCell::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CExternalCell::getType() const
	{
		return et_x_ExternalCell;
	}
	void CExternalCell::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (oReader.IsEmptyNode())
			return;

		int nCurDepth = oReader.GetDepth();
		while (oReader.ReadNextSiblingNode(nCurDepth))
		{
			std::wstring sName = oReader.GetName();
			if (L"v" == sName)
			{
				m_oValue = oReader;
			}
		}
	}
	void CExternalCell::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<cell");
		WritingStringNullableAttrString(L"r", m_oRef, m_oRef.get());
		WritingStringNullableAttrString(L"t", m_oType, m_oType->ToString());
		WritingStringNullableAttrInt2(L"vm", m_oValueMetadata);
		writer.WriteString(L">");
		if (m_oValue.IsInit())
			m_oValue->toXML2(writer, (L"v"));
		writer.WriteString(L"</cell>");
	}
	std::wstring CExternalCell::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	XLS::BaseObjectPtr CExternalCell::toBin()
	{
		
		auto ptr(new XLSB::EXTERNVALUE(0));
		XLS::BaseObjectPtr objectPtr(ptr);
		if(m_oValueMetadata.IsInit())
		{
			auto metaPtr(new XLSB::ExternValueMeta);
			ptr->m_BrtExternValueMeta = XLS::BaseObjectPtr{metaPtr};
			metaPtr->ivmb = m_oValueMetadata.get();
		}

		auto valuePtr(new XLSB::EXTERNVALUEDATA(0));
		ptr->m_EXTERNVALUEDATA = XLS::BaseObjectPtr{valuePtr};
		XLSB::RgceLoc loc;
		if(m_oRef.IsInit())
			loc = XLSB::RgceLoc(m_oRef.get());
		else
			loc = XLSB::RgceLoc(L"A1");
		valuePtr->m_Col = loc.getColumn();
		if(!m_oValue.IsInit())
		{	auto blanc(new XLSB::ExternCellBlank);
			blanc->col = valuePtr->m_Col;
			valuePtr->m_source = XLS::BaseObjectPtr{blanc};
			return objectPtr;
		}
		if(!m_oType.IsInit())
		{
			m_oType.Init();
			m_oType->SetValue(SimpleTypes::Spreadsheet::celltypeStr);
		}
		switch(m_oType->GetValue())
		{
			case SimpleTypes::Spreadsheet::celltypeStr:
			{
				auto str(new XLSB::ExternCellString);
				str->col = valuePtr->m_Col;
				str->value = m_oValue->m_sText;
				valuePtr->m_source = XLS::BaseObjectPtr{str};
				break;
			}
			case SimpleTypes::Spreadsheet::celltypeBool:
			{
				auto boolVal(new XLSB::ExternCellBool);
				boolVal->col = valuePtr->m_Col;
				boolVal->value = m_oValue->m_sText == L"1" ? true : false;
				valuePtr->m_source = XLS::BaseObjectPtr{boolVal};
				break;
			}
			case SimpleTypes::Spreadsheet::celltypeNumber:
			{
				auto doubleVal(new XLSB::ExternCellReal);
				doubleVal->col = valuePtr->m_Col;
				doubleVal->value.data.value = std::stod(m_oValue->m_sText);
				valuePtr->m_source = XLS::BaseObjectPtr{doubleVal};
				break;
			}
			case SimpleTypes::Spreadsheet::celltypeError:
			{
				auto errVal(new XLSB::ExternCellError);
				errVal->col = valuePtr->m_Col;
				if(m_oValue->m_sText == L"#NULL!")
					errVal->value = 0;
				else if(m_oValue->m_sText == L"#DIV/0!")
					errVal->value = 0x7;
				else if(m_oValue->m_sText ==  L"#VALUE!")
					errVal->value = 0xF;
				else if(m_oValue->m_sText ==  L"#REF!")
					errVal->value = 0x17;
				else if(m_oValue->m_sText ==  L"#NAME?")
					errVal->value = 0x1D;
				else if(m_oValue->m_sText ==  L"#NUM!")
					errVal->value = 0x24;
				else if(m_oValue->m_sText ==  L"#N/A")
					errVal->value = 0x2A;
				else if(m_oValue->m_sText ==  L"#GETTING_DATA")
					errVal->value = 0x2B;
				else
					errVal->value = 0x2A;
				valuePtr->m_source = XLS::BaseObjectPtr{errVal};
				break;
			}
			default:
			{
				auto blanc(new XLSB::ExternCellBlank);
				blanc->col = valuePtr->m_Col;
				valuePtr->m_source = XLS::BaseObjectPtr{blanc};
			}
		};
		
		return objectPtr;
	}
	void CExternalCell::fromBin(XLS::BaseObjectPtr& obj)
	{
		ReadAttributes(obj);
	}
	void CExternalCell::ReadAttributes(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::EXTERNVALUE*>(obj.get());
		if (ptr != nullptr)
		{
			auto ptrExternValueMeta = static_cast<XLSB::ExternValueMeta*>(ptr->m_BrtExternValueMeta.get());
			if (ptrExternValueMeta != nullptr)
			{
				m_oValueMetadata = ptrExternValueMeta->ivmb;
			}

			auto ptrEXTERNVALUEDATA = static_cast<XLSB::EXTERNVALUEDATA*>(ptr->m_EXTERNVALUEDATA.get());
			if (ptrEXTERNVALUEDATA != nullptr)
			{
				if (!ptrEXTERNVALUEDATA->m_Ref.empty())
					m_oRef = ptrEXTERNVALUEDATA->m_Ref;

				if (ptrEXTERNVALUEDATA->m_source != nullptr)
				{
					auto pSource = static_cast<XLS::BiffRecord*>(ptrEXTERNVALUEDATA->m_source.get());
					auto nType = pSource->getTypeId();
					switch (nType)
					{
					case XLSB::rt_ExternCellBlank:
						break;
					case XLSB::rt_ExternCellReal:
					{
						auto pRealNum = reinterpret_cast<XLSB::ExternCellReal*>(pSource)->value.data.value;
						m_oType.Init();
                        m_oType->SetValue(SimpleTypes::Spreadsheet::celltypeNumber);
						m_oValue.Init();
						m_oValue->m_sText = OOX::Spreadsheet::SpreadsheetCommon::WriteDouble(pRealNum);
					}
					break;
					case XLSB::rt_ExternCellBool:
					{
						auto pBool = reinterpret_cast<XLSB::ExternCellBool*>(pSource)->value;
						m_oType.Init();
						m_oType->SetValue(SimpleTypes::Spreadsheet::celltypeBool);
						m_oValue.Init();
						m_oValue->m_sText = pBool ? L"1" : L"0";
					}
					break;
					case XLSB::rt_ExternCellError:
					{
						auto pError = reinterpret_cast<XLSB::ExternCellError*>(pSource)->value;
						m_oType.Init();
						m_oType->SetValue(SimpleTypes::Spreadsheet::celltypeError);
						m_oValue.Init();
						switch (pError)
						{
						case 0x00: m_oValue->m_sText = L"#NULL!"; break;
						case 0x07: m_oValue->m_sText = L"#DIV/0!"; break;
						case 0x0F: m_oValue->m_sText = L"#VALUE!"; break;
						case 0x17: m_oValue->m_sText = L"#REF!"; break;
						case 0x1D: m_oValue->m_sText = L"#NAME?"; break;
						case 0x24: m_oValue->m_sText = L"#NUM!"; break;
						case 0x2A: m_oValue->m_sText = L"#N/A"; break;
						case 0x2B: m_oValue->m_sText = L"#GETTING_DATA"; break;
						}
					}
					break;
					case XLSB::rt_ExternCellString:
					{
						auto pSt = reinterpret_cast<XLSB::ExternCellString*>(pSource)->value.value();
						m_oType.Init();
                        m_oType->SetValue(SimpleTypes::Spreadsheet::celltypeStr);
						m_oValue.Init();
						m_oValue->m_sText = pSt;
					}
					break;
					}
				}

			}

		}
	}
	void CExternalCell::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_Read_if(oReader, (L"r"), m_oRef)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"t"), m_oType)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"vm"), m_oValueMetadata)
		WritingElement_ReadAttributes_End(oReader)
	}

	CExternalRow::CExternalRow()
	{
	}
	CExternalRow::~CExternalRow()
	{
	}
	void CExternalRow::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CExternalRow::getType() const
	{
		return et_x_ExternalRow;
	}
	void CExternalRow::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (oReader.IsEmptyNode())
			return;

		int nCurDepth = oReader.GetDepth();
		while (oReader.ReadNextSiblingNode(nCurDepth))
		{
			std::wstring sName = oReader.GetName();
			if (L"cell" == sName)
			{
				CExternalCell* pExternalCell = new CExternalCell();
				*pExternalCell = oReader;
				m_arrItems.push_back(pExternalCell);
			}
		}
	}
	void CExternalRow::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<row");
		WritingStringNullableAttrInt(L"r", m_oR, m_oR->GetValue());
		writer.WriteString(L">");

		for (size_t i = 0; i < m_arrItems.size(); ++i)
		{
			if (m_arrItems[i])
			{
				m_arrItems[i]->toXML(writer);
			}
		}

		writer.WriteString(L"</row>");
	}
	std::wstring CExternalRow::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	XLS::BaseObjectPtr CExternalRow::toBin()
	{
		auto ptr(new XLSB::EXTERNROW);
		XLS::BaseObjectPtr objectPtr(ptr);
		auto ptr1(new XLSB::ExternRowHdr);
		ptr->m_BrtExternRowHdr = XLS::BaseObjectPtr{ptr1};

		if(m_oR.IsInit() && m_oR->GetValue() > 0)
		{
			ptr1->rw = m_oR->GetValue() - 1;
		}
		else
			ptr1->rw = 0;

		for(auto i:m_arrItems)
		{
			ptr->m_arEXTERNVALUE.push_back(i->toBin());
		}

		return objectPtr;
	}
	void CExternalRow::fromBin(XLS::BaseObjectPtr& obj)
	{
		ReadAttributes(obj);
	}
	void CExternalRow::ReadAttributes(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::EXTERNROW*>(obj.get());
		if (ptr != nullptr)
		{
			auto ptrExternRowHdr = static_cast<XLSB::ExternRowHdr*>(ptr->m_BrtExternRowHdr.get());
			if (ptrExternRowHdr != nullptr)
			{
				m_oR = ptrExternRowHdr->rw + 1;
			}

			for (auto &item : ptr->m_arEXTERNVALUE)
				m_arrItems.push_back(new CExternalCell(item));
		}
	}
	void CExternalRow::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_ReadSingle(oReader, (L"r"), m_oR)
			WritingElement_ReadAttributes_End(oReader)
	}

	CExternalSheetData::CExternalSheetData()
	{
	}
	CExternalSheetData::~CExternalSheetData()
	{
	}
	void CExternalSheetData::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CExternalSheetData::getType() const
	{
		return et_x_ExternalSheetData;
	}
	void CExternalSheetData::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (oReader.IsEmptyNode())
			return;

		int nCurDepth = oReader.GetDepth();
		while (oReader.ReadNextSiblingNode(nCurDepth))
		{
			std::wstring sName = oReader.GetName();
			if (L"row" == sName)
			{
				CExternalRow* pExternalRow = new CExternalRow();
				*pExternalRow = oReader;
				m_arrItems.push_back(pExternalRow);
			}
		}
	}
	void CExternalSheetData::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<sheetData");
		WritingStringNullableAttrInt(L"sheetId", m_oSheetId, m_oSheetId->GetValue());
		WritingStringNullableAttrBool(L"refreshError", m_oRefreshError);
		writer.WriteString(L">");

		for (size_t i = 0; i < m_arrItems.size(); ++i)
		{
			if (m_arrItems[i])
			{
				m_arrItems[i]->toXML(writer);
			}
		}

		writer.WriteString(L"</sheetData>");
	}
	std::wstring CExternalSheetData::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	XLS::BaseObjectPtr CExternalSheetData::toBin()
	{
		auto ptr(new XLSB::EXTERNTABLE);
		XLS::BaseObjectPtr objectPtr(ptr);
		auto ptr1(new XLSB::ExternTableStart);
		ptr->m_BrtExternTableStart = XLS::BaseObjectPtr{ptr1};

		if(m_oSheetId.IsInit())
			ptr1->iTab = m_oSheetId->GetValue();
		else
			ptr1->iTab = 0;
		if(m_oRefreshError.IsInit())
			ptr1->fRefreshError = m_oRefreshError->GetValue();
		else
			ptr1->fRefreshError = false;
		
		for(auto i:m_arrItems)
		{
			ptr->m_arEXTERNROW.push_back(i->toBin());
		}

		return objectPtr;
	}
	void CExternalSheetData::fromBin(XLS::BaseObjectPtr& obj)
	{
		ReadAttributes(obj);
	}
	void CExternalSheetData::ReadAttributes(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::EXTERNTABLE*>(obj.get());
		if (ptr != nullptr)
		{
			auto ptrExternTableStart = static_cast<XLSB::ExternTableStart*>(ptr->m_BrtExternTableStart.get());
			if (ptrExternTableStart != nullptr)
			{
				m_oSheetId = ptrExternTableStart->iTab;
				m_oRefreshError = ptrExternTableStart->fRefreshError;
			}

			for (auto &item : ptr->m_arEXTERNROW)
				m_arrItems.push_back(new CExternalRow(item));
		}
	}
	void CExternalSheetData::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_Read_if(oReader, (L"sheetId"), m_oSheetId)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"refreshError"), m_oRefreshError)
			WritingElement_ReadAttributes_End(oReader)
	}

	CExternalSheetDataSet::CExternalSheetDataSet()
	{
	}
	CExternalSheetDataSet::~CExternalSheetDataSet()
	{
	}
	void CExternalSheetDataSet::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CExternalSheetDataSet::getType() const
	{
		return et_x_ExternalSheetDataSet;
	}
	void CExternalSheetDataSet::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		if (oReader.IsEmptyNode())
			return;

		int nCurDepth = oReader.GetDepth();
		while (oReader.ReadNextSiblingNode(nCurDepth))
		{
			std::wstring sName = oReader.GetName();
			if (L"sheetData" == sName)
			{
				CExternalSheetData* pExternalSheetData = new CExternalSheetData();
				*pExternalSheetData = oReader;
				m_arrItems.push_back(pExternalSheetData);
			}
		}
	}
	void CExternalSheetDataSet::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<sheetDataSet>");
		for (size_t i = 0; i < m_arrItems.size(); ++i)
		{
			if (m_arrItems[i])
			{
				m_arrItems[i]->toXML(writer);
			}
		}
		writer.WriteString(L"</sheetDataSet>");
	}
	std::wstring CExternalSheetDataSet::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	void CExternalSheetDataSet::fromBin(std::vector<XLS::BaseObjectPtr>& obj)
	{
		for (auto &item : obj)
		{
			m_arrItems.push_back(new CExternalSheetData(item));
		}
	}
	std::vector<XLS::BaseObjectPtr> CExternalSheetDataSet::toBin()
	{
		std::vector<XLS::BaseObjectPtr> objectVector;
		for(auto i:m_arrItems)
		{
			objectVector.push_back(i->toBin());
		}
		return objectVector;
	}
	CExternalBook::CExternalBook()
	{
	}
	CExternalBook::~CExternalBook()
	{
	}
	void CExternalBook::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CExternalBook::getType() const
	{
		return et_x_ExternalBook;
	}
	void CExternalBook::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (oReader.IsEmptyNode())
			return;

		int nCurDepth = oReader.GetDepth();
		while (oReader.ReadNextSiblingNode(nCurDepth))
		{
			std::wstring sName = oReader.GetNameNoNS();

			if (L"sheetNames" == sName)
			{
				m_oSheetNames = oReader;
			}
			else if (L"definedNames" == sName)
			{
				m_oDefinedNames = oReader;
			}
			else if (L"sheetDataSet" == sName)
			{
				m_oSheetDataSet = oReader;
			}
			else if (L"alternateUrls" == sName)
			{
				m_oAlternateUrls = oReader;
			}
		}
	}
	void CExternalBook::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<externalBook");
		if (m_oRid.IsInit())
		{
			writer.WriteString(L" r:id=\"");
			writer.WriteString(m_oRid->ToString());
			writer.WriteString(L"\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\"");
		}
		writer.WriteString(L">");
		if (m_oAlternateUrls.IsInit())
		{
			m_oAlternateUrls ->toXML(writer);
		}
		if (m_oSheetNames.IsInit())
		{
			m_oSheetNames->toXML(writer);
		}
		if (m_oDefinedNames.IsInit())
		{
			m_oDefinedNames->toXML(writer);
		}
		if (m_oSheetDataSet.IsInit())
		{
			m_oSheetDataSet->toXML(writer);
		}
		writer.WriteString(L"</externalBook>");
	}
	std::wstring CExternalBook::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	XLS::BaseObjectPtr CExternalBook::toBin()
	{
		XLSB::EXTERNALLINKPtr externalLINK(new XLSB::EXTERNALLINK());
		auto beginSupbook(new XLSB::BeginSupBook);
		if(m_oRid.IsInit())
			beginSupbook->string1 = m_oRid->GetValue();
		else
			beginSupbook->string1 = L" ";
		beginSupbook->sbt = 0;
		externalLINK->m_BrtBeginSupBook = XLS::BaseObjectPtr{beginSupbook};
		XLSB::ExternalReferenceType type;
		type = XLSB::ExternalReferenceType::WORKBOOK;
		XLSB::EXTERNALBOOKPtr externalBOOK(new XLSB::EXTERNALBOOK(type));

		externalLINK->m_EXTERNALBOOK = externalBOOK;
		if (externalBOOK != nullptr)
		{
			if (m_oSheetNames.IsInit())
				externalBOOK->m_BrtSupTabs = m_oSheetNames->toBin();
			if(m_oDefinedNames.IsInit())
				externalBOOK->m_arEXTERNNAME = m_oDefinedNames->toBin();
			if(m_oSheetDataSet.IsInit())
				externalBOOK->m_arEXTERNTABLE = m_oSheetDataSet->toBin();
		}
		return externalLINK;
	}
	void CExternalBook::fromBin(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::EXTERNALLINK*>(obj.get());
		if (ptr != nullptr)
		{
			ReadAttributes(ptr->m_BrtBeginSupBook);

			auto ptr1 = static_cast<XLSB::EXTERNALBOOK*>(ptr->m_EXTERNALBOOK.get());
			if (ptr1 != nullptr)
			{
				if (ptr1->m_BrtSupTabs != nullptr)
					m_oSheetNames = ptr1->m_BrtSupTabs;
				if (!ptr1->m_arEXTERNNAME.empty())
					m_oDefinedNames = ptr1->m_arEXTERNNAME;
				if (!ptr1->m_arEXTERNTABLE.empty())
					m_oSheetDataSet = ptr1->m_arEXTERNTABLE;
			}
		}
	}
	void CExternalBook::ReadAttributes(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::BeginSupBook*>(obj.get());
		if (ptr != nullptr)
		{
			if (!ptr->string1.empty())
				m_oRid = ptr->string1;
		}
	}
	void CExternalBook::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start_No_NS(oReader)
			WritingElement_ReadAttributes_ReadSingle(oReader, L"id", m_oRid)
			WritingElement_ReadAttributes_End_No_NS(oReader)
	}

	CDdeValue::CDdeValue()
	{
	}
	CDdeValue::~CDdeValue()
	{
	}
	void CDdeValue::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CDdeValue::getType() const
	{
		return et_x_DdeValue;
	}
	void CDdeValue::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (oReader.IsEmptyNode())
			return;

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

			if (L"val" == sName)
			{
				CText* pText = new CText();
				*pText = oReader;
				m_arrItems.push_back(pText);
			}
		}
	}
	void CDdeValue::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<value");
		WritingStringNullableAttrString(L"t", m_oType, m_oType->ToString());
		writer.WriteString(L">");

		for (size_t i = 0; i < m_arrItems.size(); ++i)
		{
			if (m_arrItems[i])
			{
				m_arrItems[i]->toXML2(writer, L"val");
			}
		}
		writer.WriteString(L"</value>");
	}
	std::wstring CDdeValue::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	XLS::BaseObjectPtr CDdeValue::toBin()
	{
		XLSB::DDEOLEITEMVALUEPtr ptr(new XLSB::DDEOLEITEMVALUE);
		if(!m_oType.IsInit())
			return ptr;
		auto type = m_oType->GetValue();
		switch(type)
		{
			case XLSB::rt_SupNameNum:
				{
					ptr->m_source = XLS::BaseObjectPtr{new XLSB::SupNameNum};
					if(!m_arrItems.empty())
					{
						auto castedSource = reinterpret_cast<XLSB::SupNameNum*>(ptr->m_source.get());
						castedSource->value.data.value = std::stod(m_arrItems.back()->m_sText);
						m_arrItems.pop_back();
					}
				}
				break;
				case XLSB::rt_SupNameBool:
				{
                    ptr->m_source = XLS::BaseObjectPtr{new XLSB::SupNameBool};
					if(!m_arrItems.empty())
					{
						auto castedSource = reinterpret_cast<XLSB::SupNameBool*>(ptr->m_source.get());
                        castedSource->value = std::stoi(m_arrItems.back()->m_sText);
						m_arrItems.pop_back();
					}

				}
				break;
				case XLSB::rt_SupNameErr:
				{
                    ptr->m_source = XLS::BaseObjectPtr{new XLSB::SupNameErr};
					if(!m_arrItems.empty())
					{
						auto castedSource = reinterpret_cast<XLSB::SupNameErr*>(ptr->m_source.get());
                        auto error = m_arrItems.back()->m_sText.c_str();

						if(error == L"#NULL!"){ castedSource->value = 0x00;}
						else if(error == L"#DIV/0!"){castedSource->value = 0x07;}
						else if(error == L"#VALUE!"){ castedSource->value = 0x0F;}
						else if(error == L"#REF!"){ castedSource->value = 0x17;}
						else if(error == L"#NAME?"){ castedSource->value = 0x1D;}
						else if(error == L"#NUM!"){castedSource->value = 0x24;}
						else if(error == L"#N/A"){castedSource->value = 0x2A;}
						else if(error == L"#GETTING_DATA"){castedSource->value = 0x2B;}

						m_arrItems.pop_back();
					}
				}
				break;
				case XLSB::rt_SupNameSt:
				{
					ptr->m_source = XLS::BaseObjectPtr{new XLSB::SupNameSt};
					if(!m_arrItems.empty())
					{
						auto castedSource = reinterpret_cast<XLSB::SupNameSt*>(ptr->m_source.get());
						castedSource->value = m_arrItems.back()->m_sText;
						m_arrItems.pop_back();
					}
				}
				break;
				case XLSB::rt_SupNameNil:
				{
					ptr->m_source = XLS::BaseObjectPtr{new XLSB::SupNameNil};
				}
				break;
		}
		return ptr;
	}
	void CDdeValue::fromBin(XLS::BaseObjectPtr& obj)
	{
		ReadAttributes(obj);
	}
	void CDdeValue::ReadAttributes(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::DDEOLEITEMVALUE*>(obj.get());
		if (ptr != nullptr)
		{

			if (ptr->m_source != nullptr)
			{
				auto pSource = static_cast<XLS::BiffRecord*>(ptr->m_source.get());
				auto nType = pSource->getTypeId();
				switch (nType)
				{
				case XLSB::rt_SupNameNum:
				{
					auto pRealNum = reinterpret_cast<XLSB::SupNameNum*>(pSource)->value.data.value;
					m_oType.Init();
					m_oType->SetValue(SimpleTypes::Spreadsheet::EDdeValueType::ddevaluetypeN);

					auto text = new CText();
					std::wstring val = OOX::Spreadsheet::SpreadsheetCommon::WriteDouble(pRealNum);
					text->fromBin(val);
					m_arrItems.push_back(text);
				}
				break;
				case XLSB::rt_SupNameBool:
				{
					auto pBool = reinterpret_cast<XLSB::SupNameBool*>(pSource)->value;
					m_oType.Init();
					m_oType->SetValue(SimpleTypes::Spreadsheet::EDdeValueType::ddevaluetypeB);

					auto text = new CText();
					std::wstring val = pBool ? L"1" : L"0";
					text->fromBin(val);
					m_arrItems.push_back(text);
				}
				break;
				case XLSB::rt_SupNameErr:
				{
					auto pError = reinterpret_cast<XLSB::SupNameErr*>(pSource)->value;
					m_oType.Init();
					m_oType->SetValue(SimpleTypes::Spreadsheet::EDdeValueType::ddevaluetypeE);

					auto text = new CText();
					std::wstring val;
					switch (pError)
					{
					case 0x00: val = L"#NULL!"; break;
					case 0x07: val = L"#DIV/0!"; break;
					case 0x0F: val = L"#VALUE!"; break;
					case 0x17: val = L"#REF!"; break;
					case 0x1D: val = L"#NAME?"; break;
					case 0x24: val = L"#NUM!"; break;
					case 0x2A: val = L"#N/A"; break;
					case 0x2B: val = L"#GETTING_DATA"; break;
					}
					text->fromBin(val);
					m_arrItems.push_back(text);
				}
				break;
				case XLSB::rt_SupNameSt:
				{
					auto pSt = reinterpret_cast<XLSB::SupNameSt*>(pSource)->value.value();
					m_oType.Init();
					m_oType->SetValue(SimpleTypes::Spreadsheet::EDdeValueType::ddevaluetypeStr);

					auto text = new CText();
					text->fromBin(pSt);
					m_arrItems.push_back(text);
				}
				break;
				case XLSB::rt_SupNameNil:
				{
					m_oType.Init();
					m_oType->SetValue(SimpleTypes::Spreadsheet::EDdeValueType::ddevaluetypeNil);;
				}
				break;
				}
			}
		}
	}
	void CDdeValue::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_ReadSingle(oReader, (L"t"), m_oType)
			WritingElement_ReadAttributes_End(oReader)
	}

	CDdeValues::CDdeValues()
	{
	}
	CDdeValues::~CDdeValues()
	{
	}
	void CDdeValues::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CDdeValues::getType() const
	{
		return et_x_DdeValues;
	}
	void CDdeValues::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (oReader.IsEmptyNode())
			return;

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

			if (L"value" == sName)
			{
				CDdeValue* pDdeValue = new CDdeValue();
				*pDdeValue = oReader;
				m_arrItems.push_back(pDdeValue);
			}
		}
	}
	void CDdeValues::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<values");
		WritingStringNullableAttrInt(L"rows", m_oRows, m_oRows->GetValue());
		WritingStringNullableAttrInt(L"cols", m_oCols, m_oCols->GetValue());
		writer.WriteString(L">");

		for (size_t i = 0; i < m_arrItems.size(); ++i)
		{
			if (m_arrItems[i])
			{
				m_arrItems[i]->toXML(writer);
			}
		}
		writer.WriteString(L"</values>");
	}
	std::wstring CDdeValues::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	void CDdeValues::fromBin(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::DDEOLEITEMVALUES*>(obj.get());
		if (ptr != nullptr)
		{
			ReadAttributes(ptr->m_BrtSupNameValueStart);

			for (auto &item : ptr->m_arDDEOLEITEMVALUE)
				m_arrItems.push_back(new CDdeValue(item));
		}
	}
	XLS::BaseObjectPtr CDdeValues::toBin()
	{
		XLSB::DDEOLEITEMVALUESPtr ptr(new XLSB::DDEOLEITEMVALUES);
		auto castedPtr = static_cast<XLSB::SupNameValueStart*>(ptr->m_BrtSupNameValueStart.get());
		if(m_oRows.IsInit())
			castedPtr->cRw = m_oRows->GetValue();
		if(m_oCols.IsInit())
		castedPtr->cCol = m_oCols->GetValue();
		for (auto &item : m_arrItems)
				ptr->m_arDDEOLEITEMVALUE.push_back(item->toBin());
       return ptr;
	}
	void CDdeValues::ReadAttributes(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::SupNameValueStart*>(obj.get());
		if (ptr != nullptr)
		{
			m_oRows = ptr->cRw;
			m_oCols = ptr->cCol;
		}
	}
	void CDdeValues::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_Read_if(oReader, (L"rows"), m_oRows)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"cols"), m_oCols)
			WritingElement_ReadAttributes_End(oReader)
	}

	CDdeItem::CDdeItem()
	{
	}
	CDdeItem::~CDdeItem()
	{
	}
	void CDdeItem::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CDdeItem::getType() const
	{
		return et_x_OleItem;
	}
	void CDdeItem::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (oReader.IsEmptyNode())
			return;

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

			if (L"values" == sName)
			{
				m_oDdeValues = oReader;
			}
		}
	}
	void CDdeItem::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<ddeItem");
		WritingStringNullableAttrEncodeXmlString(L"name", m_oName, m_oName.get());
		WritingStringNullableAttrBool(L"ole", m_oOle);
		WritingStringNullableAttrBool(L"advise", m_oAdvise);
		WritingStringNullableAttrBool(L"preferPic", m_oPreferPic);
		writer.WriteString(L">");
		if (m_oDdeValues.IsInit())
		{
			m_oDdeValues->toXML(writer);
		}
		writer.WriteString(L"</ddeItem>");
	}
	std::wstring CDdeItem::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	XLS::BaseObjectPtr CDdeItem::toBin()
	{
		XLSB::ExternalReferenceType type;
		XLSB::DDEOLEITEMPtr ptr(new XLSB::DDEOLEITEM(type));
		if (m_oDdeValues.IsInit())
				ptr->m_DDEOLEITEMVALUES = m_oDdeValues->toBin();
		if(m_oName.IsInit())
		{
			ptr->m_BrtSupNameStart = XLS::BaseObjectPtr{new XLSB::SupNameStart};
			auto ptrSupNameStart = static_cast<XLSB::SupNameStart*>(ptr->m_BrtSupNameStart.get());
			ptrSupNameStart->name = m_oName.get();
		}
		if(m_oOle.IsInit() || m_oAdvise.IsInit() || m_oPreferPic.IsInit())
		{
			ptr->m_BrtSupNameBits = XLS::BaseObjectPtr{new XLSB::SupNameBits(type)};
			auto ptrSupNameBits = static_cast<XLSB::SupNameBits*>(ptr->m_BrtSupNameBits.get());
			ptrSupNameBits->sbt = 0x0001;
			if(m_oOle.IsInit())
			{
				ptrSupNameBits->contentsDDE.fOLE = m_oOle->ToBool();
			}
			if(m_oAdvise.IsInit())
			{
				ptrSupNameBits->contentsDDE.fWantAdvise  = m_oAdvise->ToBool();
			}
			if(m_oPreferPic.IsInit())
			{
				ptrSupNameBits->contentsDDE.fWantPict = m_oPreferPic->ToBool();
			}
		}
		return ptr;
	}
	void CDdeItem::fromBin(XLS::BaseObjectPtr& obj)
	{
		ReadAttributes(obj);
	}
	void CDdeItem::ReadAttributes(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::DDEOLEITEM*>(obj.get());
		if (ptr != nullptr)
		{
			if (ptr->m_DDEOLEITEMVALUES != nullptr)
				m_oDdeValues = ptr->m_DDEOLEITEMVALUES;

			auto ptrSupNameStart = static_cast<XLSB::SupNameStart*>(ptr->m_BrtSupNameStart.get());
			if (ptrSupNameStart != nullptr)
			{
				if (!ptrSupNameStart->name.value().empty())
					m_oName = ptrSupNameStart->name.value();
			}

			auto ptrSupNameBits = static_cast<XLSB::SupNameBits*>(ptr->m_BrtSupNameBits.get());
			if (ptrSupNameBits != nullptr)
			{
				m_oOle = ptrSupNameBits->contentsDDE.fOLE;
				m_oAdvise = ptrSupNameBits->contentsDDE.fWantAdvise;
				m_oPreferPic = ptrSupNameBits->contentsDDE.fWantPict;
			}
		}
	}
	void CDdeItem::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_Read_if(oReader, (L"name"), m_oName)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"ole"), m_oOle)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"advise"), m_oAdvise)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"preferPic"), m_oPreferPic)
			WritingElement_ReadAttributes_End(oReader)
	}

	CDdeItems::CDdeItems()
	{
	}
	CDdeItems::~CDdeItems()
	{
	}
	void CDdeItems::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CDdeItems::getType() const
	{
		return et_x_DdeItems;
	}
	void CDdeItems::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		if (oReader.IsEmptyNode())
			return;

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

			if (L"ddeItem" == sName)
			{
				CDdeItem* pDdeItem = new CDdeItem();
				*pDdeItem = oReader;
				m_arrItems.push_back(pDdeItem);
			}
		}
	}
	void CDdeItems::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<ddeItems>");
		for (size_t i = 0; i < m_arrItems.size(); ++i)
		{
			if (m_arrItems[i])
			{
				m_arrItems[i]->toXML(writer);
			}
		}
		writer.WriteString(L"</ddeItems>");
	}
	std::wstring CDdeItems::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	void CDdeItems::fromBin(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::DDEOLELINK*>(obj.get());
		if (ptr != nullptr)
		{
			for (auto &item : ptr->m_arDDEOLEITEM)
				m_arrItems.push_back(new CDdeItem(item));
		}
	}

	XLS::BaseObjectPtr CDdeItems::toBin()
	{
		XLSB::ExternalReferenceType type;
		XLSB::DDEOLELINKPtr ptr(new XLSB::DDEOLELINK(type));
		for (auto item : m_arrItems)
				ptr->m_arDDEOLEITEM.push_back(item->toBin());
		return ptr;
	}

	void CDdeLink::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (oReader.IsEmptyNode())
			return;

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

			if (L"ddeItems" == sName)
			{
				m_oDdeItems = oReader;
			}
		}
	}
	void CDdeLink::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<ddeLink xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\"");
		WritingStringNullableAttrEncodeXmlString(L"ddeService", m_oDdeService, m_oDdeService.get());
		WritingStringNullableAttrEncodeXmlString(L"ddeTopic", m_oDdeTopic, m_oDdeTopic.get());
		writer.WriteString(L">");
		if (m_oDdeItems.IsInit())
		{
			m_oDdeItems->toXML(writer);
		}
		writer.WriteString(L"</ddeLink>");
	}
	std::wstring CDdeLink::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	void CDdeLink::fromBin(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::EXTERNALLINK*>(obj.get());
		if (ptr != nullptr)
		{
			ReadAttributes(ptr->m_BrtBeginSupBook);

			if (ptr->m_DDEOLELINK != nullptr)
				m_oDdeItems = ptr->m_DDEOLELINK;
		}
	}
	XLS::BaseObjectPtr CDdeLink::toBin()
	{
		XLSB::EXTERNALLINKPtr ptr(new XLSB::EXTERNALLINK);
		ptr->m_BrtBeginSupBook = XLS::BaseObjectPtr{new XLSB::BeginSupBook};
		auto castedBook = static_cast<XLSB::BeginSupBook*>(ptr->m_BrtBeginSupBook.get());
		if (m_oDdeService.IsInit())
			castedBook->string1 = m_oDdeService.get();
		else
			castedBook->string1 = L"";
		if (m_oDdeTopic.IsInit())
			castedBook->string2 = m_oDdeTopic.get();
		else
			castedBook->string2 = L"";
		if(m_oDdeItems.IsInit())
			ptr->m_DDEOLELINK = m_oDdeItems->toBin();
		castedBook->sbt = 0x0001;
        return ptr;
	}

	CDdeLink::CDdeLink()
	{
	}
	CDdeLink::~CDdeLink()
	{
	}
	void CDdeLink::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CDdeLink::getType() const
	{
		return et_x_DdeLink;
	}
	void CDdeLink::ReadAttributes(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::BeginSupBook*>(obj.get());
		if (ptr != nullptr)
		{
			if (!ptr->string1.empty())
				m_oDdeService = ptr->string1;
			if (!ptr->string2.empty())
				m_oDdeTopic = ptr->string2;
		}
	}
	void CDdeLink::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_Read_if(oReader, (L"ddeService"), m_oDdeService)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"ddeTopic"), m_oDdeTopic)
			WritingElement_ReadAttributes_End(oReader)
	}

	COleItem::COleItem()
	{
	}
	COleItem::~COleItem()
	{
	}
	void COleItem::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType COleItem::getType() const
	{
		return et_x_OleItem;
	}
	void COleItem::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (!oReader.IsEmptyNode())
			oReader.ReadTillEnd();
	}
	void COleItem::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<oleItem");
		WritingStringNullableAttrEncodeXmlString(L"name", m_oName, m_oName.get());
		WritingStringNullableAttrBool(L"icon", m_oIcon);
		WritingStringNullableAttrBool(L"advise", m_oAdvise);
		WritingStringNullableAttrBool(L"preferPic", m_oPreferPic);
		writer.WriteString(L"/>");
	}
	std::wstring COleItem::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	XLS::BaseObjectPtr COleItem::toBin()
	{
		XLSB::ExternalReferenceType type;
		XLSB::DDEOLEITEMPtr coleItem(new XLSB::DDEOLEITEM(type));
		if(m_oName.IsInit())
		{
			coleItem->m_BrtSupNameStart = XLS::BaseObjectPtr{new XLSB::SupNameStart};
			auto castedName = static_cast<XLSB::SupNameStart*>(coleItem->m_BrtSupNameStart.get());
			castedName->name = m_oName.get();
		}
		if(m_oIcon.IsInit() || m_oAdvise.IsInit() || m_oPreferPic.IsInit())
		{
			coleItem->m_BrtSupNameBits = XLS::BaseObjectPtr{new XLSB::SupNameBits(type)};
			auto ptrSupNameBits = static_cast<XLSB::SupNameBits*>(coleItem->m_BrtSupNameBits.get());
			ptrSupNameBits->sbt = 0x0002;
			if(m_oIcon.IsInit())
				ptrSupNameBits->contentsOLE.fIcon = m_oIcon->ToBool();
			if(m_oAdvise.IsInit())
				ptrSupNameBits->contentsOLE.fWantAdvise = m_oAdvise->ToBool();
			if(m_oPreferPic.IsInit())
				ptrSupNameBits->contentsOLE.fWantPict = m_oPreferPic->ToBool();
		}
		return coleItem;
	}
	void COleItem::fromBin(XLS::BaseObjectPtr& obj)
	{
		ReadAttributes(obj);
	}
	void COleItem::ReadAttributes(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::DDEOLEITEM*>(obj.get());
		if (ptr != nullptr)
		{
			auto ptrSupNameStart = static_cast<XLSB::SupNameStart*>(ptr->m_BrtSupNameStart.get());
			if (ptrSupNameStart != nullptr)
			{
				if (!ptrSupNameStart->name.value().empty())
					m_oName = ptrSupNameStart->name.value();
			}

			auto ptrSupNameBits = static_cast<XLSB::SupNameBits*>(ptr->m_BrtSupNameBits.get());
			if (ptrSupNameBits != nullptr)
			{
				m_oIcon = ptrSupNameBits->contentsOLE.fIcon;
				m_oAdvise = ptrSupNameBits->contentsOLE.fWantAdvise;
				m_oPreferPic = ptrSupNameBits->contentsOLE.fWantPict;
			}
		}
	}
	void COleItem::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_Read_if(oReader, (L"name"), m_oName)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"icon"), m_oIcon)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"advise"), m_oAdvise)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"preferPic"), m_oPreferPic)
			WritingElement_ReadAttributes_End(oReader)
	}

	COleItems::COleItems()
	{
	}
	COleItems::~COleItems()
	{
	}
	void COleItems::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType COleItems::getType() const
	{
		return et_x_OleItems;
	}
	void COleItems::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		if (oReader.IsEmptyNode())
			return;

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

			if (L"oleItem" == sName)
			{
				COleItem* pOleItem = new COleItem();
				*pOleItem = oReader;
				m_arrItems.push_back(pOleItem);
			}
		}
	}
	void COleItems::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<oleItems>");
		for (size_t i = 0; i < m_arrItems.size(); ++i)
		{
			if (m_arrItems[i])
			{
				m_arrItems[i]->toXML(writer);
			}
		}
		writer.WriteString(L"</oleItems>");
	}
	std::wstring COleItems::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	void COleItems::fromBin(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::DDEOLELINK*>(obj.get());
		if (ptr != nullptr)
		{
			for (auto &item : ptr->m_arDDEOLEITEM)
				m_arrItems.push_back(new COleItem(item));
		}
	}
	XLS::BaseObjectPtr COleItems::toBin()
	{
		XLSB::ExternalReferenceType type;
		XLSB::DDEOLELINKPtr ptr(new XLSB::DDEOLELINK(type));

		for(auto i: m_arrItems)
		{
			ptr->m_arDDEOLEITEM.push_back(i->toBin());
		}
		return ptr;
	}

	COleLink::COleLink()
	{
	}
	COleLink::~COleLink()
	{
	}
	void COleLink::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType COleLink::getType() const
	{
		return et_x_OleLink;
	}
	void COleLink::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (oReader.IsEmptyNode())
			return;

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

			if (L"oleItems" == sName)
			{
				m_oOleItems = oReader;
			}
		}
	}
	void COleLink::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<oleLink xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\"");
		WritingStringNullableAttrString(L"r:id", m_oRid, m_oRid->ToString());
		WritingStringNullableAttrEncodeXmlString(L"progId", m_oProgId, m_oProgId.get());
		writer.WriteString(L">");
		if (m_oOleItems.IsInit())
		{
			m_oOleItems->toXML(writer);
		}
		writer.WriteString(L"</oleLink>");
	}
	std::wstring COleLink::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
	void COleLink::fromBin(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::EXTERNALLINK*>(obj.get());
		if (ptr != nullptr)
		{
			ReadAttributes(ptr->m_BrtBeginSupBook);

			if (ptr->m_DDEOLELINK != nullptr)
				m_oOleItems = ptr->m_DDEOLELINK;
		}
	}
	XLS::BaseObjectPtr COleLink::toBin()
	{
		XLSB::EXTERNALLINKPtr COleLink(new XLSB::EXTERNALLINK);
		COleLink->m_BrtBeginSupBook = XLS::BaseObjectPtr{new XLSB::BeginSupBook};
		auto castedBook = static_cast<XLSB::BeginSupBook*>(COleLink->m_BrtBeginSupBook.get());
		castedBook->sbt = 0x0002;
		if(m_oRid.IsInit())
			castedBook->string1 = m_oRid->ToString();
        else
            castedBook->string1 = L"";
		if(m_oProgId.IsInit())
			castedBook->string2 = m_oProgId.get();
        else
            castedBook->string2 = L"";

        if(m_oOleItems.IsInit())
            COleLink->m_DDEOLELINK = m_oOleItems->toBin();
		return COleLink;
	}
	void COleLink::ReadAttributes(XLS::BaseObjectPtr& obj)
	{
		auto ptr = static_cast<XLSB::BeginSupBook*>(obj.get());
		if (ptr != nullptr)
		{
			if (!ptr->string1.empty())
				m_oRid = ptr->string1;
			if (!ptr->string2.empty())
				m_oProgId = ptr->string2;
		}
	}
	void COleLink::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_Read_if(oReader, (L"r:id"), m_oRid)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"relationships:id"), m_oRid)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"progId"), m_oProgId)
		WritingElement_ReadAttributes_End(oReader)
	}
	CAlternateUrls::CAlternateUrls()
	{
	}
	CAlternateUrls::~CAlternateUrls()
	{
	}
	void CAlternateUrls::fromXML(XmlUtils::CXmlNode& oNode)
	{
	}
	EElementType CAlternateUrls::getType() const
	{
		return et_x_ExternalDefinedName;
	}
	void CAlternateUrls::fromXML(XmlUtils::CXmlLiteReader& oReader)
	{
		ReadAttributes(oReader);

		if (oReader.IsEmptyNode())
			return;

		int nCurDepth = oReader.GetDepth();
		while (oReader.ReadNextSiblingNode(nCurDepth))
		{
			std::wstring sName = oReader.GetNameNoNS();

			if (L"absoluteUrl" == sName)
			{
				ReadAttributes(oReader, m_oAbsoluteUrlRid);
			}
			else if (L"relativeUrl" == sName)
			{
				ReadAttributes(oReader, m_oRelativeUrlRid);
			}
		}
	}
	void CAlternateUrls::ReadAttributes(XmlUtils::CXmlLiteReader& oReader, nullable<SimpleTypes::CRelationshipId>& rid)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_ReadSingle(oReader, (L"r:id"), rid)
		WritingElement_ReadAttributes_End(oReader)
	}
	void CAlternateUrls::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
		WritingElement_ReadAttributes_Start(oReader)
			WritingElement_ReadAttributes_Read_if(oReader, (L"driveId"), m_oDriveId)
			WritingElement_ReadAttributes_Read_else_if(oReader, (L"itemId"), m_oItemId)
		WritingElement_ReadAttributes_End(oReader)
	}
	void CAlternateUrls::toXML(NSStringUtils::CStringBuilder& writer) const
	{
		writer.WriteString(L"<xxl21:alternateUrls");
		WritingStringNullableAttrEncodeXmlString2(L"driveId", m_oDriveId);
		WritingStringNullableAttrEncodeXmlString2(L"itemId", m_oItemId);
		writer.WriteString(L">");

		if (m_oAbsoluteUrlRid.IsInit())
		{
			writer.WriteString(L"<xxl21:absoluteUrl r:id=\"" + m_oAbsoluteUrlRid->ToString() + L"\"/>");
		}
		else if (m_oRelativeUrlRid.IsInit())
		{
			writer.WriteString(L"<xxl21:relativeUrl r:id=\"" + m_oRelativeUrlRid->ToString() + L"\"/>");
		}
		writer.WriteString(L"</xxl21:alternateUrls>");
	}
	std::wstring CAlternateUrls::toXML() const
	{
		NSStringUtils::CStringBuilder writer;
		toXML(writer);
		return writer.GetData().c_str();
	}
//---------------------------------------------------------------------------------------------------------------------------------
	CExternalLink::CExternalLink(OOX::Document* pMain) : OOX::FileGlobalEnumerated(pMain), OOX::IFileContainer(pMain)
	{
		m_bSpreadsheets = true;
	}
	CExternalLink::CExternalLink(OOX::Document* pMain, const CPath& oRootPath, const CPath& oPath, const std::wstring & rId) : OOX::FileGlobalEnumerated(pMain), OOX::IFileContainer(pMain)
	{
		m_bSpreadsheets = true;
		m_rId = rId;
		read(oRootPath, oPath);
	}
	CExternalLink::~CExternalLink()
	{
	}
    XLS::BaseObjectPtr CExternalLink::writeBin() const
	{
		XLSB::ExternalLinkStreamPtr externalLinkStreamStream(new XLSB::ExternalLinkStream);

		if (externalLinkStreamStream != nullptr)
		{
			if (m_oExternalBook.IsInit())
				externalLinkStreamStream->m_EXTERNALLINK = m_oExternalBook->toBin();
			else if (m_oDdeLink.IsInit())
				externalLinkStreamStream->m_EXTERNALLINK = m_oDdeLink->toBin();
			else if (m_oOleLink.IsInit())
				externalLinkStreamStream->m_EXTERNALLINK = m_oOleLink->toBin();
		}
		return externalLinkStreamStream;
	}
	void CExternalLink::readBin(const CPath& oPath)
	{
		CXlsb* xlsb = dynamic_cast<CXlsb*>(File::m_pMainDocument);
		if (xlsb)
		{
			XLSB::ExternalLinkStreamPtr externalLinkStreamStream(new XLSB::ExternalLinkStream);

			xlsb->ReadBin(oPath, externalLinkStreamStream.get());

			externalLinkStreamStream->UpdateXti(xlsb->GetGlobalinfo(), m_rId);

			if (externalLinkStreamStream != nullptr)
			{
				if (externalLinkStreamStream->m_EXTERNALLINK != nullptr)
				{
					auto ptr = static_cast<XLSB::EXTERNALLINK*>(externalLinkStreamStream->m_EXTERNALLINK.get());
					if (ptr != nullptr)
					{
						auto ptr1 = static_cast<XLSB::BeginSupBook*>(ptr->m_BrtBeginSupBook.get());
						if (ptr1 != nullptr)
						{
							switch (ptr1->sbt.value().get())
							{
							case XLSB::ExternalReferenceType::WORKBOOK:
								m_oExternalBook = externalLinkStreamStream->m_EXTERNALLINK;
								break;
							case XLSB::ExternalReferenceType::DDE:
								m_oDdeLink = externalLinkStreamStream->m_EXTERNALLINK;
								break;
							case XLSB::ExternalReferenceType::OLE:
								m_oOleLink = externalLinkStreamStream->m_EXTERNALLINK;
								break;
							}
						}
					}
				}
			}

			//externalLinkStreamStream.reset();
		}
	}
	void CExternalLink::read(const CPath& oPath)
	{
		//don't use this. use read(const CPath& oRootPath, const CPath& oFilePath)
		CPath oRootPath;
		read(oRootPath, oPath);
	}
	void CExternalLink::read(const CPath& oRootPath, const CPath& oPath)
	{
		m_oReadPath = oPath;
		IFileContainer::Read(oRootPath, oPath);

		if (m_oReadPath.GetExtention() == _T(".bin"))
		{
			readBin(m_oReadPath);
			return;
		}

		XmlUtils::CXmlLiteReader oReader;

		if (!oReader.FromFile(oPath.GetPath()))
			return;

		if (!oReader.ReadNextNode())
			return;

		std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
		if (L"externalLink" == sName)
		{
			ReadAttributes(oReader);

			if (!oReader.IsEmptyNode())
			{
				int nStylesDepth = oReader.GetDepth();
				while (oReader.ReadNextSiblingNode(nStylesDepth))
				{
					sName = XmlUtils::GetNameNoNS(oReader.GetName());

					if (L"externalBook" == sName)
					{
						m_oExternalBook = oReader;
					}
					else if (L"oleLink" == sName)
					{
						m_oOleLink = oReader;
					}
					else if (L"ddeLink" == sName)
					{
						m_oDdeLink = oReader;
					}
					else if (L"extLst" == sName)
					{
						nullable<OOX::Drawing::COfficeArtExtensionList>	oExtLst;
						oExtLst = oReader;

						for (size_t i = 0; (oExtLst.IsInit()) && (i < oExtLst->m_arrExt.size()); i++)
						{
							if (oExtLst->m_arrExt[i]->m_oFileKey.IsInit() ||
								oExtLst->m_arrExt[i]->m_oInstanceId.IsInit())
							{
								m_oFileKey = oExtLst->m_arrExt[i]->m_oFileKey;
								m_oInstanceId = oExtLst->m_arrExt[i]->m_oInstanceId;
								break;
							}
						}
					}
				}
			}
		}
	}
	void CExternalLink::write(const CPath& oPath, const CPath& oDirectory, CContentTypes& oContent) const
	{
		CXlsb* xlsb = dynamic_cast<CXlsb*>(File::m_pMainDocument);
		if ((xlsb) && (xlsb->m_bWriteToXlsb))
		{
			XLS::BaseObjectPtr object = writeBin();
			xlsb->WriteBin(oPath, object.get());
		}
		else
		{
		NSStringUtils::CStringBuilder sXml;
		sXml.WriteString(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
		sXml.WriteString(L"<externalLink \
xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" \
xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
mc:Ignorable=\"x14 xxl21\" \
xmlns:x14=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/main\" \
xmlns:xxl21=\"http://schemas.microsoft.com/office/spreadsheetml/2021/extlinks2021\">");

		if (m_oExternalBook.IsInit())
		{
			m_oExternalBook->toXML(sXml);
		}
		if (m_oOleLink.IsInit())
		{
			m_oOleLink->toXML(sXml);
		}
		if (m_oDdeLink.IsInit())
		{
			m_oDdeLink->toXML(sXml);
		}
		if (m_oFileKey.IsInit() || m_oInstanceId.IsInit())
		{
			OOX::Drawing::COfficeArtExtension oExt;
			oExt.m_oFileKey = m_oFileKey;
			oExt.m_oInstanceId = m_oInstanceId;

			oExt.m_sUri = L"{C3750BE0-5CA9-4D1C-82C7-79D762991C26}";

			sXml.WriteString(L"<extLst>" + oExt.toXMLWithNS(L"") + L"</extLst>");
		}
		sXml.WriteString(L"</externalLink>");

		std::wstring sPath = oPath.GetPath();
		NSFile::CFileBinary::SaveToFile(sPath, sXml.GetData());
		}
		oContent.Registration(type().OverrideType(), oDirectory, oPath.GetFilename());
		IFileContainer::Write(oPath, oDirectory, oContent);
	}
	bool CExternalLink::isValid() const
	{
		return true;
	}
	const OOX::FileType CExternalLink::type() const
	{
		CXlsb* xlsb = dynamic_cast<CXlsb*>(File::m_pMainDocument);
		if ((xlsb) && (xlsb->m_bWriteToXlsb))
		{
			return OOX::SpreadsheetBin::FileTypes::ExternalLinksBin;
		}
		return OOX::Spreadsheet::FileTypes::ExternalLinks;
	}
	const CPath CExternalLink::DefaultDirectory() const
	{
		return type().DefaultDirectory();
	}
	const CPath CExternalLink::DefaultFileName() const
	{
		return type().DefaultFileName();
	}
	const CPath& CExternalLink::GetReadPath()
	{
		return m_oReadPath;
	}
	void CExternalLink::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
	{
	}
}
}