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

The beginning of writing code for converting hwp format

Browse Source
This commit is contained in:
Green
2024-11-26 20:52:11 +03:00
parent 32afe4f24e
commit f57179911f
17 changed files with 784 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
HwpFile/HWPFile.pro Normal file
View File

@ -0,0 +1,36 @@
QT -= core gui
VERSION = 0.0.0.1
TARGET = HWPFile
TEMPLATE = lib
CONFIG += shared
CONFIG += plugin
CORE_ROOT_DIR = $$PWD/..
PWD_ROOT_DIR = $$PWD
include($$CORE_ROOT_DIR/Common/base.pri)
ADD_DEPENDENCY(kernel)
SOURCES += \
HwpDoc/HWPDocInfo.cpp \
HwpDoc/HWPElements/HWPRecord.cpp \
HwpDoc/HWPElements/HWPRecordBinData.cpp \
HwpDoc/HWPFile.cpp \
HwpDoc/HWPStream.cpp \
HwpDoc/HwpFileHeader.cpp
HEADERS += \
HwpDoc/Errors.h \
HwpDoc/HWPDocInfo.h \
HwpDoc/HWPElements/HWPRecord.h \
HwpDoc/HWPElements/HWPRecordBinData.h \
HwpDoc/HWPElements/HWPTag.h \
HwpDoc/HWPElements/HwpRecordTypes.h \
HwpDoc/HWPFile.h \
HwpDoc/HWPStream.h \
HwpDoc/HanType.h \
HwpDoc/HwpFileHeader.h

22
HwpFile/HwpDoc/Errors.h Normal file
View File

@ -0,0 +1,22 @@
#ifndef ERRORS_H
#define ERRORS_H
namespace HWP
{
enum class EErrorsCode
{
UNDEFINED,
SIGANTURE_NOT_MATCH,
INVALID_MAJORVERSION,
INVALID_MINORVERSION,
INVALID_BYTEORDER,
INVALID_SECTORSHIFT,
INVALID_MINISECTORSHIFT,
INVALID_NUM_DIRECTORYSECTOR,
INVALID_MINI_STREAM_CUTOFF,
FILE_READ_ERROR,
INVALID_ZIP_DATA_FORMAT
};
}
#endif // ERRORS_H

84
HwpFile/HwpDoc/HWPDocInfo.cpp Normal file
View File

@ -0,0 +1,84 @@
#include "HWPDocInfo.h"
#include "HWPElements/HWPRecordBinData.h"
namespace HWP
{
CHWPDocInfo::CHWPDocInfo(EHanType eHanType)
: m_eHanType(eHanType)
{
}
CHWPDocInfo::CHWPDocInfo(CHWPXFile* pHWPXFile)
: m_pParentHWPX(pHWPXFile), m_eHanType(EHanType::HWPX)
{}
CHWPDocInfo::CHWPDocInfo(CHWPFile* pHWPFile)
: m_pParentHWP(pHWPFile), m_eHanType(EHanType::HWP)
{}
#define REMOVE_LIST_DATA(list) \
for (CHWPRecord* pRecord : list) \
{ \
if (nullptr != pRecord) \
delete pRecord; \
} \
list.clear() \
CHWPDocInfo::~CHWPDocInfo()
{
REMOVE_LIST_DATA(m_lRecords);
REMOVE_LIST_DATA(m_lFaseNames);
REMOVE_LIST_DATA(m_lBorderFills);
REMOVE_LIST_DATA(m_lCharShapes);
REMOVE_LIST_DATA(m_lNumberings);
REMOVE_LIST_DATA(m_lBullets);
REMOVE_LIST_DATA(m_lParaShapes);
REMOVE_LIST_DATA(m_lStyles);
REMOVE_LIST_DATA(m_lTabDefs);
for (std::pair<std::string, CHWPRecord*> oBinData : m_mBinDatas)
{
if (nullptr != oBinData.second)
delete oBinData.second;
}
m_mBinDatas.clear();
}
bool CHWPDocInfo::Parse(CHWPStream& oBuffer, int nVersion)
{
int nOff = 0;
while (nOff < oBuffer.GetLength())
{
int nHeader = ((oBuffer[nOff + 3] << 24) & 0xFF000000) | ((oBuffer[nOff + 2] << 16) & 0xFF0000) | ((oBuffer[nOff + 1] << 8) & 0xFF00) | (oBuffer[nOff] & 0xFF);
int nTagNum = nHeader & 0x3FF;
int nLevel = (nHeader & 0xFFC00) >> 10; //TODO:: Проверить побитовый сдвиг без знака
int nSize = (nHeader & 0xFFF00000) >> 20;
if (0xFFF == nSize)
{
nSize = ((oBuffer[nOff + 7] << 24) & 0xFF000000) | ((oBuffer[nOff + 6] << 16) & 0xFF0000) | ((oBuffer[nOff + 5] << 8) & 0xFF00) | (oBuffer[nOff + 4] & 0xFF);
}
else
nOff += 4;
CHWPRecord *pRecord = nullptr;
EHWPTag eTag = GetTagFromNum(nTagNum);
switch (eTag)
{
case EHWPTag::HWPTAG_BIN_DATA:
{
CHWPRecordBinData *pBindData = new CHWPRecordBinData(*this, nTagNum, nLevel, nSize, oBuffer, nOff, nVersion);
if (nullptr != pBindData)
m_mBinDatas.insert(std::make_pair(pBindData->GetItemID(), pBindData));
}
default: break;
}
}
}
}

