/* * (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 "VisioOthers.h" #include "Shapes.h" #include "../../DesktopEditor/common/SystemUtils.h" #include "../Binary/Presentation/BinaryFileReaderWriter.h" #include "../Binary/Presentation/XmlWriter.h" namespace OOX { namespace Draw { CSolutionFile::CSolutionFile(OOX::Document* pMain) : OOX::File(pMain) { } CSolutionFile::CSolutionFile(OOX::Document* pMain, const CPath& uri) : OOX::File(pMain) { read(uri.GetDirectory(), uri); } CSolutionFile::CSolutionFile(OOX::Document* pMain, const CPath& oRootPath, const CPath& oPath) : OOX::File(pMain) { read(oRootPath, oPath); } CSolutionFile::~CSolutionFile() { } void CSolutionFile::read(const CPath& oFilePath) { CPath oRootPath; read(oRootPath, oFilePath); } void CSolutionFile::read(const CPath& oRootPath, const CPath& oFilePath) { NSFile::CFileBinary::ReadAllTextUtf8A(oFilePath.GetPath(), m_sXmlA); } void CSolutionFile::write(const CPath& oFilePath, const CPath& oDirectory, CContentTypes& oContent) const { NSFile::CFileBinary oFile; if (true == oFile.CreateFileW(oFilePath.GetPath())) { if (false == m_sXmlA.empty()) oFile.WriteFile((BYTE*)m_sXmlA.c_str(), m_sXmlA.length()); oFile.CloseFile(); } oContent.Registration(type().OverrideType(), oDirectory, oFilePath.GetFilename()); } const OOX::FileType CSolutionFile::type() const { return FileTypes::Solution; } const OOX::CPath CSolutionFile::DefaultDirectory() const { return type().DefaultDirectory(); } const OOX::CPath CSolutionFile::DefaultFileName() const { return type().DefaultFileName(); } void CSolutionFile::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4; while (pReader->GetPos() < end) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { pReader->Skip(4); // len m_sXmlA = pReader->GetString2A(); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(end); } void CSolutionFile::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) { pWriter->StartRecord(0); pWriter->WriteStringA(m_sXmlA); pWriter->EndRecord(); } //----------------------------------------------------------------------------------------------------------------------------- CSolutionsFile::CSolutionsFile(OOX::Document* pMain) : OOX::IFileContainer(pMain), OOX::File(pMain) { m_bVisioPages = true; } CSolutionsFile::CSolutionsFile(OOX::Document* pMain, const CPath& uri) : OOX::IFileContainer(pMain), OOX::File(pMain) { m_bVisioPages = true; read(uri.GetDirectory(), uri); } CSolutionsFile::CSolutionsFile(OOX::Document* pMain, const CPath& oRootPath, const CPath& oPath) : OOX::IFileContainer(pMain), OOX::File(pMain) { m_bVisioPages = true; read(oRootPath, oPath); } CSolutionsFile::~CSolutionsFile() { } void CSolutionsFile::read(const CPath& oFilePath) { CPath oRootPath; read(oRootPath, oFilePath); } void CSolutionsFile::read(const CPath& oRootPath, const CPath& oFilePath) { IFileContainer::Read(oRootPath, oFilePath); XmlUtils::CXmlLiteReader oReader; if (!oReader.FromFile(oFilePath.GetPath())) return; if (!oReader.ReadNextNode()) return; m_strFilename = oFilePath.GetPath(); Solutions = oReader; } void CSolutionsFile::write(const CPath& oFilePath, const CPath& oDirectory, CContentTypes& oContent) const { NSBinPptxRW::CXmlWriter oXmlWriter; oXmlWriter.WriteString((L"")); oXmlWriter.m_lDocType = XMLWRITER_DOC_TYPE_VSDX; toXmlWriter(&oXmlWriter); NSFile::CFileBinary::SaveToFile(oFilePath.GetPath(), oXmlWriter.GetXmlString()); oContent.Registration(type().OverrideType(), oDirectory, oFilePath.GetFilename()); IFileContainer::Write(oFilePath, oDirectory, oContent); } const OOX::FileType CSolutionsFile::type() const { return FileTypes::Solutions; } const OOX::CPath CSolutionsFile::DefaultDirectory() const { return type().DefaultDirectory(); } const OOX::CPath CSolutionsFile::DefaultFileName() const { return type().DefaultFileName(); } void CSolutionsFile::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { smart_ptr rels_old = pReader->GetRels(); pReader->SetRels(dynamic_cast((CSolutionsFile*)this)); LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4; while (pReader->GetPos() < end) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { Solutions.Init(); Solutions->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(end); pReader->SetRels(rels_old); } void CSolutionsFile::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { smart_ptr rels_old = pWriter->GetRels(); pWriter->SetRels(dynamic_cast((CSolutionsFile*)this)); pWriter->WriteRecord2(0, Solutions); pWriter->SetRels(rels_old); } void CSolutionsFile::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { if (Solutions.IsInit()) Solutions->toXmlWriter(pWriter); } //----------------------------------------------------------------------------------------------------------------------------- EElementType CSolution::getType() const { return et_dr_Solution; } void CSolution::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "Name", Name) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CSolution::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); if (oReader.IsEmptyNode()) return; int nCurDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nCurDepth)) { const char* sName = XmlUtils::GetNameNoNS(oReader.GetNameChar()); if (strcmp("Rel", sName) == 0) { Rel = oReader; } } } void CSolution::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteString2(0, Name); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); if (Rel.IsInit() && Rel->Rid.IsInit()) { smart_ptr pFile = pWriter->GetRels()->Find(Rel->Rid->GetValue()); CSolutionFile* pSolution = dynamic_cast(pFile.GetPointer()); if (pSolution) { pWriter->StartRecord(0); pSolution->toPPTY(pWriter); pWriter->EndRecord(); } } } void CSolution::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { Name = pReader->GetString2(); }break; } } while (pReader->GetPos() < _end_rec) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { CSolutionFile* pSolution = new CSolutionFile(NULL); pSolution->fromPPTY(pReader); smart_ptr oFile(pSolution); Rel.Init(); Rel->Rid.Init(); Rel->Rid->SetValue(pReader->GetRels()->Add(oFile).get()); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(_end_rec); } void CSolution::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"Solution"); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"Name", Name); pWriter->EndAttributes(); if (Rel.IsInit()) Rel->toXmlWriter(pWriter); pWriter->WriteNodeEnd(L"Solution"); } //----------------------------------------------------------------------------------------------------------------------------- void CSolutions::fromXML(XmlUtils::CXmlLiteReader& oReader) { if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"Solution" == sName) { CSolution* pItem = new CSolution(); *pItem = oReader; if (pItem) m_arrItems.push_back(pItem); } } } EElementType CSolutions::getType() const { return et_dr_Solutions; } void CSolutions::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4; while (pReader->GetPos() < end) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { m_arrItems.push_back(new CSolution()); m_arrItems.back()->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(end); } void CSolutions::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { for (size_t i = 0; i < m_arrItems.size(); ++i) pWriter->WriteRecord2(0, dynamic_cast(m_arrItems[i])); } void CSolutions::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"Solutions"); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"xmlns", L"http://schemas.microsoft.com/office/visio/2012/main"); pWriter->WriteAttribute2(L"xmlns:r", L"http://schemas.openxmlformats.org/officeDocument/2006/relationships"); pWriter->WriteAttribute2(L"xml:space", L"preserve"); pWriter->EndAttributes(); for (size_t i = 0; i < m_arrItems.size(); ++i) m_arrItems[i]->toXmlWriter(pWriter); pWriter->WriteNodeEnd(L"Solutions"); } //----------------------------------------------------------------------------------------------------------------------------------------- CValidationFile::CValidationFile(OOX::Document* pMain) : OOX::File(pMain) { } CValidationFile::CValidationFile(OOX::Document* pMain, const CPath& uri) : OOX::File(pMain) { read(uri.GetDirectory(), uri); } CValidationFile::CValidationFile(OOX::Document* pMain, const CPath& oRootPath, const CPath& oPath) : OOX::File(pMain) { read(oRootPath, oPath); } CValidationFile::~CValidationFile() { } void CValidationFile::read(const CPath& oFilePath) { CPath oRootPath; read(oRootPath, oFilePath); } void CValidationFile::read(const CPath& oRootPath, const CPath& oFilePath) { XmlUtils::CXmlLiteReader oReader; if (!oReader.FromFile(oFilePath.GetPath())) return; if (!oReader.ReadNextNode()) return; m_strFilename = oFilePath.GetPath(); std::wstring sName = oReader.GetName(); if (L"Validation" == sName && !oReader.IsEmptyNode()) { int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"ValidationProperties" == sName) { ValidationProperties = oReader; } else if (L"RuleSets" == sName) { RuleSets = oReader; } else if (L"Issues" == sName) { Issues = oReader; } } } } void CValidationFile::write(const CPath& oFilePath, const CPath& oDirectory, CContentTypes& oContent) const { NSBinPptxRW::CXmlWriter oXmlWriter; oXmlWriter.WriteString((L"")); oXmlWriter.m_lDocType = XMLWRITER_DOC_TYPE_VSDX; toXmlWriter(&oXmlWriter); NSFile::CFileBinary::SaveToFile(oFilePath.GetPath(), oXmlWriter.GetXmlString()); oContent.Registration(type().OverrideType(), oDirectory, oFilePath.GetFilename()); } void CValidationFile::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"Validation"); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"xmlns", L"http://schemas.microsoft.com/office/visio/2012/main"); pWriter->WriteAttribute2(L"xmlns:r", L"http://schemas.openxmlformats.org/officeDocument/2006/relationships"); pWriter->WriteAttribute2(L"xml:space", L"preserve"); pWriter->EndAttributes(); if (ValidationProperties.IsInit()) ValidationProperties->toXmlWriter(pWriter); if (RuleSets.IsInit()) RuleSets->toXmlWriter(pWriter); if (Issues.IsInit()) Issues->toXmlWriter(pWriter); pWriter->WriteNodeEnd(L"Validation"); } const OOX::FileType CValidationFile::type() const { return FileTypes::Validation; } const OOX::CPath CValidationFile::DefaultDirectory() const { return type().DefaultDirectory(); } const OOX::CPath CValidationFile::DefaultFileName() const { return type().DefaultFileName(); } void CValidationFile::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; while (pReader->GetPos() < _end_rec) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { ValidationProperties.Init(); ValidationProperties->fromPPTY(pReader); }break; case 1: { RuleSets.Init(); RuleSets->fromPPTY(pReader); }break; case 2: { Issues.Init(); Issues->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(_end_rec); } void CValidationFile::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) { pWriter->WriteRecord2(0, ValidationProperties); pWriter->WriteRecord2(1, RuleSets); pWriter->WriteRecord2(2, Issues); } //----------------------------------------------------------------------------------------------------------------------------- EElementType CIssue::getType() const { return et_dr_Issue; } void CIssue::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "ID", ID) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Ignored", Ignored) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CIssue::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"IssueTarget" == sName) { IssueTarget = oReader; } else if (L"RuleInfo" == sName) { RuleInfo = oReader; } } } void CIssue::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteUInt2(0, ID); pWriter->WriteBool2(1, Ignored); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); pWriter->WriteRecord2(0, IssueTarget); pWriter->WriteRecord2(1, RuleInfo); } void CIssue::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { ID = pReader->GetULong(); }break; case 1: { Ignored = pReader->GetBool(); }break; } } while (pReader->GetPos() < _end_rec) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { IssueTarget.Init(); IssueTarget->fromPPTY(pReader); }break; case 1: { RuleInfo.Init(); RuleInfo->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(_end_rec); } void CIssue::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"Issue"); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"ID", ID); pWriter->WriteAttribute(L"Ignored", Ignored); pWriter->EndAttributes(); if (IssueTarget.IsInit()) IssueTarget->toXmlWriter(pWriter); if (RuleInfo.IsInit()) RuleInfo->toXmlWriter(pWriter); pWriter->WriteNodeEnd(L"Issue"); } EElementType CIssues::getType() const { return et_dr_Issues; } void CIssues::fromXML(XmlUtils::CXmlLiteReader& oReader) { if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"Issue" == sName) { CIssue* pItem = new CIssue(); *pItem = oReader; if (pItem) m_arrItems.push_back(pItem); } } } void CIssues::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4; while (pReader->GetPos() < end) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { m_arrItems.push_back(new CIssue()); m_arrItems.back()->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(end); } void CIssues::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { for (size_t i = 0; i < m_arrItems.size(); ++i) pWriter->WriteRecord2(0, dynamic_cast(m_arrItems[i])); } void CIssues::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"Issues"); pWriter->EndAttributes(); for (size_t i = 0; i < m_arrItems.size(); ++i) m_arrItems[i]->toXmlWriter(pWriter); pWriter->WriteNodeEnd(L"Issues"); } //----------------------------------------------------------------------------------------------------------------------------- EElementType CRule::getType() const { return et_dr_Rule; } void CRule::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "ID", ID) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Category", Category) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "NameU", NameU) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Description", Description) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Ignored", Ignored) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "RuleTarget", RuleTarget) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CRule::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"RuleFilter" == sName) { RuleFilter = oReader; } else if(L"RuleTest" == sName) { RuleTest = oReader; } } } void CRule::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteUInt2(0, ID); pWriter->WriteString2(1, Category); pWriter->WriteString2(2, NameU); pWriter->WriteBool2(3, Ignored); pWriter->WriteString2(4, Description); pWriter->WriteInt2(5, RuleTarget); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); pWriter->WriteRecord2(0, RuleFilter); pWriter->WriteRecord2(1, RuleTest); } void CRule::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { ID = pReader->GetULong(); }break; case 1: { Category = pReader->GetString2(); }break; case 2: { NameU = pReader->GetString2(); }break; case 3: { Ignored = pReader->GetBool(); }break; case 4: { Description = pReader->GetString2(); }break; case 5: { RuleTarget = pReader->GetLong(); }break; } } while (pReader->GetPos() < _end_rec) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { RuleFilter.Init(); RuleFilter->node_name = L"RuleFilter"; RuleFilter->fromPPTY(pReader); }break; case 1: { RuleTest.Init(); RuleFilter->node_name = L"RuleTest"; RuleTest->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(_end_rec); } void CRule::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"Rule"); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"ID", ID); pWriter->WriteAttribute2(L"Category", Category); pWriter->WriteAttribute2(L"NameU", NameU); pWriter->WriteAttribute2(L"Description", Description); pWriter->WriteAttribute(L"Ignored", Ignored); pWriter->WriteAttribute(L"RuleTarget", RuleTarget); pWriter->EndAttributes(); if (RuleFilter.IsInit()) RuleFilter->toXmlWriter(pWriter); if (RuleTest.IsInit()) RuleTest->toXmlWriter(pWriter); pWriter->WriteNodeEnd(L"Rule"); } //----------------------------------------------------------------------------------------------------------------------------- EElementType CRuleSet::getType() const { return et_dr_RuleSet; } void CRuleSet::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "ID", ID) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "NameU", NameU) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Name", Name) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Description", Description) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Enabled", Enabled) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CRuleSet::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"RuleSetFlags" == sName) { RuleSetFlags = oReader; } else if (L"Rule" == sName) { CRule* pItem = new CRule(); if (pItem) { pItem->fromXML(oReader); m_arrItems.push_back(pItem); } } } } void CRuleSet::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteUInt2(0, ID); pWriter->WriteString2(1, NameU); pWriter->WriteString2(2, Name); pWriter->WriteString2(3, Description); pWriter->WriteBool2(4, Enabled); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); pWriter->WriteRecord2(0, RuleSetFlags); for (size_t i = 0; i < m_arrItems.size(); ++i) { pWriter->WriteRecord2(1, dynamic_cast(m_arrItems[i])); } } void CRuleSet::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { ID = pReader->GetULong(); }break; case 1: { NameU = pReader->GetString2(); }break; case 2: { Name = pReader->GetString2(); }break; case 3: { Description = pReader->GetString2(); }break; case 8: { Enabled = pReader->GetBool(); }break; } } while (pReader->GetPos() < _end_rec) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { RuleSetFlags.Init(); RuleSetFlags->fromPPTY(pReader); }break; case 1: { m_arrItems.push_back(new CRule()); m_arrItems.back()->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(_end_rec); } void CRuleSet::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"RuleSet"); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"ID", ID); pWriter->WriteAttribute2(L"NameU", NameU); pWriter->WriteAttribute2(L"Name", Name); pWriter->WriteAttribute2(L"Description", Description); pWriter->WriteAttribute(L"Enabled", Enabled); pWriter->EndAttributes(); if (RuleSetFlags.IsInit()) RuleSetFlags->toXmlWriter(pWriter); for (size_t i = 0; i < m_arrItems.size(); ++i) m_arrItems[i]->toXmlWriter(pWriter); pWriter->WriteNodeEnd(L"RuleSet"); } EElementType CRuleSets::getType() const { return et_dr_RuleSets; } void CRuleSets::fromXML(XmlUtils::CXmlLiteReader& oReader) { if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"RuleSet" == sName) { CRuleSet* pItem = new CRuleSet(); *pItem = oReader; if (pItem) m_arrItems.push_back(pItem); } } } void CRuleSets::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4; while (pReader->GetPos() < end) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { m_arrItems.push_back(new CRuleSet()); m_arrItems.back()->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(end); } void CRuleSets::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { for (size_t i = 0; i < m_arrItems.size(); ++i) pWriter->WriteRecord2(0, dynamic_cast(m_arrItems[i])); } void CRuleSets::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"RuleSets"); pWriter->EndAttributes(); for (size_t i = 0; i < m_arrItems.size(); ++i) m_arrItems[i]->toXmlWriter(pWriter); pWriter->WriteNodeEnd(L"RuleSets"); } EElementType CValidationProperties::getType() const { return et_dr_ValidationProperties; } void CValidationProperties::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "ShowIgnored", ShowIgnored) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "LastValidated", LastValidated) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CValidationProperties::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); if (!oReader.IsEmptyNode()) oReader.ReadTillEnd(); } void CValidationProperties::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteBool2(0, ShowIgnored); pWriter->WriteString2(1, LastValidated); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); } void CValidationProperties::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { ShowIgnored = pReader->GetBool(); }break; case 1: { LastValidated = pReader->GetString2(); }break; } } pReader->Seek(_end_rec); } void CValidationProperties::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"ValidationProperties"); pWriter->StartAttributes(); pWriter->WriteAttribute(L"ShowIgnored", ShowIgnored); pWriter->WriteAttribute2(L"LastValidated", LastValidated); pWriter->EndAttributes(); pWriter->WriteNodeEnd(L"ValidationProperties"); } EElementType CIssueTarget::getType() const { return et_dr_IssueTarget; } void CIssueTarget::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "PageID", PageID) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ShapeID", ShapeID) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CIssueTarget::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); if (!oReader.IsEmptyNode()) oReader.ReadTillEnd(); } void CIssueTarget::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteUInt2(0, PageID); pWriter->WriteUInt2(1, ShapeID); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); } void CIssueTarget::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { PageID = pReader->GetULong(); }break; case 1: { ShapeID = pReader->GetULong(); }break; } } pReader->Seek(_end_rec); } void CIssueTarget::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"IssueTarget"); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"PageID", PageID); pWriter->WriteAttribute2(L"ShapeID", ShapeID); pWriter->EndAttributes(); pWriter->WriteNodeEnd(L"IssueTarget"); } EElementType CRuleInfo::getType() const { return et_dr_RuleInfo; } void CRuleInfo::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "RuleID", RuleID) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "RuleSetID", RuleSetID) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CRuleInfo::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); if (!oReader.IsEmptyNode()) oReader.ReadTillEnd(); } void CRuleInfo::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteUInt2(0, RuleID); pWriter->WriteUInt2(1, RuleSetID); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); } void CRuleInfo::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { RuleID = pReader->GetULong(); }break; case 1: { RuleSetID = pReader->GetULong(); }break; } } pReader->Seek(_end_rec); } void CRuleInfo::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"RuleInfo"); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"RuleID", RuleID); pWriter->WriteAttribute2(L"RuleSetID", RuleSetID); pWriter->EndAttributes(); pWriter->WriteNodeEnd(L"RuleInfo"); } EElementType CRuleFormula::getType() const { return et_dr_CRuleFormula; } void CRuleFormula::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "Formula", Formula) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CRuleFormula::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); if (!oReader.IsEmptyNode()) oReader.ReadTillEnd(); } void CRuleFormula::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteString2(0, Formula); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); } void CRuleFormula::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { Formula = pReader->GetString2(); }break; } } pReader->Seek(_end_rec); } void CRuleFormula::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) { if (node_name.empty()) node_name = L"RuleFilter"; pWriter->StartNode(node_name); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"Formula", Formula); pWriter->EndAttributes(); pWriter->WriteNodeEnd(node_name); } EElementType CRuleSetFlags::getType() const { return et_dr_RuleSetFlags; } void CRuleSetFlags::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "Hidden", Hidden) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CRuleSetFlags::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); if (!oReader.IsEmptyNode()) oReader.ReadTillEnd(); } void CRuleSetFlags::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteBool2(0, Hidden); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); } void CRuleSetFlags::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { Hidden = pReader->GetBool(); }break; } } pReader->Seek(_end_rec); } void CRuleSetFlags::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"RuleSetFlags"); pWriter->StartAttributes(); pWriter->WriteAttribute(L"Hidden", Hidden); pWriter->EndAttributes(); pWriter->WriteNodeEnd(L"RuleSetFlags"); } //----------------------------------------------------------------------------------------------------------------------------- CCommentsFile::CCommentsFile(OOX::Document* pMain) : OOX::File(pMain) { } CCommentsFile::CCommentsFile(OOX::Document* pMain, const CPath& uri) : OOX::File(pMain) { read(uri.GetDirectory(), uri); } CCommentsFile::CCommentsFile(OOX::Document* pMain, const CPath& oRootPath, const CPath& oPath) : OOX::File(pMain) { read(oRootPath, oPath); } CCommentsFile::~CCommentsFile() { } void CCommentsFile::read(const CPath& oFilePath) { CPath oRootPath; read(oRootPath, oFilePath); } void CCommentsFile::read(const CPath& oRootPath, const CPath& oFilePath) { XmlUtils::CXmlLiteReader oReader; if (!oReader.FromFile(oFilePath.GetPath())) return; if (!oReader.ReadNextNode()) return; m_strFilename = oFilePath.GetPath(); Comments = oReader; } void CCommentsFile::write(const CPath& oFilePath, const CPath& oDirectory, CContentTypes& oContent) const { NSBinPptxRW::CXmlWriter oXmlWriter; oXmlWriter.WriteString((L"")); oXmlWriter.m_lDocType = XMLWRITER_DOC_TYPE_VSDX; if (Comments.IsInit()) Comments->toXmlWriter(&oXmlWriter); NSFile::CFileBinary::SaveToFile(oFilePath.GetPath(), oXmlWriter.GetXmlString()); oContent.Registration(type().OverrideType(), oDirectory, oFilePath.GetFilename()); } const OOX::FileType CCommentsFile::type() const { return FileTypes::Comments; } const OOX::CPath CCommentsFile::DefaultDirectory() const { return type().DefaultDirectory(); } const OOX::CPath CCommentsFile::DefaultFileName() const { return type().DefaultFileName(); } void CCommentsFile::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4; while (pReader->GetPos() < end) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { Comments.Init(); Comments->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(end); } void CCommentsFile::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { smart_ptr rels_old = pWriter->GetRels(); pWriter->SetRels(dynamic_cast((CSolutionsFile*)this)); pWriter->WriteRecord2(0, Comments); pWriter->SetRels(rels_old); } void CCommentsFile::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { if (Comments.IsInit()) Comments->toXmlWriter(pWriter); } //-------------------------------------------------------------------------------------------------------------- EElementType CComments::getType() const { return et_dr_Comments; } void CComments::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "ShowCommentTags", ShowCommentTags) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CComments::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); if (oReader.IsEmptyNode()) return; int nCurDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nCurDepth)) { const char* sName = XmlUtils::GetNameNoNS(oReader.GetNameChar()); if (strcmp("AuthorList", sName) == 0) { AuthorList = oReader; } else if (strcmp("CommentList", sName) == 0) { CommentList = oReader; } } } void CComments::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteBool2(0, ShowCommentTags); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); pWriter->WriteRecord2(0, AuthorList); pWriter->WriteRecord2(1, CommentList); } void CComments::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { ShowCommentTags = pReader->GetBool(); }break; } } while (pReader->GetPos() < _end_rec) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { AuthorList.Init(); AuthorList->fromPPTY(pReader); }break; case 1: { CommentList.Init(); CommentList->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(_end_rec); } void CComments::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"Comments"); pWriter->StartAttributes(); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"xmlns", L"http://schemas.microsoft.com/office/visio/2012/main"); pWriter->WriteAttribute2(L"xmlns:r", L"http://schemas.openxmlformats.org/officeDocument/2006/relationships"); pWriter->WriteAttribute2(L"xml:space", L"preserve"); pWriter->WriteAttribute(L"ShowCommentTags", ShowCommentTags); pWriter->EndAttributes(); if (AuthorList.IsInit()) AuthorList->toXmlWriter(pWriter); if (CommentList.IsInit()) CommentList->toXmlWriter(pWriter); pWriter->WriteNodeEnd(L"Comments"); } //----------------------------------------------------------------------------------------------------------------- EElementType CCommentList::getType() const { return et_dr_CommentList; } void CCommentList::fromXML(XmlUtils::CXmlLiteReader& oReader) { if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"CommentEntry" == sName) { CCommentEntry* pItem = new CCommentEntry(); *pItem = oReader; if (pItem) m_arrItems.push_back(pItem); } } } void CCommentList::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4; while (pReader->GetPos() < end) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { m_arrItems.push_back(new CCommentEntry()); m_arrItems.back()->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(end); } void CCommentList::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { for (size_t i = 0; i < m_arrItems.size(); ++i) pWriter->WriteRecord2(0, dynamic_cast(m_arrItems[i])); } void CCommentList::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"CommentList"); pWriter->EndAttributes(); for (size_t i = 0; i < m_arrItems.size(); ++i) m_arrItems[i]->toXmlWriter(pWriter); pWriter->WriteNodeEnd(L"CommentList"); } //----------------------------------------------------------------------------------------------------------------------------- EElementType CAuthorList::getType() const { return et_dr_AuthorList; } void CAuthorList::fromXML(XmlUtils::CXmlLiteReader& oReader) { if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"AuthorEntry" == sName) { CAuthorEntry* pItem = new CAuthorEntry(); *pItem = oReader; if (pItem) m_arrItems.push_back(pItem); } } } void CAuthorList::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4; while (pReader->GetPos() < end) { BYTE _rec = pReader->GetUChar(); switch (_rec) { case 0: { m_arrItems.push_back(new CAuthorEntry()); m_arrItems.back()->fromPPTY(pReader); }break; default: { pReader->SkipRecord(); }break; } } pReader->Seek(end); } void CAuthorList::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { for (size_t i = 0; i < m_arrItems.size(); ++i) pWriter->WriteRecord2(0, dynamic_cast(m_arrItems[i])); } void CAuthorList::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"AuthorList"); pWriter->EndAttributes(); for (size_t i = 0; i < m_arrItems.size(); ++i) m_arrItems[i]->toXmlWriter(pWriter); pWriter->WriteNodeEnd(L"AuthorList"); } //----------------------------------------------------------------------------------------------------------------------------- EElementType CCommentEntry::getType() const { return et_dr_CommentEntry; } void CCommentEntry::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "AuthorID", AuthorID) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "PageID", PageID) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ShapeID", ShapeID) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Date", Date) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "EditDate", EditDate) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Done", Done) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "CommentID", CommentID) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "AutoCommentType", AutoCommentType) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CCommentEntry::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); content = oReader.GetText2(); } void CCommentEntry::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteUInt2(0, AuthorID); pWriter->WriteUInt2(1, PageID); pWriter->WriteUInt2(2, ShapeID); pWriter->WriteString2(3, Date); pWriter->WriteString2(4, EditDate); pWriter->WriteUInt2(5, CommentID); pWriter->WriteUInt2(6, AutoCommentType); pWriter->WriteString1(7, content); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); } void CCommentEntry::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { AuthorID = pReader->GetULong(); }break; case 1: { PageID = pReader->GetULong(); }break; case 2: { ShapeID = pReader->GetULong(); }break; case 3: { Date = pReader->GetString2(); }break; case 4: { EditDate = pReader->GetString2(); }break; case 5: { CommentID = pReader->GetULong(); }break; case 6: { AutoCommentType = pReader->GetULong(); }break; case 7: { content = pReader->GetString2(); }break; } } pReader->Seek(_end_rec); } void CCommentEntry::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"CommentEntry"); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"AuthorID", AuthorID); pWriter->WriteAttribute2(L"PageID", PageID); pWriter->WriteAttribute2(L"ShapeID", ShapeID); pWriter->WriteAttribute2(L"Date", Date); pWriter->WriteAttribute2(L"EditDate", EditDate); pWriter->WriteAttribute2(L"CommentID", CommentID); pWriter->WriteAttribute2(L"AutoCommentType", AutoCommentType); pWriter->EndAttributes(); pWriter->WriteStringXML(content); pWriter->WriteNodeEnd(L"CommentEntry"); } //----------------------------------------------------------------------------------------------------------------------------- EElementType CAuthorEntry::getType() const { return et_dr_AuthorEntry; } void CAuthorEntry::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_StartChar_No_NS(oReader) WritingElement_ReadAttributes_Read_ifChar(oReader, "ID", ID) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Name", Name) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "Initials", Initials) WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ResolutionID", ResolutionID) WritingElement_ReadAttributes_EndChar_No_NS(oReader) } void CAuthorEntry::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); if (!oReader.IsEmptyNode()) oReader.ReadTillEnd(); } void CAuthorEntry::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); pWriter->WriteUInt2(0, ID); pWriter->WriteString2(1, Name); pWriter->WriteString2(2, Initials); pWriter->WriteString2(3, ResolutionID); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); } void CAuthorEntry::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader) { LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4; pReader->Skip(1); // start attributes while (true) { BYTE _at = pReader->GetUChar_TypeNode(); if (_at == NSBinPptxRW::g_nodeAttributeEnd) break; switch (_at) { case 0: { ID = pReader->GetULong(); }break; case 1: { Name = pReader->GetString2(); }break; case 2: { Initials = pReader->GetString2(); }break; case 3: { ResolutionID = pReader->GetString2(); }break; } } pReader->Seek(_end_rec); } void CAuthorEntry::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { pWriter->StartNode(L"AuthorEntry"); pWriter->StartAttributes(); pWriter->WriteAttribute2(L"ID", ID); pWriter->WriteAttribute2(L"Name", Name); pWriter->WriteAttribute2(L"Initials", Initials); pWriter->WriteAttribute2(L"ResolutionID", ResolutionID); pWriter->EndAttributes(); pWriter->WriteNodeEnd(L"AuthorEntry"); } //----------------------------------------------------------------------------------------------------------------------------- } } // namespace OOX