pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-02-10 18:05:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

Added the implementation of the object property parse in HWPML

Browse Source
This commit is contained in:
Kirill Polyakov
2025-09-11 23:33:24 +03:00
parent 2ee94c4920
commit d5434f190f
57 changed files with 1311 additions and 483 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
HwpFile/HwpDoc/Common/Common.h
View File

@ -1,6 +1,7 @@
#ifndef COMMON_H
#define COMMON_H
#include <algorithm>
#include <string>
#include <vector>
#include <list>
@ -45,6 +46,8 @@ typedef char HWP_BYTE;
arTempVector[unIndex] = dynamic_cast<const type*>(array_values[unIndex]); \
return arTempVector
#define TO_LOWER(value) std::transform(value.begin(), value.end(), value.begin(), tolower)
class IRef
{
unsigned long m_ulRef;

610
HwpFile/HwpDoc/Common/NodeNames.h
View File

@ -1,16 +1,66 @@
#ifndef NODENAMES_H
#define NODENAMES_H
#define MAX_TYPES 2
#define MAX_NODES 100
#include "../HanType.h"
namespace HWP
{
enum class ENode
{
Body,
//HEAD
BeginNum,
FaceNameList,
FontFace,
Font,
SubFont,
TypeInfo,
BorderFillList,
BorderFill,
LeftBorder,
RightBorder, //10
TopBorder,
BottomBorder,
Diagonal,
FillBrush,
WindowBrush,
Gradation,
Color,
ImageBrush,
Image,
CharShapeList, //20
CharShape,
FontId,
Ratio,
CharSpacing,
RelSize,
CharOffset,
Italic,
Bold,
Underline,
Outline, //30
Shadow,
Emboss,
Engrave,
SuperScript,
SubScript,
TabDefList,
TabDef,
TabItem,
NumberingList,
Numbering, //40
ParaHead,
BulletList,
Bullet,
//ParaHead
ParaShapeList,
ParaShape,
ParaMargin,
ParaBorder,
StyleList,
Style,
//BODY
Body, //50
Section,
Paragraph,
Text,
@ -20,7 +70,7 @@ enum class ENode
Picture,
Container,
Ole,
Equation,
Equation, //60
TextArt,
Line,
Rectangle,
@ -30,11 +80,10 @@ enum class ENode
Curve,
ConnectLine,
Tab,
LineBreak,
LineBreak, //70
Hyphen,
NbSpace,
FwSpace,
//Only hwpx
Ctrl,
@ -43,14 +92,72 @@ enum class ENode
Video,
Switch,
Case,
Default
Default,
Slash,
BackSlash
};
#define MAX_TYPES 2
#define MAX_NODES 100
static constexpr const char* NODE_NAMES[MAX_TYPES][MAX_NODES] =
{
// HWPX
{
"",
//HEAD
"hh:beginNum",
"hh:fontfaces",
"hh:fontface",
"hh:font",
"hh:substFont",
"hh:typeInfo",
"hh:borderFills",
"hh:borderFill",
"hh:leftBorder",
"hh:rightBorder", //10
"hh:topBorder",
"hh:bottomBorder",
"hh:diagonal",
"hc:fillBrush",
"hc:winBrush",
"hc:gradation",
"hc:color",
"hc:imgBrush",
"hc:img",
"h:charProperties", //20
"hh:charPr",
"hh:fontRef",
"hh:ratio",
"hh:spacing",
"hh:relSz",
"hh:offset",
"hh:italic",
"hh:bold",
"hh:underline",
"hh:outline", //30
"hh:shadow",
"hh:emboss",
"hh:engrave",
"hh:supscript",
"hh:subscript",
"hh:tabProperties",
"hh:tabPr",
"hh:tabPr",
"hh:numberings",
"hh:numbering", //40
"hh:paraHead",
"hh:bullets",
"hh:bullet",
//"PARAHEAD",
"hh:paraProperties",
"hh:paraPr",
"hh:margin",
"hh:border",
"hh:styles",
"hh:style",
//BODY
"", //50
"hs:sec",
"hp:p",
"hp:run",
@ -60,7 +167,7 @@ static constexpr const char* NODE_NAMES[MAX_TYPES][MAX_NODES] =
"hp:pic",
"hp:container",
"hp:ole",
"hp:equation",
"hp:equation", //60
"hp:textart",
"hp:line",
"hp:rect",
@ -70,7 +177,7 @@ static constexpr const char* NODE_NAMES[MAX_TYPES][MAX_NODES] =
"hp:curve",
"hp:connectLine",
"hp:tab",
"hp:lineBreak",
"hp:lineBreak", //70
"hp:hyphen",
"hp:nbSpace",
"hp:fwSpace"
@ -85,7 +192,59 @@ static constexpr const char* NODE_NAMES[MAX_TYPES][MAX_NODES] =
},
// HWPML
{
"BODY",
//HEAD
"BEGINNUMBER",
"FACENAMELIST",
"FONTFACE",
"FONT",
"SUBSTFONT",
"TYPEINFO",
"BORDERFILLLIST",
"BORDERFILL",
"LEFTBORDER",
"RIGHTBORDER", //10
"TOPBORDER",
"BOTTOMBORDER",
"DIAGONAL",
"FILLBRUSH",
"WINDOWBRUSH",
"GRADATION",
"COLOR",
"IMAGEBRUSH",
"IMAGE",
"CHARSHAPELIST", //20
"CHARSHAPE",
"FONTID",
"RATIO",
"CHARSPACING",
"RELSIZE",
"CHAROFFSET",
"ITALIC",
"BOLD",
"UNDERLINE",
"OUTLINE", //30
"SHADOW",
"EMBOSS",
"ENGRAVE",
"SUPERSCRIPT",
"SUBSCRIPT",
"TABDEFLIST",
"TABDEF",
"TABITEM",
"NUMBERINGLIST",
"NUMBERING", //40
"PARAHEAD",
"BULLETLIST",
"BULLET",
//"PARAHEAD",
"PARASHAPELIST",
"PARASHAPE",
"PARAMARGIN",
"PARABORDER",
"STYLELIST",
"STYLE",
//BODY
"BODY", //50
"SECTION",
"P",
"TEXT",
@ -95,7 +254,7 @@ static constexpr const char* NODE_NAMES[MAX_TYPES][MAX_NODES] =
"PICTURE",
"CONTAINER",
"OLE",
"EQUATION",
"EQUATION", //60
"TEXTART",
"LINE",
"RECTANGLE",
@ -105,7 +264,7 @@ static constexpr const char* NODE_NAMES[MAX_TYPES][MAX_NODES] =
"CURVE",
"CONNECTLINE",
"TAB",
"LINEBREAK",
"LINEBREAK", //70
"HYPHEN",
"NBSPACE",
"FWSPACE",
@ -130,50 +289,449 @@ inline const char* GetNodeName(ENode eNode, EHanType eType)
}
}
#define MAX_ARGUMENTS 6
enum class EArgument
enum class EAttribute
{
ParaShape,
Style,
CharShape,
Href,
SubPath,
MediaType,
Type,
FontName,
FamilyType,
SerifStyle, //10
Weight,
Proportion,
Contrast,
StrokeVariation,
ArmStyle,
Letterform,
Midline,
XHeight,
ThreeD,
Shadow, //20
Slash,
BackSlash,
CrookedSlash,
CounterSlash,
CounterBackSlash,
BreakCellSeparateLine,
Width,
Color,
FaceColor,
HatchColor, //30
HatchStyle,
Alpha,
Angle,
CenterX,
CenterY,
Step,
ColorNum,
StepCenter,
Value,
Mode, //40
Bright,
Effect,
BinItem,
Height,
TextColor,
ShadeColor,
UseFontSpace,
UseKerning,
SymMask,
BorderFillId, //50
Shape,
OffsetX,
OffsetY,
AutoTabLeft,
AutoTabRight,
Leader,
Start,
Level,
Aligment,
UseInstWidth, //60
AutoIndent,
WidthAdjust,
TextOffsetType,
TextOffset,
NumFormat,
Char,
Image,
Align,
VerAlign,
HeadingType, //70
TabDef,
BreakLatinWord,
BreakNonLatinWord,
Condense,
WidowOrphan,
KeepWithNext,
KeepLines,
PageBreakBefore,
FontLineHeight,
SnapToGrid, //80
LineWrap,
AutoSpaceEAsianEng,
AutoSpaceEAsianNum,
Indent,
Left,
Right,
Prev,
Next,
LineSpacingType,
LineSpacing, //90
BorderFill,
OffsetLeft,
OffsetRight,
OffsetTop,
OffsetBottom,
Connect,
IgnoreMargin,
EngName,
NextStyle,
LangId, //100
InstId,
LockForm,
Name,
PageBreak,
ColumnBreak,
CharShape
};
static constexpr const char* ARGUMENT_NAMES[MAX_TYPES][MAX_ARGUMENTS] =
#define MAX_ATTRIBUTES 110
//TODO:: добавить все аргументы
static constexpr const char* ATTRUBUTE_NAMES[MAX_TYPES][MAX_ATTRIBUTES] =
{
// HWPX
{
"paraPrIDRef",
"styleIDRef",
"id",
"charPrIDRef",
"href",
"sub-path",
"media-type",
"type",
"face",
"familyType",
"serifStyle", //10
"weight",
"proportion",
"contrast",
"strokeVariation",
"armStyle",
"letterform",
"midline",
"xHeight",
"threeD",
"shadow", //20
"",
"",
"",
"",
"",
"breakCellSeparateLine",
"width",
"color",
"faceColor",
"hatchColor", //30
"hatchStyle",
"alpha",
"angle",
"centerX",
"centerY",
"step",
"colorNum",
"stepCenter",
"value",
"mode", //40
"bright",
"effect",
"binaryItemIDRef",
"height",
"textColor",
"shadeColor",
"useFontSpace",
"useKerning",
"symMark",
"borderFillIDRef",//50
"shape",
"offsetX",
"offsetY",
"autoTabLeft",
"autoTabRight",
"leader",
"start",
"level",
"align",
"useInstWidth", //60
"autoIndent",
"widthAdjust",
"textOffsetType",
"textOffset",
"numFormat",
"charPrIDRef",
"",
"",
"",
"", //70
"tabPrIDRef",
"breakLatinWord",
"breakNonLatinWord",
"",
"widowOrphan",
"keepWithNext",
"",
"pageBreakBefore",
"",
"", //80
"LineWrap",
"eAsianEng",
"eAsianNum",
"",
"",
"",
"",
"",
"",
"", //90
"borderFillIDRef",
"offsetLeft",
"offsetRight",
"offsetTop",
"offsetBottom",
"connect",
"ignoreMargin",
"engName",
"nextStyleIDRef",
"langID", //100
""
"lockForm",
"name",
"pageBreak",
"columnBreak",
"charPrIDRef"
},
// HWPML
{
"ParaShape",
"Style",
"CharShape",
"APath",
"RPath",
"Format",
"Type",
"Name",
"FamilyType",
"SerifStyle", //10
"Weight",
"Proportion",
"Contrast",
"StrokeVariation",
"ArmStyle",
"Letterform",
"Midline",
"XHeight",
"ThreeD",
"Shadow", //20
"Slash",
"BackSlash",
"CrookedSlash",
"CounterSlash",
"CounterBackSlash",
"BreakCellSeparateLine",
"Width",
"Color",
"FaceColor",
"HatchColor", //30
"HatchStyle",
"Alpha",
"Angle",
"CenterX",
"CenterY",
"Step",
"ColorNum",
"StepCenter",
"Value",
"Mode", //40
"Bright",
"Effect",
"BinItem",
"Height",
"TextColor",
"ShadeColor",
"UseFontSpace",
"UseKerning",
"SymMask",
"BorderFillId", //50
"Shape",
"OffsetX",
"OffsetY",
"AutoTabLeft",
"AutoTabRight",
"Leader",
"Start",
"Level",
"Aligment",
"UseInstWidth", //60
"AutoIndent",
"WidthAdjust",
"TextOffsetType",
"TextOffset",
"NumFormat",
"Char",
"Image",
"Align",
"VerAlign",
"HeadingType", //70
"TabDef",
"BreakLatinWord",
"BreakNonLatinWord",
"Condense",
"WidowOrphan",
"KeepWithNext",
"KeepLines",
"PageBreakBefore",
"FontLineHeight",
"SnapToGrid", //80
"LineWrap",
"AutoSpaceEAsianEng",
"AutoSpaceEAsianNum",
"Indent",
"Left",
"Right",
"Prev",
"Next",
"LineSpacingType",
"LineSpacing", //90
"BorderFill",
"OffsetLeft",
"OffsetRight",
"OffsetTop",
"OffsetBottom",
"Connect",
"IgnoreMargin",
"EngName",
"NextStyle",
"LangId", //100
"InstId",
"LockForm",
"Name",
"PageBreak",
"ColumnBreak",
"CharShape"
"ColumnBreak"
}
};
inline const char* GetArgumentName(EArgument eNode, EHanType eType)
inline const char* GetAttributeName(EAttribute 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)];
case EHanType::HWPX: return ATTRUBUTE_NAMES[0][static_cast<int>(eNode)];
case EHanType::HWPML: return ATTRUBUTE_NAMES[1][static_cast<int>(eNode)];
default: return "";
}
}
#define MAX_VALUES 40
// TODO:: пока всё в одном месте. Возможно стоит лучше разделить по соответствующим классам
enum class EValue
{
None,
Center,
CenterBelow,
CenterAbove,
All,
RealPic,
GrayScale,
BlackWhite,
Drop,
Continuous, //10
Left,
Right,
Percent,
HwpUnit,
Digit,
HangulSyllable,
HangulJamo,
CircledDigit,
LatinSmall,
CircledHangulSyllable, //20
CircledHangulJamo,
RomanSmall,
Para,
Char
};
static constexpr const char* VALUE_NAMES[MAX_TYPES][MAX_VALUES] =
{
//HWPX
{
"NONE",
"CENTER",
"CENTER_BELOW",
"CENTER_ABOVE",
"ALL",
"REAL_PIC",
"GRAY_SCALE",
"BLACK_WHITE",
"DROP",
"CONTINUOUS", //10
"LEFT",
"RIGHT",
"PERCENT",
"HWPUNIT",
"DIGIT",
"HANGUL_SYLLABLE",
"HANGUL_JAMO",
"CIRCLED_DIGIT",
"LATIN_SMALL",
"CIRCLED_HANGUL_SYLLABLE", //20
"CIRCLED_HANGUL_JAMO",
"ROMAN_SMALL",
"PARA",
"CHAR"
},
//HWPML
{
"None",
"Center",
"CenterBelow",
"CenterAbove",
"All",
"RealPic",
"GrayScale",
"BlackWhite",
"Drop",
"Cont", //10
"Left",
"Right",
"Percent",
"HwpUnit",
"Digit",
"HangulSyllable",
"HangulJamo",
"CircledDigit",
"LatinSmall",
"CircledHangulSyllable", //20
"CircledHangulJamo",
"RomanSmall",
"Para",
"Char"
}
};
inline const char* GetValueName(EValue eValue, EHanType eType)
{
switch (eType)
{
case EHanType::HWPX: return VALUE_NAMES[0][static_cast<int>(eValue)];
case EHanType::HWPML: return VALUE_NAMES[1][static_cast<int>(eValue)];
default: return "";
}
}
}
#endif // NODENAMES_H

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

