Merge remote-tracking branch 'origin/develop' into feature/pdf-redact

DesktopEditor/common/SystemUtils.h

@@ -1,4 +1,4 @@
-/*
+/*
  * (c) Copyright Ascensio System SIA 2010-2023
  *
  * This program is a free software product. You can redistribute it and/or
@@ -59,7 +59,7 @@ namespace NSSystemUtils
 	static const wchar_t* gc_EnvLastModifiedBy = L"LAST_MODIFIED_BY";
 	static const wchar_t* gc_EnvModified = L"MODIFIED";
 	static const wchar_t* gc_EnvMemoryLimit = L"X2T_MEMORY_LIMIT";
-	static const wchar_t* gc_EnvMemoryLimitDefault = L"4GiB";
+	static const wchar_t* gc_EnvMemoryLimitDefault = L"3GiB";
 
     KERNEL_DECL std::string GetEnvVariableA(const std::wstring& strName);
     KERNEL_DECL std::wstring GetEnvVariable(const std::wstring& strName);

DesktopEditor/graphics/commands/AnnotField.cpp

@@ -1199,6 +1199,8 @@ bool CWidgetsInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafil
 		}
 		if (nFlags & (1 << 9))
 			pParent->nMaxLen = pReader->ReadInt();
+		if (nFlags & (1 << 10))
+			pParent->sTU = pReader->ReadString();
 		m_arrParents.push_back(pParent);
 	}
 
@@ -1207,7 +1209,10 @@ bool CWidgetsInfo::Read(NSOnlineOfficeBinToPdf::CBufferReader* pReader, IMetafil
 	for (int i = 0; i < n; ++i)
 	{
 		std::string sImagePath = pReader->ReadStringA();
-		m_arrButtonImg.push_back(pCorrector->GetImagePath(UTF8_TO_U(sImagePath)));
+		std::wstring sImage = UTF8_TO_U(sImagePath);
+		if (sImagePath.find("data:") != 0 && !sImagePath.empty())
+			sImage = pCorrector->GetImagePath(sImage);
+		m_arrButtonImg.push_back(sImage);
 	}
 
 	return true;

DesktopEditor/graphics/commands/AnnotField.h

@@ -604,6 +604,7 @@ public:
 		std::wstring sName;
 		std::wstring sV;
 		std::wstring sDV;
+		std::wstring sTU;
 		std::vector<int> arrI;
 		std::vector<std::wstring> arrV;
 		std::vector<CAnnotFieldInfo::CWidgetAnnotPr::CActionWidget*> arrAction;

DesktopEditor/graphics/pro/js/wasm/js/drawingfile.js

@@ -450,13 +450,10 @@ function readAction(reader, rec, readDoubleFunc, readStringFunc)
 }
 function readAnnot(reader, rec, readDoubleFunc, readDouble2Func, readStringFunc, isRead = false)
 {
-	if (!isRead)
-		rec["AP"] = {};
+	rec["AP"] = {};
 	// Annot
 	// number for relations with AP
-	let APi = reader.readInt();
-	if (!isRead)
-		rec["AP"]["i"] = APi;
+	rec["AP"]["i"] = reader.readInt();
 	rec["annotflag"] = reader.readInt();
 	// 12.5.3
 	let bHidden = (rec["annotflag"] >> 1) & 1; // Hidden
@@ -539,10 +536,7 @@ function readAnnot(reader, rec, readDoubleFunc, readDouble2Func, readStringFunc,
 	if (flags & (1 << 6))
 	{
 		if (isRead)
-		{
-			let APrender = reader.readData(); // TODO use Render - Uint8Array
-			// rec["AP"]["render"] = APrender;
-		}
+			rec["AP"]["render"] = reader.readData(); // TODO use Render - Uint8Array
 		else
 			rec["AP"]["have"] = (flags >> 6) & 1;
 	}
@@ -1049,7 +1043,7 @@ function readWidgetType(reader, rec, readDoubleFunc, readDouble2Func, readString
 	let flags = reader.readInt();
 	// Alternative field name, used in tooltip and error messages - TU
 	if (flags & (1 << 0))
-		rec["userName"] = readStringFunc.call(reader);
+		rec["tooltip"] = readStringFunc.call(reader);
 	// Default style string (CSS2 format) - DS
 	if (flags & (1 << 1))
 		rec["defaultStyle"] = readStringFunc.call(reader);
@@ -1180,15 +1174,9 @@ function readWidgetType(reader, rec, readDoubleFunc, readDouble2Func, readString
 		if (isRead)
 		{
 			if (flags & (1 << 12))
-			{
-				let APV = readStringFunc.call(reader);
-				// rec["AP"]["V"] = APV;
-			}
+				rec["AP"]["V"] = readStringFunc.call(reader);
 			if (flags & (1 << 13))
-			{
-				let APrender = reader.readData(); // TODO use Render - Uint8Array
-				// rec["AP"]["render"] = APrender;
-			}
+				rec["AP"]["render"] = reader.readData(); // TODO use Render - Uint8Array
 		}
 		// 12.7.4.3
 		if (rec["flag"] >= 0)
@@ -1225,10 +1213,7 @@ function readWidgetType(reader, rec, readDoubleFunc, readDouble2Func, readString
 		if (isRead)
 		{
 			if (flags & (1 << 12))
-			{
-				let APV = readStringFunc.call(reader);
-				// rec["AP"]["V"] = APV;
-			}
+				rec["AP"]["V"] = readStringFunc.call(reader);
 		}
 		else
 		{
@@ -1257,10 +1242,7 @@ function readWidgetType(reader, rec, readDoubleFunc, readDouble2Func, readString
 					rec["I"].push(reader.readInt());
 			}
 			if (flags & (1 << 15))
-			{
-				let APrender = reader.readData(); // TODO use Render - Uint8Array
-				// rec["AP"]["render"] = APrender;
-			}
+				rec["AP"]["render"] = reader.readData(); // TODO use Render - Uint8Array
 		}
 		// 12.7.4.4
 		if (rec["flag"] >= 0)
@@ -1378,6 +1360,8 @@ CFile.prototype["getInteractiveFormsInfo"] = function()
 			}
 			if (flags & (1 << 9))
 				rec["maxLen"] = reader.readInt();
+			if (flags & (1 << 10))
+				rec["tooltip"] = reader.readString();
 			res["Parents"].push(rec);
 		}
 
@@ -1589,35 +1573,50 @@ CFile.prototype["readAnnotationsInfoFromBinary"] = function(AnnotInfo)
 	let reader = new CBinaryReader(AnnotInfo, 0, AnnotInfo.length);
 	if (!reader) return [];
 
-	let res = [];
+	let res = { annots:[], imgs:[] };
 	while (reader.isValid())
 	{
 		let nCommand = reader.readByte();
 		let nPos = reader.pos;
 		let nSize = reader.readInt();
-		if (nCommand != 164) // ctAnnotField
+		if (nCommand == 164) // ctAnnotField
+		{
+			let rec = {};
+			// Annotation type
+			// 0 - Text, 1 - Link, 2 - FreeText, 3 - Line, 4 - Square, 5 - Circle,
+			// 6 - Polygon, 7 - PolyLine, 8 - Highlight, 9 - Underline, 10 - Squiggly, 
+			// 11 - Strikeout, 12 - Stamp, 13 - Caret, 14 - Ink, 15 - Popup, 16 - FileAttachment, 
+			// 17 - Sound, 18 - Movie, 19 - Widget, 20 - Screen, 21 - PrinterMark,
+			// 22 - TrapNet, 23 - Watermark, 24 - 3D, 25 - Redact
+			rec["type"] = reader.readByte();
+			// Annot
+			readAnnot(reader, rec, reader.readDouble3, reader.readDouble3, reader.readString2, true);
+			// Annot type
+			readAnnotType(reader, rec, reader.readDouble3, reader.readDouble3, reader.readString2, true);
+			if (rec["type"] >= 26 && rec["type"] <= 33)
+			{
+				// Widget type
+				readWidgetType(reader, rec, reader.readDouble3, reader.readDouble3, reader.readString2, true);
+			}
+			res.annots.push(rec);
+		}
+		else if (nCommand == 166) // ctWidgetsInfo
+		{
+			reader.readInt(); // CO must be 0
+			reader.readInt(); // Parents must be 0
+			// ButtonImg
+			let n = reader.readInt();
+			for (let i = 0; i < n; ++i)
+			{
+				let data = reader.readString();
+				res.imgs.push(data);
+			}
+		}
+		else
 		{
 			reader.pos = nPos + nSize;
 			continue;
 		}
-		let rec = {};
-		// Annotation type
-		// 0 - Text, 1 - Link, 2 - FreeText, 3 - Line, 4 - Square, 5 - Circle,
-		// 6 - Polygon, 7 - PolyLine, 8 - Highlight, 9 - Underline, 10 - Squiggly, 
-		// 11 - Strikeout, 12 - Stamp, 13 - Caret, 14 - Ink, 15 - Popup, 16 - FileAttachment, 
-		// 17 - Sound, 18 - Movie, 19 - Widget, 20 - Screen, 21 - PrinterMark,
-		// 22 - TrapNet, 23 - Watermark, 24 - 3D, 25 - Redact
-		rec["type"] = reader.readByte();
-		// Annot
-		readAnnot(reader, rec, reader.readDouble3, reader.readDouble3, reader.readString2, true);
-		// Annot type
-		readAnnotType(reader, rec, reader.readDouble3, reader.readDouble3, reader.readString2, true);
-		if (rec["type"] >= 26 && rec["type"] <= 33)
-		{
-			// Widget type
-			readWidgetType(reader, rec, reader.readDouble3, reader.readDouble3, reader.readString2, true);
-		}
-		res.push(rec);
 	}
 
 	return res;

DesktopEditor/graphics/pro/js/wasm/src/drawingfile_test.cpp

@@ -415,6 +415,13 @@ void ReadInteractiveForms(BYTE* pWidgets, int& i)
 			i += 4;
 			std::cout << "MaxLen " << nPathLength << ", ";
 		}
+		if (nFlags & (1 << 10))
+		{
+			nPathLength = READ_INT(pWidgets + i);
+			i += 4;
+			std::cout << "TU " << std::string((char*)(pWidgets + i), nPathLength) << ", ";
+			i += nPathLength;
+		}
 
 		std::cout << std::endl;
 	}

HwpFile/HWPFile.pro

@@ -99,8 +99,8 @@ SOURCES += \
 HEADERS += \
     HWPFile.h \
     HwpDoc/Common/Common.h \
-    HwpDoc/Common/XMLNode.h \
     HwpDoc/Common/WriterContext.h \
+    HwpDoc/Common/XMLReader.h \
     HwpDoc/Conversion/ConversionState.h \
     HwpDoc/Conversion/Converter2OOXML.h \
     HwpDoc/Conversion/FootnoteConverter.h \

HwpFile/HwpDoc/Common/XMLNode.h

@@ -1,25 +0,0 @@
-#ifndef XMLNODEH_H
-#define XMLNODEH_H
-
-#include "../../../DesktopEditor/xml/include/xmlutils.h"
-
-namespace HWP
-{
-class CXMLNode : public XmlUtils::CXmlNode
-{
-public:
-	CXMLNode();
-	CXMLNode(const XmlUtils::CXmlNode& oNode);
-
-	bool GetAttributeBool(const std::wstring& wsName);
-	int GetAttributeColor(const std::wstring& wsName, const int& _default = 0x00000000);
-	CXMLNode GetChild(const std::wstring& wsName);
-	std::vector<CXMLNode> GetChilds();
-	std::vector<CXMLNode> GetChilds(const std::wstring& wsName);
-};
-
-int ConvertWidthToHWP(const std::wstring& wsValue);
-int ConvertHexToInt(const std::string& wsValue, const int& _default = 0x00000000);
-}
-
-#endif // XMLNODEH_H

HwpFile/HwpDoc/Common/XMLReader.cpp

@@ -1,86 +1,299 @@
-#include "XMLNode.h"
+#include "XMLReader.h"
+#include <cmath>
 
 namespace HWP
 {
-CXMLNode::CXMLNode()
-	: XmlUtils::CXmlNode()
+CXMLReader::CXMLReader()
+	: m_pReader(new XmlUtils::CXmlLiteReader), m_bParseAttribute(false)
 {}
 
-CXMLNode::CXMLNode(const CXmlNode& oNode)
-	: XmlUtils::CXmlNode(oNode)
-{}
-
-bool CXMLNode::GetAttributeBool(const std::wstring& wsName)
+CXMLReader::~CXMLReader()
 {
-	return L"1" == XmlUtils::CXmlNode::GetAttribute(wsName, L"0");
+	if (nullptr != m_pReader)
+		delete m_pReader;
 }
 
-int CXMLNode::GetAttributeColor(const std::wstring& wsName, const int& _default)
+XmlUtils::CXmlLiteReader* CXMLReader::GetReader()
 {
-	return ConvertHexToInt(XmlUtils::CXmlNode::GetAttributeA(wsName), _default);
+	return m_pReader;
 }
 
-CXMLNode CXMLNode::GetChild(const std::wstring& wsName)
+unsigned int CXMLReader::GetDepth()
 {
-	return CXMLNode(XmlUtils::CXmlNode::GetNode(wsName));
+	return (nullptr != m_pReader) ? m_pReader->GetDepth() : 0;
 }
 
-std::vector<CXMLNode> CXMLNode::GetChilds()
+bool CXMLReader::IsEmptyNode()
 {
-	std::vector<XmlUtils::CXmlNode> arChilds;
-	XmlUtils::CXmlNode::GetChilds(arChilds);
-
-	std::vector<CXMLNode> arNewChilds(arChilds.size());
-	for (unsigned int unIndex = 0; unIndex < arChilds.size(); ++unIndex)
-		arNewChilds[unIndex] = CXMLNode(arChilds[unIndex]);
-
-	return arNewChilds;
+	return (nullptr != m_pReader) ? m_pReader->IsEmptyNode() : true;
 }
 
-std::vector<CXMLNode> CXMLNode::GetChilds(const std::wstring& wsName)
+bool CXMLReader::GetBool()
 {
-	std::vector<XmlUtils::CXmlNode> arChilds{XmlUtils::CXmlNode::GetNodes(wsName)};
-
-	std::vector<CXMLNode> arNewChilds(arChilds.size());
-	for (unsigned int unIndex = 0; unIndex < arChilds.size(); ++unIndex)
-		arNewChilds[unIndex] = CXMLNode(arChilds[unIndex]);
-
-	return arNewChilds;
+	return "1" == GetTextAValue(*this);
 }
 
-int ConvertWidthToHWP(const std::wstring& wsValue)
+int CXMLReader::GetColor(const int& nDefault)
 {
-	if (wsValue.empty() || L"0.1" == wsValue || L"0.1 mm" == wsValue)
+	return ConvertHexToInt(GetTextAValue(*this), nDefault);
+}
+
+int CXMLReader::GetInt()
+{
+	return GetIntValue(*this);
+}
+
+double CXMLReader::GetDouble()
+{
+	return GetDoubleValue(*this);
+}
+
+std::string CXMLReader::GetTextA()
+{
+	if (nullptr == m_pReader)
+		return std::string();
+
+	return (m_bParseAttribute) ? m_pReader->GetTextA() : m_pReader->GetText2A();
+}
+
+std::wstring CXMLReader::GetText()
+{
+	if (nullptr == m_pReader)
+		return std::wstring();
+
+	return (m_bParseAttribute) ? m_pReader->GetText() : m_pReader->GetText2();
+}
+
+const char* CXMLReader::GetTextChar()
+{
+	if (nullptr == m_pReader)
+		return "";
+
+	return m_pReader->GetTextChar();
+}
+
+template<typename T>
+T CXMLReader::GetAttribute(const std::string& sName, T _default, T (*GetValue)(CXMLReader&))
+{
+	if (!MoveToFirstAttribute())
+		return _default;
+
+	T oValue = _default;
+
+	do
+	{
+		if (sName == m_pReader->GetNameA())
+		{
+			oValue = GetValue(*this);
+			break;
+		}
+	}while(m_pReader->MoveToNextAttribute());
+
+	MoveToElement();
+
+	return oValue;
+}
+
+int CXMLReader::GetAttributeInt(const std::string& sName, int nDefault)
+{
+	return GetAttribute<int>(sName, nDefault, &GetIntValue);
+}
+
+bool CXMLReader::GetAttributeBool(const std::string& sName)
+{
+	return GetAttribute<bool>(sName, false, &GetBoolValue);
+}
+
+double CXMLReader::GetAttributeDouble(const std::string& sName)
+{
+	return GetAttribute<double>(sName, 0., &GetDoubleValue);
+}
+
+std::string CXMLReader::GetAttributeA(const std::string& sName)
+{
+	return GetAttribute<std::string>(sName, "", &GetTextAValue);
+}
+
+std::wstring CXMLReader::GetAttribute(const std::string& sName)
+{
+	return GetAttribute<std::wstring>(sName, L"", &GetTextValue);
+}
+
+bool CXMLReader::MoveToFirstAttribute()
+{
+	if (nullptr == m_pReader || !m_pReader->MoveToFirstAttribute())
+		return false;
+
+	m_bParseAttribute = true;
+
+	return true;
+}
+
+bool CXMLReader::MoveToNextAttribute()
+{
+	return (nullptr != m_pReader) ? m_pReader->MoveToNextAttribute() : false;
+}
+
+bool CXMLReader::MoveToElement()
+{
+	if (nullptr == m_pReader || !m_pReader->MoveToElement())
+		return false;
+
+	m_bParseAttribute = false;
+
+	return true;
+}
+
+std::wstring CXMLReader::GetInnerXml()
+{
+	return m_pReader->GetInnerXml();
+}
+
+std::string CXMLReader::GetName()
+{
+	return (nullptr != m_pReader) ? m_pReader->GetNameA() : std::string();
+}
+
+bool CXMLReader::ReadNextSiblingNode(unsigned int unDepth)
+{
+	return (nullptr != m_pReader) ? m_pReader->ReadNextSiblingNode(unDepth) : false;
+}
+
+bool CXMLReader::ReadNextNode()
+{
+	return (nullptr != m_pReader) ? m_pReader->ReadNextNode() : false;
+}
+
+bool CXMLReader::Read(XmlUtils::XmlNodeType& eNodeType)
+{
+	return (nullptr != m_pReader) ? m_pReader->Read(eNodeType) : false;
+}
+
+int CXMLReader::GetIntValue(CXMLReader& oXmlReader)
+{
+	return std::atoi(oXmlReader.GetTextA().c_str());
+}
+
+bool CXMLReader::GetBoolValue(CXMLReader& oXmlReader)
+{
+	return "1" == oXmlReader.GetTextA();
+}
+
+double CXMLReader::GetDoubleValue(CXMLReader& oXmlReader)
+{
+	const std::string sValue{oXmlReader.GetTextA()};
+	const char* pCur = sValue.c_str();
+
+	while (std::isspace(*pCur))
+		++pCur;
+
+	if (!pCur)
+		return 0.;
+
+	bool bNegative = false;
+
+	while ('-' == *pCur || '+' == *pCur)
+	{
+		if ('-' == *pCur)
+			bNegative = !bNegative;
+
+		++pCur;
+	}
+
+	if (!pCur)
+		return 0.;
+
+	double dResult = 0.;
+
+	while (std::isdigit(*pCur))
+		dResult = dResult * 10. + (*pCur++ - '0');
+
+	if (',' == *pCur || '.' == *pCur)
+	{
+		++pCur;
+
+		double dFraction = 0.0;
+		double dDivisor  = 1.0;
+
+		while (std::isdigit(*pCur))
+		{
+			dFraction = dFraction * 10. + (*pCur++ - '0');
+			dDivisor *= 10;
+		}
+
+		dResult += dFraction / dDivisor;
+	}
+
+	if ('e' == *pCur || 'E' == *pCur)
+	{
+		++pCur;
+
+		bool bExpNegative = false;
+		while ('-' == *pCur || '+' == *pCur)
+		{
+			if ('-' == *pCur)
+				bExpNegative = !bExpNegative;
+
+			++pCur;
+		}
+
+		int nExponent = 0;
+
+		while (std::isdigit(*pCur))
+			nExponent = nExponent * 10 + (*pCur++ - '0');
+
+		if (bExpNegative)
+			nExponent = -nExponent;
+
+		dResult *= std::pow(10., nExponent);
+	}
+
+	return bNegative ? -dResult : dResult;
+}
+
+std::string CXMLReader::GetTextAValue(CXMLReader& oXmlReader)
+{
+	return oXmlReader.GetTextA();
+}
+
+std::wstring CXMLReader::GetTextValue(CXMLReader& oXmlReader)
+{
+	return oXmlReader.GetText();
+}
+
+int ConvertWidthToHWP(const std::string& sValue)
+{
+	if (sValue.empty() || "0.1" == sValue || "0.1 mm" == sValue)
 		return 0;
-	else if (L"0.12" == wsValue || L"0.12 mm" == wsValue)
+	else if ("0.12" == sValue || "0.12 mm" == sValue)
 		return 1;
-	else if (L"0.15" == wsValue || L"0.15 mm" == wsValue)
+	else if ("0.15" == sValue || "0.15 mm" == sValue)
 		return 2;
-	else if (L"0.2" == wsValue || L"0.2 mm" == wsValue)
+	else if ("0.2" == sValue || "0.2 mm" == sValue)
 		return 3;
-	else if (L"0.25" == wsValue || L"0.25 mm" == wsValue)
+	else if ("0.25" == sValue || "0.25 mm" == sValue)
 		return 4;
-	else if (L"0.3" == wsValue || L"0.3 mm" == wsValue)
+	else if ("0.3" == sValue || "0.3 mm" == sValue)
 		return 5;
-	else if (L"0.4" == wsValue || L"0.4 mm" == wsValue)
+	else if ("0.4" == sValue || "0.4 mm" == sValue)
 		return 6;
-	else if (L"0.5" == wsValue || L"0.5 mm" == wsValue)
+	else if ("0.5" == sValue || "0.5 mm" == sValue)
 		return 7;
-	else if (L"0.6" == wsValue || L"0.6 mm" == wsValue)
+	else if ("0.6" == sValue || "0.6 mm" == sValue)
 		return 8;
-	else if (L"0.7" == wsValue || L"0.7 mm" == wsValue)
+	else if ("0.7" == sValue || "0.7 mm" == sValue)
 		return 9;
-	else if (L"1.0" == wsValue || L"1.0 mm" == wsValue)
+	else if ("1.0" == sValue || "1.0 mm" == sValue)
 		return 10;
-	else if (L"1.5" == wsValue || L"1.5 mm" == wsValue)
+	else if ("1.5" == sValue || "1.5 mm" == sValue)
 		return 11;
-	else if (L"2.0" == wsValue || L"2.0 mm" == wsValue)
+	else if ("2.0" == sValue || "2.0 mm" == sValue)
 		return 12;
-	else if (L"3.0" == wsValue || L"3.0 mm" == wsValue)
+	else if ("3.0" == sValue || "3.0 mm" == sValue)
 		return 13;
-	else if (L"4.0" == wsValue || L"4.0 mm" == wsValue)
+	else if ("4.0" == sValue || "4.0 mm" == sValue)
 		return 14;
-	else if (L"5.0" == wsValue || L"5.0 mm" == wsValue)
+	else if ("5.0" == sValue || "5.0 mm" == sValue)
 		return 15;
 
 	return 0;

HwpFile/HwpDoc/Common/XMLReader.h

@@ -0,0 +1,110 @@
+#ifndef XMLNODEH_H
+#define XMLNODEH_H
+
+#include "../../../DesktopEditor/xml/include/xmlutils.h"
+
+namespace HWP
+{
+class CXMLReader
+{
+	XmlUtils::CXmlLiteReader *m_pReader;
+
+	bool m_bParseAttribute;
+public:
+	CXMLReader();
+	~CXMLReader();
+
+	XmlUtils::CXmlLiteReader* GetReader();
+	unsigned int GetDepth();
+	bool IsEmptyNode();
+
+	bool GetBool();
+	int GetColor(const int& nDefault = 0x000000);
+	int GetInt();
+	double GetDouble();
+	std::string GetTextA();
+	std::wstring GetText();
+	const char* GetTextChar();
+
+	int GetAttributeInt(const std::string& sName, int nDefault = 0);
+	bool GetAttributeBool(const std::string& sName);
+	double GetAttributeDouble(const std::string& sName);
+	std::string GetAttributeA(const std::string& sName);
+	std::wstring GetAttribute(const std::string& sName);
+
+	bool MoveToFirstAttribute();
+	bool MoveToNextAttribute();
+	bool MoveToElement();
+
+	std::wstring GetInnerXml();
+
+	std::string GetName();
+	bool ReadNextSiblingNode(unsigned int unDepth);
+	bool ReadNextNode();
+	bool Read(XmlUtils::XmlNodeType& eNodeType);
+private:
+	static int GetIntValue(CXMLReader& oXmlReader);
+	static bool GetBoolValue(CXMLReader& oXmlReader);
+	static double GetDoubleValue(CXMLReader& oXmlReader);
+	static std::string GetTextAValue(CXMLReader& oXmlReader);
+	static std::wstring GetTextValue(CXMLReader& oXmlReader);
+
+	template<typename T>
+	T GetAttribute(const std::string& sName, T _default, T (*GetValue)(CXMLReader& oXmlReader));
+};
+
+#define WHILE_READ_NEXT_NODE_WITH_DEPTH(xml_reader, name_depth)\
+	if (!xml_reader.IsEmptyNode())\
+	{\
+	const int n##name_depth = xml_reader.GetDepth();\
+	while (xml_reader.ReadNextSiblingNode(n##name_depth))\
+	{
+
+#define WHILE_READ_NEXT_NODE_WITH_DEPTH_AND_NAME(xml_reader, name_depth)\
+	if (!xml_reader.IsEmptyNode())\
+	{\
+	const int n##name_depth##Depth = xml_reader.GetDepth();\
+	std::string sNode##name_depth##Name;\
+	while (xml_reader.ReadNextSiblingNode(n##name_depth##Depth))\
+	{\
+		sNode##name_depth##Name = xml_reader.GetName();
+
+#define WHILE_READ_NEXT_NODE(xml_reader) WHILE_READ_NEXT_NODE_WITH_DEPTH(xml_reader, Depth)
+
+#define WHILE_READ_NEXT_NODE_WITH_NAME(xml_reader)\
+	if (!xml_reader.IsEmptyNode())\
+	{\
+	const int nDepth = xml_reader.GetDepth();\
+	std::string sNodeName;\
+	while (xml_reader.ReadNextSiblingNode(nDepth))\
+	{\
+		sNodeName = xml_reader.GetName();
+
+#define WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(xml_reader, name_depth, node_name)\
+	WHILE_READ_NEXT_NODE_WITH_DEPTH(xml_reader, name_depth)\
+		if (node_name != xml_reader.GetName())\
+			continue;
+
+#define WHILE_READ_NEXT_NODE_WITH_ONE_NAME(xml_reader, node_name) WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(xml_reader, Depth, node_name)
+
+#define END_WHILE } }
+
+#define START_READ_ATTRIBUTES(xml_reader)\
+	if (xml_reader.MoveToFirstAttribute())\
+	{\
+		std::string sAttributeName;\
+		do\
+		{\
+			sAttributeName = xml_reader.GetName();
+
+#define END_READ_ATTRIBUTES(xml_reader)\
+	}\
+	while(xml_reader.MoveToNextAttribute());\
+	xml_reader.MoveToElement();\
+	}
+
+int ConvertWidthToHWP(const std::string& sValue);
+int ConvertHexToInt(const std::string& sValue, const int& _default = 0x00000000);
+}
+
+#endif // XMLNODEH_H

HwpFile/HwpDoc/Conversion/Converter2OOXML.cpp

@@ -321,6 +321,12 @@ void CConverter2OOXML::WriteCharacter(const CCtrlCharacter* pCharacter, short sh
 			oState.m_eBreakType = TConversionState::EBreakType::TextWrapping;
 			break;
 		}
+		case ECtrlCharType::TABULATION:
+		{
+			OpenParagraph(shParaShapeID, shParaStyleID, oBuilder, oState);
+			oBuilder.WriteString(L"<w:r><w:tab/></w:r>");
+			break;
+		}
 		case ECtrlCharType::HARD_HYPHEN:
 		case ECtrlCharType::HARD_SPACE:
 			break;
@@ -670,6 +676,60 @@ void CConverter2OOXML::WriteParaShapeProperties(short shParaShapeID, short shPar
 		case EHeadingType::NONE:
 			break;
 	}
+
+	if (oState.m_bInTable)
+		return;
+
+	const CHwpRecordTabDef* pTabDef = m_pContext->GetTabDef(pParaShape->GetTabDef());
+
+	if (nullptr != pTabDef && 0 != pTabDef->GetCount())
+	{
+		oBuilder.WriteString(L"<w:tabs>");
+
+		const TTab *pTab = nullptr;
+		for (unsigned int unIndex = 0; unIndex < pTabDef->GetCount(); ++unIndex)
+		{
+			pTab = pTabDef->GetTab(unIndex);
+
+			if (nullptr == pTab)
+				continue;
+
+			oBuilder.WriteString(L"<w:tab w:val=\"");
+
+			switch (pTab->m_eType)
+			{
+				case TTab::EType::LEFT: oBuilder.WriteString(L"start"); break;
+				case TTab::EType::RIGHT: oBuilder.WriteString(L"end"); break;
+				case TTab::EType::CENTER: oBuilder.WriteString(L"center"); break;
+				case TTab::EType::DECIMAL: oBuilder.WriteString(L"decimal"); break;
+			}
+
+			oBuilder.WriteString(L"\" w:leader=\"");
+
+			switch (pTab->m_eLeader)
+			{
+				case ELineStyle2::NONE: oBuilder.WriteString(L"none"); break;
+				case ELineStyle2::SOLID:
+				case ELineStyle2::DOUBLE_SLIM:
+				case ELineStyle2::SLIM_THICK:
+				case ELineStyle2::THICK_SLIM:
+				case ELineStyle2::SLIM_THICK_SLIM:
+					oBuilder.WriteString(L"heavy"); break;
+				case ELineStyle2::DASH:
+				case ELineStyle2::LONG_DASH:
+				case ELineStyle2::DASH_DOT:
+				case ELineStyle2::DASH_DOT_DOT:
+					oBuilder.WriteString(L"hyphen"); break;
+				case ELineStyle2::DOT:
+				case ELineStyle2::CIRCLE:
+					oBuilder.WriteString(L"dot"); break;
+			}
+
+			oBuilder.WriteString(L"\" w:pos=\"" + std::to_wstring(pTab->m_nPos / 10) + L"\"/>");
+		}
+
+		oBuilder.WriteString(L"</w:tabs>");
+	}
 }
 
 void CConverter2OOXML::WriteTable(const CCtrlTable* pTable, short shParaShapeID, short shParaStyleID, NSStringUtils::CStringBuilder& oBuilder, TConversionState& oState)
@@ -1362,83 +1422,18 @@ bool CConverter2OOXML::SaveSVGFile(const HWP_STRING& sSVG, HWP_STRING& sFileName
 		return false;
 	}
 
-	NSGraphics::IGraphicsRenderer* pGrRenderer = NSGraphics::Create();
-	pGrRenderer->SetFontManager(pSvgReader->get_FontManager());
-
 	double dX, dY, dW, dH;
 	pSvgReader->GetBounds(&dX, &dY, &dW, &dH);
 
 	if (dW < 0) dW = -dW;
 	if (dH < 0) dH = -dH;
 
-	double dOneMaxSize = (double)1000.;
-
-	if (dW > dH && dW > dOneMaxSize)
-	{
-		dH *= (dOneMaxSize / dW);
-		dW = dOneMaxSize;
-	}
-	else if (dH > dW && dH > dOneMaxSize)
-	{
-		dW *= (dOneMaxSize / dH);
-		dH = dOneMaxSize;
-	}
-
-	int nWidth  = static_cast<int>(dW + 0.5);
-	int nHeight = static_cast<int>(dH + 0.5);
-
-	double dWidth  = 25.4 * nWidth / 96;
-	double dHeight = 25.4 * nHeight / 96;
-
-	unsigned char* pBgraData = (unsigned char*)malloc(nWidth * nHeight * 4);
-	if (!pBgraData)
-	{
-		double dKoef = 2000.0 / (nWidth > nHeight ? nWidth : nHeight);
-
-		nWidth = (int)(dKoef * nWidth);
-		nHeight = (int)(dKoef * nHeight);
-
-		dWidth  = 25.4 * nWidth / 96;
-		dHeight = 25.4 * nHeight / 96;
-
-		pBgraData = (unsigned char*)malloc(nWidth * nHeight * 4);
-	}
-
-	if (!pBgraData)
-		return false;
-
-	unsigned int alfa = 0xffffff;
-	//дефолтный тон должен быть прозрачным, а не белым
-	//memset(pBgraData, 0xff, nWidth * nHeight * 4);
-	for (int i = 0; i < nWidth * nHeight; i++)
-	{
-		((unsigned int*)pBgraData)[i] = alfa;
-	}
-
-	CBgraFrame oFrame;
-	oFrame.put_Data(pBgraData);
-	oFrame.put_Width(nWidth);
-	oFrame.put_Height(nHeight);
-	oFrame.put_Stride(-4 * nWidth);
-
-	pGrRenderer->CreateFromBgraFrame(&oFrame);
-	pGrRenderer->SetSwapRGB(false);
-	pGrRenderer->put_Width(dWidth);
-	pGrRenderer->put_Height(dHeight);
-
-	pSvgReader->SetTempDirectory(m_sTempDirectory);
-	pSvgReader->DrawOnRenderer(pGrRenderer, 0, 0, dWidth, dHeight);
-
 	sFileName = sFileName.substr(0, sFileName.find(L'.'));
 	sFileName += L".png";
 
-	oFrame.SaveFile(m_sTempDirectory + L"/word/media/" + sFileName, 4);
-	oFrame.put_Data(NULL);
+	const std::wstring wsImagePath{m_sTempDirectory + L"/word/media/" + sFileName};
 
-	RELEASEINTERFACE(pGrRenderer);
-
-	if (pBgraData)
-		free(pBgraData);
+	pSvgReader->ConvertToRaster(wsImagePath.c_str(), 4, dW, dH);
 
 	RELEASEINTERFACE(pSvgReader);
 	RELEASEINTERFACE(pFonts);

HwpFile/HwpDoc/Conversion/Converter2OOXML.h

@@ -24,8 +24,6 @@
 
 namespace HWP
 {
-
-
 struct TContentType
 {
 	HWP_STRING m_wsName;

HwpFile/HwpDoc/HWPDocInfo.cpp

@@ -182,81 +182,94 @@ bool CHWPDocInfo::Parse(CHWPStream& oBuffer, int nVersion)
 	return true;
 }
 
-bool CHWPDocInfo::Parse(CXMLNode& oNode, int nVersion)
+bool CHWPDocInfo::Parse(CXMLReader& oReader, int nVersion)
 {
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hh:beginNum" == oChild.GetName())
-			m_arRecords.push_back(new CHWPRecordDocumentProperties(*this, oChild, nVersion));
-		else if (L"hh:refList" == oChild.GetName())
-			ReadRefList(oChild, nVersion);
+		if ("hh:beginNum" == sNodeName)
+			m_arRecords.push_back(new CHWPRecordDocumentProperties(*this, oReader, nVersion));
+		else if ("hh:refList" == sNodeName)
+			ReadRefList(oReader, nVersion);
 	}
+	END_WHILE
 
 	return true;
 }
 
-bool CHWPDocInfo::ReadRefList(CXMLNode& oNode, int nVersion)
+bool CHWPDocInfo::ReadRefList(CXMLReader& oReader, int nVersion)
 {
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hh:fontfaces" == oChild.GetName())
+		if ("hh:fontfaces" == sNodeName)
 		{
-			for (CXMLNode& oFontFaceNode : oChild.GetChilds(L"hh:fontface"))
-				for (CXMLNode& oFontNode : oFontFaceNode.GetChilds(L"hh:font"))
-					m_arFaseNames.push_back(new CHWPRecordFaceName(*this, oFontNode, nVersion));
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, FontFace, "hh:fontface")
+				WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Font, "hh:font")
+			        m_arFaseNames.push_back(new CHWPRecordFaceName(*this, oReader, nVersion));
+				END_WHILE
+			END_WHILE
 		}
-		else if (L"hh:borderFills" == oChild.GetName())
+		else if ("hh:borderFills" == sNodeName)
 		{
-			for (CXMLNode& oBorderFillNode : oChild.GetChilds(L"hh:borderFill"))
-				m_arBorderFills.push_back(new CHWPRecordBorderFill(*this, oBorderFillNode, nVersion));
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, BorderFill, "hh:borderFill")
+				m_arBorderFills.push_back(new CHWPRecordBorderFill(*this, oReader, nVersion));
+			END_WHILE
 		}
-		else if (L"hh:charProperties" == oChild.GetName())
+		else if ("hh:charProperties" == sNodeName)
 		{
-			for (CXMLNode& oCharPrNode : oChild.GetChilds(L"hh:charPr"))
-				m_arCharShapes.push_back(new CHWPRecordCharShape(*this, oCharPrNode, nVersion));
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, CharPr, "hh:charPr")
+				m_arCharShapes.push_back(new CHWPRecordCharShape(*this, oReader, nVersion));
+			END_WHILE
 		}
-		else if (L"hh:tabProperties" == oChild.GetName())
+		else if ("hh:tabProperties" == sNodeName)
 		{
-			for (CXMLNode& oTabPrNode : oChild.GetChilds(L"hh:tabPr"))
-				m_arTabDefs.push_back(new CHwpRecordTabDef(*this, oTabPrNode, nVersion));
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, TabPr, "hh:tabPr")
+				m_arTabDefs.push_back(new CHwpRecordTabDef(*this, oReader, nVersion));
+			END_WHILE
 		}
-		else if (L"hh:numberings" == oChild.GetName())
+		else if ("hh:numberings" == sNodeName)
 		{
-			for (CXMLNode& oNumberingNode : oChild.GetChilds(L"hh:numbering"))
-				m_arNumberings.push_back(new CHWPRecordNumbering(*this, oNumberingNode, nVersion));
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Numbering, "hh:numbering")
+				m_arNumberings.push_back(new CHWPRecordNumbering(*this, oReader, nVersion));
+			END_WHILE
 		}
-		else if (L"hh:bullets" == oChild.GetName())
+		else if ("hh:bullets" == sNodeName)
 		{
-			for (CXMLNode& oBulletNode : oChild.GetChilds())
-				m_arBullets.push_back(new CHWPRecordBullet(*this, oBulletNode, nVersion));
+			WHILE_READ_NEXT_NODE_WITH_DEPTH(oReader, Bullet)
+				m_arBullets.push_back(new CHWPRecordBullet(*this, oReader, nVersion));
+			END_WHILE
 		}
-		else if (L"hh:paraProperties" == oChild.GetName())
+		else if ("hh:paraProperties" == sNodeName)
 		{
-			for (CXMLNode& oParaPrNode : oChild.GetChilds(L"hh:paraPr"))
-				m_arParaShapes.push_back(new CHWPRecordParaShape(*this, oParaPrNode, nVersion));
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, ParaPr, "hh:paraPr")
+				m_arParaShapes.push_back(new CHWPRecordParaShape(*this, oReader, nVersion));
+			END_WHILE
 		}
-		else if (L"hh:styles" == oChild.GetName())
+		else if ("hh:styles" == sNodeName)
 		{
-			for (CXMLNode& oStyleNode : oChild.GetChilds(L"hh:style"))
-				m_arStyles.push_back(new CHWPRecordStyle(*this, oStyleNode, nVersion));
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Style, "hh:style")
+				m_arStyles.push_back(new CHWPRecordStyle(*this, oReader, nVersion));
+			END_WHILE
 		}
 	}
+	END_WHILE
 
 	return true;
 }
 
-bool CHWPDocInfo::ReadContentHpf(CXMLNode& oNode, int nVersion)
+bool CHWPDocInfo::ReadContentHpf(CXMLReader& oReader, int nVersion)
 {
 	CHWPRecordBinData *pRecordBinData = nullptr;
 
-	for (CXMLNode& oChild : oNode.GetChilds(L"opf:manifest"))
+	WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "opf:manifest")
 	{
-		for (CXMLNode& oGrandChild : oChild.GetChilds(L"opf:item"))
+		WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Item, "opf:item")
 		{
-			pRecordBinData = new CHWPRecordBinData(oGrandChild, nVersion);
+			pRecordBinData = new CHWPRecordBinData(oReader, nVersion);
 			m_mBinDatas.insert(std::make_pair<HWP_STRING, CHWPRecord*>(pRecordBinData->GetItemID(), (HWP::CHWPRecord*)pRecordBinData));
 		}
+		END_WHILE
 	}
+	END_WHILE
 
 	return true;
 }

HwpFile/HwpDoc/HWPDocInfo.h

@@ -4,7 +4,7 @@
 #include "HanType.h"
 #include "HWPStream.h"
 #include "HWPElements/HWPRecord.h"
-#include "Common/XMLNode.h"
+#include "Common/XMLReader.h"
 
 #include <map>
 
@@ -46,8 +46,8 @@ public:
 	~CHWPDocInfo();
 
 	bool Parse(CHWPStream& oBuffer, int nVersion);
-	bool Parse(CXMLNode& oNode, int nVersion);
-	bool ReadContentHpf(CXMLNode& oNode, int nVersion);
+	bool Parse(CXMLReader& oReader, int nVersion);
+	bool ReadContentHpf(CXMLReader& oReader, int nVersion);
 
 	const CHWPRecord* GetRecord(int nIndex) const;
 	const CHWPRecord* GetFaceName(int nIndex) const;
@@ -65,7 +65,7 @@ public:
 	EHanType GetHanType() const;
 	ECompatDoc GetCompatibleDoc() const;
 private:
-	bool ReadRefList(CXMLNode& oNode, int nVersion);
+	bool ReadRefList(CXMLReader& oReader, int nVersion);
 };
 }
 

HwpFile/HwpDoc/HWPElements/HWPRecordBinData.cpp

@@ -74,35 +74,41 @@ CHWPRecordBinData::CHWPRecordBinData(CHWPDocInfo& oDocInfo, int nTagNum, int nLe
 	oBuffer.Skip(nSize - oBuffer.GetDistanceToLastPos(true));
 }
 
-CHWPRecordBinData::CHWPRecordBinData(CXMLNode& oNode, int nVersion)
+CHWPRecordBinData::CHWPRecordBinData(CXMLReader& oReader, int nVersion)
 	: CHWPRecord(EHWPTag::HWPTAG_BIN_DATA, 0, 0)
 {
-	m_sItemID = oNode.GetAttribute(L"id");
+	std::string sType;
+	HWP_STRING sSubPath;
 
-	HWP_STRING sType = oNode.GetAttribute(L"isEmbeded");
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("id" == sAttributeName)
+			m_sItemID = oReader.GetText();
+		else if ("isEmbeded" == sAttributeName)
+			sType = oReader.GetTextA();
+		else if ("href" == sAttributeName)
+			m_sAPath = oReader.GetText();
+		else if ("sub-path" == sAttributeName)
+			sSubPath = oReader.GetText();
+		else if ("media-type" == sAttributeName)
+		{
+			m_sFormat = oReader.GetText();
 
-	if (L"0" == sType)
+			std::wregex oRegex(L"image/(.*)");
+			m_sFormat = std::regex_replace(m_sFormat, oRegex, L"$1");
+		}
+	}
+	END_READ_ATTRIBUTES(oReader)
+
+	if ("0" == sType)
 	{
 		m_eType = EType::LINK;
 
-		m_sAPath = oNode.GetAttribute(L"sub-path");
-
-		if (m_sAPath.empty())
-			m_sAPath = oNode.GetAttribute(L"href");
+		if (!sSubPath.empty())
+			m_sAPath = sSubPath;
 	}
-	else if (L"1" == sType)
-	{
+	else if ("1" == sType)
 		m_eType = EType::EMBEDDING;
-		m_sAPath = oNode.GetAttribute(L"href");
-	}
-	else
-		m_sAPath = oNode.GetAttribute(L"href");
-
-	m_sFormat = oNode.GetAttribute(L"media-type");
-
-	std::wregex oRegex(L"image/(.*)");
-
-	m_sFormat = std::regex_replace(m_sFormat, oRegex, L"$1");
 }
 
 HWP_STRING CHWPRecordBinData::GetPath() const

HwpFile/HwpDoc/HWPElements/HWPRecordBinData.h

@@ -4,7 +4,7 @@
 #include "HWPRecord.h"
 #include "../HWPStream.h"
 #include "../HWPDocInfo.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -44,7 +44,7 @@ class CHWPRecordBinData : public CHWPRecord
 	HWP_STRING m_sItemID;
 public:
 	CHWPRecordBinData(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CHWPRecordBinData(CXMLNode& oNode, int nVersion);
+	CHWPRecordBinData(CXMLReader& oReader, int nVersion);
 
 	HWP_STRING GetPath() const;
 	HWP_STRING GetItemID() const;

HwpFile/HwpDoc/HWPElements/HWPRecordBorderFill.cpp

@@ -58,19 +58,26 @@ EColorFillPattern GetColorFillPattern(int nPattern)
 	}
 }
 
-void TBorder::ReadFromNode(CXMLNode& oNode)
+void TBorder::Read(CXMLReader& oReader)
 {
-	m_eStyle  = GetLineStyle2(oNode.GetAttribute(L"type"));
-	m_nColor  = oNode.GetAttributeColor(L"color");
-	m_chWidth = (HWP_BYTE)ConvertWidthToHWP(oNode.GetAttribute(L"width"));
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("type" == sAttributeName)
+			m_eStyle = GetLineStyle2(oReader.GetText());
+		else if ("color" == sAttributeName)
+			m_nColor = oReader.GetInt();
+		else if ("width" == sAttributeName)
+			m_chWidth = (HWP_BYTE)ConvertWidthToHWP(oReader.GetTextA());
+	}
+	END_READ_ATTRIBUTES(oReader)
 }
 
 CFill::CFill()
-	: m_nFillType(0)
+	: m_nFillType(0), m_eHatchStyle(EColorFillPattern::NONE), m_eMode(EImageFillType::NONE), m_chAlpha(0xff)
 {}
 
 CFill::CFill(CHWPStream& oBuffer, int nOff, int nSize)
-	: m_nFillType(0)
+	: m_nFillType(0), m_eHatchStyle(EColorFillPattern::NONE), m_eMode(EImageFillType::NONE), m_chAlpha(0xff)
 {
 	oBuffer.SavePosition();
 
@@ -147,82 +154,117 @@ CFill::CFill(CHWPStream& oBuffer, int nOff, int nSize)
 	m_nSize = oBuffer.GetDistanceToLastPos(true);
 }
 
-CFill::CFill(CXMLNode& oNode)
-	: m_nFillType(0)
+CFill::CFill(CXMLReader& oReader)
+	: m_nFillType(0), m_eHatchStyle(EColorFillPattern::NONE), m_eMode(EImageFillType::NONE), m_chAlpha(0xff)
 {
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hc:winBrush" == oChild.GetName())
+		if ("hc:winBrush" == sNodeName)
 		{
-			ReadWinBrush(oChild);
+			ReadWinBrush(oReader);
 			m_nFillType |= 0x01;
 		}
-		else if (L"hc:gradation" == oChild.GetName())
+		else if ("hc:gradation" == sNodeName)
 		{
-			ReadGradation(oChild);
+			ReadGradation(oReader);
 			m_nFillType |= 0x04;
 		}
-		else if (L"hc:imgBrush" == oChild.GetName())
+		else if ("hc:imgBrush" == sNodeName)
 		{
-			ReadImgBrush(oChild);
+			ReadImgBrush(oReader);
 			m_nFillType |= 0x02;
 		}
 	}
+	END_WHILE
 }
 
-void CFill::ReadWinBrush(CXMLNode& oNode)
+void CFill::ReadWinBrush(CXMLReader& oReader)
 {
-	m_nFaceColor = oNode.GetAttributeColor(L"faceColor", 0xFFFFFFFF);
-	m_nHatchColor = oNode.GetAttributeColor(L"hatchColor", 0x000000);
-	m_eHatchStyle = GetColorFillPattern(oNode.GetAttributeInt(L"hatchStyle", -1));
-	m_chAlpha = (HWP_BYTE)oNode.GetAttributeInt(L"alpha", 255);
-}
+	m_eHatchStyle = EColorFillPattern::NONE;
+	m_chAlpha = 0xff;
 
-void CFill::ReadGradation(CXMLNode& oNode)
-{
-	m_eGradType = ::HWP::GetGradFillType(oNode.GetAttributeInt(L"type"));
-	m_nAngle = oNode.GetAttributeInt(L"angle");
-	m_nCenterX = oNode.GetAttributeInt(L"centerX");
-	m_nCenterY = oNode.GetAttributeInt(L"centerY");
-	m_nStep = oNode.GetAttributeInt(L"step");
-	m_nColorNum = oNode.GetAttributeInt(L"colorNum");
-	m_chStepCenter = (HWP_BYTE)oNode.GetAttributeInt(L"stepCenter");
-	m_chAlpha = (HWP_BYTE)oNode.GetAttributeInt(L"alpha", 255);
-
-	std::vector<XmlUtils::CXmlNode> arChilds;
-
-	oNode.GetNodes(L"hc:color", arChilds);
-
-	m_arColors.resize(arChilds.size());
-
-	for (unsigned int unIndex = 0; unIndex < arChilds.size(); ++unIndex)
-		m_arColors[unIndex] = CXMLNode(arChilds[unIndex]).GetAttributeColor(L"value");
-}
-
-void CFill::ReadImgBrush(CXMLNode& oNode)
-{
-	m_eMode = GetImageFillType(oNode.GetAttributeInt(L"mode", (int)EImageFillType::NONE));
-
-	for (CXMLNode& oChild : oNode.GetChilds())
+	START_READ_ATTRIBUTES(oReader)
 	{
-		if (L"hc:img" == oChild.GetName())
-		{
-			m_chBright = (HWP_BYTE)oChild.GetAttributeInt(L"bright");
-			m_chContrast = (HWP_BYTE)oChild.GetAttributeInt(L"contrast");
-
-			HWP_STRING sEffect = oChild.GetAttribute(L"effect");
-
-			if (L"REAL_PIC" == sEffect)
-				m_chEffect = 0;
-			else if (L"GRAY_SCALE" == sEffect)
-				m_chEffect = 1;
-			else if (L"BLACK_WHITE" == sEffect)
-				m_chEffect = 2;
-
-			m_sBinItemID = oChild.GetAttribute(L"binaryItemIDRef");
-			m_chAlpha = (HWP_BYTE)oChild.GetAttributeInt(L"alpha", 255);
-		}
+		if ("faceColor" == sAttributeName)
+			m_nFaceColor = oReader.GetColor(0xFFFFFFFF);
+		else if ("hatchColor" == sAttributeName)
+			m_nHatchColor = oReader.GetColor();
+		else if ("hatchStyle" == sAttributeName)
+			m_eHatchStyle = GetColorFillPattern(oReader.GetInt());
+		else if ("alpha" == sAttributeName)
+			m_chAlpha = (HWP_BYTE)oReader.GetInt();
 	}
+	END_READ_ATTRIBUTES(oReader)
+}
+
+void CFill::ReadGradation(CXMLReader& oReader)
+{
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("type" == sAttributeName)
+			m_eGradType = ::HWP::GetGradFillType(oReader.GetInt());
+		else if ("angle" == sAttributeName)
+			m_nAngle = oReader.GetInt();
+		else if ("centerX" == sAttributeName)
+			m_nCenterX = oReader.GetInt();
+		else if ("centerY" == sAttributeName)
+			m_nCenterY = oReader.GetInt();
+		else if ("step" == sAttributeName)
+			m_nStep = oReader.GetInt();
+		else if ("colorNum" == sAttributeName)
+			m_nColorNum = oReader.GetInt();
+		else if ("stepCenter" == sAttributeName)
+			m_chStepCenter = (HWP_BYTE)oReader.GetInt();
+		else if ("alpha" == sAttributeName)
+			m_chAlpha = (HWP_BYTE)oReader.GetInt();
+	}
+	END_READ_ATTRIBUTES(oReader)
+
+	WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hc:color")
+	{
+		START_READ_ATTRIBUTES(oReader)
+		{
+			if ("value" != oReader.GetName())
+				continue;
+
+			m_arColors.push_back(oReader.GetColor(true));
+		}
+		END_READ_ATTRIBUTES(oReader)
+	}
+	END_WHILE
+}
+
+void CFill::ReadImgBrush(CXMLReader& oReader)
+{
+	m_eMode = GetImageFillType(oReader.GetAttributeInt("mode"));
+
+	WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hc:img")
+	{
+		START_READ_ATTRIBUTES(oReader)
+		{
+			if ("bright" == sAttributeName)
+				m_chBright = (HWP_BYTE)oReader.GetInt();
+			else if ("contrast" == sAttributeName)
+				m_chContrast = (HWP_BYTE)oReader.GetInt();
+			else if ("effect" == sAttributeName)
+			{
+				const std::string sEffect{oReader.GetTextA()};
+
+				if ("REAL_PIC" == sEffect)
+					m_chEffect = 0;
+				else if ("GRAY_SCALE" == sEffect)
+					m_chEffect = 1;
+				else if ("BLACK_WHITE" == sEffect)
+					m_chEffect = 2;
+			}
+			else if ("binaryItemIDRef" == sAttributeName)
+				m_sBinItemID = oReader.GetText();
+			else if ("alpha" == sAttributeName)
+				m_chAlpha = (HWP_BYTE)oReader.GetInt();
+		}
+		END_READ_ATTRIBUTES(oReader)
+	}
+	END_WHILE
 }
 
 int CFill::GetSize() const
@@ -333,66 +375,88 @@ CHWPRecordBorderFill::CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, int nTagNum, i
 	m_pFill = new CFill(oBuffer, 0, 0); // TODO:: перейти от использования off и size
 }
 
-CHWPRecordBorderFill::CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion)
+CHWPRecordBorderFill::CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
 	: CHWPRecord(EHWPTag::HWPTAG_BORDER_FILL, 0, 0), m_pFill(nullptr)
 {
-	m_bThreeD = oNode.GetAttributeBool(L"threeD");
-	m_bShadow = oNode.GetAttributeBool(L"shadow");
-	m_bBreakCellSeparateLine = oNode.GetAttributeBool(L"breakCellSeparateLine");
-
-	HWP_STRING sChildName;
-
-	for (CXMLNode& oChild : oNode.GetChilds())
+	START_READ_ATTRIBUTES(oReader)
 	{
-		if (L"hh:slash" == oChild.GetName())
-		{
-			HWP_STRING sType = oChild.GetAttribute(L"type");
-
-			if (L"NONE" == sType)
-				m_chSlash = 0x0;
-			else if (L"CENTER" == sType)
-				m_chSlash = 0b010;
-			else if (L"CENTER_BELOW" == sType)
-				m_chSlash = 0b011;
-			else if (L"CENTER_ABOVE" == sType)
-				m_chSlash = 0b110;
-			else if (L"ALL" == sType)
-				m_chSlash = 0b111;
-
-			m_chCrookedSlash = oChild.GetAttributeBool(L"Crooked");
-			m_bCounterSlash = oChild.GetAttributeBool(L"isCounter");
-		}
-		else if (L"hh:backSlash" == oChild.GetName())
-		{
-			HWP_STRING sType = oChild.GetAttribute(L"type");
-
-			if (L"NONE" == sType)
-				m_chBackSlash = 0x0;
-			else if (L"CENTER" == sType)
-				m_chBackSlash = 0b010;
-			else if (L"CENTER_BELOW" == sType)
-				m_chBackSlash = 0b011;
-			else if (L"CENTER_ABOVE" == sType)
-				m_chBackSlash = 0b110;
-			else if (L"ALL" == sType)
-				m_chBackSlash = 0b111;
-
-			m_chCrookedBackSlash = oChild.GetAttributeBool(L"Crooked");
-			m_bCounterBackSlash = oChild.GetAttributeBool(L"isCounter");
-		}
-		else if (L"hh:leftBorder" == oChild.GetName())
-			m_oLeft.ReadFromNode(oChild);
-		else if (L"hh:rightBorder" == oChild.GetName())
-			m_oRight.ReadFromNode(oChild);
-		else if (L"hh:topBorder" == oChild.GetName())
-			m_oTop.ReadFromNode(oChild);
-		else if (L"hh:bottomBorder" == oChild.GetName())
-			m_oBottom.ReadFromNode(oChild);
-		else if (L"hh:diagonal" == oChild.GetName())
-			m_oDiagonal.ReadFromNode(oChild);
-		else if (L"hc:fillBrush" == oChild.GetName())
-			m_pFill = new CFill(oChild);
+		if ("threeD" == sAttributeName)
+			m_bThreeD = oReader.GetBool();
+		else if ("shadow" == sAttributeName)
+			m_bShadow = oReader.GetBool();
+		else if ("breakCellSeparateLine" == sAttributeName)
+			m_bBreakCellSeparateLine = oReader.GetBool();
 	}
+	END_READ_ATTRIBUTES(oReader)
+
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
+	{
+		if ("hh:slash" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("type" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
+
+					if ("NONE" == sType)
+						m_chSlash = 0x0;
+					else if ("CENTER" == sType)
+						m_chSlash = 0b010;
+					else if ("CENTER_BELOW" == sType)
+						m_chSlash = 0b011;
+					else if ("CENTER_ABOVE" == sType)
+						m_chSlash = 0b110;
+					else if ("ALL" == sType)
+						m_chSlash = 0b111;
+				}
+				else if ("Crooked" == sAttributeName)
+					m_chCrookedSlash = oReader.GetBool();
+				else if ("isCounter" == sAttributeName)
+					m_bCounterSlash = oReader.GetBool();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hh:backSlash" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("type" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
+
+					if ("NONE" == sType)
+						m_chBackSlash = 0x0;
+					else if ("CENTER" == sType)
+						m_chBackSlash = 0b010;
+					else if ("CENTER_BELOW" == sType)
+						m_chBackSlash = 0b011;
+					else if ("CENTER_ABOVE" == sType)
+						m_chBackSlash = 0b110;
+					else if ("ALL" == sType)
+						m_chBackSlash = 0b111;
+				}
+				else if ("Crooked" == sAttributeName)
+					m_chCrookedBackSlash = oReader.GetBool();
+				else if ("isCounter" == sAttributeName)
+					m_bCounterBackSlash = oReader.GetBool();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hh:leftBorder" == sNodeName)
+			m_oLeft.Read(oReader);
+		else if ("hh:rightBorder" == sNodeName)
+			m_oRight.Read(oReader);
+		else if ("hh:topBorder" == sNodeName)
+			m_oTop.Read(oReader);
+		else if ("hh:bottomBorder" == sNodeName)
+			m_oBottom.Read(oReader);
+		else if ("hh:diagonal" == sNodeName)
+			m_oDiagonal.Read(oReader);
+		else if ("hc:fillBrush" == sNodeName)
+			m_pFill = new CFill(oReader);
+	}
+	END_WHILE
 }
 
 CHWPRecordBorderFill::~CHWPRecordBorderFill()

HwpFile/HwpDoc/HWPElements/HWPRecordBorderFill.h

@@ -4,7 +4,7 @@
 #include "../HWPDocInfo.h"
 #include "HwpRecordTypes.h"
 #include "../HWPStream.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 #include <vector>
 
 namespace HWP
@@ -15,7 +15,7 @@ struct TBorder
 	HWP_BYTE m_chWidth;
 	int m_nColor;
 
-	void ReadFromNode(CXMLNode& oNode);
+	void Read(CXMLReader& oReader);
 };
 
 enum class EImageFillType
@@ -86,13 +86,13 @@ class CFill : public IRef
 
 	HWP_BYTE m_chAlpha;
 
-	void ReadWinBrush(CXMLNode& oNode);
-	void ReadGradation(CXMLNode& oNode);
-	void ReadImgBrush(CXMLNode& oNode);
+	void ReadWinBrush(CXMLReader& oReader);
+	void ReadGradation(CXMLReader& oReader);
+	void ReadImgBrush(CXMLReader& oReader);
 public:
 	CFill();
 	CFill(CHWPStream& oBuffer, int nOff, int nSize);
-	CFill(CXMLNode& oNode);
+	CFill(CXMLReader& oReader);
 
 	int GetSize() const;
 	bool NoneFill() const;
@@ -136,7 +136,7 @@ class CHWPRecordBorderFill : public CHWPRecord
 public:
 	CHWPRecordBorderFill(int nTagNum, int nLevel, int nSize);
 	CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion);
+	CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion);
 	~CHWPRecordBorderFill();
 
 	TBorder GetLeftBorder() const;

HwpFile/HwpDoc/HWPElements/HWPRecordBullet.cpp

@@ -45,25 +45,32 @@ CHWPRecordBullet::CHWPRecordBullet(CHWPDocInfo& oDocInfo, int nTagNum, int nLeve
 		oBuffer.ReadChar(m_chCheckBulletChar);
 }
 
-CHWPRecordBullet::CHWPRecordBullet(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion)
+CHWPRecordBullet::CHWPRecordBullet(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
 	: CHWPRecord(EHWPTag::HWPTAG_BULLET, 0, 0), m_pParent(&oDocInfo)
 {
-	std::wstring wsAttributeValue = oNode.GetAttribute(L"char");
-
-	if (!wsAttributeValue.empty())
-		m_chBulletChar = wsAttributeValue.at(0);
-
-	wsAttributeValue = oNode.GetAttribute(L"checkedChar");
-
-	if (!wsAttributeValue.empty())
-		m_chCheckBulletChar = wsAttributeValue.at(0);
-
-	m_nBulletImage = oNode.GetAttributeInt(L"useImage");
-
-	for (CXMLNode& oChild : oNode.GetChilds())
+	START_READ_ATTRIBUTES(oReader)
 	{
-		if (L"hc:img" == oChild.GetName())
-			m_sBinItemRefID = oChild.GetAttribute(L"binaryItemIDRef");
+		if ("char" == sAttributeName)
+		{
+			const HWP_STRING wsValue{oReader.GetText()};
+
+			if (!wsValue.empty())
+				m_chBulletChar = wsValue.at(0);
+		}
+		else if ("checkedChar" == sAttributeName)
+		{
+			const HWP_STRING wsValue{oReader.GetText()};
+
+			if (!wsValue.empty())
+				m_chCheckBulletChar = wsValue.at(0);
+		}
+		else if ("useImage" == sAttributeName)
+			m_nBulletImage = oReader.GetInt();
 	}
+	END_READ_ATTRIBUTES(oReader)
+
+	WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hc:img")
+		m_sBinItemRefID = oReader.GetAttribute("binaryItemIDRef");
+	END_WHILE
 }
 }

HwpFile/HwpDoc/HWPElements/HWPRecordBullet.h

@@ -5,7 +5,7 @@
 #include "../HWPStream.h"
 #include "../HWPDocInfo.h"
 #include "HWPRecordNumbering.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -24,7 +24,7 @@ class CHWPRecordBullet : public CHWPRecord
 	HWP_CHAR m_chCheckBulletChar;
 public:
 	CHWPRecordBullet(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CHWPRecordBullet(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion);
+	CHWPRecordBullet(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion);
 };
 }
 

HwpFile/HwpDoc/HWPElements/HWPRecordCharShape.cpp

@@ -107,15 +107,29 @@ EShadow GetShadow(const HWP_STRING& sValue)
 	ELSE_STRING_IN_ENUM(NONE, EShadow);
 }
 
-void CHWPRecordCharShape::ReadContainerData(CXMLNode& oNode, short arValues[], int nDefaultValue)
+void CHWPRecordCharShape::ReadContainerData(CXMLReader& oReader, short arValues[], int nDefaultValue)
 {
-	arValues[(int)ELang::HANGUL]   = oNode.GetAttributeInt(L"hangul",   nDefaultValue);
-	arValues[(int)ELang::LATIN]    = oNode.GetAttributeInt(L"latin",    nDefaultValue);
-	arValues[(int)ELang::HANJA]    = oNode.GetAttributeInt(L"hanja",    nDefaultValue);
-	arValues[(int)ELang::JAPANESE] = oNode.GetAttributeInt(L"japanese", nDefaultValue);
-	arValues[(int)ELang::OTHER]    = oNode.GetAttributeInt(L"other",    nDefaultValue);
-	arValues[(int)ELang::SYMBOL]   = oNode.GetAttributeInt(L"symbol",   nDefaultValue);
-	arValues[(int)ELang::USER]     = oNode.GetAttributeInt(L"user",     nDefaultValue);
+	for (unsigned int unIndex = 0; unIndex < (int)ELang::MAX; ++unIndex)
+		arValues[unIndex] = nDefaultValue;
+
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("hangul" == sAttributeName)
+			arValues[(int)ELang::HANGUL] = oReader.GetInt();
+		else if ("latin" == sAttributeName)
+			arValues[(int)ELang::LATIN] = oReader.GetInt();
+		else if ("hanja" == sAttributeName)
+			arValues[(int)ELang::HANJA] = oReader.GetInt();
+		else if ("japanese" == sAttributeName)
+			arValues[(int)ELang::JAPANESE] = oReader.GetInt();
+		else if ("other" == sAttributeName)
+			arValues[(int)ELang::OTHER] = oReader.GetInt();
+		else if ("symbol" == sAttributeName)
+			arValues[(int)ELang::SYMBOL] = oReader.GetInt();
+		else if ("user" == sAttributeName)
+			arValues[(int)ELang::USER] = oReader.GetInt();
+	}
+	END_READ_ATTRIBUTES(oReader)
 }
 
 CHWPRecordCharShape::CHWPRecordCharShape(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion)
@@ -194,103 +208,138 @@ CHWPRecordCharShape::CHWPRecordCharShape(CHWPDocInfo& oDocInfo, int nTagNum, int
 	oBuffer.RemoveLastSavedPos();
 }
 
-CHWPRecordCharShape::CHWPRecordCharShape(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion)
+CHWPRecordCharShape::CHWPRecordCharShape(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
 	: CHWPRecord(EHWPTag::HWPTAG_HWP_CHAR_SHAPE, 0, 0), m_pParent(&oDocInfo),
-      m_bItalic(false), m_bBold(false), m_bEmboss(false), m_bEngrave(false),
-      m_bSuperScript(false), m_bSubScript(false)
+      m_nHeight(1000), m_bItalic(false), m_bBold(false), m_eUnderline(EUnderline::NONE),
+      m_eUnderLineShape(ELineStyle1::SOLID), m_eOutline(EOutline::NONE), m_eShadow(EShadow::NONE), m_bEmboss(false), m_bEngrave(false),
+      m_bSuperScript(false), m_bSubScript(false), m_eStrikeOutShape(ELineStyle2::NONE), m_nShadeColor(0xFFFFFFFF)
 {
-	m_eUnderline = EUnderline::NONE;
-	m_eUnderLineShape = ELineStyle1::SOLID;
-	m_eOutline = EOutline::NONE;
-	m_eShadow = EShadow::NONE;
-	m_eStrikeOutShape = ELineStyle2::NONE;
-
-	m_nHeight = oNode.GetAttributeInt(L"height", 1000);
-	m_nTextColor = oNode.GetAttributeColor(L"textColor", 0x000000);
-	m_nShadeColor = oNode.GetAttributeColor(L"shadeColor", 0xFFFFFFFF);
-	m_bUseFontSpace = oNode.GetAttributeBool(L"useFontSpace");
-	m_bUseKerning = oNode.GetAttributeBool(L"useKerning");
-
-	m_eSymMark = GetAccent(oNode.GetAttribute(L"symMark"));
-
-	m_shBorderFillIDRef = oNode.GetAttributeInt(L"borderFillIDRef");
-
-	for (CXMLNode& oChild : oNode.GetChilds())
+	START_READ_ATTRIBUTES(oReader)
 	{
-		if (L"hh:fontRef" == oChild.GetName())
+		if ("height" == sAttributeName)
+			m_nHeight = oReader.GetInt();
+		else if ("textColor" == sAttributeName)
+			m_nTextColor = oReader.GetColor();
+		else if ("shadeColor" == sAttributeName)
+			m_nShadeColor = oReader.GetColor(0xFFFFFFFF);
+		else if ("useFontSpace" == sAttributeName)
+			m_bUseFontSpace = oReader.GetBool();
+		else if ("useKerning" == sAttributeName)
+			m_bUseKerning = oReader.GetBool();
+		else if ("symMark" == sAttributeName)
+			m_eSymMark = GetAccent(oReader.GetText());
+		else if ("borderFillIDRef" == sAttributeName)
+			m_shBorderFillIDRef = oReader.GetInt();
+	}
+	END_READ_ATTRIBUTES(oReader)
+
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
+	{
+		if ("hh:fontRef" == sNodeName)
 		{
 			if (nullptr == m_pParent)
 				continue;
 
 			const CHWPRecordFaceName* pFaceName = nullptr;
 
-			#define UPDATE_FACENAME(node_name, elang_type) \
-			pFaceName = dynamic_cast<const CHWPRecordFaceName*>(m_pParent->GetFaceName(oChild.GetAttributeInt(node_name))); \
-			if (nullptr != pFaceName) \
-				m_arFontNames[(int)elang_type] = pFaceName->GetFaceName()
+			#define UPDATE_FACENAME(elang_type)\
+			{\
+				pFaceName = dynamic_cast<const CHWPRecordFaceName*>(m_pParent->GetFaceName(oReader.GetInt()));\
+				if (nullptr != pFaceName)\
+					m_arFontNames[(int)elang_type] = pFaceName->GetFaceName();\
+			}
 
-			UPDATE_FACENAME(L"hangul",   ELang::HANGUL);
-			UPDATE_FACENAME(L"latin",    ELang::LATIN);
-			UPDATE_FACENAME(L"hanja",    ELang::HANJA);
-			UPDATE_FACENAME(L"japanese", ELang::JAPANESE);
-			UPDATE_FACENAME(L"other",    ELang::OTHER);
-			UPDATE_FACENAME(L"symbol",   ELang::SYMBOL);
-			UPDATE_FACENAME(L"user",     ELang::USER);
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("hangul" == sAttributeName)
+					UPDATE_FACENAME(ELang::HANGUL)
+				else if ("latin" == sAttributeName)
+					UPDATE_FACENAME(ELang::LATIN)
+				else if ("hanja" == sAttributeName)
+					UPDATE_FACENAME(ELang::HANJA)
+				else if ("japanese" == sAttributeName)
+					UPDATE_FACENAME(ELang::JAPANESE)
+				else if ("other" == sAttributeName)
+					UPDATE_FACENAME(ELang::OTHER)
+				else if ("symbol" == sAttributeName)
+					UPDATE_FACENAME(ELang::SYMBOL)
+				else if ("user" == sAttributeName)
+					UPDATE_FACENAME(ELang::USER)
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hh:ratio" == oChild.GetName())
-			ReadContainerData(oChild, m_arRatios, 100);
-		else if (L"hh:spacing" == oChild.GetName())
-			ReadContainerData(oChild, m_arSpacings);
-		else if (L"hh:relSz" == oChild.GetName())
-			ReadContainerData(oChild, m_arRelSizes, 100);
-		else if (L"hh:offset" == oChild.GetName())
-			ReadContainerData(oChild, m_arCharOffset);
-		else if (L"hh:underline" == oChild.GetName())
+		else if ("hh:ratio" == sNodeName)
+			ReadContainerData(oReader, m_arRatios, 100);
+		else if ("hh:spacing" == sNodeName)
+			ReadContainerData(oReader, m_arSpacings);
+		else if ("hh:relSz" == sNodeName)
+			ReadContainerData(oReader, m_arRelSizes, 100);
+		else if ("hh:offset" == sNodeName)
+			ReadContainerData(oReader, m_arCharOffset);
+		else if ("hh:underline" == sNodeName)
 		{
-			m_eUnderline = GetUnderline(oChild.GetAttribute(L"type"));
-			m_eUnderLineShape = GetLineStyle1(oChild.GetAttribute(L"shape"));
-			m_nUnderlineColor = oChild.GetAttributeColor(L"color");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("type" == sAttributeName)
+					m_eUnderline = GetUnderline(oReader.GetText());
+				else if ("shape" == sAttributeName)
+					m_eUnderLineShape = GetLineStyle1(oReader.GetText());
+				else if ("color" == sAttributeName)
+					m_nUnderlineColor = oReader.GetColor();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hh:strikeout" == oChild.GetName())
+		else if ("hh:strikeout" == sNodeName)
 		{
-			m_eStrikeOutShape = GetLineStyle2(oChild.GetAttribute(L"shape"));
-			m_nStrikeOutColor = oChild.GetAttributeColor(L"color");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("shape" == sAttributeName)
+					m_eStrikeOutShape = GetLineStyle2(oReader.GetText());
+				else if ("color" == sAttributeName)
+					m_nStrikeOutColor = oReader.GetColor();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hh:outline" == sNodeName)
+			m_eOutline = GetOutline(oReader.GetAttribute("type"));
+		else if ("hh:shadow" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("type" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
 
-			if (L"3D" == oChild.GetAttribute(L"shape"))
-				m_eStrikeOutShape = ELineStyle2::NONE;
+					if ("DROP" == sType)
+						m_eShadow = EShadow::DISCRETE;
+					else if ("CONTINUOUS" == sType)
+						m_eShadow = EShadow::CONTINUOUS;
+					else
+						m_eShadow = EShadow::NONE;
+				}
+				else if ("color" == sAttributeName)
+					m_nShadowColor = oReader.GetColor();
+				else if ("offsetX" == sAttributeName)
+					m_chShadowOffsetX = (HWP_BYTE)oReader.GetInt();
+				else if ("offsetY" == sAttributeName)
+					m_chShadowOffsetY = (HWP_BYTE)oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hh:outline" == oChild.GetName())
-		{
-			m_eOutline = GetOutline(oChild.GetAttribute(L"type"));
-		}
-		else if (L"hh:shadow" == oChild.GetName())
-		{
-			HWP_STRING sType = oChild.GetAttribute(L"type");
-
-			if (L"DROP" == sType)
-				m_eShadow = EShadow::DISCRETE;
-			else if (L"CONTINUOUS" == sType)
-				m_eShadow = EShadow::CONTINUOUS;
-			else
-				m_eShadow = EShadow::NONE;
-
-			m_nShadowColor = oChild.GetAttributeColor(L"color");
-			m_chShadowOffsetX = (HWP_BYTE)oChild.GetAttributeInt(L"offsetX");
-			m_chShadowOffsetY = (HWP_BYTE)oChild.GetAttributeInt(L"offsetY");
-		}
-		else if (L"hh:italic" == oChild.GetName())
+		else if ("hh:italic" == sNodeName)
 			m_bItalic = true;
-		else if (L"hh:bold" == oChild.GetName())
+		else if ("hh:bold" == sNodeName)
 			m_bBold = true;
-		else if (L"hh:emboss" == oChild.GetName())
+		else if ("hh:emboss" == sNodeName)
 			m_bEmboss = true;
-		else if (L"hh:engrave" == oChild.GetName())
-			m_bEmboss = true;
-		else if (L"hh:supscript" == oChild.GetName())
+		else if ("hh:engrave" == sNodeName)
+			m_bEngrave = true;
+		else if ("hh:supscript" == sNodeName)
 			m_bSuperScript = true;
-		else if (L"hh:subscript" == oChild.GetName())
+		else if ("hh:subscript" == sNodeName)
 			m_bSubScript = true;
 	}
+	END_WHILE
 }
 
 bool CHWPRecordCharShape::Bold() const

HwpFile/HwpDoc/HWPElements/HWPRecordCharShape.h

@@ -5,7 +5,7 @@
 #include "../HWPStream.h"
 #include "HWPRecord.h"
 #include "HwpRecordTypes.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -100,10 +100,10 @@ class CHWPRecordCharShape : public CHWPRecord
 	short m_shBorderFillIDRef;
 	int m_nStrikeOutColor;
 
-	void ReadContainerData(CXMLNode& oNode, short arValues[], int nDefaultValue = 0);
+	void ReadContainerData(CXMLReader& oReader, short arValues[], int nDefaultValue = 0);
 public:
 	CHWPRecordCharShape(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CHWPRecordCharShape(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion);
+	CHWPRecordCharShape(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion);
 
 	bool Bold() const;
 	bool Italic() const;

HwpFile/HwpDoc/HWPElements/HWPRecordDocumentProperties.cpp

@@ -16,14 +16,24 @@ CHWPRecordDocumentProperties::CHWPRecordDocumentProperties(CHWPDocInfo& oDocInfo
 	oBuffer.ReadInt(m_nCharUnitLocInPara);
 }
 
-CHWPRecordDocumentProperties::CHWPRecordDocumentProperties(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion)
+CHWPRecordDocumentProperties::CHWPRecordDocumentProperties(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
 	: CHWPRecord(EHWPTag::HWPTAG_DOCUMENT_PROPERTIES, 0, 0), m_pParent(&oDocInfo)
 {
-	m_shFigureStartNo   = oNode.GetAttributeInt(L"page");
-	m_shFootNoteStartNo = oNode.GetAttributeInt(L"footnote");
-	m_shEndNoteStartNo  = oNode.GetAttributeInt(L"endnote");
-	m_shFigureStartNo   = oNode.GetAttributeInt(L"pic");
-	m_shTableStartNo    = oNode.GetAttributeInt(L"tbl");
-	m_shEqStartNo       = oNode.GetAttributeInt(L"equation");
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("page" == sAttributeName)
+			m_shPageStartNo = oReader.GetInt();
+		else if ("footnote" == sAttributeName)
+			m_shFootNoteStartNo = oReader.GetInt();
+		else if ("endnote" == sAttributeName)
+			m_shEndNoteStartNo = oReader.GetInt();
+		else if ("pic" == sAttributeName)
+			m_shFigureStartNo = oReader.GetInt();
+		else if ("tbl" == sAttributeName)
+			m_shTableStartNo = oReader.GetInt();
+		else if ("equation" == sAttributeName)
+			m_shEqStartNo = oReader.GetInt();
+	}
+	END_READ_ATTRIBUTES(oReader)
 }
 }

HwpFile/HwpDoc/HWPElements/HWPRecordDocumentProperties.h

@@ -4,7 +4,7 @@
 #include "../HWPDocInfo.h"
 #include "../HWPStream.h"
 #include "HWPRecord.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -24,7 +24,7 @@ class CHWPRecordDocumentProperties : public CHWPRecord
 	int m_nCharUnitLocInPara;
 public:
 	CHWPRecordDocumentProperties(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CHWPRecordDocumentProperties(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion);
+	CHWPRecordDocumentProperties(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion);
 };
 }
 

HwpFile/HwpDoc/HWPElements/HWPRecordFaceName.cpp

@@ -53,47 +53,71 @@ CHWPRecordFaceName::CHWPRecordFaceName(CHWPDocInfo& oDocInfo, int nTagNum, int n
 		oBuffer.ReadString(m_sBasicFaceName, EStringCharacter::UTF16);
 }
 
-CHWPRecordFaceName::CHWPRecordFaceName(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion)
+CHWPRecordFaceName::CHWPRecordFaceName(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
 	: CHWPRecord(EHWPTag::HWPTAG_FACE_NAME, 0, 0), m_pParent(&oDocInfo)
 {
-	m_sFaceName = oNode.GetAttribute(L"face");
+	m_sFaceName = oReader.GetAttribute("face");
 
-	for (CXMLNode& oChild: oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hh:substFont" == oChild.GetName())
+		if ("hh:substFont" == sNodeName)
 		{
 			m_bSubstExists = true;
-			m_sSubstFace = oChild.GetAttribute(L"face");
 
-			HWP_STRING sType = oChild.GetAttribute(L"type");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("face" == sAttributeName)
+					m_sSubstFace = oReader.GetText();
+				else if ("type" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
 
-			if (L"TTF" == sType)
-				m_eSubstType = EAltType::FFT;
-			else if (L"HFT" == sType)
-				m_eSubstType = EAltType::HFT;
-			else
-				m_eSubstType = EAltType::UNKNOWN;
+					if ("TTF" == sType)
+						m_eSubstType = EAltType::FFT;
+					else if ("HFT" == sType)
+						m_eSubstType = EAltType::HFT;
+					else
+						m_eSubstType = EAltType::UNKNOWN;
+				}
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hh:typeInfo" == oChild.GetName())
+		else if ("hh:typeInfo" == sNodeName)
 		{
 			m_bAttrExists = true;
 
-			m_sBasicFaceName = oChild.GetAttribute(L"familyType");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("familyType" == sAttributeName)
+				{
+					m_sBasicFaceName = oReader.GetText();
 
-			if (!m_sBasicFaceName.empty())
-				m_bBasicFaceExists = true;
-
-			m_chSerifStyle = (HWP_BYTE)oChild.GetAttributeInt(L"serifStyle");
-			m_shWeight = oChild.GetAttributeInt(L"weight");
-			m_shPropotion = oChild.GetAttributeInt(L"proportion");
-			m_shContrast = oChild.GetAttributeInt(L"contrast");
-			m_shStrokeVariation = oChild.GetAttributeInt(L"strokeVariation");
-			m_shArmStyle = oChild.GetAttributeInt(L"armStyle");
-			m_shLetterform = oChild.GetAttributeInt(L"letterform");
-			m_shMidLine = oChild.GetAttributeInt(L"midline");
-			m_shXHeight = oChild.GetAttributeInt(L"xHeight");
+					if (!m_sBasicFaceName.empty())
+						m_bBasicFaceExists = true;
+				}
+				else if ("serifStyle" == sAttributeName)
+					m_chSerifStyle = (HWP_BYTE)oReader.GetInt();
+				else if ("weight" == sAttributeName)
+					m_shWeight = oReader.GetInt();
+				else if ("proportion" == sAttributeName)
+					m_shPropotion = oReader.GetInt();
+				else if ("contrast" == sAttributeName)
+					m_shContrast = oReader.GetInt();
+				else if ("strokeVariation" == sAttributeName)
+					m_shStrokeVariation = oReader.GetInt();
+				else if ("armStyle" == sAttributeName)
+					m_shArmStyle = oReader.GetInt();
+				else if ("letterform" == sAttributeName)
+					m_shLetterform = oReader.GetInt();
+				else if ("midline" == sAttributeName)
+					m_shMidLine = oReader.GetInt();
+				else if ("xHeight" == sAttributeName)
+					m_shXHeight = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
 	}
+	END_WHILE
 }
 
 HWP_STRING CHWPRecordFaceName::GetFaceName() const

HwpFile/HwpDoc/HWPElements/HWPRecordFaceName.h

@@ -1,7 +1,7 @@
 #ifndef HWPRECORDFACENAME_H
 #define HWPRECORDFACENAME_H
 
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 #include "../HWPDocInfo.h"
 #include "../HWPStream.h"
 #include "HWPRecord.h"
@@ -41,7 +41,7 @@ class CHWPRecordFaceName : public CHWPRecord
 	short m_shXHeight;
 public:
 	CHWPRecordFaceName(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CHWPRecordFaceName(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion);
+	CHWPRecordFaceName(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion);
 
 	HWP_STRING GetFaceName() const;
 };

HwpFile/HwpDoc/HWPElements/HWPRecordNumbering.cpp

@@ -54,52 +54,68 @@ CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, int nTagNum, int
 	oBuffer.RemoveLastSavedPos();
 }
 
-CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion)
+CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
     : CHWPRecord(EHWPTag::HWPTAG_NUMBERING, 0, 0), m_pParent(&oDocInfo)
 {
-	m_shStart = oNode.GetAttributeInt(L"start", 1);
+	m_shStart = oReader.GetAttributeInt("start", 1);
 
 	unsigned int unIndex = 0;
-	HWP_STRING sType;
+	short shLevel = 0;
+	std::string sNumFormat;
 
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hh:paraHead" == oChild.GetName() ||
-		    L"paraHead" == oChild.GetName())
+		if ("hh:paraHead" == sNodeName ||
+		    "paraHead"    == sNodeName)
 		{
-			sType = oChild.GetAttribute(L"align");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("align" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
 
-			if (L"LEFT" == sType)
-				m_arNumbering[unIndex].m_chAlign = 0;
-			else if (L"CENTER" == sType)
-				m_arNumbering[unIndex].m_chAlign = 1;
-			else if (L"RIGHT" == sType)
-				m_arNumbering[unIndex].m_chAlign = 2;
+					if ("LEFT" == sType)
+						m_arNumbering[unIndex].m_chAlign = 0;
+					else if ("CENTER" == sType)
+						m_arNumbering[unIndex].m_chAlign = 1;
+					else if ("RIGHT" == sType)
+						m_arNumbering[unIndex].m_chAlign = 2;
+				}
+				else if ("useInstWidth" == sAttributeName)
+					m_arNumbering[unIndex].m_bUseInstWidth = oReader.GetBool();
+				else if ("autoIndent" == sAttributeName)
+					m_arNumbering[unIndex].m_bAutoIndent = oReader.GetBool();
+				else if ("widthAdjust" == sAttributeName)
+					m_arNumbering[unIndex].m_shWidthAdjust = oReader.GetInt();
+				else if ("textOffsetType" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
 
-			m_arNumbering[unIndex].m_bUseInstWidth = oChild.GetAttributeBool(L"useInstWidth");
-			m_arNumbering[unIndex].m_bAutoIndent = oChild.GetAttributeBool(L"autoIndent");
-			m_arNumbering[unIndex].m_shWidthAdjust = oChild.GetAttributeInt(L"widthAdjust");
+					if ("PERCENT" == sType)
+						m_arNumbering[unIndex].m_chTextOffsetType = 0;
+					else if ("HWPUNIT" == sType)
+						m_arNumbering[unIndex].m_chTextOffsetType = 1;
+				}
+				else if ("textOffset" == sAttributeName)
+					m_arNumbering[unIndex].m_shTextOffset = oReader.GetInt();
+				else if ("charPrIDRef" == sAttributeName)
+					m_arNumbering[unIndex].m_nCharShape = std::abs(oReader.GetInt());
+				else if ("start" == sAttributeName)
+					m_arNumbering[unIndex].m_nStartNumber = oReader.GetInt();
+				else if ("numFormat" == sAttributeName)
+					sNumFormat = oReader.GetTextA();
+				else if ("level" == sAttributeName)
+					shLevel = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 
-			sType =  oChild.GetAttribute(L"textOffsetType");
-
-			if (L"PERCENT" == sType)
-				m_arNumbering[unIndex].m_chTextOffsetType = 0;
-			else if (L"HWPUNIT" == sType)
-				m_arNumbering[unIndex].m_chTextOffsetType = 1;
-
-			m_arNumbering[unIndex].m_shTextOffset = oChild.GetAttributeInt(L"textOffset");
-
-			short shLevel = oChild.GetAttributeInt(L"level");
-
-			sType = oChild.GetAttribute(L"numFormat");
-
-			if (L"DIGIT" == sType)
+			if ("DIGIT" == sNumFormat)
 			{
 				if (shLevel > 0 && shLevel < 11)
 					m_arNumbering[unIndex].m_sNumFormat = L'^' + std::to_wstring(shLevel) + L'.';
 			}
-			else if (L"HANGUL_SYLLABLE" == sType ||
-			         L"HANGUL_JAMO" == sType)
+			else if ("HANGUL_SYLLABLE" == sNumFormat ||
+					 "HANGUL_JAMO"     == sNumFormat)
 			{
 				switch (shLevel)
 				{
@@ -115,7 +131,7 @@ CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLNode& oNode,
 					case 10: m_arNumbering[unIndex].m_sNumFormat = L"^차."; break;
 				}
 			}
-			else if (L"CIRCLED_DIGIT" == sType)
+			else if ("CIRCLED_DIGIT" == sNumFormat)
 			{
 				switch (shLevel)
 				{
@@ -131,7 +147,7 @@ CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLNode& oNode,
 					case 10: m_arNumbering[unIndex].m_sNumFormat = L"^\u2469."; break;
 				}
 			}
-			else if (L"LATIN_SMALL" == sType)
+			else if ("LATIN_SMALL" == sNumFormat)
 			{
 				switch (shLevel)
 				{
@@ -147,7 +163,7 @@ CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLNode& oNode,
 					case 10: m_arNumbering[unIndex].m_sNumFormat = L"^j."; break;
 				}
 			}
-			else if (L"CIRCLED_HANGUL_SYLLABLE" == sType)
+			else if ("CIRCLED_HANGUL_SYLLABLE" == sNumFormat)
 			{
 				switch (shLevel)
 				{
@@ -163,7 +179,7 @@ CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLNode& oNode,
 					case 10: m_arNumbering[unIndex].m_sNumFormat = L"^\u3277."; break;
 				}
 			}
-			else if (L"ROMAN_SMALL" == sType)
+			else if ("ROMAN_SMALL" == sNumFormat)
 			{
 				switch (shLevel)
 				{
@@ -180,14 +196,13 @@ CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLNode& oNode,
 				}
 			}
 
-			m_arNumbering[unIndex].m_nCharShape = std::abs(oChild.GetAttributeInt(L"charPrIDRef"));
-			m_arNumbering[unIndex].m_nStartNumber = oChild.GetAttributeInt(L"start");
 			++unIndex;
 		}
 
 		if (7 == unIndex)
 			return;
 	}
+	END_WHILE
 }
 
 short CHWPRecordNumbering::GetStart() const

HwpFile/HwpDoc/HWPElements/HWPRecordNumbering.h

@@ -4,7 +4,7 @@
 #include "../HWPDocInfo.h"
 #include "../HWPStream.h"
 #include "HWPRecord.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -36,7 +36,7 @@ class CHWPRecordNumbering : public CHWPRecord
 	int m_arExtLevelStart[3];
 public:
 	CHWPRecordNumbering(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion);
+	CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion);
 
 	short GetStart() const;
 	HWP_STRING GetNumFormat(unsigned short ushIndex) const;

HwpFile/HwpDoc/HWPElements/HWPRecordParaShape.cpp

@@ -131,116 +131,166 @@ CHWPRecordParaShape::CHWPRecordParaShape(CHWPDocInfo& oDocInfo, int nTagNum, int
 		oBuffer.Skip(8);
 }
 
-CHWPRecordParaShape::CHWPRecordParaShape(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion)
+CHWPRecordParaShape::CHWPRecordParaShape(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
 	: CHWPRecord(EHWPTag::HWPTAG_PARA_SHAPE, 0, 0), m_pParent(&oDocInfo),
       m_eAlign(EHorizontalAlign::JUSTIFY), m_bWidowOrphan(false), m_bKeepWithNext(false),
       m_bPageBreakBefore(false), m_eVertAlign(EVerticalAlign::BASELINE), m_eHeadingType(EHeadingType::NONE),
       m_bConnect(false), m_bIgnoreMargin(false), m_bParaTailShape(false)
 {
-	m_shTabDef = oNode.GetAttributeInt(L"tabPrIDRef");
-	m_chCondense = (HWP_BYTE)oNode.GetAttributeInt(L"condense");
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("tabPrIDRef" == sAttributeName)
+			m_shTabDef = oReader.GetInt();
+		else if ("condense" == sAttributeName)
+			m_chCondense = (HWP_BYTE)oReader.GetInt();
+		else if ("fontLineHeight" == sAttributeName)
+			m_bFontLineHeight = oReader.GetBool();
+		else if ("snapToGrid" == sAttributeName)
+			m_bSnapToGrid = oReader.GetBool();
+	}
+	END_READ_ATTRIBUTES(oReader)
 
-	m_bFontLineHeight = oNode.GetAttributeBool(L"fontLineHeight");
-	m_bSnapToGrid = oNode.GetAttributeBool(L"snapToGrid");
-
-	for (CXMLNode& oChild : oNode.GetChilds())
-		RecursiveParaShape(oChild);
+	RecursiveParaShape(oReader);
 }
 
-void CHWPRecordParaShape::RecursiveParaShape(CXMLNode& oNode)
+void CHWPRecordParaShape::RecursiveParaShape(CXMLReader& oReader)
 {
-	if (L"hh:align" == oNode.GetName())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		m_eAlign = ::HWP::GetHorizontalAlign(oNode.GetAttribute(L"horizontal"));
-		m_eVertAlign = ::HWP::GetVerticalAlign(oNode.GetAttribute(L"vertical"));
-	}
-	else if (L"hh:heading" == oNode.GetName())
-	{
-		m_eHeadingType = ::HWP::GetHeadingType(oNode.GetAttribute(L"type"));
-		m_shHeadingIdRef = oNode.GetAttributeInt(L"idRef");
-		m_chHeadingLevel = (HWP_BYTE)oNode.GetAttributeInt(L"level");
-	}
-	else if (L"hh:breakSetting" == oNode.GetName())
-	{
-		HWP_STRING sType = oNode.GetAttribute(L"breakLatinWord");
-
-		if (L"KEEP_WORD" == sType)
-			m_chBreakLatinWord = 0;
-		else if (L"BREAK_WORD" == sType)
-			m_chBreakLatinWord = 1;
-
-		sType = oNode.GetAttribute(L"breakNonLatinWord");
-
-		if (L"KEEP_WORD" == sType)
-			m_chBreakNonLatinWord = 0;
-		else if (L"BREAK_WORD" == sType)
-			m_chBreakNonLatinWord = 1;
-
-		m_bWidowOrphan = oNode.GetAttributeBool(L"widowOrphan");
-		m_bKeepWithNext = oNode.GetAttributeBool(L"keepWithNext");
-		m_bPageBreakBefore = oNode.GetAttributeBool(L"pageBreakBefore");
-
-		sType = oNode.GetAttribute(L"lineWrap");
-
-		if (L"BREAK" == sType)
-			m_chLineWrap = 0;
-		else if (L"SQUEEZE" == sType)
-			m_chLineWrap = 1;
-	}
-	else if (L"hh:lineSpacing" == oNode.GetName())
-	{
-		HWP_STRING sType = oNode.GetAttribute(L"type");
-
-		if (L"PERCENT" == sType)
-			m_nLineSpacingType = 0;
-		else if (L"FIXED" == sType)
-			m_nLineSpacingType = 1;
-		else if (L"BETWEENLINES" == sType)
-			m_nLineSpacingType = 2;
-		else if (L"AT_LEAST" == sType)
-			m_nLineSpacingType = 4;
-
-		m_nLineSpacing = oNode.GetAttributeInt(L"value");
-	}
-	else if (L"hh:border" == oNode.GetName())
-	{
-		m_shBorderFill = oNode.GetAttributeInt(L"borderFillIDRef");
-		m_shOffsetLeft = oNode.GetAttributeInt(L"offsetLeft");
-		m_shOffsetRight = oNode.GetAttributeInt(L"offsetRight");
-		m_shOffsetTop = oNode.GetAttributeInt(L"offsetTop");
-		m_shOffsetBottom = oNode.GetAttributeInt(L"offsetBottom");
-
-		m_bConnect = oNode.GetAttributeBool(L"connect");
-		m_bIgnoreMargin = oNode.GetAttributeBool(L"ignoreMargin");
-	}
-	else if (L"hh:autoSpacing" == oNode.GetName())
-	{
-		m_bAutoSpaceEAsianEng = oNode.GetAttributeBool(L"eAsianEng");
-		m_bAutoSpaceEAsianNum = oNode.GetAttributeBool(L"eAsianNum");
-	}
-	else if (L"hc:intent" == oNode.GetName())
-		m_nIndent = oNode.GetAttributeInt(L"value");
-	else if (L"hc:left" == oNode.GetName())
-		m_nMarginLeft = oNode.GetAttributeInt(L"value");
-	else if (L"hc:right" == oNode.GetName())
-		m_nMarginRight = oNode.GetAttributeInt(L"value");
-	else if (L"hc:prev" == oNode.GetName())
-		m_nMarginPrev = oNode.GetAttributeInt(L"value");
-	else if (L"hc:next" == oNode.GetName())
-		m_nMarginNext = oNode.GetAttributeInt(L"value");
-	else if (/*L"hp:switch" == oNode.GetName() ||
-	         L"hp:case" == oNode.GetName() ||
-	         L"hp:default" == oNode.GetName() ||*/
-	         L"hh:margin" == oNode.GetName())
-	{
-		for (CXMLNode& oChild : oNode.GetChilds())
-			RecursiveParaShape(oChild);
-	}
-	else if (L"hp:switch" == oNode.GetName())
-	{
-		for (CXMLNode& oChild : oNode.GetChild(L"hp:default").GetChilds())
-			RecursiveParaShape(oChild);
+		if ("hh:align" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("horizontal" == sAttributeName)
+					m_eAlign = ::HWP::GetHorizontalAlign(oReader.GetText());
+				else if ("vertical" == sAttributeName)
+					m_eVertAlign = ::HWP::GetVerticalAlign(oReader.GetText());
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hh:heading" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("type" == sAttributeName)
+					m_eHeadingType = ::HWP::GetHeadingType(oReader.GetText());
+				else if ("idRef" == sAttributeName)
+					m_shHeadingIdRef = oReader.GetInt();
+				else if ("level" == sAttributeName)
+					m_chHeadingLevel = (HWP_BYTE)oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hh:breakSetting" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("breakLatinWord" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
+
+					if ("KEEP_WORD" == sType)
+						m_chBreakLatinWord = 0;
+					else if ("BREAK_WORD" == sType)
+						m_chBreakLatinWord = 1;
+				}
+				else if ("breakNonLatinWord" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
+
+					if ("KEEP_WORD" == sType)
+						m_chBreakNonLatinWord = 0;
+					else if ("BREAK_WORD" == sType)
+						m_chBreakNonLatinWord = 1;
+				}
+				else if ("widowOrphan" == sAttributeName)
+					m_bWidowOrphan = oReader.GetBool();
+				else if ("keepWithNext" == sAttributeName)
+					m_bKeepWithNext = oReader.GetBool();
+				else if ("pageBreakBefore" == sAttributeName)
+					m_bPageBreakBefore = oReader.GetBool();
+				else if ("lineWrap" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
+
+					if ("BREAK" == sType)
+						m_chLineWrap = 0;
+					else if ("SQUEEZE" == sType)
+						m_chLineWrap = 1;
+				}
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hh:lineSpacing" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("type" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
+
+					if ("PERCENT" == sType)
+						m_nLineSpacingType = 0;
+					else if ("FIXED" == sType)
+						m_nLineSpacingType = 1;
+					else if ("BETWEENLINES" == sType)
+						m_nLineSpacingType = 2;
+					else if ("AT_LEAST" == sType)
+						m_nLineSpacingType = 4;
+				}
+				else if ("value" == sAttributeName)
+					m_nLineSpacing = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hh:border" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("borderFillIDRef" == sAttributeName)
+					m_shBorderFill = oReader.GetInt();
+				else if ("offsetLeft" == sAttributeName)
+					m_shOffsetLeft = oReader.GetInt();
+				else if ("offsetRight" == sAttributeName)
+					m_shOffsetRight = oReader.GetInt();
+				else if ("offsetTop" == sAttributeName)
+					m_shOffsetTop = oReader.GetInt();
+				else if ("offsetBottom" == sAttributeName)
+					m_shOffsetBottom = oReader.GetInt();
+				else if ("connect" == sAttributeName)
+					m_bConnect = oReader.GetBool();
+				else if ("ignoreMargin" == sAttributeName)
+					m_bIgnoreMargin = oReader.GetBool();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hh:autoSpacing" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("eAsianEng" == sAttributeName)
+					m_bAutoSpaceEAsianEng = oReader.GetBool();
+				else if ("eAsianNum" == sAttributeName)
+					m_bAutoSpaceEAsianNum = oReader.GetBool();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hc:intent" == sNodeName)
+			m_nIndent = oReader.GetAttributeInt("value");
+		else if ("hc:left" == sNodeName)
+			m_nMarginLeft = oReader.GetAttributeInt("value");
+		else if ("hc:right" == sNodeName)
+			m_nMarginRight = oReader.GetAttributeInt("value");
+		else if ("hc:prev" == sNodeName)
+			m_nMarginPrev = oReader.GetAttributeInt("value");
+		else if ("hc:next" == sNodeName)
+			m_nMarginNext = oReader.GetAttributeInt("value");
+		else if ("hh:margin"  == sNodeName ||
+		         "hp:switch"  == sNodeName ||
+		         "hp:default" == sNodeName)
+			RecursiveParaShape(oReader);
 	}