44
HwpFile/HwpDoc/HWPDocInfo.h Normal file
View File

@ -0,0 +1,44 @@
#ifndef HWPDOCINFO_H
#define HWPDOCINFO_H
#include "HWPFile.h"
#include "HanType.h"
#include "HWPStream.h"
#include "HWPElements/HWPRecord.h"
#include <map>
#include <list>
namespace HWP
{
class CHWPDocInfo
{
EHanType m_eHanType;
CHWPXFile *m_pParentHWPX;
CHWPFile *m_pParentHWP;
std::list<CHWPRecord*> m_lRecords;
std::map<std::string, CHWPRecord*> m_mBinDatas;
std::list<CHWPRecord*> m_lFaseNames;
std::list<CHWPRecord*> m_lBorderFills;
std::list<CHWPRecord*> m_lCharShapes;
std::list<CHWPRecord*> m_lNumberings;
std::list<CHWPRecord*> m_lBullets;
std::list<CHWPRecord*> m_lParaShapes;
std::list<CHWPRecord*> m_lStyles;
std::list<CHWPRecord*> m_lTabDefs;
CCompatDoc m_oCompatibleDoc;
public:
CHWPDocInfo(EHanType eHanType);
CHWPDocInfo(CHWPXFile* pHWPXFile);
CHWPDocInfo(CHWPFile* pHWPFile);
~CHWPDocInfo();
bool Parse(CHWPStream& oBuffer, int nVersion);
};
}
#endif // HWPDOCINFO_H

14
HwpFile/HwpDoc/HWPElements/HWPRecord.cpp Normal file
View File

@ -0,0 +1,14 @@
#include "HWPRecord.h"
namespace HWP
{
CHWPRecord::CHWPRecord(int nTagNum, int nLevel, int nSize)
: m_nLevel(nLevel), m_nSize(nSize)
{
m_eTag = GetTagFromNum(nTagNum);
}
CHWPRecord::CHWPRecord(EHWPTag eTag, int nLevel, int nSize)
: m_eTag(eTag), m_nLevel(nLevel), m_nSize(nSize)
{}
}

21
HwpFile/HwpDoc/HWPElements/HWPRecord.h Normal file
View File

@ -0,0 +1,21 @@
#ifndef HWPRECORD_H
#define HWPRECORD_H
#include "HWPTag.h"
namespace HWP
{
class CHWPRecord
{
EHWPTag m_eTag;
int m_nLevel;
int m_nSize;
constexpr static const char HEX_ARRAY[] = "0123456789ABCDEF";
public:
CHWPRecord(int nTagNum, int nLevel, int nSize);
CHWPRecord(EHWPTag eTag, int nLevel, int nSize);
};
}
#endif // HWPRECORD_H

