/* * (c) Copyright Ascensio System SIA 2010-2023 * * This program is a free software product. You can redistribute it and/or * modify it under the terms of the GNU Affero General Public License (AGPL) * version 3 as published by the Free Software Foundation. In accordance with * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect * that Ascensio System SIA expressly excludes the warranty of non-infringement * of any third-party rights. * * This program is distributed WITHOUT ANY WARRANTY; without even the implied * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html * * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish * street, Riga, Latvia, EU, LV-1050. * * The interactive user interfaces in modified source and object code versions * of the Program must display Appropriate Legal Notices, as required under * Section 5 of the GNU AGPL version 3. * * Pursuant to Section 7(b) of the License you must retain the original Product * logo when distributing the program. Pursuant to Section 7(e) we decline to * grant you any rights under trademark law for use of our trademarks. * * All the Product's GUI elements, including illustrations and icon sets, as * well as technical writing content are licensed under the terms of the * Creative Commons Attribution-ShareAlike 4.0 International. See the License * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode * */ #include "BinaryReaderD.h" #include "../BinWriter/BinReaderWriterDefines.h" #include "../../Sheets/Writer/BinaryReaderS.h" #include "../../../PPTXFormat/Logic/HeadingVariant.h" #include "../../../DocxFormat/Settings/Settings.h" #include "../../../DocxFormat/App.h" #include "../../../DocxFormat/Core.h" #include "../../../DocxFormat/CustomXml.h" #include "../../../DocxFormat/Math/oMathContent.h" #include "../../../DocxFormat/Logic/DocParts.h" #include "../../../DocxFormat/Logic/SectionProperty.h" #include "../../../DocxFormat/Logic/TableProperty.h" #include "../../../DocxFormat/Logic/Sdt.h" #include "../../../DocxFormat/Numbering.h" #include "../DocWrapper/XlsxSerializer.h" #include "../../../../OfficeUtils/src/OfficeUtils.h" #include "../../../../DesktopEditor/common/Directory.h" #define UINT_TO_COMPLEX_BOOL(offset, val) \ if (0 != ((nFlags >> offset) & 1)) { \ val.Init(); \ } namespace BinDocxRW { enum ETblStyleOverrideType { tblstyleoverridetypeBand1Horz = 0, tblstyleoverridetypeBand1Vert = 1, tblstyleoverridetypeBand2Horz = 2, tblstyleoverridetypeBand2Vert = 3, tblstyleoverridetypeFirstCol = 4, tblstyleoverridetypeFirstRow = 5, tblstyleoverridetypeLastCol = 6, tblstyleoverridetypeLastRow = 7, tblstyleoverridetypeNeCell = 8, tblstyleoverridetypeNwCell = 9, tblstyleoverridetypeSeCell = 10, tblstyleoverridetypeSwCell = 11, tblstyleoverridetypeWholeTable = 12 }; struct RowHeight { unsigned char HRule = 0; long nHeight = 0; }; class SdtWraper { public: OOX::Logic::CSdt m_oSdt; nullable m_oEndPr; nullable m_oRPr; int m_nType; SdtWraper(int nType) : m_nType(nType) {} ~SdtWraper() {} }; #define READ1_DEF(stLen, res, fReadFunction, arg) {\ long read1defCurPos = 0;\ while(read1defCurPos < (long)stLen)\ {\ BYTE read1defType = 0;\ if (false == m_oBufferedStream.GetUCharWithResult(&read1defType))\ break;\ long read1defLength = m_oBufferedStream.GetLong();\ res = fReadFunction(read1defType, read1defLength, arg);\ if (res == c_oSerConstants::ReadUnknown)\ {\ m_oBufferedStream.GetPointer(read1defLength);\ res = c_oSerConstants::ReadOk;\ }\ else if (res != c_oSerConstants::ReadOk)\ break;\ read1defCurPos += read1defLength + 5;\ }\ } #define READ2_DEF(stLen, res, fReadFunction, arg) {\ long read2defCurPos = 0;\ while(read2defCurPos < (long)stLen)\ {\ BYTE read2defType = 0;\ if (false == m_oBufferedStream.GetUCharWithResult(&read2defType))\ break;\ long read2defLenType = m_oBufferedStream.GetUChar();\ int read2defCurPosShift = 2;\ int read2defRealLen;\ switch(read2defLenType)\ {\ case c_oSerPropLenType::Null: read2defRealLen = 0;break;\ case c_oSerPropLenType::Byte: read2defRealLen = 1;break;\ case c_oSerPropLenType::Short: read2defRealLen = 2;break;\ case c_oSerPropLenType::Three: read2defRealLen = 3;break;\ case c_oSerPropLenType::Long:\ case c_oSerPropLenType::Double: read2defRealLen = 4;break;\ case c_oSerPropLenType::Variable:\ read2defRealLen = m_oBufferedStream.GetLong();\ read2defCurPosShift += 4;\ break;\ case c_oSerPropLenType::Double64: read2defRealLen = 8;break;\ case c_oSerPropLenType::Long64: read2defRealLen = 8;break;\ default:res = c_oSerConstants::ErrorUnknown;break;\ }\ if (res == c_oSerConstants::ReadOk)\ res = fReadFunction(read2defType, read2defRealLen, arg);\ if (res == c_oSerConstants::ReadUnknown)\ {\ m_oBufferedStream.GetPointer(read2defRealLen);\ res = c_oSerConstants::ReadOk;\ }\ else if (res != c_oSerConstants::ReadOk)\ break;\ read2defCurPos += read2defRealLen + read2defCurPosShift;\ }\ } #define READ_TABLE_DEF(res, fReadFunction, arg) {\ res = m_oBufferedStream.Peek(4) == false ? c_oSerConstants::ErrorStream : c_oSerConstants::ReadOk;\ if (c_oSerConstants::ReadOk == res) {\ long readtabledefLen = m_oBufferedStream.GetLong();\ res = m_oBufferedStream.Peek(readtabledefLen) == false ? c_oSerConstants::ErrorStream : c_oSerConstants::ReadOk;\ if (c_oSerConstants::ReadOk == res) {\ READ1_DEF(readtabledefLen, res, fReadFunction, arg);\ }\ }\ } #define READ1_TRACKREV(type, length, poResult) \ if (c_oSerProp_RevisionType::Author == type)\ {\ poResult->Author = m_oBufferedStream.GetString3(length);\ }\ else if (c_oSerProp_RevisionType::Date == type)\ {\ poResult->Date = m_oBufferedStream.GetString3(length);\ }\ else if (c_oSerProp_RevisionType::Id == type)\ {\ poResult->Id = new _INT32(m_oBufferedStream.GetLong());\ }\ else if (c_oSerProp_RevisionType::UserId == type)\ {\ poResult->UserId = m_oBufferedStream.GetString3(length);\ } //------------------------------------------------------------------------------------------------------------------ #define READ1_BORDERS_START2 \ if (c_oSerBordersType::left == type)\ {\ pBorders->m_oStart.Init();\ READ2_DEF(length, res, this->ReadBorder, pBorders->m_oStart.GetPointer());\ }\ else if (c_oSerBordersType::right == type)\ {\ pBorders->m_oEnd.Init();\ READ2_DEF(length, res, this->ReadBorder, pBorders->m_oEnd.GetPointer());\ }\ else if (c_oSerBordersType::insideV == type)\ {\ pBorders->m_oInsideV.Init();\ READ2_DEF(length, res, this->ReadBorder, pBorders->m_oInsideV.GetPointer());\ }\ else if (c_oSerBordersType::insideH == type)\ {\ pBorders->m_oInsideH.Init();\ READ2_DEF(length, res, this->ReadBorder, pBorders->m_oInsideH.GetPointer());\ }\ READ1_BORDERS_START //------------------------------------------------------------------------------------------------------------------ #define READ1_BORDERS_START1 \ if (c_oSerBordersType::left == type)\ {\ pBorders->m_oLeft.Init();\ READ2_DEF(length, res, this->ReadBorder, pBorders->m_oLeft.GetPointer());\ }\ else if (c_oSerBordersType::right == type)\ {\ pBorders->m_oRight.Init();\ READ2_DEF(length, res, this->ReadBorder, pBorders->m_oRight.GetPointer());\ }\ READ1_BORDERS_START //------------------------------------------------------------------------------------------------- #define READ1_BORDERS_START \ else if (c_oSerBordersType::top == type)\ {\ pBorders->m_oTop.Init();\ READ2_DEF(length, res, this->ReadBorder, pBorders->m_oTop.GetPointer());\ }\ else if (c_oSerBordersType::bottom == type)\ {\ pBorders->m_oBottom.Init();\ READ2_DEF(length, res, this->ReadBorder, pBorders->m_oBottom.GetPointer());\ } //------------------------------------------------------------------------------------------------------------------ #define READ1_TRACKREV_2(type, length, poResult) \ if (c_oSerProp_RevisionType::Author == type)\ {\ poResult->m_sAuthor = m_oBufferedStream.GetString3(length);\ }\ else if (c_oSerProp_RevisionType::Date == type)\ {\ poResult->m_oDate.Init(); poResult->m_oDate->SetValue(m_oBufferedStream.GetString3(length));\ }\ else if (c_oSerProp_RevisionType::Id == type)\ {\ poResult->m_oId.Init(); poResult->m_oId->SetValue( m_oBufferedStream.GetLong());\ }\ else if (c_oSerProp_RevisionType::UserId == type)\ {\ poResult->m_sUserId = m_oBufferedStream.GetString3(length);\ } Binary_CommonReader::Binary_CommonReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream):m_oBufferedStream(poBufferedStream) { } Binary_CommonReader2::Binary_CommonReader2(NSBinPptxRW::CBinaryFileReader& poBufferedStream):Binary_CommonReader(poBufferedStream) { } docRGB Binary_CommonReader2::ReadColor() { docRGB oRGB; oRGB.R = m_oBufferedStream.GetUChar(); oRGB.G = m_oBufferedStream.GetUChar(); oRGB.B = m_oBufferedStream.GetUChar(); return oRGB; } void Binary_CommonReader2::ReadHexColor(SimpleTypes::CHexColor *pColor, long length) { if (!pColor) { m_oBufferedStream.Skip(length); return; } pColor->SetValue(SimpleTypes::hexcolorRGB); if (length == 4) { pColor->SetValue(SimpleTypes::hexcolorARGB); pColor->Set_A(m_oBufferedStream.GetUChar()); } pColor->Set_R(m_oBufferedStream.GetUChar()); pColor->Set_G(m_oBufferedStream.GetUChar()); pColor->Set_B(m_oBufferedStream.GetUChar()); } void Binary_CommonReader2::ReadThemeColor(int length, CThemeColor& oCThemeColor) { int res = c_oSerConstants::ReadOk; READ2_DEF(length, res, this->ReadThemeColorContent, &oCThemeColor); } int Binary_CommonReader2::ReadThemeColorContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CThemeColor* pCThemeColor = static_cast(poResult); switch(type) { case c_oSer_ColorThemeType::Auto: pCThemeColor->Auto = true; break; case c_oSer_ColorThemeType::Color: pCThemeColor->bColor = true; pCThemeColor->Color = m_oBufferedStream.GetUChar(); break; case c_oSer_ColorThemeType::Tint: pCThemeColor->bTint = true; pCThemeColor->Tint = m_oBufferedStream.GetUChar(); break; case c_oSer_ColorThemeType::Shade: pCThemeColor->bShade = true; pCThemeColor->Shade = m_oBufferedStream.GetUChar(); break; default: res = c_oSerConstants::ReadUnknown; break; } return res; } template int Binary_CommonReader2::ReadTrackRevision(long length, T* poResult) { int res = c_oSerConstants::ReadOk; READ1_DEF(length, res, this->ReadTrackRevisionInner, poResult); return res; } template int Binary_CommonReader2::ReadTrackRevision2(long length, T* poResult) { int res = c_oSerConstants::ReadOk; READ1_DEF(length, res, this->ReadTrackRevisionInner2, poResult); return res; } int Binary_CommonReader2::ReadShdComplexType(BYTE type, long length, void* poResult) { if (length < 0) return 0; int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CShading* pShd = static_cast(poResult); if (!pShd) { m_oBufferedStream.Skip(length); return 0; } switch (type) { case c_oSerShdType::Value: { pShd->m_oVal.Init(); pShd->m_oVal->SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerShdType::Color: { pShd->m_oColor.Init(); ReadHexColor(pShd->m_oColor.GetPointer(), length); }break; case c_oSerShdType::ColorTheme: { CThemeColor themeColor; ReadThemeColor(length, themeColor); themeColor.ToCThemeColor(pShd->m_oColor, pShd->m_oThemeColor, pShd->m_oThemeTint, pShd->m_oThemeShade); }break; case c_oSerShdType::Fill: { pShd->m_oFill.Init(); ReadHexColor(pShd->m_oFill.GetPointer(), length); }break; case c_oSerShdType::FillTheme: { CThemeColor themeColor; ReadThemeColor(length, themeColor); themeColor.ToCThemeColor(pShd->m_oFill, pShd->m_oThemeFill, pShd->m_oThemeFillTint, pShd->m_oThemeFillShade); }break; default: { res = c_oSerConstants::ReadUnknown; }break; } return res; } template int Binary_CommonReader2::ReadTrackRevisionInner(BYTE type, long length, T* poResult) { int res = c_oSerConstants::ReadOk; READ1_TRACKREV(type, length, poResult) else res = c_oSerConstants::ReadUnknown; return res; } template int Binary_CommonReader2::ReadTrackRevisionInner2(BYTE type, long length, T* poResult) { int res = c_oSerConstants::ReadOk; READ1_TRACKREV_2(type, length, poResult) else res = c_oSerConstants::ReadUnknown; return res; } Binary_HdrFtrTableReader::Binary_HdrFtrTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter) : Binary_CommonReader(poBufferedStream), m_oFileWriter(oFileWriter), m_oHeaderFooterWriter(oFileWriter.get_headers_footers_writer()) { } int Binary_HdrFtrTableReader::Read() { int res = c_oSerConstants::ReadOk; READ_TABLE_DEF(res, this->ReadHdrFtrContent, NULL); return res; } int Binary_HdrFtrTableReader::ReadHdrFtrContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerHdrFtrTypes::Header == type || c_oSerHdrFtrTypes::Footer == type ) { nCurType = type; READ1_DEF(length, res, this->ReadHdrFtrFEO, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_HdrFtrTableReader::ReadHdrFtrFEO(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerHdrFtrTypes::HdrFtr_First == type || c_oSerHdrFtrTypes::HdrFtr_Even == type || c_oSerHdrFtrTypes::HdrFtr_Odd == type ) { nCurHeaderType = type; READ1_DEF(length, res, this->ReadHdrFtrItem, poResult); if (BinDocxRW::g_nCurFormatVersion < 5 && SimpleTypes::hdrftrEven == type) { m_oFileWriter.m_pCurrentSettings->m_oEvenAndOddHeaders.Init(); } } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_HdrFtrTableReader::ReadHdrFtrItem(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerHdrFtrTypes::HdrFtr_Content == type ) { Writers::HdrFtrItem* poHdrFtrItem = NULL; switch(nCurHeaderType) { case c_oSerHdrFtrTypes::HdrFtr_First:poHdrFtrItem = new Writers::HdrFtrItem(SimpleTypes::hdrftrFirst);break; case c_oSerHdrFtrTypes::HdrFtr_Even:poHdrFtrItem = new Writers::HdrFtrItem(SimpleTypes::hdrftrEven);break; case c_oSerHdrFtrTypes::HdrFtr_Odd:poHdrFtrItem = new Writers::HdrFtrItem(SimpleTypes::hdrftrDefault);break; } if (NULL != poHdrFtrItem) { if (nCurType == c_oSerHdrFtrTypes::Header) { m_oHeaderFooterWriter.m_aHeaders.push_back(poHdrFtrItem); poHdrFtrItem->m_sFilename = L"header" + std::to_wstring((int)m_oHeaderFooterWriter.m_aHeaders.size()) + L".xml"; } else { m_oHeaderFooterWriter.m_aFooters.push_back(poHdrFtrItem); poHdrFtrItem->m_sFilename = L"footer" + std::to_wstring((int)m_oHeaderFooterWriter.m_aFooters.size()) + L".xml"; } m_oFileWriter.m_pDrawingConverter->SetDstContentRels(); Binary_DocumentTableReader oBinary_DocumentTableReader(m_oBufferedStream, m_oFileWriter, poHdrFtrItem->Header, false); READ1_DEF(length, res, this->ReadHdrFtrItemContent, &oBinary_DocumentTableReader); OOX::CPath fileRelsPath = m_oFileWriter.get_document_writer().m_sDir + FILE_SEPARATOR_STR + L"word" + (m_oFileWriter.m_bGlossaryMode ? FILE_SEPARATOR_STR + std::wstring(L"glossary") : L"") + FILE_SEPARATOR_STR + L"_rels"+ FILE_SEPARATOR_STR + poHdrFtrItem->m_sFilename + L".rels"; m_oFileWriter.m_pDrawingConverter->SaveDstContentRels(fileRelsPath.GetPath()); } } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_HdrFtrTableReader::ReadHdrFtrItemContent(BYTE type, long length, void* poResult) { Binary_DocumentTableReader* pBinary_DocumentTableReader = static_cast(poResult); return pBinary_DocumentTableReader->ReadDocumentContent(type, length, NULL); } Binary_rPrReader::Binary_rPrReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter) : Binary_CommonReader(poBufferedStream), oBinary_CommonReader2(poBufferedStream), m_oFileWriter(oFileWriter) , m_mapFonts(oFileWriter.get_font_table_writer().m_mapFonts) { } int Binary_rPrReader::Read(long stLen, void* poResult) { int res = c_oSerConstants::ReadOk; READ2_DEF(stLen, res, this->ReadContent, poResult); return res; }; int Binary_rPrReader::ReadContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CRunProperty* pRPr = static_cast(poResult); switch(type) { case c_oSerProp_rPrType::Bold: { pRPr->m_oBold.Init(); pRPr->m_oBold->m_oVal.FromBool(0 != m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::Italic: { pRPr->m_oItalic.Init(); pRPr->m_oItalic->m_oVal.FromBool(0 != m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::Underline: { pRPr->m_oU.Init(); pRPr->m_oU->m_oVal.Init(); pRPr->m_oU->m_oVal->SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::Strikeout: { pRPr->m_oStrike.Init(); pRPr->m_oStrike->m_oVal.FromBool(0 != m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::FontAscii: { std::wstring sFontName = XmlUtils::EncodeXmlString(m_oBufferedStream.GetString3(length)); if (!sFontName.empty()) { m_mapFonts[sFontName] = 1; if (!pRPr->m_oRFonts.IsInit()) pRPr->m_oRFonts.Init(); pRPr->m_oRFonts->m_sAscii = sFontName; } }break; case c_oSerProp_rPrType::FontAsciiTheme: { if (!pRPr->m_oRFonts.IsInit()) pRPr->m_oRFonts.Init(); pRPr->m_oRFonts->m_oAsciiTheme.Init(); pRPr->m_oRFonts->m_oAsciiTheme->SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::FontHAnsi: { std::wstring sFontName = XmlUtils::EncodeXmlString(m_oBufferedStream.GetString3(length)); if (!sFontName.empty()) { m_mapFonts[sFontName] = 1; if (!pRPr->m_oRFonts.IsInit()) pRPr->m_oRFonts.Init(); pRPr->m_oRFonts->m_sHAnsi = sFontName; } }break; case c_oSerProp_rPrType::FontHAnsiTheme: { if (!pRPr->m_oRFonts.IsInit()) pRPr->m_oRFonts.Init(); pRPr->m_oRFonts->m_oHAnsiTheme.Init(); pRPr->m_oRFonts->m_oHAnsiTheme->SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::FontCS: { std::wstring sFontName = XmlUtils::EncodeXmlString(m_oBufferedStream.GetString3(length)); if (!sFontName.empty()) { m_mapFonts[sFontName] = 1; if (!pRPr->m_oRFonts.IsInit()) pRPr->m_oRFonts.Init(); pRPr->m_oRFonts->m_sCs = sFontName; } }break; case c_oSerProp_rPrType::FontCSTheme: { if (!pRPr->m_oRFonts.IsInit()) pRPr->m_oRFonts.Init(); pRPr->m_oRFonts->m_oCsTheme.Init(); pRPr->m_oRFonts->m_oCsTheme->SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::FontAE: { std::wstring sFontName = XmlUtils::EncodeXmlString(m_oBufferedStream.GetString3(length)); if (!sFontName.empty()) { m_mapFonts[sFontName] = 1; if (!pRPr->m_oRFonts.IsInit()) pRPr->m_oRFonts.Init(); pRPr->m_oRFonts->m_sEastAsia = sFontName; } }break; case c_oSerProp_rPrType::FontAETheme: { if (!pRPr->m_oRFonts.IsInit()) pRPr->m_oRFonts.Init(); pRPr->m_oRFonts->m_oEastAsiaTheme.Init(); pRPr->m_oRFonts->m_oEastAsiaTheme->SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::FontSize: { pRPr->m_oSz.Init(); pRPr->m_oSz->m_oVal.Init(); pRPr->m_oSz->m_oVal->FromHps(m_oBufferedStream.GetLong()); }break; case c_oSerProp_rPrType::Color: { docRGB color = oBinary_CommonReader2.ReadColor(); pRPr->m_oColor.Init(); pRPr->m_oColor->m_oVal.Init(); pRPr->m_oColor->m_oVal->SetValue(SimpleTypes::hexcolorRGB); pRPr->m_oColor->m_oVal->Set_R(color.R); pRPr->m_oColor->m_oVal->Set_G(color.G); pRPr->m_oColor->m_oVal->Set_B(color.B); }break; case c_oSerProp_rPrType::VertAlign: { pRPr->m_oVertAlign.Init(); pRPr->m_oVertAlign->m_oVal.Init(); pRPr->m_oVertAlign->m_oVal->SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::HighLight: { docRGB H = oBinary_CommonReader2.ReadColor(); std::wstring sColor; if (0x00 == H.R && 0x00 == H.G && 0x00 == H.B) sColor = _T("black"); else if (0x00 == H.R && 0x00 == H.G && 0xFF == H.B) sColor = _T("blue"); else if (0x00 == H.R && 0xFF == H.G && 0xFF == H.B) sColor = _T("cyan"); else if (0x00 == H.R && 0x00 == H.G && 0x8B == H.B) sColor = _T("darkBlue"); else if (0x00 == H.R && 0x8B == H.G && 0x8B == H.B) sColor = _T("darkCyan"); else if (0xA9 == H.R && 0xA9 == H.G && 0xA9 == H.B) sColor = _T("darkGray"); else if (0x00 == H.R && 0x64 == H.G && 0x00 == H.B) sColor = _T("darkGreen"); else if (0x80 == H.R && 0x00 == H.G && 0x80 == H.B) sColor = _T("darkMagenta"); else if (0x8B == H.R && 0x00 == H.G && 0x00 == H.B) sColor = _T("darkRed"); else if (0x80 == H.R && 0x80 == H.G && 0x00 == H.B) sColor = _T("darkYellow"); else if (0x00 == H.R && 0xFF == H.G && 0x00 == H.B) sColor = _T("green"); else if (0xD3 == H.R && 0xD3 == H.G && 0xD3 == H.B) sColor = _T("lightGray"); else if (0xFF == H.R && 0x00 == H.G && 0xFF == H.B) sColor = _T("magenta"); else if (0xFF == H.R && 0x00 == H.G && 0x00 == H.B) sColor = _T("red"); else if (0xFF == H.R && 0xFF == H.G && 0xFF == H.B) sColor = _T("white"); else if (0xFF == H.R && 0xFF == H.G && 0x00 == H.B) sColor = _T("yellow"); pRPr->m_oHighlight.Init(); pRPr->m_oHighlight->m_oVal.Init(); pRPr->m_oHighlight->m_oVal->FromString(sColor); }break; case c_oSerProp_rPrType::HighLightTyped: { BYTE byteHighLightTyped = m_oBufferedStream.GetUChar(); pRPr->m_oHighlight.Init(); pRPr->m_oHighlight->m_oVal.Init(); pRPr->m_oHighlight->m_oVal->SetValue(SimpleTypes::highlightcolorNone); }break; case c_oSerProp_rPrType::Shd: { pRPr->m_oShd.Init(); READ2_DEF(length, res, oBinary_CommonReader2.ReadShdComplexType, pRPr->m_oShd.GetPointer()); }break; case c_oSerProp_rPrType::RStyle: { pRPr->m_oRStyle.Init(); pRPr->m_oRStyle->m_sVal = m_oBufferedStream.GetString3(length); }break; case c_oSerProp_rPrType::Spacing: { pRPr->m_oSpacing.Init(); pRPr->m_oSpacing->m_oVal.Init(); pRPr->m_oSpacing->m_oVal->FromTwips(g_dKoef_mm_to_twips * m_oBufferedStream.GetDouble()); }break; case c_oSerProp_rPrType::SpacingTwips: { pRPr->m_oSpacing.Init(); pRPr->m_oSpacing->m_oVal.Init(); pRPr->m_oSpacing->m_oVal->FromTwips(m_oBufferedStream.GetLong()); }break; case c_oSerProp_rPrType::DStrikeout: { pRPr->m_oDStrike.Init(); pRPr->m_oDStrike->m_oVal.SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::Caps: { pRPr->m_oCaps.Init(); pRPr->m_oCaps->m_oVal.FromBool(0 != m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::SmallCaps: { pRPr->m_oSmallCaps.Init(); pRPr->m_oSmallCaps->m_oVal.FromBool(0 != m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::Position: { pRPr->m_oPosition.Init(); pRPr->m_oPosition->m_oVal.Init(); pRPr->m_oPosition->m_oVal->FromMm(m_oBufferedStream.GetDouble()); }break; case c_oSerProp_rPrType::PositionHps: { pRPr->m_oPosition.Init(); pRPr->m_oPosition->m_oVal.Init(); pRPr->m_oPosition->m_oVal->FromHps(m_oBufferedStream.GetLong()); }break; case c_oSerProp_rPrType::FontHint: { if (!pRPr->m_oRFonts.IsInit()) pRPr->m_oRFonts.Init(); pRPr->m_oRFonts->m_oHint.Init(); pRPr->m_oRFonts->m_oHint->SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::BoldCs: { pRPr->m_oBoldCs.Init(); pRPr->m_oBoldCs->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_rPrType::ItalicCs: { pRPr->m_oItalicCs.Init(); pRPr->m_oItalicCs->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_rPrType::FontSizeCs: { pRPr->m_oSzCs.Init(); pRPr->m_oSzCs->m_oVal.Init(); pRPr->m_oSzCs->m_oVal->FromHps(m_oBufferedStream.GetLong()); }break; case c_oSerProp_rPrType::Cs: { pRPr->m_oCs.Init(); pRPr->m_oCs->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_rPrType::Rtl: { pRPr->m_oRtL.Init(); pRPr->m_oRtL->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_rPrType::Lang: { if (!pRPr->m_oLang.IsInit()) pRPr->m_oLang.Init(); pRPr->m_oLang->m_oVal = m_oBufferedStream.GetString3(length); }break; case c_oSerProp_rPrType::LangBidi: { if (!pRPr->m_oLang.IsInit()) pRPr->m_oLang.Init(); pRPr->m_oLang->m_oBidi = m_oBufferedStream.GetString3(length); }break; case c_oSerProp_rPrType::LangEA: { if (!pRPr->m_oLang.IsInit()) pRPr->m_oLang.Init(); pRPr->m_oLang->m_oEastAsia = m_oBufferedStream.GetString3(length); }break; case c_oSerProp_rPrType::ColorTheme: { if (!pRPr->m_oColor.IsInit()) pRPr->m_oColor.Init(); CThemeColor ThemeColor; oBinary_CommonReader2.ReadThemeColor(length, ThemeColor); ThemeColor.ToCThemeColor(pRPr->m_oColor->m_oVal, pRPr->m_oColor->m_oThemeColor, pRPr->m_oColor->m_oThemeTint, pRPr->m_oColor->m_oThemeShade); }break; case c_oSerProp_rPrType::Vanish: { pRPr->m_oVanish.Init(); pRPr->m_oVanish->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_rPrType::TextOutline: { if (length > 0) { long nCurPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Skip(1);//skip type pRPr->m_oTextOutline.Init(); pRPr->m_oTextOutline->fromPPTY(&m_oBufferedStream); m_oBufferedStream.Seek(nCurPos + length); } }break; case c_oSerProp_rPrType::TextFill: { if (length > 0) { long nCurPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Skip(1);//skip type pRPr->m_oTextFill.fromPPTY(&m_oBufferedStream); m_oBufferedStream.Seek(nCurPos + length); } }break; case c_oSerProp_rPrType::Scene3d: { if (length > 0) { long nCurPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Skip(1);//skip type pRPr->m_oScene3d.Init(); pRPr->m_oScene3d->fromPPTY(&m_oBufferedStream); m_oBufferedStream.Seek(nCurPos + length); } }break; case c_oSerProp_rPrType::Props3d: { if (length > 0) { long nCurPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Skip(1);//skip type pRPr->m_oProps3d.Init(); pRPr->m_oProps3d->fromPPTY(&m_oBufferedStream); m_oBufferedStream.Seek(nCurPos + length); } }break; case c_oSerProp_rPrType::ShadowExt: { if (length > 0) { long nCurPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Skip(1);//skip type pRPr->m_oShadowExt.Init(); pRPr->m_oShadowExt->fromPPTY(&m_oBufferedStream); m_oBufferedStream.Seek(nCurPos + length); } }break; case c_oSerProp_rPrType::Glow: { if (length > 0) { long nCurPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Skip(1);//skip type pRPr->m_oGlow.Init(); pRPr->m_oGlow->fromPPTY(&m_oBufferedStream); m_oBufferedStream.Seek(nCurPos + length); } }break; case c_oSerProp_rPrType::Reflection: { if (length > 0) { long nCurPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Skip(1);//skip type pRPr->m_oReflection.Init(); pRPr->m_oReflection->fromPPTY(&m_oBufferedStream); m_oBufferedStream.Seek(nCurPos + length); } }break; case c_oSerProp_rPrType::CntxtAlts: { pRPr->m_oCntxtAlts.Init(); pRPr->m_oCntxtAlts->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_rPrType::NumForm: { pRPr->m_oNumForm.Init(); pRPr->m_oNumForm->m_oVal.Init(); pRPr->m_oNumForm->m_oVal->SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::NumSpacing: { pRPr->m_oNumSpacing.Init(); pRPr->m_oNumSpacing->m_oVal.Init(); pRPr->m_oNumSpacing->m_oVal->SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::Ligatures: { pRPr->m_oLigatures.Init(); pRPr->m_oLigatures->m_oVal.Init(); pRPr->m_oLigatures->m_oVal->SetValueFromByte(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_rPrType::Del: { pRPr->m_oDel.Init(); oBinary_CommonReader2.ReadTrackRevision2(length, pRPr->m_oDel.GetPointer()); }break; case c_oSerProp_rPrType::Ins: { pRPr->m_oIns.Init(); oBinary_CommonReader2.ReadTrackRevision2(length, pRPr->m_oIns.GetPointer()); }break; case c_oSerProp_rPrType::MoveFrom: { pRPr->m_oMoveFrom.Init(); oBinary_CommonReader2.ReadTrackRevision2(length, pRPr->m_oMoveFrom.GetPointer()); }break; case c_oSerProp_rPrType::MoveTo: { pRPr->m_oMoveTo.Init(); oBinary_CommonReader2.ReadTrackRevision2(length, pRPr->m_oMoveTo.GetPointer()); }break; case c_oSerProp_rPrType::rPrChange: { pRPr->m_oRPrChange.Init(); READ1_DEF(length, res, this->ReadrPrChange2, pRPr->m_oRPrChange.GetPointer()); }break; case c_oSerProp_rPrType::CompressText: { pRPr->m_oW.Init(); pRPr->m_oW->m_oVal.Init(); pRPr->m_oW->m_oVal->SetValue(m_oBufferedStream.GetLong()); }break; case c_oSerProp_rPrType::SnapToGrid: { pRPr->m_oSnapToGrid.Init(); pRPr->m_oSnapToGrid->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_rPrType::Kern: { pRPr->m_oKern.Init(); pRPr->m_oKern->m_oVal.Init(); pRPr->m_oKern->m_oVal->FromHps(m_oBufferedStream.GetLong()); }break; default: res = c_oSerConstants::ReadUnknown; break; } return res; } int Binary_rPrReader::ReadrPrChange2(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CRPrChange* pRPrChange = static_cast(poResult); READ1_TRACKREV_2(type, length, pRPrChange) else if (c_oSerProp_RevisionType::rPrChange == type) { pRPrChange->m_pRunPr.Init(); pRPrChange->m_pRunPr->m_bRPRChange = true; res = Read(length, pRPrChange->m_pRunPr.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; }; Binary_pPrReader::Binary_pPrReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter) : m_oFontTableWriter(oFileWriter.get_font_table_writer()), Binary_CommonReader(poBufferedStream), oBinary_CommonReader2(poBufferedStream), oBinary_rPrReader(poBufferedStream, oFileWriter), oBinary_HdrFtrTableReader(poBufferedStream, oFileWriter), m_oFileWriter(oFileWriter) { bDoNotWriteNullProp = false; m_nCurNumId = -1; m_nCurLvl = -1; } int Binary_pPrReader::Read(long stLen, void* poResult) { int res = c_oSerConstants::ReadOk; READ2_DEF(stLen, res, this->ReadContent, poResult); return res; }; int Binary_pPrReader::ReadContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CParagraphProperty* pPPr = static_cast(poResult); switch (type) { case c_oSerProp_pPrType::ContextualSpacing: { pPPr->m_oContextualSpacing.Init(); pPPr->m_oContextualSpacing->m_oVal.FromBool(m_oBufferedStream.GetUChar()); }break; case c_oSerProp_pPrType::Ind: { pPPr->m_oInd.Init(); NSStringUtils::CStringBuilder oTempWriter; READ2_DEF(length, res, this->ReadInd, pPPr->m_oInd.GetPointer()); }break; case c_oSerProp_pPrType::Jc: { BYTE jc = m_oBufferedStream.GetUChar(); pPPr->m_oJc.Init(); pPPr->m_oJc->m_oVal.Init(); switch (jc) { case align_Right: pPPr->m_oJc->m_oVal->SetValueFromByte(3); break; case align_Left: pPPr->m_oJc->m_oVal->SetValueFromByte(8); break; case align_Center: pPPr->m_oJc->m_oVal->SetValueFromByte(1); break; case align_Justify: pPPr->m_oJc->m_oVal->SetValueFromByte(0); break; } }break; case c_oSerProp_pPrType::KeepLines: { pPPr->m_oKeepLines.Init(); pPPr->m_oKeepLines->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_pPrType::KeepNext: { pPPr->m_oKeepNext.Init(); pPPr->m_oKeepNext->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_pPrType::PageBreakBefore: { pPPr->m_oPageBreakBefore.Init(); pPPr->m_oPageBreakBefore->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_pPrType::Spacing: { pPPr->m_oSpacing.Init(); READ2_DEF(length, res, this->ReadSpacing, pPPr->m_oSpacing.GetPointer()); }break; case c_oSerProp_pPrType::Shd: { pPPr->m_oShd.Init(); READ2_DEF(length, res, oBinary_CommonReader2.ReadShdComplexType, pPPr->m_oShd.GetPointer()); }break; case c_oSerProp_pPrType::WidowControl: { pPPr->m_oWidowControl.Init(); pPPr->m_oWidowControl->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_pPrType::Tab: { pPPr->m_oTabs.Init(); READ2_DEF(length, res, this->ReadTabs, pPPr->m_oTabs.GetPointer()); }break; case c_oSerProp_pPrType::ParaStyle: { pPPr->m_oPStyle.Init(); pPPr->m_oPStyle->m_sVal = m_oBufferedStream.GetString3(length); }break; case c_oSerProp_pPrType::numPr: { pPPr->m_oNumPr.Init(); READ2_DEF(length, res, this->ReadNumPr, pPPr->m_oNumPr.GetPointer()); }break; case c_oSerProp_pPrType::pPr_rPr: { pPPr->m_oRPr.Init(); res = oBinary_rPrReader.Read(length, pPPr->m_oRPr.GetPointer()); }break; case c_oSerProp_pPrType::pBdr: { pPPr->m_oPBdr.Init(); READ1_DEF(length, res, this->ReadBorders, pPPr->m_oPBdr.GetPointer()); }break; case c_oSerProp_pPrType::FramePr: { pPPr->m_oFramePr.Init(); READ2_DEF(length, res, this->ReadFramePr, pPPr->m_oFramePr.GetPointer()); }break; case c_oSerProp_pPrType::pPrChange: { pPPr->m_oPPrChange.Init(); READ1_DEF(length, res, this->ReadPPrChange, pPPr->m_oPPrChange.GetPointer()); }break; case c_oSerProp_pPrType::SectPr: { pPPr->m_oSectPr.Init(); READ1_DEF(length, res, this->Read_SecPr, pPPr->m_oSectPr.GetPointer()); }break; case c_oSerProp_pPrType::outlineLvl: { pPPr->m_oOutlineLvl.Init(); pPPr->m_oOutlineLvl->m_oVal = m_oBufferedStream.GetLong(); }break; case c_oSerProp_pPrType::SuppressLineNumbers: { pPPr->m_oSuppressLineNumbers.Init(); pPPr->m_oSuppressLineNumbers->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_pPrType::CnfStyle: { pPPr->m_oCnfStyle.Init(); READ1_DEF(length, res, this->ReadCnfStyle, pPPr->m_oCnfStyle.GetPointer()); }break; case c_oSerProp_pPrType::SnapToGrid: { pPPr->m_oSnapToGrid.Init(); pPPr->m_oSnapToGrid->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; case c_oSerProp_pPrType::Bidi: { pPPr->m_oBidi.Init(); pPPr->m_oBidi->m_oVal.FromBool(m_oBufferedStream.GetBool()); }break; default: res = c_oSerConstants::ReadUnknown; break; } return res; }; int Binary_pPrReader::ReadPPrChange(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CPPrChange* pPPrChange = static_cast(poResult); if (c_oSerProp_RevisionType::Author == type)\ {\ pPPrChange->m_sAuthor = m_oBufferedStream.GetString3(length); \ }\ else if (c_oSerProp_RevisionType::Date == type)\ {\ pPPrChange->m_oDate = m_oBufferedStream.GetString3(length); \ }\ else if (c_oSerProp_RevisionType::Id == type)\ {\ pPPrChange->m_oId.Init();\ pPPrChange->m_oId->SetValue(m_oBufferedStream.GetLong()); }\ else if (c_oSerProp_RevisionType::UserId == type)\ {\ pPPrChange->m_sUserId = m_oBufferedStream.GetString3(length); \ } //READ1_TRACKREV(type, length, pPPrChange) else if (c_oSerProp_RevisionType::pPrChange == type) { pPPrChange->m_pParPr.Init(); res = Read(length, pPPrChange->m_pParPr.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadInd(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CInd *pInd = static_cast(poResult); switch(type) { case c_oSerProp_pPrType::Ind_Left: { pInd->m_oStart.Init(); pInd->m_oStart->FromMm(m_oBufferedStream.GetDouble()); }break; case c_oSerProp_pPrType::Ind_LeftTwips: { pInd->m_oStart.Init(); pInd->m_oStart->FromTwips(m_oBufferedStream.GetLong()); }break; case c_oSerProp_pPrType::Ind_Right: { pInd->m_oEnd.Init(); pInd->m_oEnd->FromMm(m_oBufferedStream.GetDouble()); }break; case c_oSerProp_pPrType::Ind_RightTwips: { pInd->m_oEnd.Init(); pInd->m_oEnd->FromTwips(m_oBufferedStream.GetLong()); }break; case c_oSerProp_pPrType::Ind_FirstLine: { double dIndFirstLine = m_oBufferedStream.GetDouble(); std::wstring sIndFirstLine; if (dIndFirstLine >= 0) { pInd->m_oFirstLine.Init(); pInd->m_oFirstLine->FromMm(dIndFirstLine); } else { pInd->m_oHanging.Init(); pInd->m_oHanging->FromMm(-dIndFirstLine); } }break; case c_oSerProp_pPrType::Ind_FirstLineTwips: { double dIndFirstLine = m_oBufferedStream.GetLong(); std::wstring sIndFirstLine; if (dIndFirstLine >= 0) { pInd->m_oFirstLine.Init(); pInd->m_oFirstLine->FromTwips(dIndFirstLine); } else { pInd->m_oHanging.Init(); pInd->m_oHanging->FromTwips(-dIndFirstLine); } }break; default: res = c_oSerConstants::ReadUnknown; break; } return res; } int Binary_pPrReader::ReadSpacing(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CSpacing* pSpacing = static_cast(poResult); switch(type) { case c_oSerProp_pPrType::Spacing_Line: pSpacing->m_oLine.Init(); pSpacing->m_oLine->FromMm(m_oBufferedStream.GetDouble()); break; case c_oSerProp_pPrType::Spacing_LineTwips: pSpacing->m_oLine.Init(); pSpacing->m_oLine->FromTwips(m_oBufferedStream.GetLong()); break; case c_oSerProp_pPrType::Spacing_LineRule: pSpacing->m_oLineRule.Init(); pSpacing->m_oLineRule->SetValueFromByte(m_oBufferedStream.GetUChar()); break; case c_oSerProp_pPrType::Spacing_Before: pSpacing->m_oBefore.Init(); pSpacing->m_oBefore->FromMm(m_oBufferedStream.GetDouble()); break; case c_oSerProp_pPrType::Spacing_BeforeTwips: pSpacing->m_oBefore.Init(); pSpacing->m_oBefore->FromTwips(m_oBufferedStream.GetLong()); break; case c_oSerProp_pPrType::Spacing_After: pSpacing->m_oAfter.Init(); pSpacing->m_oAfter->FromMm(m_oBufferedStream.GetDouble()); break; case c_oSerProp_pPrType::Spacing_AfterTwips: pSpacing->m_oAfter.Init(); pSpacing->m_oAfter->FromTwips(m_oBufferedStream.GetLong()); break; case c_oSerProp_pPrType::Spacing_BeforeAuto: pSpacing->m_oBeforeAutospacing.Init(); pSpacing->m_oBeforeAutospacing->FromBool(m_oBufferedStream.GetBool()); break; case c_oSerProp_pPrType::Spacing_AfterAuto: pSpacing->m_oAfterAutospacing.Init(); pSpacing->m_oAfterAutospacing->FromBool(m_oBufferedStream.GetBool()); break; case c_oSerProp_pPrType::Spacing_AfterLines: { pSpacing->m_oAfterLines.Init(); pSpacing->m_oAfterLines->SetValue(m_oBufferedStream.GetLong()); }break; case c_oSerProp_pPrType::Spacing_BeforeLines: { pSpacing->m_oBeforeLines.Init(); pSpacing->m_oBeforeLines->SetValue(m_oBufferedStream.GetLong()); }break; default: res = c_oSerConstants::ReadUnknown; break; } return res; } int Binary_pPrReader::ReadTabs(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CTabs* poTabs = static_cast(poResult); if (c_oSerProp_pPrType::Tab_Item == type) { ComplexTypes::Word::CTabStop* pTabItem = new ComplexTypes::Word::CTabStop(); READ2_DEF(length, res, this->ReadTabItem, pTabItem); poTabs->m_arrTabs.push_back(pTabItem); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_pPrReader::ReadTabItem(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CTabStop* poTabItem = static_cast(poResult); if (c_oSerProp_pPrType::Tab_Item_Val == type) { poTabItem->m_oVal.Init(); poTabItem->m_oVal->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oSerProp_pPrType::Tab_Item_Pos == type) { poTabItem->m_oPos.Init(); poTabItem->m_oPos->FromMm(m_oBufferedStream.GetDouble()); } else if (c_oSerProp_pPrType::Tab_Item_PosTwips == type) { poTabItem->m_oPos.Init(); poTabItem->m_oPos->FromTwips(m_oBufferedStream.GetLong()); } else if (c_oSerProp_pPrType::Tab_Item_Leader == type) { poTabItem->m_oLeader.Init(); poTabItem->m_oLeader->SetValueFromByte( m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadNumPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CNumPr* pNumPr = static_cast(poResult); if (c_oSerProp_pPrType::numPr_lvl == type) { pNumPr->m_oIlvl.Init(); pNumPr->m_oIlvl->m_oVal = m_oBufferedStream.GetLong(); } else if (c_oSerProp_pPrType::numPr_id == type) { pNumPr->m_oNumID.Init(); pNumPr->m_oNumID->m_oVal = m_oBufferedStream.GetLong(); } else if (c_oSerProp_pPrType::numPr_Ins == type) { pNumPr->m_oIns.Init(); oBinary_CommonReader2.ReadTrackRevision2(length, pNumPr->m_oIns.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_pPrReader::ReadTableCellBorders(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CTcBorders* pBorders = static_cast(poResult); READ1_BORDERS_START2 else if (c_oSerBordersType::tl2br == type) { pBorders->m_oTL2BR.Init(); READ2_DEF(length, res, this->ReadBorder, pBorders->m_oTL2BR.GetPointer()); } else if (c_oSerBordersType::tr2bl == type) { pBorders->m_oTR2BL.Init(); READ2_DEF(length, res, this->ReadBorder, pBorders->m_oTR2BL.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadTableBorders(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CTblBorders* pBorders = static_cast(poResult); READ1_BORDERS_START2 else if (c_oSerBordersType::insideV == type) { pBorders->m_oInsideV.Init(); READ2_DEF(length, res, this->ReadBorder, pBorders->m_oInsideV.GetPointer()); } else if (c_oSerBordersType::insideH == type) { pBorders->m_oInsideH.Init(); READ2_DEF(length, res, this->ReadBorder, pBorders->m_oInsideH.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadBorders(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CPBdr *pBorders = static_cast(poResult); READ1_BORDERS_START1 else if ( c_oSerBordersType::between == type ) { pBorders->m_oBetween.Init(); READ2_DEF(length, res, this->ReadBorder, pBorders->m_oBetween.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadBorder(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CBorder* pBorder = static_cast(poResult); if ( c_oSerBorderType::Color == type ) { pBorder->m_oColor.Init(); pBorder->m_oColor->SetValue(SimpleTypes::hexcolorRGB); oBinary_CommonReader2.ReadHexColor(pBorder->m_oColor.GetPointer(), length); } else if ( c_oSerBorderType::Space == type ) { pBorder->m_oSpace.Init(); pBorder->m_oSpace->SetValue(SerializeCommon::Round(g_dKoef_mm_to_pt * m_oBufferedStream.GetDouble())); } else if ( c_oSerBorderType::SpacePoint == type ) { pBorder->m_oSpace.Init(); pBorder->m_oSpace->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerBorderType::Size == type ) { pBorder->m_oSz.Init(); pBorder->m_oSz->SetValue(SerializeCommon::Round(g_dKoef_mm_to_eightpoint * m_oBufferedStream.GetDouble())); } else if ( c_oSerBorderType::Size8Point == type ) { pBorder->m_oSz.Init(); pBorder->m_oSz->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerBorderType::Value == type ) { pBorder->m_oVal.Init(); if (0 != m_oBufferedStream.GetUChar()) pBorder->m_oVal->SetValue(SimpleTypes::bordervalueSingle); else pBorder->m_oVal->SetValue(SimpleTypes::bordervalueNone); } else if (c_oSerBorderType::ValueType == type) { pBorder->m_oVal.Init(); pBorder->m_oVal->SetValue((SimpleTypes::EBorder)m_oBufferedStream.GetLong()); } else if ( c_oSerBorderType::ColorTheme == type ) { CThemeColor ThemeColor; oBinary_CommonReader2.ReadThemeColor(length, ThemeColor); ThemeColor.ToCThemeColor(pBorder->m_oColor, pBorder->m_oThemeColor, pBorder->m_oThemeTint, pBorder->m_oThemeShade); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadFramePr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CFramePr* pFramePr = static_cast(poResult); if ( c_oSer_FramePrType::DropCap == type ) { pFramePr->m_oDropCap.Init(); pFramePr->m_oDropCap->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if ( c_oSer_FramePrType::H == type ) { pFramePr->m_oH.Init(); pFramePr->m_oH->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_FramePrType::HAnchor == type ) { pFramePr->m_oHAnchor.Init(); pFramePr->m_oHAnchor->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if ( c_oSer_FramePrType::HRule == type ) { pFramePr->m_oHRule.Init(); pFramePr->m_oHRule->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if ( c_oSer_FramePrType::HSpace == type ) { pFramePr->m_oHSpace.Init(); pFramePr->m_oHSpace->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_FramePrType::Lines == type ) { pFramePr->m_oLines.Init(); pFramePr->m_oLines->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSer_FramePrType::VAnchor == type ) { pFramePr->m_oVAnchor.Init(); pFramePr->m_oVAnchor->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if ( c_oSer_FramePrType::VSpace == type ) { pFramePr->m_oVSpace.Init(); pFramePr->m_oVSpace->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_FramePrType::W == type ) { pFramePr->m_oW.Init(); pFramePr->m_oW->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_FramePrType::Wrap == type ) { pFramePr->m_oWrap.Init(); pFramePr->m_oWrap->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if ( c_oSer_FramePrType::X == type ) { pFramePr->m_oX.Init(); pFramePr->m_oX->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_FramePrType::XAlign == type ) { pFramePr->m_oXAlign.Init(); pFramePr->m_oXAlign->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if ( c_oSer_FramePrType::Y == type ) { pFramePr->m_oY.Init(); pFramePr->m_oY->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_FramePrType::YAlign == type ) { pFramePr->m_oYAlign.Init(); pFramePr->m_oYAlign->SetValueFromByte(m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::Read_pgSetting(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CSectionProperty* pSectPr = static_cast(poResult); if (c_oSerProp_secPrSettingsType::titlePg == type) { pSectPr->m_oTitlePg.Init(); pSectPr->m_oTitlePg->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerProp_secPrSettingsType::EvenAndOddHeaders == type) { if (m_oBufferedStream.GetBool()) { m_oFileWriter.m_pCurrentSettings->m_oEvenAndOddHeaders.Init(); } } else if (c_oSerProp_secPrSettingsType::SectionType == type) { pSectPr->m_oType.Init(); pSectPr->m_oType->m_oVal.Init(); pSectPr->m_oType->m_oVal->SetValueFromByte(m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::Read_SecPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CSectionProperty* pSectPr = static_cast(poResult); if ( c_oSerProp_secPrType::pgSz == type ) { pSectPr->m_oPgSz.Init(); READ2_DEF(length, res, this->Read_pgSz, pSectPr->m_oPgSz.GetPointer()); } else if ( c_oSerProp_secPrType::pgMar == type ) { pSectPr->m_oPgMar.Init(); READ2_DEF(length, res, this->Read_pgMar, pSectPr->m_oPgMar.GetPointer()); } else if (c_oSerProp_secPrType::setting == type) { READ2_DEF(length, res, this->Read_pgSetting, poResult); } else if ( c_oSerProp_secPrType::headers == type ) { READ1_DEF(length, res, this->Read_pgHeader, poResult); } else if ( c_oSerProp_secPrType::footers == type ) { READ1_DEF(length, res, this->Read_pgFooter, poResult); } else if ( c_oSerProp_secPrType::pageNumType == type ) { pSectPr->m_oPgNumType.Init(); READ1_DEF(length, res, this->Read_pageNumType, pSectPr->m_oPgNumType.GetPointer()); } else if ( c_oSerProp_secPrType::lnNumType == type ) { pSectPr->m_oLnNumType.Init(); READ1_DEF(length, res, this->Read_lineNumType, pSectPr->m_oLnNumType.GetPointer()); } else if ( c_oSerProp_secPrType::sectPrChange == type ) { pSectPr->m_oSectPrChange.Init(); READ1_DEF(length, res, this->ReadSectPrChange, pSectPr->m_oSectPrChange.GetPointer()); } else if ( c_oSerProp_secPrType::cols == type ) { pSectPr->m_oCols.Init(); READ1_DEF(length, res, this->ReadCols, pSectPr->m_oCols.GetPointer()); } else if ( c_oSerProp_secPrType::pgBorders == type ) { pSectPr->m_oPgBorders.Init(); READ1_DEF(length, res, this->ReadPageBorders, pSectPr->m_oPgBorders.GetPointer()); } else if ( c_oSerProp_secPrType::footnotePr == type ) { pSectPr->m_oFootnotePr.Init(); READ1_DEF(length, res, this->ReadFootnotePr, pSectPr->m_oFootnotePr.GetPointer()); } else if ( c_oSerProp_secPrType::endnotePr == type ) { pSectPr->m_oEndnotePr.Init(); READ1_DEF(length, res, this->ReadEndnotePr, pSectPr->m_oEndnotePr.GetPointer()); } else if ( c_oSerProp_secPrType::rtlGutter == type ) { pSectPr->m_oRtlGutter.Init(); pSectPr->m_oRtlGutter->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerProp_secPrType::docGrid == type) { pSectPr->m_oDocGrid.Init(); READ1_DEF(length, res, this->ReadDocGrid, pSectPr->m_oDocGrid.GetPointer()); } else if (c_oSerProp_secPrType::bidi == type) { pSectPr->m_oBidi.Init(); pSectPr->m_oBidi->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadFootnotePr(BYTE type, long length, void* poResult) { OOX::Logic::CFtnProps* pFtnProps = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerNotes::PrFmt == type ) { pFtnProps->m_oNumFmt.Init(); READ1_DEF(length, res, this->ReadNumFmt, pFtnProps->m_oNumFmt.GetPointer()); } else if ( c_oSerNotes::PrRestart == type ) { pFtnProps->m_oNumRestart.Init(); pFtnProps->m_oNumRestart->m_oVal.Init(); pFtnProps->m_oNumRestart->m_oVal->SetValue((SimpleTypes::ERestartNumber)m_oBufferedStream.GetUChar()); } else if ( c_oSerNotes::PrStart == type ) { pFtnProps->m_oNumStart.Init(); pFtnProps->m_oNumStart->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSerNotes::PrFntPos == type ) { pFtnProps->m_oPos.Init(); pFtnProps->m_oPos->m_oVal.Init(); pFtnProps->m_oPos->m_oVal->SetValue((SimpleTypes::EFtnPos)m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadDocGrid(BYTE type, long length, void* poResult) { ComplexTypes::Word::CDocGrid* pDocGrid = static_cast(poResult); int res = c_oSerConstants::ReadOk; if (c_oSerProp_DocGrid::Type == type) { pDocGrid->m_oType.Init(); pDocGrid->m_oType->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oSerProp_DocGrid::CharSpace == type) { pDocGrid->m_oCharSpace.Init(); pDocGrid->m_oCharSpace->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerProp_DocGrid::LinePitch == type) { pDocGrid->m_oLinePitch.Init(); pDocGrid->m_oLinePitch->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadEndnotePr(BYTE type, long length, void* poResult) { OOX::Logic::CEdnProps* pEdnProps = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerNotes::PrFmt == type ) { pEdnProps->m_oNumFmt.Init(); READ1_DEF(length, res, this->ReadNumFmt, pEdnProps->m_oNumFmt.GetPointer()); } else if ( c_oSerNotes::PrRestart == type ) { pEdnProps->m_oNumRestart.Init(); pEdnProps->m_oNumRestart->m_oVal.Init(); pEdnProps->m_oNumRestart->m_oVal->SetValue((SimpleTypes::ERestartNumber)m_oBufferedStream.GetUChar()); } else if ( c_oSerNotes::PrStart == type ) { pEdnProps->m_oNumStart.Init(); pEdnProps->m_oNumStart->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSerNotes::PrEndPos == type ) { pEdnProps->m_oPos.Init(); pEdnProps->m_oPos->m_oVal.Init(); pEdnProps->m_oPos->m_oVal->SetValue((SimpleTypes::EEdnPos)m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadNumFmt(BYTE type, long length, void* poResult) { ComplexTypes::Word::CNumFmt* pNumFmt = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerNumTypes::NumFmtVal == type ) { pNumFmt->m_oVal.Init(); pNumFmt->m_oVal->SetValue((SimpleTypes::ENumberFormat)m_oBufferedStream.GetUChar()); } else if ( c_oSerNumTypes::NumFmtFormat == type ) { pNumFmt->m_sFormat.Init(); pNumFmt->m_sFormat->append(m_oBufferedStream.GetString3(length)); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadSectPrChange(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CSectPrChange* pSectPr = static_cast(poResult); READ1_TRACKREV_2(type, length, pSectPr) else if ( c_oSerProp_RevisionType::sectPrChange == type ) { pSectPr->m_pSecPr.Init(); READ1_DEF(length, res, this->Read_SecPr, pSectPr->m_pSecPr.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadCnfStyle(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CCnf* pCnf = static_cast(poResult); if (c_oSerCnf::Val == type) { pCnf->m_oVal.Init(); pCnf->m_oVal->SetValue(m_oBufferedStream.GetUShort()); } else if (c_oSerCnf::EvenHBand == type) { pCnf->m_oEvenHBand.Init(); pCnf->m_oEvenHBand->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerCnf::EvenVBand == type) { pCnf->m_oEvenVBand.Init(); pCnf->m_oEvenVBand->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerCnf::FirstColumn == type) { pCnf->m_oFirstColumn.Init(); pCnf->m_oFirstColumn->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerCnf::FirstRow == type) { pCnf->m_oFirstRow.Init(); pCnf->m_oFirstRow->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerCnf::FirstRowFirstColumn == type) { pCnf->m_oFirstRowFirstColumn.Init(); pCnf->m_oFirstRowFirstColumn->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerCnf::FirstRowLastColumn == type) { pCnf->m_oFirstRowLastColumn.Init(); pCnf->m_oFirstRowLastColumn->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerCnf::LastColumn == type) { pCnf->m_oLastColumn.Init(); pCnf->m_oLastColumn->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerCnf::LastRow == type) { pCnf->m_oLastRow.Init(); pCnf->m_oLastRow->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerCnf::LastRowFirstColumn == type) { pCnf->m_oLastRowFirstColumn.Init(); pCnf->m_oLastRowFirstColumn->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerCnf::LastRowLastColumn == type) { pCnf->m_oLastRowLastColumn.Init(); pCnf->m_oLastRowLastColumn->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerCnf::OddHBand == type) { pCnf->m_oOddHBand.Init(); pCnf->m_oOddHBand->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerCnf::OddVBand == type) { pCnf->m_oOddVBand.Init(); pCnf->m_oOddVBand->FromBool(m_oBufferedStream.GetBool()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::Read_pgSz(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CPageSz* pPageSz = static_cast(poResult); if ( c_oSer_pgSzType::Orientation == type ) { pPageSz->m_oOrient.Init(); pPageSz->m_oOrient->SetValueFromByte( m_oBufferedStream.GetUChar() == 1 ? 0 : 1); } else if ( c_oSer_pgSzType::W == type ) { pPageSz->m_oW.Init(); pPageSz->m_oW->FromMm(m_oBufferedStream.GetDouble()); } else if ( c_oSer_pgSzType::WTwips == type ) { pPageSz->m_oW.Init(); pPageSz->m_oW->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_pgSzType::H == type ) { pPageSz->m_oH.Init(); pPageSz->m_oH->FromMm(m_oBufferedStream.GetDouble()); } else if ( c_oSer_pgSzType::HTwips == type ) { pPageSz->m_oH.Init(); pPageSz->m_oH->FromTwips(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::Read_pgMar(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CPageMar* pPageMar = static_cast(poResult); if ( c_oSer_pgMarType::Left == type ) { pPageMar->m_oLeft.Init(); pPageMar->m_oLeft->FromMm(m_oBufferedStream.GetDouble()); } else if ( c_oSer_pgMarType::LeftTwips == type ) { pPageMar->m_oLeft.Init(); pPageMar->m_oLeft->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_pgMarType::Top == type ) { pPageMar->m_oTop.Init(); pPageMar->m_oTop->FromMm(m_oBufferedStream.GetDouble()); } else if ( c_oSer_pgMarType::TopTwips == type ) { pPageMar->m_oTop.Init(); pPageMar->m_oTop->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_pgMarType::Right == type ) { pPageMar->m_oRight.Init(); pPageMar->m_oRight->FromMm(m_oBufferedStream.GetDouble()); } else if ( c_oSer_pgMarType::RightTwips == type ) { pPageMar->m_oRight.Init(); pPageMar->m_oRight->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_pgMarType::Bottom == type ) { pPageMar->m_oBottom.Init(); pPageMar->m_oBottom->FromMm(m_oBufferedStream.GetDouble()); } else if ( c_oSer_pgMarType::BottomTwips == type ) { pPageMar->m_oBottom.Init(); pPageMar->m_oBottom->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_pgMarType::Header == type ) { pPageMar->m_oHeader.Init(); pPageMar->m_oHeader->FromMm(m_oBufferedStream.GetDouble()); } else if ( c_oSer_pgMarType::HeaderTwips == type ) { pPageMar->m_oHeader.Init(); pPageMar->m_oHeader->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_pgMarType::Footer == type ) { pPageMar->m_oFooter.Init(); pPageMar->m_oFooter->FromMm(m_oBufferedStream.GetDouble()); } else if ( c_oSer_pgMarType::FooterTwips == type ) { pPageMar->m_oFooter.Init(); pPageMar->m_oFooter->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSer_pgMarType::GutterTwips == type ) { pPageMar->m_oGutter.Init(); pPageMar->m_oGutter->FromTwips(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::Read_pgHeader(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CSectionProperty* pSectPr = static_cast(poResult); if ( c_oSerProp_secPrType::hdrftrelem == type ) { int nHdrFtrIndex = m_oBufferedStream.GetLong(); if (nHdrFtrIndex >= 0 && nHdrFtrIndex < (int)m_oFileWriter.get_headers_footers_writer().m_aHeaders.size()) { Writers::HdrFtrItem* pHdrFtrItem = m_oFileWriter.get_headers_footers_writer().m_aHeaders[nHdrFtrIndex]; nullable pRef; pRef.Init(); pRef->m_oType.Init(); pRef->m_oType->SetValueFromByte(pHdrFtrItem->eType); pRef->m_oId.Init(); pRef->m_oId->SetValue(pHdrFtrItem->rId); pSectPr->m_arrHeaderReference.push_back(pRef); } } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::Read_pgFooter(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CSectionProperty* pSectPr = static_cast(poResult); if ( c_oSerProp_secPrType::hdrftrelem == type ) { int nHdrFtrIndex = m_oBufferedStream.GetLong(); if (nHdrFtrIndex >= 0 && nHdrFtrIndex <= (int)oBinary_HdrFtrTableReader.m_oHeaderFooterWriter.m_aFooters.size()) { Writers::HdrFtrItem* pHdrFtrItem = oBinary_HdrFtrTableReader.m_oHeaderFooterWriter.m_aFooters[nHdrFtrIndex]; nullable pRef; pRef.Init(); pRef->m_oType.Init(); pRef->m_oType->SetValueFromByte(pHdrFtrItem->eType); pRef->m_oId.Init(); pRef->m_oId->SetValue(pHdrFtrItem->rId); pSectPr->m_arrFooterReference.push_back(pRef); } } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::Read_pageNumType(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CPageNumber* pCPageNumber = static_cast(poResult); if ( c_oSerProp_secPrPageNumType::start == type ) { pCPageNumber->m_oStart.Init(); pCPageNumber->m_oStart->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerProp_secPrPageNumType::fmt == type) { pCPageNumber->m_oFmt.Init(); pCPageNumber->m_oFmt->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oSerProp_secPrPageNumType::chapStyle == type) { pCPageNumber->m_oChapStyle.Init(); pCPageNumber->m_oChapStyle->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerProp_secPrPageNumType::chapSep == type) { pCPageNumber->m_oChapSep.Init(); pCPageNumber->m_oChapSep->SetValueFromByte(m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::Read_lineNumType(BYTE type, long length, void* poResult) { ComplexTypes::Word::CLineNumber* pLineNumber = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerProp_secPrLineNumType::CountBy == type ) { pLineNumber->m_oCountBy.Init(); pLineNumber->m_oCountBy->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerProp_secPrLineNumType::Distance == type ) { pLineNumber->m_oDistance.Init(); pLineNumber->m_oDistance->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSerProp_secPrLineNumType::Restart == type ) { pLineNumber->m_oRestart.Init(); pLineNumber->m_oRestart->SetValue((SimpleTypes::ELineNumberRestart)m_oBufferedStream.GetUChar()); } else if ( c_oSerProp_secPrLineNumType::Start == type ) { pLineNumber->m_oStart.Init(); pLineNumber->m_oStart->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadCols(BYTE type, long length, void* poResult) { OOX::Logic::CColumns* pCols = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerProp_Columns::EqualWidth == type ) { pCols->m_oEqualWidth.Init(); pCols->m_oEqualWidth->FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSerProp_Columns::Num == type ) { pCols->m_oNum.Init(); pCols->m_oNum->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerProp_Columns::Sep == type ) { pCols->m_oSep.Init(); pCols->m_oSep->FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSerProp_Columns::Space == type ) { pCols->m_oSpace.Init(); pCols->m_oSpace->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSerProp_Columns::Column == type ) { nullable pCol; pCol.Init(); READ1_DEF(length, res, this->ReadCol, pCol.GetPointer()); pCols->m_arrColumns.push_back(pCol); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadCol(BYTE type, long length, void* poResult) { ComplexTypes::Word::CColumn* pCol = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerProp_Columns::ColumnSpace == type ) { pCol->m_oSpace.Init(); pCol->m_oSpace->FromTwips(m_oBufferedStream.GetLong()); } else if ( c_oSerProp_Columns::ColumnW == type ) { pCol->m_oW.Init(); pCol->m_oW->FromTwips(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadPageBorders(BYTE type, long length, void* poResult) { OOX::Logic::CPageBorders* pPageBorders = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerPageBorders::Display == type ) { pPageBorders->m_oDisplay.Init(); pPageBorders->m_oDisplay->SetValueFromByte(m_oBufferedStream.GetChar()); } else if ( c_oSerPageBorders::OffsetFrom == type ) { pPageBorders->m_oOffsetFrom.Init(); pPageBorders->m_oOffsetFrom->SetValueFromByte(m_oBufferedStream.GetChar()); } else if ( c_oSerPageBorders::ZOrder == type ) { pPageBorders->m_oZOrder.Init(); pPageBorders->m_oZOrder->SetValueFromByte(m_oBufferedStream.GetChar()); } else if ( c_oSerPageBorders::Bottom == type ) { pPageBorders->m_oBottom.Init(); READ2_DEF(length, res, this->ReadPageBorder, pPageBorders->m_oBottom.GetPointer()); } else if ( c_oSerPageBorders::Left == type ) { pPageBorders->m_oLeft.Init(); READ2_DEF(length, res, this->ReadPageBorder, pPageBorders->m_oLeft.GetPointer()); } else if ( c_oSerPageBorders::Right == type ) { pPageBorders->m_oRight.Init(); READ2_DEF(length, res, this->ReadPageBorder, pPageBorders->m_oRight.GetPointer()); } else if ( c_oSerPageBorders::Top == type ) { pPageBorders->m_oTop.Init(); READ2_DEF(length, res, this->ReadPageBorder, pPageBorders->m_oTop.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_pPrReader::ReadPageBorder(BYTE type, long length, void* poResult) { ComplexTypes::Word::CPageBorder* pPageBorder = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerPageBorders::Color == type ) { docRGB color = oBinary_CommonReader2.ReadColor(); pPageBorder->m_oColor.Init(); pPageBorder->m_oColor->SetValue(SimpleTypes::hexcolorRGB); pPageBorder->m_oColor->Set_R(color.R); pPageBorder->m_oColor->Set_G(color.G); pPageBorder->m_oColor->Set_B(color.B); } else if ( c_oSerPageBorders::ColorTheme == type ) { CThemeColor themeColor; oBinary_CommonReader2.ReadThemeColor(length, themeColor); if (themeColor.Auto) { pPageBorder->m_oColor.Init(); pPageBorder->m_oColor->SetValue(SimpleTypes::hexcolorAuto); } if (themeColor.bColor) { pPageBorder->m_oThemeColor.Init(); pPageBorder->m_oThemeColor->SetValue((SimpleTypes::EThemeColor)themeColor.Color); } if (themeColor.bShade) { pPageBorder->m_oThemeShade.Init(); pPageBorder->m_oThemeShade->SetValue(themeColor.Shade); } if (themeColor.bTint) { pPageBorder->m_oThemeTint.Init(); pPageBorder->m_oThemeTint->SetValue(themeColor.Tint); } } else if ( c_oSerPageBorders::Space == type ) { pPageBorder->m_oSpace.Init(); pPageBorder->m_oSpace->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerPageBorders::Sz == type ) { pPageBorder->m_oSz.Init(); pPageBorder->m_oSz->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerPageBorders::Val == type ) { pPageBorder->m_oVal.Init(); pPageBorder->m_oVal->SetValue((SimpleTypes::EBorder)m_oBufferedStream.GetLong()); } else if ( c_oSerPageBorders::Frame == type ) { pPageBorder->m_oFrame.Init(); pPageBorder->m_oFrame->FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSerPageBorders::Shadow == type ) { pPageBorder->m_oShadow.Init(); pPageBorder->m_oShadow->FromBool(m_oBufferedStream.GetBool()); } else res = c_oSerConstants::ReadUnknown; return res; } Binary_tblPrReader::Binary_tblPrReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter):Binary_CommonReader(poBufferedStream),oBinary_CommonReader2(poBufferedStream),oBinary_pPrReader(poBufferedStream, oFileWriter) { } int Binary_tblPrReader::Read_tblPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CWiterTblPr* pWiterTblPr = static_cast(poResult); if ( c_oSerProp_tblPrType::RowBandSize == type ) { long nRowBandSize = m_oBufferedStream.GetLong(); pWiterTblPr->Props += L""; } else if ( c_oSerProp_tblPrType::ColBandSize == type ) { long nColBandSize = m_oBufferedStream.GetLong(); pWiterTblPr->Props += L""; } else if ( c_oSerProp_tblPrType::Jc == type ) { BYTE jc = m_oBufferedStream.GetUChar(); switch(jc) { case align_Right: pWiterTblPr->Props += L""; break; case align_Center: pWiterTblPr->Props += L""; break; case align_Justify: pWiterTblPr->Props += L""; break; case align_Left: break; } } else if ( c_oSerProp_tblPrType::TableInd == type ) { double dInd = m_oBufferedStream.GetDouble(); long nInd = SerializeCommon::Round( g_dKoef_mm_to_twips * dInd); pWiterTblPr->Props += L""; } else if ( c_oSerProp_tblPrType::TableIndTwips == type ) { pWiterTblPr->Props += L""; } else if ( c_oSerProp_tblPrType::TableW == type ) { docW odocW; READ2_DEF(length, res, this->ReadW, &odocW); pWiterTblPr->Props += odocW.Write(std::wstring(_T("w:tblW"))); } else if ( c_oSerProp_tblPrType::TableCellMar == type ) { NSStringUtils::CStringBuilder oTempWriter; READ1_DEF(length, res, this->ReadCellMargins, &oTempWriter); if (oTempWriter.GetCurSize() > 0) { pWiterTblPr->Props += L"" + oTempWriter.GetData() + L""; } } else if ( c_oSerProp_tblPrType::TableBorders == type ) { OOX::Logic::CTblBorders tblBorders; READ1_DEF(length, res, oBinary_pPrReader.ReadTableBorders, &tblBorders); std::wstring sTableBorders = tblBorders.toXML(); if (false == sTableBorders.empty()) { pWiterTblPr->Props += sTableBorders; } } else if ( c_oSerProp_tblPrType::Shd == type ) { ComplexTypes::Word::CShading oShd; READ2_DEF(length, res, oBinary_CommonReader2.ReadShdComplexType, &oShd); std::wstring sShd = oShd.ToString(); if (false == sShd.empty()) { pWiterTblPr->Props += L""; } } else if ( c_oSerProp_tblPrType::tblpPr == type ) { NSStringUtils::CStringBuilder oTempWriter; READ2_DEF(length, res, this->Read_tblpPr, &oTempWriter); pWiterTblPr->Props += L""; } else if ( c_oSerProp_tblPrType::tblpPr2 == type ) { NSStringUtils::CStringBuilder oTempWriter; READ2_DEF(length, res, this->Read_tblpPr2, &oTempWriter); pWiterTblPr->Props += L""; } else if ( c_oSerProp_tblPrType::Style == type ) { std::wstring Name(m_oBufferedStream.GetString3(length)); Name = XmlUtils::EncodeXmlString(Name); pWiterTblPr->Style = L""; } else if ( c_oSerProp_tblPrType::Look == type ) { // _INT32 nLook = m_oBufferedStream.GetLong(); int nFC = (0 == (nLook & 0x0080)) ? 0 : 1; int nFR = (0 == (nLook & 0x0020)) ? 0 : 1; int nLC = (0 == (nLook & 0x0100)) ? 0 : 1; int nLR = (0 == (nLook & 0x0040)) ? 0 : 1; int nBH = (0 == (nLook & 0x0200)) ? 0 : 1; int nBV = (0 == (nLook & 0x0400)) ? 0 : 1; pWiterTblPr->Props += L""; } else if ( c_oSerProp_tblPrType::Layout == type ) { long nLayout = m_oBufferedStream.GetUChar(); std::wstring sLayout; switch(nLayout) { case 1: sLayout = _T("autofit");break; case 2: sLayout = _T("fixed");break; } if (false == sLayout.empty()) pWiterTblPr->Props += L""; } else if ( c_oSerProp_tblPrType::tblPrChange == type ) { TrackRevision tblPrChange; READ1_DEF(length, res, this->ReadTblPrChange, &tblPrChange); pWiterTblPr->tblPrChange = tblPrChange.ToString(_T("w:tblPrChange")); } else if ( c_oSerProp_tblPrType::TableCellSpacing == type ) { double dSpacing = m_oBufferedStream.GetDouble(); dSpacing /=2; long nSpacing = SerializeCommon::Round( g_dKoef_mm_to_twips * dSpacing); pWiterTblPr->Props += L""; } else if ( c_oSerProp_tblPrType::TableCellSpacingTwips == type ) { pWiterTblPr->Props += L""; } else if ( c_oSerProp_tblPrType::tblCaption == type ) { pWiterTblPr->Caption = m_oBufferedStream.GetString3(length); } else if ( c_oSerProp_tblPrType::tblDescription == type ) { pWiterTblPr->Description = m_oBufferedStream.GetString3(length); } else if (c_oSerProp_tblPrType::tblOverlap == type) { BYTE jc = m_oBufferedStream.GetUChar(); switch (jc) { case 1: pWiterTblPr->Props += L""; break; case 2: pWiterTblPr->Props += L""; break; } } else if (c_oSerProp_tblPrType::bidiVisual == type) { bool val = m_oBufferedStream.GetBool(); if (val) pWiterTblPr->Props += L""; } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_tblPrReader::ReadW(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; docW* odocW = static_cast(poResult); if ( c_oSerWidthType::Type == type ) { odocW->bType = true; odocW->Type = m_oBufferedStream.GetUChar(); } else if ( c_oSerWidthType::W == type ) { odocW->bW = true; odocW->W = m_oBufferedStream.GetDouble(); } else if ( c_oSerWidthType::WDocx == type ) { odocW->bWDocx = true; odocW->WDocx = m_oBufferedStream.GetLong(); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_tblPrReader::ReadCellMargins(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if ( c_oSerMarginsType::left == type ) { docW oLeft; READ2_DEF(length, res, this->ReadW, &oLeft); oLeft.Write(*pCStringWriter, std::wstring(_T("w:left"))); } else if ( c_oSerMarginsType::top == type ) { docW oTop; READ2_DEF(length, res, this->ReadW, &oTop); oTop.Write(*pCStringWriter, std::wstring(_T("w:top"))); } else if ( c_oSerMarginsType::right == type ) { docW oRight; READ2_DEF(length, res, this->ReadW, &oRight); oRight.Write(*pCStringWriter, std::wstring(_T("w:right"))); } else if ( c_oSerMarginsType::bottom == type ) { docW oBottom; READ2_DEF(length, res, this->ReadW, &oBottom); oBottom.Write(*pCStringWriter, std::wstring(_T("w:bottom"))); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_tblPrReader::Read_tblpPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if ( c_oSer_tblpPrType::X == type ) { double dX = m_oBufferedStream.GetDouble(); long nX = SerializeCommon::Round( g_dKoef_mm_to_twips * dX); pCStringWriter->WriteString(L" w:tblpX=\"" + std::to_wstring(nX) + L"\""); } else if ( c_oSer_tblpPrType::Y == type ) { double dY = m_oBufferedStream.GetDouble(); long nY = SerializeCommon::Round( g_dKoef_mm_to_twips * dY); pCStringWriter->WriteString(L" w:tblpY=\"" + std::to_wstring(nY) + L"\""); } else if ( c_oSer_tblpPrType::Paddings == type ) { PaddingsToWrite oPaddings; READ2_DEF(length, res, this->ReadPaddings, &oPaddings); if (oPaddings.bLeft) { double dLeft = oPaddings.Left; long nLeft = SerializeCommon::Round( g_dKoef_mm_to_twips * dLeft); pCStringWriter->WriteString(L" w:leftFromText=\"" + std::to_wstring(nLeft) + L"\""); } if (oPaddings.bTop) { double dTop = oPaddings.Top; long nTop = SerializeCommon::Round( g_dKoef_mm_to_twips * dTop); pCStringWriter->WriteString(L" w:topFromText=\"" + std::to_wstring(nTop) + L"\""); } if (oPaddings.bRight) { double dRight = oPaddings.Right; long nRight = SerializeCommon::Round( g_dKoef_mm_to_twips * dRight); pCStringWriter->WriteString(L" w:rightFromText=\"" + std::to_wstring(nRight) + L"\""); } if (oPaddings.bBottom) { double dBottom = oPaddings.Bottom; long nBottom = SerializeCommon::Round( g_dKoef_mm_to_twips * dBottom); pCStringWriter->WriteString(L" w:bottomFromText=\"" + std::to_wstring(nBottom) + L"\""); } } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_tblPrReader::Read_tblpPr2(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if ( c_oSer_tblpPrType2::HorzAnchor == type ) { std::wstring sXml; switch(m_oBufferedStream.GetUChar()) { case 0:sXml += (_T(" w:horzAnchor=\"margin\""));break; case 1:sXml += (_T(" w:horzAnchor=\"page\""));break; case 2:sXml += (_T(" w:horzAnchor=\"text\""));break; default:sXml += (_T(" w:horzAnchor=\"text\""));break; } pCStringWriter->WriteString(sXml); } else if ( c_oSer_tblpPrType2::TblpX == type ) { double dX = m_oBufferedStream.GetDouble(); long nX = SerializeCommon::Round( g_dKoef_mm_to_twips * dX); pCStringWriter->WriteString(L" w:tblpX=\"" + std::to_wstring(nX) + L"\""); } else if ( c_oSer_tblpPrType2::TblpXTwips == type ) { pCStringWriter->WriteString(L" w:tblpX=\"" + std::to_wstring(m_oBufferedStream.GetLong()) + L"\""); } else if ( c_oSer_tblpPrType2::TblpXSpec == type ) { std::wstring sXml; switch(m_oBufferedStream.GetUChar()) { case 0: sXml += (_T(" w:tblpXSpec=\"center\"")); break; case 1: sXml += (_T(" w:tblpXSpec=\"inside\"")); break; case 2: sXml += (_T(" w:tblpXSpec=\"left\"")); break; case 3: sXml += (_T(" w:tblpXSpec=\"outside\"")); break; case 4: sXml += (_T(" w:tblpXSpec=\"right\"")); break; default: sXml += (_T(" w:tblpXSpec=\"left\"")); break; } pCStringWriter->WriteString(sXml); } else if ( c_oSer_tblpPrType2::VertAnchor == type ) { std::wstring sXml; switch(m_oBufferedStream.GetUChar()) { case 0: sXml += (_T(" w:vertAnchor=\"margin\""));break; case 1: sXml += (_T(" w:vertAnchor=\"page\"")); break; case 2: sXml += (_T(" w:vertAnchor=\"text\"")); break; default:sXml += (_T(" w:vertAnchor=\"text\"")); break; } pCStringWriter->WriteString(sXml); } else if ( c_oSer_tblpPrType2::TblpY == type ) { double dY = m_oBufferedStream.GetDouble(); long nY = SerializeCommon::Round( g_dKoef_mm_to_twips * dY); pCStringWriter->WriteString(L" w:tblpY=\"" + std::to_wstring(nY) + L"\""); } else if ( c_oSer_tblpPrType2::TblpYTwips == type ) { pCStringWriter->WriteString(L" w:tblpY=\"" + std::to_wstring(m_oBufferedStream.GetLong()) + L"\""); } else if ( c_oSer_tblpPrType2::TblpYSpec == type ) { std::wstring sXml; switch(m_oBufferedStream.GetUChar()) { case 0: sXml += (_T(" w:tblpYSpec=\"bottom\"")); break; case 1: sXml += (_T(" w:tblpYSpec=\"center\"")); break; case 2: sXml += (_T(" w:tblpYSpec=\"inline\"")); break; case 3: sXml += (_T(" w:tblpYSpec=\"inside\"")); break; case 4: sXml += (_T(" w:tblpYSpec=\"outside\""));break; case 5: sXml += (_T(" w:tblpYSpec=\"top\"")); break; default: sXml += (_T(" w:tblpYSpec=\"top\"")); break; } pCStringWriter->WriteString(sXml); } else if ( c_oSer_tblpPrType2::Paddings == type ) { READ2_DEF(length, res, this->ReadPaddings2, poResult); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_tblPrReader::Read_RowPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if ( c_oSerProp_rowPrType::CantSplit == type ) { BYTE CantSplit = m_oBufferedStream.GetUChar(); if (0 != CantSplit) pCStringWriter->WriteString(std::wstring(_T(""))); else pCStringWriter->WriteString(std::wstring(_T(""))); } else if ( c_oSerProp_rowPrType::After == type ) { rowPrAfterBefore orowPrAfterBefore(_T("After")); READ2_DEF(length, res, this->ReadAfter, &orowPrAfterBefore); if (true == orowPrAfterBefore.bGridAfter && orowPrAfterBefore.nGridAfter > 0 && false == orowPrAfterBefore.oAfterWidth.bW) { //ищем по tblGrid long nGridLength = (long)m_aCurTblGrid.size(); if (orowPrAfterBefore.nGridAfter < nGridLength) { double nSumW = 0; for(int i = 0; i < orowPrAfterBefore.nGridAfter; i++) { nSumW += m_aCurTblGrid[nGridLength - i - 1]; } orowPrAfterBefore.oAfterWidth.bW = true; orowPrAfterBefore.oAfterWidth.W = nSumW; } } orowPrAfterBefore.Write(*pCStringWriter); } else if ( c_oSerProp_rowPrType::Before == type ) { rowPrAfterBefore orowPrAfterBefore(_T("Before")); READ2_DEF(length, res, this->ReadBefore, &orowPrAfterBefore); if (true == orowPrAfterBefore.bGridAfter && orowPrAfterBefore.nGridAfter > 0 && false == orowPrAfterBefore.oAfterWidth.bW) { //ищем по tblGrid if (orowPrAfterBefore.nGridAfter < (long)m_aCurTblGrid.size()) { double nSumW = 0; for(int i = 0; i < orowPrAfterBefore.nGridAfter; i++) { nSumW += m_aCurTblGrid[i]; } orowPrAfterBefore.oAfterWidth.bW = true; orowPrAfterBefore.oAfterWidth.W = nSumW; } } orowPrAfterBefore.Write(*pCStringWriter); } else if ( c_oSerProp_rowPrType::Jc == type ) { BYTE jc = m_oBufferedStream.GetUChar(); switch(jc) { case align_Right: pCStringWriter->WriteString(std::wstring(_T("")));break; case align_Left: pCStringWriter->WriteString(std::wstring(_T("")));break; case align_Center: pCStringWriter->WriteString(std::wstring(_T("")));break; case align_Justify: pCStringWriter->WriteString(std::wstring(_T("")));break; } } else if ( c_oSerProp_rowPrType::TableCellSpacing == type ) { double dSpacing = m_oBufferedStream.GetDouble(); dSpacing /=2; long nSpacing = SerializeCommon::Round( g_dKoef_mm_to_twips * dSpacing); pCStringWriter->WriteString(L""); } else if ( c_oSerProp_rowPrType::TableCellSpacingTwips == type ) { pCStringWriter->WriteString(L""); } else if ( c_oSerProp_rowPrType::Height == type ) { RowHeight val; READ2_DEF(length, res, this->ReadHeight, &val); pCStringWriter->WriteString(L"WriteString(L" w:hRule=\"auto\""); break; case 2: pCStringWriter->WriteString(L" w:hRule=\"exact\""); break; } pCStringWriter->WriteString(L"/>"); } else if ( c_oSerProp_rowPrType::TableHeader == type ) { BYTE tblHeader = m_oBufferedStream.GetUChar(); if (0 != tblHeader) pCStringWriter->WriteString(std::wstring(_T(""))); else pCStringWriter->WriteString(std::wstring(_T(""))); } else if ( c_oSerProp_rowPrType::Del == type ) { TrackRevision Del; oBinary_CommonReader2.ReadTrackRevision(length, &Del); Del.Write(pCStringWriter, _T("w:del")); } else if ( c_oSerProp_rowPrType::Ins == type ) { TrackRevision Ins; oBinary_CommonReader2.ReadTrackRevision(length, &Ins); Ins.Write(pCStringWriter, _T("w:ins")); } else if ( c_oSerProp_rowPrType::trPrChange == type ) { TrackRevision trPrChange; READ1_DEF(length, res, this->ReadTrPrChange, &trPrChange); trPrChange.Write(pCStringWriter, _T("w:trPrChange")); } else if (c_oSerProp_rowPrType::CnfStyle == type) { ComplexTypes::Word::CCnf cnf; READ1_DEF(length, res, this->oBinary_pPrReader.ReadCnfStyle, &cnf); pCStringWriter->WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_tblPrReader::ReadAfter(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; rowPrAfterBefore* orowPrAfterBefore = static_cast(poResult); if ( c_oSerProp_rowPrType::GridAfter == type ) { orowPrAfterBefore->bGridAfter = true; orowPrAfterBefore->nGridAfter = m_oBufferedStream.GetLong(); } else if ( c_oSerProp_rowPrType::WAfter == type ) { READ2_DEF(length, res, this->ReadW, &orowPrAfterBefore->oAfterWidth); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_tblPrReader::ReadBefore(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; rowPrAfterBefore* orowPrAfterBefore = static_cast(poResult); if ( c_oSerProp_rowPrType::GridBefore == type ) { orowPrAfterBefore->bGridAfter = true; orowPrAfterBefore->nGridAfter = m_oBufferedStream.GetLong(); } else if ( c_oSerProp_rowPrType::WBefore == type ) { READ2_DEF(length, res, this->ReadW, &orowPrAfterBefore->oAfterWidth); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_tblPrReader::ReadHeight(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; RowHeight* pHeight = static_cast(poResult); if ( c_oSerProp_rowPrType::Height_Rule == type ) { pHeight->HRule = m_oBufferedStream.GetUChar(); } else if ( c_oSerProp_rowPrType::Height_Value == type ) { double dHeight = m_oBufferedStream.GetDouble(); pHeight->nHeight = SerializeCommon::Round( g_dKoef_mm_to_twips * dHeight); } else if ( c_oSerProp_rowPrType::Height_ValueTwips == type ) { pHeight->nHeight = m_oBufferedStream.GetLong(); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_tblPrReader::Read_CellPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if ( c_oSerProp_cellPrType::GridSpan == type ) { long nGridSpan = m_oBufferedStream.GetLong(); if (nGridSpan > 1) { pCStringWriter->WriteString(L""); } } else if ( c_oSerProp_cellPrType::Shd == type ) { ComplexTypes::Word::CShading oShd; READ2_DEF(length, res, oBinary_CommonReader2.ReadShdComplexType, &oShd); std::wstring sShd = oShd.ToString(); if (false == sShd.empty()) pCStringWriter->WriteString(L""); } else if ( c_oSerProp_cellPrType::TableCellBorders == type ) { OOX::Logic::CTcBorders tcBorders; READ1_DEF(length, res, oBinary_pPrReader.ReadTableCellBorders, &tcBorders); std::wstring sTcBorders = tcBorders.toXML(); if (false == sTcBorders.empty()) { pCStringWriter->WriteString(sTcBorders); } } else if ( c_oSerProp_cellPrType::CellMar == type ) { NSStringUtils::CStringBuilder oTempWriter; READ1_DEF(length, res, this->ReadCellMargins, &oTempWriter); if (oTempWriter.GetCurSize() > 0) { pCStringWriter->WriteString(std::wstring(_T(""))); pCStringWriter->Write(oTempWriter); pCStringWriter->WriteString(std::wstring(_T(""))); } } else if ( c_oSerProp_cellPrType::TableCellW == type ) { docW oW; READ2_DEF(length, res, this->ReadW, &oW); oW.Write(*pCStringWriter, std::wstring(_T("w:tcW"))); } else if ( c_oSerProp_cellPrType::VAlign == type ) { BYTE VAlign = m_oBufferedStream.GetUChar(); switch(VAlign) { case vertalignjc_Top:pCStringWriter->WriteString(std::wstring(_T("")));break; case vertalignjc_Center:pCStringWriter->WriteString(std::wstring(_T("")));break; case vertalignjc_Bottom:pCStringWriter->WriteString(std::wstring(_T("")));break; } } else if ( c_oSerProp_cellPrType::VMerge == type ) { BYTE VMerge = m_oBufferedStream.GetUChar(); switch(VMerge) { case vmerge_Restart:pCStringWriter->WriteString(std::wstring(_T("")));break; case vmerge_Continue:pCStringWriter->WriteString(std::wstring(_T("")));break; } } else if ( c_oSerProp_cellPrType::HMerge == type ) { BYTE HMerge = m_oBufferedStream.GetUChar(); switch(HMerge) { case vmerge_Restart:pCStringWriter->WriteString(std::wstring(_T("")));break; case vmerge_Continue:pCStringWriter->WriteString(std::wstring(_T("")));break; } } else if ( c_oSerProp_cellPrType::CellDel == type ) { TrackRevision Del; oBinary_CommonReader2.ReadTrackRevision(length, &Del); Del.Write(pCStringWriter, _T("w:del")); } else if ( c_oSerProp_cellPrType::CellIns == type ) { TrackRevision Ins; oBinary_CommonReader2.ReadTrackRevision(length, &Ins); Ins.Write(pCStringWriter, _T("w:ins")); } else if ( c_oSerProp_cellPrType::CellMerge == type ) { TrackRevision cellMerge; READ1_DEF(length, res, this->ReadCellMerge, &cellMerge); cellMerge.Write(pCStringWriter, _T("w:cellMerge")); } else if ( c_oSerProp_cellPrType::tcPrChange == type ) { TrackRevision tcPrChange; READ1_DEF(length, res, this->ReadTcPrChange, &tcPrChange); tcPrChange.Write(pCStringWriter, _T("w:tcPrChange")); } else if ( c_oSerProp_cellPrType::textDirection == type ) { SimpleTypes::CTextDirection oTextDirection; oTextDirection.SetValue((SimpleTypes::ETextDirection)m_oBufferedStream.GetUChar()); pCStringWriter->WriteString(std::wstring(_T("WriteString(oTextDirection.ToString()); pCStringWriter->WriteString(std::wstring(_T("\" />"))); } else if ( c_oSerProp_cellPrType::hideMark == type ) { bool hideMark = m_oBufferedStream.GetBool(); if (hideMark) pCStringWriter->WriteString(std::wstring(_T(""))); else pCStringWriter->WriteString(std::wstring(_T(""))); } else if ( c_oSerProp_cellPrType::noWrap == type ) { bool noWrap = m_oBufferedStream.GetBool(); if (noWrap) pCStringWriter->WriteString(std::wstring(_T(""))); else pCStringWriter->WriteString(std::wstring(_T(""))); } else if ( c_oSerProp_cellPrType::tcFitText == type ) { bool tcFitText = m_oBufferedStream.GetBool(); if (tcFitText) pCStringWriter->WriteString(std::wstring(_T(""))); else pCStringWriter->WriteString(std::wstring(_T(""))); } else if (c_oSerProp_cellPrType::CnfStyle == type) { ComplexTypes::Word::CCnf cnf; READ1_DEF(length, res, this->oBinary_pPrReader.ReadCnfStyle, &cnf); pCStringWriter->WriteString(cnf.ToString()); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_tblPrReader::ReadPaddings(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; PaddingsToWrite* oPaddings = static_cast(poResult); if (c_oSerPaddingType::left == type) { oPaddings->bLeft = true; oPaddings->Left = m_oBufferedStream.GetDouble(); } else if (c_oSerPaddingType::top == type) { oPaddings->bTop = true; oPaddings->Top = m_oBufferedStream.GetDouble(); } else if (c_oSerPaddingType::right == type) { oPaddings->bRight = true; oPaddings->Right = m_oBufferedStream.GetDouble(); } else if (c_oSerPaddingType::bottom == type) { oPaddings->bBottom = true; oPaddings->Bottom = m_oBufferedStream.GetDouble(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_tblPrReader::ReadPaddings2(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if (c_oSerPaddingType::left == type) { double dLeft = m_oBufferedStream.GetDouble(); long nLeft = SerializeCommon::Round( g_dKoef_mm_to_twips * dLeft); pCStringWriter->WriteString(L" w:leftFromText=\"" + std::to_wstring(nLeft) + L"\""); } else if (c_oSerPaddingType::leftTwips == type) { pCStringWriter->WriteString(L" w:leftFromText=\"" + std::to_wstring(m_oBufferedStream.GetLong()) + L"\""); } else if (c_oSerPaddingType::top == type) { double dTop = m_oBufferedStream.GetDouble(); long nTop = SerializeCommon::Round( g_dKoef_mm_to_twips * dTop); pCStringWriter->WriteString(L" w:topFromText=\"" + std::to_wstring(nTop) + L"\""); } else if (c_oSerPaddingType::topTwips == type) { pCStringWriter->WriteString(L" w:topFromText=\"" + std::to_wstring(m_oBufferedStream.GetLong()) + L"\""); } else if (c_oSerPaddingType::right == type) { double dRight = m_oBufferedStream.GetDouble(); long nRight = SerializeCommon::Round( g_dKoef_mm_to_twips * dRight); pCStringWriter->WriteString(L" w:rightFromText=\"" + std::to_wstring(nRight) + L"\""); } else if (c_oSerPaddingType::rightTwips == type) { pCStringWriter->WriteString(L" w:rightFromText=\"" + std::to_wstring(m_oBufferedStream.GetLong()) + L"\""); } else if (c_oSerPaddingType::bottom == type) { double dBottom = m_oBufferedStream.GetDouble(); long nBottom = SerializeCommon::Round( g_dKoef_mm_to_twips * dBottom); pCStringWriter->WriteString(L" w:bottomFromText=\"" + std::to_wstring(nBottom) + L"\""); } else if (c_oSerPaddingType::bottomTwips == type) { pCStringWriter->WriteString(L" w:bottomFromText=\"" + std::to_wstring(m_oBufferedStream.GetLong()) + L"\""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_tblPrReader::ReadCellMerge(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; TrackRevision* pTrackRevision = static_cast(poResult); READ1_TRACKREV(type, length, pTrackRevision) else if (c_oSerProp_RevisionType::VMerge == type) { pTrackRevision->vMerge = new _INT32(m_oBufferedStream.GetLong()); } else if (c_oSerProp_RevisionType::VMergeOrigin == type) { pTrackRevision->vMergeOrigin = new _INT32(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_tblPrReader::ReadTblPrChange(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; TrackRevision* pTrackRevision = static_cast(poResult); READ1_TRACKREV(type, length, pTrackRevision) else if (c_oSerProp_RevisionType::tblPrChange == type) { pTrackRevision->tblPr = new CWiterTblPr(); READ1_DEF(length, res, this->Read_tblPr, pTrackRevision->tblPr); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_tblPrReader::ReadTrPrChange(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; TrackRevision* pTrackRevision = static_cast(poResult); READ1_TRACKREV(type, length, pTrackRevision) else if (c_oSerProp_RevisionType::trPrChange == type) { pTrackRevision->trPr = new NSStringUtils::CStringBuilder(); READ2_DEF(length, res, this->Read_RowPr, pTrackRevision->trPr); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_tblPrReader::ReadTcPrChange(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; TrackRevision* pTrackRevision = static_cast(poResult); READ1_TRACKREV(type, length, pTrackRevision) else if (c_oSerProp_RevisionType::tcPrChange == type) { pTrackRevision->tcPr = new NSStringUtils::CStringBuilder(); READ2_DEF(length, res, this->Read_CellPr, pTrackRevision->tcPr); } else res = c_oSerConstants::ReadUnknown; return res; } Binary_NumberingTableReader::Binary_NumberingTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter, OOX::CNumbering* numbering) : Binary_CommonReader(poBufferedStream), oBinary_pPrReader(poBufferedStream, oFileWriter), oBinary_rPrReader(poBufferedStream, oFileWriter), m_pNumbering(numbering) { } int Binary_NumberingTableReader::Read() { int res = c_oSerConstants::ReadOk; READ_TABLE_DEF(res, this->ReadNumberingContent, NULL); return res; }; int Binary_NumberingTableReader::ReadNumberingContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerNumTypes::AbstractNums == type ) { READ1_DEF(length, res, this->ReadAbstractNums, poResult); } else if ( c_oSerNumTypes::Nums == type ) { READ1_DEF(length, res, this->ReadNums, poResult); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_NumberingTableReader::ReadNums(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerNumTypes::Num == type ) { OOX::Numbering::CNum* pdocNum = new OOX::Numbering::CNum(); READ2_DEF(length, res, this->ReadNum, pdocNum); if (pdocNum->m_oNumId.IsInit() && pdocNum->m_oAbstractNumId.IsInit()) m_pNumbering->m_mapAbstractNum[*pdocNum->m_oAbstractNumId->m_oVal] = *pdocNum->m_oNumId; m_pNumbering->m_arrNum.push_back(pdocNum); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_NumberingTableReader::ReadNum(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Numbering::CNum* odocNum = static_cast(poResult); if ( c_oSerNumTypes::Num_ANumId == type ) { odocNum->m_oAbstractNumId.Init(); odocNum->m_oAbstractNumId->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSerNumTypes::Num_NumId == type ) { odocNum->m_oNumId = m_oBufferedStream.GetLong(); } else if ( c_oSerNumTypes::Num_LvlOverride == type ) { OOX::Numbering::CNumLvl* lvlOverride = new OOX::Numbering::CNumLvl(); READ1_DEF(length, res, this->ReadLvlOverride, lvlOverride); odocNum->m_arrLvlOverride.push_back(lvlOverride); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_NumberingTableReader::ReadLvlOverride(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Numbering::CNumLvl* lvlOverride = static_cast(poResult); if (c_oSerNumTypes::ILvl == type) { lvlOverride->m_oIlvl = m_oBufferedStream.GetLong(); } else if (c_oSerNumTypes::StartOverride == type) { lvlOverride->m_oStartOverride.Init(); lvlOverride->m_oStartOverride ->m_oVal = m_oBufferedStream.GetLong(); } else if (c_oSerNumTypes::Lvl == type) { lvlOverride->m_oLvl.Init(); READ2_DEF(length, res, this->ReadLevel, lvlOverride->m_oLvl.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_NumberingTableReader::ReadAbstractNums(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerNumTypes::AbstractNum == type ) { OOX::Numbering::CAbstractNum* pdocANum = new OOX::Numbering::CAbstractNum(); READ1_DEF(length, res, this->ReadAbstractNum, pdocANum); m_pNumbering->m_arrAbstractNum.push_back(pdocANum); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_NumberingTableReader::ReadAbstractNum(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Numbering::CAbstractNum* odocANum = static_cast(poResult); if ( c_oSerNumTypes::AbstractNum_Lvls == type ) { READ1_DEF(length, res, this->ReadLevels, poResult); } else if ( c_oSerNumTypes::AbstractNum_Id == type ) { odocANum->m_oAbstractNumId = m_oBufferedStream.GetLong(); } else if (c_oSerNumTypes::NumStyleLink == type) { odocANum->m_oNumStyleLink.Init(); odocANum->m_oNumStyleLink->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerNumTypes::StyleLink == type) { odocANum->m_oStyleLink.Init(); odocANum->m_oStyleLink->m_sVal = m_oBufferedStream.GetString3(length); } else if ( c_oSerNumTypes::AbstractNum_Type == type ) { odocANum->m_oMultiLevelType.Init(); odocANum->m_oMultiLevelType->m_oVal.Init(); odocANum->m_oMultiLevelType->m_oVal->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oSerNumTypes::Nsid == type) { odocANum->m_oNsid.Init(); odocANum->m_oNsid->m_oVal.Init(); odocANum->m_oNsid->m_oVal->SetValue(m_oBufferedStream.GetULong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_NumberingTableReader::ReadLevels(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Numbering::CAbstractNum* odocANum = static_cast(poResult); if ( c_oSerNumTypes::Lvl == type ) { OOX::Numbering::CLvl* odocLvl = new OOX::Numbering::CLvl(); odocLvl->m_oIlvl = (long)odocANum->m_arrLvl.size(); READ2_DEF(length, res, this->ReadLevel, odocLvl); odocANum->m_arrLvl.push_back(odocLvl); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_NumberingTableReader::ReadLevel(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Numbering::CLvl* odocLvl = static_cast(poResult); if ( c_oSerNumTypes::lvl_Format == type ) {//old } else if ( c_oSerNumTypes::lvl_NumFmt == type ) { odocLvl->m_oNumFmt.Init(); READ1_DEF(length, res, oBinary_pPrReader.ReadNumFmt, odocLvl->m_oNumFmt.GetPointer()); } else if ( c_oSerNumTypes::lvl_Jc_deprecated == type ) {//old } else if ( c_oSerNumTypes::lvl_Jc == type ) { odocLvl->m_oLvlJc.Init(); odocLvl->m_oLvlJc->m_oVal.Init(); odocLvl->m_oLvlJc->m_oVal->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if ( c_oSerNumTypes::lvl_LvlText == type ) { odocLvl->m_oLvlText.Init(); READ1_DEF(length, res, this->ReadLevelText, odocLvl->m_oLvlText.GetPointer()); } else if ( c_oSerNumTypes::lvl_Restart == type ) { odocLvl->m_oLvlRestart.Init(); odocLvl->m_oLvlRestart->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSerNumTypes::lvl_Start == type ) { odocLvl->m_oStart.Init(); odocLvl->m_oStart->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSerNumTypes::lvl_Suff == type ) { odocLvl->m_oSuffix.Init(); odocLvl->m_oSuffix->m_oVal.Init(); odocLvl->m_oSuffix->m_oVal->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if ( c_oSerNumTypes::lvl_PStyle == type ) { odocLvl->m_oPStyle.Init(); odocLvl->m_oPStyle->m_sVal = m_oBufferedStream.GetString3(length); } else if ( c_oSerNumTypes::lvl_ParaPr == type ) { odocLvl->m_oPPr.Init(); res = oBinary_pPrReader.Read(length, odocLvl->m_oPPr.GetPointer()); } else if ( c_oSerNumTypes::lvl_TextPr == type ) { odocLvl->m_oRPr.Init(); res = oBinary_rPrReader.Read(length, odocLvl->m_oRPr.GetPointer()); } else if ( c_oSerNumTypes::ILvl == type ) { odocLvl->m_oIlvl = m_oBufferedStream.GetLong(); } else if ( c_oSerNumTypes::Tentative == type ) { odocLvl->m_oTentative.Init(); odocLvl->m_oTentative->FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSerNumTypes::Tplc == type ) { odocLvl->m_oTplc.Init(); odocLvl->m_oTplc->SetValue(m_oBufferedStream.GetULong()); } else if ( c_oSerNumTypes::IsLgl == type ) { odocLvl->m_oIsLgl.Init(); odocLvl->m_oIsLgl->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSerNumTypes::LvlLegacy == type ) { odocLvl->m_oLegacy.Init(); READ1_DEF(length, res, this->ReadLvlLegacy, odocLvl->m_oLegacy.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_NumberingTableReader::ReadLvlLegacy(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CLvlLegacy* odocLvl = static_cast(poResult); if ( c_oSerNumTypes::Legacy == type ) { odocLvl->m_oLegacy = m_oBufferedStream.GetBool(); } else if ( c_oSerNumTypes::LegacyIndent == type ) { odocLvl->m_oLegacyIndent.Init(); odocLvl->m_oLegacyIndent->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerNumTypes::LegacySpace == type ) { odocLvl->m_oLegacySpace.Init(); odocLvl->m_oLegacySpace->SetValue(m_oBufferedStream.GetULong()); } else res = c_oSerConstants::ReadUnknown; return res; } struct docLvlText { std::wstring Text; BYTE Number = 0; bool bText = false; bool bNumber = false; }; int Binary_NumberingTableReader::ReadLevelText(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CLevelText* oLvlText = static_cast(poResult); if ( c_oSerNumTypes::lvl_LvlTextItem == type ) { docLvlText odocLvlText; READ1_DEF(length, res, this->ReadLevelTextItem, &odocLvlText); std::wstring sText; if (odocLvlText.bText) { sText = odocLvlText.Text; } else if (odocLvlText.bNumber) { sText = L"%" + std::to_wstring(odocLvlText.Number + 1); } oLvlText->m_sVal += sText; } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_NumberingTableReader::ReadLevelTextItem(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; docLvlText* odocLvlText = static_cast(poResult); if ( c_oSerNumTypes::lvl_LvlTextItemText == type ) { std::wstring sText(m_oBufferedStream.GetString3(length)); odocLvlText->bText = true; odocLvlText->Text = sText; } else if ( c_oSerNumTypes::lvl_LvlTextItemNum == type ) { odocLvlText->bNumber = true; odocLvlText->Number = m_oBufferedStream.GetUChar(); } else res = c_oSerConstants::ReadUnknown; return res; } BinaryStyleTableReader::BinaryStyleTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter) : Binary_CommonReader(poBufferedStream), m_oStylesWriter(oFileWriter.get_style_writers()), m_oFontTableWriter(oFileWriter.get_font_table_writer()), oBinary_pPrReader(poBufferedStream, oFileWriter), oBinary_rPrReader(poBufferedStream, oFileWriter), oBinary_tblPrReader(poBufferedStream, oFileWriter) { } int BinaryStyleTableReader::Read() { int res = c_oSerConstants::ReadOk; READ_TABLE_DEF(res, this->ReadStyleTableContent, NULL); return res; }; int BinaryStyleTableReader::ReadStyleTableContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if (c_oSer_st::Styles == type) { READ1_DEF(length, res, this->ReadStyle, poResult); } else if (c_oSer_st::DefpPr == type) { OOX::Logic::CParagraphProperty paraPr; res = oBinary_pPrReader.Read(length, ¶Pr); if (paraPr.IsNoEmpty()) { m_oStylesWriter.m_pPrDefault.WriteString(paraPr.toXML()); } } else if (c_oSer_st::DefrPr == type) { OOX::Logic::CRunProperty runPr; res = oBinary_rPrReader.Read(length, &runPr); if (runPr.IsNoEmpty()) { m_oStylesWriter.m_rPrDefault.WriteString(runPr.toXML()); } } else res = c_oSerConstants::ReadUnknown; return res; }; int BinaryStyleTableReader::ReadStyle(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if (c_oSer_sts::Style == type) { docStyle odocStyle; READ1_DEF(length, res, this->ReadStyleContent, &odocStyle); if (m_oStylesWriter.m_nVersion < 2) { odocStyle.bqFormat = true; odocStyle.qFormat = true; } odocStyle.Write(&m_oStylesWriter.m_Styles); } else res = c_oSerConstants::ReadUnknown; return res; }; int BinaryStyleTableReader::ReadStyleContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; docStyle* odocStyle = static_cast(poResult); if (c_oSer_sts::Style_Name == type) { std::wstring Name(m_oBufferedStream.GetString3(length)); Name = XmlUtils::EncodeXmlString(Name); odocStyle->Name = Name; } else if (c_oSer_sts::Style_Id == type) { std::wstring Id(m_oBufferedStream.GetString3(length)); Id = XmlUtils::EncodeXmlString(Id); odocStyle->Id = Id; } else if (c_oSer_sts::Style_Type == type) { odocStyle->byteType = m_oBufferedStream.GetUChar(); } else if (c_oSer_sts::Style_Default == type) { odocStyle->bDefault = true; odocStyle->Default = m_oBufferedStream.GetBool(); } else if (c_oSer_sts::Style_BasedOn == type) { std::wstring BasedOn(m_oBufferedStream.GetString3(length)); BasedOn = XmlUtils::EncodeXmlString(BasedOn); odocStyle->BasedOn = BasedOn; } else if (c_oSer_sts::Style_Next == type) { std::wstring NextId(m_oBufferedStream.GetString3(length)); NextId = XmlUtils::EncodeXmlString(NextId); odocStyle->NextId = NextId; } else if (c_oSer_sts::Style_Link == type) { odocStyle->Link = m_oBufferedStream.GetString3(length); } else if (c_oSer_sts::Style_qFormat == type) { odocStyle->bqFormat = true; odocStyle->qFormat = (0 != m_oBufferedStream.GetUChar()) ? true : false; } else if (c_oSer_sts::Style_uiPriority == type) { odocStyle->buiPriority = true; odocStyle->uiPriority = m_oBufferedStream.GetLong(); } else if (c_oSer_sts::Style_hidden == type) { odocStyle->bhidden = true; odocStyle->hidden = (0 != m_oBufferedStream.GetUChar()) ? true : false; } else if (c_oSer_sts::Style_semiHidden == type) { odocStyle->bsemiHidden = true; odocStyle->semiHidden = (0 != m_oBufferedStream.GetUChar()) ? true : false; } else if (c_oSer_sts::Style_unhideWhenUsed == type) { odocStyle->bunhideWhenUsed = true; odocStyle->unhideWhenUsed = (0 != m_oBufferedStream.GetUChar()) ? true : false; } else if (c_oSer_sts::Style_TextPr == type) { OOX::Logic::CRunProperty newRPr; res = oBinary_rPrReader.Read(length, &newRPr); if (newRPr.IsNoEmpty()) { odocStyle->TextPr = newRPr.toXML(); } } else if (c_oSer_sts::Style_ParaPr == type) { OOX::Logic::CParagraphProperty pPPr; oBinary_pPrReader.m_nCurNumId = -1; oBinary_pPrReader.m_nCurLvl = -1; res = oBinary_pPrReader.Read(length, &pPPr); odocStyle->ParaPr = pPPr.toXML(); } else if (c_oSer_sts::Style_TablePr == type) { CWiterTblPr oWiterTblPr; READ1_DEF(length, res, oBinary_tblPrReader.Read_tblPr, &oWiterTblPr); odocStyle->TablePr = oWiterTblPr.Write(); } else if (c_oSer_sts::Style_RowPr == type) { NSStringUtils::CStringBuilder oTempWriter; READ2_DEF(length, res, oBinary_tblPrReader.Read_RowPr, &oTempWriter); std::wstring sRowPr = oTempWriter.GetData(); odocStyle->RowPr = sRowPr; } else if (c_oSer_sts::Style_CellPr == type) { NSStringUtils::CStringBuilder oTempWriter; READ2_DEF(length, res, oBinary_tblPrReader.Read_CellPr, &oTempWriter); std::wstring sCellPr = oTempWriter.GetData(); odocStyle->CellPr = sCellPr; } else if (c_oSer_sts::Style_TblStylePr == type) { READ1_DEF(length, res, this->ReadTblStylePr, odocStyle); } else if (c_oSer_sts::Style_CustomStyle == type) { odocStyle->bCustom = true; odocStyle->Custom = m_oBufferedStream.GetBool(); } else if (c_oSer_sts::Style_Aliases == type) { odocStyle->Aliases = m_oBufferedStream.GetString3(length); } else if (c_oSer_sts::Style_AutoRedefine == type) { odocStyle->bautoRedefine = true; odocStyle->autoRedefine = m_oBufferedStream.GetBool(); } else if (c_oSer_sts::Style_Locked == type) { odocStyle->blocked = true; odocStyle->locked = m_oBufferedStream.GetBool(); } else if (c_oSer_sts::Style_Personal == type) { odocStyle->bpersonal = true; odocStyle->personal = m_oBufferedStream.GetBool(); } else if (c_oSer_sts::Style_PersonalCompose == type) { odocStyle->bpersonalCompose = true; odocStyle->personalCompose = m_oBufferedStream.GetBool(); } else if (c_oSer_sts::Style_PersonalReply == type) { odocStyle->bpersonalReply = true; odocStyle->personalReply = m_oBufferedStream.GetBool(); } else res = c_oSerConstants::ReadUnknown; return res; }; int BinaryStyleTableReader::ReadTblStylePr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; docStyle* odocStyle = static_cast(poResult); if (c_oSerProp_tblStylePrType::TblStylePr == type) { tblStylePr otblStylePr; READ1_DEF(length, res, this->ReadTblStyleProperty, &otblStylePr); if (otblStylePr.bType && otblStylePr.Writer.GetCurSize() > 0) { NSStringUtils::CStringBuilder oCStringWriter; switch(otblStylePr.Type) { case ETblStyleOverrideType::tblstyleoverridetypeBand1Horz: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeBand1Vert: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeBand2Horz: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeBand2Vert: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeFirstCol: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeFirstRow: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeLastCol: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeLastRow: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeNeCell: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeNwCell: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeSeCell: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeSwCell: oCStringWriter.WriteString(std::wstring(_T("")));break; case ETblStyleOverrideType::tblstyleoverridetypeWholeTable: oCStringWriter.WriteString(std::wstring(_T("")));break; } oCStringWriter.Write(otblStylePr.Writer); oCStringWriter.WriteString(std::wstring(_T(""))); odocStyle->TblStylePr.push_back(oCStringWriter.GetData()); } } else res = c_oSerConstants::ReadUnknown; return res; } int BinaryStyleTableReader::ReadTblStyleProperty(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; tblStylePr* ptblStylePr = static_cast(poResult); if (c_oSerProp_tblStylePrType::Type == type) { ptblStylePr->bType = true; ptblStylePr->Type = m_oBufferedStream.GetUChar(); } else if (c_oSerProp_tblStylePrType::RunPr == type) { OOX::Logic::CRunProperty newRPr; res = oBinary_rPrReader.Read(length, &newRPr); if (newRPr.IsNoEmpty()) { ptblStylePr->Writer.WriteString(newRPr.toXML()); } } else if (c_oSerProp_tblStylePrType::ParPr == type) { OOX::Logic::CParagraphProperty paraPr; res = oBinary_pPrReader.Read(length, ¶Pr); if (paraPr.IsNoEmpty()) { ptblStylePr->Writer.WriteString(paraPr.toXML()); } } else if (c_oSerProp_tblStylePrType::TblPr == type) { CWiterTblPr oWiterTblPr; READ1_DEF(length, res, oBinary_tblPrReader.Read_tblPr, &oWiterTblPr); if (false == oWiterTblPr.IsEmpty()) ptblStylePr->Writer.WriteString(oWiterTblPr.Write()); } else if (c_oSerProp_tblStylePrType::TrPr == type) { NSStringUtils::CStringBuilder oTempWriter; READ2_DEF(length, res, oBinary_tblPrReader.Read_RowPr, &oTempWriter); if (oTempWriter.GetCurSize() > 0) { ptblStylePr->Writer.WriteString(std::wstring(_T(""))); ptblStylePr->Writer.Write(oTempWriter); ptblStylePr->Writer.WriteString(std::wstring(_T(""))); } } else if (c_oSerProp_tblStylePrType::TcPr == type) { NSStringUtils::CStringBuilder oTempWriter; READ2_DEF(length, res, oBinary_tblPrReader.Read_CellPr, &oTempWriter); if (oTempWriter.GetCurSize() > 0) { ptblStylePr->Writer.WriteString(std::wstring(_T(""))); ptblStylePr->Writer.Write(oTempWriter); ptblStylePr->Writer.WriteString(std::wstring(_T(""))); } } else res = c_oSerConstants::ReadUnknown; return res; } Binary_OtherTableReader::Binary_OtherTableReader(std::wstring sFileInDir, NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter) : m_sFileInDir(sFileInDir), Binary_CommonReader(poBufferedStream), m_oFileWriter(oFileWriter) { } int Binary_OtherTableReader::Read() { int res = c_oSerConstants::ReadOk; READ_TABLE_DEF(res, this->ReadOtherContent, NULL); return res; } int Binary_OtherTableReader::ReadOtherContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; // not using now //if ( c_oSerOtherTableTypes::ImageMap == type ) //{ // READ1_DEF(length, res, this->ReadImageMapContent, NULL); //} //else if (c_oSerOtherTableTypes::DocxTheme == type) { smart_ptr pTheme = new PPTX::Theme(NULL); try { pTheme->fromPPTY(&m_oBufferedStream); } catch(...) { //todooo в отдельный лог } if (false == m_oFileWriter.m_bGlossaryMode) { NSBinPptxRW::CXmlWriter xmlWriter; pTheme->toXmlWriter(&xmlWriter); m_oFileWriter.m_oTheme.m_sContent = xmlWriter.GetXmlString(); if ((m_oFileWriter.m_pDrawingConverter) && (m_oFileWriter.m_pDrawingConverter->m_pTheme)) { *m_oFileWriter.m_pDrawingConverter->m_pTheme = pTheme; } } } else res = c_oSerConstants::ReadUnknown; return res; } Binary_CustomsTableReader::Binary_CustomsTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter) : Binary_CommonReader(poBufferedStream), m_oFileWriter(oFileWriter) { } int Binary_CustomsTableReader::Read() { int res = c_oSerConstants::ReadOk; READ_TABLE_DEF(res, this->ReadCustom, NULL); return res; } int Binary_CustomsTableReader::ReadCustom(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if (c_oSerCustoms::Custom == type) { OOX::CCustomXMLProps oCustomXmlProps(NULL); int res = c_oSerConstants::ReadOk; READ1_DEF(length, res, this->ReadCustomContent, &oCustomXmlProps); if (false == oCustomXmlProps.m_oCustomXmlContent.empty()) { m_oFileWriter.m_oCustomXmlWriter.WriteCustom(oCustomXmlProps.toXML(), oCustomXmlProps.m_oCustomXmlContent, m_oFileWriter.m_bGlossaryMode); } else { m_oFileWriter.m_oCustomXmlWriter.WriteCustomA(oCustomXmlProps.toXML(), oCustomXmlProps.m_oCustomXmlContentA, m_oFileWriter.m_bGlossaryMode); } } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_CustomsTableReader::ReadCustomContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::CCustomXMLProps* pCustomXMLProps = static_cast(poResult); if (c_oSerCustoms::Uri == type) { if (false == pCustomXMLProps->m_oShemaRefs.IsInit()) pCustomXMLProps->m_oShemaRefs.Init(); pCustomXMLProps->m_oShemaRefs->m_arrItems.push_back(new OOX::CCustomXMLProps::CShemaRef()); pCustomXMLProps->m_oShemaRefs->m_arrItems.back()->m_sUri = m_oBufferedStream.GetString3(length); } else if (c_oSerCustoms::ItemId == type) { pCustomXMLProps->m_oItemID.FromString(m_oBufferedStream.GetString3(length)); } else if (c_oSerCustoms::Content == type) { pCustomXMLProps->m_oCustomXmlContent = m_oBufferedStream.GetString3(length); } else if (c_oSerCustoms::ContentA == type) { pCustomXMLProps->m_oCustomXmlContentA = m_oBufferedStream.GetString2A(); } else res = c_oSerConstants::ReadUnknown; return res; } //----------------------------------------------------------------------------------------------------------------------------------------- Binary_CommentsTableReader::Binary_CommentsTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter) : Binary_CommonReader(poBufferedStream), m_oFileWriter(oFileWriter) { if (!m_oFileWriter.m_pComments) m_oFileWriter.m_pComments = &m_oComments; } int Binary_CommentsTableReader::Read() { m_oFileWriter.m_pDrawingConverter->SetDstContentRels(); Writers::ContentWriter oContentWriter; Binary_DocumentTableReader oBinary_DocumentTableReader(m_oBufferedStream, m_oFileWriter, oContentWriter, false); oBinary_DocumentTableReader.m_bUsedParaIdCounter = true; int res = c_oSerConstants::ReadOk; READ_TABLE_DEF(res, this->ReadComments, &oBinary_DocumentTableReader); OOX::CPath fileRelsPath = m_oFileWriter.get_document_writer().m_sDir + FILE_SEPARATOR_STR + L"word" + (m_oFileWriter.m_bGlossaryMode ? (FILE_SEPARATOR_STR + std::wstring(L"glossary")) : L"") + FILE_SEPARATOR_STR + L"_rels" + FILE_SEPARATOR_STR + m_oFileWriter.get_comments_writer().getFilename() + L".rels"; m_oFileWriter.m_pDrawingConverter->SaveDstContentRels(fileRelsPath.GetPath()); return res; } int Binary_CommentsTableReader::ReadComments(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_CommentsType::Comment == type ) { CComment* pComment = new CComment(m_oComments.m_oParaIdCounter, m_oComments.m_oFormatIdCounter); pComment->pBinary_DocumentTableReader = poResult; READ1_DEF(length, res, this->ReadCommentContent, pComment); if (pComment->bIdOpen && NULL == m_oComments.get(pComment->IdOpen)) m_oComments.add(pComment); else RELEASEOBJECT(pComment); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_CommentsTableReader::ReadCommentContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CComment* pComment = static_cast(poResult); if ( c_oSer_CommentsType::Id == type ) { pComment->bIdOpen = true; pComment->IdOpen = m_oBufferedStream.GetLong(); } else if ( c_oSer_CommentsType::UserName == type ) { std::wstring UserName(m_oBufferedStream.GetString3(length)); pComment->UserName = UserName; } else if ( c_oSer_CommentsType::Initials == type ) { pComment->Initials = m_oBufferedStream.GetString3(length); } else if ( c_oSer_CommentsType::UserId == type ) { std::wstring UserId(m_oBufferedStream.GetString3(length)); pComment->UserId = UserId; } else if ( c_oSer_CommentsType::ProviderId == type ) { std::wstring ProviderId(m_oBufferedStream.GetString3(length)); pComment->ProviderId = ProviderId; } else if ( c_oSer_CommentsType::Date == type ) { std::wstring Date(m_oBufferedStream.GetString3(length)); pComment->Date = Date; } else if ( c_oSer_CommentsType::OOData == type ) { std::wstring Data(m_oBufferedStream.GetString3(length)); pComment->OOData = Data; } else if ( c_oSer_CommentsType::DateUtc == type ) { std::wstring Data(m_oBufferedStream.GetString3(length)); pComment->DateUtc = Data; } else if ( c_oSer_CommentsType::UserData == type ) { std::wstring Data(m_oBufferedStream.GetString3(length)); pComment->UserData = Data; } else if ( c_oSer_CommentsType::Text == type ) { std::wstring Text(m_oBufferedStream.GetString3(length)); pComment->Text = Text; } else if ( c_oSer_CommentsType::Solved == type ) { pComment->bSolved = true; pComment->Solved = m_oBufferedStream.GetBool(); } else if ( c_oSer_CommentsType::DurableId == type ) { pComment->bDurableId = true; pComment->DurableId = m_oBufferedStream.GetULong(); } else if ( c_oSer_CommentsType::CommentContent == type ) { READ1_DEF(length, res, this->ReadCommentContentExt, pComment->pBinary_DocumentTableReader); Binary_DocumentTableReader* doc_reader = (Binary_DocumentTableReader*)pComment->pBinary_DocumentTableReader; pComment->sContent = doc_reader->GetCurrentStringWriter().GetData(); doc_reader->GetCurrentStringWriter().Clear(); _INT32 nId = m_oFileWriter.m_pComments->m_oParaIdCounter.getCurrentId(); pComment->sParaId = XmlUtils::ToString(nId, L"%08X"); } else if ( c_oSer_CommentsType::Replies == type ) { READ1_DEF(length, res, this->ReadReplies, pComment); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_CommentsTableReader::ReadCommentContentExt(BYTE type, long length, void* poResult) { Binary_DocumentTableReader* pBinary_DocumentTableReader = static_cast(poResult); if (!pBinary_DocumentTableReader) return c_oSerConstants::ReadOk; return pBinary_DocumentTableReader->ReadDocumentContent(type, length, NULL); } int Binary_CommentsTableReader::ReadReplies(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CComment* pCommentParent = static_cast(poResult); if ( c_oSer_CommentsType::Comment == type ) { CComment* pNewComment = new CComment(m_oComments.m_oParaIdCounter, m_oComments.m_oFormatIdCounter); pNewComment->pBinary_DocumentTableReader = pCommentParent->pBinary_DocumentTableReader; READ1_DEF(length, res, this->ReadCommentContent, pNewComment); pNewComment->sParaIdParent = pCommentParent->sParaId; pCommentParent->replies.push_back(pNewComment); } else res = c_oSerConstants::ReadUnknown; return res; } Binary_SettingsTableReader::Binary_SettingsTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter, OOX::CSettingsCustom* pSettingsCustom) : Binary_CommonReader(poBufferedStream), m_oSettingWriter(oFileWriter.get_settings_writer()), m_oFileWriter(oFileWriter), m_oBinary_pPrReader(poBufferedStream, oFileWriter), m_oBinary_rPrReader(poBufferedStream, oFileWriter), m_pSettingsCustom(pSettingsCustom) { } int Binary_SettingsTableReader::Read() { int res = c_oSerConstants::ReadOk; READ_TABLE_DEF(res, this->ReadSettings, m_oFileWriter.m_pCurrentSettings); return res; }; int Binary_SettingsTableReader::ReadSettings(BYTE type, long length, void* poResult) { OOX::CSettings *pSettings = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSer_SettingsType::ClrSchemeMapping == type ) { pSettings->m_oClrSchemeMapping.Init(); pSettings->m_oClrSchemeMapping->m_name = L"w:clrSchemeMapping"; int aSchemeMapping[] = { 0, 1, 2, 3, 4, 5, 10, 11, 8, 9, 6, 7 }; READ2_DEF(length, res, this->ReadClrSchemeMapping, aSchemeMapping); for (BYTE i = 0; i < 12; ++i) { std::wstring val; switch (i) { case 0: val = L"accent1"; break; case 1: val = L"accent2"; break; case 2: val = L"accent3"; break; case 3: val = L"accent4"; break; case 4: val = L"accent5"; break; case 5: val = L"accent6"; break; case 6: val = L"bg1"; break; case 7: val = L"bg2"; break; case 8: val = L"folHlink"; break; case 9: val = L"hlink"; break; case 10: val = L"tx1"; break; case 11: val = L"tx2"; break; } PPTX::Limit::ColorSchemeIndex index; index.SetBYTECode(aSchemeMapping[i] > 5 ? aSchemeMapping[i] + 2 : aSchemeMapping[i]); pSettings->m_oClrSchemeMapping->Insert(val, index); } smart_ptr pClrMap = pSettings->m_oClrSchemeMapping.GetPointer(); pClrMap.AddRef(); *m_oFileWriter.m_pDrawingConverter->m_pClrMap = pClrMap; } else if ( c_oSer_SettingsType::DefaultTabStop == type ) { pSettings->m_oDefaultTabStop.Init(); pSettings->m_oDefaultTabStop->m_oVal.Init(); pSettings->m_oDefaultTabStop->m_oVal->FromMm(m_oBufferedStream.GetDouble()); } else if ( c_oSer_SettingsType::DefaultTabStopTwips == type ) { pSettings->m_oDefaultTabStop.Init(); pSettings->m_oDefaultTabStop->m_oVal.Init(); pSettings->m_oDefaultTabStop->m_oVal->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSer_SettingsType::MathPr == type ) { pSettings->m_oMathPr.Init(); READ1_DEF(length, res, this->ReadMathPr, pSettings->m_oMathPr.GetPointer()); } else if ( c_oSer_SettingsType::TrackRevisions == type ) { pSettings->m_oTrackRevisions.Init(); pSettings->m_oTrackRevisions->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSer_SettingsType::FootnotePr == type ) { pSettings->m_oFootnotePr.Init(); READ1_DEF(length, res, this->ReadFootnotePr, pSettings->m_oFootnotePr.GetPointer()); } else if ( c_oSer_SettingsType::EndnotePr == type ) { pSettings->m_oEndnotePr.Init(); READ1_DEF(length, res, this->ReadEndnotePr, pSettings->m_oEndnotePr.GetPointer()); } else if ( c_oSer_SettingsType::DecimalSymbol == type ) { pSettings->m_oDecimalSymbol.Init(); pSettings->m_oDecimalSymbol->m_sVal = m_oBufferedStream.GetString3(length); } else if ( c_oSer_SettingsType::ListSeparator == type ) { pSettings->m_oListSeparator.Init(); pSettings->m_oListSeparator->m_sVal = m_oBufferedStream.GetString3(length); } else if ( c_oSer_SettingsType::GutterAtTop == type ) { pSettings->m_oGutterAtTop.Init(); pSettings->m_oGutterAtTop->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSer_SettingsType::MirrorMargins == type ) { pSettings->m_oMirrorMargins.Init(); pSettings->m_oMirrorMargins->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSer_SettingsType::PrintTwoOnOne == type ) { pSettings->m_oPrintTwoOnOne.Init(); pSettings->m_oPrintTwoOnOne->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSer_SettingsType::BookFoldPrinting == type ) { pSettings->m_oBookFoldPrinting.Init(); pSettings->m_oBookFoldPrinting->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSer_SettingsType::BookFoldPrintingSheets == type ) { pSettings->m_oBookFoldPrintingSheets.Init(); pSettings->m_oBookFoldPrintingSheets->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSer_SettingsType::BookFoldRevPrinting == type ) { pSettings->m_oBookFoldRevPrinting.Init(); pSettings->m_oBookFoldRevPrinting->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSer_SettingsType::SdtGlobalColor == type ) { OOX::Logic::CRunProperty oRPr; res = m_oBinary_rPrReader.Read(length, &oRPr); m_pSettingsCustom->m_oSdtGlobalColor = oRPr.m_oColor; } else if ( c_oSer_SettingsType::SdtGlobalShowHighlight == type ) { m_pSettingsCustom->m_oSdtGlobalShowHighlight.Init(); m_pSettingsCustom->m_oSdtGlobalShowHighlight->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSer_SettingsType::SpecialFormsHighlight == type ) { OOX::Logic::CRunProperty oRPr; res = m_oBinary_rPrReader.Read(length, &oRPr); m_pSettingsCustom->m_oSpecialFormsHighlight = oRPr.m_oColor; } else if ( c_oSer_SettingsType::Compat == type ) { pSettings->m_oCompat.Init(); READ1_DEF(length, res, this->ReadCompat, pSettings->m_oCompat.GetPointer()); } else if (c_oSer_SettingsType::DocumentProtection == type) { pSettings->m_oDocumentProtection.Init(); READ1_DEF(length, res, this->ReadDocProtect, pSettings->m_oDocumentProtection.GetPointer()); } else if (c_oSer_SettingsType::WriteProtection == type) { pSettings->m_oWriteProtection.Init(); READ1_DEF(length, res, this->ReadWriteProtect, pSettings->m_oWriteProtection.GetPointer()); } else if (c_oSer_SettingsType::SdtGlobalShowHighlight == type) { m_pSettingsCustom->m_oSdtGlobalShowHighlight.Init(); m_pSettingsCustom->m_oSdtGlobalShowHighlight->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if (c_oSer_SettingsType::AutoHyphenation == type) { pSettings->m_oAutoHyphenation.Init(); pSettings->m_oAutoHyphenation->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if (c_oSer_SettingsType::HyphenationZone == type) { pSettings->m_oHyphenationZone.Init(); pSettings->m_oHyphenationZone->m_oVal.Init(); pSettings->m_oHyphenationZone->m_oVal->FromTwips(m_oBufferedStream.GetLong()); } else if (c_oSer_SettingsType::DoNotHyphenateCaps == type) { pSettings->m_oDoNotHyphenateCaps.Init(); pSettings->m_oDoNotHyphenateCaps->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if (c_oSer_SettingsType::ConsecutiveHyphenLimit == type) { pSettings->m_oConsecutiveHyphenLimit.Init(); pSettings->m_oConsecutiveHyphenLimit->m_oVal = m_oBufferedStream.GetLong(); } else if (c_oSer_SettingsType::DrawingGridHorizontalOrigin == type) { pSettings->m_oDrawingGridHorizontalOrigin.Init(); pSettings->m_oDrawingGridHorizontalOrigin->m_oVal.Init(); pSettings->m_oDrawingGridHorizontalOrigin->m_oVal->FromTwips(m_oBufferedStream.GetLong()); } else if (c_oSer_SettingsType::DrawingGridHorizontalSpacing == type) { pSettings->m_oDrawingGridHorizontalSpacing.Init(); pSettings->m_oDrawingGridHorizontalSpacing->m_oVal.Init(); pSettings->m_oDrawingGridHorizontalSpacing->m_oVal->FromTwips(m_oBufferedStream.GetLong()); } else if (c_oSer_SettingsType::DrawingGridVerticalOrigin == type) { pSettings->m_oDrawingGridVerticalOrigin.Init(); pSettings->m_oDrawingGridVerticalOrigin->m_oVal.Init(); pSettings->m_oDrawingGridVerticalOrigin->m_oVal->FromTwips(m_oBufferedStream.GetLong()); } else if (c_oSer_SettingsType::DrawingGridVerticalSpacing == type) { pSettings->m_oDrawingGridVerticalSpacing.Init(); pSettings->m_oDrawingGridVerticalSpacing->m_oVal.Init(); pSettings->m_oDrawingGridVerticalSpacing->m_oVal->FromTwips(m_oBufferedStream.GetLong()); } else if (c_oSer_SettingsType::DisplayHorizontalDrawingGridEvery == type) { pSettings->m_oDisplayHorizontalDrawingGridEvery.Init(); pSettings->m_oDisplayHorizontalDrawingGridEvery->m_oVal = m_oBufferedStream.GetLong(); } else if (c_oSer_SettingsType::DisplayVerticalDrawingGridEvery == type) { pSettings->m_oDisplayVerticalDrawingGridEvery.Init(); pSettings->m_oDisplayVerticalDrawingGridEvery->m_oVal = m_oBufferedStream.GetLong(); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_SettingsTableReader::ReadCompat(BYTE type, long length, void* poResult) { OOX::Settings::CCompat* pCompat = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerCompat::CompatSetting == type ) { OOX::Settings::CCompatSetting* pCCompatSetting = new OOX::Settings::CCompatSetting(); READ1_DEF(length, res, this->ReadCompatSetting, pCCompatSetting); pCompat->m_arrCompatSettings.push_back(pCCompatSetting); } else if ( c_oSerCompat::Flags1 == type ) { _UINT32 nFlags = m_oBufferedStream.GetULong(); UINT_TO_COMPLEX_BOOL(0, pCompat->m_oUseSingleBorderforContiguousCells); UINT_TO_COMPLEX_BOOL(1, pCompat->m_oWpJustification); UINT_TO_COMPLEX_BOOL(2, pCompat->m_oNoTabHangInd); UINT_TO_COMPLEX_BOOL(3, pCompat->m_oNoLeading); UINT_TO_COMPLEX_BOOL(4, pCompat->m_oSpaceForUL); UINT_TO_COMPLEX_BOOL(5, pCompat->m_oNoColumnBalance); UINT_TO_COMPLEX_BOOL(6, pCompat->m_oBalanceSingleByteDoubleByteWidth); UINT_TO_COMPLEX_BOOL(7, pCompat->m_oNoExtraLineSpacing); UINT_TO_COMPLEX_BOOL(8, pCompat->m_oDoNotLeaveBackslashAlone); UINT_TO_COMPLEX_BOOL(9, pCompat->m_oUlTrailSpace); UINT_TO_COMPLEX_BOOL(10, pCompat->m_oDoNotExpandShiftReturn); UINT_TO_COMPLEX_BOOL(11, pCompat->m_oSpacingInWholePoints); UINT_TO_COMPLEX_BOOL(12, pCompat->m_oLineWrapLikeWord6); UINT_TO_COMPLEX_BOOL(13, pCompat->m_oPrintBodyTextBeforeHeader); UINT_TO_COMPLEX_BOOL(14, pCompat->m_oPrintColBlack); UINT_TO_COMPLEX_BOOL(15, pCompat->m_oWpSpaceWidth); UINT_TO_COMPLEX_BOOL(16, pCompat->m_oShowBreaksInFrames); UINT_TO_COMPLEX_BOOL(17, pCompat->m_oSubFontBySize); UINT_TO_COMPLEX_BOOL(18, pCompat->m_oSuppressBottomSpacing); UINT_TO_COMPLEX_BOOL(19, pCompat->m_oSuppressTopSpacing); UINT_TO_COMPLEX_BOOL(20, pCompat->m_oSuppressSpacingAtTopOfPage); UINT_TO_COMPLEX_BOOL(21, pCompat->m_oSuppressTopSpacingWP); UINT_TO_COMPLEX_BOOL(22, pCompat->m_oSuppressSpBfAfterPgBrk); UINT_TO_COMPLEX_BOOL(23, pCompat->m_oSwapBordersFacingPages); UINT_TO_COMPLEX_BOOL(24, pCompat->m_oConvMailMergeEsc); UINT_TO_COMPLEX_BOOL(25, pCompat->m_oTruncateFontHeightsLikeWP6); UINT_TO_COMPLEX_BOOL(26, pCompat->m_oMwSmallCaps); UINT_TO_COMPLEX_BOOL(27, pCompat->m_oUsePrinterMetrics); UINT_TO_COMPLEX_BOOL(28, pCompat->m_oDoNotSuppressParagraphBorders); UINT_TO_COMPLEX_BOOL(29, pCompat->m_oWrapTrailSpaces); UINT_TO_COMPLEX_BOOL(30, pCompat->m_oFootnoteLayoutLikeWW8); UINT_TO_COMPLEX_BOOL(31, pCompat->m_oShapeLayoutLikeWW8); } else if ( c_oSerCompat::Flags2 == type ) { _UINT32 nFlags = m_oBufferedStream.GetULong(); UINT_TO_COMPLEX_BOOL(0, pCompat->m_oAlignTablesRowByRow); UINT_TO_COMPLEX_BOOL(1, pCompat->m_oForgetLastTabAlignment); UINT_TO_COMPLEX_BOOL(2, pCompat->m_oAdjustLineHeightInTable); UINT_TO_COMPLEX_BOOL(3, pCompat->m_oAutoSpaceLikeWord95); UINT_TO_COMPLEX_BOOL(4, pCompat->m_oNoSpaceRaiseLower); UINT_TO_COMPLEX_BOOL(5, pCompat->m_oDoNotUseHTMLParagraphAutoSpacing); UINT_TO_COMPLEX_BOOL(6, pCompat->m_oLayoutRawTableWidth); UINT_TO_COMPLEX_BOOL(7, pCompat->m_oLayoutTableRowsApart); UINT_TO_COMPLEX_BOOL(8, pCompat->m_oUseWord97LineBreakRules); UINT_TO_COMPLEX_BOOL(9, pCompat->m_oDoNotBreakWrappedTables); UINT_TO_COMPLEX_BOOL(10, pCompat->m_oDoNotSnapToGridInCell); UINT_TO_COMPLEX_BOOL(11, pCompat->m_oSelectFldWithFirstOrLastChar); UINT_TO_COMPLEX_BOOL(12, pCompat->m_oApplyBreakingRules); UINT_TO_COMPLEX_BOOL(13, pCompat->m_oDoNotWrapTextWithPunct); UINT_TO_COMPLEX_BOOL(14, pCompat->m_oDoNotUseEastAsianBreakRules); UINT_TO_COMPLEX_BOOL(15, pCompat->m_oUseWord2002TableStyleRules); UINT_TO_COMPLEX_BOOL(16, pCompat->m_oGrowAutofit); UINT_TO_COMPLEX_BOOL(17, pCompat->m_oUseFELayout); UINT_TO_COMPLEX_BOOL(18, pCompat->m_oUseNormalStyleForList); UINT_TO_COMPLEX_BOOL(19, pCompat->m_oDoNotUseIndentAsNumberingTabStop); UINT_TO_COMPLEX_BOOL(20, pCompat->m_oUseAltKinsokuLineBreakRules); UINT_TO_COMPLEX_BOOL(21, pCompat->m_oAllowSpaceOfSameStyleInTable); UINT_TO_COMPLEX_BOOL(22, pCompat->m_oDoNotSuppressIndentation); UINT_TO_COMPLEX_BOOL(23, pCompat->m_oDoNotAutofitConstrainedTables); UINT_TO_COMPLEX_BOOL(24, pCompat->m_oAutofitToFirstFixedWidthCell); UINT_TO_COMPLEX_BOOL(25, pCompat->m_oUnderlineTabInNumList); UINT_TO_COMPLEX_BOOL(26, pCompat->m_oDisplayHangulFixedWidth); UINT_TO_COMPLEX_BOOL(27, pCompat->m_oSplitPgBreakAndParaMark); UINT_TO_COMPLEX_BOOL(28, pCompat->m_oDoNotVertAlignCellWithSp); UINT_TO_COMPLEX_BOOL(29, pCompat->m_oDoNotBreakConstrainedForcedTable); UINT_TO_COMPLEX_BOOL(30, pCompat->m_oDoNotVertAlignInTxbx); UINT_TO_COMPLEX_BOOL(31, pCompat->m_oUseAnsiKerningPairs); } else if ( c_oSerCompat::Flags3 == type ) { _UINT32 nFlags = m_oBufferedStream.GetULong(); UINT_TO_COMPLEX_BOOL(0, pCompat->m_oCachedColBalance); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadCompatSetting(BYTE type, long length, void* poResult) { OOX::Settings::CCompatSetting* pCompatSetting = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerCompat::CompatName == type ) { pCompatSetting->m_sName = m_oBufferedStream.GetString3(length); } else if ( c_oSerCompat::CompatUri == type ) { pCompatSetting->m_sUri = m_oBufferedStream.GetString3(length); } else if ( c_oSerCompat::CompatValue == type ) { pCompatSetting->m_sVal = m_oBufferedStream.GetString3(length); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadDocProtect(BYTE type, long length, void* poResult) { OOX::Settings::CDocProtect* pDocProtect = static_cast(poResult); int res = c_oSerConstants::ReadOk; if (c_oDocProtect::AlgIdExt == type) { pDocProtect->m_oAlgIdExt = m_oBufferedStream.GetString3(length); } else if (c_oDocProtect::AlgIdExtSource == type) { pDocProtect->m_oAlgIdExtSource = m_oBufferedStream.GetString3(length); } else if (c_oDocProtect::AlgorithmName == type) { pDocProtect->m_oAlgorithmName.Init(); pDocProtect->m_oAlgorithmName->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oDocProtect::CryptAlgorithmClass == type) { pDocProtect->m_oCryptAlgorithmClass.Init(); pDocProtect->m_oCryptAlgorithmClass->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oDocProtect::CryptAlgorithmSid == type) { pDocProtect->m_oCryptAlgorithmSid = m_oBufferedStream.GetLong(); } else if (c_oDocProtect::CryptAlgorithmType == type) { pDocProtect->m_oCryptAlgorithmType.Init(); pDocProtect->m_oCryptAlgorithmType->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oDocProtect::CryptProvider == type) { pDocProtect->m_oCryptProvider = m_oBufferedStream.GetString3(length); } else if (c_oDocProtect::CryptProviderType == type) { pDocProtect->m_oCryptProviderType.Init(); pDocProtect->m_oCryptProviderType->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oDocProtect::CryptProviderTypeExt == type) { pDocProtect->m_oCryptProviderTypeExt = m_oBufferedStream.GetString3(length); } else if (c_oDocProtect::CryptProviderTypeExtSource == type) { pDocProtect->m_oCryptProviderTypeExtSource = m_oBufferedStream.GetString3(length); } else if (c_oDocProtect::Edit == type) { pDocProtect->m_oEdit.Init(); pDocProtect->m_oEdit->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oDocProtect::Enforcment == type) { pDocProtect->m_oEnforcment = m_oBufferedStream.GetUChar() != 0; } else if (c_oDocProtect::Formatting == type) { pDocProtect->m_oFormatting = m_oBufferedStream.GetUChar() != 0; } else if (c_oDocProtect::HashValue == type) { pDocProtect->m_sHashValue = m_oBufferedStream.GetString3(length); } else if (c_oDocProtect::SaltValue == type) { pDocProtect->m_sSaltValue = m_oBufferedStream.GetString3(length); } else if (c_oDocProtect::SpinCount == type) { pDocProtect->m_oSpinCount = m_oBufferedStream.GetLong(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadWriteProtect(BYTE type, long length, void* poResult) { OOX::Settings::CWriteProtection* pWriteProtect = static_cast(poResult); int res = c_oSerConstants::ReadOk; if (c_oWriteProtect::AlgIdExt == type) { pWriteProtect->m_oAlgIdExt = m_oBufferedStream.GetString3(length); } else if (c_oWriteProtect::AlgIdExtSource == type) { pWriteProtect->m_oAlgIdExtSource = m_oBufferedStream.GetString3(length); } else if (c_oWriteProtect::AlgorithmName == type) { pWriteProtect->m_oAlgorithmName.Init(); pWriteProtect->m_oAlgorithmName->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oWriteProtect::CryptAlgorithmClass == type) { pWriteProtect->m_oCryptAlgorithmClass.Init(); pWriteProtect->m_oCryptAlgorithmClass->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oWriteProtect::CryptAlgorithmSid == type) { pWriteProtect->m_oCryptAlgorithmSid = m_oBufferedStream.GetLong(); } else if (c_oWriteProtect::CryptAlgorithmType == type) { pWriteProtect->m_oCryptAlgorithmType.Init(); pWriteProtect->m_oCryptAlgorithmType->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oWriteProtect::CryptProvider == type) { pWriteProtect->m_oCryptProvider = m_oBufferedStream.GetString3(length); } else if (c_oWriteProtect::CryptProviderType == type) { pWriteProtect->m_oCryptProviderType.Init(); pWriteProtect->m_oCryptProviderType->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oWriteProtect::CryptProviderTypeExt == type) { pWriteProtect->m_oCryptProviderTypeExt = m_oBufferedStream.GetString3(length); } else if (c_oWriteProtect::CryptProviderTypeExtSource == type) { pWriteProtect->m_oCryptProviderTypeExtSource = m_oBufferedStream.GetString3(length); } else if (c_oWriteProtect::Recommended == type) { pWriteProtect->m_oRecommended = m_oBufferedStream.GetUChar() != 0; } else if (c_oWriteProtect::HashValue == type) { pWriteProtect->m_sHashValue = m_oBufferedStream.GetString3(length); } else if (c_oWriteProtect::SaltValue == type) { pWriteProtect->m_sSaltValue = m_oBufferedStream.GetString3(length); } else if (c_oWriteProtect::SpinCount == type) { pWriteProtect->m_oSpinCount = m_oBufferedStream.GetLong(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadFootnotePr(BYTE type, long length, void* poResult) { OOX::Settings::CFtnDocProps* pFtnProps = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerNotes::PrFmt == type ) { pFtnProps->m_oNumFmt.Init(); READ1_DEF(length, res, m_oBinary_pPrReader.ReadNumFmt, pFtnProps->m_oNumFmt.GetPointer()); } else if ( c_oSerNotes::PrRestart == type ) { pFtnProps->m_oNumRestart.Init(); pFtnProps->m_oNumRestart->m_oVal.Init(); pFtnProps->m_oNumRestart->m_oVal->SetValue((SimpleTypes::ERestartNumber)m_oBufferedStream.GetUChar()); } else if ( c_oSerNotes::PrStart == type ) { pFtnProps->m_oNumStart.Init(); pFtnProps->m_oNumStart->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSerNotes::PrFntPos == type ) { pFtnProps->m_oPos.Init(); pFtnProps->m_oPos->m_oVal.Init(); pFtnProps->m_oPos->m_oVal->SetValue((SimpleTypes::EFtnPos)m_oBufferedStream.GetUChar()); } else if ( c_oSerNotes::PrRef == type ) { OOX::CFtnEdnSepRef* pRef = new OOX::CFtnEdnSepRef(); pRef->m_eType = OOX::et_w_footnote; pRef->m_oId.Init(); pRef->m_oId->SetValue(m_oBufferedStream.GetLong()); pFtnProps->m_arrFootnote.push_back(pRef); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadEndnotePr(BYTE type, long length, void* poResult) { OOX::Settings::CEdnDocProps* pEdnProps = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerNotes::PrFmt == type ) { pEdnProps->m_oNumFmt.Init(); READ1_DEF(length, res, m_oBinary_pPrReader.ReadNumFmt, pEdnProps->m_oNumFmt.GetPointer()); } else if ( c_oSerNotes::PrRestart == type ) { pEdnProps->m_oNumRestart.Init(); pEdnProps->m_oNumRestart->m_oVal.Init(); pEdnProps->m_oNumRestart->m_oVal->SetValue((SimpleTypes::ERestartNumber)m_oBufferedStream.GetUChar()); } else if ( c_oSerNotes::PrStart == type ) { pEdnProps->m_oNumStart.Init(); pEdnProps->m_oNumStart->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSerNotes::PrEndPos == type ) { pEdnProps->m_oPos.Init(); pEdnProps->m_oPos->m_oVal.Init(); pEdnProps->m_oPos->m_oVal->SetValue((SimpleTypes::EEdnPos)m_oBufferedStream.GetUChar()); } else if ( c_oSerNotes::PrRef == type ) { OOX::CFtnEdnSepRef* pRef = new OOX::CFtnEdnSepRef(); pRef->m_eType = OOX::et_w_endnote; pRef->m_oId.Init(); pRef->m_oId->SetValue(m_oBufferedStream.GetLong()); pEdnProps->m_arrEndnote.push_back(pRef); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathPr(BYTE type, long length, void* poResult) { OOX::Logic::CMathPr* pMathPr = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSer_MathPrType::BrkBin == type ) { pMathPr->m_oBrkBin.Init(); READ2_DEF(length, res, this->ReadMathBrkBin, pMathPr->m_oBrkBin.GetPointer()); } else if ( c_oSer_MathPrType::BrkBinSub == type ) { pMathPr->m_oBrkBinSub.Init(); READ2_DEF(length, res, this->ReadMathBrkBinSub, pMathPr->m_oBrkBinSub.GetPointer()); } else if ( c_oSer_MathPrType::DefJc == type ) { pMathPr->m_oDefJc.Init(); READ2_DEF(length, res, this->ReadMathDefJc, pMathPr->m_oDefJc.GetPointer()); } else if ( c_oSer_MathPrType::DispDef == type ) { pMathPr->m_oDispDef.Init(); READ2_DEF(length, res, this->ReadMathDispDef, pMathPr->m_oDispDef.GetPointer()); } else if ( c_oSer_MathPrType::InterSp == type ) { pMathPr->m_oInterSp.Init(); READ2_DEF(length, res, this->ReadMathInterSp, pMathPr->m_oInterSp.GetPointer()); } else if ( c_oSer_MathPrType::IntLim == type ) { pMathPr->m_oIntLim.Init(); READ2_DEF(length, res, this->ReadMathIntLim, pMathPr->m_oIntLim.GetPointer()); } else if ( c_oSer_MathPrType::IntraSp == type ) { pMathPr->m_oIntraSp.Init(); READ2_DEF(length, res, this->ReadMathIntraSp, pMathPr->m_oIntraSp.GetPointer()); } else if ( c_oSer_MathPrType::LMargin == type ) { pMathPr->m_oLMargin.Init(); READ2_DEF(length, res, this->ReadMathLMargin, pMathPr->m_oLMargin.GetPointer()); } else if ( c_oSer_MathPrType::MathFont == type ) { pMathPr->m_oMathFont.Init(); READ2_DEF(length, res, this->ReadMathMathFont, pMathPr->m_oMathFont.GetPointer()); } else if ( c_oSer_MathPrType::NaryLim == type ) { pMathPr->m_oNaryLim.Init(); READ2_DEF(length, res, this->ReadMathNaryLim, pMathPr->m_oNaryLim.GetPointer()); } else if ( c_oSer_MathPrType::PostSp == type ) { pMathPr->m_oPostSp.Init(); READ2_DEF(length, res, this->ReadMathPostSp, pMathPr->m_oPostSp.GetPointer()); } else if ( c_oSer_MathPrType::PreSp == type ) { pMathPr->m_oPreSp.Init(); READ2_DEF(length, res, this->ReadMathPreSp, pMathPr->m_oPreSp.GetPointer()); } else if ( c_oSer_MathPrType::RMargin == type ) { pMathPr->m_oRMargin.Init(); READ2_DEF(length, res, this->ReadMathRMargin, pMathPr->m_oRMargin.GetPointer()); } else if ( c_oSer_MathPrType::SmallFrac == type ) { pMathPr->m_oSmallFrac.Init(); READ2_DEF(length, res, this->ReadMathSmallFrac, pMathPr->m_oSmallFrac.GetPointer()); } else if ( c_oSer_MathPrType::WrapIndent == type ) { pMathPr->m_oWrapIndent.Init(); READ2_DEF(length, res, this->ReadMathWrapIndent, pMathPr->m_oWrapIndent.GetPointer()); } else if ( c_oSer_MathPrType::WrapRight == type ) { pMathPr->m_oWrapRight.Init(); READ2_DEF(length, res, this->ReadMathWrapRight, pMathPr->m_oWrapRight.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathBrkBin(BYTE type, long length, void* poResult)//GetUChar { OOX::Logic::CBrkBin* item = static_cast(poResult); int res = c_oSerConstants::ReadOk; if (c_oSer_OMathBottomNodesValType::Val == type) { item->m_val.Init(); item->m_val->SetValueFromByte(m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathBrkBinSub(BYTE type, long length, void* poResult)//GetUChar { OOX::Logic::CBrkBinSub* item = static_cast(poResult); int res = c_oSerConstants::ReadOk; if (c_oSer_OMathBottomNodesValType::Val == type) { item->m_val.Init(); item->m_val->SetValueFromByte(m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathDefJc(BYTE type, long length, void* poResult)//GetUChar { OOX::Logic::CDefJc* item = static_cast(poResult); int res = c_oSerConstants::ReadOk; if (c_oSer_OMathBottomNodesValType::Val == type) { item->m_val.Init(); item->m_val->SetValueFromByte(m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathDispDef(BYTE type, long length, void* poResult)//GetBool { OOX::Logic::CDispDef* item = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { item->m_val.Init(); item->m_val->FromBool(m_oBufferedStream.GetBool()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathInterSp(BYTE type, long length, void* poResult)//GetUChar { OOX::Logic::CInterSp* item = static_cast(poResult); item->m_val.Init(); int res = c_oSerConstants::ReadOk; if (c_oSer_OMathBottomNodesValType::Val == type) { item->m_val->FromMm(m_oBufferedStream.GetDouble()); } else if (c_oSer_OMathBottomNodesValType::ValTwips == type) { item->m_val->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathIntLim(BYTE type, long length, void* poResult)//GetUChar { OOX::Logic::CIntLim* item = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { item->m_val.Init(); item->m_val->SetValueFromByte(m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathIntraSp(BYTE type, long length, void* poResult)//GetUChar { OOX::Logic::CIntraSp* item = static_cast(poResult); item->m_val.Init(); int res = c_oSerConstants::ReadOk; if (c_oSer_OMathBottomNodesValType::Val == type) { item->m_val->FromMm(m_oBufferedStream.GetDouble()); //LONG lVal = (LONG)Mm_To_Dx(m_oBufferedStream.GetDouble()); } else if (c_oSer_OMathBottomNodesValType::ValTwips == type) { item->m_val->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathLMargin(BYTE type, long length, void* poResult)//GetUChar { OOX::Logic::CLMargin* item = static_cast(poResult); item->m_val.Init(); int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { item->m_val->FromMm(m_oBufferedStream.GetDouble()); //LONG lVal = (LONG)Mm_To_Dx(m_oBufferedStream.GetDouble()); } else if (c_oSer_OMathBottomNodesValType::ValTwips == type) { item->m_val->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathMathFont(BYTE type, long length, void* poResult)//ReadString { OOX::Logic::CMathFont* item = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { item->m_val = m_oBufferedStream.GetString3(length); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathNaryLim(BYTE type, long length, void* poResult)//Readbyte { OOX::Logic::CNaryLim* item = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { item->m_val.Init(); item->m_val->SetValueFromByte(m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathPostSp(BYTE type, long length, void* poResult) { OOX::Logic::CPostSp* item = static_cast(poResult); item->m_val.Init(); int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { item->m_val->FromMm(m_oBufferedStream.GetDouble()); //LONG lVal = (LONG)Mm_To_Dx(m_oBufferedStream.GetDouble()); } else if ( c_oSer_OMathBottomNodesValType::ValTwips == type ) { item->m_val->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathPreSp(BYTE type, long length, void* poResult) { OOX::Logic::CPreSp* item = static_cast(poResult); item->m_val.Init(); int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { item->m_val->FromMm(m_oBufferedStream.GetDouble()); //LONG lVal = (LONG)Mm_To_Dx(m_oBufferedStream.GetDouble()); } else if ( c_oSer_OMathBottomNodesValType::ValTwips == type ) { item->m_val->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathRMargin(BYTE type, long length, void* poResult) { OOX::Logic::CRMargin* item = static_cast(poResult); item->m_val.Init(); int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { item->m_val->FromMm(m_oBufferedStream.GetDouble()); } else if ( c_oSer_OMathBottomNodesValType::ValTwips == type ) { item->m_val->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathSmallFrac(BYTE type, long length, void* poResult)//GetBool { OOX::Logic::CSmallFrac* item = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { item->m_val.Init(); item->m_val->FromBool(m_oBufferedStream.GetBool()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathWrapIndent(BYTE type, long length, void* poResult) { OOX::Logic::CWrapIndent* item = static_cast(poResult); int res = c_oSerConstants::ReadOk; item->m_val.Init(); if ( c_oSer_OMathBottomNodesValType::Val == type ) { item->m_val->FromMm(m_oBufferedStream.GetDouble()); } else if ( c_oSer_OMathBottomNodesValType::ValTwips == type ) { item->m_val->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadMathWrapRight(BYTE type, long length, void* poResult)//GetBool { OOX::Logic::CWrapRight* item = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { item->m_val.Init(); item->m_val->FromBool(m_oBufferedStream.GetBool()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_SettingsTableReader::ReadClrSchemeMapping(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; int *paSchemeMapping = static_cast(poResult); if ( c_oSer_ClrSchemeMappingType::Accent1 <= type && type <= c_oSer_ClrSchemeMappingType::T2) { paSchemeMapping[type] = m_oBufferedStream.GetUChar(); } else res = c_oSerConstants::ReadUnknown; return res; }; Binary_DocumentTableReader::Binary_DocumentTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter, Writers::ContentWriter& oDocumentWriter, bool bOFormRead) : Binary_CommonReader(poBufferedStream) , m_oDocumentWriter(oDocumentWriter) , m_oFileWriter(oFileWriter) , m_oMediaWriter(oFileWriter.m_oMediaWriter) , m_oFontTableWriter(oFileWriter.get_font_table_writer()) , oBinary_CommonReader2(poBufferedStream) , oBinary_pPrReader(poBufferedStream, oFileWriter) , oBinary_rPrReader(poBufferedStream, oFileWriter) , oBinary_tblPrReader(poBufferedStream, oFileWriter) , m_bOFormRead(bOFormRead) { m_bUsedParaIdCounter = false; m_byteLastElemType = c_oSerParType::Content; m_pCurWriter = NULL; } Binary_DocumentTableReader::~Binary_DocumentTableReader() { } int Binary_DocumentTableReader::Read() { int res = c_oSerConstants::ReadOk; READ_TABLE_DEF(res, this->ReadDocumentContent, NULL); return res; } NSStringUtils::CStringBuilder& Binary_DocumentTableReader::GetCurrentStringWriter() { if (NULL != m_pCurWriter) return *m_pCurWriter; else return m_oDocumentWriter.m_oContent; } int Binary_DocumentTableReader::ReadDocumentContentOut(long length) { int res = c_oSerConstants::ReadOk; READ1_DEF(length, res, this->ReadDocumentContent, NULL); return res; } int Binary_DocumentTableReader::ReadDocumentContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerParType::Par == type ) { m_byteLastElemType = c_oSerParType::Par; m_oCur_pPr.Clear(); m_oParaId.reset(); m_oTextId.reset(); NSStringUtils::CStringBuilder paraWriter; NSStringUtils::CStringBuilder* pPrevWriter = m_pCurWriter; m_pCurWriter = ¶Writer; READ1_DEF(length, res, this->ReadParagraph, NULL); m_pCurWriter = pPrevWriter; if (m_oParaId.IsInit() || m_oTextId.IsInit()) { GetCurrentStringWriter().WriteString(L"ToString() + L"\""); if (m_oTextId.IsInit()) GetCurrentStringWriter().WriteString(L" w14:textId=\"" + m_oTextId->ToString() + L"\""); GetCurrentStringWriter().WriteString(L">"); } else if (m_bUsedParaIdCounter && m_oFileWriter.m_pComments) { _INT32 nId = m_oFileWriter.m_pComments->m_oParaIdCounter.getNextId(); std::wstring sParaId = XmlUtils::ToString(nId, L"%08X"); GetCurrentStringWriter().WriteString(L""); } else { GetCurrentStringWriter().WriteString(L""); } GetCurrentStringWriter().WriteString(paraWriter.GetData()); GetCurrentStringWriter().WriteString(L""); } else if (c_oSerParType::CommentStart == type) { long nId = 0; READ1_DEF(length, res, this->ReadComment, &nId); if (NULL != m_oFileWriter.m_pComments) { CComment* pComment = m_oFileWriter.m_pComments->get(nId); if (NULL != pComment) { int nNewId = m_oFileWriter.m_pComments->getNextId(pComment->getCount()); pComment->setFormatStart(nNewId); GetCurrentStringWriter().WriteString(pComment->writeRef(std::wstring(_T("")), std::wstring(_T("w:commentRangeStart")), std::wstring(_T("")))); } } } else if (c_oSerParType::CommentEnd == type) { long nId = 0; READ1_DEF(length, res, this->ReadComment, &nId); if (NULL != m_oFileWriter.m_pComments) { CComment* pComment = m_oFileWriter.m_pComments->get(nId); if (NULL != pComment && pComment->bIdFormat) GetCurrentStringWriter().WriteString(pComment->writeRef(std::wstring(_T("")), std::wstring(_T("w:commentRangeEnd")), std::wstring(_T("")))); } } else if (c_oSerParType::Table == type) { m_byteLastElemType = c_oSerParType::Table; GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadDocTable, &m_oDocumentWriter.m_oContent); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerParType::Sdt == type) { SdtWraper oSdt(0); READ1_DEF(length, res, this->ReadSdt, &oSdt); } else if ( c_oSerParType::sectPr == type ) { OOX::Logic::CSectionProperty oSectPr; READ1_DEF(length, res, this->Read_SecPr, &oSectPr); m_oDocumentWriter.m_oSecPr.WriteString(oSectPr.toXML()); } else if ( c_oSerParType::Background == type ) { Background oBackground; READ2_DEF(length, res, this->Read_Background, &oBackground); m_oDocumentWriter.m_oBackground.WriteString(oBackground.Write()); } else if ( c_oSerParType::BookmarkStart == type ) { OOX::Logic::CBookmarkStart oBookmarkStart; READ1_DEF(length, res, this->ReadBookmarkStart, &oBookmarkStart); GetCurrentStringWriter().WriteString(oBookmarkStart.toXML()); } else if ( c_oSerParType::BookmarkEnd == type ) { OOX::Logic::CBookmarkEnd oBookmarkEnd; READ1_DEF(length, res, this->ReadBookmarkEnd, &oBookmarkEnd); GetCurrentStringWriter().WriteString(oBookmarkEnd.toXML()); } else if ( c_oSerParType::MoveFromRangeStart == type ) { OOX::Logic::CMoveFromRangeStart oMoveFromRangeStart; READ1_DEF(length, res, this->ReadMoveFromRangeStart, &oMoveFromRangeStart); GetCurrentStringWriter().WriteString(oMoveFromRangeStart.toXML()); } else if ( c_oSerParType::MoveFromRangeEnd == type ) { OOX::Logic::CMoveFromRangeEnd oMoveToRangeEnd; READ1_DEF(length, res, this->ReadMoveFromRangeEnd, &oMoveToRangeEnd); GetCurrentStringWriter().WriteString(oMoveToRangeEnd.toXML()); } else if ( c_oSerParType::MoveToRangeStart == type ) { OOX::Logic::CMoveToRangeStart oMoveToRangeStart; READ1_DEF(length, res, this->ReadMoveToRangeStart, &oMoveToRangeStart); GetCurrentStringWriter().WriteString(oMoveToRangeStart.toXML()); } else if ( c_oSerParType::MoveToRangeEnd == type ) { OOX::Logic::CMoveToRangeEnd oMoveToRangeEnd; READ1_DEF(length, res, this->ReadMoveToRangeEnd, &oMoveToRangeEnd); GetCurrentStringWriter().WriteString(oMoveToRangeEnd.toXML()); } else if (c_oSerParType::DocParts == type) { GetCurrentStringWriter().WriteString(L""); OOX::Logic::CDocParts oDocParts; READ1_DEF(length, res, this->ReadDocParts, &oDocParts); GetCurrentStringWriter().WriteString(L""); } else if (c_oSerParType::JsaProjectExternal == type) { std::wstring filePath = m_oBufferedStream.GetString3(length); unsigned int lId = 0; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::JsaProject.RelationType(), filePath, L"External", &lId); } else if(c_oSerParType::JsaProject == type) { BYTE* pData = m_oBufferedStream.GetPointer(length); OOX::CPath sJsaProject = OOX::FileTypes::JsaProject.DefaultFileName(); std::wstring filePath = m_oFileWriter.get_document_writer().m_sDir + FILE_SEPARATOR_STR + L"word"+ FILE_SEPARATOR_STR + sJsaProject.GetPath(); NSFile::CFileBinary oFile; oFile.CreateFileW(filePath); oFile.WriteFile(pData, length); oFile.CloseFile(); unsigned int lId = 0; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::JsaProject.RelationType(), sJsaProject.GetPath(), L"", &lId); m_oFileWriter.m_pDrawingConverter->m_pImageManager->m_pContentTypes->AddDefault(sJsaProject.GetExtention(false)); } else if (c_oSerParType::PermStart == type) { OOX::Logic::CPermStart oPerm; READ1_DEF(length, res, this->ReadPermStart, &oPerm); GetCurrentStringWriter().WriteString(oPerm.toXML()); } else if (c_oSerParType::PermEnd == type) { OOX::Logic::CPermEnd oPerm; READ1_DEF(length, res, this->ReadPermEnd, &oPerm); GetCurrentStringWriter().WriteString(oPerm.toXML()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadDocParts(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CDocParts* pDocParts = static_cast(poResult); if (c_oSerGlossary::DocPart == type) { GetCurrentStringWriter().WriteString(L""); pDocParts->m_arrItems.push_back(new OOX::Logic::CDocPart()); READ1_DEF(length, res, this->ReadDocPart, pDocParts->m_arrItems.back()); GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadDocPart(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CDocPart* pDocPart = static_cast(poResult); if (c_oSerGlossary::DocPartPr == type) { pDocPart->m_oDocPartPr = new OOX::Logic::CDocPartPr(); READ1_DEF(length, res, this->ReadDocPartPr, pDocPart->m_oDocPartPr.GetPointer()); GetCurrentStringWriter().WriteString(pDocPart->m_oDocPartPr->toXML()); } else if (c_oSerGlossary::DocPartBody == type) { GetCurrentStringWriter().WriteString(L""); READ1_DEF(length, res, this->ReadDocumentContent, this); GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadDocPartPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CDocPartPr* pDocPartPr = static_cast(poResult); if (c_oSerGlossary::Name == type) { pDocPartPr->m_oName.Init(); pDocPartPr->m_oName->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerGlossary::Style == type) { pDocPartPr->m_oStyle.Init(); pDocPartPr->m_oStyle->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerGlossary::Guid == type) { pDocPartPr->m_oGuid.Init(); pDocPartPr->m_oGuid->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerGlossary::Description == type) { pDocPartPr->m_oDescription.Init(); pDocPartPr->m_oDescription->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerGlossary::CategoryName == type) { if (false == pDocPartPr->m_oCategory.IsInit()) pDocPartPr->m_oCategory.Init(); pDocPartPr->m_oCategory->m_oName.Init(); pDocPartPr->m_oCategory->m_oName->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerGlossary::CategoryGallery == type) { if (false == pDocPartPr->m_oCategory.IsInit()) pDocPartPr->m_oCategory.Init(); pDocPartPr->m_oCategory->m_oGallery.Init(); pDocPartPr->m_oCategory->m_oGallery->m_oVal.Init(); pDocPartPr->m_oCategory->m_oGallery->m_oVal->SetValue((SimpleTypes::EDocPartGallery)m_oBufferedStream.GetUChar()); } else if (c_oSerGlossary::Types == type) { pDocPartPr->m_oTypes = new OOX::Logic::CDocPartTypes(); READ1_DEF(length, res, this->ReadDocPartTypes, pDocPartPr->m_oTypes.GetPointer()); } else if (c_oSerGlossary::Behaviors == type) { pDocPartPr->m_oBehaviors = new OOX::Logic::CDocPartBehaviors(); READ1_DEF(length, res, this->ReadDocPartBehaviors, pDocPartPr->m_oBehaviors.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadDocPartBehaviors(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CDocPartBehaviors* pDocPartBehaviors = static_cast(poResult); if (c_oSerGlossary::Behavior == type) { ComplexTypes::Word::CDocPartBehavior *behavior = new ComplexTypes::Word::CDocPartBehavior(); pDocPartBehaviors->m_arrItems.push_back(behavior); behavior->m_oVal.Init(); behavior->m_oVal->SetValue((SimpleTypes::EDocPartBehavior)m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadDocPartTypes(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CDocPartTypes* pDocPartTypes = static_cast(poResult); if (c_oSerGlossary::Type == type) { ComplexTypes::Word::String *type = new ComplexTypes::Word::String(); pDocPartTypes->m_arrItems.push_back(type); type->m_sVal = m_oBufferedStream.GetString3(length); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadParagraph(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerParType::pPr == type ) { m_oCur_pPr.Clear(); res = oBinary_pPrReader.Read(length, &m_oCur_pPr); if (m_oCur_pPr.IsNoEmpty()) { std::wstring sParaPr = m_oCur_pPr.toXML(); GetCurrentStringWriter().WriteString(sParaPr); } } else if ( c_oSerParType::Content == type ) { READ1_DEF(length, res, this->ReadParagraphContent, NULL); } else if (c_oSerParType::ParaID == type) { m_oParaId.Init(); _INT64 res = m_oBufferedStream.GetULong(); m_oParaId->SetValue(res); } else if (c_oSerParType::TextID == type) { m_oTextId.Init(); _INT64 res = m_oBufferedStream.GetULong(); m_oTextId->SetValue(res); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadParagraphContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerParType::Run == type ) { m_oCur_rPr.Clear(); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadRun, NULL); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSerParType::CommentStart == type ) { long nId = 0; READ1_DEF(length, res, this->ReadComment, &nId); if (NULL != m_oFileWriter.m_pComments) { CComment* pComment = m_oFileWriter.m_pComments->get(nId); if (NULL != pComment) { int nNewId = m_oFileWriter.m_pComments->getNextId(pComment->getCount()); pComment->setFormatStart(nNewId); GetCurrentStringWriter().WriteString(pComment->writeRef(std::wstring(_T("")), std::wstring(_T("w:commentRangeStart")), std::wstring(_T("")))); } } } else if ( c_oSerParType::CommentEnd == type ) { long nId = 0; READ1_DEF(length, res, this->ReadComment, &nId); if (NULL != m_oFileWriter.m_pComments) { CComment* pComment = m_oFileWriter.m_pComments->get(nId); if (NULL != pComment && pComment->bIdFormat) GetCurrentStringWriter().WriteString(pComment->writeRef(std::wstring(_T("")), std::wstring(_T("w:commentRangeEnd")), std::wstring(_T("")))); } } else if ( c_oSerParType::OMathPara == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathOMathPara, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSerParType::OMath == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSerParType::MRun == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathMRun, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSerParType::Hyperlink == type ) { CHyperlink oHyperlink; READ1_DEF(length, res, this->ReadHyperlink, &oHyperlink); oHyperlink.Write(GetCurrentStringWriter()); } else if ( c_oSerParType::FldSimple == type ) { CFldSimple oFldSimple; READ1_DEF(length, res, this->ReadFldSimple, &oFldSimple); oFldSimple.Write(GetCurrentStringWriter()); } else if ( c_oSerParType::Ins == type ) { TrackRevision oTrackRevision; READ1_DEF(length, res, this->ReadDelIns, &oTrackRevision); oTrackRevision.Write(&GetCurrentStringWriter(), _T("w:ins")); } else if ( c_oSerParType::Del == type ) { TrackRevision oTrackRevision; READ1_DEF(length, res, this->ReadDelIns, &oTrackRevision); oTrackRevision.Write(&GetCurrentStringWriter(), _T("w:del")); } else if ( c_oSerParType::MoveFrom == type ) { TrackRevision oTrackRevision; READ1_DEF(length, res, this->ReadDelIns, &oTrackRevision); oTrackRevision.Write(&GetCurrentStringWriter(), _T("w:moveFrom")); } else if ( c_oSerParType::MoveTo == type ) { TrackRevision oTrackRevision; READ1_DEF(length, res, this->ReadDelIns, &oTrackRevision); oTrackRevision.Write(&GetCurrentStringWriter(), _T("w:moveTo")); } else if ( c_oSerParType::MoveFromRangeStart == type ) { OOX::Logic::CMoveFromRangeStart oMoveFromRangeStart; READ1_DEF(length, res, this->ReadMoveFromRangeStart, &oMoveFromRangeStart); GetCurrentStringWriter().WriteString(oMoveFromRangeStart.toXML()); } else if ( c_oSerParType::MoveFromRangeEnd == type ) { OOX::Logic::CMoveFromRangeEnd oMoveToRangeEnd; READ1_DEF(length, res, this->ReadMoveFromRangeEnd, &oMoveToRangeEnd); GetCurrentStringWriter().WriteString(oMoveToRangeEnd.toXML()); } else if ( c_oSerParType::MoveToRangeStart == type ) { OOX::Logic::CMoveToRangeStart oMoveToRangeStart; READ1_DEF(length, res, this->ReadMoveToRangeStart, &oMoveToRangeStart); GetCurrentStringWriter().WriteString(oMoveToRangeStart.toXML()); } else if ( c_oSerParType::MoveToRangeEnd == type ) { OOX::Logic::CMoveToRangeEnd oMoveToRangeEnd; READ1_DEF(length, res, this->ReadMoveToRangeEnd, &oMoveToRangeEnd); GetCurrentStringWriter().WriteString(oMoveToRangeEnd.toXML()); } else if (c_oSerParType::Sdt == type) { SdtWraper oSdt(1); READ1_DEF(length, res, this->ReadSdt, &oSdt); } else if ( c_oSerParType::BookmarkStart == type ) { OOX::Logic::CBookmarkStart oBookmarkStart; READ1_DEF(length, res, this->ReadBookmarkStart, &oBookmarkStart); GetCurrentStringWriter().WriteString(oBookmarkStart.toXML()); } else if ( c_oSerParType::BookmarkEnd == type ) { OOX::Logic::CBookmarkEnd oBookmarkEnd; READ1_DEF(length, res, this->ReadBookmarkEnd, &oBookmarkEnd); GetCurrentStringWriter().WriteString(oBookmarkEnd.toXML()); } else if (c_oSerParType::PermStart == type) { OOX::Logic::CPermStart oPerm; READ1_DEF(length, res, this->ReadPermStart, &oPerm); GetCurrentStringWriter().WriteString(oPerm.toXML()); } else if (c_oSerParType::PermEnd == type) { OOX::Logic::CPermEnd oPerm; READ1_DEF(length, res, this->ReadPermEnd, &oPerm); GetCurrentStringWriter().WriteString(oPerm.toXML()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadDelIns(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; TrackRevision* pTrackRevision = static_cast(poResult); READ1_TRACKREV(type, length, pTrackRevision) else if ( c_oSerProp_RevisionType::Content == type ) { pTrackRevision->content = new NSStringUtils::CStringBuilder(); NSStringUtils::CStringBuilder* pPrevWriter = m_pCurWriter; m_pCurWriter = pTrackRevision->content; READ1_DEF(length, res, this->ReadParagraphContent, NULL); m_pCurWriter = pPrevWriter; } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMoveFromRangeStart(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CMoveFromRangeStart* pMoveFromRangeStart = static_cast(poResult); if (c_oSerMoveRange::Author == type) { pMoveFromRangeStart->m_sAuthor.Init(); pMoveFromRangeStart->m_sAuthor->append(m_oBufferedStream.GetString3(length)); } else if (c_oSerMoveRange::ColFirst == type) { pMoveFromRangeStart->m_oColFirst.Init(); pMoveFromRangeStart->m_oColFirst->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerMoveRange::ColLast == type) { pMoveFromRangeStart->m_oColLast.Init(); pMoveFromRangeStart->m_oColLast->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerMoveRange::Date == type) { std::wstring strValue = m_oBufferedStream.GetString3(length); pMoveFromRangeStart->m_oDate.Init(); pMoveFromRangeStart->m_oDate->SetValue(strValue); } else if (c_oSerMoveRange::DisplacedByCustomXml == type) { pMoveFromRangeStart->m_oDisplacedByCustomXml.Init(); pMoveFromRangeStart->m_oDisplacedByCustomXml->SetValue((SimpleTypes::EDisplacedByCustomXml)m_oBufferedStream.GetUChar()); } else if (c_oSerMoveRange::Id == type) { pMoveFromRangeStart->m_oId.Init(); pMoveFromRangeStart->m_oId->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerMoveRange::Name == type) { pMoveFromRangeStart->m_sName.Init(); pMoveFromRangeStart->m_sName->append(m_oBufferedStream.GetString3(length)); } else if (c_oSerMoveRange::UserId == type) { pMoveFromRangeStart->m_sUserId.Init(); pMoveFromRangeStart->m_sUserId->append(m_oBufferedStream.GetString3(length)); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMoveToRangeStart(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CMoveToRangeStart* pMoveToRangeStart = static_cast(poResult); if (c_oSerMoveRange::Author == type) { pMoveToRangeStart->m_sAuthor.Init(); pMoveToRangeStart->m_sAuthor->append(m_oBufferedStream.GetString3(length)); } else if (c_oSerMoveRange::ColFirst == type) { pMoveToRangeStart->m_oColFirst.Init(); pMoveToRangeStart->m_oColFirst->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerMoveRange::ColLast == type) { pMoveToRangeStart->m_oColLast.Init(); pMoveToRangeStart->m_oColLast->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerMoveRange::Date == type) { std::wstring strValue = m_oBufferedStream.GetString3(length); pMoveToRangeStart->m_oDate.Init(); pMoveToRangeStart->m_oDate->SetValue(strValue); } else if (c_oSerMoveRange::DisplacedByCustomXml == type) { pMoveToRangeStart->m_oDisplacedByCustomXml.Init(); pMoveToRangeStart->m_oDisplacedByCustomXml->SetValue((SimpleTypes::EDisplacedByCustomXml)m_oBufferedStream.GetUChar()); } else if (c_oSerMoveRange::Id == type) { pMoveToRangeStart->m_oId.Init(); pMoveToRangeStart->m_oId->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerMoveRange::Name == type) { pMoveToRangeStart->m_sName.Init(); pMoveToRangeStart->m_sName->append(m_oBufferedStream.GetString3(length)); } else if (c_oSerMoveRange::UserId == type) { pMoveToRangeStart->m_sUserId.Init(); pMoveToRangeStart->m_sUserId->append(m_oBufferedStream.GetString3(length)); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMoveFromRangeEnd(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CMoveFromRangeEnd* pMoveFromRangeEnd = static_cast(poResult); if (c_oSerMoveRange::DisplacedByCustomXml == type) { pMoveFromRangeEnd->m_oDisplacedByCustomXml.Init(); pMoveFromRangeEnd->m_oDisplacedByCustomXml->SetValue((SimpleTypes::EDisplacedByCustomXml)m_oBufferedStream.GetUChar()); } else if (c_oSerMoveRange::Id == type) { pMoveFromRangeEnd->m_oId.Init(); pMoveFromRangeEnd->m_oId->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMoveToRangeEnd(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CMoveToRangeEnd* pMoveToRangeEnd = static_cast(poResult); if (c_oSerMoveRange::DisplacedByCustomXml == type) { pMoveToRangeEnd->m_oDisplacedByCustomXml.Init(); pMoveToRangeEnd->m_oDisplacedByCustomXml->SetValue((SimpleTypes::EDisplacedByCustomXml)m_oBufferedStream.GetUChar()); } else if (c_oSerMoveRange::Id == type) { pMoveToRangeEnd->m_oId.Init(); pMoveToRangeEnd->m_oId->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadFldChar(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CFldChar* pFldChar = static_cast(poResult); if ( c_oSer_FldSimpleType::CharType == type ) { pFldChar->m_oFldCharType.Init(); pFldChar->m_oFldCharType->SetValue((SimpleTypes::EFldCharType)m_oBufferedStream.GetUChar()); } else if (c_oSer_FldSimpleType::FFData == type) { pFldChar->m_oFFData.Init(); READ1_DEF(length, res, this->ReadFFData, pFldChar->m_oFFData.GetPointer()); } else if (c_oSer_FldSimpleType::PrivateData == type) { pFldChar->m_sPrivateData = m_oBufferedStream.GetString3(length); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadFldSimple(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CFldSimple* pFldSimple = static_cast(poResult); if (c_oSer_FldSimpleType::Instr == type) { pFldSimple->sInstr = m_oBufferedStream.GetString3(length); } else if ( c_oSer_FldSimpleType::Content == type ) { NSStringUtils::CStringBuilder* pPrevWriter = m_pCurWriter; m_pCurWriter = &pFldSimple->writer; READ1_DEF(length, res, this->ReadParagraphContent, NULL); m_pCurWriter = pPrevWriter; } else if ( c_oSer_FldSimpleType::FFData == type ) { OOX::Logic::CFFData oFFData; READ1_DEF(length, res, this->ReadFFData, &oFFData); pFldSimple->writer.WriteString(oFFData.toXML()); } else if (c_oSer_FldSimpleType::PrivateData == type) { std::wstring sVal = m_oBufferedStream.GetString3(length); pFldSimple->writer.WriteString(L"" + sVal + L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadFFData(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CFFData* pFFData = static_cast(poResult); if ( c_oSerFFData::CalcOnExit == type ) { pFFData->m_oCalcOnExit.Init(); pFFData->m_oCalcOnExit->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSerFFData::CheckBox == type ) { pFFData->m_oCheckBox.Init(); READ1_DEF(length, res, this->ReadFFCheckBox, pFFData->m_oCheckBox.GetPointer()); } else if ( c_oSerFFData::DDList == type ) { pFFData->m_oDDList.Init(); READ1_DEF(length, res, this->ReadDDList, pFFData->m_oDDList.GetPointer()); } else if ( c_oSerFFData::Enabled == type ) { pFFData->m_oEnabled.Init(); pFFData->m_oEnabled->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSerFFData::EntryMacro == type ) { std::wstring sVal = m_oBufferedStream.GetString3(length); pFFData->m_oEntryMacro.Init(); pFFData->m_oEntryMacro->m_oVal.Init(); pFFData->m_oEntryMacro->m_oVal->SetValue(sVal); } else if ( c_oSerFFData::ExitMacro == type ) { std::wstring sVal = m_oBufferedStream.GetString3(length); pFFData->m_oExitMacro.Init(); pFFData->m_oExitMacro->m_oVal.Init(); pFFData->m_oExitMacro->m_oVal->SetValue(sVal); } else if ( c_oSerFFData::HelpText == type ) { pFFData->m_oHelpText.Init(); READ1_DEF(length, res, this->ReadFFHelpText, pFFData->m_oHelpText.GetPointer()); } else if ( c_oSerFFData::Label == type ) { pFFData->m_oLabel.Init(); pFFData->m_oLabel->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSerFFData::Name == type ) { std::wstring sVal = m_oBufferedStream.GetString3(length); pFFData->m_oName.Init(); pFFData->m_oName->m_oVal.Init(); pFFData->m_oName->m_oVal->SetValue(sVal); } else if ( c_oSerFFData::StatusText == type ) { pFFData->m_oStatusText.Init(); READ1_DEF(length, res, this->ReadFFStatusText, pFFData->m_oStatusText.GetPointer()); } else if ( c_oSerFFData::TabIndex == type ) { pFFData->m_oTabIndex.Init(); pFFData->m_oTabIndex->m_oVal.Init(); pFFData->m_oTabIndex->m_oVal->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerFFData::TextInput == type ) { pFFData->m_oTextInput.Init(); READ1_DEF(length, res, this->ReadTextInput, pFFData->m_oTextInput.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadFFCheckBox(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CFFCheckBox* pFFCheckBox = static_cast(poResult); if ( c_oSerFFData::CBChecked == type ) { pFFCheckBox->m_oChecked.Init(); pFFCheckBox->m_oChecked->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSerFFData::CBDefault == type ) { pFFCheckBox->m_oDefault.Init(); pFFCheckBox->m_oDefault->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if ( c_oSerFFData::CBSize == type ) { pFFCheckBox->m_oSize.Init(); pFFCheckBox->m_oSize->m_oVal.Init(); pFFCheckBox->m_oSize->m_oVal->FromHps(m_oBufferedStream.GetULong()); } else if ( c_oSerFFData::CBSizeAuto == type ) { pFFCheckBox->m_oSizeAuto.Init(); pFFCheckBox->m_oSizeAuto->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadDDList(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CFFDDList* pDDList = static_cast(poResult); if ( c_oSerFFData::DLDefault == type ) { pDDList->m_oDefault.Init(); pDDList->m_oDefault->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSerFFData::DLResult == type ) { pDDList->m_oResult.Init(); pDDList->m_oResult->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSerFFData::DLListEntry == type ) { ComplexTypes::Word::String* pVal = new ComplexTypes::Word::String(); pVal->m_sVal = m_oBufferedStream.GetString3(length); pDDList->m_arrListEntry.push_back(pVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadFFHelpText(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CFFHelpText* pHelpText = static_cast(poResult); if ( c_oSerFFData::HTType == type ) { pHelpText->m_oType.Init(); pHelpText->m_oType->SetValue((SimpleTypes::EInfoTextType)m_oBufferedStream.GetUChar()); } else if ( c_oSerFFData::HTVal == type ) { std::wstring sVal = m_oBufferedStream.GetString3(length); pHelpText->m_oVal.Init(); pHelpText->m_oVal->SetValue(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadFFStatusText(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CFFStatusText* pStatusText = static_cast(poResult); if ( c_oSerFFData::HTType == type ) { pStatusText->m_oType.Init(); pStatusText->m_oType->SetValue((SimpleTypes::EInfoTextType)m_oBufferedStream.GetUChar()); } else if ( c_oSerFFData::HTVal == type ) { std::wstring sVal = m_oBufferedStream.GetString3(length); pStatusText->m_oVal.Init(); pStatusText->m_oVal->SetValue(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadTextInput(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CFFTextInput* pTextInput = static_cast(poResult); if ( c_oSerFFData::TIDefault == type ) { pTextInput->m_oDefault.Init(); pTextInput->m_oDefault->m_sVal = m_oBufferedStream.GetString3(length); } else if ( c_oSerFFData::TIFormat == type ) { pTextInput->m_oFormat.Init(); pTextInput->m_oFormat->m_sVal = m_oBufferedStream.GetString3(length); } else if ( c_oSerFFData::TIMaxLength == type ) { pTextInput->m_oMaxLength.Init(); pTextInput->m_oMaxLength->m_oVal = m_oBufferedStream.GetLong(); } else if ( c_oSerFFData::TIType == type ) { pTextInput->m_oType.Init(); pTextInput->m_oType->m_oVal.Init(); pTextInput->m_oType->m_oVal->SetValue((SimpleTypes::EFFTextType)m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadBookmarkStart(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CBookmarkStart* pBookmarkStart = static_cast(poResult); if ( c_oSerBookmark::Id == type ) { pBookmarkStart->m_oId.Init(); pBookmarkStart->m_oId->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerBookmark::Name == type ) { pBookmarkStart->m_sName.Init(); pBookmarkStart->m_sName->append(m_oBufferedStream.GetString3(length)); } else if ( c_oSerBookmark::DisplacedByCustomXml == type ) { pBookmarkStart->m_oDisplacedByCustomXml.Init(); pBookmarkStart->m_oDisplacedByCustomXml->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if ( c_oSerBookmark::ColFirst == type ) { pBookmarkStart->m_oColFirst.Init(); pBookmarkStart->m_oColFirst->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerBookmark::ColLast == type ) { pBookmarkStart->m_oColLast.Init(); pBookmarkStart->m_oColLast->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadBookmarkEnd(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CBookmarkEnd* pBookmarkEnd = static_cast(poResult); if ( c_oSerBookmark::Id == type ) { pBookmarkEnd->m_oId.Init(); pBookmarkEnd->m_oId->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerBookmark::DisplacedByCustomXml == type ) { pBookmarkEnd->m_oDisplacedByCustomXml.Init(); pBookmarkEnd->m_oDisplacedByCustomXml->SetValue((SimpleTypes::EDisplacedByCustomXml)m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadPermStart(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CPermStart* pPerm = static_cast(poResult); if (c_oSerPermission::Id == type) { pPerm->m_sId.Init(); *pPerm->m_sId = m_oBufferedStream.GetString3(length); } else if (c_oSerPermission::DisplacedByCustomXml == type) { pPerm->m_oDisplacedByCustomXml.Init(); pPerm->m_oDisplacedByCustomXml->SetValueFromByte(m_oBufferedStream.GetUChar()); } else if (c_oSerPermission::ColFirst == type) { pPerm->m_oColFirst.Init(); pPerm->m_oColFirst->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerPermission::ColLast == type) { pPerm->m_oColLast.Init(); pPerm->m_oColLast->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerPermission::Ed == type) { pPerm->m_sEd.Init(); *pPerm->m_sEd = m_oBufferedStream.GetString3(length); } else if (c_oSerPermission::EdGroup == type) { pPerm->m_oEdGrp.Init(); pPerm->m_oEdGrp->SetValueFromByte(m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadPermEnd(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Logic::CPermEnd* pPerm = static_cast(poResult); if (c_oSerPermission::Id == type) { pPerm->m_sId.Init(); *pPerm->m_sId = m_oBufferedStream.GetString3(length); } else if (c_oSerPermission::DisplacedByCustomXml == type) { pPerm->m_oDisplacedByCustomXml.Init(); pPerm->m_oDisplacedByCustomXml->SetValueFromByte(m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadHyperlink(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CHyperlink* pHyperlink = static_cast(poResult); if ( c_oSer_HyperlinkType::Link == type ) pHyperlink->sLink = m_oBufferedStream.GetString3(length); else if ( c_oSer_HyperlinkType::Anchor == type ) pHyperlink->sAnchor = m_oBufferedStream.GetString3(length); else if ( c_oSer_HyperlinkType::Tooltip == type ) pHyperlink->sTooltip = m_oBufferedStream.GetString3(length); else if ( c_oSer_HyperlinkType::History == type ) { pHyperlink->bHistory = true; pHyperlink->History = m_oBufferedStream.GetBool(); } else if ( c_oSer_HyperlinkType::DocLocation == type ) pHyperlink->sDocLocation = m_oBufferedStream.GetString3(length); else if ( c_oSer_HyperlinkType::TgtFrame == type ) pHyperlink->sTgtFrame = m_oBufferedStream.GetString3(length); else if ( c_oSer_HyperlinkType::Content == type ) { NSStringUtils::CStringBuilder* pPrevWriter = m_pCurWriter; m_pCurWriter = &pHyperlink->writer; READ1_DEF(length, res, this->ReadParagraphContent, NULL); if (!pHyperlink->sLink.empty()) { unsigned int rId; std::wstring sHref = XmlUtils::EncodeXmlString(pHyperlink->sLink); m_oFileWriter.m_pDrawingConverter->WriteRels(std::wstring(_T("http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink")), sHref, std::wstring(L"External"), &rId); pHyperlink->rId = L"rId" + std::to_wstring(rId); } m_pCurWriter = pPrevWriter; } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathLong(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) LONG lVal = m_oBufferedStream.GetLong(); else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathArgOut(long length) { int res = c_oSerConstants::ReadOk; READ1_DEF(length, res, this->ReadMathArg, NULL); return res; } int Binary_DocumentTableReader::ReadMathArg(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Acc == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathAcc, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::ArgPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArgPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Bar == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathBar, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::BorderBox == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathBorderBox, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Box == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathBox, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Delimiter == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathDelimiter, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Del == type ) { TrackRevision oTrackRevision; READ1_DEF(length, res, this->ReadDelIns, &oTrackRevision); oTrackRevision.Write(&GetCurrentStringWriter(), _T("w:del")); } else if ( c_oSer_OMathContentType::EqArr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathEqArr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Fraction == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathFraction, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Func == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathFunc, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::GroupChr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathGroupChr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Ins == type ) { TrackRevision oTrackRevision; READ1_DEF(length, res, this->ReadDelIns, &oTrackRevision); oTrackRevision.Write(&GetCurrentStringWriter(), _T("w:ins")); } else if ( c_oSer_OMathContentType::LimLow == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathLimLow, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::LimUpp == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathLimUpp, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Matrix == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathMatrix, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Nary == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathNary, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::OMath == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::OMathPara == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathOMathPara, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Phant == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathPhant, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::MRun == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathMRun, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Rad == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathRad, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::SPre == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathSPre, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::SSub == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathSSub, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::SSubSup == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathSSubSup, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::SSup == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathSSup, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::BookmarkStart == type ) { OOX::Logic::CBookmarkStart oBookmarkStart; READ1_DEF(length, res, this->ReadBookmarkStart, &oBookmarkStart); GetCurrentStringWriter().WriteString(oBookmarkStart.toXML()); } else if ( c_oSer_OMathContentType::BookmarkEnd == type ) { OOX::Logic::CBookmarkEnd oBookmarkEnd; READ1_DEF(length, res, this->ReadBookmarkEnd, &oBookmarkEnd); GetCurrentStringWriter().WriteString(oBookmarkEnd.toXML()); } else if ( c_oSer_OMathContentType::MoveFromRangeStart == type ) { OOX::Logic::CMoveFromRangeStart oMoveFromRangeStart; READ1_DEF(length, res, this->ReadMoveFromRangeStart, &oMoveFromRangeStart); GetCurrentStringWriter().WriteString(oMoveFromRangeStart.toXML()); } else if ( c_oSer_OMathContentType::MoveFromRangeEnd == type ) { OOX::Logic::CMoveFromRangeEnd oMoveToRangeEnd; READ1_DEF(length, res, this->ReadMoveFromRangeEnd, &oMoveToRangeEnd); GetCurrentStringWriter().WriteString(oMoveToRangeEnd.toXML()); } else if ( c_oSer_OMathContentType::MoveToRangeStart == type ) { OOX::Logic::CMoveToRangeStart oMoveToRangeStart; READ1_DEF(length, res, this->ReadMoveToRangeStart, &oMoveToRangeStart); GetCurrentStringWriter().WriteString(oMoveToRangeStart.toXML()); } else if ( c_oSer_OMathContentType::MoveToRangeEnd == type ) { OOX::Logic::CMoveToRangeEnd oMoveToRangeEnd; READ1_DEF(length, res, this->ReadMoveToRangeEnd, &oMoveToRangeEnd); GetCurrentStringWriter().WriteString(oMoveToRangeEnd.toXML()); } else if (c_oSer_OMathContentType::PermStart == type) { OOX::Logic::CPermStart oPerm; READ1_DEF(length, res, this->ReadPermStart, &oPerm); GetCurrentStringWriter().WriteString(oPerm.toXML()); } else if (c_oSer_OMathContentType::PermEnd == type) { OOX::Logic::CPermEnd oPerm; READ1_DEF(length, res, this->ReadPermEnd, &oPerm); GetCurrentStringWriter().WriteString(oPerm.toXML()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathAcc(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::AccPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathAccPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathAccPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::Chr == type ) { READ2_DEF(length, res, this->ReadMathChr, poResult); } else if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathAln(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathAlnScr(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathArgPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::ArgSz == type ) { READ2_DEF(length, res, this->ReadMathArgSz, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathArgSz(BYTE type, long length, void* poResult)//GetLong { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { LONG lVal; lVal = m_oBufferedStream.GetLong(); std::wstring sVal(_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathBar(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::BarPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathBarPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathBarPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::Pos == type ) { READ2_DEF(length, res, this->ReadMathPos, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathBaseJc(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { BYTE BaseJc; std::wstring sBaseJc (_T("top")); BaseJc = m_oBufferedStream.GetUChar(); switch(BaseJc) { case 0: sBaseJc = _T("bottom");break; case 1: sBaseJc = _T("center");break; case 2: sBaseJc = _T("inline");break; case 3: sBaseJc = _T("inside");break; case 4: sBaseJc = _T("outside");break; case 5: sBaseJc = _T("top"); break; } GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathBegChr(BYTE type, long length, void* poResult) //ReadString { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { std::wstring sChr = GetMathText (length); std::wstring sVal; sVal += (_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathBorderBox(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::BorderBoxPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathBorderBoxPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathBorderBoxPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::HideBot == type ) { READ2_DEF(length, res, this->ReadMathHideBot, poResult); } else if ( c_oSer_OMathBottomNodesType::HideLeft == type ) { READ2_DEF(length, res, this->ReadMathHideLeft, poResult); } else if ( c_oSer_OMathBottomNodesType::HideRight == type ) { READ2_DEF(length, res, this->ReadMathHideRight, poResult); } else if ( c_oSer_OMathBottomNodesType::HideTop == type ) { READ2_DEF(length, res, this->ReadMathHideTop, poResult); } else if ( c_oSer_OMathBottomNodesType::StrikeBLTR == type ) { READ2_DEF(length, res, this->ReadMathStrikeBLTR, poResult); } else if ( c_oSer_OMathBottomNodesType::StrikeH == type ) { READ2_DEF(length, res, this->ReadMathStrikeH, poResult); } else if ( c_oSer_OMathBottomNodesType::StrikeTLBR == type ) { READ2_DEF(length, res, this->ReadMathStrikeTLBR, poResult); } else if ( c_oSer_OMathBottomNodesType::StrikeV == type ) { READ2_DEF(length, res, this->ReadMathStrikeV, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathBox(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::BoxPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathBoxPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathBoxPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::Aln == type ) { READ2_DEF(length, res, this->ReadMathAln, poResult); } else if ( c_oSer_OMathBottomNodesType::Brk == type ) { READ2_DEF(length, res, this->ReadMathBrk, poResult); } else if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::Diff == type ) { READ2_DEF(length, res, this->ReadMathDiff, poResult); } else if ( c_oSer_OMathBottomNodesType::NoBreak == type ) { READ2_DEF(length, res, this->ReadMathNoBreak, poResult); } else if ( c_oSer_OMathBottomNodesType::OpEmu == type ) { READ2_DEF(length, res, this->ReadMathOpEmu, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathBrk(BYTE type, long length, void* poResult)//GetLong { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::AlnAt == type ) { LONG lVal; lVal = m_oBufferedStream.GetLong(); std::wstring sVal(_T("")); GetCurrentStringWriter().WriteString(sVal); } else if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal(_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathCGp(BYTE type, long length, void* poResult)//GetLong { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { LONG lVal; lVal = m_oBufferedStream.GetLong(); std::wstring sVal(_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathCGpRule(BYTE type, long length, void* poResult)//GetUChar { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { LONG lVal; lVal = m_oBufferedStream.GetLong(); std::wstring sVal(_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathChr(BYTE type, long length, void* poResult)//ReadString { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { std::wstring sChr = GetMathText (length); std::wstring sVal; sVal += (_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathCount(BYTE type, long length, void* poResult)//GetLong { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { LONG lVal; lVal = m_oBufferedStream.GetLong(); std::wstring sVal(_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathCSp(BYTE type, long length, void* poResult)//GetLong { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { LONG lVal; lVal = m_oBufferedStream.GetLong(); std::wstring sVal(_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathCtrlPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerRunType::rPr == type ) { m_oMath_rPr.Clear(); res = oBinary_rPrReader.Read(length, &m_oMath_rPr); if (m_oMath_rPr.IsNoEmpty()) GetCurrentStringWriter().WriteString(m_oMath_rPr.toXML()); } else if ( c_oSerRunType::arPr == type ) { PPTX::Logic::RunProperties rPr; m_oBufferedStream.Skip(1);//skip type rPr.fromPPTY(&m_oBufferedStream); rPr.m_name = L"a:rPr"; //todo use one writer NSBinPptxRW::CXmlWriter oWriter; rPr.toXmlWriter(&oWriter); GetCurrentStringWriter().WriteString(oWriter.GetXmlString()); } else if ( c_oSerRunType::del == type ) { ComplexTypes::Word::CTrackChange del; READ1_DEF(length, res, this->ReadMathCtrlPrDelIns, &del); GetCurrentStringWriter().WriteString(del.ValNode(L"w:del")); } else if ( c_oSerRunType::ins == type ) { ComplexTypes::Word::CTrackChange ins; READ1_DEF(length, res, this->ReadMathCtrlPrDelIns, &ins); GetCurrentStringWriter().WriteString(ins.ValNode(L"w:ins")); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathCtrlPrDelIns(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; ComplexTypes::Word::CTrackChange* trackChange = static_cast(poResult); READ1_TRACKREV_2(type, length, trackChange) else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathDelimiter(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::DelimiterPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathDelimiterPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathDegHide(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { //word writes "1"(excel, powerpoint write "on"). "on" is correct for word, libre, onedrive, gdrive bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathDiff(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathDelimiterPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::Column == type ) { READ2_DEF(length, res, this->ReadMathLong, poResult); } else if ( c_oSer_OMathBottomNodesType::BegChr == type ) { READ2_DEF(length, res, this->ReadMathBegChr, poResult); } else if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::EndChr == type ) { READ2_DEF(length, res, this->ReadMathEndChr, poResult); } else if ( c_oSer_OMathBottomNodesType::Grow == type ) { READ2_DEF(length, res, this->ReadMathGrow, poResult); } else if ( c_oSer_OMathBottomNodesType::SepChr == type ) { READ2_DEF(length, res, this->ReadMathSepChr, poResult); } else if ( c_oSer_OMathBottomNodesType::Shp == type ) { READ2_DEF(length, res, this->ReadMathShp, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathEndChr(BYTE type, long length, void* poResult)//ReadString { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { std::wstring sChr = GetMathText (length); std::wstring sVal; sVal += (_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathEqArr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::EqArrPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathEqArrPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathEqArrPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::Row == type ) { READ2_DEF(length, res, this->ReadMathLong, poResult); } else if ( c_oSer_OMathBottomNodesType::BaseJc == type ) { READ2_DEF(length, res, this->ReadMathBaseJc, poResult); } else if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::MaxDist == type ) { READ2_DEF(length, res, this->ReadMathMaxDist, poResult); } else if ( c_oSer_OMathBottomNodesType::ObjDist == type ) { READ2_DEF(length, res, this->ReadMathObjDist, poResult); } else if ( c_oSer_OMathBottomNodesType::RSp == type ) { READ2_DEF(length, res, this->ReadMathRSp, poResult); } else if ( c_oSer_OMathBottomNodesType::RSpRule == type ) { READ2_DEF(length, res, this->ReadMathRSpRule, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathFraction(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Den == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::FPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathFPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Num == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathFPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::Type == type ) { READ2_DEF(length, res, this->ReadMathType, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathFunc(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::FName == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::FuncPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathFuncPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathFuncPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathGroupChr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::GroupChrPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathGroupChrPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathGroupChrPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::Chr == type ) { READ2_DEF(length, res, this->ReadMathChr, poResult); } else if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::Pos == type ) { READ2_DEF(length, res, this->ReadMathPos, poResult); } else if ( c_oSer_OMathBottomNodesType::VertJc == type ) { READ2_DEF(length, res, this->ReadMathVertJc, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathGrow(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"on\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathHideBot(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathHideLeft(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathHideRight(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathHideTop(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathMJc(BYTE type, long length, void* poResult)//GetUChar { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { BYTE Jc; std::wstring sJc (_T("centerGroup")); Jc = m_oBufferedStream.GetUChar(); switch(Jc) { case 0: sJc = _T("center");break; case 1: sJc = _T("centerGroup");break; case 2: sJc = _T("left");break; case 3: sJc = _T("right");break; } GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathLimLoc(BYTE type, long length, void* poResult)//GetUChar { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { BYTE LimLoc; std::wstring sLimLoc (_T("subSup")); LimLoc = m_oBufferedStream.GetUChar(); switch(LimLoc) { case 0: sLimLoc = _T("subSup");break; case 1: sLimLoc = _T("undOvr");break; } GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathLimLow(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Lim == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::LimLowPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathLimLowPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathLimLowPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathLimUpp(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Lim == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::LimUppPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathLimUppPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathLimUppPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathLit(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathMatrix(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::MPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathMPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Mr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathMr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathMaxDist(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathMc(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::McPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathMcPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathMcJc(BYTE type, long length, void* poResult)//GetUChar { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { BYTE McJc; std::wstring sMcJc (_T("center")); McJc = m_oBufferedStream.GetUChar(); switch(McJc) { case 0: sMcJc = _T("center"); break; case 1: sMcJc = _T("inside"); break; case 2: sMcJc = _T("left"); break; case 3: sMcJc = _T("outside"); break; case 4: sMcJc = _T("right"); break; } GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathMcPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::Count == type ) { READ2_DEF(length, res, this->ReadMathCount, poResult); } else if ( c_oSer_OMathBottomNodesType::McJc == type ) { READ2_DEF(length, res, this->ReadMathMcJc, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathMcs(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Mc == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathMc, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathMPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::Row == type ) { READ2_DEF(length, res, this->ReadMathLong, poResult); } else if ( c_oSer_OMathBottomNodesType::Column == type ) { READ2_DEF(length, res, this->ReadMathLong, poResult); } else if ( c_oSer_OMathBottomNodesType::BaseJc == type ) { READ2_DEF(length, res, this->ReadMathBaseJc, poResult); } else if ( c_oSer_OMathBottomNodesType::CGp == type ) { READ2_DEF(length, res, this->ReadMathCGp, poResult); } else if ( c_oSer_OMathBottomNodesType::CGpRule == type ) { READ2_DEF(length, res, this->ReadMathCGpRule, poResult); } else if ( c_oSer_OMathBottomNodesType::CSp == type ) { READ2_DEF(length, res, this->ReadMathCSp, poResult); } else if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::Mcs == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathMcs, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::PlcHide == type ) { READ2_DEF(length, res, this->ReadMathPlcHide, poResult); } else if ( c_oSer_OMathBottomNodesType::RSp == type ) { READ2_DEF(length, res, this->ReadMathRSp, poResult); } else if ( c_oSer_OMathBottomNodesType::RSpRule == type ) { READ2_DEF(length, res, this->ReadMathRSpRule, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathMr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathNary(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::NaryPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathNaryPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Sub == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Sup == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathNaryPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::Chr == type ) { READ2_DEF(length, res, this->ReadMathChr, poResult); } else if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::Grow == type ) { READ2_DEF(length, res, this->ReadMathGrow, poResult); } else if ( c_oSer_OMathBottomNodesType::LimLoc == type ) { READ2_DEF(length, res, this->ReadMathLimLoc, poResult); } else if ( c_oSer_OMathBottomNodesType::SubHide == type ) { READ2_DEF(length, res, this->ReadMathSubHide, poResult); } else if ( c_oSer_OMathBottomNodesType::SupHide == type ) { READ2_DEF(length, res, this->ReadMathSupHide, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathNoBreak(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathNor(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathObjDist(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathOMathParaOut(long length) { int res = c_oSerConstants::ReadOk; READ1_DEF(length, res, this->ReadMathOMathPara, NULL); return res; } int Binary_DocumentTableReader::ReadMathOMathPara(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::OMath == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::OMathParaPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathOMathParaPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Run == type ) { m_oCur_rPr.Clear(); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadRun, NULL); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathOMathParaPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::MJc == type ) { READ2_DEF(length, res, this->ReadMathMJc, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathOpEmu(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathPhant(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::PhantPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathPhantPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathPhantPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::Show == type ) { READ2_DEF(length, res, this->ReadMathShow, poResult); } else if ( c_oSer_OMathBottomNodesType::Transp == type ) { READ2_DEF(length, res, this->ReadMathTransp, poResult); } else if ( c_oSer_OMathBottomNodesType::ZeroAsc == type ) { READ2_DEF(length, res, this->ReadMathZeroAsc, poResult); } else if ( c_oSer_OMathBottomNodesType::ZeroDesc == type ) { READ2_DEF(length, res, this->ReadMathZeroDesc, poResult); } else if ( c_oSer_OMathBottomNodesType::ZeroWid == type ) { READ2_DEF(length, res, this->ReadMathZeroWid, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathPlcHide(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathPos(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { BYTE Pos; std::wstring sPos(_T("bot")); Pos = m_oBufferedStream.GetUChar(); switch(Pos) { case 0: sPos = _T("bot");break; case 1: sPos = _T("top");break; } GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } std::wstring Binary_DocumentTableReader::GetMathText (long length) { std::wstring strVal(m_oBufferedStream.GetString3(length)); return XmlUtils::EncodeXmlString(strVal, true); } int Binary_DocumentTableReader::ReadMathText(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { std::wstring sText = GetMathText (length); GetCurrentStringWriter().WriteString(sText); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathMRun(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::MText == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ2_DEF(length, res, this->ReadMathText, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::RPr == type ) { m_oMath_rPr.Clear(); res = oBinary_rPrReader.Read(length, &m_oMath_rPr); if (m_oMath_rPr.IsNoEmpty()) GetCurrentStringWriter().WriteString(m_oMath_rPr.toXML()); } else if ( c_oSer_OMathContentType::MRPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathMRPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::ARPr == type ) { PPTX::Logic::RunProperties rPr; m_oBufferedStream.Skip(1);//skip type rPr.fromPPTY(&m_oBufferedStream); rPr.m_name = L"a:rPr"; //todo use one writer NSBinPptxRW::CXmlWriter oWriter; rPr.toXmlWriter(&oWriter); GetCurrentStringWriter().WriteString(oWriter.GetXmlString()); } else if (c_oSer_OMathContentType::pagebreak == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSer_OMathContentType::linebreak == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSer_OMathContentType::columnbreak == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSer_OMathContentType::Del == type) { TrackRevision oTrackRevision; READ1_DEF(length, res, this->ReadMathInsDel, &oTrackRevision); oTrackRevision.Write(&GetCurrentStringWriter(), _T("w:del")); } else if (c_oSer_OMathContentType::Ins == type) { TrackRevision oTrackRevision; READ1_DEF(length, res, this->ReadMathInsDel, &oTrackRevision); oTrackRevision.Write(&GetCurrentStringWriter(), _T("w:ins")); } else if (c_oSer_OMathContentType::AnnotationRef == type) { OOX::Logic::CAnnotationRef oAnnotationRef; GetCurrentStringWriter().WriteString(oAnnotationRef.toXML()); } else if (c_oSer_OMathContentType::CommentReference == type) { long nId = 0; READ1_DEF(length, res, this->ReadComment, &nId); if (NULL != m_oFileWriter.m_pComments) { CComment* pComment = m_oFileWriter.m_pComments->get(nId); if (NULL != pComment) // могут быть и без start/end { GetCurrentStringWriter().WriteString(pComment->writeRef(std::wstring(_T("")), std::wstring(_T("w:commentReference")), std::wstring(_T("")))); } } } else if (c_oSer_OMathContentType::Cr == type) { OOX::Logic::CCr oCr; GetCurrentStringWriter().WriteString(oCr.toXML()); } else if (c_oSer_OMathContentType::EndnoteRef == type) { OOX::Logic::CEndnoteRef oEndnoteRef; GetCurrentStringWriter().WriteString(oEndnoteRef.toXML()); } else if (c_oSer_OMathContentType::FootnoteRef == type) { OOX::Logic::CFootnoteRef oFootnoteRef; GetCurrentStringWriter().WriteString(oFootnoteRef.toXML()); } else if (c_oSer_OMathContentType::EndnoteReference == type) { OOX::Logic::CEndnoteReference oEndnoteReference; READ1_DEF(length, res, this->ReadEndnoteRef, &oEndnoteReference); GetCurrentStringWriter().WriteString(oEndnoteReference.toXML()); } else if (c_oSer_OMathContentType::FootnoteReference == type) { OOX::Logic::CFootnoteReference oFootnoteReference; READ1_DEF(length, res, this->ReadFootnoteRef, &oFootnoteReference); GetCurrentStringWriter().WriteString(oFootnoteReference.toXML()); } else if (c_oSer_OMathContentType::LastRenderedPageBreak == type) { OOX::Logic::CLastRenderedPageBreak oLastRenderedPageBreak; GetCurrentStringWriter().WriteString(oLastRenderedPageBreak.toXML()); } else if (c_oSer_OMathContentType::NoBreakHyphen == type) { OOX::Logic::CNoBreakHyphen oNoBreakHyphen; GetCurrentStringWriter().WriteString(oNoBreakHyphen.toXML()); } else if (c_oSer_OMathContentType::SoftHyphen == type) { OOX::Logic::CSoftHyphen oSoftHyphen; GetCurrentStringWriter().WriteString(oSoftHyphen.toXML()); } else if (c_oSer_OMathContentType::Tab == type) { OOX::Logic::CTab oTab; GetCurrentStringWriter().WriteString(oTab.toXML()); } else if (c_oSer_OMathContentType::Sym == type) { std::wstring sText = m_oBufferedStream.GetString3(length); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathInsDel(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; TrackRevision* pTrackRevision = static_cast(poResult); READ1_TRACKREV(type, length, pTrackRevision) else if (c_oSerProp_RevisionType::ContentRun == type) { pTrackRevision->contentRun = new NSStringUtils::CStringBuilder(); NSStringUtils::CStringBuilder* pPrevWriter = m_pCurWriter; m_pCurWriter = pTrackRevision->contentRun; READ1_DEF(length, res, this->ReadMathMRun, NULL); m_pCurWriter = pPrevWriter; } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_DocumentTableReader::ReadMathRad(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::Deg== type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::RadPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathRadPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathRadPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathBottomNodesType::DegHide == type ) { READ2_DEF(length, res, this->ReadMathDegHide, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathMRPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::Aln == type ) { READ2_DEF(length, res, this->ReadMathAln, poResult); } else if ( c_oSer_OMathBottomNodesType::Brk == type ) { READ2_DEF(length, res, this->ReadMathBrk, poResult); } else if ( c_oSer_OMathBottomNodesType::Lit == type ) { READ2_DEF(length, res, this->ReadMathLit, poResult); } else if ( c_oSer_OMathBottomNodesType::Nor == type ) { READ2_DEF(length, res, this->ReadMathNor, poResult); } else if ( c_oSer_OMathBottomNodesType::Scr == type ) { READ2_DEF(length, res, this->ReadMathScr, poResult); } else if ( c_oSer_OMathBottomNodesType::Sty == type ) { READ2_DEF(length, res, this->ReadMathSty, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathRSp(BYTE type, long length, void* poResult)//GetLong { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { LONG lVal; lVal = m_oBufferedStream.GetLong(); std::wstring sVal(_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathRSpRule(BYTE type, long length, void* poResult)//GetUChar { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { LONG lVal; lVal = m_oBufferedStream.GetLong(); std::wstring sVal(_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathScr(BYTE type, long length, void* poResult)//GetUChar { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { BYTE Scr; std::wstring sScr (_T("roman")); Scr = m_oBufferedStream.GetUChar(); switch(Scr) { case 0: sScr = _T("double-struck");break; case 1: sScr = _T("fraktur"); break; case 2: sScr = _T("monospace"); break; case 3: sScr = _T("roman"); break; case 4: sScr = _T("sans-serif");break; case 5: sScr = _T("script"); break; } GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSepChr(BYTE type, long length, void* poResult)//ReadString { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { std::wstring sChr = GetMathText (length); std::wstring sVal; sVal += (_T("")); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathShow(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathShp(BYTE type, long length, void* poResult)//GetUChar { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { BYTE Shp; std::wstring sShp (_T("centered")); Shp = m_oBufferedStream.GetUChar(); switch(Shp) { case 0: sShp = _T("centered");break; case 1: sShp = _T("match");break; } GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSPre(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::SPrePr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathSPrePr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Sub == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Sup == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSPrePr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSSub(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::SSubPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathSSubPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Sub == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSSubPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSSubSup(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::SSubSupPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathSSubSupPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Sub == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Sup == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSSubSupPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::AlnScr == type ) { READ2_DEF(length, res, this->ReadMathAlnScr, poResult); } else if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSSup(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathContentType::SSupPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathSSupPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Sup == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSer_OMathContentType::Element == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSSupPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesType::CtrlPr == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathCtrlPr, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathStrikeBLTR(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathStrikeH(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathStrikeTLBR(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathStrikeV(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSty(BYTE type, long length, void* poResult)//GetUChar { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { BYTE Sty; std::wstring sSty (_T("i")); Sty = m_oBufferedStream.GetUChar(); switch(Sty) { case 0: sSty = _T("b");break; case 1: sSty = _T("bi");break; case 2: sSty = _T("i");break; case 3: sSty = _T("p");break; } GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSubHide(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathSupHide(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathTransp(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathType(BYTE type, long length, void* poResult)//GetUChar { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { BYTE Type; std::wstring sType (_T("bar")); Type = m_oBufferedStream.GetUChar(); switch(Type) { case 0: sType = _T("bar");break; case 1: sType = _T("lin");break; case 2: sType = _T("noBar");break; case 3: sType = _T("skw");break; } GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathVertJc(BYTE type, long length, void* poResult)//GetUChar { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { BYTE VertJc; std::wstring sVertJc (_T("bot")); VertJc = m_oBufferedStream.GetUChar(); switch(VertJc) { case 0: sVertJc = _T("bot");break; case 1: sVertJc = _T("top");break; } GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathZeroAsc(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathZeroDesc(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadMathZeroWid(BYTE type, long length, void* poResult)//GetBool { int res = c_oSerConstants::ReadOk; if ( c_oSer_OMathBottomNodesValType::Val == type ) { bool bVal = m_oBufferedStream.GetBool(); std::wstring sVal = _T(""); else sVal += _T(" m:val=\"off\" />"); GetCurrentStringWriter().WriteString(sVal); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadRun(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerRunType::rPr == type ) { res = oBinary_rPrReader.Read(length, &m_oCur_rPr); if (m_oCur_rPr.IsNoEmpty()) GetCurrentStringWriter().WriteString(m_oCur_rPr.toXML()); } else if ( c_oSerRunType::Content == type ) { READ1_DEF(length, res, this->ReadRunContent, NULL); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadRunContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if (c_oSerRunType::run == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); std::wstring sText(m_oBufferedStream.GetString3(length)); sText = XmlUtils::EncodeXmlString(sText); GetCurrentStringWriter().WriteString(sText); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::delText == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); std::wstring sText(m_oBufferedStream.GetString3(length)); sText = XmlUtils::EncodeXmlString(sText); GetCurrentStringWriter().WriteString(sText); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::tab == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::cr == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::noBreakHyphen == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::softHyphen == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::pagenum == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); if (m_oCur_rPr.IsNoEmpty()) GetCurrentStringWriter().WriteString(m_oCur_rPr.toXML()); GetCurrentStringWriter().WriteString(std::wstring(_T("PAGE \\* MERGEFORMAT"))); if (m_oCur_rPr.IsNoEmpty()) GetCurrentStringWriter().WriteString(m_oCur_rPr.toXML()); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); if (m_oCur_rPr.IsNoEmpty()) GetCurrentStringWriter().WriteString(m_oCur_rPr.toXML()); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::pagebreak == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::linebreak == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::linebreakClearAll == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::linebreakClearLeft == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::linebreakClearRight == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::columnbreak == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::image == type) { docImg odocImg(m_oFileWriter.getNextDocPr()); READ2_DEF(length, res, this->ReadImage, &odocImg); if (odocImg.MediaId >= 0 && odocImg.MediaId < m_oMediaWriter.nImageCount) { std::wstring sNewImgName = m_oMediaWriter.m_aImageNames[odocImg.MediaId]; std::wstring sNewImgRel = _T("media/") + sNewImgName; sNewImgRel = XmlUtils::EncodeXmlString(sNewImgRel); unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(std::wstring(_T("http://schemas.openxmlformats.org/officeDocument/2006/relationships/image")), sNewImgRel, std::wstring(), &rId); odocImg.srId = L"rId" + std::to_wstring(rId); //odocImg.srId = m_oMediaWriter.m_poDocumentRelsWriter->AddRels(_T("http://schemas.openxmlformats.org/officeDocument/2006/relationships/image"), sNewImgRel, false); //odocImg.srId = m_oMediaWriter.m_aImageRels[odocImg.MediaId]; if (!odocImg.srId.empty()) { odocImg.Write(&GetCurrentStringWriter()); } } } else if (c_oSerRunType::pptxDrawing == type) { CDrawingProperty oCDrawingProperty(m_oFileWriter.getNextDocPr()); READ2_DEF(length, res, this->ReadPptxDrawing, &oCDrawingProperty); if (oCDrawingProperty.IsGraphicFrameContent()) { GetCurrentStringWriter().WriteString(oCDrawingProperty.Write()); } else if (oCDrawingProperty.bDataPos && oCDrawingProperty.bDataLength) { std::wstring sDrawingProperty = oCDrawingProperty.Write(); if (false == sDrawingProperty.empty()) { ReadDrawing(oCDrawingProperty); } } } else if (c_oSerRunType::table == type) { //todo GetCurrentStringWriter().WriteString(L""); GetCurrentStringWriter().WriteString(L""); READ1_DEF(length, res, this->ReadDocTable, &m_oDocumentWriter.m_oContent); GetCurrentStringWriter().WriteString(L""); if (m_bUsedParaIdCounter && m_oFileWriter.m_pComments) { _INT32 nId = m_oFileWriter.m_pComments->m_oParaIdCounter.getNextId(); std::wstring sParaId = XmlUtils::ToString(nId, L"%08X"); GetCurrentStringWriter().WriteString(L""); } else { GetCurrentStringWriter().WriteString(L""); } if (m_oCur_pPr.IsNoEmpty()) { std::wstring sParaPr = m_oCur_pPr.toXML(); GetCurrentStringWriter().WriteString(sParaPr); } } else if (c_oSerRunType::fldstart_deprecated == type) { std::wstring sField(m_oBufferedStream.GetString3(length)); sField = XmlUtils::EncodeXmlString(sField); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); if (m_oCur_rPr.IsNoEmpty()) GetCurrentStringWriter().WriteString(m_oCur_rPr.toXML()); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); GetCurrentStringWriter().WriteString(sField); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); if (m_oCur_rPr.IsNoEmpty()) GetCurrentStringWriter().WriteString(m_oCur_rPr.toXML()); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::fldend_deprecated == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSerRunType::CommentReference == type ) { long nId = 0; READ1_DEF(length, res, this->ReadComment, &nId); if (NULL != m_oFileWriter.m_pComments) { CComment* pComment = m_oFileWriter.m_pComments->get(nId); if (NULL != pComment) // могут быть и без start/end { GetCurrentStringWriter().WriteString(pComment->writeRef(std::wstring(_T("")), std::wstring(_T("w:commentReference")), std::wstring(_T("")))); } } } else if ( c_oSerRunType::object == type) { READ1_DEF(length, res, this->ReadObject, poResult); } else if ( c_oSerRunType::separator == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSerRunType::continuationSeparator == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSerRunType::footnoteRef == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSerRunType::endnoteRef == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSerRunType::footnoteReference == type) { OOX::Logic::CFootnoteReference oFootnoteRef; READ1_DEF(length, res, this->ReadFootnoteRef, &oFootnoteRef); GetCurrentStringWriter().WriteString(oFootnoteRef.toXML()); } else if ( c_oSerRunType::endnoteReference == type) { OOX::Logic::CEndnoteReference oEndnoteRef; READ1_DEF(length, res, this->ReadEndnoteRef, &oEndnoteRef); GetCurrentStringWriter().WriteString(oEndnoteRef.toXML()); } else if ( c_oSerRunType::fldChar == type) { OOX::Logic::CFldChar oFldChar; READ1_DEF(length, res, this->ReadFldChar, &oFldChar); GetCurrentStringWriter().WriteString(oFldChar.toXML()); } else if ( c_oSerRunType::instrText == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); std::wstring sText(m_oBufferedStream.GetString3(length)); sText = XmlUtils::EncodeXmlString(sText); GetCurrentStringWriter().WriteString(sText); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if ( c_oSerRunType::delInstrText == type) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); std::wstring sText(m_oBufferedStream.GetString3(length)); sText = XmlUtils::EncodeXmlString(sText); GetCurrentStringWriter().WriteString(sText); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadFootnoteRef(BYTE type, long length, void* poResult) { OOX::Logic::CFootnoteReference* pFootnoteRef = static_cast(poResult); int res = c_oSerConstants::ReadOk; if (c_oSerNotes::RefCustomMarkFollows == type) { pFootnoteRef->m_oCustomMarkFollows.Init(); pFootnoteRef->m_oCustomMarkFollows->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerNotes::RefId == type) { pFootnoteRef->m_oId.Init(); pFootnoteRef->m_oId->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadEndnoteRef(BYTE type, long length, void* poResult) { OOX::Logic::CEndnoteReference* pEndnoteRef = static_cast(poResult); int res = c_oSerConstants::ReadOk; if (c_oSerNotes::RefCustomMarkFollows == type) { pEndnoteRef->m_oCustomMarkFollows.Init(); pEndnoteRef->m_oCustomMarkFollows->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerNotes::RefId == type) { pEndnoteRef->m_oId.Init(); pEndnoteRef->m_oId->SetValue(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } void Binary_DocumentTableReader::ReadDrawing(CDrawingProperty &oCDrawingProperty) { std::wstring sDrawingProperty = oCDrawingProperty.Write(); if (false == sDrawingProperty.empty()) { long nCurPos = m_oBufferedStream.GetPos(); std::wstring sDrawingXml; int nDocType = m_oFileWriter.m_bGlossaryMode ? XMLWRITER_DOC_TYPE_DOCX_GLOSSARY : XMLWRITER_DOC_TYPE_DOCX; m_oFileWriter.m_pDrawingConverter->SaveObjectEx(oCDrawingProperty.DataPos, oCDrawingProperty.DataLength, sDrawingProperty, nDocType, sDrawingXml); m_oBufferedStream.Seek(nCurPos); if ( false == sDrawingXml.empty()) { GetCurrentStringWriter().WriteString(sDrawingXml); } } } int Binary_DocumentTableReader::ReadObject(BYTE type, long length, void* poResult) { CDrawingProperty oCDrawingProperty(m_oFileWriter.getNextDocPr()); int res = c_oSerConstants::ReadOk; if ( c_oSerParType::OMath == type ) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadMathArg, poResult); GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } else if (c_oSerRunType::pptxDrawing == type) { READ2_DEF(length, res, this->ReadPptxDrawing, &oCDrawingProperty); if (oCDrawingProperty.bDataPos && oCDrawingProperty.bDataLength) { ReadDrawing(oCDrawingProperty); } } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadComment(BYTE type, long length, void* poResult) { long* pVal = static_cast(poResult); int res = c_oSerConstants::ReadOk; if (c_oSer_CommentsType::Id == type) *pVal = m_oBufferedStream.GetLong(); else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadDocTable(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if ( c_oSerDocTableType::tblPr == type ) { CWiterTblPr oWiterTblPr; READ1_DEF(length, res, oBinary_tblPrReader.Read_tblPr, &oWiterTblPr); pCStringWriter->WriteString(oWiterTblPr.Write()); } else if ( c_oSerDocTableType::tblGrid == type ) { oBinary_tblPrReader.m_aCurTblGrid.clear(); pCStringWriter->WriteString(std::wstring(_T(""))); READ2_DEF(length, res, this->Read_tblGrid, poResult); pCStringWriter->WriteString(std::wstring(_T(""))); } else if ( c_oSerDocTableType::Content == type ) { READ1_DEF(length, res, this->Read_TableContent, poResult); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_DocumentTableReader::Read_tblGrid(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if ( c_oSerDocTableType::tblGrid_Item == type ) { double dgridCol = m_oBufferedStream.GetDouble(); oBinary_tblPrReader.m_aCurTblGrid.push_back(dgridCol); long ngridCol = SerializeCommon::Round( g_dKoef_mm_to_twips * dgridCol); pCStringWriter->WriteString(L""); } else if ( c_oSerDocTableType::tblGrid_ItemTwips == type ) { int ngridCol = m_oBufferedStream.GetLong(); if (ngridCol > 0) pCStringWriter->WriteString(L""); else pCStringWriter->WriteString(L""); } else if ( c_oSerDocTableType::tblGridChange == type ) { TrackRevision oTrackRevision; READ1_DEF(length, res, this->Read_tblGridChange, &oTrackRevision); oTrackRevision.Write(pCStringWriter, _T("w:tblGridChange")); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_DocumentTableReader::Read_tblGridChange(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; TrackRevision* pTrackRevision = static_cast(poResult); if (c_oSerProp_RevisionType::Id == type) { pTrackRevision->Id = new _INT32(m_oBufferedStream.GetLong()); } else if (c_oSerProp_RevisionType::tblGridChange == type) { oBinary_tblPrReader.m_aCurTblGrid.clear(); pTrackRevision->tblGridChange = new NSStringUtils::CStringBuilder(); READ2_DEF(length, res, this->Read_tblGrid, pTrackRevision->tblGridChange); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_DocumentTableReader::Read_TableContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if ( c_oSerDocTableType::Row == type ) { pCStringWriter->WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->Read_Row, poResult); pCStringWriter->WriteString(std::wstring(_T(""))); } else if (c_oSerDocTableType::Sdt == type) { SdtWraper oSdt(2); READ1_DEF(length, res, this->ReadSdt, &oSdt); } else if (c_oSerDocTableType::BookmarkStart == type) { OOX::Logic::CBookmarkStart oBookmarkStart; READ1_DEF(length, res, this->ReadBookmarkStart, &oBookmarkStart); pCStringWriter->WriteString(oBookmarkStart.toXML()); } else if (c_oSerDocTableType::BookmarkEnd == type) { OOX::Logic::CBookmarkEnd oBookmarkEnd; READ1_DEF(length, res, this->ReadBookmarkEnd, &oBookmarkEnd); pCStringWriter->WriteString(oBookmarkEnd.toXML()); } else if ( c_oSerDocTableType::MoveFromRangeStart == type ) { OOX::Logic::CMoveFromRangeStart oMoveFromRangeStart; READ1_DEF(length, res, this->ReadMoveFromRangeStart, &oMoveFromRangeStart); pCStringWriter->WriteString(oMoveFromRangeStart.toXML()); } else if ( c_oSerDocTableType::MoveFromRangeEnd == type ) { OOX::Logic::CMoveFromRangeEnd oMoveToRangeEnd; READ1_DEF(length, res, this->ReadMoveFromRangeEnd, &oMoveToRangeEnd); pCStringWriter->WriteString(oMoveToRangeEnd.toXML()); } else if ( c_oSerDocTableType::MoveToRangeStart == type ) { OOX::Logic::CMoveToRangeStart oMoveToRangeStart; READ1_DEF(length, res, this->ReadMoveToRangeStart, &oMoveToRangeStart); pCStringWriter->WriteString(oMoveToRangeStart.toXML()); } else if ( c_oSerDocTableType::MoveToRangeEnd == type ) { OOX::Logic::CMoveToRangeEnd oMoveToRangeEnd; READ1_DEF(length, res, this->ReadMoveToRangeEnd, &oMoveToRangeEnd); pCStringWriter->WriteString(oMoveToRangeEnd.toXML()); } else if (c_oSerDocTableType::PermStart == type) { OOX::Logic::CPermStart oPerm; READ1_DEF(length, res, this->ReadPermStart, &oPerm); pCStringWriter->WriteString(oPerm.toXML()); } else if (c_oSerDocTableType::PermEnd == type) { OOX::Logic::CPermEnd oPerm; READ1_DEF(length, res, this->ReadPermEnd, &oPerm); pCStringWriter->WriteString(oPerm.toXML()); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_DocumentTableReader::Read_Row(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if ( c_oSerDocTableType::Row_Pr == type ) { pCStringWriter->WriteString(std::wstring(_T(""))); READ2_DEF(length, res, oBinary_tblPrReader.Read_RowPr, pCStringWriter); pCStringWriter->WriteString(std::wstring(_T(""))); } else if ( c_oSerDocTableType::Row_Content == type ) { READ1_DEF(length, res, this->ReadRowContent, poResult); } else res = c_oSerConstants::ReadUnknown; return res; }; int Binary_DocumentTableReader::ReadRowContent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if ( c_oSerDocTableType::Cell == type ) { pCStringWriter->WriteString(std::wstring(_T(""))); READ1_DEF(length, res, this->ReadCell, poResult); pCStringWriter->WriteString(std::wstring(_T(""))); } else if (c_oSerDocTableType::Sdt == type) { SdtWraper oSdt(3); READ1_DEF(length, res, this->ReadSdt, &oSdt); } else if (c_oSerDocTableType::BookmarkStart == type) { OOX::Logic::CBookmarkStart oBookmarkStart; READ1_DEF(length, res, this->ReadBookmarkStart, &oBookmarkStart); pCStringWriter->WriteString(oBookmarkStart.toXML()); } else if (c_oSerDocTableType::BookmarkEnd == type) { OOX::Logic::CBookmarkEnd oBookmarkEnd; READ1_DEF(length, res, this->ReadBookmarkEnd, &oBookmarkEnd); pCStringWriter->WriteString(oBookmarkEnd.toXML()); } else if ( c_oSerDocTableType::MoveFromRangeStart == type ) { OOX::Logic::CMoveFromRangeStart oMoveFromRangeStart; READ1_DEF(length, res, this->ReadMoveFromRangeStart, &oMoveFromRangeStart); pCStringWriter->WriteString(oMoveFromRangeStart.toXML()); } else if ( c_oSerDocTableType::MoveFromRangeEnd == type ) { OOX::Logic::CMoveFromRangeEnd oMoveToRangeEnd; READ1_DEF(length, res, this->ReadMoveFromRangeEnd, &oMoveToRangeEnd); pCStringWriter->WriteString(oMoveToRangeEnd.toXML()); } else if ( c_oSerDocTableType::MoveToRangeStart == type ) { OOX::Logic::CMoveToRangeStart oMoveToRangeStart; READ1_DEF(length, res, this->ReadMoveToRangeStart, &oMoveToRangeStart); pCStringWriter->WriteString(oMoveToRangeStart.toXML()); } else if ( c_oSerDocTableType::MoveToRangeEnd == type ) { OOX::Logic::CMoveToRangeEnd oMoveToRangeEnd; READ1_DEF(length, res, this->ReadMoveToRangeEnd, &oMoveToRangeEnd); pCStringWriter->WriteString(oMoveToRangeEnd.toXML()); } else if (c_oSerDocTableType::PermStart == type) { OOX::Logic::CPermStart oPerm; READ1_DEF(length, res, this->ReadPermStart, &oPerm); pCStringWriter->WriteString(oPerm.toXML()); } else if (c_oSerDocTableType::PermEnd == type) { OOX::Logic::CPermEnd oPerm; READ1_DEF(length, res, this->ReadPermEnd, &oPerm); pCStringWriter->WriteString(oPerm.toXML()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadCell(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; NSStringUtils::CStringBuilder* pCStringWriter = static_cast(poResult); if ( c_oSerDocTableType::Cell_Pr == type ) { pCStringWriter->WriteString(std::wstring(_T(""))); READ2_DEF(length, res, oBinary_tblPrReader.Read_CellPr, pCStringWriter); pCStringWriter->WriteString(std::wstring(_T(""))); } else if ( c_oSerDocTableType::Cell_Content == type ) { Binary_DocumentTableReader oBinary_DocumentTableReader(m_oBufferedStream, m_oFileWriter, m_oDocumentWriter, m_bOFormRead); READ1_DEF(length, res, this->ReadCellContent, &oBinary_DocumentTableReader); //Потому что если перед не идет

