pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-07-20 03:08:28 +08:00
Code Issues Packages Projects Releases Wiki Activity

Text conversion from HWPML format is implemented

Browse Source
This commit is contained in:
Kirill Polyakov
2025-09-10 13:59:15 +03:00
parent f96dd51403
commit 2ee94c4920
20 changed files with 475 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
HwpFile/HWPFile.cpp
View File

@ -36,6 +36,14 @@ bool CHWPFile::OpenHWPX(const std::wstring& wsFilePath)
return m_pInternal->Open(wsFilePath, HWP::EHanType::HWPX);
}
bool CHWPFile::OpenHWPML(const std::wstring &wsFilePath)
{
if (nullptr == m_pInternal)
return false;
return m_pInternal->Open(wsFilePath, HWP::EHanType::HWPML);
}
void CHWPFile::Close()
{
if (nullptr != m_pInternal)

1
HwpFile/HWPFile.h
View File

@ -24,6 +24,7 @@ public:
bool OpenHWP(const std::wstring& wsFilePath);
bool OpenHWPX(const std::wstring& wsFilePath);
bool OpenHWPML(const std::wstring& wsFilePath);
void Close();
bool ConvertToOOXML(const std::wstring& wsFilePath);
bool ConvertToOOXML_Dir(const std::wstring& wsDirectoryPath);

3
HwpFile/HWPFile.pro
View File

@ -49,6 +49,7 @@ SOURCES += \
HwpDoc/HWPElements/HWPRecordStyle.cpp \
HwpDoc/HWPElements/HwpRecordTabDef.cpp \
HwpDoc/HWPFile.cpp \
HwpDoc/HWPMLFile.cpp \
HwpDoc/HWPSection.cpp \
HwpDoc/HWPStream.cpp \
HwpDoc/HWPXFile.cpp \
@ -99,6 +100,7 @@ SOURCES += \
HEADERS += \
HWPFile.h \
HwpDoc/Common/Common.h \
HwpDoc/Common/NodeNames.h \
HwpDoc/Common/WriterContext.h \
HwpDoc/Common/XMLReader.h \
HwpDoc/Conversion/ConversionState.h \
@ -133,6 +135,7 @@ HEADERS += \
HwpDoc/HWPElements/HwpRecordTabDef.h \
HwpDoc/HWPElements/HwpRecordTypes.h \
HwpDoc/HWPFile.h \
HwpDoc/HWPMLFile.h \
HwpDoc/HWPSection.h \
HwpDoc/HWPStream.h \
HwpDoc/HWPXFile.h \

179
HwpFile/HwpDoc/Common/NodeNames.h Normal file
View File

@ -0,0 +1,179 @@
#ifndef NODENAMES_H
#define NODENAMES_H
#define MAX_TYPES 2
#define MAX_NODES 100
#include "../HanType.h"
namespace HWP
{
enum class ENode
{
Body,
Section,
Paragraph,
Text,
Char,
SectionDef,
Table,
Picture,
Container,
Ole,
Equation,
TextArt,
Line,
Rectangle,
Ellipse,
Arc,
Polygon,
Curve,
ConnectLine,
Tab,
LineBreak,
Hyphen,
NbSpace,
FwSpace,
//Only hwpx
Ctrl,
Lineseg,
LinesegArray,
Video,
Switch,
Case,
Default
};
static constexpr const char* NODE_NAMES[MAX_TYPES][MAX_NODES] =
{
// HWPX
{
"",
"hs:sec",
"hp:p",
"hp:run",
"hp:t",
"hp:secPr",
"hp:tbl",
"hp:pic",
"hp:container",
"hp:ole",
"hp:equation",
"hp:textart",
"hp:line",
"hp:rect",
"hp:ellipse",
"hp:arc",
"hp:polygon",
"hp:curve",
"hp:connectLine",
"hp:tab",
"hp:lineBreak",
"hp:hyphen",
"hp:nbSpace",
"hp:fwSpace"
"hp:ctrl",
"hp:lineseg",
"hp:linesegarray",
"hp:video",
"hp:switch",
"hp:case",
"hp:default"
},
// HWPML
{
"BODY",
"SECTION",
"P",
"TEXT",
"CHAR",
"SECDEF",
"TABLE",
"PICTURE",
"CONTAINER",
"OLE",
"EQUATION",
"TEXTART",
"LINE",
"RECTANGLE",
"ELLIPSE",
"ARC",
"POLYGON",
"CURVE",
"CONNECTLINE",
"TAB",
"LINEBREAK",
"HYPHEN",
"NBSPACE",
"FWSPACE",
"",
"",
"",
"",
"",
"",
""
}
};
inline const char* GetNodeName(ENode eNode, EHanType eType)
{
switch (eType)
{
case EHanType::HWPX: return NODE_NAMES[0][static_cast<int>(eNode)];
case EHanType::HWPML: return NODE_NAMES[1][static_cast<int>(eNode)];
default: return "";
}
}
#define MAX_ARGUMENTS 6
enum class EArgument
{
ParaShape,
Style,
InstId,
PageBreak,
ColumnBreak,
CharShape
};
static constexpr const char* ARGUMENT_NAMES[MAX_TYPES][MAX_ARGUMENTS] =
{
// HWPX
{
"paraPrIDRef",
"styleIDRef",
"id",
"pageBreak",
"columnBreak",
"charPrIDRef"
},
// HWPML
{
"ParaShape",
"Style",
"InstId",
"PageBreak",
"ColumnBreak",
"CharShape"
}
};
inline const char* GetArgumentName(EArgument eNode, EHanType eType)
{
switch (eType)
{
case EHanType::HWPX: return ARGUMENT_NAMES[0][static_cast<int>(eNode)];
case EHanType::HWPML: return ARGUMENT_NAMES[1][static_cast<int>(eNode)];
default: return "";
}
}
}
#endif // NODENAMES_H

158
HwpFile/HwpDoc/Common/WriterContext.cpp
View File

@ -13,28 +13,45 @@ CWriterContext::CWriterContext()
CWriterContext::~CWriterContext()
{
if (nullptr != m_pHWPFile)
delete m_pHWPFile;
if (nullptr != m_pHWPXFile)
delete m_pHWPXFile;
Clear();
}
void CWriterContext::Clear()
{
switch (m_eType)
{
case EHanType::HWP:
{
if (nullptr == m_pHWPFile)
return;
delete m_pHWPFile;
m_pHWPFile = nullptr;
break;
}
case EHanType::HWPX:
{
if (nullptr == m_pHWPXFile)
return;
delete m_pHWPXFile;
m_pHWPXFile = nullptr;
break;
}
case EHanType::HWPML:
{
if(nullptr == m_pHWPMLFile)
return;
delete m_pHWPMLFile;
m_pHWPMLFile = nullptr;
break;
}
default:
break;
}
m_eType = EHanType::NONE;
if (nullptr != m_pHWPFile)
{
delete m_pHWPFile;
m_pHWPFile = nullptr;
}
if (nullptr != m_pHWPXFile)
{
delete m_pHWPXFile;
m_pHWPXFile = nullptr;
}
}
EHanType CWriterContext::GetType()
@ -61,6 +78,13 @@ VECTOR<const CHWPSection*> CWriterContext::GetSections()
break;
}
case EHanType::HWPML:
{
if (nullptr != m_pHWPMLFile)
return m_pHWPMLFile->GetSections();
break;
}
}
return VECTOR<const CHWPSection*>();
@ -70,36 +94,35 @@ EHanType CWriterContext::DetectHancom(const HWP_STRING& sPathToFile)
{
bool bDetected = false;
CHWPFile* pHwpTemp = new CHWPFile(sPathToFile);
if (nullptr != pHwpTemp)
{
if (pHwpTemp->Detect())
{
bDetected = true;
pHwpTemp->Close();
}
delete pHwpTemp;
#define DETECT(hwp_class)\
{\
hwp_class* pTemp = new hwp_class(sPathToFile);\
if (nullptr != pTemp)\
{\
if (pTemp->Detect())\
{\
bDetected = true;\
pTemp->Close();\
}\
delete pTemp;\
}\
}
DETECT(CHWPFile)
if (bDetected)
return EHanType::HWP;
CHWPXFile* pHwpxTemp = new CHWPXFile(sPathToFile);
if (nullptr != pHwpxTemp)
{
if (pHwpxTemp->Detect())
{
bDetected = true;
pHwpxTemp->Close();
}
delete pHwpxTemp;
}
DETECT(CHWPXFile)
if (bDetected)
return EHanType::HWPX;
DETECT(CHWPMLFile)
if(bDetected)
return EHanType::HWPML;
return EHanType::NONE;
}
@ -108,19 +131,11 @@ bool CWriterContext::Detect()
switch(m_eType)
{
case EHanType::HWP:
{
if (nullptr == m_pHWPFile)
return false;
return m_pHWPFile->Detect();
}
return (nullptr != m_pHWPFile) ? m_pHWPFile->Detect() : false;
case EHanType::HWPX:
{
if (nullptr == m_pHWPXFile)
return false;
return m_pHWPXFile->Detect();
}
return (nullptr != m_pHWPXFile) ? m_pHWPXFile->Detect() : false;
case EHanType::HWPML:
return (nullptr != m_pHWPMLFile) ? m_pHWPMLFile->Detect() : false;
case EHanType::NONE:
return false;
}
@ -132,25 +147,25 @@ bool CWriterContext::Open(const HWP_STRING& sPathToFile, EHanType eHanType)
m_eType = eHanType;
#define OPEN(variable_name, class_name)\
variable_name = new class_name(sPathToFile);\
if (nullptr == variable_name)\
return false;\
return variable_name->Open()
switch (m_eType)
{
case EHanType::HWP:
{
m_pHWPFile = new CHWPFile(sPathToFile);
if (nullptr == m_pHWPFile)
return false;
return m_pHWPFile->Open();
OPEN(m_pHWPFile, CHWPFile);
}
case EHanType::HWPX:
{
m_pHWPXFile = new CHWPXFile(sPathToFile);
if (nullptr == m_pHWPXFile)
return false;
return m_pHWPXFile->Open();
OPEN(m_pHWPXFile, CHWPXFile);
}
case EHanType::HWPML:
{
OPEN(m_pHWPMLFile, CHWPMLFile);
}
case EHanType::NONE:
break;
@ -161,19 +176,24 @@ bool CWriterContext::Open(const HWP_STRING& sPathToFile, EHanType eHanType)
void CWriterContext::Close()
{
#define CLOSE(variable_name)\
if (nullptr != variable_name)\
variable_name->Close();\
break
switch (m_eType)
{
case EHanType::HWP:
{
if (nullptr != m_pHWPFile)
m_pHWPFile->Close();
break;
CLOSE(m_pHWPFile);
}
case EHanType::HWPX:
{
if (nullptr != m_pHWPXFile)
m_pHWPXFile->Close();
break;
CLOSE(m_pHWPXFile);
}
case EHanType::HWPML:
{
CLOSE(m_pHWPMLFile);
}
case EHanType::NONE:
break;
@ -198,7 +218,7 @@ const CHWPDocInfo* CWriterContext::GetDocInfo()
return m_pHWPXFile->GetDocInfo();
}
case EHanType::NONE:
default:
return nullptr;
}
}

8
HwpFile/HwpDoc/Common/WriterContext.h
View File

@ -4,6 +4,7 @@
#include "../HanType.h"
#include "../HWPFile.h"
#include "../HWPXFile.h"
#include "../HWPMLFile.h"
#include "../HWPElements/HWPRecordParaShape.h"
#include "../HWPElements/HWPRecordStyle.h"
@ -16,9 +17,10 @@ namespace HWP
{
class CWriterContext
{
EHanType m_eType;
CHWPFile* m_pHWPFile;
CHWPXFile* m_pHWPXFile;
EHanType m_eType;
CHWPFile* m_pHWPFile;
CHWPXFile* m_pHWPXFile;
CHWPMLFile* m_pHWPMLFile;
public:
CWriterContext();
~CWriterContext();

2
HwpFile/HwpDoc/Conversion/Converter2OOXML.cpp
View File

@ -1442,7 +1442,7 @@ bool CConverter2OOXML::SaveSVGFile(const HWP_STRING& sSVG, HWP_STRING& sFileName
HWP_STRING CConverter2OOXML::SavePicture(const HWP_STRING& sBinItemId, TConversionState& oState)
{
if (nullptr == m_pContext)
if (nullptr == m_pContext || sBinItemId.empty())
return HWP_STRING();
//TODO:: добавить поддержку устновки размеров изображения из свойств шейпа

100
HwpFile/HwpDoc/HWPMLFile.cpp Normal file
View File

@ -0,0 +1,100 @@
#include "HWPMLFile.h"
#include "../../DesktopEditor/common/File.h"
namespace HWP
{
CHWPMLFile::CHWPMLFile(const HWP_STRING &wsFilePath)
: m_wsFilePath(wsFilePath)
{}
CHWPMLFile::~CHWPMLFile()
{
CLEAR_ARRAY(CHWPSection, m_arSections);
}
bool CHWPMLFile::Open()
{
if (m_wsFilePath.empty() || !NSFile::CFileBinary::Exists(m_wsFilePath) || !Detect())
return false;
CXMLReader oReader;
oReader.GetReader()->FromFile(m_wsFilePath);
oReader.ReadNextNode();
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
if ("HEAD" == sNodeName)
ReadHead(oReader);
else if ("BODY" == sNodeName)
ReadBody(oReader);
else if ("TAIL" == sNodeName)
ReadTail(oReader);
}
END_WHILE
return true;
}
bool CHWPMLFile::Detect() const
{
if (m_wsFilePath.empty())
return false;
CXMLReader oReader;
if (nullptr == oReader.GetReader() || !oReader.GetReader()->FromFile(m_wsFilePath))
return false;
if (!oReader.ReadNextNode() && "HWPML" != oReader.GetName())
return false;
return true;
}
void CHWPMLFile::Close()
{}
void CHWPMLFile::ReadHead(CXMLReader &oReader)
{
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
}
END_WHILE
}
void CHWPMLFile::ReadBody(CXMLReader &oReader)
{
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
if ("SECTION" == sNodeName)
ReadSection(oReader, 0);
}
END_WHILE
}
void CHWPMLFile::ReadTail(CXMLReader &oReader)
{
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
}
END_WHILE
}
void CHWPMLFile::ReadSection(CXMLReader &oReader, int nVersion)
{
CHWPSection* pSection = new CHWPSection();
if (pSection->Parse(oReader, nVersion, EHanType::HWPML))
m_arSections.push_back(pSection);
else
delete pSection;
}
VECTOR<const CHWPSection*> CHWPMLFile::GetSections() const
{
RETURN_VECTOR_CONST_PTR(CHWPSection, m_arSections);
}
}

31
HwpFile/HwpDoc/HWPMLFile.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef CHWPMLFILE_H
#define CHWPMLFILE_H
#include "Common/XMLReader.h"
#include "HWPSection.h"
namespace HWP
{
class CHWPMLFile
{
HWP_STRING m_wsFilePath;
VECTOR<CHWPSection*> m_arSections;
void ReadHead(CXMLReader& oReader);
void ReadBody(CXMLReader& oReader);
void ReadTail(CXMLReader& oReader);
void ReadSection(CXMLReader& oReader, int nVersion);
public:
CHWPMLFile(const HWP_STRING& wsFilePath);
~CHWPMLFile();
bool Open();
bool Detect() const;
void Close();
VECTOR<const CHWPSection*> GetSections() const;
};
}
#endif // CHWPMLFILE_H

8
HwpFile/HwpDoc/HWPSection.cpp
View File

@ -1,6 +1,6 @@
#include "HWPSection.h"
#include "HWPElements/HWPTag.h"
#include "Common/NodeNames.h"
#include "HwpDoc/Paragraph/CtrlEqEdit.h"
#include "Paragraph/CtrlTable.h"
@ -111,10 +111,10 @@ CHWPSection::~CHWPSection()
CLEAR_ARRAY(CHWPPargraph, m_arParas);
}
bool CHWPSection::Parse(CXMLReader& oReader, int nVersion)
bool CHWPSection::Parse(CXMLReader& oReader, int nVersion, EHanType eType)
{
WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hp:p")
m_arParas.push_back(new CHWPPargraph(oReader, nVersion));
WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, GetNodeName(ENode::Paragraph, eType))
m_arParas.push_back(new CHWPPargraph(oReader, nVersion, eType));
END_WHILE
return true;