@ -218,6 +218,13 @@ const CHWPDocInfo* CWriterContext::GetDocInfo()
return m_pHWPXFile->GetDocInfo();
}
case EHanType::HWPML:
{
if (nullptr == m_pHWPMLFile)
return nullptr;
return m_pHWPMLFile->GetDocInfo();
}
default:
return nullptr;
}

58
HwpFile/HwpDoc/Common/XMLReader.cpp
View File

@ -31,12 +31,54 @@ bool CXMLReader::IsEmptyNode()
bool CXMLReader::GetBool()
{
return "1" == GetTextAValue(*this);
return "1" == GetTextAValue(*this) || "true" == GetTextAValue(*this);
}
int StringToInt(const std::string& sValue, const int& _default)
{
std::string::const_iterator itPos{sValue.cbegin()};
while (std::isspace(*itPos))
++itPos;
if (sValue.cend() == itPos)
return _default;
bool bNegative = false;
while ('-' == *itPos || '+' == *itPos)
{
if ('-' == *itPos)
bNegative = !bNegative;
++itPos;
}
if (sValue.cend() == itPos)
return _default;
int nResult = 0;
while (itPos != sValue.cend() && std::isdigit(*itPos))
{
nResult = nResult * 10 + (*itPos - '0');
++itPos;
}
return bNegative ? -nResult : nResult;
}
int CXMLReader::GetColor(const int& nDefault)
{
return ConvertHexToInt(GetTextAValue(*this), nDefault);
const std::string sValue{GetTextAValue(*this)};
if (sValue.empty())
return nDefault;
if ('#' == sValue[0])
return ConvertHexToInt(sValue, nDefault);
return StringToInt(sValue, nDefault);
}
int CXMLReader::GetInt()
@ -300,24 +342,24 @@ int ConvertWidthToHWP(const std::string& sValue)
return 0;
}
int ConvertHexToInt(const std::string& wsValue, const int& _default)
int ConvertHexToInt(const std::string& sValue, const int& _default)
{
if (wsValue.empty() || "none" == wsValue)
if (sValue.empty() || "none" == sValue)
return _default;
std::string::const_iterator itStart = wsValue.cbegin();
std::string::const_iterator itStart = sValue.cbegin();
if ('#' == *itStart)
++itStart;
if (wsValue.cend() - itStart < 6)
if (sValue.cend() - itStart != 6)
return _default;
itStart = wsValue.cend() - 6;
itStart = sValue.cend() - 6;
int nResult = 0;
while (itStart != wsValue.cend())
while (itStart != sValue.cend())
{
if ('0' <= *itStart && *itStart <= '9')
nResult = (nResult << 4) | (*itStart++ - '0');

139
HwpFile/HwpDoc/HWPDocInfo.cpp
View File

@ -12,6 +12,8 @@
#include "HWPElements/HWPRecordStyle.h"
#include "HWPElements/HwpRecordTabDef.h"
#include "Common/NodeNames.h"
namespace HWP
{
ECompatDoc GetCompatDoc(int nValue)
@ -38,6 +40,10 @@ CHWPDocInfo::CHWPDocInfo(CHWPFile* pHWPFile)
: m_eHanType(EHanType::HWP), m_pParentHWP(pHWPFile), m_eCompatibleDoc(ECompatDoc::HWP)
{}
CHWPDocInfo::CHWPDocInfo(CHWPMLFile* pHWPMLFile)
: m_eHanType(EHanType::HWPML), m_pParentHWPML(pHWPMLFile), m_eCompatibleDoc(ECompatDoc::UNKNOWN)
{}
CHWPDocInfo::~CHWPDocInfo()
{
#define REMOVE_LIST_DATA(array) \
@ -196,58 +202,26 @@ bool CHWPDocInfo::Parse(CXMLReader& oReader, int nVersion)
return true;
}
bool CHWPDocInfo::ReadRefList(CXMLReader& oReader, int nVersion)
bool CHWPDocInfo::Parse(CXMLReader &oReader)
{
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
if ("hh:fontfaces" == sNodeName)
if ("MAPPINGTABLE" == sNodeName)
{
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 ("hh:borderFills" == sNodeName)
{
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 ("hh:charProperties" == sNodeName)
{
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 ("hh:tabProperties" == sNodeName)
{
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 ("hh:numberings" == sNodeName)
{
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 ("hh:bullets" == sNodeName)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH(oReader, Bullet)
m_arBullets.push_back(new CHWPRecordBullet(*this, oReader, nVersion));
END_WHILE
}
else if ("hh:paraProperties" == sNodeName)
{
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 ("hh:styles" == sNodeName)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Style, "hh:style")
m_arStyles.push_back(new CHWPRecordStyle(*this, oReader, nVersion));
WHILE_READ_NEXT_NODE_WITH_DEPTH_AND_NAME(oReader, Mapping)
{
if ("BINDATALIST" == sNodeMappingName)
{
CHWPRecordBinData *pRecordBinData = nullptr;
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, BinData, "BINITEM")
pRecordBinData = new CHWPRecordBinData(oReader, 0, EHanType::HWPML);
m_mBinDatas.insert(std::make_pair<HWP_STRING, CHWPRecord*>(pRecordBinData->GetItemID(), (HWP::CHWPRecord*)pRecordBinData));
END_WHILE
}
else
ReadRefListElement(oReader, 0, EHanType::HWPML);
}
END_WHILE
}
}
@ -256,6 +230,73 @@ bool CHWPDocInfo::ReadRefList(CXMLReader& oReader, int nVersion)
return true;
}
bool CHWPDocInfo::ReadRefList(CXMLReader& oReader, int nVersion)
{
WHILE_READ_NEXT_NODE(oReader)
ReadRefListElement(oReader, nVersion, EHanType::HWPX);
END_WHILE
return true;
}
bool CHWPDocInfo::ReadRefListElement(CXMLReader &oReader, int nVersion, HWP::EHanType eType)
{
const std::string sNodeName{oReader.GetName()};
if (GetNodeName(ENode::FaceNameList, eType) == sNodeName)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, FontFace, GetNodeName(ENode::FontFace, eType))
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Font, GetNodeName(ENode::Font, eType))
m_arFaseNames.push_back(new CHWPRecordFaceName(*this, oReader, nVersion, eType));
END_WHILE
END_WHILE
}
else if (GetNodeName(ENode::BorderFillList, eType) == sNodeName)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, BorderFill, GetNodeName(ENode::BorderFill, eType))
m_arBorderFills.push_back(new CHWPRecordBorderFill(*this, oReader, nVersion, eType));
END_WHILE
}
else if (GetNodeName(ENode::CharShapeList, eType) == sNodeName)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, CharPr, GetNodeName(ENode::CharShape, eType))
m_arCharShapes.push_back(new CHWPRecordCharShape(*this, oReader, nVersion, eType));
END_WHILE
}
else if (GetNodeName(ENode::TabDefList, eType) == sNodeName)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, TabPr, GetNodeName(ENode::TabDef, eType))
m_arTabDefs.push_back(new CHwpRecordTabDef(*this, oReader, nVersion, eType));
END_WHILE
}
else if (GetNodeName(ENode::NumberingList, eType) == sNodeName)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Numbering, GetNodeName(ENode::Numbering, eType))
m_arNumberings.push_back(new CHWPRecordNumbering(*this, oReader, nVersion, eType));
END_WHILE
}
else if (GetNodeName(ENode::BulletList, eType) == sNodeName)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH(oReader, Bullet)
m_arBullets.push_back(new CHWPRecordBullet(*this, oReader, nVersion, eType));
END_WHILE
}
else if (GetNodeName(ENode::ParaShapeList, eType) == sNodeName)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, ParaPr, GetNodeName(ENode::ParaShape, eType))
m_arParaShapes.push_back(new CHWPRecordParaShape(*this, oReader, nVersion, eType));
END_WHILE
}
else if (GetNodeName(ENode::StyleList, eType) == sNodeName)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Style, GetNodeName(ENode::Style, eType))
m_arStyles.push_back(new CHWPRecordStyle(*this, oReader, nVersion, eType));
END_WHILE
}
return true;
}
bool CHWPDocInfo::ReadContentHpf(CXMLReader& oReader, int nVersion)
{
CHWPRecordBinData *pRecordBinData = nullptr;
@ -264,7 +305,7 @@ bool CHWPDocInfo::ReadContentHpf(CXMLReader& oReader, int nVersion)
{
WHILE_READ_NEXT_NODE_WITH_DEPTH_ONE_NAME(oReader, Item, "opf:item")
{
pRecordBinData = new CHWPRecordBinData(oReader, nVersion);
pRecordBinData = new CHWPRecordBinData(oReader, nVersion, EHanType::HWPX);
m_mBinDatas.insert(std::make_pair<HWP_STRING, CHWPRecord*>(pRecordBinData->GetItemID(), (HWP::CHWPRecord*)pRecordBinData));
}
END_WHILE

11
HwpFile/HwpDoc/HWPDocInfo.h
View File

@ -20,11 +20,13 @@ enum class ECompatDoc
class CHWPFile;
class CHWPXFile;
class CHWPMLFile;
class CHWPDocInfo
{
EHanType m_eHanType;
CHWPXFile *m_pParentHWPX;
CHWPFile *m_pParentHWP;
EHanType m_eHanType;
CHWPXFile *m_pParentHWPX;
CHWPFile *m_pParentHWP;
CHWPMLFile *m_pParentHWPML;
VECTOR<CHWPRecord*> m_arRecords;
std::map<HWP_STRING, CHWPRecord*> m_mBinDatas;
@ -42,11 +44,13 @@ public:
CHWPDocInfo(EHanType eHanType);
CHWPDocInfo(CHWPXFile* pHWPXFile);
CHWPDocInfo(CHWPFile* pHWPFile);
CHWPDocInfo(CHWPMLFile* pHWPMLFile);
~CHWPDocInfo();
bool Parse(CHWPStream& oBuffer, int nVersion);
bool Parse(CXMLReader& oReader, int nVersion);
bool Parse(CXMLReader& oReader);
bool ReadContentHpf(CXMLReader& oReader, int nVersion);
const CHWPRecord* GetRecord(int nIndex) const;
@ -66,6 +70,7 @@ public:
ECompatDoc GetCompatibleDoc() const;
private:
bool ReadRefList(CXMLReader& oReader, int nVersion);
bool ReadRefListElement(CXMLReader& oReader, int nVersion, EHanType eType);
};
}

46
HwpFile/HwpDoc/HWPElements/HWPRecordBinData.cpp
View File

@ -1,6 +1,7 @@
#include "HWPRecordBinData.h"
#include "../HWPFile.h"
#include "../Common/NodeNames.h"
#include <iomanip>
#include <regex>
@ -28,7 +29,6 @@ EType GetType(int nValue)
}
}
EState GetState(int nValue)
{
SWITCH(EState, nValue)
@ -74,23 +74,40 @@ CHWPRecordBinData::CHWPRecordBinData(CHWPDocInfo& oDocInfo, int nTagNum, int nLe
oBuffer.Skip(nSize - oBuffer.GetDistanceToLastPos(true));
}
CHWPRecordBinData::CHWPRecordBinData(CXMLReader& oReader, int nVersion)
CHWPRecordBinData::CHWPRecordBinData(CXMLReader& oReader, int nVersion, EHanType eType)
: CHWPRecord(EHWPTag::HWPTAG_BIN_DATA, 0, 0)
{
std::string sType;
HWP_STRING sSubPath;
START_READ_ATTRIBUTES(oReader)
{
if ("id" == sAttributeName)
m_sItemID = oReader.GetText();
else if ("isEmbeded" == sAttributeName)
sType = oReader.GetTextA();
else if ("href" == sAttributeName)
else if (EHanType::HWPX == eType && "isEmbeded" == sAttributeName)
{
const std::string sType = oReader.GetTextA();
if ("0" == sType)
m_eType = EType::LINK;
else if ("1" == sType)
m_eType = EType::EMBEDDING;
}
else if (EHanType::HWPML == eType && "Type" == sAttributeName)
{
const std::string sType = oReader.GetTextA();
if ("Link" == sType)
m_eType = EType::LINK;
else if ("Embedding" == sType)
m_eType = EType::EMBEDDING;
else if ("Storage" == sType)
m_eType = EType::STORAGE;
}
else if (GetAttributeName(EAttribute::Href, eType) == sAttributeName)
m_sAPath = oReader.GetText();
else if ("sub-path" == sAttributeName)
else if (GetAttributeName(EAttribute::SubPath, eType) == sAttributeName)
sSubPath = oReader.GetText();
else if ("media-type" == sAttributeName)
else if (GetAttributeName(EAttribute::MediaType, eType) == sAttributeName)
{
m_sFormat = oReader.GetText();
@ -100,15 +117,10 @@ CHWPRecordBinData::CHWPRecordBinData(CXMLReader& oReader, int nVersion)
}
END_READ_ATTRIBUTES(oReader)
if ("0" == sType)
{
m_eType = EType::LINK;
if (!sSubPath.empty())
m_sAPath = sSubPath;
}
else if ("1" == sType)
m_eType = EType::EMBEDDING;
if (EType::LINK != m_eType || sSubPath.empty())
return;
m_sAPath = sSubPath;
}
HWP_STRING CHWPRecordBinData::GetPath() const

2
HwpFile/HwpDoc/HWPElements/HWPRecordBinData.h
View File

@ -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(CXMLReader& oReader, int nVersion);
CHWPRecordBinData(CXMLReader& oReader, int nVersion, EHanType eType);
HWP_STRING GetPath() const;
HWP_STRING GetItemID() const;

142
HwpFile/HwpDoc/HWPElements/HWPRecordBorderFill.cpp
View File

@ -1,5 +1,7 @@
#include "HWPRecordBorderFill.h"
#include "../Common/NodeNames.h"
namespace HWP
{
EImageFillType GetImageFillType(int nType)
@ -58,15 +60,15 @@ EColorFillPattern GetColorFillPattern(int nPattern)
}
}
void TBorder::Read(CXMLReader& oReader)
void TBorder::Read(CXMLReader& oReader, EHanType eType)
{
START_READ_ATTRIBUTES(oReader)
{
if ("type" == sAttributeName)
if (GetAttributeName(EAttribute::Type, eType) == sAttributeName)
m_eStyle = GetLineStyle2(oReader.GetText());
else if ("color" == sAttributeName)
else if (GetAttributeName(EAttribute::Color, eType) == sAttributeName)
m_nColor = oReader.GetInt();
else if ("width" == sAttributeName)
else if (GetAttributeName(EAttribute::Width, eType) == sAttributeName)
m_chWidth = (HWP_BYTE)ConvertWidthToHWP(oReader.GetTextA());
}
END_READ_ATTRIBUTES(oReader)
@ -154,112 +156,112 @@ CFill::CFill(CHWPStream& oBuffer, int nOff, int nSize)
m_nSize = oBuffer.GetDistanceToLastPos(true);
}
CFill::CFill(CXMLReader& oReader)
CFill::CFill(CXMLReader& oReader, EHanType eType)
: m_nFillType(0), m_eHatchStyle(EColorFillPattern::NONE), m_eMode(EImageFillType::NONE), m_chAlpha(0xff)
{
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
if ("hc:winBrush" == sNodeName)
if (GetNodeName(ENode::WindowBrush, eType) == sNodeName)
{
ReadWinBrush(oReader);
ReadWinBrush(oReader, eType);
m_nFillType |= 0x01;
}
else if ("hc:gradation" == sNodeName)
else if (GetNodeName(ENode::Gradation, eType) == sNodeName)
{
ReadGradation(oReader);
ReadGradation(oReader, eType);
m_nFillType |= 0x04;
}
else if ("hc:imgBrush" == sNodeName)
else if (GetNodeName(ENode::ImageBrush, eType) == sNodeName)
{
ReadImgBrush(oReader);
ReadImgBrush(oReader, eType);
m_nFillType |= 0x02;
}
}
END_WHILE
}
void CFill::ReadWinBrush(CXMLReader& oReader)
void CFill::ReadWinBrush(CXMLReader& oReader, EHanType eType)
{
m_eHatchStyle = EColorFillPattern::NONE;
m_chAlpha = 0xff;
START_READ_ATTRIBUTES(oReader)
{
if ("faceColor" == sAttributeName)
if (GetAttributeName(EAttribute::FaceColor, eType) == sAttributeName)
m_nFaceColor = oReader.GetColor(0xFFFFFFFF);
else if ("hatchColor" == sAttributeName)
else if (GetAttributeName(EAttribute::HatchColor, eType) == sAttributeName)
m_nHatchColor = oReader.GetColor();
else if ("hatchStyle" == sAttributeName)
else if (GetAttributeName(EAttribute::HatchStyle, eType) == sAttributeName)
m_eHatchStyle = GetColorFillPattern(oReader.GetInt());
else if ("alpha" == sAttributeName)
else if (GetAttributeName(EAttribute::Alpha, eType) == sAttributeName)
m_chAlpha = (HWP_BYTE)oReader.GetInt();
}
END_READ_ATTRIBUTES(oReader)
}
void CFill::ReadGradation(CXMLReader& oReader)
void CFill::ReadGradation(CXMLReader& oReader, EHanType eType)
{
START_READ_ATTRIBUTES(oReader)
{
if ("type" == sAttributeName)
if (GetAttributeName(EAttribute::Type, eType) == sAttributeName)
m_eGradType = ::HWP::GetGradFillType(oReader.GetInt());
else if ("angle" == sAttributeName)
else if (GetAttributeName(EAttribute::Angle, eType) == sAttributeName)
m_nAngle = oReader.GetInt();
else if ("centerX" == sAttributeName)
else if (GetAttributeName(EAttribute::CenterX, eType) == sAttributeName)
m_nCenterX = oReader.GetInt();
else if ("centerY" == sAttributeName)
else if (GetAttributeName(EAttribute::CenterY, eType) == sAttributeName)
m_nCenterY = oReader.GetInt();
else if ("step" == sAttributeName)
else if (GetAttributeName(EAttribute::Step, eType) == sAttributeName)
m_nStep = oReader.GetInt();
else if ("colorNum" == sAttributeName)
else if (GetAttributeName(EAttribute::ColorNum, eType) == sAttributeName)
m_nColorNum = oReader.GetInt();
else if ("stepCenter" == sAttributeName)
else if (GetAttributeName(EAttribute::StepCenter, eType) == sAttributeName)
m_chStepCenter = (HWP_BYTE)oReader.GetInt();
else if ("alpha" == sAttributeName)
else if (GetAttributeName(EAttribute::Alpha, eType) == sAttributeName)
m_chAlpha = (HWP_BYTE)oReader.GetInt();
}
END_READ_ATTRIBUTES(oReader)
WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hc:color")
WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, GetNodeName(ENode::Color, eType))
{
START_READ_ATTRIBUTES(oReader)
{
if ("value" != oReader.GetName())
if (GetAttributeName(EAttribute::Value, eType) != sAttributeName)
continue;
m_arColors.push_back(oReader.GetColor(true));
m_arColors.push_back(oReader.GetColor());
}
END_READ_ATTRIBUTES(oReader)
}
END_WHILE
}
void CFill::ReadImgBrush(CXMLReader& oReader)
void CFill::ReadImgBrush(CXMLReader& oReader, EHanType eType)
{
m_eMode = GetImageFillType(oReader.GetAttributeInt("mode"));
m_eMode = GetImageFillType(oReader.GetAttributeInt(GetAttributeName(EAttribute::Mode, eType)));
WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, "hc:img")
WHILE_READ_NEXT_NODE_WITH_ONE_NAME(oReader, GetNodeName(ENode::Image, eType))
{
START_READ_ATTRIBUTES(oReader)
{
if ("bright" == sAttributeName)
if (GetAttributeName(EAttribute::Bright, eType) == sAttributeName)
m_chBright = (HWP_BYTE)oReader.GetInt();
else if ("contrast" == sAttributeName)
else if (GetAttributeName(EAttribute::Contrast, eType) == sAttributeName)
m_chContrast = (HWP_BYTE)oReader.GetInt();
else if ("effect" == sAttributeName)
else if (GetAttributeName(EAttribute::Effect, eType) == sAttributeName)
{
const std::string sEffect{oReader.GetTextA()};
if ("REAL_PIC" == sEffect)
if (GetValueName(EValue::RealPic, eType))
m_chEffect = 0;
else if ("GRAY_SCALE" == sEffect)
else if (GetValueName(EValue::GrayScale, eType))
m_chEffect = 1;
else if ("BLACK_WHITE" == sEffect)
else if (GetValueName(EValue::BlackWhite, eType))
m_chEffect = 2;
}
else if ("binaryItemIDRef" == sAttributeName)
else if (GetAttributeName(EAttribute::BinItem, eType))
m_sBinItemID = oReader.GetText();
else if ("alpha" == sAttributeName)
else if (GetAttributeName(EAttribute::Alpha, eType) == sAttributeName)
m_chAlpha = (HWP_BYTE)oReader.GetInt();
}
END_READ_ATTRIBUTES(oReader)
@ -375,39 +377,51 @@ CHWPRecordBorderFill::CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, int nTagNum, i
m_pFill = new CFill(oBuffer, 0, 0); // TODO:: перейти от использования off и size
}
CHWPRecordBorderFill::CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
CHWPRecordBorderFill::CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType)
: CHWPRecord(EHWPTag::HWPTAG_BORDER_FILL, 0, 0), m_pFill(nullptr)
{
START_READ_ATTRIBUTES(oReader)
{
if ("threeD" == sAttributeName)
if (GetAttributeName(EAttribute::ThreeD, eType) == sAttributeName)
m_bThreeD = oReader.GetBool();
else if ("shadow" == sAttributeName)
else if (GetAttributeName(EAttribute::Shadow, eType) == sAttributeName)
m_bShadow = oReader.GetBool();
else if ("breakCellSeparateLine" == sAttributeName)
else if (GetAttributeName(EAttribute::BreakCellSeparateLine, eType) == sAttributeName)
m_bBreakCellSeparateLine = oReader.GetBool();
}
END_READ_ATTRIBUTES(oReader)
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
if ("hh:slash" == sNodeName)
if (GetNodeName(ENode::LeftBorder, eType) == sNodeName)
m_oLeft.Read(oReader, eType);
else if (GetNodeName(ENode::RightBorder, eType) == sNodeName)
m_oRight.Read(oReader, eType);
else if (GetNodeName(ENode::TopBorder, eType) == sNodeName)
m_oTop.Read(oReader, eType);
else if (GetNodeName(ENode::BottomBorder, eType) == sNodeName)
m_oBottom.Read(oReader, eType);
else if (GetNodeName(ENode::Diagonal, eType) == sNodeName)
m_oDiagonal.Read(oReader, eType);
else if (GetNodeName(ENode::FillBrush, eType) == sNodeName)
m_pFill = new CFill(oReader, eType);
else if (GetNodeName(ENode::Slash, eType) == sNodeName)
{
START_READ_ATTRIBUTES(oReader)
{
if ("type" == sAttributeName)
if (GetAttributeName(EAttribute::Type, eType) == sAttributeName)
{
const std::string sType{oReader.GetTextA()};
if ("NONE" == sType)
if (GetValueName(EValue::None, eType) == sType)
m_chSlash = 0x0;
else if ("CENTER" == sType)
else if (GetValueName(EValue::Center, eType) == sType)
m_chSlash = 0b010;
else if ("CENTER_BELOW" == sType)
else if (GetValueName(EValue::CenterBelow, eType) == sType)
m_chSlash = 0b011;
else if ("CENTER_ABOVE" == sType)
else if (GetValueName(EValue::CenterAbove, eType) == sType)
m_chSlash = 0b110;
else if ("ALL" == sType)
else if (GetValueName(EValue::All, eType) == sType)
m_chSlash = 0b111;
}
else if ("Crooked" == sAttributeName)
@ -417,23 +431,23 @@ CHWPRecordBorderFill::CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, CXMLReader& oR
}
END_READ_ATTRIBUTES(oReader)
}
else if ("hh:backSlash" == sNodeName)
else if (GetNodeName(ENode::BackSlash, eType) == sNodeName)
{
START_READ_ATTRIBUTES(oReader)
{
if ("type" == sAttributeName)
if (GetAttributeName(EAttribute::Type, eType) == sAttributeName)
{
const std::string sType{oReader.GetTextA()};
if ("NONE" == sType)
if (GetValueName(EValue::None, eType) == sType)
m_chBackSlash = 0x0;
else if ("CENTER" == sType)
else if (GetValueName(EValue::Center, eType) == sType)
m_chBackSlash = 0b010;
else if ("CENTER_BELOW" == sType)
else if (GetValueName(EValue::CenterBelow, eType) == sType)
m_chBackSlash = 0b011;
else if ("CENTER_ABOVE" == sType)
else if (GetValueName(EValue::CenterAbove, eType) == sType)
m_chBackSlash = 0b110;
else if ("ALL" == sType)
else if (GetValueName(EValue::All, eType) == sType)
m_chBackSlash = 0b111;
}
else if ("Crooked" == sAttributeName)
@ -443,18 +457,6 @@ CHWPRecordBorderFill::CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, CXMLReader& oR
}
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
}

12
HwpFile/HwpDoc/HWPElements/HWPRecordBorderFill.h
View File

@ -15,7 +15,7 @@ struct TBorder
HWP_BYTE m_chWidth;
int m_nColor;
void Read(CXMLReader& oReader);
void Read(CXMLReader& oReader, EHanType eType);
};
enum class EImageFillType
@ -86,13 +86,13 @@ class CFill : public IRef
HWP_BYTE m_chAlpha;
void ReadWinBrush(CXMLReader& oReader);
void ReadGradation(CXMLReader& oReader);
void ReadImgBrush(CXMLReader& oReader);
void ReadWinBrush(CXMLReader& oReader, EHanType eType);
void ReadGradation(CXMLReader& oReader, EHanType eType);
void ReadImgBrush(CXMLReader& oReader, EHanType eType);
public:
CFill();
CFill(CHWPStream& oBuffer, int nOff, int nSize);
CFill(CXMLReader& oReader);
CFill(CXMLReader& oReader, EHanType eType);
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, CXMLReader& oReader, int nVersion);
CHWPRecordBorderFill(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType);
~CHWPRecordBorderFill();
TBorder GetLeftBorder() const;