16
HwpFile/HwpDoc/HWPElements/HWPRecordBinData.cpp Normal file
View File

@ -0,0 +1,16 @@
#include "HWPRecordBinData.h"
namespace HWP
{
CHWPRecordBinData::CHWPRecordBinData(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion)
: CHWPRecord(nTagNum, nLevel, nSize)
{
}
std::string CHWPRecordBinData::GetItemID() const
{
return m_sItemID;
}
}

47
HwpFile/HwpDoc/HWPElements/HWPRecordBinData.h Normal file
View File

@ -0,0 +1,47 @@
#ifndef HWPRECORDBINDATA_H
#define HWPRECORDBINDATA_H
#include "HWPRecord.h"
#include "../HWPStream.h"
#include "../HWPDocInfo.h"
namespace HWP
{
class CHWPRecordBinData : public CHWPRecord
{
enum class EType
{
LINK = 0x0,
EMBEDDING = 0x1,
STORAGE = 0x2
} m_eType;
enum class ECompressed
{
FOLLOW_STORAGE = 0x00,
COMPRESS = 0x10,
NO_COMPRESS = 0x20
} m_eCompressed;
enum class EState
{
NEVER_ACCESSED = 0x000,
FOUND_FILE_BY_ACCESS = 0x100,
ACCESS_FAILED = 0x200,
LINK_ACCESS_IGNORED = 0x400
} m_eState;
std::string m_sAPath;
short m_shBinDataID;
std::string m_sFormat;
std::string m_sItemID;
public:
CHWPRecordBinData(CHWPDocInfo& oDocInfo, int nTagNum, int nLevel, int nSize, CHWPStream& oBuffer, int nOff, int nVersion);
std::string GetItemID() const;
};
}
#endif // HWPRECORDBINDATA_H

127
HwpFile/HwpDoc/HWPElements/HWPTag.h Normal file
View File