5
HwpFile/HwpDoc/HWPSection.h
View File

@ -15,9 +15,10 @@ class CHWPSection
public:
CHWPSection();
~CHWPSection();
bool Parse(CXMLReader& oReader, int nVersion);
bool Parse(CXMLReader& oReader, int nVersion, EHanType eType);
bool Parse(CHWPStream& oBuffer, int nVersion);
bool ParseHWPML(CXMLReader &oReader, 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);
int ParseContainerRecurse(CCtrlContainer* oContainer, int nRunLevel, CHWPStream& oBuffer, int nOff, int nVersion);

2
HwpFile/HwpDoc/HWPXFile.cpp
View File

@ -176,7 +176,7 @@ bool CHWPXFile::ReadSection(const HWP_STRING& sName, int nVersion)
return false;
CHWPSection* pSection = new CHWPSection();
const bool bResult = pSection->Parse(oReader, nVersion);
const bool bResult = pSection->Parse(oReader, nVersion, EHanType::HWPX);
if (bResult)
m_arSections.push_back(pSection);

1
HwpFile/HwpDoc/HanType.h
View File

@ -7,6 +7,7 @@ enum class EHanType
{
NONE,
HWP,
HWPML,
HWPX
};
}

2
HwpFile/HwpDoc/Paragraph/CapParagraph.cpp
View File