+	END_WHILE
 }
 
 EHorizontalAlign CHWPRecordParaShape::GetHorizantalAlign() const
@@ -308,6 +358,11 @@ int CHWPRecordParaShape::GetRightIndent() const
 	return m_nMarginRight;
 }
 
+short CHWPRecordParaShape::GetTabDef() const
+{
+	return m_shTabDef;
+}
+
 bool CHWPRecordParaShape::KeepWithNext() const
 {
 	return m_bKeepWithNext;

HwpFile/HwpDoc/HWPElements/HWPRecordParaShape.h

@@ -3,7 +3,7 @@
 
 #include "HWPRecord.h"
 #include "../HWPDocInfo.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -74,10 +74,10 @@ class CHWPRecordParaShape : public CHWPRecord
 	bool m_bAutoSpaceEAsianNum;
 
 	int m_nLineSpacingType;
-	void RecursiveParaShape(CXMLNode& oNode);
+	void RecursiveParaShape(CXMLReader& oReader);
 public:
 	CHWPRecordParaShape(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CHWPRecordParaShape(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion);
+	CHWPRecordParaShape(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion);
 
 	EHorizontalAlign GetHorizantalAlign() const;
 	EVerticalAlign GetVerticalAlign() const;
@@ -94,6 +94,8 @@ public:
 	int GetLeftIndent() const;
 	int GetRightIndent() const;
 
+	short GetTabDef() const;
+
 	bool KeepWithNext() const;
 };
 }