@ -0,0 +1,127 @@
#ifndef HWPTAG_H
#define HWPTAG_H
#include <map>
namespace HWP
{
#define ADD_TAG(name, index) name = 0x010 + index
enum EHWPTag
{
ADD_TAG(null, -1),
ADD_TAG(HWPTAG_DOCUMENT_PROPERTIES, 0),
ADD_TAG(HWPTAG_ID_MAPPINGS, 1),
ADD_TAG(HWPTAG_BIN_DATA, 2),
ADD_TAG(HWPTAG_FACE_NAME, 3),
ADD_TAG(HWPTAG_BORDER_FILL, 4),
ADD_TAG(HWPTAG_CHAR_SHAPE, 5),
ADD_TAG(HWPTAG_TAB_DEF, 6),
ADD_TAG(HWPTAG_NUMBERING, 7),
ADD_TAG(HWPTAG_BULLET, 8),
ADD_TAG(HWPTAG_PARA_SHAPE, 9),
ADD_TAG(HWPTAG_STYLE, 10),
ADD_TAG(HWPTAG_DOC_DATA, 11),
ADD_TAG(HWPTAG_DISTRIBUTE_DOC_DATA, 12),
ADD_TAG(HWPTAG_COMPATIBLE_DOCUMENT, 13),
ADD_TAG(HWPTAG_LAYOUT_COMPATIBILITY, 14),
ADD_TAG(HWPTAG_TRACKCHANGE, 15),
ADD_TAG(HWPTAG_PARA_HEADER, 50),
ADD_TAG(HWPTAG_PARA_TEXT, 51),
ADD_TAG(HWPTAG_PARA_CHAR_SHAPE, 52),
ADD_TAG(HWPTAG_PARA_LINE_SEG, 53),
ADD_TAG(HWPTAG_PARA_RANGE_TAG, 54),
ADD_TAG(HWPTAG_CTRL_HEADER, 55),
ADD_TAG(HWPTAG_LIST_HEADER, 56),
ADD_TAG(HWPTAG_PAGE_DEF, 57),
ADD_TAG(HWPTAG_FOOTNOTE_SHAPE, 58),
ADD_TAG(HWPTAG_PAGE_BORDER_FILL, 59),
ADD_TAG(HWPTAG_SHAPE_COMPONENT, 60),
ADD_TAG(HWPTAG_TABLE, 61),
ADD_TAG(HWPTAG_SHAPE_COMPONENT_LINE, 62),
ADD_TAG(HWPTAG_SHAPE_COMPONENT_RECTANGLE, 63),
ADD_TAG(HWPTAG_SHAPE_COMPONENT_ELLIPSE, 64),
ADD_TAG(HWPTAG_SHAPE_COMPONENT_ARC, 65),
ADD_TAG(HWPTAG_SHAPE_COMPONENT_POLYGON, 66),
ADD_TAG(HWPTAG_SHAPE_COMPONENT_CURVE, 67),
ADD_TAG(HWPTAG_SHAPE_COMPONENT_OLE, 68),
ADD_TAG(HWPTAG_SHAPE_COMPONENT_PICTURE, 69),
ADD_TAG(HWPTAG_SHAPE_COMPONENT_CONTAINER, 70),
ADD_TAG(HWPTAG_CTRL_DATA, 71),
ADD_TAG(HWPTAG_EQEDIT, 72),
ADD_TAG(HWPTAG_SHAPE_COMPONENT_TEXTART, 74),
ADD_TAG(HWPTAG_FORM_OBJECT, 75),
ADD_TAG(HWPTAG_MEMO_SHAPE, 76),
ADD_TAG(HWPTAG_MEMO_LIST, 77),
ADD_TAG(HWPTAG_FORBIDDEN_CHAR, 78),
ADD_TAG(HWPTAG_CHART_DATA, 79),
ADD_TAG(HWPTAG_TRACK_CHANGE, 80),
ADD_TAG(HWPTAG_TRACK_CHANGE_AUTHOR, 81),
ADD_TAG(HWPTAG_VIDEO_DATA, 82),
ADD_TAG(HWPTAG_SHAPE_COMPONENT_UNKNOWN, 99)
};
EHWPTag GetTagFromNum(int nTagNum)
{
switch (nTagNum)
{
case(EHWPTag::HWPTAG_DOCUMENT_PROPERTIES):
case(EHWPTag::HWPTAG_ID_MAPPINGS):
case(EHWPTag::HWPTAG_BIN_DATA):
case(EHWPTag::HWPTAG_FACE_NAME):
case(EHWPTag::HWPTAG_BORDER_FILL):
case(EHWPTag::HWPTAG_CHAR_SHAPE):
case(EHWPTag::HWPTAG_TAB_DEF):
case(EHWPTag::HWPTAG_NUMBERING):
case(EHWPTag::HWPTAG_BULLET):
case(EHWPTag::HWPTAG_PARA_SHAPE):
case(EHWPTag::HWPTAG_STYLE):
case(EHWPTag::HWPTAG_DISTRIBUTE_DOC_DATA):
case(EHWPTag::HWPTAG_COMPATIBLE_DOCUMENT):
case(EHWPTag::HWPTAG_LAYOUT_COMPATIBILITY):
case(EHWPTag::HWPTAG_TRACKCHANGE):
case(EHWPTag::HWPTAG_PARA_HEADER):
case(EHWPTag::HWPTAG_PARA_TEXT):
case(EHWPTag::HWPTAG_PARA_CHAR_SHAPE):
case(EHWPTag::HWPTAG_PARA_LINE_SEG):
case(EHWPTag::HWPTAG_PARA_RANGE_TAG):
case(EHWPTag::HWPTAG_CTRL_HEADER):
case(EHWPTag::HWPTAG_LIST_HEADER):
case(EHWPTag::HWPTAG_PAGE_DEF):
case(EHWPTag::HWPTAG_FOOTNOTE_SHAPE):
case(EHWPTag::HWPTAG_PAGE_BORDER_FILL):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT):
case(EHWPTag::HWPTAG_TABLE):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT_LINE):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT_RECTANGLE):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT_ELLIPSE):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT_ARC):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT_POLYGON):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT_CURVE):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT_OLE):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT_PICTURE):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT_CONTAINER):
case(EHWPTag::HWPTAG_CTRL_DATA):
case(EHWPTag::HWPTAG_EQEDIT):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT_TEXTART):
case(EHWPTag::HWPTAG_FORM_OBJECT):
case(EHWPTag::HWPTAG_MEMO_SHAPE):
case(EHWPTag::HWPTAG_MEMO_LIST):
case(EHWPTag::HWPTAG_FORBIDDEN_CHAR):
case(EHWPTag::HWPTAG_CHART_DATA):
case(EHWPTag::HWPTAG_TRACK_CHANGE):
case(EHWPTag::HWPTAG_TRACK_CHANGE_AUTHOR):
case(EHWPTag::HWPTAG_VIDEO_DATA):
case(EHWPTag::HWPTAG_SHAPE_COMPONENT_UNKNOWN):
return static_cast<EHWPTag>(nTagNum);
default:
return EHWPTag::null;
}
}
}
#endif // HWPTAG_H