@ -7,7 +7,7 @@ CCapParagraph::CCapParagraph()
{}
CCapParagraph::CCapParagraph(CXMLReader& oReader, int nVersion)
: CHWPPargraph(oReader, nVersion)
: CHWPPargraph(oReader, nVersion, EHanType::HWPX)
{}
EParagraphType CCapParagraph::GetType() const

2
HwpFile/HwpDoc/Paragraph/CellParagraph.cpp
View File

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

2
HwpFile/HwpDoc/Paragraph/CtrlGeneralShape.cpp
View File

@ -243,7 +243,7 @@ void CCtrlGeneralShape::ReadSubList(CXMLReader& oReader, int nVersion)
WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hp:p")
{
CHWPPargraph* pParagraph = new CHWPPargraph(oReader, nVersion);
CHWPPargraph* pParagraph = new CHWPPargraph(oReader, nVersion, EHanType::HWPX);
if (nullptr == pParagraph)
continue;

2
HwpFile/HwpDoc/Paragraph/CtrlHeadFoot.cpp
View File

@ -47,7 +47,7 @@ CCtrlHeadFoot::CCtrlHeadFoot(const HWP_STRING& sCtrlID, CXMLReader& oReader, int
END_READ_ATTRIBUTES(oReader)
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Child, "hp:p")
m_arParas.push_back(new CHWPPargraph(oReader, nVersion));
m_arParas.push_back(new CHWPPargraph(oReader, nVersion, EHanType::HWPX));
END_WHILE
}
END_WHILE