HwpFile/HwpDoc/HWPElements/HWPRecordParaText.cpp

@@ -148,11 +148,21 @@ LIST<CCtrl*> CHWPRecordParaText::Parse(int nTagNum, int nLevel, int nSize, CHWPS
 					unIndex += unInfoLength + 2;
 					break;
 				}
+				case 0x09: // Tabs
+				{
+					UPDATE_CURRENT_TEXT();
+
+					if (sText.length() < unIndex + 6 || (sText[unIndex] != sText[unIndex + 6] && sText[unIndex] != sText[unIndex + 7]))
+						continue;
+
+					arParas.push_back(new CCtrlCharacter(L"   _", ECtrlCharType::TABULATION));
+					unIndex += 6;
+					break;
+				}
 				case 0x05: // Scheduling
 				case 0x06: // Scheduling
 				case 0x07: // Scheduling
 				case 0x08: // Title mark
-				case 0x09: // Tabs
 				case 0x13: // Scheduling
 				case 0x14: // Scheduling
 				{

HwpFile/HwpDoc/HWPElements/HWPRecordStyle.cpp

@@ -20,23 +20,36 @@ CHWPRecordStyle::CHWPRecordStyle(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel,
 	m_nCharShape = oBuffer.ReadShort();
 }
 
-CHWPRecordStyle::CHWPRecordStyle(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion)
+CHWPRecordStyle::CHWPRecordStyle(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
 	: CHWPRecord(EHWPTag::HWPTAG_STYLE, 0, 0), m_pParent(&oDocInfo)
 {
-	HWP_STRING sType = oNode.GetAttribute(L"type");
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("type" == sAttributeName)
+		{
+			const std::string sType{oReader.GetTextA()};
 
-	if (L"PARA" == sType)
-		m_chType = 0;
-	else if (L"CHAR" == sType)
-		m_chType = 1;
-
-	m_sName = oNode.GetAttribute(L"name");
-	m_sEngName = oNode.GetAttribute(L"engName");
-	m_nParaShape = oNode.GetAttributeInt(L"paraPrIDRef");
-	m_nCharShape = oNode.GetAttributeInt(L"charPrIDRef");
-	m_chNextStyle = oNode.GetAttributeInt(L"nextStyleIDRef");
-	m_shLangID = oNode.GetAttributeInt(L"langID");
-	m_bLockForm = oNode.GetAttributeBool(L"lockForm");
+			if ("PARA" == sType)
+				m_chType = 0;
+			else if ("CHAR" == sType)
+				m_chType = 1;
+		}
+		else if ("name" == sAttributeName)
+			m_sName = oReader.GetText();
+		else if ("engName" == sAttributeName)
+			m_sEngName = oReader.GetText();
+		else if ("paraPrIDRef" == sAttributeName)
+			m_nParaShape = oReader.GetInt();
+		else if ("charPrIDRef" == sAttributeName)
+			m_nCharShape = oReader.GetInt();
+		else if ("nextStyleIDRef" == sAttributeName)
+			m_chNextStyle = oReader.GetInt();
+		else if ("langID" == sAttributeName)
+			m_shLangID = oReader.GetInt();
+		else if ("lockForm" == sAttributeName)
+			m_bLockForm = oReader.GetBool();
+	}
+	END_READ_ATTRIBUTES(oReader)
 }
 
 HWP_STRING CHWPRecordStyle::GetName() const

HwpFile/HwpDoc/HWPElements/HWPRecordStyle.h

@@ -3,7 +3,7 @@
 
 #include "HWPRecord.h"
 #include "../HWPDocInfo.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -22,7 +22,7 @@ class CHWPRecordStyle : public CHWPRecord
 public:
 	CHWPRecordStyle(int nTagNum, int nLevel, int nSize);
 	CHWPRecordStyle(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CHWPRecordStyle(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion);
+	CHWPRecordStyle(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion);
 
 	HWP_STRING GetName() const;
 	HWP_STRING GetEngName() const;

HwpFile/HwpDoc/HWPElements/HwpRecordTabDef.cpp

@@ -5,11 +5,18 @@ namespace HWP
 TTab::TTab()
 {}
 
-TTab::TTab(CXMLNode& oNode)
+TTab::TTab(CXMLReader& oReader)
 {
-	m_nPos = oNode.GetAttributeInt(L"pos");
-	SetType(oNode.GetAttributeInt(L"type"));
-	m_eLeader = GetLineStyle2(oNode.GetAttribute(L"leader"));
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("pos" == sAttributeName)
+			m_nPos = oReader.GetInt();
+		else if ("type" == sAttributeName)
+			SetType(oReader.GetInt());
+		else if ("leader" == sAttributeName)
+			m_eLeader = GetLineStyle2(oReader.GetText());
+	}
+	END_READ_ATTRIBUTES(oReader)
 }
 
 void TTab::SetType(int nValue)
@@ -24,7 +31,7 @@ void TTab::SetType(int nValue)
 }
 
 CHwpRecordTabDef::CHwpRecordTabDef(int nTagNum, int nLevel, int nSize)