131
HwpFile/HwpDoc/HWPElements/HwpRecordTypes.h Normal file
View File

@ -0,0 +1,131 @@
#ifndef HWPRECORDTYPES_H
#define HWPRECORDTYPES_H
namespace HWP
{
enum class ELineStyle1
{
SOLID,
DASH,
DOT,
DASH_DOT,
DASH_DOT_DOT,
LONG_DASH,
CIRCLE,
DOUBLE_SLIM,
SLIM_THICK,
THICK_SLIM,
SLIM_THICK_SLIM,
WAVE,
DOUBLE_WAVE,
THICK_3D,
THICK_3D_REVERS_LI,
SOLID_3D,
SOLID_3D_REVERS_LI
};
enum class ELineStyle2
{
NONE,
SOLID,
DASH,
DOT,
DASH_DOT,
DASH_DOT_DOT,
LONG_DASH,
CIRCLE,
DOUBLE_SLIM,
SLIM_THICK,
THICK_SLIM,
SLIM_THICK_SLIM
};
enum class ENumberShape1
{
DIGIT,
CIRCLE_DIGIT,
ROMAN_CAPITAL,
ROMAN_SMALL,
LATIN_CAPITAL,
LATIN_SMALL,
CIRCLED_LATIN_CAPITAL,
CIRCLED_LATIN_SMALL,
HANGLE_SYLLABLE,
CIRCLED_HANGUL_SYLLABLE,
HANGUL_JAMO,
CIRCLED_HANGUL_JAMO,
HANGUL_PHONETIC,
IDEOGRAPH,
CIRCLED_IDEOGRAPH
};
enum class ENumberShape2
{
DIGIT,
CIRCLE_DIGIT,
ROMAN_CAPITAL,
ROMAN_SMALL,
LATIN_CAPITAL,
LATIN_SMALL,
CIRCLED_LATIN_CAPITAL,
CIRCLED_LATIN_SMALL,
HANGLE_SYLLABLE,
CIRCLED_HANGUL_SYLLABLE,
HANGUL_JAMO,
CIRCLED_HANGUL_JAMO,
HANGUL_PHONETIC,
IDEOGRAPH,
CIRCLED_IDEOGRAPH,
DECAGON_CIRCLE,
DECAGON_CRICLE_HANGJA,
SYMBOL = 0x80,
USER_CHAR = 0x81
};
enum class ELineArrowStyle
{
NORMAL,
ARROW,
SPEAR,
CONCAVE_ARROW,
DIAMOND,
CIRCLE,
BOX,
EMPTY_DIAMOND,
EMPTY_CIRCLE,
EMPTY_BOX
};
ELineArrowStyle GetLineArrowStyle(int nNum, bool bFill)
{
switch (nNum)
{
case 0: return ELineArrowStyle::NORMAL;
case 1: return ELineArrowStyle::ARROW;
case 2: return ELineArrowStyle::SPEAR;
case 3: return ELineArrowStyle::CONCAVE_ARROW;
case 4:
case 7: return bFill ? ELineArrowStyle::DIAMOND : ELineArrowStyle::EMPTY_DIAMOND;
case 5:
case 8: return bFill ? ELineArrowStyle::CIRCLE : ELineArrowStyle::EMPTY_CIRCLE;
case 6:
case 9: return bFill ? ELineArrowStyle::BOX : ELineArrowStyle::EMPTY_BOX;
default: return ELineArrowStyle::NORMAL;
}
}
enum class ELineArrowSize
{
SMALL_SMALL,
SMALL_MEDIUM,
SMALL_LARGE,
MEDIUM_SMALL,
MEDIUM_MEDIUM,
MEDIUM_LARGE,
LARGE_SMALL,
LARGE_MEDIUM,
LARGE_LARGE
};
}
#endif // HWPRECORDTYPES_H