2
HwpFile/HwpDoc/Paragraph/CtrlNote.cpp
View File

@ -21,7 +21,7 @@ CCtrlNote::CCtrlNote(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersio
{
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));
m_arParas.push_back(new CHWPPargraph(oReader, nVersion, EHanType::HWPX));
END_WHILE
END_WHILE

81
HwpFile/HwpDoc/Paragraph/HWPPargraph.cpp
View File

@ -19,6 +19,8 @@
#include "CtrlShapeVideo.h"
#include "ParaText.h"
#include "../Common/NodeNames.h"
#include "../../../DesktopEditor/common/File.h"
namespace HWP
@ -27,23 +29,23 @@ CHWPPargraph::CHWPPargraph()
: m_pLineSegs(nullptr)
{}
CHWPPargraph::CHWPPargraph(CXMLReader& oReader, int nVersion)
CHWPPargraph::CHWPPargraph(CXMLReader& oReader, int nVersion, EHanType eType)
: m_chBreakType(0), m_pLineSegs(nullptr)
{
START_READ_ATTRIBUTES(oReader)
{
if ("paraPrIDRef" == sAttributeName)
if (GetArgumentName(EArgument::ParaShape, eType) == sAttributeName)
m_shParaShapeID = oReader.GetInt();
else if ("styleIDRef" == sAttributeName)
else if (GetArgumentName(EArgument::Style, eType) == sAttributeName)
m_shParaStyleID = oReader.GetInt();
else if ("pageBreak" == sAttributeName)
else if (GetArgumentName(EArgument::PageBreak, eType) == sAttributeName)
{
if (oReader.GetBool())
m_chBreakType |= 0b00000100;
else
m_chBreakType &= 0b11111011;
}
else if ("columnBreak" == sAttributeName)
else if (GetArgumentName(EArgument::ColumnBreak, eType) == sAttributeName)
{
if (oReader.GetBool())
m_chBreakType |= 0b00001000;
@ -57,17 +59,17 @@ CHWPPargraph::CHWPPargraph(CXMLReader& oReader, int nVersion)
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
if ("hp:run" == sNodeName)
if (GetNodeName(ENode::Text, eType) == sNodeName)
{
nCharShapeID = oReader.GetAttributeInt("charPrIDRef");
nCharShapeID = oReader.GetAttributeInt(GetArgumentName(EArgument::CharShape, eType));
WHILE_READ_NEXT_NODE_WITH_DEPTH(oReader, Child)
ParseHWPParagraph(oReader, nCharShapeID, nVersion);
ParseHWPParagraph(oReader, nCharShapeID, nVersion, eType);
END_WHILE
}
else if ("hp:linesegarray" == sNodeName)
else if (GetNodeName(ENode::LinesegArray, eType) == sNodeName)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Child, "hp:lineseg")
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Child, GetNodeName(ENode::Lineseg, eType))
{
m_pLineSegs = new CLineSeg(oReader, nVersion);
break;
@ -87,21 +89,21 @@ CHWPPargraph::~CHWPPargraph()
delete m_pLineSegs;
}
bool CHWPPargraph::ParseHWPParagraph(CXMLReader& oReader, int nCharShapeID, int nVersion)
bool CHWPPargraph::ParseHWPParagraph(CXMLReader& oReader, int nCharShapeID, int nVersion, HWP::EHanType eType)
{
const size_t unCurrentParaCount = m_arP.size();
const std::string sNodeName{oReader.GetName()};
if ("hp:secPr" == sNodeName)
if (GetNodeName(ENode::SectionDef, eType) == sNodeName)
m_arP.push_back(new CCtrlSectionDef(L"dces", oReader, nVersion));
else if ("hp:ctrl" == sNodeName)
else if (GetNodeName(ENode::Ctrl, eType) == sNodeName)
{
WHILE_READ_NEXT_NODE(oReader)
AddCtrl(CCtrl::GetCtrl(oReader, nVersion));
END_WHILE
}
else if ("hp:t" == sNodeName)
else if (GetNodeName(ENode::Char, eType) == sNodeName)
{
if (oReader.IsEmptyNode())
return false;
@ -128,60 +130,60 @@ bool CHWPPargraph::ParseHWPParagraph(CXMLReader& oReader, int nCharShapeID, int
{
const std::string sChildNodeName{oReader.GetName()};
if ("hp:lineBreak" == sChildNodeName)
if (GetNodeName(ENode::LineBreak, eType) == 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)
else if (GetNodeName(ENode::Tab, eType) == sChildNodeName)
m_arP.push_back(new CCtrlCharacter(L" _", ECtrlCharType::TABULATION));
else if (GetNodeName(ENode::Hyphen, eType) == sChildNodeName)
m_arP.push_back(new CCtrlCharacter(L" _", ECtrlCharType::HARD_HYPHEN));
else if (GetNodeName(ENode::NbSpace, eType) == sChildNodeName ||
GetNodeName(ENode::FwSpace, eType) == sChildNodeName)
m_arP.push_back(new CCtrlCharacter(L" _", ECtrlCharType::HARD_SPACE));
}
}
}
else if ("hp:tbl" == sNodeName)
else if (GetNodeName(ENode::Table, eType) == sNodeName)
m_arP.push_back(new CCtrlTable(L" lbt", oReader, nVersion));
else if ("hp:pic" == sNodeName)
else if (GetNodeName(ENode::Picture, eType) == sNodeName)
m_arP.push_back(new CCtrlShapePic(L"cip$", oReader, nVersion));
else if ("hp:container" == sNodeName)
else if (GetNodeName(ENode::Container, eType) == sNodeName)
m_arP.push_back(new CCtrlContainer(L"noc$", oReader, nVersion));
else if ("hp:ole" == sNodeName)
else if (GetNodeName(ENode::Ole, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeOle(L"elo$", oReader, nVersion));
else if ("hp:equation" == sNodeName)
else if (GetNodeName(ENode::Equation, eType) == sNodeName)
m_arP.push_back(new CCtrlEqEdit(L"deqe", oReader, nVersion));
else if ("hp:line" == sNodeName)
else if (GetNodeName(ENode::Line, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeLine(L"nil$", oReader, nVersion));
else if ("hp:rect" == sNodeName)
else if (GetNodeName(ENode::Rectangle, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeRect(L"cer$", oReader, nVersion));
else if ("hp:ellipse" == sNodeName)
else if (GetNodeName(ENode::Ellipse, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeEllipse(L"lle$", oReader, nVersion));
else if ("hp:arc" == sNodeName)
else if (GetNodeName(ENode::Arc, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeArc(L"cra$", oReader, nVersion));
else if ("hp:polygon" == sNodeName)
else if (GetNodeName(ENode::Polygon, eType) == sNodeName)
m_arP.push_back(new CCtrlShapePolygon(L"lop$", oReader, nVersion));
else if ("hp:curve" == sNodeName)
else if (GetNodeName(ENode::Curve, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeCurve(L"ruc$", oReader, nVersion));
else if ("hp:connectLine" == sNodeName)
else if (GetNodeName(ENode::ConnectLine, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeConnectLine(L"loc$", oReader, nVersion));
else if ("hp:textart" == sNodeName)
else if (GetNodeName(ENode::TextArt, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeTextArt(L"tat$", oReader, nVersion));
else if ("hp:video" == sNodeName)
else if (GetNodeName(ENode::Video, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeVideo(L"div$", oReader, nVersion));
if (unCurrentParaCount != m_arP.size())
return true;
if ("hp:switch" == sNodeName)
if (GetNodeName(ENode::Switch, eType) == sNodeName)
{
WHILE_READ_NEXT_NODE(oReader)
{
if ("hp:case" != oReader.GetName() &&
"hp:default" != oReader.GetName())
if (GetNodeName(ENode::Case, eType) != oReader.GetName() &&
GetNodeName(ENode::Default, eType) != oReader.GetName())
continue;
WHILE_READ_NEXT_NODE(oReader)
if (ParseHWPParagraph(oReader, nCharShapeID, nVersion))
if (ParseHWPParagraph(oReader, nCharShapeID, nVersion, eType))
return true;
END_WHILE
}
@ -191,7 +193,6 @@ bool CHWPPargraph::ParseHWPParagraph(CXMLReader& oReader, int nCharShapeID, int
return false;
}
EParagraphType CHWPPargraph::GetType() const
{
return EParagraphType::Normal;

5
HwpFile/HwpDoc/Paragraph/HWPPargraph.h
View File

@ -5,6 +5,7 @@
#include "RangeTag.h"
#include "Ctrl.h"
#include "../Common/XMLReader.h"
#include "../HanType.h"
namespace HWP
{
@ -26,10 +27,10 @@ class CHWPPargraph : public IRef
VECTOR<CCtrl*> m_arP; //HWPTAG_PARA_TEXT
bool ParseHWPParagraph(CXMLReader& oReader, int nCharShapeID, int nVersion);
bool ParseHWPParagraph(CXMLReader& oReader, int nCharShapeID, int nVersion, EHanType eType);
public:
CHWPPargraph();
CHWPPargraph(CXMLReader& oReader, int nVersion);
CHWPPargraph(CXMLReader& oReader, int nVersion, EHanType eType);
virtual ~CHWPPargraph();
virtual EParagraphType GetType() const;