5
HwpFile/HwpDoc/HWPElements/HWPRecordBullet.cpp
View File

@ -45,9 +45,12 @@ CHWPRecordBullet::CHWPRecordBullet(CHWPDocInfo& oDocInfo, int nTagNum, int nLeve
oBuffer.ReadChar(m_chCheckBulletChar);
}
CHWPRecordBullet::CHWPRecordBullet(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
CHWPRecordBullet::CHWPRecordBullet(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType)
: CHWPRecord(EHWPTag::HWPTAG_BULLET, 0, 0), m_pParent(&oDocInfo)
{
if (EHanType::HWPML == eType)
return; // TODO:: реализовать как встретится пример
START_READ_ATTRIBUTES(oReader)
{
if ("char" == sAttributeName)

2
HwpFile/HwpDoc/HWPElements/HWPRecordBullet.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CHWPRecordBullet(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType);
};
}

92
HwpFile/HwpDoc/HWPElements/HWPRecordCharShape.cpp
View File

@ -1,6 +1,8 @@
#include "HWPRecordCharShape.h"
#include "../HWPElements/HWPRecordFaceName.h"
#include "../Common/NodeNames.h"
namespace HWP
{
EAccent GetAccent(int nValue)
@ -114,6 +116,8 @@ void CHWPRecordCharShape::ReadContainerData(CXMLReader& oReader, short arValues[
START_READ_ATTRIBUTES(oReader)
{
TO_LOWER(sAttributeName);
if ("hangul" == sAttributeName)
arValues[(int)ELang::HANGUL] = oReader.GetInt();
else if ("latin" == sAttributeName)
@ -208,7 +212,7 @@ CHWPRecordCharShape::CHWPRecordCharShape(CHWPDocInfo& oDocInfo, int nTagNum, int
oBuffer.RemoveLastSavedPos();
}
CHWPRecordCharShape::CHWPRecordCharShape(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
CHWPRecordCharShape::CHWPRecordCharShape(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType)
: CHWPRecord(EHWPTag::HWPTAG_HWP_CHAR_SHAPE, 0, 0), m_pParent(&oDocInfo),
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),
@ -216,26 +220,26 @@ CHWPRecordCharShape::CHWPRecordCharShape(CHWPDocInfo& oDocInfo, CXMLReader& oRea
{
START_READ_ATTRIBUTES(oReader)
{
if ("height" == sAttributeName)
if (GetAttributeName(EAttribute::Height, eType) == sAttributeName)
m_nHeight = oReader.GetInt();
else if ("textColor" == sAttributeName)
else if (GetAttributeName(EAttribute::TextColor, eType)== sAttributeName)
m_nTextColor = oReader.GetColor();
else if ("shadeColor" == sAttributeName)
else if (GetAttributeName(EAttribute::ShadeColor, eType) == sAttributeName)
m_nShadeColor = oReader.GetColor(0xFFFFFFFF);
else if ("useFontSpace" == sAttributeName)
else if (GetAttributeName(EAttribute::UseFontSpace, eType) == sAttributeName)
m_bUseFontSpace = oReader.GetBool();
else if ("useKerning" == sAttributeName)
else if (GetAttributeName(EAttribute::Height, eType) == sAttributeName)
m_bUseKerning = oReader.GetBool();
else if ("symMark" == sAttributeName)
else if (GetAttributeName(EAttribute::SymMask, eType) == sAttributeName)
m_eSymMark = GetAccent(oReader.GetText());
else if ("borderFillIDRef" == sAttributeName)
else if (GetAttributeName(EAttribute::BorderFillId, eType) == sAttributeName)
m_shBorderFillIDRef = oReader.GetInt();
}
END_READ_ATTRIBUTES(oReader)
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
if ("hh:fontRef" == sNodeName)
if (GetNodeName(ENode::FontId, eType) == sNodeName)
{
if (nullptr == m_pParent)
continue;
@ -251,6 +255,8 @@ CHWPRecordCharShape::CHWPRecordCharShape(CHWPDocInfo& oDocInfo, CXMLReader& oRea
START_READ_ATTRIBUTES(oReader)
{
TO_LOWER(sAttributeName);
if ("hangul" == sAttributeName)
UPDATE_FACENAME(ELang::HANGUL)
else if ("latin" == sAttributeName)
@ -268,76 +274,76 @@ CHWPRecordCharShape::CHWPRecordCharShape(CHWPDocInfo& oDocInfo, CXMLReader& oRea
}
END_READ_ATTRIBUTES(oReader)
}
else if ("hh:ratio" == sNodeName)
else if (GetNodeName(ENode::Ratio, eType) == sNodeName)
ReadContainerData(oReader, m_arRatios, 100);
else if ("hh:spacing" == sNodeName)
else if (GetNodeName(ENode::CharSpacing, eType) == sNodeName)
ReadContainerData(oReader, m_arSpacings);
else if ("hh:relSz" == sNodeName)
else if (GetNodeName(ENode::RelSize, eType) == sNodeName)
ReadContainerData(oReader, m_arRelSizes, 100);
else if ("hh:offset" == sNodeName)
else if (GetNodeName(ENode::CharOffset, eType) == sNodeName)
ReadContainerData(oReader, m_arCharOffset);
else if ("hh:underline" == sNodeName)
else if (GetNodeName(ENode::Underline, eType) == sNodeName)
{
START_READ_ATTRIBUTES(oReader)
{
if ("type" == sAttributeName)
if (GetAttributeName(EAttribute::Type, eType) == sAttributeName)
m_eUnderline = GetUnderline(oReader.GetText());
else if ("shape" == sAttributeName)
else if (GetAttributeName(EAttribute::Shape, eType) == sAttributeName)
m_eUnderLineShape = GetLineStyle1(oReader.GetText());
else if ("color" == sAttributeName)
else if (GetAttributeName(EAttribute::Color, eType) == sAttributeName)
m_nUnderlineColor = oReader.GetColor();
}
END_READ_ATTRIBUTES(oReader)
}
else if ("hh:strikeout" == sNodeName)
else if (GetNodeName(ENode::Outline, eType) == sNodeName)
m_eOutline = GetOutline(oReader.GetAttribute(GetAttributeName(EAttribute::Type, eType)));
else if (GetNodeName(ENode::Shadow, eType) == sNodeName)
{
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)
if (GetAttributeName(EAttribute::Type, eType) == sAttributeName)
{
const std::string sType{oReader.GetTextA()};
if ("DROP" == sType)
if (GetValueName(EValue::Drop, eType))
m_eShadow = EShadow::DISCRETE;
else if ("CONTINUOUS" == sType)
else if (GetValueName(EValue::Continuous, eType))
m_eShadow = EShadow::CONTINUOUS;
else
m_eShadow = EShadow::NONE;
}
else if ("color" == sAttributeName)
else if (GetAttributeName(EAttribute::Color, eType) == sAttributeName)
m_nShadowColor = oReader.GetColor();
else if ("offsetX" == sAttributeName)
else if (GetAttributeName(EAttribute::OffsetX, eType) == sAttributeName)
m_chShadowOffsetX = (HWP_BYTE)oReader.GetInt();
else if ("offsetY" == sAttributeName)
else if (GetAttributeName(EAttribute::OffsetY, eType) == sAttributeName)
m_chShadowOffsetY = (HWP_BYTE)oReader.GetInt();
}
END_READ_ATTRIBUTES(oReader)
}
else if ("hh:italic" == sNodeName)
else if (GetNodeName(ENode::Italic, eType) == sNodeName)
m_bItalic = true;
else if ("hh:bold" == sNodeName)
else if (GetNodeName(ENode::Bold, eType) == sNodeName)
m_bBold = true;
else if ("hh:emboss" == sNodeName)
else if (GetNodeName(ENode::Emboss, eType) == sNodeName)
m_bEmboss = true;
else if ("hh:engrave" == sNodeName)
else if (GetNodeName(ENode::Engrave, eType) == sNodeName)
m_bEngrave = true;
else if ("hh:supscript" == sNodeName)
else if (GetNodeName(ENode::SuperScript, eType) == sNodeName)
m_bSuperScript = true;
else if ("hh:subscript" == sNodeName)
else if (GetNodeName(ENode::SubScript, eType) == sNodeName)
m_bSubScript = true;
else if (EHanType::HWPX == eType && "hh:strikeout" == sNodeName)
{
START_READ_ATTRIBUTES(oReader)
{
if (GetAttributeName(EAttribute::Shape, eType) == sAttributeName)
m_eStrikeOutShape = GetLineStyle2(oReader.GetText());
else if (GetAttributeName(EAttribute::Color, eType) == sAttributeName)
m_nStrikeOutColor = oReader.GetColor();
}
END_READ_ATTRIBUTES(oReader)
}
}
END_WHILE
}

2
HwpFile/HwpDoc/HWPElements/HWPRecordCharShape.h
View File

@ -103,7 +103,7 @@ class CHWPRecordCharShape : public CHWPRecord
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, CXMLReader& oReader, int nVersion);
CHWPRecordCharShape(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType);
bool Bold() const;
bool Italic() const;

42
HwpFile/HwpDoc/HWPElements/HWPRecordFaceName.cpp
View File

@ -1,8 +1,9 @@
#include "HWPRecordFaceName.h"
#include "../Common/NodeNames.h"
namespace HWP
{
EAltType GetAltType(int nValue)
{
switch(static_cast<EAltType>(nValue))
@ -53,28 +54,29 @@ CHWPRecordFaceName::CHWPRecordFaceName(CHWPDocInfo& oDocInfo, int nTagNum, int n
oBuffer.ReadString(m_sBasicFaceName, EStringCharacter::UTF16);
}
CHWPRecordFaceName::CHWPRecordFaceName(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
CHWPRecordFaceName::CHWPRecordFaceName(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType)
: CHWPRecord(EHWPTag::HWPTAG_FACE_NAME, 0, 0), m_pParent(&oDocInfo)
{
m_sFaceName = oReader.GetAttribute("face");
m_sFaceName = oReader.GetAttribute(GetAttributeName(EAttribute::FontName, eType));
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
if ("hh:substFont" == sNodeName)
if (GetNodeName(ENode::SubFont, eType) == sNodeName)
{
m_bSubstExists = true;
START_READ_ATTRIBUTES(oReader)
{
if ("face" == sAttributeName)
if (GetAttributeName(EAttribute::FontName, eType) == sAttributeName)
m_sSubstFace = oReader.GetText();
else if ("type" == sAttributeName)
else if (GetAttributeName(EAttribute::Type, eType) == sAttributeName)
{
const std::string sType{oReader.GetTextA()};
std::string sType{oReader.GetTextA()};
TO_LOWER(sType);
if ("TTF" == sType)
if ("ttf" == sType)
m_eSubstType = EAltType::FFT;
else if ("HFT" == sType)
else if ("hft" == sType)
m_eSubstType = EAltType::HFT;
else
m_eSubstType = EAltType::UNKNOWN;
@ -82,36 +84,36 @@ CHWPRecordFaceName::CHWPRecordFaceName(CHWPDocInfo& oDocInfo, CXMLReader& oReade
}
END_READ_ATTRIBUTES(oReader)
}
else if ("hh:typeInfo" == sNodeName)
else if (GetNodeName(ENode::TypeInfo, eType) == sNodeName)
{
m_bAttrExists = true;
START_READ_ATTRIBUTES(oReader)
{
if ("familyType" == sAttributeName)
if (GetAttributeName(EAttribute::FamilyType, eType) == sAttributeName)
{
m_sBasicFaceName = oReader.GetText();
if (!m_sBasicFaceName.empty())
m_bBasicFaceExists = true;
}
else if ("serifStyle" == sAttributeName)
else if (GetAttributeName(EAttribute::SerifStyle, eType) == sAttributeName)
m_chSerifStyle = (HWP_BYTE)oReader.GetInt();
else if ("weight" == sAttributeName)
else if (GetAttributeName(EAttribute::Weight, eType) == sAttributeName)
m_shWeight = oReader.GetInt();
else if ("proportion" == sAttributeName)
else if (GetAttributeName(EAttribute::Proportion, eType) == sAttributeName)
m_shPropotion = oReader.GetInt();
else if ("contrast" == sAttributeName)
else if (GetAttributeName(EAttribute::Contrast, eType) == sAttributeName)
m_shContrast = oReader.GetInt();
else if ("strokeVariation" == sAttributeName)
else if (GetAttributeName(EAttribute::StrokeVariation, eType) == sAttributeName)
m_shStrokeVariation = oReader.GetInt();
else if ("armStyle" == sAttributeName)
else if (GetAttributeName(EAttribute::ArmStyle, eType) == sAttributeName)
m_shArmStyle = oReader.GetInt();
else if ("letterform" == sAttributeName)
else if (GetAttributeName(EAttribute::Letterform, eType) == sAttributeName)
m_shLetterform = oReader.GetInt();
else if ("midline" == sAttributeName)
else if (GetAttributeName(EAttribute::Midline, eType) == sAttributeName)
m_shMidLine = oReader.GetInt();
else if ("xHeight" == sAttributeName)
else if (GetAttributeName(EAttribute::XHeight, eType) == sAttributeName)
m_shXHeight = oReader.GetInt();
}
END_READ_ATTRIBUTES(oReader)

2
HwpFile/HwpDoc/HWPElements/HWPRecordFaceName.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CHWPRecordFaceName(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType);
HWP_STRING GetFaceName() const;
};

263
HwpFile/HwpDoc/HWPElements/HWPRecordNumbering.cpp
View File

@ -1,5 +1,7 @@
#include "HWPRecordNumbering.h"
#include "../Common/NodeNames.h"
namespace HWP
{
CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion)
@ -54,10 +56,10 @@ CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, int nTagNum, int
oBuffer.RemoveLastSavedPos();
}
CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType)
: CHWPRecord(EHWPTag::HWPTAG_NUMBERING, 0, 0), m_pParent(&oDocInfo)
{
m_shStart = oReader.GetAttributeInt("start", 1);
m_shStart = oReader.GetAttributeInt(GetAttributeName(EAttribute::Start, eType), 1);
unsigned int unIndex = 0;
short shLevel = 0;
@ -65,139 +67,142 @@ CHWPRecordNumbering::CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLReader& oRea
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
if ("hh:paraHead" == sNodeName ||
"paraHead" == sNodeName)
TO_LOWER(sNodeName);
if (GetNodeName(ENode::ParaHead, eType) != sNodeName &&
(EHanType::HWPX == eType && "parahead" != sNodeName))
continue;
START_READ_ATTRIBUTES(oReader)
{
START_READ_ATTRIBUTES(oReader)
if (GetAttributeName(EAttribute::Aligment, eType) == sAttributeName)
{
if ("align" == sAttributeName)
{
const std::string sType{oReader.GetTextA()};
const std::string sType{oReader.GetTextA()};
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()};
if (GetValueName(EValue::Left, eType) == sType)
m_arNumbering[unIndex].m_chAlign = 0;
else if (GetValueName(EValue::Center, eType) == sType)
m_arNumbering[unIndex].m_chAlign = 1;
else if (GetValueName(EValue::Right, eType) == sType)
m_arNumbering[unIndex].m_chAlign = 2;
}
else if (GetAttributeName(EAttribute::UseInstWidth, eType) == sAttributeName)
m_arNumbering[unIndex].m_bUseInstWidth = oReader.GetBool();
else if (GetAttributeName(EAttribute::AutoIndent, eType) == sAttributeName)
m_arNumbering[unIndex].m_bAutoIndent = oReader.GetBool();
else if (GetAttributeName(EAttribute::WidthAdjust, eType) == sAttributeName)
m_arNumbering[unIndex].m_shWidthAdjust = oReader.GetInt();
else if (GetAttributeName(EAttribute::TextOffsetType, eType) == sAttributeName)
{
const std::string sType{oReader.GetTextA()};
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();
if (GetValueName(EValue::Percent, eType) == sType)
m_arNumbering[unIndex].m_chTextOffsetType = 0;
else if (GetValueName(EValue::HwpUnit, eType) == sType)
m_arNumbering[unIndex].m_chTextOffsetType = 1;
}
END_READ_ATTRIBUTES(oReader)
if ("DIGIT" == sNumFormat)
{
if (shLevel > 0 && shLevel < 11)
m_arNumbering[unIndex].m_sNumFormat = L'^' + std::to_wstring(shLevel) + L'.';
}
else if ("HANGUL_SYLLABLE" == sNumFormat ||
"HANGUL_JAMO" == sNumFormat)
{
switch (shLevel)
{
case 1: m_arNumbering[unIndex].m_sNumFormat = L"^가."; break;
case 2: m_arNumbering[unIndex].m_sNumFormat = L"^나."; break;
case 3: m_arNumbering[unIndex].m_sNumFormat = L"^다."; break;
case 4: m_arNumbering[unIndex].m_sNumFormat = L"^라."; break;
case 5: m_arNumbering[unIndex].m_sNumFormat = L"^마."; break;
case 6: m_arNumbering[unIndex].m_sNumFormat = L"^바."; break;
case 7: m_arNumbering[unIndex].m_sNumFormat = L"^사."; break;
case 8: m_arNumbering[unIndex].m_sNumFormat = L"^아."; break;
case 9: m_arNumbering[unIndex].m_sNumFormat = L"^자."; break;
case 10: m_arNumbering[unIndex].m_sNumFormat = L"^차."; break;
}
}
else if ("CIRCLED_DIGIT" == sNumFormat)
{
switch (shLevel)
{
case 1: m_arNumbering[unIndex].m_sNumFormat = L"^\u2460."; break;
case 2: m_arNumbering[unIndex].m_sNumFormat = L"^\u2461."; break;
case 3: m_arNumbering[unIndex].m_sNumFormat = L"^\u2462."; break;
case 4: m_arNumbering[unIndex].m_sNumFormat = L"^\u2463."; break;
case 5: m_arNumbering[unIndex].m_sNumFormat = L"^\u2464."; break;
case 6: m_arNumbering[unIndex].m_sNumFormat = L"^\u2465."; break;
case 7: m_arNumbering[unIndex].m_sNumFormat = L"^\u2466."; break;
case 8: m_arNumbering[unIndex].m_sNumFormat = L"^\u2467."; break;
case 9: m_arNumbering[unIndex].m_sNumFormat = L"^\u2468."; break;
case 10: m_arNumbering[unIndex].m_sNumFormat = L"^\u2469."; break;
}
}
else if ("LATIN_SMALL" == sNumFormat)
{
switch (shLevel)
{
case 1: m_arNumbering[unIndex].m_sNumFormat = L"^a."; break;
case 2: m_arNumbering[unIndex].m_sNumFormat = L"^b."; break;
case 3: m_arNumbering[unIndex].m_sNumFormat = L"^c."; break;
case 4: m_arNumbering[unIndex].m_sNumFormat = L"^d."; break;
case 5: m_arNumbering[unIndex].m_sNumFormat = L"^e."; break;
case 6: m_arNumbering[unIndex].m_sNumFormat = L"^f."; break;
case 7: m_arNumbering[unIndex].m_sNumFormat = L"^g."; break;
case 8: m_arNumbering[unIndex].m_sNumFormat = L"^h."; break;
case 9: m_arNumbering[unIndex].m_sNumFormat = L"^i."; break;
case 10: m_arNumbering[unIndex].m_sNumFormat = L"^j."; break;
}
}
else if ("CIRCLED_HANGUL_SYLLABLE" == sNumFormat)
{
switch (shLevel)
{
case 1: m_arNumbering[unIndex].m_sNumFormat = L"^\u326E."; break;
case 2: m_arNumbering[unIndex].m_sNumFormat = L"^\u326F."; break;
case 3: m_arNumbering[unIndex].m_sNumFormat = L"^\u3270."; break;
case 4: m_arNumbering[unIndex].m_sNumFormat = L"^\u3271."; break;
case 5: m_arNumbering[unIndex].m_sNumFormat = L"^\u3272."; break;
case 6: m_arNumbering[unIndex].m_sNumFormat = L"^\u3273."; break;
case 7: m_arNumbering[unIndex].m_sNumFormat = L"^\u3274."; break;
case 8: m_arNumbering[unIndex].m_sNumFormat = L"^\u3275."; break;
case 9: m_arNumbering[unIndex].m_sNumFormat = L"^\u3276."; break;
case 10: m_arNumbering[unIndex].m_sNumFormat = L"^\u3277."; break;
}
}
else if ("ROMAN_SMALL" == sNumFormat)
{
switch (shLevel)
{
case 1: m_arNumbering[unIndex].m_sNumFormat = L"^\u2170."; break;
case 2: m_arNumbering[unIndex].m_sNumFormat = L"^\u2171."; break;
case 3: m_arNumbering[unIndex].m_sNumFormat = L"^\u2172."; break;
case 4: m_arNumbering[unIndex].m_sNumFormat = L"^\u2173."; break;
case 5: m_arNumbering[unIndex].m_sNumFormat = L"^\u2174."; break;
case 6: m_arNumbering[unIndex].m_sNumFormat = L"^\u2175."; break;
case 7: m_arNumbering[unIndex].m_sNumFormat = L"^\u2176."; break;
case 8: m_arNumbering[unIndex].m_sNumFormat = L"^\u2177."; break;
case 9: m_arNumbering[unIndex].m_sNumFormat = L"^\u2178."; break;
case 10: m_arNumbering[unIndex].m_sNumFormat = L"^\u2179."; break;
}
}
++unIndex;
else if (GetAttributeName(EAttribute::TextOffset, eType) == sAttributeName)
m_arNumbering[unIndex].m_shTextOffset = oReader.GetInt();
else if (GetAttributeName(EAttribute::CharShape, eType) == sAttributeName)
m_arNumbering[unIndex].m_nCharShape = std::abs(oReader.GetInt());
else if (GetAttributeName(EAttribute::Start, eType) == sAttributeName)
m_arNumbering[unIndex].m_nStartNumber = oReader.GetInt();
else if (GetAttributeName(EAttribute::NumFormat, eType) == sAttributeName)
sNumFormat = oReader.GetTextA();
else if (GetAttributeName(EAttribute::Level, eType) == sAttributeName)
shLevel = oReader.GetInt();
}
END_READ_ATTRIBUTES(oReader)
if (GetValueName(EValue::Digit, eType))
{
if (shLevel > 0 && shLevel < 11)
m_arNumbering[unIndex].m_sNumFormat = L'^' + std::to_wstring(shLevel) + L'.';
}
else if (GetValueName(EValue::HangulSyllable, eType) ||
GetValueName(EValue::HangulJamo, eType))
{
switch (shLevel)
{
case 1: m_arNumbering[unIndex].m_sNumFormat = L"^가."; break;
case 2: m_arNumbering[unIndex].m_sNumFormat = L"^나."; break;
case 3: m_arNumbering[unIndex].m_sNumFormat = L"^다."; break;
case 4: m_arNumbering[unIndex].m_sNumFormat = L"^라."; break;
case 5: m_arNumbering[unIndex].m_sNumFormat = L"^마."; break;
case 6: m_arNumbering[unIndex].m_sNumFormat = L"^바."; break;
case 7: m_arNumbering[unIndex].m_sNumFormat = L"^사."; break;
case 8: m_arNumbering[unIndex].m_sNumFormat = L"^아."; break;
case 9: m_arNumbering[unIndex].m_sNumFormat = L"^자."; break;
case 10: m_arNumbering[unIndex].m_sNumFormat = L"^차."; break;
}
}
else if (GetValueName(EValue::CircledDigit, eType))
{
switch (shLevel)
{
case 1: m_arNumbering[unIndex].m_sNumFormat = L"^\u2460."; break;
case 2: m_arNumbering[unIndex].m_sNumFormat = L"^\u2461."; break;
case 3: m_arNumbering[unIndex].m_sNumFormat = L"^\u2462."; break;
case 4: m_arNumbering[unIndex].m_sNumFormat = L"^\u2463."; break;
case 5: m_arNumbering[unIndex].m_sNumFormat = L"^\u2464."; break;
case 6: m_arNumbering[unIndex].m_sNumFormat = L"^\u2465."; break;
case 7: m_arNumbering[unIndex].m_sNumFormat = L"^\u2466."; break;
case 8: m_arNumbering[unIndex].m_sNumFormat = L"^\u2467."; break;
case 9: m_arNumbering[unIndex].m_sNumFormat = L"^\u2468."; break;
case 10: m_arNumbering[unIndex].m_sNumFormat = L"^\u2469."; break;
}
}
else if (GetValueName(EValue::LatinSmall, eType))
{
switch (shLevel)
{
case 1: m_arNumbering[unIndex].m_sNumFormat = L"^a."; break;
case 2: m_arNumbering[unIndex].m_sNumFormat = L"^b."; break;
case 3: m_arNumbering[unIndex].m_sNumFormat = L"^c."; break;
case 4: m_arNumbering[unIndex].m_sNumFormat = L"^d."; break;
case 5: m_arNumbering[unIndex].m_sNumFormat = L"^e."; break;
case 6: m_arNumbering[unIndex].m_sNumFormat = L"^f."; break;
case 7: m_arNumbering[unIndex].m_sNumFormat = L"^g."; break;
case 8: m_arNumbering[unIndex].m_sNumFormat = L"^h."; break;
case 9: m_arNumbering[unIndex].m_sNumFormat = L"^i."; break;
case 10: m_arNumbering[unIndex].m_sNumFormat = L"^j."; break;
}
}
else if (GetValueName(EValue::CircledHangulSyllable, eType) ||
GetValueName(EValue::CircledHangulJamo, eType))
{
switch (shLevel)
{
case 1: m_arNumbering[unIndex].m_sNumFormat = L"^\u326E."; break;
case 2: m_arNumbering[unIndex].m_sNumFormat = L"^\u326F."; break;
case 3: m_arNumbering[unIndex].m_sNumFormat = L"^\u3270."; break;
case 4: m_arNumbering[unIndex].m_sNumFormat = L"^\u3271."; break;
case 5: m_arNumbering[unIndex].m_sNumFormat = L"^\u3272."; break;
case 6: m_arNumbering[unIndex].m_sNumFormat = L"^\u3273."; break;
case 7: m_arNumbering[unIndex].m_sNumFormat = L"^\u3274."; break;
case 8: m_arNumbering[unIndex].m_sNumFormat = L"^\u3275."; break;
case 9: m_arNumbering[unIndex].m_sNumFormat = L"^\u3276."; break;
case 10: m_arNumbering[unIndex].m_sNumFormat = L"^\u3277."; break;
}
}
else if (GetValueName(EValue::RomanSmall, eType))
{
switch (shLevel)
{
case 1: m_arNumbering[unIndex].m_sNumFormat = L"^\u2170."; break;
case 2: m_arNumbering[unIndex].m_sNumFormat = L"^\u2171."; break;
case 3: m_arNumbering[unIndex].m_sNumFormat = L"^\u2172."; break;
case 4: m_arNumbering[unIndex].m_sNumFormat = L"^\u2173."; break;
case 5: m_arNumbering[unIndex].m_sNumFormat = L"^\u2174."; break;
case 6: m_arNumbering[unIndex].m_sNumFormat = L"^\u2175."; break;
case 7: m_arNumbering[unIndex].m_sNumFormat = L"^\u2176."; break;
case 8: m_arNumbering[unIndex].m_sNumFormat = L"^\u2177."; break;
case 9: m_arNumbering[unIndex].m_sNumFormat = L"^\u2178."; break;
case 10: m_arNumbering[unIndex].m_sNumFormat = L"^\u2179."; break;
}
}
++unIndex;
if (7 == unIndex)
return;

2
HwpFile/HwpDoc/HWPElements/HWPRecordNumbering.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CHWPRecordNumbering(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType);
short GetStart() const;
HWP_STRING GetNumFormat(unsigned short ushIndex) const;

143
HwpFile/HwpDoc/HWPElements/HWPRecordParaShape.cpp
View File

@ -1,5 +1,7 @@
#include "HWPRecordParaShape.h"
#include "../Common/NodeNames.h"
namespace HWP
{
EHeadingType GetHeadingType(int nValue)
@ -131,26 +133,155 @@ CHWPRecordParaShape::CHWPRecordParaShape(CHWPDocInfo& oDocInfo, int nTagNum, int
oBuffer.Skip(8);
}
CHWPRecordParaShape::CHWPRecordParaShape(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
CHWPRecordParaShape::CHWPRecordParaShape(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType)
: 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_nIndent(0), m_nMarginLeft(0), m_nMarginRight(0), m_nMarginPrev(0), m_nMarginNext(0),
m_bConnect(false), m_bIgnoreMargin(false), m_bParaTailShape(false)
{
//В HWPX в данной ноде данный пишутся по типу данный в нодах
//В HWPML в данной ноде данные пишуься по типк данные в аргументах
if (EHanType::HWPX == eType)
{
START_READ_ATTRIBUTES(oReader)
{
if (GetAttributeName(EAttribute::TabDef, eType))
m_shTabDef = oReader.GetInt();
else if (GetAttributeName(EAttribute::Condense, eType) == sAttributeName)
m_chCondense = (HWP_BYTE)oReader.GetInt();
else if (GetAttributeName(EAttribute::FontLineHeight, eType) == sAttributeName)
m_bFontLineHeight = oReader.GetBool();
else if (GetAttributeName(EAttribute::SnapToGrid, eType) == sAttributeName)
m_bSnapToGrid = oReader.GetBool();
}
END_READ_ATTRIBUTES(oReader)
RecursiveParaShape(oReader);
return;
}
else if (EHanType::HWPML != eType)
return;
START_READ_ATTRIBUTES(oReader)
{
if ("tabPrIDRef" == sAttributeName)
if ("Align" == sAttributeName)
m_eAlign = ::HWP::GetHorizontalAlign(oReader.GetText());
else if ("VerAlign" == sAttributeName)
m_eVertAlign = ::HWP::GetVerticalAlign(oReader.GetText());
else if ("HeadingType" == sAttributeName)
m_eHeadingType = ::HWP::GetHeadingType(oReader.GetText());
else if ("Heading" == sAttributeName)
m_shHeadingIdRef = oReader.GetInt();
else if ("Level" == sAttributeName)
m_chHeadingLevel = (HWP_BYTE)oReader.GetInt();
else if ("TabDef" == sAttributeName)
m_shTabDef = oReader.GetInt();
else if ("condense" == sAttributeName)
else if ("BreakLatinWord" == sAttributeName)
{
const std::string sType{oReader.GetTextA()};
if ("KeepWord" == sType)
m_chBreakLatinWord = 0;
else if ("BreakWord" == sType)
m_chBreakLatinWord = 1;
else if ("Hyphenation" == sType)
m_chBreakLatinWord = 2;
}
else if ("BreakNonLatinWord" == sAttributeName)
{
//TODO:: проверить соответсвие hwpx и hwpml
}
else if ("Condense" == sAttributeName)
m_chCondense = (HWP_BYTE)oReader.GetInt();
else if ("fontLineHeight" == sAttributeName)
else if ("WidowOrphan" == sAttributeName)
m_bWidowOrphan = oReader.GetBool();
else if ("KeepWithNext" == sAttributeName)
m_bKeepWithNext = oReader.GetBool();
else if ("KeepLines" == sAttributeName)
{ /*TODO:: проверить соответсвие hwpx и hwpml*/ }
else if ("PageBreakBefore" == sAttributeName)
m_bPageBreakBefore = oReader.GetBool();
else if ("FontLineHeight" == sAttributeName)
m_bFontLineHeight = oReader.GetBool();
else if ("snapToGrid" == sAttributeName)
else if ("SnapToGrid" == sAttributeName)
m_bSnapToGrid = 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;
else if ("Keep" == sType)
m_chLineWrap = 2;
}
else if ("AutoSpaceEAsianEng" == sAttributeName)
m_bAutoSpaceEAsianEng = oReader.GetBool();
else if ("AutoSpaceEAsianNum" == sAttributeName)
m_bAutoSpaceEAsianNum = oReader.GetBool();
}
END_READ_ATTRIBUTES(oReader)
RecursiveParaShape(oReader);
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
if ("PARAMARGIN" == sNodeName)
{
START_READ_ATTRIBUTES(oReader)
{
if ("Indent" == sAttributeName)
m_nIndent = oReader.GetInt();
else if ("Left" == sAttributeName)
m_nMarginLeft = oReader.GetInt();
else if ("Right" == sAttributeName)
m_nMarginRight = oReader.GetInt();
else if ("Prev" == sAttributeName)
m_nMarginPrev = oReader.GetInt();
else if ("Next" == sAttributeName)
m_nMarginNext = oReader.GetInt();
else if ("LineSpacingType" == 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 ("AtLeast" == sType)
m_nLineSpacingType = 4;
}
else if ("LineSpacing" == sAttributeName)
m_nLineSpacing = oReader.GetInt();
}
END_READ_ATTRIBUTES(oReader)
}
else if ("PARABORDER" == sNodeName)
{
START_READ_ATTRIBUTES(oReader)
{
if ("BorderFill" == sAttributeName)
m_shBorderFill = oReader.GetInt();
else if ("OffsetLeft" == sAttributeName)
m_shOffsetLeft = oReader.GetInt();
else if ("OffsetRigth" == 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)
}
}
END_WHILE
}
void CHWPRecordParaShape::RecursiveParaShape(CXMLReader& oReader)

2
HwpFile/HwpDoc/HWPElements/HWPRecordParaShape.h
View File

@ -77,7 +77,7 @@ class CHWPRecordParaShape : public CHWPRecord
void RecursiveParaShape(CXMLReader& oReader);
public:
CHWPRecordParaShape(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
CHWPRecordParaShape(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion);
CHWPRecordParaShape(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType);
EHorizontalAlign GetHorizantalAlign() const;
EVerticalAlign GetVerticalAlign() const;

24
HwpFile/HwpDoc/HWPElements/HWPRecordStyle.cpp
View File

@ -1,5 +1,7 @@
#include "HWPRecordStyle.h"
#include "../Common/NodeNames.h"
#include <iostream>
namespace HWP
{
CHWPRecordStyle::CHWPRecordStyle(int nTagNum, int nLevel, int nSize)
@ -20,33 +22,33 @@ CHWPRecordStyle::CHWPRecordStyle(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel,
m_nCharShape = oBuffer.ReadShort();
}
CHWPRecordStyle::CHWPRecordStyle(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
CHWPRecordStyle::CHWPRecordStyle(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType)
: CHWPRecord(EHWPTag::HWPTAG_STYLE, 0, 0), m_pParent(&oDocInfo)
{
START_READ_ATTRIBUTES(oReader)
{
if ("type" == sAttributeName)
if (GetAttributeName(EAttribute::Type, eType) == sAttributeName)
{
const std::string sType{oReader.GetTextA()};
if ("PARA" == sType)
if (GetValueName(EValue::Para, eType) == sType)
m_chType = 0;
else if ("CHAR" == sType)
else if (GetValueName(EValue::Char, eType) == sType)
m_chType = 1;
}
else if ("name" == sAttributeName)
else if (GetAttributeName(EAttribute::Name, eType) == sAttributeName)
m_sName = oReader.GetText();
else if ("engName" == sAttributeName)
else if (GetAttributeName(EAttribute::EngName, eType) == sAttributeName)
m_sEngName = oReader.GetText();
else if ("paraPrIDRef" == sAttributeName)
else if (GetAttributeName(EAttribute::ParaShape, eType) == sAttributeName)
m_nParaShape = oReader.GetInt();
else if ("charPrIDRef" == sAttributeName)
else if (GetAttributeName(EAttribute::CharShape, eType) == sAttributeName)
m_nCharShape = oReader.GetInt();
else if ("nextStyleIDRef" == sAttributeName)
else if (GetAttributeName(EAttribute::NextStyle, eType) == sAttributeName)
m_chNextStyle = oReader.GetInt();
else if ("langID" == sAttributeName)
else if (GetAttributeName(EAttribute::LangId, eType) == sAttributeName)
m_shLangID = oReader.GetInt();
else if ("lockForm" == sAttributeName)
else if (GetAttributeName(EAttribute::LockForm, eType) == sAttributeName)
m_bLockForm = oReader.GetBool();
}
END_READ_ATTRIBUTES(oReader)

2
HwpFile/HwpDoc/HWPElements/HWPRecordStyle.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CHWPRecordStyle(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType);
HWP_STRING GetName() const;
HWP_STRING GetEngName() const;

13
HwpFile/HwpDoc/HWPElements/HwpRecordTabDef.cpp
View File

@ -1,5 +1,7 @@
#include "HwpRecordTabDef.h"
#include "../Common/NodeNames.h"
namespace HWP
{
TTab::TTab()
@ -69,19 +71,19 @@ CHwpRecordTabDef::CHwpRecordTabDef(CHWPDocInfo& oDocInfo, int nTagNum, int nLeve
oBuffer.RemoveLastSavedPos();
}
CHwpRecordTabDef::CHwpRecordTabDef(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion)
CHwpRecordTabDef::CHwpRecordTabDef(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType)
: CHWPRecord(EHWPTag::HWPTAG_TAB_DEF, 0, 0), m_pParent(&oDocInfo), m_nAttr(0)
{
START_READ_ATTRIBUTES(oReader)
{
if ("autoTabLeft" == sAttributeName)
if (GetAttributeName(EAttribute::AutoTabLeft, eType) == sAttributeName)
{
if (oReader.GetBool())
m_nAttr |= 0x00000001;
else
m_nAttr &= 0xFFFFFFFE;
}
else if ("autoTabRight" == sAttributeName)
else if (GetAttributeName(EAttribute::AutoTabRight, eType) == sAttributeName)
{
if (oReader.GetBool())
m_nAttr |= 0x00000002;
@ -91,6 +93,10 @@ CHwpRecordTabDef::CHwpRecordTabDef(CHWPDocInfo& oDocInfo, CXMLReader& oReader, i
}
END_READ_ATTRIBUTES(oReader)
// Дальнейшая структура встречается лишь в HWPX формате
if (EHanType::HWPX != eType)
return;
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")
@ -98,7 +104,6 @@ CHwpRecordTabDef::CHwpRecordTabDef(CHWPDocInfo& oDocInfo, CXMLReader& oReader, i
END_WHILE
END_WHILE
END_WHILE
}
int CHwpRecordTabDef::GetCount() const

2
HwpFile/HwpDoc/HWPElements/HwpRecordTabDef.h
View File

@ -36,7 +36,7 @@ class CHwpRecordTabDef : public CHWPRecord
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, CXMLReader& oReader, int nVersion);
CHwpRecordTabDef(CHWPDocInfo& oDocInfo, CXMLReader& oReader, int nVersion, EHanType eType);
int GetCount() const;
const TTab* GetTab(unsigned int unIndex) const;

12
HwpFile/HwpDoc/HWPMLFile.cpp
View File

@ -6,7 +6,7 @@ namespace HWP
{
CHWPMLFile::CHWPMLFile(const HWP_STRING &wsFilePath)
: m_wsFilePath(wsFilePath)
: m_wsFilePath(wsFilePath), m_oDocInfo(this)
{}
CHWPMLFile::~CHWPMLFile()
@ -57,12 +57,14 @@ bool CHWPMLFile::Detect() const
void CHWPMLFile::Close()
{}
const CHWPDocInfo* CHWPMLFile::GetDocInfo() const
{
return &m_oDocInfo;
}
void CHWPMLFile::ReadHead(CXMLReader &oReader)
{
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
{
}
END_WHILE
m_oDocInfo.Parse(oReader);
}
void CHWPMLFile::ReadBody(CXMLReader &oReader)

6
HwpFile/HwpDoc/HWPMLFile.h
View File

@ -8,7 +8,8 @@ namespace HWP
{
class CHWPMLFile
{
HWP_STRING m_wsFilePath;
HWP_STRING m_wsFilePath;
CHWPDocInfo m_oDocInfo;
VECTOR<CHWPSection*> m_arSections;
void ReadHead(CXMLReader& oReader);
@ -23,7 +24,8 @@ public:
bool Open();
bool Detect() const;
void Close();
const CHWPDocInfo* GetDocInfo() const;
VECTOR<const CHWPSection*> GetSections() const;
};
}

22
HwpFile/HwpDoc/Paragraph/CtrlContainer.cpp
View File

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

2
HwpFile/HwpDoc/Paragraph/CtrlContainer.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlContainer(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
~CCtrlContainer();

4
HwpFile/HwpDoc/Paragraph/CtrlEqEdit.cpp
View File

@ -17,7 +17,7 @@ CCtrlEqEdit::CCtrlEqEdit(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuff
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlEqEdit::CCtrlEqEdit(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlEqEdit::CCtrlEqEdit(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
START_READ_ATTRIBUTES(oReader)
@ -49,7 +49,7 @@ CCtrlEqEdit::CCtrlEqEdit(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVe
if ("hp:script" == oReader.GetName())
m_sEqn = oReader.GetText();
else
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
}
END_WHILE

2
HwpFile/HwpDoc/Paragraph/CtrlEqEdit.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlEqEdit(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
EShapeType GetShapeType() const override;

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

@ -84,7 +84,7 @@ EShapeType CCtrlGeneralShape::GetShapeType() const
return EShapeType::GeneralShape;
}
void CCtrlGeneralShape::ParseChildren(CXMLReader& oReader, int nVersion)
void CCtrlGeneralShape::ParseChildren(CXMLReader& oReader, int nVersion, EHanType eType)
{
bool bHeadFill = false, bTailFill = false;
@ -198,7 +198,7 @@ void CCtrlGeneralShape::ParseChildren(CXMLReader& oReader, int nVersion)
m_eLineTail = ELineArrowStyle::NORMAL;
}
else if ("hc:fillBrush" == sNodeName)
m_pFill = new CFill(oReader);
m_pFill = new CFill(oReader, eType);
else if ("hp:drawText" == sNodeName)
{
m_nMaxTxtWidth = oReader.GetAttributeInt("lastWidth");

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

@ -65,7 +65,7 @@ public:
ECtrlObjectType GetCtrlType() const override;
virtual EShapeType GetShapeType() const;
void ParseChildren(CXMLReader& oReader, int nVersion);
void ParseChildren(CXMLReader& oReader, int nVersion, EHanType eType);
void SetParent(CHWPPargraph* pParent);
CHWPPargraph* GetParent();

4
HwpFile/HwpDoc/Paragraph/CtrlShapeArc.cpp
View File

@ -17,7 +17,7 @@ CCtrlShapeArc::CCtrlShapeArc(const HWP_STRING& sCtrlID, int nSize, CHWPStream& o
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlShapeArc::CCtrlShapeArc(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlShapeArc::CCtrlShapeArc(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
m_eType = GetArcType(oReader.GetAttributeInt("type"));
@ -58,7 +58,7 @@ CCtrlShapeArc::CCtrlShapeArc(const HWP_STRING& sCtrlID, CXMLReader& oReader, int
END_READ_ATTRIBUTES(oReader)
}
else
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
}
END_WHILE
}

2
HwpFile/HwpDoc/Paragraph/CtrlShapeArc.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlShapeArc(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
EShapeType GetShapeType() const override;

4
HwpFile/HwpDoc/Paragraph/CtrlShapeConnectLine.cpp
View File

@ -25,7 +25,7 @@ CCtrlShapeConnectLine::CCtrlShapeConnectLine(const HWP_STRING& sCtrlID, int nSiz
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlShapeConnectLine::CCtrlShapeConnectLine(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlShapeConnectLine::CCtrlShapeConnectLine(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
m_eType = GetConnectLineType(oReader.GetAttributeInt("type"));
@ -63,7 +63,7 @@ CCtrlShapeConnectLine::CCtrlShapeConnectLine(const HWP_STRING& sCtrlID, CXMLRead
END_READ_ATTRIBUTES(oReader)
}
else
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
}
END_WHILE
}

2
HwpFile/HwpDoc/Paragraph/CtrlShapeConnectLine.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlShapeConnectLine(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
EShapeType GetShapeType() const override;
};

4
HwpFile/HwpDoc/Paragraph/CtrlShapeCurve.cpp
View File

@ -17,7 +17,7 @@ CCtrlShapeCurve::CCtrlShapeCurve(const HWP_STRING& sCtrlID, int nSize, CHWPStrea
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlShapeCurve::CCtrlShapeCurve(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlShapeCurve::CCtrlShapeCurve(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
// bool bReadedType
@ -58,7 +58,7 @@ CCtrlShapeCurve::CCtrlShapeCurve(const HWP_STRING& sCtrlID, CXMLReader& oReader,
m_arPoints.push_back(oPoint1);
}
else
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
}
END_WHILE

2
HwpFile/HwpDoc/Paragraph/CtrlShapeCurve.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlShapeCurve(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
EShapeType GetShapeType() const override;

4
HwpFile/HwpDoc/Paragraph/CtrlShapeEllipse.cpp
View File

@ -34,7 +34,7 @@ CCtrlShapeEllipse::CCtrlShapeEllipse(const HWP_STRING& sCtrlID, int nSize, CHWPS
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlShapeEllipse::CCtrlShapeEllipse(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlShapeEllipse::CCtrlShapeEllipse(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
START_READ_ATTRIBUTES(oReader)
@ -128,7 +128,7 @@ CCtrlShapeEllipse::CCtrlShapeEllipse(const HWP_STRING& sCtrlID, CXMLReader& oRea
END_READ_ATTRIBUTES(oReader)
}
else
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
}
END_WHILE
}

2
HwpFile/HwpDoc/Paragraph/CtrlShapeEllipse.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlShapeEllipse(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
EShapeType GetShapeType() const override;

4
HwpFile/HwpDoc/Paragraph/CtrlShapeLine.cpp
View File

@ -17,7 +17,7 @@ CCtrlShapeLine::CCtrlShapeLine(const HWP_STRING& sCtrlID, int nSize, CHWPStream&
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlShapeLine::CCtrlShapeLine(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlShapeLine::CCtrlShapeLine(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
m_shAttr = (short)oReader.GetAttributeBool("isReverseHV");
@ -47,7 +47,7 @@ CCtrlShapeLine::CCtrlShapeLine(const HWP_STRING& sCtrlID, CXMLReader& oReader, i
END_READ_ATTRIBUTES(oReader)
}
else
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
}
END_WHILE
}

2
HwpFile/HwpDoc/Paragraph/CtrlShapeLine.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlShapeLine(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
EShapeType GetShapeType() const override;

4
HwpFile/HwpDoc/Paragraph/CtrlShapeOle.cpp
View File

@ -17,7 +17,7 @@ CCtrlShapeOle::CCtrlShapeOle(const HWP_STRING& sCtrlID, int nSize, CHWPStream& o
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlShapeOle::CCtrlShapeOle(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlShapeOle::CCtrlShapeOle(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
m_sBinDataID = oReader.GetAttribute("binaryItemIDRef");
@ -36,7 +36,7 @@ CCtrlShapeOle::CCtrlShapeOle(const HWP_STRING& sCtrlID, CXMLReader& oReader, int
END_READ_ATTRIBUTES(oReader)
}
else
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
}
END_WHILE
}

2
HwpFile/HwpDoc/Paragraph/CtrlShapeOle.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlShapeOle(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
EShapeType GetShapeType() const override;

4
HwpFile/HwpDoc/Paragraph/CtrlShapePic.cpp
View File

@ -256,7 +256,7 @@ CCtrlShapePic::CCtrlShapePic(const HWP_STRING& sCtrlID, int nSize, CHWPStream& o
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlShapePic::CCtrlShapePic(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlShapePic::CCtrlShapePic(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
WHILE_READ_NEXT_NODE_WITH_NAME(oReader)
@ -357,7 +357,7 @@ CCtrlShapePic::CCtrlShapePic(const HWP_STRING& sCtrlID, CXMLReader& oReader, int
END_READ_ATTRIBUTES(oReader)
}
else
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
}
END_WHILE
}

2
HwpFile/HwpDoc/Paragraph/CtrlShapePic.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlShapePic(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
~CCtrlShapePic();
EShapeType GetShapeType() const override;

4
HwpFile/HwpDoc/Paragraph/CtrlShapePolygon.cpp
View File

@ -17,7 +17,7 @@ CCtrlShapePolygon::CCtrlShapePolygon(const HWP_STRING& sCtrlID, int nSize, CHWPS
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlShapePolygon::CCtrlShapePolygon(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlShapePolygon::CCtrlShapePolygon(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
TPoint oPoint{0, 0};
@ -40,7 +40,7 @@ CCtrlShapePolygon::CCtrlShapePolygon(const HWP_STRING& sCtrlID, CXMLReader& oRea
oPoint = {0, 0};
}
else
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
}
END_WHILE

2
HwpFile/HwpDoc/Paragraph/CtrlShapePolygon.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlShapePolygon(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
EShapeType GetShapeType() const override;

4
HwpFile/HwpDoc/Paragraph/CtrlShapeRect.cpp
View File

@ -17,7 +17,7 @@ CCtrlShapeRect::CCtrlShapeRect(const HWP_STRING& sCtrlID, int nSize, CHWPStream&
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlShapeRect::CCtrlShapeRect(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlShapeRect::CCtrlShapeRect(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
m_chCurv = (HWP_BYTE)oReader.GetAttributeInt("ratio");
@ -45,7 +45,7 @@ CCtrlShapeRect::CCtrlShapeRect(const HWP_STRING& sCtrlID, CXMLReader& oReader, i
else if ("hc:pt3" == sNodeName)
READ_POINT(3)
else
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
}
END_WHILE
}

2
HwpFile/HwpDoc/Paragraph/CtrlShapeRect.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlShapeRect(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
EShapeType GetShapeType() const override;

4
HwpFile/HwpDoc/Paragraph/CtrlShapeTextArt.cpp
View File

@ -17,7 +17,7 @@ CCtrlShapeTextArt::CCtrlShapeTextArt(const HWP_STRING& sCtrlID, int nSize, CHWPS
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlShapeTextArt::CCtrlShapeTextArt(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlShapeTextArt::CCtrlShapeTextArt(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
m_sText = oReader.GetAttribute("text");
@ -89,7 +89,7 @@ CCtrlShapeTextArt::CCtrlShapeTextArt(const HWP_STRING& sCtrlID, CXMLReader& oRea
END_WHILE
}
else
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
}
END_WHILE
}

2
HwpFile/HwpDoc/Paragraph/CtrlShapeTextArt.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlShapeTextArt(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
EShapeType GetShapeType() const override;

4
HwpFile/HwpDoc/Paragraph/CtrlShapeVideo.cpp
View File

@ -14,7 +14,7 @@ CCtrlShapeVideo::CCtrlShapeVideo(const HWP_STRING& sCtrlID, int nSize, CHWPStrea
: CCtrlGeneralShape(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlShapeVideo::CCtrlShapeVideo(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlShapeVideo::CCtrlShapeVideo(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlGeneralShape(sCtrlID, oReader, nVersion)
{
START_READ_ATTRIBUTES(oReader)
@ -38,7 +38,7 @@ CCtrlShapeVideo::CCtrlShapeVideo(const HWP_STRING& sCtrlID, CXMLReader& oReader,
END_READ_ATTRIBUTES(oReader)
WHILE_READ_NEXT_NODE(oReader)
CCtrlGeneralShape::ParseChildren(oReader, nVersion);
CCtrlGeneralShape::ParseChildren(oReader, nVersion, eType);
END_WHILE
}

2
HwpFile/HwpDoc/Paragraph/CtrlShapeVideo.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlShapeVideo(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
EShapeType GetShapeType() const override;

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

@ -10,7 +10,7 @@ CCtrlTable::CCtrlTable(const HWP_STRING& sCtrlID, int nSize, CHWPStream& oBuffer
: CCtrlCommon(sCtrlID, nSize, oBuffer, nOff, nVersion)
{}
CCtrlTable::CCtrlTable(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion)
CCtrlTable::CCtrlTable(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType)
: CCtrlCommon(sCtrlID, oReader, nVersion)
{
START_READ_ATTRIBUTES(oReader)

2
HwpFile/HwpDoc/Paragraph/CtrlTable.h
View File

@ -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, CXMLReader& oReader, int nVersion);
CCtrlTable(const HWP_STRING& sCtrlID, CXMLReader& oReader, int nVersion, EHanType eType);
~CCtrlTable();
ECtrlObjectType GetCtrlType() const override;

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

@ -26,26 +26,26 @@
namespace HWP
{
CHWPPargraph::CHWPPargraph()
: m_pLineSegs(nullptr)
: m_chBreakType(0), m_pLineSegs(nullptr), m_shParaShapeID(0), m_shParaStyleID(0)
{}
CHWPPargraph::CHWPPargraph(CXMLReader& oReader, int nVersion, EHanType eType)
: m_chBreakType(0), m_pLineSegs(nullptr)
: m_chBreakType(0), m_pLineSegs(nullptr), m_shParaShapeID(0), m_shParaStyleID(0)
{
START_READ_ATTRIBUTES(oReader)
{
if (GetArgumentName(EArgument::ParaShape, eType) == sAttributeName)
if (GetAttributeName(EAttribute::ParaShape, eType) == sAttributeName)
m_shParaShapeID = oReader.GetInt();
else if (GetArgumentName(EArgument::Style, eType) == sAttributeName)
else if (GetAttributeName(EAttribute::Style, eType) == sAttributeName)
m_shParaStyleID = oReader.GetInt();
else if (GetArgumentName(EArgument::PageBreak, eType) == sAttributeName)
else if (GetAttributeName(EAttribute::PageBreak, eType) == sAttributeName)
{
if (oReader.GetBool())
m_chBreakType |= 0b00000100;
else
m_chBreakType &= 0b11111011;
}
else if (GetArgumentName(EArgument::ColumnBreak, eType) == sAttributeName)
else if (GetAttributeName(EAttribute::ColumnBreak, eType) == sAttributeName)
{
if (oReader.GetBool())
m_chBreakType |= 0b00001000;
@ -61,7 +61,7 @@ CHWPPargraph::CHWPPargraph(CXMLReader& oReader, int nVersion, EHanType eType)
{
if (GetNodeName(ENode::Text, eType) == sNodeName)
{
nCharShapeID = oReader.GetAttributeInt(GetArgumentName(EArgument::CharShape, eType));
nCharShapeID = oReader.GetAttributeInt(GetAttributeName(EAttribute::CharShape, eType));
WHILE_READ_NEXT_NODE_WITH_DEPTH(oReader, Child)
ParseHWPParagraph(oReader, nCharShapeID, nVersion, eType);
@ -89,7 +89,7 @@ CHWPPargraph::~CHWPPargraph()
delete m_pLineSegs;
}
bool CHWPPargraph::ParseHWPParagraph(CXMLReader& oReader, int nCharShapeID, int nVersion, HWP::EHanType eType)
bool CHWPPargraph::ParseHWPParagraph(CXMLReader& oReader, int nCharShapeID, int nVersion, EHanType eType)
{
const size_t unCurrentParaCount = m_arP.size();
@ -143,33 +143,33 @@ bool CHWPPargraph::ParseHWPParagraph(CXMLReader& oReader, int nCharShapeID, int
}
}
else if (GetNodeName(ENode::Table, eType) == sNodeName)
m_arP.push_back(new CCtrlTable(L" lbt", oReader, nVersion));
m_arP.push_back(new CCtrlTable(L" lbt", oReader, nVersion, eType));
else if (GetNodeName(ENode::Picture, eType) == sNodeName)
m_arP.push_back(new CCtrlShapePic(L"cip$", oReader, nVersion));
m_arP.push_back(new CCtrlShapePic(L"cip$", oReader, nVersion, eType));
else if (GetNodeName(ENode::Container, eType) == sNodeName)
m_arP.push_back(new CCtrlContainer(L"noc$", oReader, nVersion));
m_arP.push_back(new CCtrlContainer(L"noc$", oReader, nVersion, eType));
else if (GetNodeName(ENode::Ole, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeOle(L"elo$", oReader, nVersion));
m_arP.push_back(new CCtrlShapeOle(L"elo$", oReader, nVersion, eType));
else if (GetNodeName(ENode::Equation, eType) == sNodeName)
m_arP.push_back(new CCtrlEqEdit(L"deqe", oReader, nVersion));
m_arP.push_back(new CCtrlEqEdit(L"deqe", oReader, nVersion, eType));
else if (GetNodeName(ENode::Line, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeLine(L"nil$", oReader, nVersion));
m_arP.push_back(new CCtrlShapeLine(L"nil$", oReader, nVersion, eType));
else if (GetNodeName(ENode::Rectangle, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeRect(L"cer$", oReader, nVersion));
m_arP.push_back(new CCtrlShapeRect(L"cer$", oReader, nVersion, eType));
else if (GetNodeName(ENode::Ellipse, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeEllipse(L"lle$", oReader, nVersion));
m_arP.push_back(new CCtrlShapeEllipse(L"lle$", oReader, nVersion, eType));
else if (GetNodeName(ENode::Arc, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeArc(L"cra$", oReader, nVersion));
m_arP.push_back(new CCtrlShapeArc(L"cra$", oReader, nVersion, eType));
else if (GetNodeName(ENode::Polygon, eType) == sNodeName)
m_arP.push_back(new CCtrlShapePolygon(L"lop$", oReader, nVersion));
m_arP.push_back(new CCtrlShapePolygon(L"lop$", oReader, nVersion, eType));
else if (GetNodeName(ENode::Curve, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeCurve(L"ruc$", oReader, nVersion));
m_arP.push_back(new CCtrlShapeCurve(L"ruc$", oReader, nVersion, eType));
else if (GetNodeName(ENode::ConnectLine, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeConnectLine(L"loc$", oReader, nVersion));
m_arP.push_back(new CCtrlShapeConnectLine(L"loc$", oReader, nVersion, eType));
else if (GetNodeName(ENode::TextArt, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeTextArt(L"tat$", oReader, nVersion));
m_arP.push_back(new CCtrlShapeTextArt(L"tat$", oReader, nVersion, eType));
else if (GetNodeName(ENode::Video, eType) == sNodeName)
m_arP.push_back(new CCtrlShapeVideo(L"div$", oReader, nVersion));
m_arP.push_back(new CCtrlShapeVideo(L"div$", oReader, nVersion, eType));
if (unCurrentParaCount != m_arP.size())
return true;