9
HwpFile/HwpDoc/HWPFile.cpp Normal file
View File

@ -0,0 +1,9 @@
#include "HWPFile.h"
namespace HWP
{
CHWPFile::CHWPFile()
{
}
}

22
HwpFile/HwpDoc/HWPFile.h Normal file
View File

@ -0,0 +1,22 @@
#ifndef HWPFILE_H
#define HWPFILE_H
#include "HwpFileHeader.h"
namespace HWP
{
class CHWPFile
{
std::string m_sFileName;
CCompoundFile m_oOleFile;
CHwpFileHeader m_oFileHeader;
int m_nVersion;
CHwpDocInfo m_oDocInfo;
std::list<CHwpSection> m_lBodyText;
std::list<CHwpSection> m_lViewText;
public:
CHWPFile();
};
}
#endif // HWPFILE_H

57
HwpFile/HwpDoc/HWPStream.cpp Normal file
View File

@ -0,0 +1,57 @@
#include "HWPStream.h"
namespace HWP
{
CHWPStream::CHWPStream()
: m_pBegin(nullptr), m_pCur(nullptr), m_pEnd(nullptr)
{
}
CHWPStream::CHWPStream(BYTE* pBuffer, unsigned int unSize)
: m_pBegin(pBuffer), m_pCur(pBuffer), m_pEnd(pBuffer + unSize)
{}
void CHWPStream::SetStream(BYTE* pBuffer, unsigned int unSize)
{
m_pBegin = pBuffer;
m_pCur = pBuffer;
m_pEnd = pBuffer + unSize;
}
BYTE* CHWPStream::GetCurPtr()
{
return m_pCur;
}
void CHWPStream::Skip(unsigned int unStep)
{
if (m_pCur + unStep >= m_pEnd)
m_pCur = m_pEnd;
else
m_pCur += unStep;
}
bool CHWPStream::IsValid() const
{
return nullptr != m_pBegin;
}
bool CHWPStream::IsEof() const
{
return m_pCur >= m_pEnd;
}
unsigned int CHWPStream::GetLength() const
{
return (unsigned int)(m_pEnd - m_pCur);
}
BYTE CHWPStream::operator[](unsigned int unPosition) const
{
if (m_pCur >= m_pEnd)
return *m_pEnd;
return *(m_pCur + unPosition);
}
}

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

@ -0,0 +1,31 @@
#ifndef HWPSTREAM_H
#define HWPSTREAM_H
namespace HWP
{
typedef unsigned char BYTE;
class CHWPStream
{
BYTE* m_pBegin;
BYTE* m_pCur;
BYTE* m_pEnd;
public:
CHWPStream();
CHWPStream(BYTE* pBuffer, unsigned int unSize);
void SetStream(BYTE* pBuffer, unsigned int unSize);
BYTE* GetCurPtr();
void Skip(unsigned int unStep);
bool IsValid() const;
bool IsEof() const;
unsigned int GetLength() const;
BYTE operator[](unsigned int unPosition) const;
};
}
#endif // HWPSTREAM_H