, то документ считается невалидным if (c_oSerParType::Par != oBinary_DocumentTableReader.m_byteLastElemType) { GetCurrentStringWriter().WriteString(std::wstring(_T(""))); } } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadCellContent(BYTE type, long length, void* poResult) { Binary_DocumentTableReader* pBinary_DocumentTableReader = static_cast(poResult); return pBinary_DocumentTableReader->ReadDocumentContent(type, length, NULL); } int Binary_DocumentTableReader::ReadImage(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; docImg* odocImg = static_cast(poResult); if ( c_oSerImageType::MediaId == type ) { odocImg->bMediaId = true; odocImg->MediaId = m_oBufferedStream.GetLong(); } else if ( c_oSerImageType::Type == type ) { odocImg->bType = true; odocImg->Type = m_oBufferedStream.GetUChar(); } else if ( c_oSerImageType::Width == type ) { odocImg->bWidth = true; odocImg->Width = m_oBufferedStream.GetDouble(); } else if ( c_oSerImageType::Height == type ) { odocImg->bHeight = true; odocImg->Height = m_oBufferedStream.GetDouble(); } else if ( c_oSerImageType::X == type ) { odocImg->bX = true; odocImg->X = m_oBufferedStream.GetDouble(); } else if ( c_oSerImageType::Y == type ) { odocImg->bY = true; odocImg->Y = m_oBufferedStream.GetDouble(); } else if ( c_oSerImageType::Padding == type ) { odocImg->bPaddings = true; READ2_DEF(length, res, oBinary_tblPrReader.ReadPaddings, &odocImg->Paddings); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::Read_Background(BYTE type, long length, void* poResult) { m_oFileWriter.m_pCurrentSettings->m_oDisplayBackgroundShape.Init(); int res = c_oSerConstants::ReadOk; Background* pBackground = static_cast(poResult); if ( c_oSerBackgroundType::Color == type ) { pBackground->bColor = true; pBackground->Color = oBinary_CommonReader2.ReadColor(); } else if ( c_oSerBackgroundType::ColorTheme == type ) { pBackground->bThemeColor = true; oBinary_CommonReader2.ReadThemeColor(length, pBackground->ThemeColor); } else if ( c_oSerBackgroundType::pptxDrawing == type ) { CDrawingProperty oCDrawingProperty(m_oFileWriter.getNextDocPr()); READ2_DEF(length, res, this->ReadPptxDrawing, &oCDrawingProperty); if (oCDrawingProperty.bDataPos && oCDrawingProperty.bDataLength) { m_oFileWriter.m_pDrawingConverter->m_pReader->m_nDocumentType = m_oFileWriter.m_bGlossaryMode ? XMLWRITER_DOC_TYPE_DOCX_GLOSSARY : XMLWRITER_DOC_TYPE_DOCX; long nCurPos = m_oBufferedStream.GetPos(); pBackground->sObject = m_oFileWriter.m_pDrawingConverter->SaveObjectBackground(oCDrawingProperty.DataPos, oCDrawingProperty.DataLength); m_oBufferedStream.Seek(nCurPos); } } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadPptxDrawing(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CDrawingProperty* pDrawingProperty = static_cast(poResult); if (c_oSerImageType2::Type == type) { pDrawingProperty->bType = true; pDrawingProperty->Type = m_oBufferedStream.GetUChar(); } else if (c_oSerImageType2::PptxData == type) { pDrawingProperty->bDataPos = true; pDrawingProperty->bDataLength = true; pDrawingProperty->DataPos = m_oBufferedStream.GetPos(); pDrawingProperty->DataLength = length; //сейчас пропуская, потому что перед чтение этого поля надо собрать остальные данные res = c_oSerConstants::ReadUnknown; } else if (c_oSerImageType2::Chart == type) { OOX::CPath pathCharts = m_oFileWriter.m_oChartWriter.m_sDir + FILE_SEPARATOR_STR + L"word" + FILE_SEPARATOR_STR + L"charts"; OOX::CSystemUtility::CreateDirectories(pathCharts.GetPath()); m_oBufferedStream.m_pRels->m_pManager->SetDstCharts(pathCharts.GetPath()); m_oBufferedStream.Seek(m_oBufferedStream.GetPos() - 4); //roll back length PPTX::Logic::GraphicFrame graphicFrame; graphicFrame.chartRec.Init(); graphicFrame.chartRec->fromPPTY(&m_oBufferedStream); if (graphicFrame.chartRec->id_data.IsInit()) { pDrawingProperty->sGraphicFrameContent = graphicFrame.toXML2(); } } else if (c_oSerImageType2::ChartEx == type) { OOX::CPath pathCharts = m_oFileWriter.m_oChartWriter.m_sDir + FILE_SEPARATOR_STR + L"word" + FILE_SEPARATOR_STR + L"charts"; OOX::CSystemUtility::CreateDirectories(pathCharts.GetPath()); m_oBufferedStream.m_pRels->m_pManager->SetDstCharts(pathCharts.GetPath()); m_oBufferedStream.Seek(m_oBufferedStream.GetPos() - 4); //roll back length PPTX::Logic::GraphicFrame graphicFrame; graphicFrame.chartRec.Init(); graphicFrame.chartRec->m_bChartEx = true; graphicFrame.chartRec->fromPPTY(&m_oBufferedStream); if (graphicFrame.chartRec->id_data.IsInit()) { pDrawingProperty->sGraphicFrameContent = graphicFrame.toXML2(); } } else if ( c_oSerImageType2::BehindDoc == type ) { pDrawingProperty->bBehindDoc = true; pDrawingProperty->BehindDoc = m_oBufferedStream.GetBool(); } else if ( c_oSerImageType2::DistL == type ) { pDrawingProperty->bDistL = true; pDrawingProperty->DistL = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerImageType2::DistLEmu == type ) { pDrawingProperty->bDistL = true; pDrawingProperty->DistL = (__int64)m_oBufferedStream.GetULong(); } else if ( c_oSerImageType2::DistT == type ) { pDrawingProperty->bDistT = true; pDrawingProperty->DistT = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerImageType2::DistTEmu == type ) { pDrawingProperty->bDistT = true; pDrawingProperty->DistT = (__int64)m_oBufferedStream.GetULong(); } else if ( c_oSerImageType2::DistR == type ) { pDrawingProperty->bDistR = true; pDrawingProperty->DistR = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerImageType2::DistREmu == type ) { pDrawingProperty->bDistR = true; pDrawingProperty->DistR = (__int64)m_oBufferedStream.GetULong(); } else if ( c_oSerImageType2::DistB == type ) { pDrawingProperty->bDistB = true; pDrawingProperty->DistB = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerImageType2::DistBEmu == type ) { pDrawingProperty->bDistB = true; pDrawingProperty->DistB = (__int64)m_oBufferedStream.GetULong(); } else if ( c_oSerImageType2::LayoutInCell == type ) { pDrawingProperty->bLayoutInCell = true; pDrawingProperty->LayoutInCell = m_oBufferedStream.GetBool(); } else if ( c_oSerImageType2::RelativeHeight == type ) { pDrawingProperty->bRelativeHeight = true; pDrawingProperty->RelativeHeight = m_oBufferedStream.GetULong(); } else if ( c_oSerImageType2::BSimplePos == type ) { pDrawingProperty->bBSimplePos = true; pDrawingProperty->BSimplePos = m_oBufferedStream.GetBool(); } else if ( c_oSerImageType2::EffectExtent == type ) { READ2_DEF(length, res, this->ReadEffectExtent, poResult); } else if ( c_oSerImageType2::Extent == type ) { READ2_DEF(length, res, this->ReadExtent, poResult); } else if ( c_oSerImageType2::PositionH == type ) { READ2_DEF(length, res, this->ReadPositionH, poResult); } else if ( c_oSerImageType2::PositionV == type ) { READ2_DEF(length, res, this->ReadPositionV, poResult); } else if ( c_oSerImageType2::SimplePos == type ) { READ2_DEF(length, res, this->ReadSimplePos, poResult); } else if ( c_oSerImageType2::SizeRelH == type ) { OOX::Drawing::CSizeRelH oSizeRelH; READ2_DEF(length, res, this->ReadSizeRelH, &oSizeRelH); pDrawingProperty->sSizeRelH = oSizeRelH.toXML(); } else if ( c_oSerImageType2::SizeRelV == type ) { OOX::Drawing::CSizeRelV oSizeRelV; READ2_DEF(length, res, this->ReadSizeRelV, &oSizeRelV); pDrawingProperty->sSizeRelV = oSizeRelV.toXML(); } else if ( c_oSerImageType2::WrapNone == type ) { pDrawingProperty->bDrawingPropertyWrap = true; pDrawingProperty->DrawingPropertyWrap.bWrappingType = true; pDrawingProperty->DrawingPropertyWrap.WrappingType = type; } else if ( c_oSerImageType2::WrapSquare == type ) { pDrawingProperty->bDrawingPropertyWrap = true; pDrawingProperty->DrawingPropertyWrap.bWrappingType = true; pDrawingProperty->DrawingPropertyWrap.WrappingType = type; READ2_DEF(length, res, this->ReadEmptyWrap, poResult); } else if ( c_oSerImageType2::WrapThrough == type ) { pDrawingProperty->bDrawingPropertyWrap = true; pDrawingProperty->DrawingPropertyWrap.bWrappingType = true; pDrawingProperty->DrawingPropertyWrap.WrappingType = type; READ2_DEF(length, res, this->ReadWrapThroughTight, &pDrawingProperty->DrawingPropertyWrap); } else if ( c_oSerImageType2::WrapTight == type ) { pDrawingProperty->bDrawingPropertyWrap = true; pDrawingProperty->DrawingPropertyWrap.bWrappingType = true; pDrawingProperty->DrawingPropertyWrap.WrappingType = type; READ2_DEF(length, res, this->ReadWrapThroughTight, &pDrawingProperty->DrawingPropertyWrap); } else if ( c_oSerImageType2::WrapTopAndBottom == type ) { pDrawingProperty->bDrawingPropertyWrap = true; pDrawingProperty->DrawingPropertyWrap.bWrappingType = true; pDrawingProperty->DrawingPropertyWrap.WrappingType = type; READ2_DEF(length, res, this->ReadEmptyWrap, poResult); } else if ( c_oSerImageType2::GraphicFramePr == type ) { PPTX::Logic::CNvGraphicFramePr oGraphicFramePr(L"wp"); READ2_DEF(length, res, this->ReadCNvGraphicFramePr, &oGraphicFramePr); pDrawingProperty->sGraphicFramePr = oGraphicFramePr.toXML(); } else if ( c_oSerImageType2::DocPr == type ) { PPTX::Logic::CNvPr pNonVisualDrawingProps(L"wp"); READ1_DEF(length, res, this->ReadDocPr, &pNonVisualDrawingProps); pNonVisualDrawingProps.id = pDrawingProperty->m_nDocPr; pDrawingProperty->sDocPr = pNonVisualDrawingProps.toXML2(L"wp:docPr"); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadEmbedded(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CDrawingProperty* pDrawingProperty = static_cast(poResult); if ( c_oSerEmbedded::Type == type ) { pDrawingProperty->nObjectType = m_oBufferedStream.GetUChar(); } else if ( c_oSerEmbedded::Program == type ) { pDrawingProperty->sObjectProgram = m_oBufferedStream.GetString2(); } else if ( c_oSerEmbedded::Data == type ) { pDrawingProperty->bObject = true; long pos = m_oBufferedStream.GetPos(); if (pDrawingProperty->nObjectType == 1) { } else if (pDrawingProperty->nObjectType == 2) { BinXlsxRW::CXlsxSerializer oXlsxSerializer; oXlsxSerializer.setDrawingConverter(m_oFileWriter.m_pDrawingConverter); std::wstring strDstEmbedded = m_oBufferedStream.m_pRels->m_pManager->GetDstMedia(); int nPos = (int)strDstEmbedded.rfind(wchar_t('m')); if (-1 != nPos) strDstEmbedded = strDstEmbedded.substr(0, nPos); strDstEmbedded += L"embeddings"; NSDirectory::CreateDirectory(strDstEmbedded); std::wstring strDstEmbeddedTemp = strDstEmbedded + FILE_SEPARATOR_STR + L"Temp"; if (true == NSDirectory::CreateDirectory(strDstEmbeddedTemp)) { std::wstring strDstEmbeddedTempXl = strDstEmbeddedTemp + FILE_SEPARATOR_STR + L"xl"; NSDirectory::CreateDirectory(strDstEmbeddedTempXl); std::wstring strDstEmbeddedTempThemePath = strDstEmbeddedTempXl + FILE_SEPARATOR_STR + L"theme"; std::wstring strDstEmbeddedTempDrawingPath = strDstEmbeddedTempXl + FILE_SEPARATOR_STR + L"drawings"; std::wstring strDstEmbeddedTempEmbeddingsPath = strDstEmbeddedTempXl + FILE_SEPARATOR_STR + L"embeddings"; int id = m_oFileWriter.m_oChartWriter.nEmbeddedCount++; BinXlsxRW::SaveParams oSaveParams(strDstEmbeddedTempDrawingPath, strDstEmbeddedTempEmbeddingsPath, strDstEmbeddedTempThemePath, m_oFileWriter.m_pDrawingConverter->GetContentTypes(), NULL, true); OOX::Spreadsheet::CXlsx oXlsx; BinXlsxRW::BinaryFileReader embeddedReader; embeddedReader.ReadMainTable(oXlsx, m_oBufferedStream, L"", strDstEmbeddedTemp, oSaveParams, m_oFileWriter.m_pDrawingConverter); oXlsx.PrepareToWrite(); oXlsx.Write(strDstEmbeddedTemp, *oSaveParams.pContentTypes); std::wstring sXlsxFilename = L"Microsoft_Excel_Worksheet" + std::to_wstring(id + 1) + (oSaveParams.bMacroEnabled ? L".xlsm" : L".xlsx"); COfficeUtils oOfficeUtils(NULL); oOfficeUtils.CompressFileOrDirectory(strDstEmbeddedTemp, strDstEmbedded + FILE_SEPARATOR_STR + sXlsxFilename, true); std::wstring sEmbWorksheetRelsName = L"embeddings/" + sXlsxFilename; std::wstring sEmbWorksheetRelType = oSaveParams.bMacroEnabled ? OOX::FileTypes::MicrosoftOfficeExcelMacro_EnabledWorksheet.RelationType() : OOX::FileTypes::MicrosoftOfficeExcelWorksheet.RelationType(); m_oFileWriter.m_pDrawingConverter->WriteRels(sEmbWorksheetRelType, sEmbWorksheetRelsName, std::wstring(), &pDrawingProperty->nObjectId); NSDirectory::DeleteDirectory(strDstEmbeddedTemp); } } m_oBufferedStream.Seek( pos + length); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadCNvGraphicFramePr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; PPTX::Logic::CNvGraphicFramePr * pLocking = static_cast(poResult); if ( c_oSerGraphicFramePr::NoChangeAspect == type ) { pLocking->noChangeAspect = m_oBufferedStream.GetBool(); } else if ( c_oSerGraphicFramePr::NoDrilldown == type ) { pLocking->noDrilldown = m_oBufferedStream.GetBool(); } else if ( c_oSerGraphicFramePr::NoGrp == type ) { pLocking->noGrp = m_oBufferedStream.GetBool(); } else if ( c_oSerGraphicFramePr::NoMove == type ) { pLocking->noMove = m_oBufferedStream.GetBool(); } else if ( c_oSerGraphicFramePr::NoResize == type ) { pLocking->noResize = m_oBufferedStream.GetBool(); } else if ( c_oSerGraphicFramePr::NoSelect == type ) { pLocking->noSelect = m_oBufferedStream.GetBool(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadDocPr(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; PPTX::Logic::CNvPr* pNonVisualDrawingProps = static_cast(poResult); if ( c_oSerDocPr::Id == type ) { pNonVisualDrawingProps->id = m_oBufferedStream.GetLong(); } else if ( c_oSerDocPr::Name == type ) { pNonVisualDrawingProps->name = m_oBufferedStream.GetString3(length); } else if ( c_oSerDocPr::Hidden == type ) { pNonVisualDrawingProps->hidden = m_oBufferedStream.GetBool(); } else if ( c_oSerDocPr::Title == type ) { pNonVisualDrawingProps->title = m_oBufferedStream.GetString3(length); } else if ( c_oSerDocPr::Descr == type ) { pNonVisualDrawingProps->descr = m_oBufferedStream.GetString3(length); } else if (c_oSerDocPr::Form == type) { pNonVisualDrawingProps->form = m_oBufferedStream.GetBool(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadEffectExtent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CDrawingProperty* pDrawingProperty = static_cast(poResult); if ( c_oSerEffectExtent::Left == type ) { pDrawingProperty->bEffectExtentL = true; pDrawingProperty->EffectExtentL = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerEffectExtent::LeftEmu == type ) { pDrawingProperty->bEffectExtentL = true; pDrawingProperty->EffectExtentL = (__int64)m_oBufferedStream.GetLong(); } else if ( c_oSerEffectExtent::Top == type ) { pDrawingProperty->bEffectExtentT = true; pDrawingProperty->EffectExtentT = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerEffectExtent::TopEmu == type ) { pDrawingProperty->bEffectExtentT = true; pDrawingProperty->EffectExtentT = (__int64)m_oBufferedStream.GetLong(); } else if ( c_oSerEffectExtent::Right == type ) { pDrawingProperty->bEffectExtentR = true; pDrawingProperty->EffectExtentR = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerEffectExtent::RightEmu == type ) { pDrawingProperty->bEffectExtentR = true; pDrawingProperty->EffectExtentR = (__int64)m_oBufferedStream.GetLong(); } else if ( c_oSerEffectExtent::Bottom == type ) { pDrawingProperty->bEffectExtentB = true; pDrawingProperty->EffectExtentB = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerEffectExtent::BottomEmu == type ) { pDrawingProperty->bEffectExtentB = true; pDrawingProperty->EffectExtentB = (__int64)m_oBufferedStream.GetLong(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadExtent(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CDrawingProperty* pDrawingProperty = static_cast(poResult); if ( c_oSerExtent::Cx == type ) { pDrawingProperty->bWidth = true; pDrawingProperty->Width = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerExtent::CxEmu == type ) { pDrawingProperty->bWidth = true; pDrawingProperty->Width = (__int64)m_oBufferedStream.GetULong(); } else if ( c_oSerExtent::Cy == type ) { pDrawingProperty->bHeight = true; pDrawingProperty->Height = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerExtent::CyEmu == type ) { pDrawingProperty->bHeight = true; pDrawingProperty->Height = (__int64)m_oBufferedStream.GetULong(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadPositionH(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CDrawingProperty* pDrawingProperty = static_cast(poResult); if ( c_oSerPosHV::RelativeFrom == type ) { pDrawingProperty->bPositionHRelativeFrom = true; pDrawingProperty->PositionHRelativeFrom = m_oBufferedStream.GetUChar(); } else if ( c_oSerPosHV::Align == type ) { pDrawingProperty->bPositionHAlign = true; pDrawingProperty->PositionHAlign = m_oBufferedStream.GetUChar(); } else if ( c_oSerPosHV::PosOffset == type ) { pDrawingProperty->bPositionHPosOffset = true; pDrawingProperty->PositionHPosOffset = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerPosHV::PosOffsetEmu == type ) { pDrawingProperty->bPositionHPosOffset = true; pDrawingProperty->PositionHPosOffset = (__int64)m_oBufferedStream.GetLong(); } else if ( c_oSerPosHV::PctOffset == type ) { pDrawingProperty->bPositionHPctOffset = true; pDrawingProperty->PositionHPctOffset = m_oBufferedStream.GetDouble(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadPositionV(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CDrawingProperty* pDrawingProperty = static_cast(poResult); if ( c_oSerPosHV::RelativeFrom == type ) { pDrawingProperty->bPositionVRelativeFrom = true; pDrawingProperty->PositionVRelativeFrom = m_oBufferedStream.GetUChar(); } else if ( c_oSerPosHV::Align == type ) { pDrawingProperty->bPositionVAlign = true; pDrawingProperty->PositionVAlign = m_oBufferedStream.GetUChar(); } else if ( c_oSerPosHV::PosOffset == type ) { pDrawingProperty->bPositionVPosOffset = true; pDrawingProperty->PositionVPosOffset = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerPosHV::PosOffsetEmu == type ) { pDrawingProperty->bPositionVPosOffset = true; pDrawingProperty->PositionVPosOffset = (__int64)m_oBufferedStream.GetLong(); } else if ( c_oSerPosHV::PctOffset == type ) { pDrawingProperty->bPositionVPctOffset = true; pDrawingProperty->PositionVPctOffset = m_oBufferedStream.GetDouble(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSimplePos(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CDrawingProperty* pDrawingProperty = static_cast(poResult); if ( c_oSerSimplePos::X == type ) { pDrawingProperty->bSimplePosX = true; pDrawingProperty->SimplePosX = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerSimplePos::XEmu == type ) { pDrawingProperty->bSimplePosX = true; pDrawingProperty->SimplePosX = (__int64)m_oBufferedStream.GetLong(); } else if ( c_oSerSimplePos::Y == type ) { pDrawingProperty->bSimplePosY = true; pDrawingProperty->SimplePosY = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerSimplePos::YEmu == type ) { pDrawingProperty->bSimplePosY = true; pDrawingProperty->SimplePosY = (__int64)m_oBufferedStream.GetLong(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSizeRelH(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Drawing::CSizeRelH* pSizeRelH = static_cast(poResult); if ( c_oSerSizeRelHV::RelativeFrom == type ) { pSizeRelH->m_oRelativeFrom.Init(); pSizeRelH->m_oRelativeFrom->SetValue((SimpleTypes::ESizeRelFromH)m_oBufferedStream.GetUChar()); } else if ( c_oSerSizeRelHV::Pct == type ) { pSizeRelH->m_oPctWidth.Init(); pSizeRelH->m_oPctWidth->SetValue(m_oBufferedStream.GetDouble()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSizeRelV(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; OOX::Drawing::CSizeRelV* pSizeRelV = static_cast(poResult); if ( c_oSerSizeRelHV::RelativeFrom == type ) { pSizeRelV->m_oRelativeFrom.Init(); pSizeRelV->m_oRelativeFrom->SetValue((SimpleTypes::ESizeRelFromV)m_oBufferedStream.GetUChar()); } else if ( c_oSerSizeRelHV::Pct == type ) { pSizeRelV->m_oPctHeight.Init(); pSizeRelV->m_oPctHeight->SetValue(m_oBufferedStream.GetDouble()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadWrapThroughTight(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerWrapThroughTight::WrapPolygon == type ) { READ2_DEF(length, res, this->ReadWrapPolygon, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadWrapPolygon(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CDrawingPropertyWrap* pDrawingPropertyWrap = static_cast(poResult); if ( c_oSerWrapPolygon::Edited == type ) { pDrawingPropertyWrap->bEdited = true; pDrawingPropertyWrap->Edited = m_oBufferedStream.GetBool(); } else if ( c_oSerWrapPolygon::Start == type ) { pDrawingPropertyWrap->bStart = true; READ2_DEF(length, res, this->ReadPolygonPoint, &pDrawingPropertyWrap->Start); } else if ( c_oSerWrapPolygon::ALineTo == type ) { READ2_DEF(length, res, this->ReadLineTo, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadLineTo(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CDrawingPropertyWrap* pDrawingPropertyWrap = static_cast(poResult); if ( c_oSerWrapPolygon::LineTo == type ) { CDrawingPropertyWrapPoint* pWrapPoint = new CDrawingPropertyWrapPoint(); READ2_DEF(length, res, this->ReadPolygonPoint, pWrapPoint); pDrawingPropertyWrap->Points.push_back(pWrapPoint); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadPolygonPoint(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; CDrawingPropertyWrapPoint* pWrapPoint = static_cast(poResult); if ( c_oSerPoint2D::X == type ) { pWrapPoint->bX = true; pWrapPoint->X = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerPoint2D::XEmu == type ) { pWrapPoint->bX = true; pWrapPoint->X = (__int64)m_oBufferedStream.GetLong(); } else if ( c_oSerPoint2D::Y == type ) { pWrapPoint->bY = true; pWrapPoint->Y = (__int64)(g_dKoef_mm_to_emu * m_oBufferedStream.GetDouble()); } else if ( c_oSerPoint2D::YEmu == type ) { pWrapPoint->bY = true; pWrapPoint->Y = (__int64)m_oBufferedStream.GetLong(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadEmptyWrap(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::Read_SecPr(BYTE type, long length, void* poResult) { return oBinary_pPrReader.Read_SecPr(type, length, poResult); } int Binary_DocumentTableReader::ReadSdt(BYTE type, long length, void* poResult) { int res = 0; SdtWraper* pSdt = static_cast(poResult); if (c_oSerSdt::Pr == type) { pSdt->m_oSdt.m_oSdtPr.Init(); READ1_DEF(length, res, this->ReadSdtPr, pSdt); } else if (c_oSerSdt::EndPr == type) { pSdt->m_oEndPr.Init(); res = oBinary_rPrReader.Read(length, pSdt->m_oEndPr.GetPointer()); } else if (c_oSerSdt::Content == type) { GetCurrentStringWriter().WriteString(L""); if ( pSdt->m_oSdt.m_oSdtPr.IsInit() ) { GetCurrentStringWriter().WriteString(pSdt->m_oSdt.m_oSdtPr->toXMLStart()); if (pSdt->m_oRPr.IsInit()) { GetCurrentStringWriter().WriteString(pSdt->m_oRPr->toXML()); } GetCurrentStringWriter().WriteString(pSdt->m_oSdt.m_oSdtPr->toXMLEnd()); } if (pSdt->m_oEndPr.IsInit()) { GetCurrentStringWriter().WriteString(L""); GetCurrentStringWriter().WriteString(pSdt->m_oEndPr->toXML()); GetCurrentStringWriter().WriteString(L""); } GetCurrentStringWriter().WriteString(L""); switch(pSdt->m_nType) { case 0: { READ1_DEF(length, res, this->ReadDocumentContent, this); } break; case 1: { READ1_DEF(length, res, this->ReadParagraphContent, this); } break; case 2: { READ1_DEF(length, res, this->Read_TableContent, &m_oDocumentWriter.m_oContent); } break; case 3: { READ1_DEF(length, res, this->ReadRowContent, &m_oDocumentWriter.m_oContent); } break; } GetCurrentStringWriter().WriteString(L""); GetCurrentStringWriter().WriteString(L""); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtPr(BYTE type, long length, void* poResult) { int res = 0; SdtWraper* pSdtWraper = static_cast(poResult); OOX::Logic::CSdtPr* pSdtPr = pSdtWraper->m_oSdt.m_oSdtPr.GetPointer(); if (c_oSerSdt::Type == type) { pSdtPr->m_eType = (OOX::Logic::ESdtType)m_oBufferedStream.GetUChar(); } else if (c_oSerSdt::Alias == type) { pSdtPr->m_oAlias.Init(); pSdtPr->m_oAlias->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::Appearance == type) { pSdtPr->m_oAppearance.Init(); pSdtPr->m_oAppearance->m_oVal.Init(); pSdtPr->m_oAppearance->m_oVal->SetValue((SimpleTypes::ESdtAppearance)m_oBufferedStream.GetUChar()); } else if (c_oSerSdt::ComboBox == type) { pSdtPr->m_oComboBox.Init(); READ1_DEF(length, res, this->ReadSdtComboBox, pSdtPr->m_oComboBox.GetPointer()); } else if (c_oSerSdt::Color == type) { OOX::Logic::CRunProperty oRPr; res = oBinary_rPrReader.Read(length, &oRPr); pSdtPr->m_oColor = oRPr.m_oColor; } else if (c_oSerSdt::DataBinding == type) { pSdtPr->m_oDataBinding.Init(); READ1_DEF(length, res, this->ReadSdtPrDataBinding, pSdtPr->m_oDataBinding.GetPointer()); } else if (c_oSerSdt::PrDate == type) { pSdtPr->m_oDate.Init(); READ1_DEF(length, res, this->ReadSdtPrDate, pSdtPr->m_oDate.GetPointer()); } else if (c_oSerSdt::DocPartList == type) { pSdtPr->m_oDocPartList.Init(); READ1_DEF(length, res, this->ReadDocPartList, pSdtPr->m_oDocPartList.GetPointer()); } else if (c_oSerSdt::DocPartObj == type) { pSdtPr->m_oDocPartObj.Init(); READ1_DEF(length, res, this->ReadDocPartList, pSdtPr->m_oDocPartObj.GetPointer()); } else if (c_oSerSdt::DropDownList == type) { pSdtPr->m_oDropDownList.Init(); READ1_DEF(length, res, this->ReadDropDownList, pSdtPr->m_oDropDownList.GetPointer()); } else if (c_oSerSdt::Id == type) { pSdtPr->m_oId.Init(); pSdtPr->m_oId->m_oVal = m_oBufferedStream.GetULong(); } else if (c_oSerSdt::Label == type) { pSdtPr->m_oLabel.Init(); pSdtPr->m_oLabel->m_oVal = m_oBufferedStream.GetULong(); } else if (c_oSerSdt::Lock == type) { pSdtPr->m_oLock.Init(); pSdtPr->m_oLock->m_oVal.SetValue((SimpleTypes::ELock)m_oBufferedStream.GetUChar()); } else if (c_oSerSdt::PlaceHolder == type) { pSdtPr->m_oPlaceHolder.Init(); pSdtPr->m_oPlaceHolder->m_oDocPart.Init(); pSdtPr->m_oPlaceHolder->m_oDocPart->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::RPr == type) { pSdtWraper->m_oRPr.Init(); res = oBinary_rPrReader.Read(length, pSdtWraper->m_oRPr.GetPointer()); } else if (c_oSerSdt::ShowingPlcHdr == type) { pSdtPr->m_oShowingPlcHdr.Init(); pSdtPr->m_oShowingPlcHdr->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerSdt::TabIndex == type) { pSdtPr->m_oTabIndex.Init(); pSdtPr->m_oTabIndex->m_oVal.Init(); pSdtPr->m_oTabIndex->m_oVal->SetValue(m_oBufferedStream.GetULong()); } else if (c_oSerSdt::Tag == type) { pSdtPr->m_oTag.Init(); pSdtPr->m_oTag->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::Temporary == type) { pSdtPr->m_oTemporary.Init(); pSdtPr->m_oTemporary->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerSdt::MultiLine == type) { pSdtPr->m_oText.Init(); pSdtPr->m_oText->m_oMultiLine.Init(); pSdtPr->m_oText->m_oMultiLine->FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerSdt::Checkbox == type) { pSdtPr->m_oCheckbox.Init(); READ1_DEF(length, res, this->ReadSdtCheckBox, pSdtPr->m_oCheckbox.GetPointer()); } else if (c_oSerSdt::FormPr == type) { pSdtPr->m_oFormPr.Init(); READ1_DEF(length, res, this->ReadSdtFormPr, pSdtPr->m_oFormPr.GetPointer()); } else if (c_oSerSdt::TextFormPr == type) { pSdtPr->m_oTextFormPr.Init(); READ1_DEF(length, res, this->ReadSdtTextFormPr, pSdtPr->m_oTextFormPr.GetPointer()); } else if (c_oSerSdt::PictureFormPr == type) { pSdtPr->m_oPicture.Init(); READ1_DEF(length, res, this->ReadSdtPicture, pSdtPr->m_oPicture.GetPointer()); } else if (c_oSerSdt::ComplexFormPr == type) { pSdtPr->m_oComplexFormPr.Init(); READ1_DEF(length, res, this->ReadSdtComplexFormPr, pSdtPr->m_oComplexFormPr.GetPointer()); } else if (c_oSerSdt::Border == type) { pSdtPr->m_oBorder.Init(); READ2_DEF(length, res, oBinary_pPrReader.ReadBorder, pSdtPr->m_oBorder.GetPointer()); } else if (c_oSerSdt::Shd == type) { pSdtPr->m_oShd.Init(); READ2_DEF(length, res, oBinary_CommonReader2.ReadShdComplexType, pSdtPr->m_oShd.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtCheckBox(BYTE type, long length, void* poResult) { int res = 0; OOX::Logic::CSdtCheckBox* pSdtCheckBox = static_cast(poResult); if (c_oSerSdt::CheckboxChecked == type) { pSdtCheckBox->m_oChecked.Init(); pSdtCheckBox->m_oChecked->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else if (c_oSerSdt::CheckboxCheckedFont == type) { if (!pSdtCheckBox->m_oCheckedState.IsInit()) pSdtCheckBox->m_oCheckedState.Init(); pSdtCheckBox->m_oCheckedState->m_oFont.Init(); pSdtCheckBox->m_oCheckedState->m_oFont->append(m_oBufferedStream.GetString3(length)); } else if (c_oSerSdt::CheckboxCheckedVal == type) { if (!pSdtCheckBox->m_oCheckedState.IsInit()) pSdtCheckBox->m_oCheckedState.Init(); pSdtCheckBox->m_oCheckedState->m_oVal.Init(); pSdtCheckBox->m_oCheckedState->m_oVal->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerSdt::CheckboxUncheckedFont == type) { if (!pSdtCheckBox->m_oUncheckedState.IsInit()) pSdtCheckBox->m_oUncheckedState.Init(); pSdtCheckBox->m_oUncheckedState->m_oFont.Init(); pSdtCheckBox->m_oUncheckedState->m_oFont->append(m_oBufferedStream.GetString3(length)); } else if (c_oSerSdt::CheckboxUncheckedVal == type) { if (!pSdtCheckBox->m_oUncheckedState.IsInit()) pSdtCheckBox->m_oUncheckedState.Init(); pSdtCheckBox->m_oUncheckedState->m_oVal.Init(); pSdtCheckBox->m_oUncheckedState->m_oVal->SetValue(m_oBufferedStream.GetLong()); } else if (c_oSerSdt::CheckboxGroupKey == type) { pSdtCheckBox->m_oGroupKey.Init(); pSdtCheckBox->m_oGroupKey->m_sVal = m_oBufferedStream.GetString3(length); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtComboBox(BYTE type, long length, void* poResult) { int res = 0; OOX::Logic::CSdtComboBox* pSdtComboBox = static_cast(poResult); if (c_oSerSdt::LastValue == type) { pSdtComboBox->m_sLastValue.Init(); pSdtComboBox->m_sLastValue->append(m_oBufferedStream.GetString3(length)); } else if (c_oSerSdt::TextFormPrFormat == type) { pSdtComboBox->m_oFormat.Init(); READ1_DEF(length, res, this->ReadSdtTextFormPrFormat, pSdtComboBox->m_oFormat.GetPointer()); } else if (c_oSerSdt::SdtListItem == type) { ComplexTypes::Word::CSdtListItem* pSdtListItem = new ComplexTypes::Word::CSdtListItem(); READ1_DEF(length, res, this->ReadSdtListItem, pSdtListItem); pSdtComboBox->m_arrListItem.push_back(pSdtListItem); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtListItem(BYTE type, long length, void* poResult) { int res = 0; ComplexTypes::Word::CSdtListItem* pSdtListItem = static_cast(poResult); if (c_oSerSdt::DisplayText == type) { pSdtListItem->m_sDisplayText = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::Value == type) { pSdtListItem->m_sValue = m_oBufferedStream.GetString3(length); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtPrDataBinding(BYTE type, long length, void* poResult) { int res = 0; ComplexTypes::Word::CDataBinding* pDataBinding = static_cast(poResult); if (c_oSerSdt::PrefixMappings == type) { pDataBinding->m_sPrefixMappings = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::StoreItemID == type) { pDataBinding->m_sStoreItemID = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::XPath == type) { pDataBinding->m_sXPath = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::StoreItemChecksum == type) { pDataBinding->m_sStoreItemChecksum = m_oBufferedStream.GetString3(length); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtPrDate(BYTE type, long length, void* poResult) { int res = 0; OOX::Logic::CDate* pDate = static_cast(poResult); if (c_oSerSdt::FullDate == type) { std::wstring sVal = m_oBufferedStream.GetString3(length); pDate->m_oFullDate.Init(); pDate->m_oFullDate->SetValue(sVal); } else if (c_oSerSdt::Calendar == type) { pDate->m_oCalendar.Init(); pDate->m_oCalendar->m_oVal.SetValue((SimpleTypes::ECalendarType)m_oBufferedStream.GetUChar()); } else if (c_oSerSdt::DateFormat == type) { pDate->m_oDateFormat.Init(); pDate->m_oDateFormat->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::Lid == type) { pDate->m_oLid.Init(); pDate->m_oLid->m_oVal = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::StoreMappedDataAs == type) { pDate->m_oStoreMappedDateAs.Init(); pDate->m_oStoreMappedDateAs->m_oVal.SetValue((SimpleTypes::ESdtDateMappingType)m_oBufferedStream.GetUChar()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadDocPartList(BYTE type, long length, void* poResult) { int res = 0; OOX::Logic::CSdtDocPart* pDocPart = static_cast(poResult); if (c_oSerSdt::DocPartCategory == type) { pDocPart->m_oDocPartCategory.Init(); pDocPart->m_oDocPartCategory->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::DocPartGallery == type) { pDocPart->m_oDocPartGallery.Init(); pDocPart->m_oDocPartGallery->m_sVal = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::DocPartUnique == type) { pDocPart->m_oDocPartUnique.Init(); pDocPart->m_oDocPartUnique->m_oVal.FromBool(m_oBufferedStream.GetBool()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadDropDownList(BYTE type, long length, void* poResult) { int res = 0; OOX::Logic::CSdtDropDownList* pDropDownList = static_cast(poResult); if (c_oSerSdt::LastValue == type) { pDropDownList->m_sLastValue = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::SdtListItem == type) { ComplexTypes::Word::CSdtListItem* pSdtListItem = new ComplexTypes::Word::CSdtListItem(); READ1_DEF(length, res, this->ReadSdtListItem, pSdtListItem); pDropDownList->m_arrListItem.push_back(pSdtListItem); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtPicture(BYTE type, long length, void* poResult) { OOX::Logic::CSdtPicture* pPicture = static_cast(poResult); int res = 0; if (c_oSerSdt::PictureFormPrScaleFlag == type) { pPicture->m_oScaleFlag = m_oBufferedStream.GetLong(); } else if (c_oSerSdt::PictureFormPrLockProportions == type) { pPicture->m_oLockProportions = m_oBufferedStream.GetBool(); } else if (c_oSerSdt::PictureFormPrRespectBorders == type) { pPicture->m_oRespectBorders = m_oBufferedStream.GetBool(); } else if (c_oSerSdt::PictureFormPrShiftX == type) { pPicture->m_oShiftX = m_oBufferedStream.GetDoubleReal(); } else if (c_oSerSdt::PictureFormPrShiftY == type) { pPicture->m_oShiftY = m_oBufferedStream.GetDoubleReal(); } else if (c_oSerSdt::PictureFormPrSignature == type) { pPicture->m_oSignature = m_oBufferedStream.GetBool(); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtFormPr(BYTE type, long length, void* poResult) { int res = 0; OOX::Logic::CFormPr* pFormPr = static_cast(poResult); if (c_oSerSdt::FormPrKey == type) { pFormPr->m_oKey = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::FormPrLabel == type) { pFormPr->m_oLabel = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::FormPrHelpText == type) { pFormPr->m_oHelpText = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::FormPrRequired == type) { pFormPr->m_oRequired = m_oBufferedStream.GetBool(); } else if (c_oSerSdt::FormPrBorder == type) { pFormPr->m_oBorder.Init(); READ2_DEF(length, res, oBinary_pPrReader.ReadBorder, pFormPr->m_oBorder.GetPointer()); } else if (c_oSerSdt::FormPrShd == type) { pFormPr->m_oShd.Init(); READ2_DEF(length, res, oBinary_CommonReader2.ReadShdComplexType, pFormPr->m_oShd.GetPointer()); } else if (c_oSerSdt::OformMaster == type) { std::wstring pathOFormMaster = m_oBufferedStream.GetString3(length); if (false == pathOFormMaster.empty() && m_bOFormRead) { XmlUtils::replace_all(pathOFormMaster, L"\\", L"/"); m_oFileWriter.m_pDrawingConverter->GetContentTypes()->Registration(L"oform/fieldMaster+xml", L"", pathOFormMaster.substr(3)); // del "../" unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(L"https://schemas.onlyoffice.com/relationships/oform-fieldMaster", pathOFormMaster, L"", &rId); pFormPr->m_oFieldRid.Init(); pFormPr->m_oFieldRid->SetValue(L"rId" + std::to_wstring(rId)); } } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtTextFormPr(BYTE type, long length, void* poResult) { int res = 0; OOX::Logic::CTextFormPr* pTextFormPr = static_cast(poResult); if (c_oSerSdt::TextFormPrComb == type) { pTextFormPr->m_oComb.Init(); READ1_DEF(length, res, this->ReadSdtTextFormPrComb, pTextFormPr->m_oComb.GetPointer()); } else if (c_oSerSdt::TextFormPrMaxCharacters == type) { pTextFormPr->m_oMaxCharacters.Init(); pTextFormPr->m_oMaxCharacters->m_oVal = m_oBufferedStream.GetLong(); } else if (c_oSerSdt::TextFormPrCombBorder == type) { pTextFormPr->m_oCombBorder.Init(); READ2_DEF(length, res, oBinary_pPrReader.ReadBorder, pTextFormPr->m_oCombBorder.GetPointer()); } else if (c_oSerSdt::TextFormPrAutoFit == type) { pTextFormPr->m_oAutoFit = m_oBufferedStream.GetBool(); } else if (c_oSerSdt::TextFormPrMultiLine == type) { pTextFormPr->m_oMultiLine = m_oBufferedStream.GetBool(); } else if (c_oSerSdt::TextFormPrFormat == type) { pTextFormPr->m_oFormat.Init(); READ1_DEF(length, res, this->ReadSdtTextFormPrFormat, pTextFormPr->m_oFormat.GetPointer()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtComplexFormPr(BYTE type, long length, void* poResult) { int res = 0; OOX::Logic::CComplexFormPr* pComplexForm = static_cast(poResult); if (c_oSerSdt::ComplexFormPrType == type) { pComplexForm->m_oType.Init(); pComplexForm->m_oType->SetValueFromByte(m_oBufferedStream.GetLong()); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtTextFormPrFormat(BYTE type, long length, void* poResult) { int res = 0; ComplexTypes::Word::CTextFormFormat* pFormat = static_cast(poResult); if (c_oSerSdt::TextFormPrFormatType == type) { pFormat->m_oType.Init(); pFormat->m_oType->SetValueFromByte(m_oBufferedStream.GetChar()); } else if (c_oSerSdt::TextFormPrFormatVal == type) { pFormat->m_oVal = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::TextFormPrFormatSymbols == type) { pFormat->m_oSymbols = m_oBufferedStream.GetString3(length); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_DocumentTableReader::ReadSdtTextFormPrComb(BYTE type, long length, void* poResult) { int res = 0; ComplexTypes::Word::CComb* pComb = static_cast(poResult); if (c_oSerSdt::TextFormPrCombWidth == type) { pComb->m_oWidth = m_oBufferedStream.GetLong(); } else if (c_oSerSdt::TextFormPrCombSym == type) { pComb->m_oSym = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::TextFormPrCombFont == type) { pComb->m_oFont = m_oBufferedStream.GetString3(length); } else if (c_oSerSdt::TextFormPrCombWRule == type) { pComb->m_oWRule.Init(); pComb->m_oWRule->SetValueFromByte(m_oBufferedStream.GetChar()); } else res = c_oSerConstants::ReadUnknown; return res; } Binary_NotesTableReader::Binary_NotesTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter, bool bIsFootnote) : Binary_CommonReader(poBufferedStream), m_oFileWriter(oFileWriter), m_bIsFootnote(bIsFootnote) { } int Binary_NotesTableReader::Read() { m_oFileWriter.m_pDrawingConverter->SetDstContentRels(); std::wstring sFilename; Writers::ContentWriter* pContentWriter = NULL; if (m_bIsFootnote) { sFilename = m_oFileWriter.get_footnotes_writer().getFilename(); pContentWriter = &m_oFileWriter.get_footnotes_writer().m_oNotesWriter; } else { sFilename = m_oFileWriter.get_endnotes_writer().getFilename(); pContentWriter = &m_oFileWriter.get_endnotes_writer().m_oNotesWriter; } Binary_DocumentTableReader oBinary_DocumentTableReader(m_oBufferedStream, m_oFileWriter, *pContentWriter, false); int res = c_oSerConstants::ReadOk; READ_TABLE_DEF(res, this->ReadNotes, &oBinary_DocumentTableReader); OOX::CPath fileRelsPath = (m_oFileWriter.get_document_writer().m_sDir) + FILE_SEPARATOR_STR + L"word" + (m_oFileWriter.m_bGlossaryMode ? FILE_SEPARATOR_STR + std::wstring(L"glossary") : L"") + FILE_SEPARATOR_STR + L"_rels" + FILE_SEPARATOR_STR + sFilename + L".rels"; m_oFileWriter.m_pDrawingConverter->SaveDstContentRels(fileRelsPath.GetPath()); return res; } int Binary_NotesTableReader::ReadNotes(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; if ( c_oSerNotes::Note == type ) { m_oType.reset(); m_oId.reset(); READ1_DEF(length, res, this->ReadNote, poResult); } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_NotesTableReader::ReadNote(BYTE type, long length, void* poResult) { Binary_DocumentTableReader* pBinary_DocumentTableReader = static_cast(poResult); int res = c_oSerConstants::ReadOk; if ( c_oSerNotes::NoteType == type ) { m_oType.Init(); m_oType->SetValue((SimpleTypes::EFtnEdn)m_oBufferedStream.GetUChar()); } else if ( c_oSerNotes::NoteId == type ) { m_oId.Init(); m_oId->SetValue(m_oBufferedStream.GetLong()); } else if ( c_oSerNotes::NoteContent == type ) { NSStringUtils::CStringBuilder& writer = pBinary_DocumentTableReader->m_oDocumentWriter.m_oContent; if (m_bIsFootnote) { writer.WriteString(L"ToString()); writer.WriteString(L"\""); } if (m_oId.IsInit()) { writer.WriteString(L" w:id=\""); writer.WriteString(m_oId->ToString()); writer.WriteString(L"\""); } writer.WriteString(L">"); READ1_DEF(length, res, this->ReadNoteContent, poResult); if (m_bIsFootnote) { writer.WriteString(L""); } else { writer.WriteString(L""); } } else res = c_oSerConstants::ReadUnknown; return res; } int Binary_NotesTableReader::ReadNoteContent(BYTE type, long length, void* poResult) { Binary_DocumentTableReader* pBinary_DocumentTableReader = static_cast(poResult); return pBinary_DocumentTableReader->ReadDocumentContent(type, length, NULL); }; BinaryFileReader::BinaryFileReader(std::wstring& sFileInDir, NSBinPptxRW::CBinaryFileReader& oBufferedStream, Writers::FileWriter& oFileWriter, bool bMacro, bool bOForm) : m_sFileInDir(sFileInDir), m_oBufferedStream(oBufferedStream), m_oFileWriter(oFileWriter), m_bMacro(bMacro), m_bOForm(bOForm) { } int BinaryFileReader::ReadFile() { long res = c_oSerConstants::ReadOk; try { res = ReadMainTable(); } catch(...) { res = c_oSerConstants::ErrorStream; } return res; } int BinaryFileReader::ReadMainTable() { m_oBufferedStream.m_nDocumentType = m_oFileWriter.m_bGlossaryMode ? XMLWRITER_DOC_TYPE_DOCX_GLOSSARY : XMLWRITER_DOC_TYPE_DOCX; long res = c_oSerConstants::ReadOk; res = m_oBufferedStream.Peek(1) == false ? c_oSerConstants::ErrorStream : c_oSerConstants::ReadOk; if (c_oSerConstants::ReadOk != res) return res; long nOtherOffset = -1; long nStyleOffset = -1; long nSettingsOffset = -1; long nDocumentOffset = -1; long nCommentsOffset = -1; long nDocumentCommentsOffset = -1; std::vector aTypes; std::vector aOffBits; BYTE mtLen = m_oBufferedStream.GetUChar(); OOX::CSettings oSettings(NULL); oSettings.SetDefaults(); m_oFileWriter.m_pCurrentSettings = &oSettings; for (int i = 0; i < mtLen; ++i) { //mtItem res = m_oBufferedStream.Peek(5) == false ? c_oSerConstants::ErrorStream : c_oSerConstants::ReadOk; if (c_oSerConstants::ReadOk != res) return res; BYTE mtiType = m_oBufferedStream.GetUChar(); long mtiOffBits = m_oBufferedStream.GetLong(); if (c_oSerTableTypes::Other == mtiType) { nOtherOffset = mtiOffBits; } else if (c_oSerTableTypes::Style == mtiType) { nStyleOffset = mtiOffBits; } else if (c_oSerTableTypes::Settings == mtiType) { nSettingsOffset = mtiOffBits; } else if (c_oSerTableTypes::Document == mtiType) { nDocumentOffset = mtiOffBits; } else if (c_oSerTableTypes::Comments == mtiType) { nCommentsOffset = mtiOffBits; } else if (c_oSerTableTypes::DocumentComments == mtiType) { nDocumentCommentsOffset = mtiOffBits; } else { aTypes.push_back(mtiType); aOffBits.push_back(mtiOffBits); } } if (-1 != nOtherOffset) { int nOldPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Seek(nOtherOffset); res = Binary_OtherTableReader(m_sFileInDir, m_oBufferedStream, m_oFileWriter).Read(); if (c_oSerConstants::ReadOk != res) return res; } if (-1 != nSettingsOffset) { OOX::CSettingsCustom oSettingsCustom; int nOldPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Seek(nSettingsOffset); res = Binary_SettingsTableReader(m_oBufferedStream, m_oFileWriter, &oSettingsCustom).Read(); if (c_oSerConstants::ReadOk != res) return res; if (!oSettingsCustom.IsEmpty()) { m_oFileWriter.m_oCustomXmlWriter.WriteCustomSettings(oSettingsCustom.GetSchemaUrl(), oSettingsCustom.toXML(), m_oFileWriter.m_bGlossaryMode); } } else { std::wstring sClrMap(L""); m_oFileWriter.m_pDrawingConverter->LoadClrMap(sClrMap); oSettings.m_oClrSchemeMapping.Init(); oSettings.m_oClrSchemeMapping->fromXMLString(sClrMap); } BinaryStyleTableReader oBinaryStyleTableReader(m_oBufferedStream, m_oFileWriter); if (-1 != nStyleOffset) { int nOldPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Seek(nStyleOffset); res = oBinaryStyleTableReader.Read(); if (c_oSerConstants::ReadOk != res) return res; } Binary_CommentsTableReader oBinary_CommentsTableReader(m_oBufferedStream, m_oFileWriter); if (-1 != nCommentsOffset) { int nOldPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Seek(nCommentsOffset); res = oBinary_CommentsTableReader.Read(); if (c_oSerConstants::ReadOk != res) return res; } Binary_CommentsTableReader oBinary_DocumentCommentsTableReader(m_oBufferedStream, m_oFileWriter); if (-1 != nDocumentCommentsOffset) { int nOldPos = m_oBufferedStream.GetPos(); m_oBufferedStream.Seek(nDocumentCommentsOffset); res = oBinary_DocumentCommentsTableReader.Read(); if (c_oSerConstants::ReadOk != res) return res; } for (size_t i = 0; i < aTypes.size(); ++i) { BYTE mtiType = aTypes[i]; long mtiOffBits = aOffBits[i]; m_oBufferedStream.Seek(mtiOffBits); switch (mtiType) { //case c_oSerTableTypes::Signature:break; //case c_oSerTableTypes::Info:break; //case c_oSerTableTypes::Style: // res = BinaryStyleTableReader(m_oBufferedStream, m_oFileWriter).Read(); // break; //case c_oSerTableTypes::Document: // res = Binary_DocumentTableReader(m_oBufferedStream, m_oFileWriter, m_oFileWriter.m_oDocumentWriter).Read(); // break; case c_oSerTableTypes::App: { OOX::CApp* pApp = new OOX::CApp(NULL); pApp->fromPPTY(&m_oBufferedStream); pApp->SetRequiredDefaults(); m_oFileWriter.m_pApp = pApp; } break; case c_oSerTableTypes::Core: { OOX::CCore* pCore = new OOX::CCore(NULL); pCore->fromPPTY(&m_oBufferedStream); pCore->SetRequiredDefaults(); m_oFileWriter.m_pCore = pCore; } break; case c_oSerTableTypes::CustomProperties: { PPTX::CustomProperties* pCustomProperties = new PPTX::CustomProperties(NULL); pCustomProperties->fromPPTY(&m_oBufferedStream); m_oFileWriter.m_pCustomProperties = pCustomProperties; m_oFileWriter.m_oDocumentRelsWriter.m_bHasCustomProperties = true; }break; case c_oSerTableTypes::HdrFtr: { res = Binary_HdrFtrTableReader(m_oBufferedStream, m_oFileWriter).Read(); }break; case c_oSerTableTypes::Numbering: { OOX::CNumbering numbering(NULL); res = Binary_NumberingTableReader(m_oBufferedStream, m_oFileWriter, &numbering).Read(); for (size_t i = 0; i < numbering.m_arrAbstractNum.size(); ++i) { m_oFileWriter.get_numbering_writer().m_oANum.WriteString(numbering.m_arrAbstractNum[i]->toXML()); } for (size_t i = 0; i < numbering.m_arrNum.size(); ++i) { m_oFileWriter.get_numbering_writer().m_oNumList.WriteString(numbering.m_arrNum[i]->toXML()); } }break; case c_oSerTableTypes::Footnotes: { res = Binary_NotesTableReader(m_oBufferedStream, m_oFileWriter, true).Read(); }break; case c_oSerTableTypes::Endnotes: { res = Binary_NotesTableReader(m_oBufferedStream, m_oFileWriter, false).Read(); }break; case c_oSerTableTypes::VbaProject: { m_bMacroRead = true; m_oBufferedStream.Skip(1); //skip type if (m_bMacro) { m_oFileWriter.m_pVbaProject = new OOX::VbaProject(NULL); m_oFileWriter.m_pVbaProject->fromPPTY(&m_oBufferedStream); } else m_oBufferedStream.SkipRecord(); }break; case c_oSerTableTypes::OForm: { if (m_bOForm) { _INT32 nDataSize = m_oBufferedStream.GetLong(); BYTE *pData = new BYTE[nDataSize]; if (pData) { m_oBufferedStream.GetArray(pData, nDataSize); std::wstring pathOFormDst = m_oFileWriter.get_document_writer().m_sDir + FILE_SEPARATOR_STR + L"oform"; std::wstring sZipOformFile = NSFile::CFileBinary::CreateTempFileWithUniqueName(m_oFileWriter.get_document_writer().m_sDir, L"oform"); NSFile::CFileBinary zipOform; if (zipOform.CreateFile(sZipOformFile) && NSDirectory::CreateDirectory(pathOFormDst)) { zipOform.WriteFile(pData, nDataSize); zipOform.CloseFile(); COfficeUtils oCOfficeUtils(NULL); if (S_OK == oCOfficeUtils.ExtractToDirectory(sZipOformFile, pathOFormDst, NULL, 0)) { m_oFileWriter.m_pDrawingConverter->GetContentTypes()->Registration(L"oform/main+xml", L"/oform", L"main.xml"); } NSFile::CFileBinary::Remove(sZipOformFile); } delete[]pData; } } else m_oBufferedStream.SkipRecord(); }break; case c_oSerTableTypes::Glossary: { OOX::CPath pathGlossary = m_oFileWriter.get_document_writer().m_sDir + FILE_SEPARATOR_STR + L"word" + FILE_SEPARATOR_STR + L"glossary"; OOX::CPath pathGlossaryRels = pathGlossary + FILE_SEPARATOR_STR + L"_rels"; if (NSDirectory::CreateDirectory(pathGlossary.GetPath()) && NSDirectory::CreateDirectory(pathGlossaryRels.GetPath())) { m_oFileWriter.m_bGlossaryMode = true; ReadMainTable(); m_oFileWriter.WriteGlossary(); m_oFileWriter.m_bGlossaryMode = false; m_oFileWriter.m_pCurrentSettings = &oSettings; smart_ptr pClrMap = m_oFileWriter.m_pCurrentSettings->m_oClrSchemeMapping.GetPointer(); pClrMap.AddRef(); *m_oFileWriter.m_pDrawingConverter->m_pClrMap = pClrMap; } else res = c_oSerConstants::ReadUnknown; }break; case c_oSerTableTypes::Customs: { OOX::CPath pathCustomXml = m_oFileWriter.get_document_writer().m_sDir + FILE_SEPARATOR_STR + L"customXml"; OOX::CPath pathCustomXmlRels = pathCustomXml + FILE_SEPARATOR_STR + L"_rels"; if (NSDirectory::CreateDirectory(pathCustomXml.GetPath()) && NSDirectory::CreateDirectory(pathCustomXmlRels.GetPath())) { Binary_CustomsTableReader oBinary_CustomsTableReader(m_oBufferedStream, m_oFileWriter); res = oBinary_CustomsTableReader.Read(); } }break; } if (c_oSerConstants::ReadOk != res) return res; } if (-1 != nDocumentOffset) { m_oBufferedStream.Seek(nDocumentOffset); m_oFileWriter.m_pDrawingConverter->SetDstContentRels(); unsigned int stamdartRId; m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles", L"styles.xml", L"", &stamdartRId); m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings", L"settings.xml", L"", &stamdartRId); m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings",L"webSettings.xml", L"", &stamdartRId); m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable", L"fontTable.xml", L"", &stamdartRId); if (m_oFileWriter.m_bGlossaryMode) { m_oFileWriter.m_pDrawingConverter->Registration(L"application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml", L"/word/glossary", L"document.xml"); } else { m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme", L"theme/theme1.xml", L"", &stamdartRId); if (m_oFileWriter.m_pVbaProject.IsInit()) { m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.microsoft.com/office/2006/relationships/vbaProject", L"vbaProject.bin", L"", &stamdartRId); m_oFileWriter.m_pDrawingConverter->Registration(L"application/vnd.ms-word.document.macroEnabled.main+xml", L"/word", L"document.xml"); m_oFileWriter.m_pDrawingConverter->Registration(L"application/vnd.ms-office.vbaProject", L"/word", L"vbaProject.bin"); } else { m_oFileWriter.m_pDrawingConverter->Registration(L"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml", L"/word", L"document.xml"); } } m_oFileWriter.m_pDrawingConverter->Registration(L"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml", L"/word" + std::wstring(m_oFileWriter.m_bGlossaryMode ? L"/glossary" : L""), L"styles.xml"); m_oFileWriter.m_pDrawingConverter->Registration(L"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml", L"/word" + std::wstring(m_oFileWriter.m_bGlossaryMode ? L"/glossary" : L""), L"settings.xml"); m_oFileWriter.m_pDrawingConverter->Registration(L"application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml", L"/word" + std::wstring(m_oFileWriter.m_bGlossaryMode ? L"/glossary" : L""), L"webSettings.xml"); m_oFileWriter.m_pDrawingConverter->Registration(L"application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml", L"/word" + std::wstring(m_oFileWriter.m_bGlossaryMode ? L"/glossary" : L""), L"fontTable.xml"); m_oFileWriter.m_pDrawingConverter->Registration(L"application/vnd.openxmlformats-officedocument.theme+xml", L"/word/theme", L"theme1.xml"); if (false == m_oFileWriter.m_bGlossaryMode && false == m_oFileWriter.IsEmptyGlossary()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/glossaryDocument", L"glossary/document.xml", L"", &rId); } if (false == m_oFileWriter.get_numbering_writer().IsEmpty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering", L"numbering.xml", std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration( L"application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml", L"/word" + std::wstring(m_oFileWriter.m_bGlossaryMode ? L"/glossary" : L""), L"numbering.xml"); } if (false == m_oFileWriter.get_footnotes_writer().IsEmpty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes", L"footnotes.xml", std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration( L"application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml", L"/word" + std::wstring(m_oFileWriter.m_bGlossaryMode ? L"/glossary" : L""), L"footnotes.xml"); } if (false == m_oFileWriter.get_endnotes_writer().IsEmpty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes", L"endnotes.xml", std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration( L"application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml", L"/word" + std::wstring(m_oFileWriter.m_bGlossaryMode ? L"/glossary" : L""), L"endnotes.xml"); } for (size_t i = 0; i < m_oFileWriter.get_headers_footers_writer().m_aHeaders.size(); ++i) { Writers::HdrFtrItem* pHeader = m_oFileWriter.get_headers_footers_writer().m_aHeaders[i]; if (false == pHeader->IsEmpty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", pHeader->m_sFilename, std::wstring(), &rId); pHeader->rId = L"rId" + std::to_wstring( rId ); m_oFileWriter.m_pDrawingConverter->Registration( L"application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml", L"/word" + std::wstring(m_oFileWriter.m_bGlossaryMode ? L"/glossary" : L""), pHeader->m_sFilename); } } for (size_t i = 0; i < m_oFileWriter.get_headers_footers_writer().m_aFooters.size(); ++i) { Writers::HdrFtrItem* pFooter = m_oFileWriter.get_headers_footers_writer().m_aFooters[i]; if (false == pFooter->IsEmpty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", pFooter->m_sFilename, std::wstring(), &rId); pFooter->rId = L"rId" + std::to_wstring( rId ); m_oFileWriter.m_pDrawingConverter->Registration( L"application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml", L"/word" + (m_oFileWriter.m_bGlossaryMode ? std::wstring(L"/glossary") : L""), pFooter->m_sFilename); } } for (size_t i = 0; i < m_oFileWriter.m_oCustomXmlWriter.arItems.size(); ++i) { if (m_oFileWriter.m_oCustomXmlWriter.arItems[i].second != m_oFileWriter.m_bGlossaryMode) continue; std::wstring sRelsPath = L"../" + OOX::FileTypes::CustomXml.DefaultDirectory().GetPath() + L"/" + m_oFileWriter.m_oCustomXmlWriter.arItems[i].first; unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::CustomXml.RelationType(), sRelsPath, L"", &rId); } res = Binary_DocumentTableReader(m_oBufferedStream, m_oFileWriter, m_oFileWriter.get_document_writer(), m_bOForm).Read(); OOX::CPath fileRelsPath = m_oFileWriter.get_document_writer().m_sDir + FILE_SEPARATOR_STR + L"word" + (m_oFileWriter.m_bGlossaryMode ? (FILE_SEPARATOR_STR + std::wstring(L"glossary")) : L"") + FILE_SEPARATOR_STR + L"_rels" + FILE_SEPARATOR_STR + L"document.xml.rels"; //------------------------------------------------------------------------------------------------------------------------ //comments CComments& oComments= oBinary_CommentsTableReader.m_oComments; Writers::CommentsWriter& oCommentsWriter = m_oFileWriter.get_comments_writer(); std::wstring sContent = oComments.writeContent(); std::wstring sContentEx = oComments.writeContentExt(); //важно чтобы writeContentExt вызывался после writeContent std::wstring sContentExtensible = oComments.writeContentExtensible(); std::wstring sContentsId = oComments.writeContentsIds(); std::wstring sPeople = oComments.writePeople(); std::wstring sDocumentContent = oBinary_DocumentCommentsTableReader.m_oComments.writeContent(); std::wstring sDocumentContentEx = oBinary_DocumentCommentsTableReader.m_oComments.writeContentExt(); //важно чтобы writeContentExt вызывался после writeContent std::wstring sDocumentContentExtensible = oBinary_DocumentCommentsTableReader.m_oComments.writeContentExtensible(); std::wstring sDocumentContentsId = oBinary_DocumentCommentsTableReader.m_oComments.writeContentsIds(); std::wstring sDocumentPeople = oBinary_DocumentCommentsTableReader.m_oComments.writePeople(); std::wstring sContentUserData = oComments.writeContentUserData(); sContentUserData += oBinary_DocumentCommentsTableReader.m_oComments.writeContentUserData(); oCommentsWriter.setElements(sContent, sContentEx, sContentExtensible, sContentsId, sPeople, sDocumentContent, sDocumentContentEx, sDocumentContentExtensible, sDocumentContentsId, sDocumentPeople, sContentUserData); //------------------------------------------------------------------------------------------------------------------------ //settings m_oFileWriter.get_settings_writer().AddSetting(oSettings.toXML()); //------------------------------------------------------------------------------------------------------------------------ if (false == oCommentsWriter.m_sComment.empty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::Comments.RelationType(), OOX::FileTypes::Comments.DefaultFileName().GetPath(), std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration(OOX::FileTypes::Comments.OverrideType(), L"/word", OOX::FileTypes::Comments.DefaultFileName().GetPath()); } if (false == oCommentsWriter.m_sCommentExt.empty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::CommentsExt.RelationType(), OOX::FileTypes::CommentsExt.DefaultFileName().GetPath(), std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration(OOX::FileTypes::CommentsExt.OverrideType(), L"/word", OOX::FileTypes::CommentsExt.DefaultFileName().GetPath()); } if (false == oCommentsWriter.m_sContentExtensible.empty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::CommentsExtensible.RelationType(), OOX::FileTypes::CommentsExtensible.DefaultFileName().GetPath(), std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration(OOX::FileTypes::CommentsExtensible.OverrideType(), L"/word", OOX::FileTypes::CommentsExtensible.DefaultFileName().GetPath()); } if (false == oCommentsWriter.m_sCommentsIds.empty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::CommentsIds.RelationType(), OOX::FileTypes::CommentsIds.DefaultFileName().GetPath(), std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration(OOX::FileTypes::CommentsIds.OverrideType(), L"/word", OOX::FileTypes::CommentsIds.DefaultFileName().GetPath()); } if (false == oCommentsWriter.m_sPeople.empty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::People.RelationType(), OOX::FileTypes::People.DefaultFileName().GetPath(), std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration(OOX::FileTypes::People.OverrideType(), L"/word", OOX::FileTypes::People.DefaultFileName().GetPath()); } if (false == oCommentsWriter.m_sDocumentComment.empty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::DocumentComments.RelationType(), OOX::FileTypes::DocumentComments.DefaultFileName().GetPath(), std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration(OOX::FileTypes::DocumentComments.OverrideType(), L"/word", OOX::FileTypes::DocumentComments.DefaultFileName().GetPath()); } if (false == oCommentsWriter.m_sDocumentCommentExt.empty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::DocumentCommentsExt.RelationType(), OOX::FileTypes::DocumentCommentsExt.DefaultFileName().GetPath(), std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration(OOX::FileTypes::DocumentCommentsExt.OverrideType(), L"/word", OOX::FileTypes::DocumentCommentsExt.DefaultFileName().GetPath()); } if (false == oCommentsWriter.m_sDocumentContentExtensible.empty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::DocumentCommentsExtensible.RelationType(), OOX::FileTypes::DocumentCommentsExtensible.DefaultFileName().GetPath(), std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration(OOX::FileTypes::DocumentCommentsExtensible.OverrideType(), L"/word", OOX::FileTypes::DocumentCommentsExtensible.DefaultFileName().GetPath()); } if (false == oCommentsWriter.m_sDocumentCommentsIds.empty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::DocumentCommentsIds.RelationType(), OOX::FileTypes::DocumentCommentsIds.DefaultFileName().GetPath(), std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration(OOX::FileTypes::DocumentCommentsIds.OverrideType(), L"/word", OOX::FileTypes::DocumentCommentsIds.DefaultFileName().GetPath()); } if (false == oCommentsWriter.m_sDocumentPeople.empty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::DocumentPeople.RelationType(), OOX::FileTypes::DocumentPeople.DefaultFileName().GetPath(), std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration(OOX::FileTypes::DocumentPeople.OverrideType(), L"/word", OOX::FileTypes::DocumentPeople.DefaultFileName().GetPath()); } if (false == oCommentsWriter.m_sContentUserData.empty()) { unsigned int rId; m_oFileWriter.m_pDrawingConverter->WriteRels(OOX::FileTypes::CommentsUserData.RelationType(), OOX::FileTypes::CommentsUserData.DefaultFileName().GetPath(), std::wstring(), &rId); m_oFileWriter.m_pDrawingConverter->Registration(OOX::FileTypes::CommentsUserData.OverrideType(), L"/word", OOX::FileTypes::CommentsUserData.DefaultFileName().GetPath()); } m_oFileWriter.m_pDrawingConverter->SaveDstContentRels(fileRelsPath.GetPath()); if (c_oSerConstants::ReadOk != res) return res; } return res; } }