-	: CHWPRecord(nTagNum, nLevel, nSize), m_pParent(nullptr)
+	: CHWPRecord(nTagNum, nLevel, nSize), m_pParent(nullptr), m_nAttr(0)
 {}
 
 CHwpRecordTabDef::CHwpRecordTabDef(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion)
@@ -33,13 +40,15 @@ CHwpRecordTabDef::CHwpRecordTabDef(CHWPDocInfo& oDocInfo, int nTagNum, int nLeve
 	oBuffer.SavePosition();
 
 	oBuffer.ReadInt(m_nAttr);
-	oBuffer.ReadInt(m_nCount);
 
-	if (nSize - oBuffer.GetDistanceToLastPos() != m_nCount * 8)
+	int nCount = 0;
+	oBuffer.ReadInt(nCount);
+
+	if (nSize - oBuffer.GetDistanceToLastPos() != nCount * 8)
 		return; // TODO:: ошибка
 
 	TTab *pTab = nullptr;
-	for (unsigned int unIndex = 0; unIndex < m_nCount; ++unIndex)
+	for (unsigned int unIndex = 0; unIndex < nCount; ++unIndex)
 	{
 		pTab = new TTab();
 
@@ -60,24 +69,48 @@ CHwpRecordTabDef::CHwpRecordTabDef(CHWPDocInfo& oDocInfo, int nTagNum, int nLeve
 	oBuffer.RemoveLastSavedPos();
 }
 
-CHwpRecordTabDef::CHwpRecordTabDef(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion)
-	: CHWPRecord(EHWPTag::HWPTAG_TAB_DEF, 0, 0), m_pParent(&oDocInfo)
+CHwpRecordTabDef::CHwpRecordTabDef(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
+	: CHWPRecord(EHWPTag::HWPTAG_TAB_DEF, 0, 0), m_pParent(&oDocInfo), m_nAttr(0)
 {
-	if (oNode.GetAttributeBool(L"autoTabLeft"))
-		m_nAttr |= 0x00000001;
-	else
-		m_nAttr &= 0xFFFFFFFE;
-
-	if (oNode.GetAttributeBool(L"autoTabRight"))
-		m_nAttr |= 0x00000002;
-	else
-		m_nAttr &= 0xFFFFFFFD;
-
-	for (CXMLNode& oChild : oNode.GetChilds(L"hp:switch"))
-		for (CXMLNode& oGrandChild : oChild.GetChilds(L"hp:default"))
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("autoTabLeft" == sAttributeName)
 		{
-			CXMLNode oTabItem{oGrandChild.GetChild(L"hh:tabItem")};
-			m_arTabs.push_back(new TTab(oTabItem));
+			if (oReader.GetBool())
+				m_nAttr |= 0x00000001;
+			else
+				m_nAttr &= 0xFFFFFFFE;
 		}
+		else if ("autoTabRight" == sAttributeName)
+		{
+			if (oReader.GetBool())
+				m_nAttr |= 0x00000002;
+			else
+				m_nAttr &= 0xFFFFFFFD;
+		}
+	}
+	END_READ_ATTRIBUTES(oReader)
+
+	WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hp:switch")
+		WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Child, "hp:default")
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, TabChild, "hh:tabItem")
+				m_arTabs.push_back(new TTab(oReader));
+			END_WHILE
+		END_WHILE
+	END_WHILE
+
+}
+
+int CHwpRecordTabDef::GetCount() const
+{
+	return m_arTabs.size();
+}
+
+const TTab* CHwpRecordTabDef::GetTab(unsigned int unIndex) const
+{
+	if (unIndex >= m_arTabs.size())
+		return nullptr;
+
+	return dynamic_cast<const TTab*>(m_arTabs.at(unIndex));
 }
 }

HwpFile/HwpDoc/HWPElements/HwpRecordTabDef.h

@@ -4,7 +4,7 @@
 #include "HWPRecord.h"
 #include "../HWPDocInfo.h"
 #include "HwpRecordTypes.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -22,7 +22,7 @@ struct TTab
 
 
 	TTab();
-	TTab(CXMLNode& oNode);
+	TTab(CXMLReader& oReader);
 
 	void SetType(int nValue);
 };
@@ -32,12 +32,14 @@ class CHwpRecordTabDef : public CHWPRecord
 	CHWPDocInfo *m_pParent;
 
 	int m_nAttr;
-	int m_nCount;
-	LIST<TTab*> m_arTabs;
+	VECTOR<TTab*> m_arTabs;
 public:
 	CHwpRecordTabDef(int nTagNum, int nLevel, int nSize);
 	CHwpRecordTabDef(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CHwpRecordTabDef(CHWPDocInfo& oDocInfo, CXMLNode& oNode, int nVersion);
+	CHwpRecordTabDef(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion);
+
+	int GetCount() const;
+	const TTab* GetTab(unsigned int unIndex) const;
 };
 }
 

HwpFile/HwpDoc/HWPSection.cpp

@@ -111,14 +111,11 @@ CHWPSection::~CHWPSection()
 	CLEAR_ARRAY(CHWPPargraph, m_arParas);
 }
 
-bool CHWPSection::Parse(CXMLNode& oNode, int nVersion)
+bool CHWPSection::Parse(CXMLReader& oReader, int nVersion)
 {
-	std::vector<CXMLNode> arParagraphNodes{oNode.GetChilds(L"hp:p")};
-
-	m_arParas.resize(arParagraphNodes.size());
-
-	for (unsigned int unIndex = 0; unIndex < arParagraphNodes.size(); ++unIndex)
-		m_arParas[unIndex] = new CHWPPargraph(arParagraphNodes[unIndex], nVersion);
+	WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hp:p")
+		m_arParas.push_back(new CHWPPargraph(oReader, nVersion));
+	END_WHILE
 
 	return true;
 }

HwpFile/HwpDoc/HWPSection.h

@@ -16,7 +16,7 @@ public:
 	CHWPSection();
 	~CHWPSection();
 
-	bool Parse(CXMLNode& oNode, int nVersion);
+	bool Parse(CXMLReader& oReader, int nVersion);
 	bool Parse(CHWPStream& oBuffer, int nVersion);
 	int ParseRecurse(CHWPPargraph* oCurrPara, int nRunLevel, CHWPStream& oBuffer, int nOff, int nVersion);
 	int ParseCtrlRecurse(CCtrl* oCurrCtrl, int nRunLevel, CHWPStream& oBuffer, int nOff, int nVersion);

HwpFile/HwpDoc/HWPXFile.cpp

@@ -115,8 +115,12 @@ VECTOR<HWP_STRING> CHWPXFile::GetPathsToSections() const
 
 bool CHWPXFile::GetFileHeader()
 {
-	CXMLNode oVersionXml{GetDocument(L"version.xml")};
-	return m_oFileHeader.Parse(oVersionXml);
+	CXMLReader oReader;
+
+	if (!GetDocument(L"version.xml", oReader))
+		return false;
+
+	return m_oFileHeader.Parse(oReader);
 }
 
 const CHWPDocInfo* CHWPXFile::GetDocInfo() const
@@ -146,11 +150,19 @@ bool CHWPXFile::GetChildStream(const HWP_STRING& sFileName, CHWPStream& oBuffer)
 
 bool CHWPXFile::GetDocInfo(int nVersion)
 {
-	CXMLNode oContent{GetDocument(L"Contents/content.hpf")};
-	if (m_oDocInfo.ReadContentHpf(oContent, nVersion))
+	CXMLReader oContentReader;
+
+	if (!GetDocument(L"Contents/content.hpf", oContentReader))
+		return false;
+
+	if (m_oDocInfo.ReadContentHpf(oContentReader, nVersion))
 	{
-		CXMLNode oHeader{GetDocument(L"Contents/header.xml")};
-		return m_oDocInfo.Parse(oHeader, nVersion);
+		CXMLReader oHeaderReader;
+
+		if (!GetDocument(L"Contents/header.xml", oHeaderReader))
+			return false;
+
+		return m_oDocInfo.Parse(oHeaderReader, nVersion);
 	}
 
 	return false;
@@ -158,10 +170,13 @@ bool CHWPXFile::GetDocInfo(int nVersion)
 
 bool CHWPXFile::ReadSection(const HWP_STRING& sName, int nVersion)
 {
-	CXMLNode oRootNode{GetDocument(sName)};
+	CXMLReader oReader;
+
+	if (!GetDocument(sName, oReader))
+		return false;
 
 	CHWPSection* pSection = new CHWPSection();
-	const bool bResult = pSection->Parse(oRootNode, nVersion);
+	const bool bResult = pSection->Parse(oReader, nVersion);
 
 	if (bResult)
 		m_arSections.push_back(pSection);
@@ -171,11 +186,14 @@ bool CHWPXFile::ReadSection(const HWP_STRING& sName, int nVersion)
 	return bResult;
 }
 
-CXMLNode CHWPXFile::GetDocument(const HWP_STRING& sEntryName)
+bool CHWPXFile::GetDocument(const HWP_STRING& sEntryName, CXMLReader& oReader)
 {
-	if (nullptr == m_pZipFolder)
-		return CXMLNode();
+	if (nullptr == m_pZipFolder || nullptr == oReader.GetReader())
+		return false;
 
-	return CXMLNode(m_pZipFolder->getNodeFromFile(sEntryName));
+	if (m_pZipFolder->getReaderFromFile(sEntryName, *oReader.GetReader()))
+		return oReader.ReadNextNode();
+
+	return false;
 }
 }

HwpFile/HwpDoc/HWPXFile.h

@@ -32,7 +32,7 @@ private:
 	bool GetFileHeader();
 	bool GetDocInfo(int nVersion);
 	bool ReadSection(const HWP_STRING& sName, int nVersion);
-	CXMLNode GetDocument(const HWP_STRING& sEntryName);
+	bool GetDocument(const HWP_STRING& sEntryName, CXMLReader& oReader);
 };
 }
 

HwpFile/HwpDoc/HwpFileHeader.cpp

@@ -60,15 +60,27 @@ bool CHwpFileHeader::Parse(CHWPStream& oBuffer)
 	return true;
 }
 
-bool CHwpFileHeader::Parse(CXMLNode& oNode)
+bool CHwpFileHeader::Parse(CXMLReader& oReader)
 {
-	if (!oNode.IsValid())
-		return false;
+	HWP_STRING wsMajor, wsMinor, wsMicro, wsBuildNumber;
 
-	m_sVersion += oNode.GetAttribute(L"major");
-	m_sVersion += oNode.GetAttribute(L"minor");
-	m_sVersion += oNode.GetAttribute(L"micro");
-	m_sVersion += oNode.GetAttribute(L"buildNumber");
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("major" == sAttributeName)
+			wsMajor = oReader.GetText();
+		else if ("minor" == sAttributeName)
+			wsMinor = oReader.GetText();
+		else if ("micro" == sAttributeName)
+			wsMicro = oReader.GetText();
+		else if ("buildNumber" == sAttributeName)
+			wsBuildNumber = oReader.GetText();
+	}
+	END_READ_ATTRIBUTES(oReader)
+
+	m_sVersion = ((!wsMajor.empty()) ? wsMajor : L"0") +
+	             ((!wsMinor.empty()) ? wsMinor : L"0") +
+	             ((!wsMicro.empty()) ? wsMicro : L"0") +
+	             ((!wsBuildNumber.empty()) ? wsBuildNumber : L"0");
 
 	return true;
 }

HwpFile/HwpDoc/HwpFileHeader.h

@@ -2,7 +2,7 @@
 #define HWPFILEHEADER_H
 
 #include "HWPStream.h"
-#include "Common/XMLNode.h"
+#include "Common/XMLReader.h"
 
 namespace HWP
 {
@@ -47,7 +47,7 @@ public:
 	HWP_STRING GetVersion() const;
 
 	bool Parse(CHWPStream& oBuffer);
-	bool Parse(CXMLNode& oNode);
+	bool Parse(CXMLReader& oReader);
 };
 }
 

HwpFile/HwpDoc/Paragraph/CapParagraph.cpp

@@ -6,8 +6,8 @@ CCapParagraph::CCapParagraph()
 	: CHWPPargraph()
 {}
 
-CCapParagraph::CCapParagraph(CXMLNode& oNode, int nVersion)
-	: CHWPPargraph(oNode, nVersion)
+CCapParagraph::CCapParagraph(CXMLReader& oReader, int nVersion)
+    : CHWPPargraph(oReader, nVersion)
 {}
 
 EParagraphType CCapParagraph::GetType() const

HwpFile/HwpDoc/Paragraph/CapParagraph.h

@@ -9,7 +9,7 @@ class CCapParagraph : public CHWPPargraph
 {
 public:
 	CCapParagraph();
-	CCapParagraph(CXMLNode& oNode, int nVersion);
+	CCapParagraph(CXMLReader& oReader, int nVersion);
 
 	EParagraphType GetType() const override;
 };

HwpFile/HwpDoc/Paragraph/CellParagraph.cpp

@@ -7,8 +7,8 @@ CCellParagraph::CCellParagraph()
 {
 }
 
-CCellParagraph::CCellParagraph(CXMLNode& oNode, int nVersion)
-	: CHWPPargraph(oNode, nVersion)
+CCellParagraph::CCellParagraph(CXMLReader& oReader, int nVersion)
+    : CHWPPargraph(oReader, nVersion)
 {}
 
 EParagraphType CCellParagraph::GetType() const

HwpFile/HwpDoc/Paragraph/CellParagraph.h

@@ -9,7 +9,7 @@ class CCellParagraph : public CHWPPargraph
 {
 public:
 	CCellParagraph();
-	CCellParagraph(CXMLNode& oNode, int nVersion);
+	CCellParagraph(CXMLReader& oReader, int nVersion);
 
 	EParagraphType GetType() const override;
 };

HwpFile/HwpDoc/Paragraph/CommonObj.h

@@ -2,9 +2,6 @@
 #define COMMONOBJ_H
 
 #include "HWPPargraph.h"
-#include <string>
-#include <vector>
-#include <list>
 
 namespace HWP
 {

HwpFile/HwpDoc/Paragraph/Ctrl.cpp

@@ -50,27 +50,29 @@ bool CCtrl::Equals(CCtrl* pFirstCtrl, CCtrl* pSecondCtrl)
 	       pFirstCtrl->m_bFullFilled == pSecondCtrl->m_bFullFilled;
 }
 
-CCtrl* CCtrl::GetCtrl(CXMLNode& oNode, int nVersion)
+CCtrl* CCtrl::GetCtrl(CXMLReader& oReader, int nVersion)
 {
-	if (L"hp:colPr" == oNode.GetName())
-		return new CCtrlColumnDef(L"dloc", oNode, nVersion);
-	else if (L"hp:header" == oNode.GetName())
-		return new CCtrlHeadFoot(L"daeh", oNode, nVersion);
-	else if (L"hp:footer" == oNode.GetName())
-		return new CCtrlHeadFoot(L"toof", oNode, nVersion);
-	else if (L"hp:footNote" == oNode.GetName())
-		return new CCtrlNote(L"  nf", oNode, nVersion);
-	else if (L"hp:endNote" == oNode.GetName())
-		return new CCtrlNote(L"  ne", oNode, nVersion);
-	else if (L"hp:autoNum" == oNode.GetName())
-		return new CCtrlAutoNumber(L"onta", oNode, nVersion);
-	else if (L"hp:newNum" == oNode.GetName())
-		return new CCtrlNewNumber(L"onwn", oNode, nVersion);
-	else if (L"hp:pageNum" == oNode.GetName())
-		return new CCtrlPageNumPos(L"pngp", oNode, nVersion);
-	else if (L"hp:fieldBegin" == oNode.GetName() ||
-	         L"hp:fieldEnd" == oNode.GetName())
-		return new CCtrlField(L"", oNode, nVersion);
+	const std::string sNodeName{oReader.GetName()};
+
+	if ("hp:colPr" == sNodeName)
+		return new CCtrlColumnDef(L"dloc", oReader, nVersion);
+	else if ("hp:header" == sNodeName)
+		return new CCtrlHeadFoot(L"daeh", oReader, nVersion);
+	else if ("hp:footer" == sNodeName)
+		return new CCtrlHeadFoot(L"toof", oReader, nVersion);
+	else if ("hp:footNote" == sNodeName)
+		return new CCtrlNote(L"  nf", oReader, nVersion);
+	else if ("hp:endNote" == sNodeName)
+		return new CCtrlNote(L"  ne", oReader, nVersion);
+	else if ("hp:autoNum" == sNodeName)
+		return new CCtrlAutoNumber(L"onta", oReader, nVersion);
+	else if ("hp:newNum" == sNodeName)
+		return new CCtrlNewNumber(L"onwn", oReader, nVersion);
+	else if ("hp:pageNum" == sNodeName)
+		return new CCtrlPageNumPos(L"pngp", oReader, nVersion);
+	else if ("hp:fieldBegin" == sNodeName ||
+	         "hp:fieldEnd"   == sNodeName)
+		return new CCtrlField(L"", oReader, nVersion);
 
 	return nullptr;
 }

HwpFile/HwpDoc/Paragraph/Ctrl.h

@@ -2,7 +2,7 @@
 #define CTRL_H
 
 #include "../Common/Common.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -46,7 +46,7 @@ public:
 	void SetFullFilled();
 
 	static bool Equals(CCtrl* pFirstCtrl, CCtrl* pSecondCtrl);
-	static CCtrl* GetCtrl(CXMLNode& oNode, int nVersion);
+	static CCtrl* GetCtrl(CXMLReader& oReader, int nVersion);
 };
 }
 

HwpFile/HwpDoc/Paragraph/CtrlAutoNumber.cpp

@@ -44,58 +44,65 @@ CCtrlAutoNumber::CCtrlAutoNumber(const HWP_STRING& sCtrlID, int nSize, CHWPStrea
 	m_bFullFilled = true;
 }
 