14
HwpFile/HwpDoc/HanType.h Normal file
View File

@ -0,0 +1,14 @@
#ifndef HANTYPE_H
#define HANTYPE_H
namespace HWP
{
enum class EHanType
{
NONE,
HWP,
HWPX
};
}
#endif // HANTYPE_H

64
HwpFile/HwpDoc/HwpFileHeader.cpp Normal file
View File

@ -0,0 +1,64 @@
#include "HwpFileHeader.h"
namespace HWP
{
CHwpFileHeader::CHwpFileHeader()
{}
bool CHwpFileHeader::Parse(CHWPStream& oBuffer)
{
unsigned int unOffset = 0;
m_sSignature = std::string((char*)oBuffer.GetCurPtr(), 32);
if ("HWP Document File" != m_sSignature)
return false;
unOffset += 32;
//version
unOffset += 4;
#define CHECK_BOOL(value) (oBuffer[unOffset] & value) == value ? true : false
m_bCompressed = CHECK_BOOL(0x01);
m_bPasswordEncrypted = CHECK_BOOL(0x02);
m_bDistributable = CHECK_BOOL(0x04);
m_bSaveScript = CHECK_BOOL(0x08);
m_bDRMprotected = CHECK_BOOL(0x10);
m_bHasXMLTemplateStorage = CHECK_BOOL(0x20);
m_bHasDocumentHistory = CHECK_BOOL(0x40);
m_bHasPkiSignature = CHECK_BOOL(0x80);
++unOffset;
m_bPkiEncrypted = CHECK_BOOL(0x01);
m_bReservePkiSignature = CHECK_BOOL(0x02);
m_bPkiCertificateDRM = CHECK_BOOL(0x04);
m_bCCLDocument = CHECK_BOOL(0x08);
m_bMobileOptimized = CHECK_BOOL(0x10);
m_bPrivateInformation = CHECK_BOOL(0x20);
m_bModifyTracking = CHECK_BOOL(0x40);
m_bCopyrightKOGL = CHECK_BOOL(0x80);
++unOffset;
m_bHasVideoControl = CHECK_BOOL(0x01);
m_bHasMarkFieldControl = CHECK_BOOL(0x02);
unOffset += 2;
m_bCopyrighted = CHECK_BOOL(0x01);
m_bCopyProhibited = CHECK_BOOL(0x02);
m_bCopyPermitted = CHECK_BOOL(0x04);
unOffset += 4;
//encryptVersion
unOffset += 4;
m_nCountryKOGLLicensed = (int)oBuffer[unOffset];
return true;
}
}

45
HwpFile/HwpDoc/HwpFileHeader.h Normal file
View File

@ -0,0 +1,45 @@
#ifndef HWPFILEHEADER_H
#define HWPFILEHEADER_H
#include <string>
#include "HWPStream.h"
namespace HWP
{
class CHwpFileHeader
{
std::string m_sSignature;
std::string m_sVersion;
bool m_bCompressed;
bool m_bPasswordEncrypted;
bool m_bDistributable;
bool m_bSaveScript;
bool m_bDRMprotected;
bool m_bHasXMLTemplateStorage;
bool m_bHasDocumentHistory;
bool m_bHasPkiSignature;
bool m_bPkiEncrypted;
bool m_bReservePkiSignature;
bool m_bPkiCertificateDRM;
bool m_bCCLDocument;
bool m_bMobileOptimized;
bool m_bPrivateInformation;
bool m_bModifyTracking;
bool m_bCopyrightKOGL;
bool m_bHasVideoControl;
bool m_bHasMarkFieldControl;
bool m_bCopyrighted;
bool m_bCopyProhibited;
bool m_bCopyPermitted;
int m_nEncryptVersion;
int m_nCountryKOGLLicensed;
public:
CHwpFileHeader();
bool Parse(unsigned char* pBuffer);
};
}
#endif // HWPFILEHEADER_H