-CCtrlAutoNumber::CCtrlAutoNumber(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
+CCtrlAutoNumber::CCtrlAutoNumber(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
 	: CCtrl(sCtrlID)
 {
-	m_eNumType = ::HWP::GetNumType(oNode.GetAttribute(L"numType"));
+	m_eNumType = ::HWP::GetNumType(oReader.GetAttribute("numType"));
 
-	HWP_STRING sType;
-
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE(oReader)
 	{
-		m_bSuperscript = oChild.GetAttributeBool(L"supscript");
+		START_READ_ATTRIBUTES(oReader)
+		{
+			if ("supscript" == sAttributeName)
+				m_bSuperscript = oReader.GetBool();
+			else if ("type" == sAttributeName)
+			{
+				const std::string sType{oReader.GetTextA()};
 
-		sType = oChild.GetAttribute(L"type");
-
-		if (L"DIGIT" == sType)
-			m_eNumShape = ENumberShape2::DIGIT;
-		else if (L"CIRCLE_DIGIT" == sType)
-			m_eNumShape = ENumberShape2::CIRCLE_DIGIT;
-		else if (L"ROMAN_CAPITAL" == sType)
-			m_eNumShape = ENumberShape2::ROMAN_CAPITAL;
-		else if (L"ROMAN_SMALL" == sType)
-			m_eNumShape = ENumberShape2::ROMAN_SMALL;
-		else if (L"LATIN_CAPITAL" == sType)
-			m_eNumShape = ENumberShape2::LATIN_CAPITAL;
-		else if (L"LATIN_SMALL" == sType)
-			m_eNumShape = ENumberShape2::LATIN_SMALL;
-		else if (L"CIRCLED_LATIN_CAPITAL" == sType)
-			m_eNumShape = ENumberShape2::CIRCLED_LATIN_CAPITAL;
-		else if (L"CIRCLED_LATIN_SMALL" == sType)
-			m_eNumShape = ENumberShape2::CIRCLED_LATIN_SMALL;
-		else if (L"CIRCLED_HANGUL_SYLLABLE" == sType)
-			m_eNumShape = ENumberShape2::CIRCLED_HANGUL_SYLLABLE;
-		else if (L"HANGUL_JAMO" == sType)
-			m_eNumShape = ENumberShape2::HANGUL_JAMO;
-		else if (L"CIRCLED_HANGUL_JAMO" == sType)
-			m_eNumShape = ENumberShape2::CIRCLED_HANGUL_JAMO;
-		else if (L"HANGUL_PHONETIC" == sType)
-			m_eNumShape = ENumberShape2::HANGUL_PHONETIC;
-		else if (L"IDEOGRAPH" == sType)
-			m_eNumShape = ENumberShape2::IDEOGRAPH;
-		else if (L"CIRCLED_IDEOGRAPH" == sType)
-			m_eNumShape = ENumberShape2::CIRCLED_IDEOGRAPH;
-		else if (L"DECAGON_CIRCLE" == sType)
-			m_eNumShape = ENumberShape2::DECAGON_CIRCLE;
-		else if (L"DECAGON_CRICLE_HANGJA" == sType)
-			m_eNumShape = ENumberShape2::DECAGON_CRICLE_HANGJA;
-		else if (L"SYMBOL" == sType)
-			m_eNumShape = ENumberShape2::SYMBOL;
-		else if (L"USER_CHAR" == sType)
-			m_eNumShape = ENumberShape2::USER_HWP_CHAR;
-
-		m_eNumShape = GetNumberShape2(oChild.GetAttributeInt(L"hp:autoNumFormat", oChild.GetAttributeInt(L"autoNumFormat")));
+				if ("DIGIT" == sType)
+					m_eNumShape = ENumberShape2::DIGIT;
+				else if ("CIRCLE_DIGIT" == sType)
+					m_eNumShape = ENumberShape2::CIRCLE_DIGIT;
+				else if ("ROMAN_CAPITAL" == sType)
+					m_eNumShape = ENumberShape2::ROMAN_CAPITAL;
+				else if ("ROMAN_SMALL" == sType)
+					m_eNumShape = ENumberShape2::ROMAN_SMALL;
+				else if ("LATIN_CAPITAL" == sType)
+					m_eNumShape = ENumberShape2::LATIN_CAPITAL;
+				else if ("LATIN_SMALL" == sType)
+					m_eNumShape = ENumberShape2::LATIN_SMALL;
+				else if ("CIRCLED_LATIN_CAPITAL" == sType)
+					m_eNumShape = ENumberShape2::CIRCLED_LATIN_CAPITAL;
+				else if ("CIRCLED_LATIN_SMALL" == sType)
+					m_eNumShape = ENumberShape2::CIRCLED_LATIN_SMALL;
+				else if ("CIRCLED_HANGUL_SYLLABLE" == sType)
+					m_eNumShape = ENumberShape2::CIRCLED_HANGUL_SYLLABLE;
+				else if ("HANGUL_JAMO" == sType)
+					m_eNumShape = ENumberShape2::HANGUL_JAMO;
+				else if ("CIRCLED_HANGUL_JAMO" == sType)
+					m_eNumShape = ENumberShape2::CIRCLED_HANGUL_JAMO;
+				else if ("HANGUL_PHONETIC" == sType)
+					m_eNumShape = ENumberShape2::HANGUL_PHONETIC;
+				else if ("IDEOGRAPH" == sType)
+					m_eNumShape = ENumberShape2::IDEOGRAPH;
+				else if ("CIRCLED_IDEOGRAPH" == sType)
+					m_eNumShape = ENumberShape2::CIRCLED_IDEOGRAPH;
+				else if ("DECAGON_CIRCLE" == sType)
+					m_eNumShape = ENumberShape2::DECAGON_CIRCLE;
+				else if ("DECAGON_CRICLE_HANGJA" == sType)
+					m_eNumShape = ENumberShape2::DECAGON_CRICLE_HANGJA;
+				else if ("SYMBOL" == sType)
+					m_eNumShape = ENumberShape2::SYMBOL;
+				else if ("USER_CHAR" == sType)
+					m_eNumShape = ENumberShape2::USER_HWP_CHAR;
+			}
+			else if ("hp:autoNumFormat" == sAttributeName ||
+			         "autoNumFormat" == sAttributeName)
+				m_eNumShape = GetNumberShape2(oReader.GetInt());
+		}
+		END_READ_ATTRIBUTES(oReader)
 	}
+	END_WHILE
 
 	m_bFullFilled = true;
 }

HwpFile/HwpDoc/Paragraph/CtrlAutoNumber.h

@@ -5,7 +5,7 @@
 #include "../HWPStream.h"
 #include "../HWPElements/HwpRecordTypes.h"
 #include "../Common/Common.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -31,7 +31,7 @@ class CCtrlAutoNumber : public CCtrl
 public:
 	CCtrlAutoNumber(const HWP_STRING& sCtrlID);
 	CCtrlAutoNumber(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlAutoNumber(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlAutoNumber(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	ECtrlObjectType GetCtrlType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlCharacter.h

@@ -10,7 +10,8 @@ enum class ECtrlCharType
 	LINE_BREAK = 0x1,
 	PARAGRAPH_BREAK = 0x2,
 	HARD_HYPHEN = 0x3,
-	HARD_SPACE = 0x04
+	HARD_SPACE = 0x04,
+	TABULATION = 0x05
 };
 
 class CCtrlCharacter : public CCtrl

HwpFile/HwpDoc/Paragraph/CtrlColumnDef.cpp

@@ -40,12 +40,17 @@ CCtrlColumnDef::CCtrlColumnDef(const HWP_STRING& sCtrlID, int nSize, CHWPStream&
 	m_bFullFilled = true;
 }
 
-CCtrlColumnDef::CCtrlColumnDef(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrl(sCtrlID)
+CCtrlColumnDef::CCtrlColumnDef(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+	: CCtrl(sCtrlID), m_eColLineStyle(ELineStyle2::SOLID)
 {
-	m_eColLineStyle = ELineStyle2::SOLID;
-	m_shColCount = oNode.GetAttributeInt(L"colCount");
-	m_bSameSz = oNode.GetAttributeBool(L"sameSz");
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("colCount" == sAttributeName)
+			m_shColCount = oReader.GetInt();
+		else if ("sameSz" == sAttributeName)
+			m_bSameSz = oReader.GetBool();
+	}
+	END_READ_ATTRIBUTES(oReader)
 
 	if (!m_bSameSz)
 	{
@@ -55,20 +60,34 @@ CCtrlColumnDef::CCtrlColumnDef(const HWP_STRING& sCtrlID, CXMLNode& oNode, int n
 
 	unsigned int unColSzIndex = 0;
 
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hp:colLine" == oChild.GetName())
+		if ("hp:colLine" == sNodeName)
 		{
-			m_eColLineStyle = GetLineStyle2(oChild.GetAttribute(L"type"));
-			m_chColLineWidth = (HWP_BYTE)ConvertWidthToHWP(oChild.GetAttribute(L"width"));
-			m_nColLineColor = oChild.GetAttributeColor(L"color");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("type" == sAttributeName)
+					m_eColLineStyle = GetLineStyle2(oReader.GetText());
+				else if ("width" == sAttributeName)
+					m_chColLineWidth = (HWP_BYTE)ConvertWidthToHWP(oReader.GetTextA());
+				else if ("color" == sAttributeName)
+					m_nColLineColor = oReader.GetColor();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hp:colSz" == oChild.GetName())
+		else if ("hp:colSz" == sNodeName)
 		{
-			m_arColSzWidths[unColSzIndex] = oChild.GetAttributeInt(L"width");
-			m_arColSzGaps[unColSzIndex++] = oChild.GetAttributeInt(L"gap");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("width" == sAttributeName)
+					m_arColSzWidths[unColSzIndex] = oReader.GetInt();
+				else if ("gap" == sAttributeName)
+					m_arColSzGaps[unColSzIndex++] =  oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
 	}
+	END_WHILE
 
 	m_bFullFilled = true;
 }

HwpFile/HwpDoc/Paragraph/CtrlColumnDef.h

@@ -4,7 +4,7 @@
 #include "../HWPElements/HwpRecordTypes.h"
 #include "../HWPStream.h"
 #include "Ctrl.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -22,7 +22,7 @@ class CCtrlColumnDef : public CCtrl
 public:
 	CCtrlColumnDef(const HWP_STRING& sCtrlID);
 	CCtrlColumnDef(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlColumnDef(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlColumnDef(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	ECtrlObjectType GetCtrlType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlCommon.cpp

@@ -1,6 +1,8 @@
 #include "CtrlCommon.h"
 #include "../Common/Common.h"
 #include <climits>
+#include <iostream>
+#include <ostream>
 
 #include "CapParagraph.h"
 
@@ -250,116 +252,58 @@ namespace HWP
 		oBuffer.Skip(nSize - oBuffer.GetDistanceToLastPos(true));
 	}
 
-	CCtrlCommon::CCtrlCommon(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
+	CCtrlCommon::CCtrlCommon(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
 	    : CCtrl(sCtrlID), m_bTreatAsChar(false), m_eVertRelTo(EVRelTo::PARA), m_eHorzRelTo(EHRelTo::PARA), m_nVertOffset(0), m_nHorzOffset(0), m_nWidth(0), m_nHeight(0), m_arOutMargin{0, 0, 0, 0},  m_arInMargin{0, 0, 0, 0}, m_eTextVerAlign(EVertAlign::TOP)
 	{
-		m_nObjInstanceID = std::abs(oNode.GetAttributeInt(L"id"));
+		std::string sType;
 
-		HWP_STRING sType = oNode.GetAttribute(L"textFlow");
-
-		if (L"BOTH_SIDES" == sType)
-			m_chTextFlow = 0;
-		else if (L"LEFT_ONLY" == sType)
-			m_chTextFlow = 1;
-		else if (L"RIGHT_ONLY" == sType)
-			m_chTextFlow = 2;
-		else if (L"LARGEST_ONLY" == sType)
-			m_chTextFlow = 3;
-
-		sType = oNode.GetAttribute(L"textWrap");
-
-		if (L"SQUARE" == sType)
-			m_eTextWrap = ETextWrap::SQUARE;
-		else if (L"TOP_AND_BOTTOM" == sType)
-			m_eTextWrap = ETextWrap::TOP_AND_BOTTOM;
-		else if (L"BEHIND_TEXT" == sType)
-			m_eTextWrap = ETextWrap::BEHIND_TEXT;
-		else if (L"IN_FRONT_OF_TEXT" == sType)
-			m_eTextWrap = ETextWrap::IN_FRONT_OF_TEXT;
-
-		m_nZOrder = oNode.GetAttributeInt(L"zOrder");
-
-		sType = oNode.GetAttribute(L"numberingType");
-
-		if (L"NONE" == sType)
-			m_chNumeringType = 0;
-		else if (L"PICTURE" == sType)
-			m_chNumeringType = 1;
-		else if (L"TABLE" == sType)
-			m_chNumeringType = 2;
-		else if (L"EQUATION" == sType)
-			m_chNumeringType = 3;
-
-		for (CXMLNode& oChild : oNode.GetChilds())
+		START_READ_ATTRIBUTES(oReader)
 		{
-			if (L"hp:sz" == oChild.GetName())
+			if ("id" == sAttributeName)
+				m_nObjInstanceID = std::abs(oReader.GetInt());
+			else if ("textFlow" == sAttributeName)
 			{
-				m_nWidth = oChild.GetAttributeInt(L"width");
-				m_eWidthRelTo = ::HWP::GetWidthRelTo(oChild.GetAttribute(L"widthRelTo"));
-				m_nHeight = oChild.GetAttributeInt(L"height");
-				m_eHeightRelTo = ::HWP::GetHeightRelTo(oChild.GetAttribute(L"heightRelTo"));
+				sType = oReader.GetTextA();
+
+				if ("BOTH_SIDES" == sType)
+					m_chTextFlow = 0;
+				else if ("LEFT_ONLY" == sType)
+					m_chTextFlow = 1;
+				else if ("RIGHT_ONLY" == sType)
+					m_chTextFlow = 2;
+				else if ("LARGEST_ONLY" == sType)
+					m_chTextFlow = 3;
 			}
-			else if (L"hp:pos" == oChild.GetName())
+			else if ("textWrap" == sAttributeName)
 			{
-				m_bTreatAsChar = oChild.GetAttributeBool(L"treatAsChar");
+				sType = oReader.GetTextA();
 
-				if (m_bTreatAsChar)
-					m_bAffectLSpacing = oChild.GetAttributeBool(L"affectLSpacing");
-				else
-					m_bAllowOverlap = oChild.GetAttributeBool(L"allowOverlap");
-
-				m_eVertRelTo = GetVRelTo(oChild.GetAttribute(L"vertRelTo"));
-				m_eHorzRelTo = GetHRelTo(oChild.GetAttribute(L"horzRelTo"));
-
-				if (EVRelTo::PARA == m_eVertRelTo)
-					m_bFlowWithText = oChild.GetAttributeBool(L"flowWithText");
-
-				m_eVertAlign = GetVertAlign(oChild.GetAttribute(L"vertAlign"));
-				m_eHorzAlign = GetHorzAlign(oChild.GetAttribute(L"horzAlign"));
-				m_nVertOffset = oChild.GetAttributeInt(L"vertOffset");
-				m_nHorzOffset = oChild.GetAttributeInt(L"horzOffset");
+				if ("SQUARE" == sType)
+					m_eTextWrap = ETextWrap::SQUARE;
+				else if ("TOP_AND_BOTTOM" == sType)
+					m_eTextWrap = ETextWrap::TOP_AND_BOTTOM;
+				else if ("BEHIND_TEXT" == sType)
+					m_eTextWrap = ETextWrap::BEHIND_TEXT;
+				else if ("IN_FRONT_OF_TEXT" == sType)
+					m_eTextWrap = ETextWrap::IN_FRONT_OF_TEXT;
 			}
-			else if (L"hp:outMargin" == oChild.GetName())
+			else if ("zOrder" == sAttributeName)
+				m_nZOrder = oReader.GetInt();
+			else if ("numberingType" == sAttributeName)
 			{
-				m_arOutMargin[0] = oChild.GetAttributeInt(L"left");
-				m_arOutMargin[1] = oChild.GetAttributeInt(L"right");
-				m_arOutMargin[2] = oChild.GetAttributeInt(L"top");
-				m_arOutMargin[3] = oChild.GetAttributeInt(L"bottom");
-			}
-			else if (L"hp:inMargin" == oChild.GetName())
-			{
-				m_arInMargin[0] = oChild.GetAttributeInt(L"left");
-				m_arInMargin[1] = oChild.GetAttributeInt(L"right");
-				m_arInMargin[2] = oChild.GetAttributeInt(L"top");
-				m_arInMargin[3] = oChild.GetAttributeInt(L"bottom");
-			}
-			else if (L"hp:caption" == oChild.GetName())
-			{
-				HWP_STRING sType = oChild.GetAttribute(L"side");
+				sType = oReader.GetTextA();
 
-				if (L"LEFT" == sType)
-					m_nCaptionAttr = 0b00;
-				else if (L"RIGHT" == sType)
-					m_nCaptionAttr = 0b01;
-				else if (L"TOP" == sType)
-					m_nCaptionAttr = 0b10;
-				else if (L"BOTTOM" == sType)
-					m_nCaptionAttr = 0b11;
-
-				if (oChild.GetAttributeBool(L"fullSz"))
-					m_nCaptionAttr |= 0b100;
-
-				m_nCaptionWidth = oChild.GetAttributeInt(L"width");
-				m_nCaptionSpacing = oChild.GetAttributeInt(L"gap");
-				m_nCaptionMaxW = oChild.GetAttributeInt(L"lastWidth");
-
-				for (CXMLNode& oSubList : oChild.GetChilds(L"hp:subList"))
-				{
-					for (CXMLNode& oParagraph : oSubList.GetChilds(L"hp:p"))
-						m_arCaption.push_back(new CCapParagraph(oParagraph, nVersion));
-				}
+				if ("NONE" == sType)
+					m_chNumeringType = 0;
+				else if ("PICTURE" == sType)
+					m_chNumeringType = 1;
+				else if ("TABLE" == sType)
+					m_chNumeringType = 2;
+				else if ("EQUATION" == sType)
+					m_chNumeringType = 3;
 			}
 		}
+		END_READ_ATTRIBUTES(oReader)
 	}
 
 	CCtrlCommon::~CCtrlCommon()
@@ -387,6 +331,121 @@ namespace HWP
 		m_eTextVerAlign = eVertAlign;
 	}
 
+	void CCtrlCommon::ParseChildren(CXMLReader& oReader, int nVersion)
+	{
+		const std::string sNodeName{oReader.GetName()};
+
+		if ("hp:sz" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("width" == sAttributeName)
+					m_nWidth = oReader.GetInt();
+				else if ("widthRelTo" == sAttributeName)
+					m_eWidthRelTo = ::HWP::GetWidthRelTo(oReader.GetText());
+				else if ("height" == sAttributeName)
+					m_nHeight = oReader.GetInt();
+				else if ("heightRelTo" == sAttributeName)
+					m_eHeightRelTo = ::HWP::GetHeightRelTo(oReader.GetText());
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:pos" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("treatAsChar" == sAttributeName)
+					m_bTreatAsChar = oReader.GetBool();
+				else if ("affectLSpacing" == sAttributeName)
+					m_bAffectLSpacing = oReader.GetBool();
+				else if ("allowOverlap" == sAttributeName)
+					m_bAllowOverlap = oReader.GetBool();
+				else if ("vertRelTo" == sAttributeName)
+					m_eVertRelTo = GetVRelTo(oReader.GetText());
+				else if ("horzRelTo" == sAttributeName)
+					m_eHorzRelTo = GetHRelTo(oReader.GetText());
+				else if ("flowWithText" == sAttributeName)
+					m_bFlowWithText = oReader.GetBool();
+				else if ("vertAlign" == sAttributeName)
+					m_eVertAlign = GetVertAlign(oReader.GetText());
+				else if ("horzAlign" == sAttributeName)
+					m_eHorzAlign = GetHorzAlign(oReader.GetText());
+				else if ("vertOffset" == sAttributeName)
+					m_nVertOffset = oReader.GetInt();
+				else if ("horzOffset" == sAttributeName)
+					m_nHorzOffset = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:outMargin" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("left" == sAttributeName)
+					m_arOutMargin[0] = oReader.GetInt();
+				else if ("right" == sAttributeName)
+					m_arOutMargin[1] = oReader.GetInt();
+				else if ("top" == sAttributeName)
+					m_arOutMargin[2] = oReader.GetInt();
+				else if ("bottom" == sAttributeName)
+					m_arOutMargin[3] = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:inMargin" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("left" == sAttributeName)
+					m_arInMargin[0] = oReader.GetInt();
+				else if ("right" == sAttributeName)
+					m_arInMargin[1] = oReader.GetInt();
+				else if ("top" == sAttributeName)
+					m_arInMargin[2] = oReader.GetInt();
+				else if ("bottom" == sAttributeName)
+					m_arInMargin[3] = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:caption" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("side" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
+
+					if ("LEFT" == sType)
+						m_nCaptionAttr = 0b00;
+					else if ("RIGHT" == sType)
+						m_nCaptionAttr = 0b01;
+					else if ("TOP" == sType)
+						m_nCaptionAttr = 0b10;
+					else if ("BOTTOM" == sType)
+						m_nCaptionAttr = 0b11;
+				}
+				else if ("fullSz" == sAttributeName)
+				{
+					if (oReader.GetBool())
+						m_nCaptionAttr |= 0b100;
+				}
+				else if ("width" == sAttributeName)
+					m_nCaptionWidth = oReader.GetInt();
+				else if ("gap" == sAttributeName)
+					m_nCaptionSpacing = oReader.GetInt();
+				else if ("lastWidth" == sAttributeName)
+					m_nCaptionMaxW = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, SubList, "hp:subList")
+				WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Paragraph, "hp:p")
+					m_arCaption.push_back(new CCapParagraph(oReader, nVersion));
+				END_WHILE
+			END_WHILE
+		}
+	}
+
 	void CCtrlCommon::AddParagraph(CHWPPargraph* pParagraph)
 	{
 		m_arParas.push_back(pParagraph);

HwpFile/HwpDoc/Paragraph/CtrlCommon.h

@@ -114,13 +114,15 @@ public:
 	CCtrlCommon(const HWP_STRING& sCtrlID);
 	CCtrlCommon(const CCtrlCommon& oCtrlCommon);
 	CCtrlCommon(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlCommon(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlCommon(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 	virtual ~CCtrlCommon();
 
 	ECtrlObjectType GetCtrlType() const override;
 
 	void SetTextVerAlign(EVertAlign eVertAlign);
 
+	void ParseChildren(CXMLReader& oReader, int nVersion);
+
 	void AddParagraph(CHWPPargraph* pParagraph);
 	void AddCaption(CCapParagraph* pCapPara);
 

HwpFile/HwpDoc/Paragraph/CtrlContainer.cpp

@@ -25,32 +25,33 @@ CCtrlContainer::CCtrlContainer(const HWP_STRING& sCtrlID, int nSize, CHWPStream&
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlContainer::CCtrlContainer(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlContainer::CCtrlContainer(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hp:container" == oChild.GetName())
-			m_arShapes.push_back(new CCtrlContainer(L"noc$", oChild, nVersion));
-		else if (L"hp:line" == oChild.GetName())
-			m_arShapes.push_back(new CCtrlShapeLine(L"nil$", oChild, nVersion));
-		else if (L"hp:rect" == oChild.GetName())
-			m_arShapes.push_back(new CCtrlShapeRect(L"cer$", oChild, nVersion));
-		else if (L"hp:ellipse" == oChild.GetName())
-			m_arShapes.push_back(new CCtrlShapeEllipse(L"lle$", oChild, nVersion));
-		else if (L"hp:arc" == oChild.GetName())
-			m_arShapes.push_back(new CCtrlShapeArc(L"cra$", oChild, nVersion));
-		else if (L"hp:polygon" == oChild.GetName())
-			m_arShapes.push_back(new CCtrlShapePolygon(L"lop$", oChild, nVersion));
-		else if (L"hp:curve" == oChild.GetName())
-			m_arShapes.push_back(new CCtrlShapeCurve(L"ruc$", oChild, nVersion));
-		else if (L"hp:connectLine" == oChild.GetName())
-			m_arShapes.push_back(new CCtrlShapeConnectLine(L"loc$", oChild, nVersion));
-		else if (L"hp:pic" == oChild.GetName())
-			m_arShapes.push_back(new CCtrlShapePic(L"cip$", oChild, nVersion));
-		else if (L"hp:ole" == oChild.GetName())
-			m_arShapes.push_back(new CCtrlShapeOle(L"elo$", oChild, nVersion));
+		if ("hp:container" == sNodeName)
+			m_arShapes.push_back(new CCtrlContainer(L"noc$", oReader, nVersion));
+		else if ("hp:line" == sNodeName)
+			m_arShapes.push_back(new CCtrlShapeLine(L"nil$", oReader, nVersion));
+		else if ("hp:rect" == sNodeName)
+			m_arShapes.push_back(new CCtrlShapeRect(L"cer$", oReader, nVersion));
+		else if ("hp:ellipse" == sNodeName)
+			m_arShapes.push_back(new CCtrlShapeEllipse(L"lle$", oReader, nVersion));
+		else if ("hp:arc" == sNodeName)
+			m_arShapes.push_back(new CCtrlShapeArc(L"cra$", oReader, nVersion));
+		else if ("hp:polygon" == sNodeName)
+			m_arShapes.push_back(new CCtrlShapePolygon(L"lop$", oReader, nVersion));
+		else if ("hp:curve" == sNodeName)
+			m_arShapes.push_back(new CCtrlShapeCurve(L"ruc$", oReader, nVersion));
+		else if ("hp:connectLine" == sNodeName)
+			m_arShapes.push_back(new CCtrlShapeConnectLine(L"loc$", oReader, nVersion));
+		else if ("hp:pic" == sNodeName)
+			m_arShapes.push_back(new CCtrlShapePic(L"cip$", oReader, nVersion));
+		else if ("hp:ole" == sNodeName)
+			m_arShapes.push_back(new CCtrlShapeOle(L"elo$", oReader, nVersion));
 	}
+	END_WHILE
 
 	m_shNElement = m_arShapes.size();
 }

HwpFile/HwpDoc/Paragraph/CtrlContainer.h

@@ -14,7 +14,7 @@ public:
 	CCtrlContainer(const HWP_STRING& sCtrlID);
 	CCtrlContainer(const CCtrlGeneralShape& oShape);
 	CCtrlContainer(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlContainer(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlContainer(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	~CCtrlContainer();
 

HwpFile/HwpDoc/Paragraph/CtrlEqEdit.cpp

@@ -17,23 +17,41 @@ CCtrlEqEdit::CCtrlEqEdit(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuff
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlEqEdit::CCtrlEqEdit(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID)
+CCtrlEqEdit::CCtrlEqEdit(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+	: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	m_sVersion = oNode.GetAttribute(L"version");
-	m_nBaseline = oNode.GetAttributeInt(L"baseLine");
-	m_nColor = oNode.GetAttributeColor(L"textColor");
-	m_nCharSize = oNode.GetAttributeInt(L"baseUnit");
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("version" == sAttributeName)
+			m_sVersion = oReader.GetText();
+		else if ("baseLine" == sAttributeName)
+			m_nBaseline = oReader.GetInt();
+		else if ("textColor" == sAttributeName)
+			m_nColor = oReader.GetColor();
+		else if ("baseUnit" == sAttributeName)
+			m_nCharSize = oReader.GetInt();
+		else if ("lineMode" == sAttributeName)
+		{
+			const std::string sType{oReader.GetTextA()};
 
-	HWP_STRING sType = oNode.GetAttribute(L"lineMode");
+			if ("LINE" == sType)
+				m_nAttr = 1;
+			else if ("CHAR" == sType)
+				m_nAttr = 0;
+		}
+		else if ("font" == sAttributeName)
+			m_sFont = oReader.GetText();
+	}
+	END_READ_ATTRIBUTES(oReader)
 
-	if (L"LINE" == sType)
-		m_nAttr = 1;
-	else if (L"CHAR" == sType)
-		m_nAttr = 0;
-
-	m_sFont = oNode.GetAttribute(L"font");
-	m_sEqn = oNode.GetChild(L"hp:script").GetText();
+	WHILE_READ_NEXT_NODE(oReader)
+	{
+		if ("hp:script" == oReader.GetName())
+			m_sEqn = oReader.GetText();
+		else
+			CCtrlGeneralShape::ParseChildren(oReader, nVersion);
+	}
+	END_WHILE
 
 	m_bFullFilled = true;
 }

HwpFile/HwpDoc/Paragraph/CtrlEqEdit.h

@@ -19,7 +19,7 @@ public:
 	CCtrlEqEdit(const HWP_STRING& sCtrlID);
 	CCtrlEqEdit(const CCtrlGeneralShape& oShape);
 	CCtrlEqEdit(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlEqEdit(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlEqEdit(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	EShapeType GetShapeType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlField.cpp

@@ -1,6 +1,4 @@
 #include "CtrlField.h"
-#include <iostream>
-#include <ostream>
 
 namespace HWP
 {
@@ -33,37 +31,50 @@ void CCtrlField::UpdateType(const HWP_STRING& sCtrlID)
 		m_eType = EFieldType::BookmarkClosing;
 }
 
-CCtrlField::CCtrlField(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
+CCtrlField::CCtrlField(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
 	: CCtrl(sCtrlID), m_eType(EFieldType::Unknown)
 {
-	if (L"hp:fieldBegin" == oNode.GetName())
+	const std::string sNodeName{oReader.GetName()};
+	HWP_STRING wsName;
+
+	if ("hp:fieldBegin" == sNodeName)
 	{
-		HWP_STRING sType = oNode.GetAttribute(L"type");
-
-		if (L"HYPERLINK" == sType)
-			m_eType = EFieldType::Hyperlink;
-		else if (L"BOOKMARK" == sType)
-			m_eType = EFieldType::Bookmark;
-
-		m_nInstanceID = oNode.GetAttributeInt(L"fieldid");
-
-		HWP_STRING sName = oNode.GetAttribute(L"name");
-
-		if (!sName.empty() && EFieldType::Bookmark == m_eType)
-			AddStringParam(L"bookmarkname", sName);
-
-		for (CXMLNode& oChild : oNode.GetChild(L"hp:parameters").GetChilds())
+		START_READ_ATTRIBUTES(oReader)
 		{
-			if (L"hp:stringParam" == oChild.GetName())
-				AddStringParam(oChild.GetAttribute(L"name"), oChild.GetText());
-			else if (L"hp:integerParam" == oChild.GetName())
-				AddIntegerParam(oChild.GetAttribute(L"name"), std::stoi(oChild.GetText()));
+			if ("type" == sAttributeName)
+			{
+				const std::string sType{oReader.GetTextA()};
+
+				if ("HYPERLINK" == sType)
+					m_eType = EFieldType::Hyperlink;
+				else if ("BOOKMARK" == sType)
+					m_eType = EFieldType::Bookmark;
+			}
+			else if ("fieldid" == sAttributeName)
+				m_nInstanceID = oReader.GetInt();
+			else if ("name" == sAttributeName)
+				wsName = oReader.GetText();
 		}
+		END_READ_ATTRIBUTES(oReader)
+
+		if (!wsName.empty() && EFieldType::Bookmark == m_eType)
+			AddStringParam(L"bookmarkname", wsName);
+
+		WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hp:parameters")
+		{
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_AND_NAME(oReader, Child)
+			{
+				if ("hp:stringParam" == sNodeChildName)
+					AddStringParam(oReader.GetAttribute("name"), oReader.GetText());
+				else if ("hp:integerParam" == sNodeChildName)
+					AddIntegerParam(oReader.GetAttribute("name"), oReader.GetInt());
+			}
+			END_WHILE
+		}
+		END_WHILE
 	}
-	else if (L"hp:fieldEnd" == oNode.GetName())
-	{
-		m_nInstanceID = oNode.GetAttributeInt(L"fieldid");
-	}
+	else if ("hp:fieldEnd" == sNodeName)
+		m_nInstanceID = oReader.GetAttributeInt("fieldid");
 }
 
 ECtrlObjectType CCtrlField::GetCtrlType() const

HwpFile/HwpDoc/Paragraph/CtrlField.h

@@ -32,7 +32,7 @@ class CCtrlField : public CCtrl
 public:
 	CCtrlField(const HWP_STRING& sCtrlID);
 	CCtrlField(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlField(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlField(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	ECtrlObjectType GetCtrlType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlGeneralShape.cpp

@@ -62,121 +62,10 @@ CCtrlGeneralShape::CCtrlGeneralShape(const HWP_STRING& sCtrlID, int nSize, CHWPS
 	InitData();
 }
 
-CCtrlGeneralShape::CCtrlGeneralShape(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlObjElement(sCtrlID, oNode, nVersion)
+CCtrlGeneralShape::CCtrlGeneralShape(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlObjElement(sCtrlID, oReader, nVersion)
 {
 	InitData();
-
-	for (CXMLNode& oChild : oNode.GetChilds())
-	{
-		if (L"hp:lineShape" == oChild.GetName())
-		{
-			m_nLineColor = oChild.GetAttributeColor(L"color");
-			m_nLineThick = std::abs(oChild.GetAttributeInt(L"width"));
-			m_eLineStyle = GetLineStyle2(oChild.GetAttribute(L"style"));
-
-			HWP_STRING sType = oChild.GetAttribute(L"headStyle");
-
-			if (L"ARROW" == sType)
-				m_eLineHead = ELineArrowStyle::ARROW;
-			else if (L"SPEAR" == sType)
-				m_eLineHead = ELineArrowStyle::SPEAR;
-			else if (L"CONCAVE_ARROW" == sType)
-				m_eLineHead = ELineArrowStyle::CONCAVE_ARROW;
-			else if (L"EMPTY_DIAMOND" == sType)
-				m_eLineHead = (oChild.GetAttributeBool(L"headfill")) ? ELineArrowStyle::DIAMOND : ELineArrowStyle::EMPTY_DIAMOND;
-			else if (L"EMPTY_CIRCLE" == sType)
-				m_eLineHead = (oChild.GetAttributeBool(L"headfill")) ? ELineArrowStyle::CIRCLE : ELineArrowStyle::EMPTY_CIRCLE;
-			else if (L"EMPTY_BOX" == sType)
-				m_eLineHead = (oChild.GetAttributeBool(L"headfill")) ? ELineArrowStyle::BOX : ELineArrowStyle::EMPTY_BOX;
-			else
-				m_eLineHead = ELineArrowStyle::NORMAL;
-
-			sType = oChild.GetAttribute(L"headSz");
-
-			if (L"SMALL_SMALL" == sType)
-				m_eLineHeadSz = ELineArrowSize::SMALL_SMALL;
-			else if (L"SMALL_MEDIUM" == sType)
-				m_eLineHeadSz = ELineArrowSize::SMALL_MEDIUM;
-			else if (L"SMALL_LARGE" == sType)
-				m_eLineHeadSz = ELineArrowSize::SMALL_LARGE;
-			else if (L"MEDIUM_SMALL" == sType)
-				m_eLineHeadSz = ELineArrowSize::MEDIUM_SMALL;
-			else if (L"MEDIUM_MEDIUM" == sType)
-				m_eLineHeadSz = ELineArrowSize::MEDIUM_MEDIUM;
-			else if (L"MEDIUM_LARGE" == sType)
-				m_eLineHeadSz = ELineArrowSize::MEDIUM_LARGE;
-			else if (L"LARGE_SMALL" == sType)
-				m_eLineHeadSz = ELineArrowSize::LARGE_SMALL;
-			else if (L"LARGE_MEDIUM" == sType)
-				m_eLineHeadSz = ELineArrowSize::LARGE_MEDIUM;
-			else if (L"LARGE_LARGE" == sType)
-				m_eLineHeadSz = ELineArrowSize::LARGE_LARGE;
-			else
-				m_eLineHeadSz = ELineArrowSize::MEDIUM_MEDIUM;
-
-			sType = oChild.GetAttribute(L"tailStyle");
-
-			if (L"ARROW" == sType)
-				m_eLineTail = ELineArrowStyle::ARROW;
-			else if (L"SPEAR" == sType)
-				m_eLineTail = ELineArrowStyle::SPEAR;
-			else if (L"CONCAVE_ARROW" == sType)
-				m_eLineTail = ELineArrowStyle::CONCAVE_ARROW;
-			else if (L"EMPTY_DIAMOND" == sType)
-				m_eLineTail = (oChild.GetAttributeBool(L"tailfill")) ? ELineArrowStyle::DIAMOND : ELineArrowStyle::EMPTY_DIAMOND;
-			else if (L"EMPTY_CIRCLE" == sType)
-				m_eLineTail = (oChild.GetAttributeBool(L"tailfill")) ? ELineArrowStyle::CIRCLE : ELineArrowStyle::EMPTY_CIRCLE;
-			else if (L"EMPTY_BOX" == sType)
-				m_eLineTail = (oChild.GetAttributeBool(L"tailfill")) ? ELineArrowStyle::BOX : ELineArrowStyle::EMPTY_BOX;
-			else
-				m_eLineTail = ELineArrowStyle::NORMAL;
-
-			sType = oChild.GetAttribute(L"tailSz");
-
-			if (L"SMALL_SMALL" == sType)
-				m_eLineTailSz = ELineArrowSize::SMALL_SMALL;
-			else if (L"SMALL_MEDIUM" == sType)
-				m_eLineTailSz = ELineArrowSize::SMALL_MEDIUM;
-			else if (L"SMALL_LARGE" == sType)
-				m_eLineTailSz = ELineArrowSize::SMALL_LARGE;
-			else if (L"MEDIUM_SMALL" == sType)
-				m_eLineTailSz = ELineArrowSize::MEDIUM_SMALL;
-			else if (L"MEDIUM_MEDIUM" == sType)
-				m_eLineTailSz = ELineArrowSize::MEDIUM_MEDIUM;
-			else if (L"MEDIUM_LARGE" == sType)
-				m_eLineTailSz = ELineArrowSize::MEDIUM_LARGE;
-			else if (L"LARGE_SMALL" == sType)
-				m_eLineTailSz = ELineArrowSize::LARGE_SMALL;
-			else if (L"LARGE_MEDIUM" == sType)
-				m_eLineTailSz = ELineArrowSize::LARGE_MEDIUM;
-			else if (L"LARGE_LARGE" == sType)
-				m_eLineTailSz = ELineArrowSize::LARGE_LARGE;
-			else
-				m_eLineTailSz = ELineArrowSize::MEDIUM_MEDIUM;
-		}
-		else if (L"hc:fillBrush" ==  oChild.GetName())
-			m_pFill = new CFill(oChild);
-		else if (L"hp:drawText" == oChild.GetName())
-		{
-			m_nMaxTxtWidth = oChild.GetAttributeInt(L"lastWidth");
-
-			for (CXMLNode& oGrandChild : oChild.GetChilds())
-			{
-				if (L"hp:textMargin" == oGrandChild.GetName())
-				{
-					m_shLeftSpace = oGrandChild.GetAttributeInt(L"left");
-					m_shRightSpace = oGrandChild.GetAttributeInt(L"right");
-					m_shTopSpace = oGrandChild.GetAttributeInt(L"top");
-					m_shBottomSpace = oGrandChild.GetAttributeInt(L"bottom");
-				}
-				else if (L"hp:subList" == oGrandChild.GetName())
-				{
-					ReadSubList(oGrandChild, nVersion);
-				}
-			}
-		}
-	}
 }
 
 CCtrlGeneralShape::~CCtrlGeneralShape()
@@ -195,36 +84,177 @@ EShapeType CCtrlGeneralShape::GetShapeType() const
 	return EShapeType::GeneralShape;
 }
 
+void CCtrlGeneralShape::ParseChildren(CXMLReader& oReader, int nVersion)
+{
+	bool bHeadFill = false, bTailFill = false;
+
+	const std::string sNodeName{oReader.GetName()};
+
+	if ("hp:lineShape" == sNodeName)
+	{
+		std::string sHeadStyle, sTailStyle;
+
+		START_READ_ATTRIBUTES(oReader)
+		{
+			if ("color" == sAttributeName)
+				m_nLineColor = oReader.GetInt();
+			else if ("width" == sAttributeName)
+				m_nLineThick = oReader.GetInt();
+			else if ("style" == sAttributeName)
+				m_eLineStyle = GetLineStyle2(oReader.GetText());
+			else if ("headStyle" == sAttributeName)
+				sHeadStyle = oReader.GetTextA();
+			else if ("headfill" == sAttributeName)
+				bHeadFill = oReader.GetBool();
+			else if ("headSz" == sAttributeName)
+			{
+				const std::string sHeadSz{oReader.GetTextA()};
+
+				if ("SMALL_SMALL" == sHeadSz)
+					m_eLineHeadSz = ELineArrowSize::SMALL_SMALL;
+				else if ("SMALL_MEDIUM" == sHeadSz)
+					m_eLineHeadSz = ELineArrowSize::SMALL_MEDIUM;
+				else if ("SMALL_LARGE" == sHeadSz)
+					m_eLineHeadSz = ELineArrowSize::SMALL_LARGE;
+				else if ("MEDIUM_SMALL" == sHeadSz)
+					m_eLineHeadSz = ELineArrowSize::MEDIUM_SMALL;
+				else if ("MEDIUM_MEDIUM" == sHeadSz)
+					m_eLineHeadSz = ELineArrowSize::MEDIUM_MEDIUM;
+				else if ("MEDIUM_LARGE" == sHeadSz)
+					m_eLineHeadSz = ELineArrowSize::MEDIUM_LARGE;
+				else if ("LARGE_SMALL" == sHeadSz)
+					m_eLineHeadSz = ELineArrowSize::LARGE_SMALL;
+				else if ("LARGE_MEDIUM" == sHeadSz)
+					m_eLineHeadSz = ELineArrowSize::LARGE_MEDIUM;
+				else if ("LARGE_LARGE" == sHeadSz)
+					m_eLineHeadSz = ELineArrowSize::LARGE_LARGE;
+				else
+					m_eLineHeadSz = ELineArrowSize::MEDIUM_MEDIUM;
+			}
+			else if ("tailStyle" == sAttributeName)
+				sTailStyle = oReader.GetTextA();
+			else if ("tailfill" == sAttributeName)
+				bTailFill = oReader.GetBool();
+			else if ("tailSz" == sAttributeName)
+			{
+				const std::string sType{oReader.GetTextA()};
+
+				if ("SMALL_SMALL" == sType)
+					m_eLineTailSz = ELineArrowSize::SMALL_SMALL;
+				else if ("SMALL_MEDIUM" == sType)
+					m_eLineTailSz = ELineArrowSize::SMALL_MEDIUM;
+				else if ("SMALL_LARGE" == sType)
+					m_eLineTailSz = ELineArrowSize::SMALL_LARGE;
+				else if ("MEDIUM_SMALL" == sType)
+					m_eLineTailSz = ELineArrowSize::MEDIUM_SMALL;
+				else if ("MEDIUM_MEDIUM" == sType)
+					m_eLineTailSz = ELineArrowSize::MEDIUM_MEDIUM;
+				else if ("MEDIUM_LARGE" == sType)
+					m_eLineTailSz = ELineArrowSize::MEDIUM_LARGE;
+				else if ("LARGE_SMALL" == sType)
+					m_eLineTailSz = ELineArrowSize::LARGE_SMALL;
+				else if ("LARGE_MEDIUM" == sType)
+					m_eLineTailSz = ELineArrowSize::LARGE_MEDIUM;
+				else if ("LARGE_LARGE" == sType)
+					m_eLineTailSz = ELineArrowSize::LARGE_LARGE;
+				else
+					m_eLineTailSz = ELineArrowSize::MEDIUM_MEDIUM;
+			}
+		}
+		END_READ_ATTRIBUTES(oReader)
+
+		if (sHeadStyle.empty())
+			m_eLineHead = ELineArrowStyle::NORMAL;
+		else if ("ARROW" == sHeadStyle)
+			m_eLineHead = ELineArrowStyle::ARROW;
+		else if ("SPEAR" == sHeadStyle)
+			m_eLineHead = ELineArrowStyle::SPEAR;
+		else if ("CONCAVE_ARROW" == sHeadStyle)
+			m_eLineHead = ELineArrowStyle::CONCAVE_ARROW;
+		else if ("EMPTY_DIAMOND" == sHeadStyle)
+			m_eLineHead = bHeadFill ? ELineArrowStyle::DIAMOND : ELineArrowStyle::EMPTY_DIAMOND;
+		else if ("EMPTY_CIRCLE" == sHeadStyle)
+			m_eLineHead = bHeadFill ? ELineArrowStyle::CIRCLE : ELineArrowStyle::EMPTY_CIRCLE;
+		else if ("EMPTY_BOX" == sHeadStyle)
+			m_eLineHead = bHeadFill ? ELineArrowStyle::BOX : ELineArrowStyle::EMPTY_BOX;
+		else
+			m_eLineHead = ELineArrowStyle::NORMAL;
+
+		if (sTailStyle.empty())
+			m_eLineTail = ELineArrowStyle::NORMAL;
+		else if ("ARROW" == sTailStyle)
+			m_eLineTail = ELineArrowStyle::ARROW;
+		else if ("SPEAR" == sTailStyle)
+			m_eLineTail = ELineArrowStyle::SPEAR;
+		else if ("CONCAVE_ARROW" == sTailStyle)
+			m_eLineTail = ELineArrowStyle::CONCAVE_ARROW;
+		else if ("EMPTY_DIAMOND" == sTailStyle)
+			m_eLineTail = bTailFill ? ELineArrowStyle::DIAMOND : ELineArrowStyle::EMPTY_DIAMOND;
+		else if ("EMPTY_CIRCLE" == sTailStyle)
+			m_eLineTail = bTailFill ? ELineArrowStyle::CIRCLE : ELineArrowStyle::EMPTY_CIRCLE;
+		else if ("EMPTY_BOX" == sTailStyle)
+			m_eLineTail = bTailFill ? ELineArrowStyle::BOX : ELineArrowStyle::EMPTY_BOX;
+		else
+			m_eLineTail = ELineArrowStyle::NORMAL;
+	}
+	else if ("hc:fillBrush" == sNodeName)
+		m_pFill = new CFill(oReader);
+	else if ("hp:drawText" == sNodeName)
+	{
+		m_nMaxTxtWidth = oReader.GetAttributeInt("lastWidth");
+
+		WHILE_READ_NEXT_NODE_WITH_DEPTH_AND_NAME(oReader, Child)
+		{
+			if ("hp:textMargin" == sNodeChildName)
+			{
+				START_READ_ATTRIBUTES(oReader)
+				{
+					if ("left" == sAttributeName)
+						m_shLeftSpace = oReader.GetInt();
+					else if ("right" == sAttributeName)
+						m_shRightSpace =  oReader.GetInt();
+					else if ("top" == sAttributeName)
+						m_shTopSpace =  oReader.GetInt();
+					else if ("bottom" == sAttributeName)
+						m_shBottomSpace =  oReader.GetInt();
+				}
+				END_READ_ATTRIBUTES(oReader)
+			}
+			else if ("hp:subList" == sNodeChildName)
+				ReadSubList(oReader, nVersion);
+		}
+		END_WHILE
+	}
+	else
+		CCtrlObjElement::ParseChildren(oReader, nVersion);
+}
+
 void CCtrlGeneralShape::InitData()
 {
 	m_eLineStyle = ELineStyle2::NONE;
 	m_pFill = nullptr;
 }
 
-void CCtrlGeneralShape::ReadSubList(CXMLNode& oNode, int nVersion)
+void CCtrlGeneralShape::ReadSubList(CXMLReader& oReader, int nVersion)
 {
-	m_eTextVerAlign = GetVertAlign(oNode.ReadAttributeInt(L"vertAlign"));
+	m_eTextVerAlign = GetVertAlign(oReader.GetAttributeInt("vertAlign"));
 
-	std::vector<CXMLNode> arChilds{oNode.GetChilds()};
+	// CHWPPargraph* pLatestParagraph = nullptr;
 
-	for (unsigned int unIndex = 0; unIndex < arChilds.size(); ++unIndex)
+	WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hp:p")
 	{
-		CHWPPargraph* pLatestParagraph = nullptr;
+		CHWPPargraph* pParagraph = new CHWPPargraph(oReader, nVersion);
 
-		if (L"hp:p" == arChilds[unIndex].GetName())
-		{
-			CHWPPargraph* pParagraph = new CHWPPargraph(arChilds[unIndex], nVersion);
+		if (nullptr == pParagraph)
+			continue;
 
-			if (nullptr == pParagraph)
-				continue;
+		m_arParas.push_back(pParagraph);
+		// pLatestParagraph = pParagraph;
 
-			m_arParas.push_back(pParagraph);
-			pLatestParagraph = pParagraph;
-		}
-
-		if (nullptr != pLatestParagraph && 0 != pLatestParagraph->GetCountCtrls() && ECtrlObjectType::ParaText == pLatestParagraph->GetCtrls().back()->GetCtrlType() && unIndex < arChilds.size() - 1)
-			pLatestParagraph->AddCtrl(new CCtrlCharacter(L"   _", ECtrlCharType::PARAGRAPH_BREAK));
+		// if (nullptr != pLatestParagraph && 0 != pLatestParagraph->GetCountCtrls() && ECtrlObjectType::ParaText == pLatestParagraph->GetCtrls().back()->GetCtrlType())
+		// 	pLatestParagraph->AddCtrl(new CCtrlCharacter(L"   _", ECtrlCharType::PARAGRAPH_BREAK));
 	}
+	END_WHILE
 }
 
 void CCtrlGeneralShape::SetParent(CHWPPargraph* pParent)

HwpFile/HwpDoc/Paragraph/CtrlGeneralShape.h

@@ -53,18 +53,20 @@ class CCtrlGeneralShape : public CCtrlObjElement
 	friend class CCtrlShapePolygon;
 	friend class CCtrlShapeRect;
 
-	void ReadSubList(CXMLNode& oNode, int nVersion);
+	void ReadSubList(CXMLReader& oReader, int nVersion);
 public:
 	CCtrlGeneralShape();
 	CCtrlGeneralShape(const HWP_STRING& sCtrlID);
 	CCtrlGeneralShape(const CCtrlGeneralShape& oGeneralShape);
 	CCtrlGeneralShape(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlGeneralShape(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlGeneralShape(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 	virtual ~CCtrlGeneralShape();
 
 	ECtrlObjectType GetCtrlType() const override;
 	virtual EShapeType GetShapeType() const;
 
+	void ParseChildren(CXMLReader& oReader, int nVersion);
+
 	void SetParent(CHWPPargraph* pParent);
 	CHWPPargraph* GetParent();
 

HwpFile/HwpDoc/Paragraph/CtrlHeadFoot.cpp

@@ -24,23 +24,33 @@ CCtrlHeadFoot::CCtrlHeadFoot(const HWP_STRING& sCtrlID, int nSize, CHWPStream& o
 	oBuffer.ReadInt(m_nSerialInSec);
 }
 
-CCtrlHeadFoot::CCtrlHeadFoot(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
+CCtrlHeadFoot::CCtrlHeadFoot(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
 	: CCtrl(sCtrlID)
 {
 	m_bIsHeader = L"daeh" == sCtrlID;
 
-	m_eWhichPage = GetPageRange(oNode.GetAttributeInt(L"applyPageType"));
+	m_eWhichPage = GetPageRange(oReader.GetAttributeInt("applyPageType"));
 
-	for (CXMLNode& oChild : oNode.GetChilds(L"hp:subList"))
+	WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hp:subList")
 	{
-		m_chRefLevelNum = (HWP_BYTE)oChild.GetAttributeInt(L"hasNumRef");
-		m_chRefLevelText = (HWP_BYTE)oChild.GetAttributeInt(L"hasTextRef");
-		m_nTextHeight = oChild.GetAttributeInt(L"textHeight");
-		m_nTextWidth = oChild.GetAttributeInt(L"textWidth");
+		START_READ_ATTRIBUTES(oReader)
+		{
+			if ("hasNumRef" == sAttributeName)
+				m_chRefLevelNum = (HWP_BYTE)oReader.GetInt();
+			else if ("hasTextRef" == sAttributeName)
+				m_chRefLevelText = (HWP_BYTE)oReader.GetInt();
+			else if ("textHeight" == sAttributeName)
+				m_nTextHeight = oReader.GetInt();
+			else if ("textWidth" == sAttributeName)
+				m_nTextWidth = oReader.GetInt();
+		}
+		END_READ_ATTRIBUTES(oReader)
 
-		for (CXMLNode& oGrandChild : oChild.GetChilds(L"hp:p"))
-			m_arParas.push_back(new CHWPPargraph(oGrandChild, nVersion));
+		WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Child, "hp:p")
+			m_arParas.push_back(new CHWPPargraph(oReader, nVersion));
+		END_WHILE
 	}
+	END_WHILE
 
 	m_bFullFilled = true;
 }

HwpFile/HwpDoc/Paragraph/CtrlHeadFoot.h

@@ -31,7 +31,7 @@ class CCtrlHeadFoot : public CCtrl
 public:
 	CCtrlHeadFoot(const HWP_STRING& sCtrlID);
 	CCtrlHeadFoot(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion, bool bIsHeader);
-	CCtrlHeadFoot(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlHeadFoot(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	ECtrlObjectType GetCtrlType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlNewNumber.cpp

@@ -20,13 +20,20 @@ CCtrlNewNumber::CCtrlNewNumber(const HWP_STRING& sCtrlID, int nSize, CHWPStream&
 	m_bFullFilled = true;
 }
 
-CCtrlNewNumber::CCtrlNewNumber(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
+CCtrlNewNumber::CCtrlNewNumber(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
 	: CCtrl(sCtrlID)
 {
-	m_shNum = oNode.GetAttributeInt(L"num");
-	m_eNumType = ::HWP::GetNumType(oNode.GetAttribute(L"numType"));
-	//TODO:: проверить данный момент
-	m_eNumShape = GetNumberShape2(oNode.GetAttributeInt(L"autoNumFormat"));
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("num" == sAttributeName)
+			m_shNum = oReader.GetInt();
+		else if ("numType" == sAttributeName)
+			m_eNumType = ::HWP::GetNumType(oReader.GetText());
+		//TODO:: проверить данный момент
+		else if ("autoNumFormat" == sAttributeName)
+			m_eNumShape = GetNumberShape2(oReader.GetInt());
+	}
+	END_READ_ATTRIBUTES(oReader)
 
 	m_bFullFilled = true;
 }

HwpFile/HwpDoc/Paragraph/CtrlNewNumber.h

@@ -13,7 +13,7 @@ class CCtrlNewNumber : public CCtrl
 public:
 	CCtrlNewNumber(const HWP_STRING& sCtrlID);
 	CCtrlNewNumber(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlNewNumber(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlNewNumber(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	ECtrlObjectType GetCtrlType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlNote.cpp

@@ -16,14 +16,14 @@ CCtrlNote::CCtrlNote(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer,
 	m_bFullFilled = true;
 }
 
-CCtrlNote::CCtrlNote(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
+CCtrlNote::CCtrlNote(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
 	: CCtrl(sCtrlID)
 {
-	for (CXMLNode& oChild : oNode.GetChilds(L"hp:subList"))
-	{
-		for (CXMLNode& oGrandChild : oChild.GetChilds(L"hp:p"))
-			m_arParas.push_back(new CHWPPargraph(oGrandChild, nVersion));
-	}
+	WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hp:subList")
+		WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Child, "hp:p")
+			m_arParas.push_back(new CHWPPargraph(oReader, nVersion));
+		END_WHILE
+	END_WHILE
 
 	m_bFullFilled = true;
 }

HwpFile/HwpDoc/Paragraph/CtrlNote.h

@@ -14,7 +14,7 @@ public:
 	CCtrlNote();
 	CCtrlNote(const HWP_STRING& sCtrlID);
 	CCtrlNote(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlNote(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlNote(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	ECtrlObjectType GetCtrlType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlObjElement.cpp

@@ -47,66 +47,115 @@ CCtrlObjElement::CCtrlObjElement(const HWP_STRING& sCtrlID, int nSize, CHWPStrea
 	: CCtrlCommon(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-TMatrix ReadMatrix(CXMLNode& oNode)
+TMatrix ReadMatrix(CXMLReader& oReader)
 {
-	return TMatrix
+	TMatrix oMatrix;
+
+	START_READ_ATTRIBUTES(oReader)
 	{
-		oNode.GetAttributeDouble(L"e1", 1.),
-		oNode.GetAttributeDouble(L"e2"),
-		oNode.GetAttributeDouble(L"e4"),
-		oNode.GetAttributeDouble(L"e5", 1.),
-		oNode.GetAttributeDouble(L"e3"),
-		oNode.GetAttributeDouble(L"e6"),
-	};
+		if ("e1" == sAttributeName)
+			oMatrix.m_dM11 = oReader.GetDouble();
+		else if ("e2" == sAttributeName)
+			oMatrix.m_dM12 = oReader.GetDouble();
+		else if ("e3" == sAttributeName)
+			oMatrix.m_dDX = oReader.GetDouble();
+		else if ("e4" == sAttributeName)
+			oMatrix.m_dM21 = oReader.GetDouble();
+		else if ("e5" == sAttributeName)
+			oMatrix.m_dM22 = oReader.GetDouble();
+		else if ("e6" == sAttributeName)
+			oMatrix.m_dDY = oReader.GetDouble();
+	}
+	END_READ_ATTRIBUTES(oReader)
+
+	return oMatrix;
 }
 
-CCtrlObjElement::CCtrlObjElement(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlCommon(sCtrlID, oNode, nVersion)
+CCtrlObjElement::CCtrlObjElement(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlCommon(sCtrlID, oReader, nVersion)
 {
-	m_shNGrp = oNode.GetAttributeInt(L"groupLevel");
+	m_shNGrp = oReader.GetAttributeInt("groupLevel");
+}
 
-	for (CXMLNode& oChild : oNode.GetChilds())
+void CCtrlObjElement::ParseChildren(CXMLReader& oReader, int nVersion)
+{
+	const std::string sNodeName{oReader.GetName()};
+
+	if ("hp:offset" == sNodeName)
 	{
-		if (L"hp:offset" == oChild.GetName())
+		START_READ_ATTRIBUTES(oReader)
 		{
-			m_nXGrpOffset = oChild.GetAttributeInt(L"x");
-			m_nYGrpOffset = oChild.GetAttributeInt(L"y");
-		}
-		else if (L"hp:orgSz" == oChild.GetName())
-		{
-			m_nOrgWidth  = oChild.GetAttributeInt(L"width");
-			m_nOrgHeight = oChild.GetAttributeInt(L"height");
-		}
-		else if (L"hp:curSz" == oChild.GetName())
-		{
-			m_nCurWidth  = oChild.GetAttributeInt(L"width");
-			m_nCurHeight = oChild.GetAttributeInt(L"height");
-		}
-		else if (L"hp:flip" == oChild.GetName())
-		{
-			m_bHorzFlip = oChild.GetAttributeBool(L"horizontal");
-			m_bVerFlip  = oChild.GetAttributeBool(L"vertical");
-		}
-		else if (L"hp:rotationInfo" == oChild.GetName())
-		{
-			m_shRotat = oChild.GetAttributeInt(L"angle");
-			m_nXCenter = oChild.GetAttributeInt(L"centerX");
-			m_nYCenter = oChild.GetAttributeInt(L"centerY");
-		}
-		else if (L"hp:renderingInfo" == oChild.GetName())
-		{
-			for (CXMLNode& oGrandChild : oChild.GetChilds())
-			{
-				// Сначала идёт 1 hc:transMatrix, а после попарно идут hc:scaMatrix с hc:rotMatrix
-				if (L"hc:transMatrix" == oGrandChild.GetName())
-					m_arMatrixs.push_back(ReadMatrix(oGrandChild));
-				else if (L"hc:scaMatrix" == oGrandChild.GetName())
-					m_arMatrixs.push_back(ReadMatrix(oGrandChild));
-				else if (L"hc:rotMatrix" == oGrandChild.GetName())
-					m_arMatrixs.push_back(ReadMatrix(oGrandChild));
-			}
+			if ("x" == sAttributeName)
+				m_nXGrpOffset = oReader.GetInt();
+			else if ("y" == sAttributeName)
+				m_nYGrpOffset = oReader.GetInt();
 		}
+		END_READ_ATTRIBUTES(oReader)
 	}
+
+	else if ("hp:orgSz" == sNodeName)
+	{
+		START_READ_ATTRIBUTES(oReader)
+		{
+			if ("width" == sAttributeName)
+				m_nOrgWidth = oReader.GetInt();
+			else if ("height" == sAttributeName)
+				m_nOrgHeight = oReader.GetInt();
+		}
+		END_READ_ATTRIBUTES(oReader)
+	}
+	else if ("hp:curSz" == sNodeName)
+	{
+		START_READ_ATTRIBUTES(oReader)
+		{
+			if ("width" == sAttributeName)
+				m_nCurWidth = oReader.GetInt();
+			else if ("height" == sAttributeName)
+				m_nCurHeight = oReader.GetInt();
+		}
+		END_READ_ATTRIBUTES(oReader)
+	}
+	else if ("hp:flip" == sNodeName)
+	{
+		START_READ_ATTRIBUTES(oReader)
+		{
+			if ("horizontal" == sAttributeName)
+				m_bHorzFlip = oReader.GetBool();
+			else if ("vertical" == sAttributeName)
+				m_bVerFlip = oReader.GetBool();
+		}
+		END_READ_ATTRIBUTES(oReader)
+	}
+	else if ("hp:rotationInfo" == sNodeName)
+	{
+		START_READ_ATTRIBUTES(oReader)
+		{
+			if ("angle" == sAttributeName)
+				m_shRotat = oReader.GetInt();
+			else if ("centerX" == sAttributeName)
+				m_nXCenter = oReader.GetInt();
+			else if ("centerY" == sAttributeName)
+				m_nYCenter = oReader.GetInt();
+		}
+		END_READ_ATTRIBUTES(oReader)
+	}
+	else if ("hp:renderingInfo" == sNodeName)
+	{
+		WHILE_READ_NEXT_NODE_WITH_DEPTH_AND_NAME(oReader, Child)
+		{
+			// Сначала идёт 1 hc:transMatrix, а после попарно идут hc:scaMatrix с hc:rotMatrix
+
+			if ("hc:transMatrix" != sNodeChildName &&
+				"hc:scaMatrix"   != sNodeChildName &&
+				"hc:rotMatrix"   != sNodeChildName)
+				continue;
+
+			m_arMatrixs.push_back(ReadMatrix(oReader));
+		}
+		END_WHILE
+	}
+	else
+		CCtrlCommon::ParseChildren(oReader, nVersion);
 }
 
 int CCtrlObjElement::GetCurWidth() const
@@ -145,9 +194,14 @@ int CCtrlObjElement::GetFinalHeight() const
 	return CCtrlCommon::GetHeight();
 }
 
+short CCtrlObjElement::GetGroupLevel() const
+{
+	return m_shNGrp;
+}
+
 TMatrix CCtrlObjElement::GetFinalMatrix() const
 {
-	if (m_arMatrixs.empty() || 0 == m_shNGrp)
+	if (m_arMatrixs.empty())
 		return TMatrix();
 
 	TMatrix oMatrix{m_arMatrixs.front()};

HwpFile/HwpDoc/Paragraph/CtrlObjElement.h

@@ -44,7 +44,9 @@ public:
 	CCtrlObjElement(const HWP_STRING& sCtrlID);
 	CCtrlObjElement(const CCtrlObjElement& oObjElement);
 	CCtrlObjElement(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlObjElement(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlObjElement(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
+
+	void ParseChildren(CXMLReader& oReader, int nVersion);
 
 	int GetCurWidth() const;
 	int GetCurHeight() const;
@@ -55,6 +57,8 @@ public:
 	int GetFinalWidth() const;
 	int GetFinalHeight() const;
 
+	short GetGroupLevel() const;
+
 	TMatrix GetFinalMatrix() const;
 
 	bool HorzFlip() const;

HwpFile/HwpDoc/Paragraph/CtrlPageNumPos.cpp

@@ -54,13 +54,20 @@ CCtrlPageNumPos::CCtrlPageNumPos(const HWP_STRING& sCtrlID, int nSize, CHWPStrea
 	oBuffer.ReadString(m_sConstantDash, 2, EStringCharacter::UTF16);
 }
 
-CCtrlPageNumPos::CCtrlPageNumPos(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
+CCtrlPageNumPos::CCtrlPageNumPos(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
 	: CCtrl(sCtrlID)
 {
-	m_ePos = GetNumPos(oNode.GetAttribute(L"pos"));
-	m_eNumShape = GetNumberShape2(oNode.GetAttributeInt(L"formatType"));
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("pos" == sAttributeName)
+			m_ePos = GetNumPos(oReader.GetText());
+		else if ("formatType" == sAttributeName)
+			m_eNumShape = GetNumberShape2(oReader.GetInt());
+		else if ("sideChar" == sAttributeName)
+			m_sPostfix = oReader.GetText();
+	}
+	END_READ_ATTRIBUTES(oReader)
 
-	m_sPostfix = oNode.GetAttribute(L"sideChar");
 	m_sPrefix  = m_sPostfix;
 }
 

HwpFile/HwpDoc/Paragraph/CtrlPageNumPos.h

@@ -4,7 +4,7 @@
 #include "Ctrl.h"
 #include "../HWPStream.h"
 #include "../HWPElements/HwpRecordTypes.h"
-#include "../Common/XMLNode.h"
+#include "../Common/XMLReader.h"
 
 namespace HWP
 {
@@ -34,7 +34,7 @@ class CCtrlPageNumPos : public CCtrl
 public:
 	CCtrlPageNumPos(const HWP_STRING& sCtrlID);
 	CCtrlPageNumPos(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlPageNumPos(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlPageNumPos(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	ENumPos GetPos() const;
 

HwpFile/HwpDoc/Paragraph/CtrlSectionDef.cpp

@@ -40,100 +40,140 @@ CCtrlSectionDef::CCtrlSectionDef(const HWP_STRING& sCtrlID, int nSize, CHWPStrea
 	m_bFullFilled = true;
 }
 
-CCtrlSectionDef::CCtrlSectionDef(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
+CCtrlSectionDef::CCtrlSectionDef(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
 	: CCtrl(sCtrlID), m_pPage(nullptr)
 {
-	HWP_STRING sType = oNode.GetAttribute(L"textDirection");
+	std::string sType;
 
-	if (L"HORIZONTAL" == sType)
-		m_chTextDirection = 0;
-	else if (L"VERTICAL" == sType)
-		m_chTextDirection = 1;
-
-	m_shSpaceColumns = oNode.GetAttributeInt(L"spaceColumns");
-	m_nTabStop = oNode.GetAttributeInt(L"tabStop");
-	m_nOutlineNumberingID = oNode.GetAttributeInt(L"outlineShapeIDRef");
-
-	for (CXMLNode& oChild : oNode.GetChilds())
+	START_READ_ATTRIBUTES(oReader)
 	{
-		if (L"hp:startNum" == oChild.GetName())
+		if ("textDirection" == sAttributeName)
 		{
-			sType = oChild.GetAttribute(L"pageStartsOn");
+			sType = oReader.GetTextA();
 
-			if (L"BOTH" == sType)
-				m_chPageStartOn = 0;
-			else if (L"EVEN" == sType)
-				m_chPageStartOn = 1;
-			else if (L"ODD" == sType)
-				m_chPageStartOn = 2;
-
-			m_shPageNum = oChild.GetAttributeInt(L"page");
-			m_shFigure = oChild.GetAttributeInt(L"pic");
-			m_shTable = oChild.GetAttributeInt(L"tbl");
-			m_shEquation = oChild.GetAttributeInt(L"equation");
+			if ("HORIZONTAL" == sType)
+				m_chTextDirection = 0;
+			else if ("VERTICAL" == sType)
+				m_chTextDirection = 1;
 		}
-		else if (L"hp:grid" == oChild.GetName())
+		else if ("spaceColumns" == sAttributeName)
+			m_shSpaceColumns = oReader.GetInt();
+		else if ("tabStop" == sAttributeName)
+			m_nTabStop = oReader.GetInt();
+		else if ("outlineShapeIDRef" == sAttributeName)
+			m_nOutlineNumberingID = oReader.GetInt();
+	}
+	END_READ_ATTRIBUTES(oReader)
+
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
+	{
+		if ("hp:startNum" == sNodeName)
 		{
-			m_shLineGrid = oChild.GetAttributeInt(L"lineGrid");
-			m_shCharGrid = oChild.GetAttributeInt(L"charGrid");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("pageStartsOn" == sAttributeName)
+				{
+					sType = oReader.GetTextA();
+
+					if ("BOTH" == sType)
+						m_chPageStartOn = 0;
+					else if ("EVEN" == sType)
+						m_chPageStartOn = 1;
+					else if ("ODD" == sType)
+						m_chPageStartOn = 2;
+				}
+				else if ("page" == sAttributeName)
+					m_shPageNum = oReader.GetInt();
+				else if ("pic" == sAttributeName)
+					m_shFigure = oReader.GetInt();
+				else if ("tbl" == sAttributeName)
+					m_shTable = oReader.GetInt();
+				else if ("equation" == sAttributeName)
+					m_shEquation = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hp:visibility" == oChild.GetName())
+		else if ("hp:grid" == sNodeName)
 		{
-			m_bHideHeader = oChild.GetAttributeBool(L"hideFirstHeader");
-			m_bHideFooter = oChild.GetAttributeBool(L"hideFirstFooter");
-			m_bHideMasterPage = oChild.GetAttributeBool(L"hideFirstMasterPage");
-
-			sType = oChild.GetAttribute(L"border");
-
-			if (L"HIDE_FIRST" == sType)
+			START_READ_ATTRIBUTES(oReader)
 			{
-				m_bHideBorder = true;
-				m_bShowFirstBorder = false;
+				if ("lineGrid" == sAttributeName)
+					m_shLineGrid = oReader.GetInt();
+				else if ("charGrid" == sAttributeName)
+					m_shCharGrid = oReader.GetInt();
 			}
-			else if (L"SHOW_FIRST" == sType)
-			{
-				m_bHideBorder = true;
-				m_bShowFirstBorder = true;
-			}
-			else if (L"SHOW_ALL" == sType)
-			{
-				m_bHideBorder = false;
-				m_bShowFirstBorder = false;
-			}
-
-			sType = oChild.GetAttribute(L"fill");
-
-			if (L"HIDE_FIRST" == sType)
-			{
-				m_bHideFill = true;
-				m_bShowFirstFill = false;
-			}
-			else if (L"SHOW_FIRST" == sType)
-			{
-				m_bHideFill = true;
-				m_bShowFirstFill = true;
-			}
-			else if (L"SHOW_ALL" == sType)
-			{
-				m_bHideFill = false;
-				m_bShowFirstFill = false;
-			}
-
-			m_bHidePageNumPos = oChild.GetAttributeBool(L"hideFirstPageNum");
-			m_bHideEmptyLine = oChild.GetAttributeBool(L"hideFirstEmptyLine");
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hp:pagePr" == oChild.GetName())
-			m_pPage = new CPage(oChild);
-		else if (L"hp:footNotePr" == oChild.GetName() ||
-		         L"hp:endNotePr"  == oChild.GetName())
-			m_arNoteShapes.push_back(new CNoteShape(oChild, nVersion));
-		else if (L"hp:pageBorderFill" == oChild.GetName())
-			m_arBorderFills.push_back(new CPageBorderFill(oChild, nVersion));
-		else if (L"hp:masterPage" == oChild.GetName())
+		else if ("hp:visibility" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("hideFirstHeader" == sAttributeName)
+					m_bHideHeader = oReader.GetBool();
+				else if ("hideFirstFooter" == sAttributeName)
+					m_bHideFooter = oReader.GetBool();
+				else if ("hideFirstMasterPage" == sAttributeName)
+					m_bHideMasterPage = oReader.GetBool();
+				else if ("border" == sAttributeName)
+				{
+					sType = oReader.GetTextA();
+
+					if ("HIDE_FIRST" == sType)
+					{
+						m_bHideBorder = true;
+						m_bShowFirstBorder = false;
+					}
+					else if ("SHOW_FIRST" == sType)
+					{
+						m_bHideBorder = true;
+						m_bShowFirstBorder = true;
+					}
+					else if ("SHOW_ALL" == sType)
+					{
+						m_bHideBorder = false;
+						m_bShowFirstBorder = false;
+					}
+				}
+				else if ("fill" == sAttributeName)
+				{
+					sType = oReader.GetTextA();
+
+					if ("HIDE_FIRST" == sType)
+					{
+						m_bHideFill = true;
+						m_bShowFirstFill = false;
+					}
+					else if ("SHOW_FIRST" == sType)
+					{
+						m_bHideFill = true;
+						m_bShowFirstFill = true;
+					}
+					else if ("SHOW_ALL" == sType)
+					{
+						m_bHideFill = false;
+						m_bShowFirstFill = false;
+					}
+				}
+				else if ("hp:visibility" == sAttributeName)
+					m_bHidePageNumPos = oReader.GetBool();
+				else if ("hideFirstEmptyLine" == sAttributeName)
+					m_bHideEmptyLine = oReader.GetBool();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:pagePr" == sNodeName)
+			m_pPage = new CPage(oReader);
+		else if ("hp:footNotePr" == sNodeName ||
+		         "hp:endNotePr"  == sNodeName)
+			m_arNoteShapes.push_back(new CNoteShape(oReader, nVersion));
+		else if ("hp:pageBorderFill" == sNodeName)
+			m_arBorderFills.push_back(new CPageBorderFill(oReader, nVersion));
+		else if ("hp:masterPage" == sNodeName)
 		{
 			//TODO:: добавить реализацию
 		}
 	}
+	END_WHILE
 
 	m_bFullFilled = true;
 }

HwpFile/HwpDoc/Paragraph/CtrlSectionDef.h

@@ -45,7 +45,7 @@ class CCtrlSectionDef : public CCtrl
 public:
 	CCtrlSectionDef(const HWP_STRING& sCtrlID);
 	CCtrlSectionDef(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlSectionDef(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlSectionDef(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 	~CCtrlSectionDef();
 
 	ECtrlObjectType GetCtrlType() const override;

HwpFile/HwpDoc/Paragraph/CtrlShapeArc.cpp

@@ -17,29 +17,50 @@ CCtrlShapeArc::CCtrlShapeArc(const HWP_STRING& sCtrlID, int nSize, CHWPStream& o
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlShapeArc::CCtrlShapeArc(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlShapeArc::CCtrlShapeArc(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	m_eType = GetArcType(oNode.GetAttributeInt(L"type"));
+	m_eType = GetArcType(oReader.GetAttributeInt("type"));
 
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hp:center" == oChild.GetName())
+		if ("hp:center" == sNodeName)
 		{
-			m_nCenterX = oChild.GetAttributeInt(L"x");
-			m_nCenterY = oChild.GetAttributeInt(L"y");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nCenterX = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nCenterY = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hp:ax1" == oChild.GetName())
+		else if ("hp:ax1" == sNodeName)
 		{
-			m_nAxixX1 = oChild.GetAttributeInt(L"x");
-			m_nAxixY1 = oChild.GetAttributeInt(L"y");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nAxixX1 = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nAxixY1 = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hp:ax2" == oChild.GetName())
+		else if ("hp:ax2" == sNodeName)
 		{
-			m_nAxixX2 = oChild.GetAttributeInt(L"x");
-			m_nAxixY2 = oChild.GetAttributeInt(L"y");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nAxixX2 = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nAxixY2 = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
+		else
+			CCtrlGeneralShape::ParseChildren(oReader, nVersion);
 	}
+	END_WHILE
 }
 
 EShapeType CCtrlShapeArc::GetShapeType() const

HwpFile/HwpDoc/Paragraph/CtrlShapeArc.h

@@ -20,7 +20,7 @@ public:
 	CCtrlShapeArc(const HWP_STRING& sCtrlID);
 	CCtrlShapeArc(const CCtrlGeneralShape& oShape);
 	CCtrlShapeArc(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlShapeArc(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlShapeArc(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	EShapeType GetShapeType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlShapeConnectLine.cpp

@@ -25,28 +25,47 @@ CCtrlShapeConnectLine::CCtrlShapeConnectLine(const HWP_STRING& sCtrlID, int nSiz
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlShapeConnectLine::CCtrlShapeConnectLine(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlShapeConnectLine::CCtrlShapeConnectLine(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	m_eType = GetConnectLineType(oNode.GetAttributeInt(L"type"));
+	m_eType = GetConnectLineType(oReader.GetAttributeInt("type"));
 
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hp:startPt" == oChild.GetName())
+		if ("hp:startPt" == sNodeName)
 		{
-			m_oStartPt.m_nX = oChild.GetAttributeInt(L"x");
-			m_oStartPt.m_nY = oChild.GetAttributeInt(L"y");
-			m_oStartPt.m_shSubjectIDRef = oChild.GetAttributeInt(L"subjectIDRef");
-			m_oStartPt.m_shSubjectIdx = oChild.GetAttributeInt(L"subjectIdx");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_oStartPt.m_nX = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_oStartPt.m_nY = oReader.GetInt();
+				else if ("subjectIDRef" == sAttributeName)
+					m_oStartPt.m_shSubjectIDRef = oReader.GetInt();
+				else if ("subjectIdx" == sAttributeName)
+					m_oStartPt.m_shSubjectIdx = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hp:endPt" == oChild.GetName())
+		else if ("hp:endPt" == sNodeName)
 		{
-			m_oEndPt.m_nX = oChild.GetAttributeInt(L"x");
-			m_oEndPt.m_nY = oChild.GetAttributeInt(L"y");
-			m_oEndPt.m_shSubjectIDRef = oChild.GetAttributeInt(L"subjectIDRef");
-			m_oEndPt.m_shSubjectIdx = oChild.GetAttributeInt(L"subjectIdx");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_oEndPt.m_nX = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_oEndPt.m_nY = oReader.GetInt();
+				else if ("subjectIDRef" == sAttributeName)
+					m_oEndPt.m_shSubjectIDRef = oReader.GetInt();
+				else if ("subjectIdx" == sAttributeName)
+					m_oEndPt.m_shSubjectIdx = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
+		else
+			CCtrlGeneralShape::ParseChildren(oReader, nVersion);
 	}
+	END_WHILE
 }
 
 EShapeType CCtrlShapeConnectLine::GetShapeType() const

HwpFile/HwpDoc/Paragraph/CtrlShapeConnectLine.h

@@ -33,7 +33,7 @@ class CCtrlShapeConnectLine : public CCtrlGeneralShape
 	TConnectPoint m_oEndPt;
 public:
 	CCtrlShapeConnectLine(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlShapeConnectLine(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlShapeConnectLine(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	EShapeType GetShapeType() const override;
 };

HwpFile/HwpDoc/Paragraph/CtrlShapeCurve.cpp

@@ -17,34 +17,52 @@ CCtrlShapeCurve::CCtrlShapeCurve(const HWP_STRING& sCtrlID, int nSize, CHWPStrea
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlShapeCurve::CCtrlShapeCurve(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlShapeCurve::CCtrlShapeCurve(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	std::vector<CXMLNode> arChilds{oNode.GetChilds(L"hp:seg")};
+	// bool bReadedType
+	TPoint oPoint1{0, 0}, oPoint2{0, 0};
+	HWP_BYTE chSegmentType = 0;
 
-	m_arPoints.resize(arChilds.size() + 1);
-	m_arSegmentType.resize(arChilds.size());
-
-	HWP_STRING sType;
-
-	for (unsigned int unIndex = 0; unIndex < arChilds.size(); ++unIndex)
+	WHILE_READ_NEXT_NODE(oReader)
 	{
-		sType = arChilds[unIndex].GetAttribute(L"type");
-
-		if (L"CURVE" == sType)
-			m_arSegmentType[unIndex] = 1;
-		else if (L"LINE" == sType)
-			m_arSegmentType[unIndex] = 0;
-
-		m_arPoints[unIndex].m_nX = arChilds[unIndex].GetAttributeInt(L"x1");
-		m_arPoints[unIndex].m_nY = arChilds[unIndex].GetAttributeInt(L"y1");
-
-		if (unIndex == arChilds.size() - 1)
+		if ("hp:seg" == oReader.GetName())
 		{
-			m_arPoints[unIndex + 1].m_nX = arChilds[unIndex].GetAttributeInt(L"x2");
-			m_arPoints[unIndex + 1].m_nY = arChilds[unIndex].GetAttributeInt(L"y2");
+			chSegmentType = 0;
+			oPoint1 = {0, 0};
+			oPoint2 = {0, 0};
+
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("type" == sAttributeName)
+				{
+					const std::string sType{oReader.GetTextA()};
+
+					if ("CURVE" == sType)
+						chSegmentType = 1;
+					else if ("LINE" == sType)
+						chSegmentType = 0;
+				}
+				else if ("x1" == sAttributeName)
+					oPoint1.m_nX = oReader.GetInt();
+				else if ("y1" == sAttributeName)
+					oPoint1.m_nY = oReader.GetInt();
+				else if ("x2" == sAttributeName)
+					oPoint2.m_nX = oReader.GetInt();
+				else if ("y2" == sAttributeName)
+					oPoint2.m_nY = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+
+			m_arSegmentType.push_back(chSegmentType);
+			m_arPoints.push_back(oPoint1);
 		}
+		else
+			CCtrlGeneralShape::ParseChildren(oReader, nVersion);
 	}
+	END_WHILE
+
+	m_arPoints.push_back(oPoint2);
 }
 
 EShapeType CCtrlShapeCurve::GetShapeType() const

HwpFile/HwpDoc/Paragraph/CtrlShapeCurve.h

@@ -16,7 +16,7 @@ public:
 	CCtrlShapeCurve(const HWP_STRING& sCtrlID);
 	CCtrlShapeCurve(const CCtrlGeneralShape& oShape);
 	CCtrlShapeCurve(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlShapeCurve(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlShapeCurve(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	EShapeType GetShapeType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlShapeEllipse.cpp

@@ -34,51 +34,103 @@ CCtrlShapeEllipse::CCtrlShapeEllipse(const HWP_STRING& sCtrlID, int nSize, CHWPS
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlShapeEllipse::CCtrlShapeEllipse(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlShapeEllipse::CCtrlShapeEllipse(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	m_bIntervalDirty = oNode.GetAttributeBool(L"intervalDirty");
-	m_bHasArcProperty = oNode.GetAttributeBool(L"hasArcPr");
-	m_eArcType = GetArcType(oNode.GetAttribute(L"arcType"));
-
-	for (CXMLNode& oChild : oNode.GetChilds())
+	START_READ_ATTRIBUTES(oReader)
 	{
-		if (L"hc:center" == oChild.GetName())
-		{
-			m_nCenterX = oChild.GetAttributeInt(L"x");
-			m_nCenterY = oChild.GetAttributeInt(L"y");
-		}
-		else if (L"hp:ax1" == oChild.GetName())
-		{
-			m_nAxixX1 = oChild.GetAttributeInt(L"x");
-			m_nAxixY1 = oChild.GetAttributeInt(L"y");
-		}
-		else if (L"hp:ax2" == oChild.GetName())
-		{
-			m_nAxixX2 = oChild.GetAttributeInt(L"x");
-			m_nAxixY2 = oChild.GetAttributeInt(L"y");
-		}
-		else if (L"hc:start1" == oChild.GetName())
-		{
-			m_nStartX1 = oChild.GetAttributeInt(L"x");
-			m_nStartY1 = oChild.GetAttributeInt(L"y");
-		}
-		else if (L"hc:start2" == oChild.GetName())
-		{
-			m_nStartX2 = oChild.GetAttributeInt(L"x");
-			m_nStartY2 = oChild.GetAttributeInt(L"y");
-		}
-		else if (L"hc:end1" == oChild.GetName())
-		{
-			m_nEndX1 = oChild.GetAttributeInt(L"x");
-			m_nEndY1 = oChild.GetAttributeInt(L"y");
-		}
-		else if (L"hc:end2" == oChild.GetName())
-		{
-			m_nEndX2 = oChild.GetAttributeInt(L"x");
-			m_nEndY2 = oChild.GetAttributeInt(L"y");
-		}
+		if ("intervalDirty" == sAttributeName)
+			m_bIntervalDirty = oReader.GetBool();
+		else if ("hasArcPr" == sAttributeName)
+			m_bHasArcProperty = oReader.GetBool();
+		else if ("arcType" == sAttributeName)
+			m_eArcType = GetArcType(oReader.GetText());
 	}
+	END_READ_ATTRIBUTES(oReader)
+
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
+	{
+		if ("hc:center" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nCenterX = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nCenterY = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:ax1" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nAxixX1 = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nAxixY1 = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:ax2" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nAxixX2 = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nAxixY2 = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:start1" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nStartX1 = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nStartY1 = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:start2" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nStartX2 = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nStartY2 = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:end1" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nEndX1 = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nEndY1 = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:end2" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nEndX2 = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nEndY2 = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else
+			CCtrlGeneralShape::ParseChildren(oReader, nVersion);
+	}
+	END_WHILE
 }
 
 EShapeType CCtrlShapeEllipse::GetShapeType() const

HwpFile/HwpDoc/Paragraph/CtrlShapeEllipse.h

@@ -39,7 +39,7 @@ public:
 	CCtrlShapeEllipse(const HWP_STRING& sCtrlID);
 	CCtrlShapeEllipse(const CCtrlGeneralShape& oShape);
 	CCtrlShapeEllipse(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlShapeEllipse(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlShapeEllipse(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	EShapeType GetShapeType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlShapeLine.cpp

@@ -17,24 +17,39 @@ CCtrlShapeLine::CCtrlShapeLine(const HWP_STRING& sCtrlID, int nSize, CHWPStream&
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlShapeLine::CCtrlShapeLine(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlShapeLine::CCtrlShapeLine(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	m_shAttr = (short)oNode.GetAttributeBool(L"isReverseHV");
+	m_shAttr = (short)oReader.GetAttributeBool("isReverseHV");
 
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hc:startPt" == oChild.GetName())
+		if ("hc:startPt" == sNodeName)
 		{
-			m_nStartX = oChild.GetAttributeInt(L"x");
-			m_nStartY = oChild.GetAttributeInt(L"y");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nStartX = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nStartY = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hc:endPt" == oChild.GetName())
+		else if ("hc:endPt" == sNodeName)
 		{
-			m_nEndX = oChild.GetAttributeInt(L"x");
-			m_nEndY = oChild.GetAttributeInt(L"y");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nEndX = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nEndY = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
+		else
+			CCtrlGeneralShape::ParseChildren(oReader, nVersion);
 	}
+	END_WHILE
 }
 
 EShapeType CCtrlShapeLine::GetShapeType() const

HwpFile/HwpDoc/Paragraph/CtrlShapeLine.h

@@ -17,7 +17,7 @@ public:
 	CCtrlShapeLine(const HWP_STRING& sCtrlID);
 	CCtrlShapeLine(const CCtrlGeneralShape& oShape);
 	CCtrlShapeLine(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlShapeLine(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlShapeLine(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	EShapeType GetShapeType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlShapeOle.cpp

@@ -17,16 +17,28 @@ CCtrlShapeOle::CCtrlShapeOle(const HWP_STRING& sCtrlID, int nSize, CHWPStream& o
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlShapeOle::CCtrlShapeOle(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlShapeOle::CCtrlShapeOle(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	m_sBinDataID = oNode.GetAttribute(L"binaryItemIDRef");
+	m_sBinDataID = oReader.GetAttribute("binaryItemIDRef");
 
-	for (CXMLNode& oChild : oNode.GetChilds(L"hc:extent"))
+	WHILE_READ_NEXT_NODE(oReader)
 	{
-		m_nExtentX = oChild.GetAttributeInt(L"x");
-		m_nExtentY = oChild.GetAttributeInt(L"y");
+		if ("hc:extent" == oReader.GetName())
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_nExtentX = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_nExtentY = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else
+			CCtrlGeneralShape::ParseChildren(oReader, nVersion);
 	}
+	END_WHILE
 }
 
 EShapeType CCtrlShapeOle::GetShapeType() const

HwpFile/HwpDoc/Paragraph/CtrlShapeOle.h

@@ -19,7 +19,7 @@ public:
 	CCtrlShapeOle(const HWP_STRING& sCtrlID);
 	CCtrlShapeOle(const CCtrlGeneralShape& oShape);
 	CCtrlShapeOle(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlShapeOle(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlShapeOle(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	EShapeType GetShapeType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlShapePic.cpp

@@ -25,7 +25,7 @@ CPicColor::CPicColor(CHWPStream& oBuffer, int nOff, int nSize)
 	m_nSize = nSize;
 }
 
-CPicColor::CPicColor(CXMLNode& oNode)
+CPicColor::CPicColor(CXMLReader& oReader)
 {
 	//TODO:: проверить
 	m_nType = 0;
@@ -65,33 +65,54 @@ CShadow::CShadow(int nTypeNum, CHWPStream& oBuffer, int nOff, int nSize)
 	m_nSize = oBuffer.GetDistanceToLastPos(true);
 }
 
-CShadow::CShadow(CXMLNode& oNode, int nVersion)
+CShadow::CShadow(CXMLReader& oReader, int nVersion)
 	: CPicEffect(EPicEffectType::SHADOW), m_pColor(nullptr)
 {
-	m_nStyle = oNode.GetAttributeInt(L"style");
-	m_nTransparency = oNode.GetAttributeInt(L"alpha");
-	m_nBlur = oNode.GetAttributeInt(L"radius");
-	m_nDirection = oNode.GetAttributeInt(L"direction");
-	m_nDistance = oNode.GetAttributeInt(L"distance");
-	m_nRotation = (int)oNode.GetAttributeBool(L"rotationStyle");
-
-	for (CXMLNode& oChild : oNode.GetChilds())
+	START_READ_ATTRIBUTES(oReader)
 	{
-		if (L"hp:skew" == oChild.GetName())
-		{
-			m_fAngleX = oChild.GetAttributeDouble(L"x");
-			m_fAngleY = oChild.GetAttributeDouble(L"y");
-		}
-		else if (L"hp:scale" == oChild.GetName())
-		{
-			m_fMagnifyX = oChild.GetAttributeDouble(L"x");
-			m_fMagnifyY = oChild.GetAttributeDouble(L"y");
-		}
-		else if (L"hp:effectsColor" == oChild.GetName())
-		{
-			m_pColor = new CPicColor(oChild);
-		}
+		if ("style" == sAttributeName)
+			m_nStyle = oReader.GetInt();
+		else if ("alpha" == sAttributeName)
+			m_nTransparency = oReader.GetInt();
+		else if ("radius" == sAttributeName)
+			m_nBlur = oReader.GetInt();
+		else if ("direction" == sAttributeName)
+			m_nDirection = oReader.GetInt();
+		else if ("distance" == sAttributeName)
+			m_nDistance = oReader.GetInt();
+		else if ("rotationStyle" == sAttributeName)
+			m_nRotation = (int)oReader.GetBool();
 	}
+	END_READ_ATTRIBUTES(oReader)
+
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
+	{
+		if ("hp:skew" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_fAngleX = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_fAngleY = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:scale" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					m_fMagnifyX = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					m_fMagnifyY = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:effectsColor" == sNodeName)
+			m_pColor = new CPicColor(oReader);
+	}
+	END_WHILE
 }
 
 CShadow::~CShadow()
@@ -112,14 +133,24 @@ CNeon::CNeon(int nTypeNum, CHWPStream& oBuffer, int nOff, int nSize)
 	m_nSize = oBuffer.GetDistanceToLastPos(true);
 }
 
-CNeon::CNeon(CXMLNode& oNode, int nVersion)
+CNeon::CNeon(CXMLReader& oReader, int nVersion)
 	: CPicEffect(EPicEffectType::GLOW), m_pColor(nullptr)
 {
-	m_fTransparency = oNode.GetAttributeDouble(L"alpha");
-	m_fRadius = oNode.GetAttributeDouble(L"radius");
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("alpha" == sAttributeName)
+			m_fTransparency = oReader.GetDouble();
+		else if ("radius" == sAttributeName)
+			m_fRadius = oReader.GetDouble();
+	}
+	END_READ_ATTRIBUTES(oReader)
 
-	CXMLNode oChild{oNode.GetChild(L"hp:effectsColor")};
-	m_pColor = new CPicColor(oChild);
+	WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hp:effectsColor")
+	{
+		m_pColor = new CPicColor(oReader);
+		break;
+	}
+	END_WHILE
 }
 
 CNeon::~CNeon()
@@ -136,10 +167,10 @@ CSoftEdge::CSoftEdge(int nTypeNum, CHWPStream& oBuffer, int nOff, int nSize)
 	m_nSize = 4;
 }
 
-CSoftEdge::CSoftEdge(CXMLNode& oNode, int nVersion)
+CSoftEdge::CSoftEdge(CXMLReader& oReader, int nVersion)
 	: CPicEffect(EPicEffectType::SOFT_EDGE)
 {
-	m_fRadius = oNode.GetAttributeDouble(L"radius");
+	m_fRadius = oReader.GetAttributeDouble("radius");
 }
 
 CReflect::CReflect(int nTypeNum, CHWPStream& oBuffer, int nOff, int nSize)
@@ -165,38 +196,48 @@ CReflect::CReflect(int nTypeNum, CHWPStream& oBuffer, int nOff, int nSize)
 	m_nSize = oBuffer.GetDistanceToLastPos(true);
 }
 
-CReflect::CReflect(CXMLNode& oNode, int nVersion)
+CReflect::CReflect(CXMLReader& oReader, int nVersion)
 	: CPicEffect(EPicEffectType::REFLECT)
 {
-	m_fRadius = oNode.GetAttributeDouble(L"radius");
-	m_fDirection = oNode.GetAttributeInt(L"direction");
-	m_fDistance = oNode.GetAttributeInt(L"distance");
-	m_nRotateStyle = (int)oNode.GetAttributeBool(L"rotationStyle");
-	m_fOffsetDirection = oNode.GetAttributeInt(L"fadeDirection");
-
-	for (CXMLNode& oChild : oNode.GetChilds())
+	START_READ_ATTRIBUTES(oReader)
 	{
-		if (L"hp:skew" == oChild.GetName())
-		{
-			m_fAngleX = oChild.GetAttributeDouble(L"x");
-			m_fAngleY = oChild.GetAttributeDouble(L"y");
-		}
-		else if (L"hp:scale" == oChild.GetName())
-		{
-			m_fMagnifyX = oChild.GetAttributeDouble(L"x");
-			m_fMagnifyY = oChild.GetAttributeDouble(L"y");
-		}
-		else if (L"hp:alpha" == oChild.GetName())
-		{
-			m_fStartTrans = oChild.GetAttributeDouble(L"start");
-			m_fEndTrans = oChild.GetAttributeDouble(L"end");
-		}
-		else if (L"hp:pos" == oChild.GetName())
-		{
-			m_fStartPos = oChild.GetAttributeDouble(L"start");
-			m_fEndPos = oChild.GetAttributeDouble(L"end");
-		}
+		if ("radius" == sAttributeName)
+			m_fRadius = oReader.GetDouble();
+		else if ("direction" == sAttributeName)
+			m_fDirection = oReader.GetDouble();
+		else if ("distance" == sAttributeName)
+			m_fDistance = oReader.GetDouble();
+		else if ("rotationStyle" == sAttributeName)
+			m_nRotateStyle = (int)oReader.GetBool();
+		else if ("fadeDirection" == sAttributeName)
+			m_fOffsetDirection = oReader.GetDouble();
 	}
+	END_READ_ATTRIBUTES(oReader)
+
+	#define READ_VALUES(value_1_name, value_1_variable, value_2_name, value_2_variable)\
+	{\
+		START_READ_ATTRIBUTES(oReader)\
+		{\
+			if (value_1_name == sAttributeName)\
+				value_1_variable = oReader.GetDouble();\
+			else if (value_2_name == sAttributeName)\
+				value_2_variable = oReader.GetDouble();\
+		}\
+		END_READ_ATTRIBUTES(oReader)\
+	}
+
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
+	{
+		if ("hp:skew" == sNodeName)
+			READ_VALUES("x", m_fAngleX, "y", m_fAngleY)
+		else if ("hp:scale" == sNodeName)
+			READ_VALUES("x", m_fMagnifyX, "y", m_fMagnifyY)
+		else if ("hp:alpha" == sNodeName)
+			READ_VALUES("start", m_fStartTrans, "end", m_fEndTrans)
+		else if ("hp:pos" == sNodeName)
+			READ_VALUES("start", m_fStartPos, "end", m_fEndPos)
+	}
+	END_WHILE
 }
 
 CCtrlShapePic::CCtrlShapePic()
@@ -215,69 +256,110 @@ CCtrlShapePic::CCtrlShapePic(const HWP_STRING& sCtrlID, int nSize, CHWPStream& o
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlShapePic::CCtrlShapePic(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlShapePic::CCtrlShapePic(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hp:imgRect" == oChild.GetName())
+		if ("hp:imgRect" == sNodeName)
 		{
-			for (CXMLNode& oGrandChild : oChild.GetChilds())
+			#define READ_POINT(index_point)\
+			{\
+				START_READ_ATTRIBUTES(oReader)\
+				{\
+					if ("x" == sAttributeName)\
+						m_arBorderPoints[index_point].m_nX = oReader.GetInt();\
+					else if ("y" == sAttributeName)\
+						m_arBorderPoints[index_point].m_nY = oReader.GetInt();\
+				}\
+				END_READ_ATTRIBUTES(oReader)\
+			}
+
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_AND_NAME(oReader, Child)
 			{
-				for (unsigned int unIndex = 0; unIndex < 4; ++unIndex)
+				if ("hc:pt0" == sNodeChildName)
+					READ_POINT(0)
+				else if ("hc:pt1" == sNodeChildName)
+					READ_POINT(1)
+				else if ("hc:pt2" == sNodeChildName)
+					READ_POINT(2)
+				else if ("hc:pt3" == sNodeChildName)
+					READ_POINT(3)
+			}
+			END_WHILE
+		}
+		else if ("hp:imgClip" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("left" == sAttributeName)
+					m_nCropLeft = oReader.GetInt();
+				else if ("right" == sAttributeName)
+					m_nCropRight = oReader.GetInt();
+				else if ("top" == sAttributeName)
+					m_nCropTop = oReader.GetInt();
+				else if ("bottom" == sAttributeName)
+					m_nCropBottom = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:effects" == sNodeName)
+		{
+			if (oReader.GetReader()->IsEmptyNode())
+				continue;
+
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_AND_NAME(oReader, Child)
+			{
+				if ("hp:shadow" == sNodeChildName)
+					m_arPicEffect.push_back(new CShadow(oReader, nVersion));
+				else if ("hp:glow" == sNodeChildName)
+					m_arPicEffect.push_back(new CNeon(oReader, nVersion));
+				else if ("hp:softEdge" == sNodeChildName)
+					m_arPicEffect.push_back(new CSoftEdge(oReader, nVersion));
+				else if ("hp:reflection" == sNodeChildName)
+					m_arPicEffect.push_back(new CReflect(oReader, nVersion));
+			}
+			END_WHILE
+		}
+		else if ("hc:img" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("bright" == sAttributeName)
+					m_chBright = (HWP_BYTE)oReader.GetInt();
+				else if ("contrast" == sAttributeName)
+					m_chContrast = (HWP_BYTE)oReader.GetInt();
+				else if ("effect" == sAttributeName)
 				{
-					if ((L"hc:pt" + std::to_wstring(unIndex)) == oGrandChild.GetName())
-					{
-						m_arBorderPoints[unIndex].m_nX = oGrandChild.GetAttributeInt(L"x");
-						m_arBorderPoints[unIndex].m_nY = oGrandChild.GetAttributeInt(L"y");
-						break;
-					}
+					const std::string sType{oReader.GetTextA()};
+
+					if ("REAL_PIC" == sType)
+						m_chEffect = 0;
+					else if ("GRAY_SCALE" == sType)
+						m_chEffect = 1;
+					else if ("BLACK_WHITE" == sType)
+						m_chEffect = 2;
 				}
+				else if ("binaryItemIDRef" == sAttributeName)
+					m_sBinDataID = oReader.GetText();
 			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hp:imgClip" == oChild.GetName())
+		else if ("hp:imgDim" == sNodeName)
 		{
-			m_nCropLeft = oChild.GetAttributeInt(L"left");
-			m_nCropRight = oChild.GetAttributeInt(L"right");
-			m_nCropTop = oChild.GetAttributeInt(L"top");
-			m_nCropBottom = oChild.GetAttributeInt(L"bottom");
-		}
-		else if (L"hp:effects" == oChild.GetName())
-		{
-			for (CXMLNode& oGrandChild : oChild.GetChilds())
+			START_READ_ATTRIBUTES(oReader)
 			{
-				if (L"hp:shadow" == oGrandChild.GetName())
-					m_arPicEffect.push_back(new CShadow(oGrandChild, nVersion));
-				else if (L"hp:glow" == oGrandChild.GetName())
-					m_arPicEffect.push_back(new CNeon(oGrandChild, nVersion));
-				else if (L"hp:softEdge" == oGrandChild.GetName())
-					m_arPicEffect.push_back(new CSoftEdge(oGrandChild, nVersion));
-				else if (L"hp:reflection" == oGrandChild.GetName())
-					m_arPicEffect.push_back(new CReflect(oGrandChild, nVersion));
+				if ("dimwidth" == sAttributeName)
+					m_nIniPicWidth = oReader.GetInt();
+				else if ("dimheight" == sAttributeName)
+					m_nIniPicHeight = oReader.GetInt();
 			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hc:img" == oChild.GetName())
-		{
-			m_chBright = (HWP_BYTE)oChild.GetAttributeInt(L"bright");
-			m_chContrast = (HWP_BYTE)oChild.GetAttributeInt(L"contrast");
-
-			HWP_STRING sType = oChild.GetAttribute(L"effect");
-
-			if (L"REAL_PIC" == sType)
-				m_chEffect = 0;
-			else if (L"GRAY_SCALE" == sType)
-				m_chEffect = 1;
-			else if (L"BLACK_WHITE" == sType)
-				m_chEffect = 2;
-
-			m_sBinDataID = oChild.GetAttribute(L"binaryItemIDRef");
-		}
-		else if (L"hp:imgDim" == oChild.GetName())
-		{
-			m_nIniPicWidth = oChild.GetAttributeInt(L"dimwidth");
-			m_nIniPicHeight = oChild.GetAttributeInt(L"dimheight");
-		}
+		else
+			CCtrlGeneralShape::ParseChildren(oReader, nVersion);
 	}
+	END_WHILE
 }
 
 CCtrlShapePic::~CCtrlShapePic()

HwpFile/HwpDoc/Paragraph/CtrlShapePic.h

@@ -31,7 +31,7 @@ class CPicColor
 	int m_nRGB;
 public:
 	CPicColor(CHWPStream& oBuffer, int nOff, int nSize);
-	CPicColor(CXMLNode& oNode);
+	CPicColor(CXMLReader& oReader);
 };
 
 class CPicEffect
@@ -61,7 +61,7 @@ class CShadow : public CPicEffect
 	CPicColor *m_pColor;
 public:
 	CShadow(int nTypeNum, CHWPStream& oBuffer, int nOff, int nSize);
-	CShadow(CXMLNode& oNode, int nVersion);
+	CShadow(CXMLReader& oReader, int nVersion);
 	~CShadow();
 };
 
@@ -72,7 +72,7 @@ class CNeon : public CPicEffect
 	CPicColor *m_pColor;
 public:
 	CNeon(int nTypeNum, CHWPStream& oBuffer, int nOff, int nSize);
-	CNeon(CXMLNode& oNode, int nVersion);
+	CNeon(CXMLReader& oReader, int nVersion);
 	~CNeon();
 };
 
@@ -81,7 +81,7 @@ class CSoftEdge : public CPicEffect
 	float m_fRadius;
 public:
 	CSoftEdge(int nTypeNum, CHWPStream& oBuffer, int nOff, int nSize);
-	CSoftEdge(CXMLNode& oNode, int nVersion);
+	CSoftEdge(CXMLReader& oReader, int nVersion);
 };
 
 class CReflect : public CPicEffect
@@ -102,7 +102,7 @@ class CReflect : public CPicEffect
 	float m_fOffsetDirection;
 public:
 	CReflect(int nTypeNum, CHWPStream& oBuffer, int nOff, int nSize);
-	CReflect(CXMLNode& oNode, int nVersion);
+	CReflect(CXMLReader& oReader, int nVersion);
 };
 
 class CCtrlShapePic : public CCtrlGeneralShape
@@ -134,7 +134,7 @@ public:
 	CCtrlShapePic(const HWP_STRING& sCtrlID);
 	CCtrlShapePic(const CCtrlGeneralShape& oShape);
 	CCtrlShapePic(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlShapePic(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlShapePic(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 	~CCtrlShapePic();
 
 	EShapeType GetShapeType() const override;

HwpFile/HwpDoc/Paragraph/CtrlShapePolygon.cpp

@@ -17,18 +17,32 @@ CCtrlShapePolygon::CCtrlShapePolygon(const HWP_STRING& sCtrlID, int nSize, CHWPS
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlShapePolygon::CCtrlShapePolygon(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlShapePolygon::CCtrlShapePolygon(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	std::vector<CXMLNode> arChilds{oNode.GetChilds(L"hc:pt")};
+	TPoint oPoint{0, 0};
 
-	m_arPoints.resize(arChilds.size());
-
-	for (unsigned int unIndex = 0; unIndex < arChilds.size(); ++unIndex)
+	WHILE_READ_NEXT_NODE(oReader)
 	{
-		m_arPoints[unIndex].m_nX = arChilds[unIndex].GetAttributeInt(L"x");
-		m_arPoints[unIndex].m_nY = arChilds[unIndex].GetAttributeInt(L"y");
+		if ("hc:pt" == oReader.GetName())
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("x" == sAttributeName)
+					oPoint.m_nX = oReader.GetInt();
+				else if ("y" == sAttributeName)
+					oPoint.m_nY = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
+
+			m_arPoints.push_back(oPoint);
+
+			oPoint = {0, 0};
+		}
+		else
+			CCtrlGeneralShape::ParseChildren(oReader, nVersion);
 	}
+	END_WHILE
 
 	m_nPoints = m_arPoints.size();
 }

HwpFile/HwpDoc/Paragraph/CtrlShapePolygon.h

@@ -15,7 +15,7 @@ public:
 	CCtrlShapePolygon(const HWP_STRING& sCtrlID);
 	CCtrlShapePolygon(const CCtrlGeneralShape& oShape);
 	CCtrlShapePolygon(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlShapePolygon(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlShapePolygon(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	EShapeType GetShapeType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlShapeRect.cpp

@@ -17,20 +17,37 @@ CCtrlShapeRect::CCtrlShapeRect(const HWP_STRING& sCtrlID, int nSize, CHWPStream&
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlShapeRect::CCtrlShapeRect(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlShapeRect::CCtrlShapeRect(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	m_chCurv = (HWP_BYTE)oNode.GetAttributeInt(L"ratio");
+	m_chCurv = (HWP_BYTE)oReader.GetAttributeInt("ratio");
 
-	for (unsigned int unIndex = 0; unIndex < 4; ++unIndex)
-	{
-		if ((L"hc:pt" + std::to_wstring(unIndex)) == oNode.GetName())
-		{
-			m_arPoints[unIndex].m_nX = oNode.GetAttributeInt(L"x");
-			m_arPoints[unIndex].m_nY = oNode.GetAttributeInt(L"y");
-			break;
-		}
+	#define READ_POINT(point_index)\
+	{\
+		START_READ_ATTRIBUTES(oReader)\
+		{\
+			if ("x" == sAttributeName)\
+				m_arPoints[point_index].m_nX = oReader.GetInt();\
+			else if ("y" == sAttributeName)\
+				m_arPoints[point_index].m_nY = oReader.GetInt();\
+		}\
+		END_READ_ATTRIBUTES(oReader)\
 	}
+
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
+	{
+		if ("hc:pt0" == sNodeName)
+			READ_POINT(0)
+		else if ("hc:pt1" == sNodeName)
+			READ_POINT(1)
+		else if ("hc:pt2" == sNodeName)
+			READ_POINT(2)
+		else if ("hc:pt3" == sNodeName)
+			READ_POINT(3)
+		else
+			CCtrlGeneralShape::ParseChildren(oReader, nVersion);
+	}
+	END_WHILE
 }
 
 EShapeType CCtrlShapeRect::GetShapeType() const

HwpFile/HwpDoc/Paragraph/CtrlShapeRect.h

@@ -15,7 +15,7 @@ public:
 	CCtrlShapeRect(const HWP_STRING& sCtrlID);
 	CCtrlShapeRect(const CCtrlGeneralShape& oShape);
 	CCtrlShapeRect(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlShapeRect(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlShapeRect(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	EShapeType GetShapeType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlShapeTextArt.cpp

@@ -17,58 +17,81 @@ CCtrlShapeTextArt::CCtrlShapeTextArt(const HWP_STRING& sCtrlID, int nSize, CHWPS
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlShapeTextArt::CCtrlShapeTextArt(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlShapeTextArt::CCtrlShapeTextArt(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	m_sText = oNode.GetAttribute(L"text");
+	m_sText = oReader.GetAttribute("text");
 
-	for (CXMLNode& oChild : oNode.GetChilds())
-	{
-		if (L"hp:pt0" == oChild.GetName())
-		{
-			m_oPt0.m_nX = oNode.GetAttributeInt(L"x");
-			m_oPt0.m_nY = oNode.GetAttributeInt(L"y");
-		}
-		else if (L"hp:pt1" == oChild.GetName())
-		{
-			m_oPt1.m_nX = oNode.GetAttributeInt(L"x");
-			m_oPt1.m_nY = oNode.GetAttributeInt(L"y");
-		}
-		else if (L"hp:pt2" == oChild.GetName())
-		{
-			m_oPt2.m_nX = oNode.GetAttributeInt(L"x");
-			m_oPt2.m_nY = oNode.GetAttributeInt(L"y");
-		}
-		else if (L"hp:pt3" == oChild.GetName())
-		{
-			m_oPt3.m_nX = oNode.GetAttributeInt(L"x");
-			m_oPt3.m_nY = oNode.GetAttributeInt(L"y");
-		}
-		else if (L"hp:textartPr" == oChild.GetName())
-		{
-			m_sFontName = oChild.GetAttribute(L"fontName");
-			m_sFontStyle = oChild.GetAttribute(L"fontStyle");
-			m_sFontType = oChild.GetAttribute(L"fontType");
-			m_sTextShape = oChild.GetAttribute(L"textShape");
-			m_sFontStyle = oChild.GetAttribute(L"fontStyle");
-			m_shLineSpacing = oChild.GetAttributeInt(L"lineSpacing");
-			m_shSpacing = oChild.GetAttributeInt(L"spacing");
-			m_sAlign = oChild.GetAttribute(L"align");
-
-			//TODO:: реализовать shadows
-		}
-		else if (L"hp:outline" == oChild.GetName())
-		{
-			std::vector<CXMLNode> arGrandChilds{oChild.GetChilds(L"hp:pt")};
-			m_arOutline.resize(arGrandChilds.size());
-
-			for (unsigned int unIndex = 0; unIndex < arGrandChilds.size(); ++unIndex)
-			{
-				m_arOutline[unIndex].m_nX = arGrandChilds[unIndex].GetAttributeInt(L"x");
-				m_arOutline[unIndex].m_nY = arGrandChilds[unIndex].GetAttributeInt(L"y");
-			}
-		}
+	#define READ_POINT(variable_point)\
+	{\
+		START_READ_ATTRIBUTES(oReader)\
+		{\
+			if ("x" == sAttributeName)\
+				variable_point.m_nX = oReader.GetInt();\
+			else if ("y" == sAttributeName)\
+				variable_point.m_nY = oReader.GetInt();\
+		}\
+		END_READ_ATTRIBUTES(oReader)\
 	}
+
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
+	{
+		if ("hp:pt0" == sNodeName)
+			READ_POINT(m_oPt0)
+		else if ("hp:pt1" == sNodeName)
+			READ_POINT(m_oPt1)
+		else if ("hp:pt2" == sNodeName)
+			READ_POINT(m_oPt2)
+		else if ("hp:pt3" == sNodeName)
+			READ_POINT(m_oPt3)
+		else if ("hp:textartPr" == sNodeName)
+		{
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("fontName" == sAttributeName)
+					m_sFontName = oReader.GetText();
+				else if ("fontStyle" == sAttributeName)
+					m_sFontStyle = oReader.GetText();
+				else if ("fontType" == sAttributeName)
+					m_sFontType = oReader.GetText();
+				else if ("textShape" == sAttributeName)
+					m_sTextShape = oReader.GetText();
+				else if ("align" == sAttributeName)
+					m_sAlign = oReader.GetText();
+				else if ("lineSpacing" == sAttributeName)
+					m_shLineSpacing = oReader.GetInt();
+				else if ("spacing" == sAttributeName)
+					m_shSpacing = oReader.GetInt();
+
+				//TODO:: реализовать shadows
+			}
+			END_READ_ATTRIBUTES(oReader)
+		}
+		else if ("hp:outline" == sNodeName)
+		{
+			TPoint oPoint{0, 0};
+
+			WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hp:pt")
+			{
+				START_READ_ATTRIBUTES(oReader)
+				{
+					if ("x" == sAttributeName)
+						oPoint.m_nX = oReader.GetInt();
+					else if ("y" == sAttributeName)
+						oPoint.m_nY = oReader.GetInt();
+				}
+				END_READ_ATTRIBUTES(oReader)
+
+				m_arOutline.push_back(oPoint);
+
+				oPoint = {0, 0};
+			}
+			END_WHILE
+		}
+		else
+			CCtrlGeneralShape::ParseChildren(oReader, nVersion);
+	}
+	END_WHILE
 }
 
 EShapeType CCtrlShapeTextArt::GetShapeType() const

HwpFile/HwpDoc/Paragraph/CtrlShapeTextArt.h

@@ -28,7 +28,7 @@ public:
 	CCtrlShapeTextArt(const HWP_STRING& sCtrlID);
 	CCtrlShapeTextArt(const CCtrlGeneralShape& oShape);
 	CCtrlShapeTextArt(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlShapeTextArt(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlShapeTextArt(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	EShapeType GetShapeType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlShapeVideo.cpp

@@ -14,21 +14,32 @@ CCtrlShapeVideo::CCtrlShapeVideo(const HWP_STRING& sCtrlID, int nSize, CHWPStrea
 	: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlShapeVideo::CCtrlShapeVideo(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlGeneralShape(sCtrlID, oNode, nVersion)
+CCtrlShapeVideo::CCtrlShapeVideo(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlGeneralShape(sCtrlID, oReader, nVersion)
 {
-	HWP_STRING sType = oNode.GetAttribute(L"videotype");
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("type" == sAttributeName)
+		{
+			const std::string sType{oReader.GetTextA()};
 
-	if (L"Local" == sType)
-		m_nVideoType = 0;
-	else if (L"Web" == sType)
-		m_nVideoType = 1;
+			if ("Local" == sType)
+				m_nVideoType = 0;
+			else if ("Web" == sType)
+				m_nVideoType = 1;
+		}
+		else if ("fileIDRef" == sAttributeName)
+			m_shVideoBinID = oReader.GetInt();
+		else if ("imageIDRef" == sAttributeName)
+			m_sThumnailBinID = oReader.GetInt();
+		else if ("tag" == sAttributeName)
+			m_sWebURL = oReader.GetText();
+	}
+	END_READ_ATTRIBUTES(oReader)
 
-	m_shVideoBinID = oNode.GetAttributeInt(L"fileIDRef");
-	m_sThumnailBinID = oNode.GetAttribute(L"imageIDRef");
-
-	if (1 == m_nVideoType)
-		m_sWebURL = oNode.GetAttribute(L"tag");
+	WHILE_READ_NEXT_NODE(oReader)
+		CCtrlGeneralShape::ParseChildren(oReader, nVersion);
+	END_WHILE
 }
 
 EShapeType CCtrlShapeVideo::GetShapeType() const

HwpFile/HwpDoc/Paragraph/CtrlShapeVideo.h

@@ -15,7 +15,7 @@ public:
 	CCtrlShapeVideo(const HWP_STRING& sCtrlID);
 	CCtrlShapeVideo(const CCtrlGeneralShape& oShape);
 	CCtrlShapeVideo(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlShapeVideo(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlShapeVideo(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 
 	EShapeType GetShapeType() const override;
 

HwpFile/HwpDoc/Paragraph/CtrlTable.cpp

@@ -10,44 +10,74 @@ CCtrlTable::CCtrlTable(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer
 	: CCtrlCommon(sCtrlID, nSize, oBuffer, nOff, nVersion)
 {}
 
-CCtrlTable::CCtrlTable(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion)
-	: CCtrlCommon(sCtrlID, oNode, nVersion)
+CCtrlTable::CCtrlTable(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
+    : CCtrlCommon(sCtrlID, oReader, nVersion)
 {
-	m_shNRows = oNode.GetAttributeInt(L"rowCnt");
-	m_shNCols = oNode.GetAttributeInt(L"colCnt");
-	m_shCellSpacing = oNode.GetAttributeInt(L"cellSpacing");
-	m_shBorderFillID = oNode.GetAttributeInt(L"borderFillIDRef");
-
-	for (CXMLNode& oChild : oNode.GetChilds())
+	START_READ_ATTRIBUTES(oReader)
 	{
-		if (L"hp:inMargin" == oChild.GetName())
+		if ("rowCnt" == sAttributeName)
+			m_shNRows = oReader.GetInt();
+		else if ("colCnt" == sAttributeName)
+			m_shNCols = oReader.GetInt();
+		else if ("cellSpacing" == sAttributeName)
+			m_shCellSpacing = oReader.GetInt();
+		else if ("borderFillIDRef" == sAttributeName)
+			m_shBorderFillID = oReader.GetInt();
+	}
+	END_READ_ATTRIBUTES(oReader)
+
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
+	{
+		if ("hp:inMargin" == sNodeName)
 		{
-			m_shInLSpace = oChild.GetAttributeInt(L"left");
-			m_shInRSpace = oChild.GetAttributeInt(L"right");
-			m_shInTSpace = oChild.GetAttributeInt(L"top");
-			m_shInBSpace = oChild.GetAttributeInt(L"bottom");
+			START_READ_ATTRIBUTES(oReader)
+			{
+				if ("left" == sAttributeName)
+					m_shInLSpace = oReader.GetInt();
+				else if ("right" == sAttributeName)
+					m_shInRSpace = oReader.GetInt();
+				else if ("top" == sAttributeName)
+					m_shInTSpace = oReader.GetInt();
+				else if ("bottom" == sAttributeName)
+					m_shInBSpace = oReader.GetInt();
+			}
+			END_READ_ATTRIBUTES(oReader)
 		}
-		else if (L"hp:cellzoneList" == oChild.GetName())
+		else if ("hp:cellzoneList" == sNodeName)
 		{
-			for (CXMLNode& oGrandChild : oChild.GetChilds(L"hp:cellzone"))
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Child, "hp:cellzone")
 			{
 				TCellZone* pCellZone = new TCellZone();
 
-				pCellZone->m_shStartRowAddr = oGrandChild.GetAttributeInt(L"startRowAddr");
-				pCellZone->m_shStartColAddr = oGrandChild.GetAttributeInt(L"startColAddr");
-				pCellZone->m_shEndRowAddr = oGrandChild.GetAttributeInt(L"endRowAddr");
-				pCellZone->m_shEndColAddr = oGrandChild.GetAttributeInt(L"endColAddr");
-				pCellZone->m_shBorderFillIDRef = oGrandChild.GetAttributeInt(L"borderFillIDRef");
+				START_READ_ATTRIBUTES(oReader)
+				{
+					if ("startRowAddr" == sAttributeName)
+						pCellZone->m_shStartRowAddr = oReader.GetInt();
+					else if ("startColAddr" == sAttributeName)
+						pCellZone->m_shStartColAddr = oReader.GetInt();
+					else if ("endRowAddr" == sAttributeName)
+						pCellZone->m_shEndRowAddr = oReader.GetInt();
+					else if ("endColAddr" == sAttributeName)
+						pCellZone->m_shEndColAddr = oReader.GetInt();
+					else if ("borderFillIDRef" == sAttributeName)
+						pCellZone->m_shBorderFillIDRef = oReader.GetInt();
+				}
+				END_READ_ATTRIBUTES(oReader)
 
 				m_arCellzoneList.push_back(pCellZone);
 			}
+			END_WHILE
 		}
-		else if(L"hp:tr" == oChild.GetName())
+		else if ("hp:tr" == sNodeName)
 		{
-			for (CXMLNode& oGrandChild : oChild.GetChilds(L"hp:tc"))
-				m_arCells.push_back(new CTblCell(oGrandChild, nVersion));
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Child, "hp:tc")
+				m_arCells.push_back(new CTblCell(oReader, nVersion));
+			END_WHILE
 		}
+		else
+			CCtrlCommon::ParseChildren(oReader, nVersion);
 	}
+	END_WHILE
 }
 
 CCtrlTable::~CCtrlTable()

HwpFile/HwpDoc/Paragraph/CtrlTable.h

@@ -32,7 +32,7 @@ class CCtrlTable : public CCtrlCommon
 public:
 	CCtrlTable(const HWP_STRING& sCtrlID);
 	CCtrlTable(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
-	CCtrlTable(const HWP_STRING& sCtrlID, CXMLNode& oNode, int nVersion);
+	CCtrlTable(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion);
 	~CCtrlTable();
 
 	ECtrlObjectType GetCtrlType() const override;

HwpFile/HwpDoc/Paragraph/HWPPargraph.cpp

@@ -19,45 +19,63 @@
 #include "CtrlShapeVideo.h"
 #include "ParaText.h"
 
+#include "../../../DesktopEditor/common/File.h"
+
 namespace HWP
 {
 CHWPPargraph::CHWPPargraph()
 	: m_pLineSegs(nullptr)
 {}
 
-CHWPPargraph::CHWPPargraph(CXMLNode& oNode, int nVersion)
+CHWPPargraph::CHWPPargraph(CXMLReader& oReader, int nVersion)
 	: m_chBreakType(0), m_pLineSegs(nullptr)
 {
-	m_shParaShapeID = oNode.GetAttributeInt(L"paraPrIDRef");
-	m_shParaStyleID = oNode.GetAttributeInt(L"styleIDRef");
-
-	if (oNode.GetAttributeBool(L"pageBreak"))
-		m_chBreakType |= 0b00000100;
-	else
-		m_chBreakType &= 0b11111011;
-
-	if (oNode.GetAttributeBool(L"columnBreak"))
-		m_chBreakType |= 0b00001000;
-	else
-		m_chBreakType &= 0b11110111;
+	START_READ_ATTRIBUTES(oReader)
+	{
+		if ("paraPrIDRef" == sAttributeName)
+			m_shParaShapeID = oReader.GetInt();
+		else if ("styleIDRef" == sAttributeName)
+			m_shParaStyleID = oReader.GetInt();
+		else if ("pageBreak" == sAttributeName)
+		{
+			if (oReader.GetBool())
+				m_chBreakType |= 0b00000100;
+			else
+				m_chBreakType &= 0b11111011;
+		}
+		else if ("columnBreak" == sAttributeName)
+		{
+			if (oReader.GetBool())
+				m_chBreakType |= 0b00001000;
+			else
+				m_chBreakType &= 0b11110111;
+		}
+	}
+	END_READ_ATTRIBUTES(oReader)
 
 	int nCharShapeID = 0;
 
-	for (CXMLNode& oChild : oNode.GetChilds())
+	WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
 	{
-		if (L"hp:run" == oChild.GetName())
+		if ("hp:run" == sNodeName)
 		{
-			nCharShapeID = oChild.GetAttributeInt(L"charPrIDRef");
+			nCharShapeID = oReader.GetAttributeInt("charPrIDRef");
 
-			for (CXMLNode& oGrandChild : oChild.GetChilds())
-				ParseHWPParagraph(oGrandChild, nCharShapeID, nVersion);
+			WHILE_READ_NEXT_NODE_WITH_DEPTH(oReader, Child)
+				ParseHWPParagraph(oReader, nCharShapeID, nVersion);
+			END_WHILE
 		}
-		else if (L"hp:linesegarray" == oChild.GetName())
+		else if ("hp:linesegarray" == sNodeName)
 		{
-			CXMLNode oGrandChild{oChild.GetChild(L"hp:lineseg")};
-			m_pLineSegs = new CLineSeg(oGrandChild, nVersion);
+			WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Child, "hp:lineseg")
+			{
+				m_pLineSegs = new CLineSeg(oReader, nVersion);
+				break;
+			}
+			END_WHILE
 		}
 	}
+	END_WHILE
 
 	if (m_arP.empty() || ECtrlObjectType::Character != m_arP.back()->GetCtrlType())
 		m_arP.push_back(new CCtrlCharacter(L"   _", ECtrlCharType::PARAGRAPH_BREAK, nCharShapeID));
@@ -69,79 +87,105 @@ CHWPPargraph::~CHWPPargraph()
 		delete m_pLineSegs;
 }
 
-bool CHWPPargraph::ParseHWPParagraph(CXMLNode& oNode, int nCharShapeID, int nVersion)
+bool CHWPPargraph::ParseHWPParagraph(CXMLReader& oReader, int nCharShapeID, int nVersion)
 {
 	const size_t unCurrentParaCount = m_arP.size();
 
-	if (L"hp:secPr" == oNode.GetName())
-		m_arP.push_back(new CCtrlSectionDef(L"dces", oNode, nVersion));
-	else if (L"hp:ctrl" == oNode.GetName())
-	{
-		for(CXMLNode& oChild : oNode.GetChilds())
-			AddCtrl(CCtrl::GetCtrl(oChild, nVersion));
-	}
-	else if (L"hp:t" == oNode.GetName())
-	{
-		m_arP.push_back(new CParaText(L"____", oNode.GetText(), 0, nCharShapeID));
+	const std::string sNodeName{oReader.GetName()};
 
-		for(CXMLNode& oChild : oNode.GetChilds())
+	if ("hp:secPr" == sNodeName)
+		m_arP.push_back(new CCtrlSectionDef(L"dces", oReader, nVersion));
+	else if ("hp:ctrl" == sNodeName)
+	{
+		WHILE_READ_NEXT_NODE(oReader)
+			AddCtrl(CCtrl::GetCtrl(oReader, nVersion));
+		END_WHILE
+	}
+	else if ("hp:t" == sNodeName)
+	{
+		if (oReader.IsEmptyNode())
+			return false;
+
+		const int nDepth = oReader.GetDepth();
+		XmlUtils::XmlNodeType eNodeType = XmlUtils::XmlNodeType_EndElement;
+		while (oReader.Read(eNodeType) && oReader.GetDepth() >= nDepth && XmlUtils::XmlNodeType_EndElement != eNodeType)
 		{
-			if (L"hp:lineBreak" == oChild.GetName())
-				m_arP.push_back(new CCtrlCharacter(L"   _", ECtrlCharType::LINE_BREAK));
-			else if (L"hp:hyphen" == oChild.GetName())
-				m_arP.push_back(new CCtrlCharacter(L"   _", ECtrlCharType::HARD_HYPHEN));
-			else if (L"hp:nbSpace" == oChild.GetName()||
-			         L"hp:fwSpace" == oChild.GetName())
-				m_arP.push_back(new CCtrlCharacter(L"   _", ECtrlCharType::HARD_SPACE));
-			else if (L"hp:tab" == oChild.GetName())
-				m_arP.push_back(new CParaText(L"____", L"\t", 0));
+			if (eNodeType == XmlUtils::XmlNodeType_Text ||
+			    eNodeType == XmlUtils::XmlNodeType_Whitespace ||
+			    eNodeType == XmlUtils::XmlNodeType_SIGNIFICANT_WHITESPACE ||
+			    eNodeType == XmlUtils::XmlNodeType_CDATA)
+			{
+				const char* pValue = oReader.GetTextChar();
+				std::wstring wsValue;
+
+				if('\0' != pValue[0])
+				{
+					NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pValue, (LONG)strlen(pValue), wsValue);
+					m_arP.push_back(new CParaText(L"____", wsValue, 0, nCharShapeID));
+				}
+			}
+			else if (eNodeType == XmlUtils::XmlNodeType_Element)
+			{
+				const std::string sChildNodeName{oReader.GetName()};
+
+				if ("hp:lineBreak" == sChildNodeName)
+					m_arP.push_back(new CCtrlCharacter(L"   _", ECtrlCharType::LINE_BREAK));
+				else if ("hp:hyphen" == sChildNodeName)
+					m_arP.push_back(new CCtrlCharacter(L"   _", ECtrlCharType::HARD_HYPHEN));
+				else if ("hp:nbSpace" == sChildNodeName ||
+				         "hp:fwSpace" == sChildNodeName)
+					m_arP.push_back(new CCtrlCharacter(L"   _", ECtrlCharType::HARD_SPACE));
+				else if ("hp:tab" == sChildNodeName)
+					m_arP.push_back(new CCtrlCharacter(L"   _", ECtrlCharType::TABULATION));
+			}
 		}
 	}
-	else if (L"hp:tbl" == oNode.GetName())
-		m_arP.push_back(new CCtrlTable(L" lbt", oNode, nVersion));
-	else if (L"hp:pic" == oNode.GetName())
-		m_arP.push_back(new CCtrlShapePic(L"cip$", oNode, nVersion));
-	else if (L"hp:container" == oNode.GetName())
-		m_arP.push_back(new CCtrlContainer(L"noc$", oNode, nVersion));
-	else if (L"hp:ole" == oNode.GetName())
-		m_arP.push_back(new CCtrlShapeOle(L"elo$", oNode, nVersion));
-	else if (L"hp:equation" == oNode.GetName())
-		m_arP.push_back(new CCtrlEqEdit(L"deqe", oNode, nVersion));
-	else if (L"hp:line" == oNode.GetName())
-		m_arP.push_back(new CCtrlShapeLine(L"nil$", oNode, nVersion));
-	else if (L"hp:rect" == oNode.GetName())
-		m_arP.push_back(new CCtrlShapeRect(L"cer$", oNode, nVersion));
-	else if (L"hp:ellipse" == oNode.GetName())
-		m_arP.push_back(new CCtrlShapeEllipse(L"lle$", oNode, nVersion));
-	else if (L"hp:arc" == oNode.GetName())
-		m_arP.push_back(new CCtrlShapeArc(L"cra$", oNode, nVersion));
-	else if (L"hp:polygon" == oNode.GetName())
-		m_arP.push_back(new CCtrlShapePolygon(L"lop$", oNode, nVersion));
-	else if (L"hp:curve" == oNode.GetName())
-		m_arP.push_back(new CCtrlShapeCurve(L"ruc$", oNode, nVersion));
-	else if (L"hp:connectLine" == oNode.GetName())
-		m_arP.push_back(new CCtrlShapeConnectLine(L"loc$", oNode, nVersion));
-	else if (L"hp:textart" == oNode.GetName())
-		m_arP.push_back(new CCtrlShapeTextArt(L"tat$", oNode, nVersion));
-	else if (L"hp:video" == oNode.GetName())
-		m_arP.push_back(new CCtrlShapeVideo(L"div$", oNode, nVersion));
+	else if ("hp:tbl" == sNodeName)
+		m_arP.push_back(new CCtrlTable(L" lbt", oReader, nVersion));
+	else if ("hp:pic" == sNodeName)
+		m_arP.push_back(new CCtrlShapePic(L"cip$", oReader, nVersion));
+	else if ("hp:container" == sNodeName)
+		m_arP.push_back(new CCtrlContainer(L"noc$", oReader, nVersion));
+	else if ("hp:ole" == sNodeName)
+		m_arP.push_back(new CCtrlShapeOle(L"elo$", oReader, nVersion));
+	else if ("hp:equation" == sNodeName)
+		m_arP.push_back(new CCtrlEqEdit(L"deqe", oReader, nVersion));
+	else if ("hp:line" == sNodeName)
+		m_arP.push_back(new CCtrlShapeLine(L"nil$", oReader, nVersion));
+	else if ("hp:rect" == sNodeName)
+		m_arP.push_back(new CCtrlShapeRect(L"cer$", oReader, nVersion));
+	else if ("hp:ellipse" == sNodeName)
+		m_arP.push_back(new CCtrlShapeEllipse(L"lle$", oReader, nVersion));
+	else if ("hp:arc" == sNodeName)
+		m_arP.push_back(new CCtrlShapeArc(L"cra$", oReader, nVersion));
+	else if ("hp:polygon" == sNodeName)
+		m_arP.push_back(new CCtrlShapePolygon(L"lop$", oReader, nVersion));
+	else if ("hp:curve" == sNodeName)
+		m_arP.push_back(new CCtrlShapeCurve(L"ruc$", oReader, nVersion));
+	else if ("hp:connectLine" == sNodeName)
+		m_arP.push_back(new CCtrlShapeConnectLine(L"loc$", oReader, nVersion));
+	else if ("hp:textart" == sNodeName)
+		m_arP.push_back(new CCtrlShapeTextArt(L"tat$", oReader, nVersion));
+	else if ("hp:video" == sNodeName)
+		m_arP.push_back(new CCtrlShapeVideo(L"div$", oReader, nVersion));
 
 	if (unCurrentParaCount != m_arP.size())
 		return true;
 
-	if (L"hp:switch" == oNode.GetName())
+	if ("hp:switch" == sNodeName)
 	{
-		for (CXMLNode& oCaseChild : oNode.GetChilds(L"hp:case"))
+		WHILE_READ_NEXT_NODE(oReader)
 		{
-			for (CXMLNode& oChild : oCaseChild.GetChilds())
-				if (ParseHWPParagraph(oChild, nCharShapeID, nVersion))
-					return true;
-		}
+			if ("hp:case" != oReader.GetName() &&
+			    "hp:default" != oReader.GetName())
+				continue;
 
-		CXMLNode oDefaultChild{oNode.GetChild(L"hp:default")};
-		for (CXMLNode& oChild : oDefaultChild.GetChilds())
-			if (ParseHWPParagraph(oChild, nCharShapeID, nVersion))
-				return true;
+			WHILE_READ_NEXT_NODE(oReader)
+				if (ParseHWPParagraph(oReader, nCharShapeID, nVersion))
+					return true;
+			END_WHILE
+		}
+		END_WHILE
 	}
 
 	return false;