2143 lines
66 KiB
C++
2143 lines
66 KiB
C++
/*
|
|
* (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
|
|
*
|
|
*/
|
|
#pragma once
|
|
|
|
#include "DiagramLayout.h"
|
|
#include "../Drawing/DrawingExt.h"
|
|
|
|
#include "../Document.h"
|
|
#include "../../XlsxFormat/Xlsx.h"
|
|
|
|
#include "../../Common/SimpleTypes_Shared.h"
|
|
#include "../../Common/SimpleTypes_Drawing.h"
|
|
|
|
#include "../../Binary/Presentation/BinaryFileReaderWriter.h"
|
|
|
|
#define Diagram_Layout_Read_Xml() \
|
|
{\
|
|
ReadAttributes(oReader);\
|
|
if (oReader.IsEmptyNode())\
|
|
return;\
|
|
int nParentDepth = oReader.GetDepth();\
|
|
while (oReader.ReadNextSiblingNode(nParentDepth))\
|
|
{\
|
|
std::wstring sName = oReader.GetName();\
|
|
WritingElement *pItem = NULL;\
|
|
if (L"dgm:alg" == sName)\
|
|
AssignPtrXmlContentNoMain(pItem, CAlg, oReader)\
|
|
else if (L"dgm:choose" == sName)\
|
|
AssignPtrXmlContentNoMain(pItem, CChoose, oReader)\
|
|
else if (L"dgm:constrLst" == sName)\
|
|
AssignPtrXmlContentNoMain(pItem, CConstrLst, oReader)\
|
|
else if (L"dgm:forEach" == sName)\
|
|
AssignPtrXmlContentNoMain(pItem, CForEach, oReader)\
|
|
else if (L"dgm:layoutNode" == sName)\
|
|
AssignPtrXmlContentNoMain(pItem, CLayoutNode, oReader)\
|
|
else if (L"dgm:presOf" == sName)\
|
|
AssignPtrXmlContentNoMain(pItem, CPresOf, oReader)\
|
|
else if (L"dgm:ruleLst" == sName)\
|
|
AssignPtrXmlContentNoMain(pItem, CRuleLst, oReader)\
|
|
else if (L"dgm:shape" == sName)\
|
|
AssignPtrXmlContentNoMain(pItem, CShape, oReader)\
|
|
else if (L"dgm:varLst" == sName)\
|
|
AssignPtrXmlContentNoMain(pItem, CVariableList, oReader)\
|
|
else if (L"dgm:extLst" == sName)\
|
|
AssignPtrXmlContentNoMain(pItem, OOX::Drawing::COfficeArtExtensionList, oReader)\
|
|
if (pItem)\
|
|
m_arrItems.push_back(pItem);\
|
|
}}
|
|
//---------------------------------------------------------------------------------
|
|
#define Diagram_Layout_From_PPTY() \
|
|
while (pReader->GetPos() < end)\
|
|
{\
|
|
BYTE _rec = pReader->GetUChar();\
|
|
OOX::WritingElement *pItem = NULL;\
|
|
switch (_rec)\
|
|
{\
|
|
case DIAGRAM_LAYOUT_TYPE_ALG: pItem = new OOX::Diagram::CAlg(); break;\
|
|
case DIAGRAM_LAYOUT_TYPE_CHOOSE: pItem = new OOX::Diagram::CChoose(); break;\
|
|
case DIAGRAM_LAYOUT_TYPE_CONSTRLST: pItem = new OOX::Diagram::CConstrLst(); break;\
|
|
case DIAGRAM_LAYOUT_TYPE_FOREACH: pItem = new OOX::Diagram::CForEach(); break;\
|
|
case DIAGRAM_LAYOUT_TYPE_LAYOUTNODE: pItem = new OOX::Diagram::CLayoutNode(); break;\
|
|
case DIAGRAM_LAYOUT_TYPE_PRESOF: pItem = new OOX::Diagram::CPresOf(); break;\
|
|
case DIAGRAM_LAYOUT_TYPE_RULELST: pItem = new OOX::Diagram::CRuleLst(); break;\
|
|
case DIAGRAM_LAYOUT_TYPE_SHAPE: pItem = new OOX::Diagram::CShape(); break;\
|
|
case DIAGRAM_LAYOUT_TYPE_VARIABLELIST: pItem = new OOX::Diagram::CVariableList(); break;\
|
|
default:\
|
|
{\
|
|
pReader->SkipRecord();\
|
|
}break;\
|
|
}\
|
|
if (pItem)\
|
|
{\
|
|
pItem->fromPPTY(pReader);\
|
|
m_arrItems.push_back(pItem);\
|
|
}\
|
|
}
|
|
//-----------------------------------------------------------------------------------------------------
|
|
#define Diagram_Layout_To_PPTY() \
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)\
|
|
{\
|
|
if (!m_arrItems[i]) continue;\
|
|
switch (m_arrItems[i]->getType())\
|
|
{\
|
|
case OOX::et_dgm_Alg: pWriter->WriteRecord2(DIAGRAM_LAYOUT_TYPE_ALG, m_arrItems[i]); break;\
|
|
case OOX::et_dgm_Choose: pWriter->WriteRecord2(DIAGRAM_LAYOUT_TYPE_CHOOSE, m_arrItems[i]); break;\
|
|
case OOX::et_dgm_ConstrLst: pWriter->WriteRecord2(DIAGRAM_LAYOUT_TYPE_CONSTRLST, m_arrItems[i]); break;\
|
|
case OOX::et_dgm_ForEach: pWriter->WriteRecord2(DIAGRAM_LAYOUT_TYPE_FOREACH, m_arrItems[i]); break;\
|
|
case OOX::et_dgm_LayoutNode: pWriter->WriteRecord2(DIAGRAM_LAYOUT_TYPE_LAYOUTNODE, m_arrItems[i]); break;\
|
|
case OOX::et_dgm_PresOf: pWriter->WriteRecord2(DIAGRAM_LAYOUT_TYPE_PRESOF, m_arrItems[i]); break;\
|
|
case OOX::et_dgm_RuleLst: pWriter->WriteRecord2(DIAGRAM_LAYOUT_TYPE_RULELST, m_arrItems[i]); break;\
|
|
case OOX::et_dgm_Shape: pWriter->WriteRecord2(DIAGRAM_LAYOUT_TYPE_SHAPE, m_arrItems[i]); break;\
|
|
case OOX::et_dgm_VariableList: pWriter->WriteRecord2(DIAGRAM_LAYOUT_TYPE_VARIABLELIST, m_arrItems[i]); break;\
|
|
default:\
|
|
break;\
|
|
}\
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------------------------
|
|
namespace OOX
|
|
{
|
|
CDiagramLayout::CDiagramLayout(OOX::Document* pMain, bool bDocument) : OOX::IFileContainer(pMain), OOX::FileGlobalEnumerated(pMain)
|
|
{
|
|
m_bDocument = bDocument;
|
|
m_bSpreadsheets = (NULL != dynamic_cast<OOX::Spreadsheet::CXlsx*>(pMain));
|
|
}
|
|
CDiagramLayout::CDiagramLayout(OOX::Document* pMain, const CPath& uri) : OOX::IFileContainer(pMain), OOX::FileGlobalEnumerated(pMain)
|
|
{
|
|
m_bDocument = (NULL != dynamic_cast<OOX::CDocument*>(pMain));
|
|
m_bSpreadsheets = (NULL != dynamic_cast<OOX::Spreadsheet::CXlsx*>(pMain));
|
|
|
|
read(uri.GetDirectory(), uri);
|
|
}
|
|
CDiagramLayout::CDiagramLayout(OOX::Document* pMain, const CPath& oRootPath, const CPath& oPath) : OOX::IFileContainer(pMain), OOX::FileGlobalEnumerated(pMain)
|
|
{
|
|
m_bDocument = (NULL != dynamic_cast<OOX::CDocument*>(pMain));
|
|
m_bSpreadsheets = (NULL != dynamic_cast<OOX::Spreadsheet::CXlsx*>(pMain));
|
|
|
|
read(oRootPath, oPath);
|
|
}
|
|
CDiagramLayout::~CDiagramLayout()
|
|
{
|
|
}
|
|
void CDiagramLayout::read(const CPath& oFilePath)
|
|
{
|
|
CPath oRootPath;
|
|
read(oRootPath, oFilePath);
|
|
}
|
|
void CDiagramLayout::read(const CPath& oRootPath, const CPath& oFilePath)
|
|
{
|
|
IFileContainer::Read(oRootPath, oFilePath);
|
|
|
|
XmlUtils::CXmlLiteReader oReader;
|
|
|
|
if (!oReader.FromFile(oFilePath.GetPath()))
|
|
return;
|
|
|
|
if (!oReader.ReadNextNode())
|
|
return;
|
|
|
|
std::wstring sName = oReader.GetName();
|
|
if (L"dgm:layoutDef" == sName)
|
|
{
|
|
ReadAttributes(oReader);
|
|
|
|
if (!oReader.IsEmptyNode())
|
|
{
|
|
int nNumberingDepth = oReader.GetDepth();
|
|
while (oReader.ReadNextSiblingNode(nNumberingDepth))
|
|
{
|
|
sName = oReader.GetName();
|
|
nullable_string m_sUniqueId;
|
|
nullable_string m_sMinVer;
|
|
|
|
if (L"dgm:catLst" == sName)
|
|
{
|
|
m_oCatLst = oReader;
|
|
}
|
|
else if (L"dgm:desc" == sName)
|
|
{
|
|
m_oDesc = oReader;
|
|
}
|
|
else if (L"dgm:title" == sName)
|
|
{
|
|
m_oTitle = oReader;
|
|
}
|
|
else if (L"dgm:clrData" == sName)
|
|
{
|
|
m_oClrData = oReader;
|
|
}
|
|
else if (L"dgm:layoutNode" == sName)
|
|
{
|
|
m_oLayoutNode = oReader;
|
|
}
|
|
else if (L"dgm:sampData" == sName)
|
|
{
|
|
m_oSampData = oReader;
|
|
}
|
|
else if (L"dgm:styleData" == sName)
|
|
{
|
|
m_oStyleData = oReader;
|
|
}
|
|
else if (L"dgm:extLst" == sName)
|
|
{
|
|
m_oExtLst = oReader;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void CDiagramLayout::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"uniqueId", m_sUniqueId)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"minVer", m_sMinVer)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"defStyle", m_sDefStyle)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
}
|
|
void CDiagramLayout::write(const CPath& oFilePath, const CPath& oDirectory, CContentTypes& oContent) const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oXmlWriter;
|
|
oXmlWriter.WriteString((L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"));
|
|
|
|
oXmlWriter.m_lDocType = XMLWRITER_DOC_TYPE_DIAGRAM;
|
|
toXmlWriter(&oXmlWriter);
|
|
|
|
NSFile::CFileBinary::SaveToFile(oFilePath.GetPath(), oXmlWriter.GetXmlString());
|
|
|
|
oContent.Registration(type().OverrideType(), oDirectory, oFilePath.GetFilename());
|
|
IFileContainer::Write(oFilePath, oDirectory, oContent);
|
|
}
|
|
const OOX::FileType CDiagramLayout::type() const
|
|
{
|
|
return FileTypes::DiagramLayout;
|
|
}
|
|
const CPath CDiagramLayout::DefaultDirectory() const
|
|
{
|
|
if (m_bDocument)
|
|
return type().DefaultDirectory();
|
|
else
|
|
return L"../" + type().DefaultDirectory();
|
|
}
|
|
const CPath CDiagramLayout::DefaultFileName() const
|
|
{
|
|
return type().DefaultFileName();
|
|
}
|
|
void CDiagramLayout::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_sUniqueId = pReader->GetString2();
|
|
else if (1 == _at) m_sMinVer = pReader->GetString2();
|
|
else if (2 == _at) m_sDefStyle = pReader->GetString2();
|
|
}
|
|
while (pReader->GetPos() < end)
|
|
{
|
|
BYTE _rec = pReader->GetUChar();
|
|
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
m_oTitle.Init();
|
|
m_oTitle->node_name = L"dgm:title";
|
|
m_oTitle->fromPPTY(pReader);
|
|
}break;
|
|
case 1:
|
|
{
|
|
m_oDesc.Init();
|
|
m_oDesc->node_name = L"dgm:desc";
|
|
m_oDesc->fromPPTY(pReader);
|
|
}break;
|
|
case 2:
|
|
{
|
|
m_oCatLst.Init();
|
|
m_oCatLst->fromPPTY(pReader);
|
|
}break;
|
|
case 3:
|
|
{
|
|
m_oSampData.Init(); m_oSampData->node_name = L"dgm:sampData";
|
|
m_oSampData->fromPPTY(pReader);
|
|
}break;
|
|
case 4:
|
|
{
|
|
m_oStyleData.Init(); m_oStyleData->node_name = L"dgm:styleData";
|
|
m_oStyleData->fromPPTY(pReader);
|
|
}break;
|
|
case 5:
|
|
{
|
|
m_oClrData.Init(); m_oClrData->node_name = L"dgm:clrData";
|
|
m_oClrData->fromPPTY(pReader);
|
|
}break;
|
|
case DIAGRAM_LAYOUT_TYPE_LAYOUTNODE:
|
|
{
|
|
m_oLayoutNode.Init();
|
|
m_oLayoutNode->fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
{
|
|
pReader->SkipRecord();
|
|
}break;
|
|
}
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void CDiagramLayout::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteString2(0, m_sUniqueId);
|
|
pWriter->WriteString2(1, m_sMinVer);
|
|
pWriter->WriteString2(2, m_sDefStyle);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
|
|
pWriter->WriteRecord2(0, m_oTitle);
|
|
pWriter->WriteRecord2(1, m_oDesc);
|
|
pWriter->WriteRecord2(2, m_oCatLst);
|
|
pWriter->WriteRecord2(3, m_oSampData);
|
|
pWriter->WriteRecord2(4, m_oStyleData);
|
|
pWriter->WriteRecord2(5, m_oClrData);
|
|
pWriter->WriteRecord2(DIAGRAM_LAYOUT_TYPE_LAYOUTNODE, m_oLayoutNode);
|
|
}
|
|
void CDiagramLayout::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:layoutDef");
|
|
|
|
pWriter->StartAttributes();
|
|
pWriter->WriteAttribute(L"xmlns:dgm", L"http://schemas.openxmlformats.org/drawingml/2006/diagram");
|
|
pWriter->WriteAttribute(L"xmlns:a", L"http://schemas.openxmlformats.org/drawingml/2006/main");
|
|
pWriter->WriteAttribute(L"xmlns:r", L"http://schemas.openxmlformats.org/officeDocument/2006/relationships");
|
|
|
|
pWriter->WriteAttribute(L"uniqueId", m_sUniqueId);
|
|
pWriter->WriteAttribute(L"minVer", m_sMinVer);
|
|
pWriter->WriteAttribute(L"defStyle", m_sDefStyle);
|
|
pWriter->EndAttributes();
|
|
|
|
if (m_oTitle.IsInit()) m_oTitle->toXmlWriter(pWriter);
|
|
if (m_oDesc.IsInit()) m_oDesc->toXmlWriter(pWriter);
|
|
if (m_oCatLst.IsInit()) m_oCatLst->toXmlWriter(pWriter);
|
|
if (m_oSampData.IsInit()) m_oSampData->toXmlWriter(pWriter);
|
|
if (m_oStyleData.IsInit()) m_oStyleData->toXmlWriter(pWriter);
|
|
if (m_oClrData.IsInit()) m_oClrData->toXmlWriter(pWriter);
|
|
if (m_oLayoutNode.IsInit()) m_oLayoutNode->toXmlWriter(pWriter);
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:layoutDef");
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CDiferentData::CDiferentData() {}
|
|
Diagram::CDiferentData::~CDiferentData() {}
|
|
std::wstring Diagram::CDiferentData::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CDiferentData::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CDiferentData::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
node_name = oReader.GetName();
|
|
|
|
ReadAttributes(oReader);
|
|
|
|
if (oReader.IsEmptyNode())
|
|
return;
|
|
|
|
int nParentDepth = oReader.GetDepth();
|
|
while (oReader.ReadNextSiblingNode(nParentDepth))
|
|
{
|
|
std::wstring sName = oReader.GetName();
|
|
|
|
if (L"dgm:dataModel" == sName)
|
|
{
|
|
m_oDataModel = oReader;
|
|
}
|
|
}
|
|
|
|
}
|
|
EElementType Diagram::CDiferentData::getType() const
|
|
{
|
|
return et_dgm_DiferentData;
|
|
}
|
|
void Diagram::CDiferentData::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_bUseDef = pReader->GetBool();
|
|
}
|
|
|
|
while (pReader->GetPos() < end)
|
|
{
|
|
BYTE _rec = pReader->GetUChar();
|
|
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
m_oDataModel.Init(); m_oDataModel->bMain = false;
|
|
m_oDataModel->fromPPTY(pReader);
|
|
|
|
}break;
|
|
default:
|
|
{
|
|
pReader->SkipRecord();
|
|
}break;
|
|
}
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CDiferentData::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteBool2(0, m_bUseDef);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
|
|
pWriter->WriteRecord2(0, m_oDataModel);
|
|
}
|
|
void Diagram::CDiferentData::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(node_name);
|
|
pWriter->WriteAttribute(L"useDef", m_bUseDef);
|
|
pWriter->EndAttributes();
|
|
if (m_oDataModel.IsInit())
|
|
m_oDataModel->toXmlWriter(pWriter);
|
|
pWriter->WriteNodeEnd(node_name);
|
|
}
|
|
void Diagram::CDiferentData::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"useDef", m_bUseDef)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CLayoutNode::CLayoutNode() {}
|
|
Diagram::CLayoutNode::~CLayoutNode() {}
|
|
std::wstring Diagram::CLayoutNode::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CLayoutNode::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CLayoutNode::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
Diagram_Layout_Read_Xml()
|
|
}
|
|
EElementType Diagram::CLayoutNode::getType() const
|
|
{
|
|
return et_dgm_LayoutNode;
|
|
}
|
|
void Diagram::CLayoutNode::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_sName = pReader->GetString2();
|
|
else if (1 == _at) m_sStyleLbl = pReader->GetString2();
|
|
else if (2 == _at) m_sMoveWith = pReader->GetString2();
|
|
else if (3 == _at)
|
|
{
|
|
m_oChOrder.Init();
|
|
m_oChOrder->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
}
|
|
Diagram_Layout_From_PPTY()
|
|
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CLayoutNode::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteString2(0, m_sName);
|
|
pWriter->WriteString2(1, m_sStyleLbl);
|
|
pWriter->WriteString2(2, m_sMoveWith);
|
|
if (m_oChOrder.IsInit()) pWriter->WriteByte1(3, m_oChOrder->GetValue());
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
|
|
Diagram_Layout_To_PPTY()
|
|
}
|
|
void Diagram::CLayoutNode::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:layoutNode");
|
|
pWriter->WriteAttribute(L"name", m_sName);
|
|
pWriter->WriteAttribute(L"styleLbl", m_sStyleLbl);
|
|
pWriter->WriteAttribute(L"moveWith", m_sMoveWith);
|
|
if (m_oChOrder.IsInit()) pWriter->WriteAttribute(L"chOrder", m_oChOrder->ToString());
|
|
pWriter->EndAttributes();
|
|
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
{
|
|
if (!m_arrItems[i]) continue;
|
|
|
|
m_arrItems[i]->toXmlWriter(pWriter);
|
|
}
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:layoutNode");
|
|
}
|
|
void Diagram::CLayoutNode::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"name", m_sName)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"styleLbl", m_sStyleLbl)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"moveWith", m_sMoveWith)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"chOrder", m_oChOrder)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CForEach::CForEach() {}
|
|
Diagram::CForEach::~CForEach() {}
|
|
std::wstring Diagram::CForEach::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CForEach::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CForEach::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
Diagram_Layout_Read_Xml()
|
|
}
|
|
EElementType Diagram::CForEach::getType() const
|
|
{
|
|
return et_dgm_ForEach;
|
|
}
|
|
void Diagram::CForEach::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_sName = pReader->GetString2();
|
|
else if (1 == _at) m_arSt.push_back(pReader->GetLong());
|
|
else if (2 == _at) m_arStep.push_back(pReader->GetLong());
|
|
else if (3 == _at) m_arHideLastTrans.push_back(pReader->GetBool());
|
|
else if (4 == _at) m_arCnt.push_back(pReader->GetLong());
|
|
else if (5 == _at)
|
|
{
|
|
SimpleTypes::CAxisTypes axis; axis.SetValueFromByte(pReader->GetUChar());
|
|
m_arAxis.push_back(axis);
|
|
}
|
|
else if (6 == _at)
|
|
{
|
|
SimpleTypes::CElementTypes ptType; ptType.SetValueFromByte(pReader->GetUChar());
|
|
m_arPtType.push_back(ptType);
|
|
}
|
|
else if (7 == _at) m_sRef = pReader->GetString2();
|
|
}
|
|
|
|
Diagram_Layout_From_PPTY()
|
|
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CForEach::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteString2(0, m_sName);
|
|
for (size_t i = 0; i < m_arSt.size(); ++i)
|
|
pWriter->WriteInt1(1, m_arSt[i]);
|
|
for (size_t i = 0; i < m_arStep.size(); ++i)
|
|
pWriter->WriteInt1(2, m_arStep[i]);
|
|
for (size_t i = 0; i < m_arHideLastTrans.size(); ++i)
|
|
pWriter->WriteBool1(3, m_arHideLastTrans[i]);
|
|
for (size_t i = 0; i < m_arCnt.size(); ++i)
|
|
pWriter->WriteInt1(4, m_arCnt[i]);
|
|
for (size_t i = 0; i < m_arAxis.size(); ++i)
|
|
pWriter->WriteByte1(5, m_arAxis[i].GetValue());
|
|
for (size_t i = 0; i < m_arPtType.size(); ++i)
|
|
pWriter->WriteByte1(6, m_arPtType[i].GetValue());
|
|
pWriter->WriteString2(7, m_sRef);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
|
|
Diagram_Layout_To_PPTY()
|
|
}
|
|
void Diagram::CForEach::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:forEach");
|
|
pWriter->WriteAttribute(L"name", m_sName);
|
|
if (false == m_arAxis.empty())
|
|
{
|
|
std::wstring sAxis;
|
|
for (size_t i = 0; i < m_arAxis.size(); ++i) sAxis += L" " + m_arAxis[i].ToString();
|
|
pWriter->WriteAttribute(L"axis", sAxis.substr(1));
|
|
}
|
|
if (false == m_arPtType.empty())
|
|
{
|
|
std::wstring sPtType;
|
|
for (size_t i = 0; i < m_arPtType.size(); ++i) sPtType += L" " + m_arPtType[i].ToString();
|
|
pWriter->WriteAttribute(L"ptType", sPtType.substr(1));
|
|
}
|
|
if (false == m_arSt.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arSt.size(); ++i) sRes += L" " + std::to_wstring(m_arSt[i]);
|
|
pWriter->WriteAttribute(L"st", sRes.substr(1));
|
|
}
|
|
if (false == m_arCnt.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arCnt.size(); ++i) sRes += L" " + std::to_wstring(m_arCnt[i]);
|
|
pWriter->WriteAttribute(L"cnt", sRes.substr(1));
|
|
}
|
|
if (false == m_arStep.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arStep.size(); ++i) sRes += L" " + std::to_wstring(m_arStep[i]);
|
|
pWriter->WriteAttribute(L"step", sRes.substr(1));
|
|
}
|
|
if (false == m_arHideLastTrans.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arHideLastTrans.size(); ++i) sRes += (m_arHideLastTrans[i] ? L" 1" : L" 0");
|
|
pWriter->WriteAttribute(L"hideLastTrans", sRes.substr(1));
|
|
}
|
|
pWriter->WriteAttribute(L"ref", m_sRef);
|
|
pWriter->EndAttributes();
|
|
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
{
|
|
if (!m_arrItems[i]) continue;
|
|
|
|
m_arrItems[i]->toXmlWriter(pWriter);
|
|
}
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:forEach");
|
|
}
|
|
void Diagram::CForEach::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
nullable_string sPtTypes, sAxis, sCnt, sStep, sHideLastTrans, sSt;
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"name", m_sName)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"axis", sAxis)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"cnt", sCnt)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"hideLastTrans", sHideLastTrans)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"ptType", sPtTypes)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"ref", m_sRef)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"st", sSt)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"step", sStep)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
|
|
if (sAxis.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sAxis, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arAxis.push_back(SimpleTypes::CAxisTypes(arStr[i]));
|
|
}
|
|
if (sPtTypes.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sPtTypes, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arPtType.push_back(SimpleTypes::CElementTypes(arStr[i]));
|
|
}
|
|
if (sSt.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sSt, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arSt.push_back(XmlUtils::GetInteger(arStr[i]));
|
|
}
|
|
if (sCnt.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sCnt, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arCnt.push_back(XmlUtils::GetInteger(arStr[i]));
|
|
}
|
|
if (sStep.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sStep, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arStep.push_back(XmlUtils::GetInteger(arStr[i]));
|
|
}
|
|
if (sHideLastTrans.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sHideLastTrans, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arHideLastTrans.push_back(SimpleTypes::COnOff(arStr[i]).ToBool());
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CIf::CIf() {}
|
|
Diagram::CIf::~CIf() {}
|
|
std::wstring Diagram::CIf::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CIf::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CIf::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
Diagram_Layout_Read_Xml()
|
|
}
|
|
EElementType Diagram::CIf::getType() const
|
|
{
|
|
return et_dgm_If;
|
|
}
|
|
void Diagram::CIf::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_sName = pReader->GetString2();
|
|
else if (1 == _at) m_arSt.push_back(pReader->GetLong());
|
|
else if (2 == _at) m_arStep.push_back(pReader->GetLong());
|
|
else if (3 == _at) m_arHideLastTrans.push_back(pReader->GetBool());
|
|
else if (4 == _at) m_arCnt.push_back(pReader->GetLong());
|
|
else if (5 == _at)
|
|
{
|
|
SimpleTypes::CAxisTypes axis; axis.SetValueFromByte(pReader->GetUChar());
|
|
m_arAxis.push_back(axis);
|
|
}
|
|
else if (6 == _at)
|
|
{
|
|
SimpleTypes::CElementTypes ptType; ptType.SetValueFromByte(pReader->GetUChar());
|
|
m_arPtType.push_back(ptType);
|
|
}
|
|
else if (7 == _at) m_sRef = pReader->GetString2();
|
|
else if (8 == _at)
|
|
{
|
|
m_oOp.Init();
|
|
m_oOp->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (9 == _at)
|
|
{
|
|
m_oFunc.Init();
|
|
m_oFunc->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (10 == _at) m_sVal = pReader->GetString2();
|
|
else if (11 == _at) m_sArg = pReader->GetString2();
|
|
}
|
|
Diagram_Layout_From_PPTY()
|
|
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CIf::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteString2(0, m_sName);
|
|
for (size_t i = 0; i < m_arSt.size(); ++i)
|
|
pWriter->WriteInt1(1, m_arSt[i]);
|
|
for (size_t i = 0; i < m_arStep.size(); ++i)
|
|
pWriter->WriteInt1(2, m_arStep[i]);
|
|
for (size_t i = 0; i < m_arHideLastTrans.size(); ++i)
|
|
pWriter->WriteBool1(3, m_arHideLastTrans[i]);
|
|
for (size_t i = 0; i < m_arCnt.size(); ++i)
|
|
pWriter->WriteInt1(4, m_arCnt[i]);
|
|
for (size_t i = 0; i < m_arAxis.size(); ++i)
|
|
pWriter->WriteByte1(5, m_arAxis[i].GetValue());
|
|
for (size_t i = 0; i < m_arPtType.size(); ++i)
|
|
pWriter->WriteByte1(6, m_arPtType[i].GetValue());
|
|
pWriter->WriteString2(7, m_sRef);
|
|
if (m_oOp.IsInit()) pWriter->WriteByte1(8, m_oOp->GetValue());
|
|
if (m_oFunc.IsInit()) pWriter->WriteByte1(9, m_oFunc->GetValue());
|
|
pWriter->WriteString2(10, m_sVal);
|
|
pWriter->WriteString2(11, m_sArg);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
|
|
Diagram_Layout_To_PPTY()
|
|
}
|
|
void Diagram::CIf::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:if");
|
|
pWriter->WriteAttribute(L"name", m_sName);
|
|
if (false == m_arAxis.empty())
|
|
{
|
|
std::wstring sAxis;
|
|
for (size_t i = 0; i < m_arAxis.size(); ++i) sAxis += L" " + m_arAxis[i].ToString();
|
|
pWriter->WriteAttribute(L"axis", sAxis.substr(1));
|
|
}
|
|
if (false == m_arPtType.empty())
|
|
{
|
|
std::wstring sPtType;
|
|
for (size_t i = 0; i < m_arPtType.size(); ++i) sPtType += L" " + m_arPtType[i].ToString();
|
|
pWriter->WriteAttribute(L"ptType", sPtType.substr(1));
|
|
}
|
|
if (false == m_arSt.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arSt.size(); ++i) sRes += L" " + std::to_wstring(m_arSt[i]);
|
|
pWriter->WriteAttribute(L"st", sRes.substr(1));
|
|
}
|
|
if (false == m_arCnt.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arCnt.size(); ++i) sRes += L" " + std::to_wstring(m_arCnt[i]);
|
|
pWriter->WriteAttribute(L"cnt", sRes.substr(1));
|
|
}
|
|
if (m_oFunc.IsInit()) pWriter->WriteAttribute(L"func", m_oFunc->ToString());
|
|
pWriter->WriteAttribute(L"arg", m_sArg);
|
|
if (false == m_arStep.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arStep.size(); ++i) sRes += L" " + std::to_wstring(m_arStep[i]);
|
|
pWriter->WriteAttribute(L"step", sRes.substr(1));
|
|
}
|
|
if (false == m_arHideLastTrans.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arHideLastTrans.size(); ++i) sRes += (m_arHideLastTrans[i] ? L" 1" : L" 0");
|
|
pWriter->WriteAttribute(L"hideLastTrans", sRes.substr(1));
|
|
}
|
|
|
|
if (m_oOp.IsInit()) pWriter->WriteAttribute(L"op", m_oOp->ToString());
|
|
pWriter->WriteAttribute(L"ref", m_sRef);
|
|
pWriter->WriteAttribute(L"val", m_sVal);
|
|
pWriter->EndAttributes();
|
|
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
{
|
|
if (!m_arrItems[i]) continue;
|
|
|
|
m_arrItems[i]->toXmlWriter(pWriter);
|
|
}
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:if");
|
|
}
|
|
void Diagram::CIf::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
nullable_string sPtTypes, sAxis, sCnt, sStep, sHideLastTrans, sSt;
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"name", m_sName)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"axis", sAxis)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"cnt", sCnt)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"hideLastTrans", sHideLastTrans)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"ptType", sPtTypes)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"ref", m_sRef)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"st", sSt)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"step", sStep)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"arg", m_sArg)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"func", m_oFunc)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"op", m_oOp)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"val", m_sVal)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
if (sAxis.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sAxis, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arAxis.push_back(SimpleTypes::CAxisTypes(arStr[i]));
|
|
}
|
|
if (sPtTypes.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sPtTypes, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arPtType.push_back(SimpleTypes::CElementTypes(arStr[i]));
|
|
}
|
|
if (sSt.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sSt, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arSt.push_back(XmlUtils::GetInteger(arStr[i]));
|
|
}
|
|
if (sCnt.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sCnt, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arCnt.push_back(XmlUtils::GetInteger(arStr[i]));
|
|
}
|
|
if (sStep.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sStep, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arStep.push_back(XmlUtils::GetInteger(arStr[i]));
|
|
}
|
|
if (sHideLastTrans.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sHideLastTrans, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arHideLastTrans.push_back(SimpleTypes::COnOff(arStr[i]).ToBool());
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CElse::CElse() {}
|
|
Diagram::CElse::~CElse() {}
|
|
std::wstring Diagram::CElse::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CElse::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CElse::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
Diagram_Layout_Read_Xml()
|
|
}
|
|
EElementType Diagram::CElse::getType() const
|
|
{
|
|
return et_dgm_Else;
|
|
}
|
|
void Diagram::CElse::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_sName = pReader->GetString2();
|
|
}
|
|
Diagram_Layout_From_PPTY()
|
|
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CElse::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteString2(0, m_sName);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
|
|
Diagram_Layout_To_PPTY()
|
|
}
|
|
void Diagram::CElse::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:else");
|
|
pWriter->WriteAttribute(L"name", m_sName);
|
|
pWriter->EndAttributes();
|
|
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
{
|
|
if (!m_arrItems[i]) continue;
|
|
|
|
m_arrItems[i]->toXmlWriter(pWriter);
|
|
}
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:else");
|
|
}
|
|
void Diagram::CElse::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"name", m_sName)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CChoose::CChoose() {}
|
|
Diagram::CChoose::~CChoose() {}
|
|
std::wstring Diagram::CChoose::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CChoose::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CChoose::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"dgm:if" == sName)
|
|
{
|
|
OOX::Diagram::CIf *pItem = new Diagram::CIf();
|
|
*pItem = oReader;
|
|
|
|
if (pItem)
|
|
m_arrItems.push_back(pItem);
|
|
}
|
|
else if (L"dgm:else" == sName)
|
|
{
|
|
m_oElse = oReader;
|
|
}
|
|
}
|
|
}
|
|
EElementType Diagram::CChoose::getType() const
|
|
{
|
|
return et_dgm_Choose;
|
|
}
|
|
void Diagram::CChoose::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_sName = pReader->GetString2();
|
|
}
|
|
while (pReader->GetPos() < end)
|
|
{
|
|
BYTE _rec = pReader->GetUChar();
|
|
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
m_arrItems.push_back(new Diagram::CIf());
|
|
m_arrItems.back()->fromPPTY(pReader);
|
|
}break;
|
|
case 1:
|
|
{
|
|
m_oElse.Init();
|
|
m_oElse->fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
{
|
|
pReader->SkipRecord();
|
|
}break;
|
|
}
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CChoose::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteString2(0, m_sName);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
pWriter->WriteRecord2(0, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
|
|
|
|
pWriter->WriteRecord2(1, m_oElse);
|
|
}
|
|
void Diagram::CChoose::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:choose");
|
|
pWriter->WriteAttribute(L"name", m_sName);
|
|
pWriter->EndAttributes();
|
|
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
m_arrItems[i]->toXmlWriter(pWriter);
|
|
|
|
if (m_oElse.IsInit()) m_oElse->toXmlWriter(pWriter);
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:choose");
|
|
}
|
|
void Diagram::CChoose::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"name", m_sName)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CAlg::CAlg() {}
|
|
Diagram::CAlg::~CAlg() {}
|
|
std::wstring Diagram::CAlg::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CAlg::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CAlg::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"dgm:param" == sName)
|
|
{
|
|
CParam* pItem = new CParam();
|
|
*pItem = oReader;
|
|
|
|
if (pItem)
|
|
m_arrItems.push_back(pItem);
|
|
}
|
|
else if (L"dgm:extLst" == sName)
|
|
m_oExtLst = oReader;
|
|
}
|
|
|
|
}
|
|
EElementType Diagram::CAlg::getType() const
|
|
{
|
|
return et_dgm_Alg;
|
|
}
|
|
void Diagram::CAlg::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_nRev = pReader->GetULong();
|
|
else if (1 == _at)
|
|
{
|
|
m_oType.Init();
|
|
m_oType->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
}
|
|
while (pReader->GetPos() < end)
|
|
{
|
|
BYTE _rec = pReader->GetUChar();
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
m_arrItems.push_back(new Diagram::CParam());
|
|
m_arrItems.back()->fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
{
|
|
pReader->SkipRecord();
|
|
}break;
|
|
}
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CAlg::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteUInt2(0, m_nRev);
|
|
if (m_oType.IsInit()) pWriter->WriteByte1(1, m_oType->GetValue());
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
pWriter->WriteRecord2(0, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
|
|
}
|
|
void Diagram::CAlg::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:alg");
|
|
if (m_oType.IsInit()) pWriter->WriteAttribute(L"type", m_oType->ToString());
|
|
pWriter->WriteAttribute2(L"rev", m_nRev);
|
|
pWriter->EndAttributes();
|
|
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
m_arrItems[i]->toXmlWriter(pWriter);
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:alg");
|
|
}
|
|
void Diagram::CAlg::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"rev", m_nRev)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"type", m_oType)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CConstrLst::CConstrLst() {}
|
|
Diagram::CConstrLst::~CConstrLst() {}
|
|
std::wstring Diagram::CConstrLst::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CConstrLst::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CConstrLst::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
if (oReader.IsEmptyNode())
|
|
return;
|
|
int nParentDepth = oReader.GetDepth();
|
|
while (oReader.ReadNextSiblingNode(nParentDepth))
|
|
{
|
|
std::wstring sName = oReader.GetName();
|
|
|
|
if (L"dgm:constr" == sName)
|
|
{
|
|
CConstraint* pItem = new CConstraint();
|
|
*pItem = oReader;
|
|
|
|
if (pItem)
|
|
m_arrItems.push_back(pItem);
|
|
}
|
|
}
|
|
}
|
|
EElementType Diagram::CConstrLst::getType() const
|
|
{
|
|
return et_dgm_ConstrLst;
|
|
}
|
|
void Diagram::CConstrLst::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 Diagram::CConstraint());
|
|
m_arrItems.back()->fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
{
|
|
pReader->SkipRecord();
|
|
}break;
|
|
}
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CConstrLst::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
pWriter->WriteRecord2(0, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
|
|
}
|
|
void Diagram::CConstrLst::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:constrLst");
|
|
pWriter->EndAttributes();
|
|
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
m_arrItems[i]->toXmlWriter(pWriter);
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:constrLst");
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CRuleLst::CRuleLst() {}
|
|
Diagram::CRuleLst::~CRuleLst() {}
|
|
std::wstring Diagram::CRuleLst::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CRuleLst::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CRuleLst::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
if (oReader.IsEmptyNode())
|
|
return;
|
|
int nParentDepth = oReader.GetDepth();
|
|
while (oReader.ReadNextSiblingNode(nParentDepth))
|
|
{
|
|
std::wstring sName = oReader.GetName();
|
|
|
|
if (L"dgm:rule" == sName)
|
|
{
|
|
CRule* pItem = new CRule();
|
|
*pItem = oReader;
|
|
|
|
if (pItem)
|
|
m_arrItems.push_back(pItem);
|
|
}
|
|
}
|
|
}
|
|
EElementType Diagram::CRuleLst::getType() const
|
|
{
|
|
return et_dgm_RuleLst;
|
|
}
|
|
void Diagram::CRuleLst::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 Diagram::CRule());
|
|
m_arrItems.back()->fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
{
|
|
pReader->SkipRecord();
|
|
}break;
|
|
}
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CRuleLst::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
pWriter->WriteRecord2(0, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
|
|
}
|
|
void Diagram::CRuleLst::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:ruleLst");
|
|
pWriter->EndAttributes();
|
|
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
m_arrItems[i]->toXmlWriter(pWriter);
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:ruleLst");
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CAdjLst::CAdjLst() {}
|
|
Diagram::CAdjLst::~CAdjLst() {}
|
|
std::wstring Diagram::CAdjLst::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CAdjLst::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CAdjLst::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
if (oReader.IsEmptyNode())
|
|
return;
|
|
int nParentDepth = oReader.GetDepth();
|
|
while (oReader.ReadNextSiblingNode(nParentDepth))
|
|
{
|
|
std::wstring sName = oReader.GetName();
|
|
|
|
if (L"dgm:adj" == sName)
|
|
{
|
|
CShapeAdjust* pItem = new CShapeAdjust();
|
|
*pItem = oReader;
|
|
|
|
if (pItem)
|
|
m_arrItems.push_back(pItem);
|
|
}
|
|
}
|
|
}
|
|
EElementType Diagram::CAdjLst::getType() const
|
|
{
|
|
return et_dgm_AdjLst;
|
|
}
|
|
void Diagram::CAdjLst::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 Diagram::CShapeAdjust());
|
|
m_arrItems.back()->fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
{
|
|
pReader->SkipRecord();
|
|
}break;
|
|
}
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CAdjLst::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
pWriter->WriteRecord2(0, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
|
|
}
|
|
void Diagram::CAdjLst::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:adjLst");
|
|
pWriter->EndAttributes();
|
|
|
|
for (size_t i = 0; i < m_arrItems.size(); ++i)
|
|
m_arrItems[i]->toXmlWriter(pWriter);
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:adjLst");
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CConstraint::CConstraint() {}
|
|
Diagram::CConstraint::~CConstraint() {}
|
|
std::wstring Diagram::CConstraint::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CConstraint::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CConstraint::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"dgm:extLst" == sName)
|
|
m_oExtLst = oReader;
|
|
}
|
|
|
|
}
|
|
EElementType Diagram::CConstraint::getType() const
|
|
{
|
|
return et_dgm_Constraint;
|
|
}
|
|
void Diagram::CConstraint::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_oFact = pReader->GetDoubleReal();
|
|
else if (1 == _at)
|
|
{
|
|
m_oFor.Init();
|
|
m_oFor->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (2 == _at) m_oForName = pReader->GetString2();
|
|
else if (3 == _at)
|
|
{
|
|
m_oOp.Init();
|
|
m_oOp->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (4 == _at)
|
|
{
|
|
m_oPtType.Init();
|
|
m_oPtType->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (5 == _at)
|
|
{
|
|
m_oRefFor.Init();
|
|
m_oRefFor->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (6 == _at) m_oRefForName = pReader->GetString2();
|
|
else if (7 == _at)
|
|
{
|
|
m_oRefPtType.Init();
|
|
m_oRefPtType->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (8 == _at)
|
|
{
|
|
m_oRefType.Init();
|
|
m_oRefType->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (9 == _at)
|
|
{
|
|
m_oType.Init();
|
|
m_oType->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (10 == _at)
|
|
{
|
|
m_oVal.Init();
|
|
m_oVal->SetValue(pReader->GetDoubleReal());
|
|
}
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CConstraint::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteDoubleReal2(0, m_oFact);
|
|
if (m_oFor.IsInit()) pWriter->WriteByte1(1, m_oFor->GetValue());
|
|
pWriter->WriteString2(2, m_oForName);
|
|
if (m_oOp.IsInit()) pWriter->WriteByte1(3, m_oOp->GetValue());
|
|
if (m_oPtType.IsInit()) pWriter->WriteByte1(4, m_oPtType->GetValue());
|
|
if (m_oRefFor.IsInit()) pWriter->WriteByte1(5, m_oRefFor->GetValue());
|
|
pWriter->WriteString2(6, m_oRefForName);
|
|
if (m_oRefPtType.IsInit()) pWriter->WriteByte1(7, m_oRefPtType->GetValue());
|
|
if (m_oRefType.IsInit()) pWriter->WriteByte1(8, m_oRefType->GetValue());
|
|
if (m_oType.IsInit()) pWriter->WriteByte1(9, m_oType->GetValue());
|
|
if (m_oVal.IsInit()) pWriter->WriteDoubleReal1(10, m_oVal->GetValue());
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
}
|
|
void Diagram::CConstraint::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:constr");
|
|
|
|
pWriter->StartAttributes();
|
|
if (m_oType.IsInit()) pWriter->WriteAttribute(L"type", m_oType->ToString());
|
|
if (m_oFor.IsInit()) pWriter->WriteAttribute(L"for", m_oFor->ToString());
|
|
pWriter->WriteAttribute(L"forName", m_oForName);
|
|
if (m_oPtType.IsInit()) pWriter->WriteAttribute(L"ptType", m_oPtType->ToString());
|
|
if (m_oRefPtType.IsInit()) pWriter->WriteAttribute(L"refPtType", m_oRefPtType->ToString());
|
|
if (m_oRefType.IsInit()) pWriter->WriteAttribute(L"refType", m_oRefType->ToString());
|
|
if (m_oRefFor.IsInit()) pWriter->WriteAttribute(L"refFor", m_oRefFor->ToString());
|
|
pWriter->WriteAttribute(L"refForName", m_oRefForName);
|
|
if (m_oOp.IsInit()) pWriter->WriteAttribute(L"op", m_oOp->ToString());
|
|
pWriter->WriteAttribute(L"fact", m_oFact);
|
|
if (m_oVal.IsInit()) pWriter->WriteAttribute(L"val", m_oVal->ToString());
|
|
pWriter->EndAttributes();
|
|
pWriter->WriteNodeEnd(L"dgm:constr");
|
|
}
|
|
void Diagram::CConstraint::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"fact", m_oFact)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"for", m_oFor)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"op", m_oOp)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"refFor", m_oRefFor)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"forName", m_oForName)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"refForName", m_oRefForName)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"refType", m_oRefType)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"refPtType", m_oRefPtType)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"ptType", m_oPtType)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"type", m_oType)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"val", m_oVal)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CRule::CRule() {}
|
|
Diagram::CRule::~CRule() {}
|
|
std::wstring Diagram::CRule::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CRule::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::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"dgm:extLst" == sName)
|
|
m_oExtLst = oReader;
|
|
}
|
|
}
|
|
void Diagram::CRule::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at)
|
|
{
|
|
m_oFact.Init();
|
|
m_oFact->SetValue(pReader->GetDoubleReal());
|
|
}
|
|
else if (1 == _at)
|
|
{
|
|
m_oFor.Init();
|
|
m_oFor->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (2 == _at) m_oForName = pReader->GetString2();
|
|
else if (3 == _at)
|
|
{
|
|
m_oPtType.Init();
|
|
m_oPtType->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (4 == _at)
|
|
{
|
|
m_oType.Init();
|
|
m_oType->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
else if (5 == _at)
|
|
{
|
|
m_oVal.Init();
|
|
m_oVal->SetValue(pReader->GetDoubleReal());
|
|
}
|
|
else if (6 == _at)
|
|
{
|
|
m_oMax.Init();
|
|
m_oMax->SetValue(pReader->GetDoubleReal());
|
|
}
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
EElementType Diagram::CRule::getType() const
|
|
{
|
|
return et_dgm_Rule;
|
|
}
|
|
void Diagram::CRule::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
if (m_oFact.IsInit())pWriter->WriteDoubleReal1(0, m_oFact->GetValue());
|
|
if (m_oFor.IsInit()) pWriter->WriteByte1(1, m_oFor->GetValue());
|
|
pWriter->WriteString2(2, m_oForName);
|
|
if (m_oPtType.IsInit()) pWriter->WriteByte1(3, m_oPtType->GetValue());
|
|
if (m_oType.IsInit()) pWriter->WriteByte1(4, m_oType->GetValue());
|
|
if (m_oVal.IsInit()) pWriter->WriteDoubleReal1(5, m_oVal->GetValue());
|
|
if (m_oMax.IsInit()) pWriter->WriteDoubleReal1(6, m_oMax->GetValue());
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
}
|
|
void Diagram::CRule::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:rule");
|
|
|
|
pWriter->StartAttributes();
|
|
if (m_oType.IsInit()) pWriter->WriteAttribute(L"type", m_oType->ToString());
|
|
if (m_oFor.IsInit()) pWriter->WriteAttribute(L"for", m_oFor->ToString());
|
|
pWriter->WriteAttribute(L"forName", m_oForName);
|
|
if (m_oPtType.IsInit()) pWriter->WriteAttribute(L"ptType", m_oPtType->ToString());
|
|
if (m_oVal.IsInit()) pWriter->WriteAttribute(L"val", m_oVal->ToString());
|
|
if (m_oFact.IsInit()) pWriter->WriteAttribute(L"fact", m_oFact->ToString());
|
|
if (m_oMax.IsInit()) pWriter->WriteAttribute(L"max", m_oMax->ToString());
|
|
pWriter->EndAttributes();
|
|
pWriter->WriteNodeEnd(L"dgm:rule");
|
|
}
|
|
void Diagram::CRule::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"fact", m_oFact)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"for", m_oFor)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"forName", m_oForName)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"ptType", m_oPtType)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"type", m_oType)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"val", m_oVal)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"max", m_oMax)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CParam::CParam() {}
|
|
Diagram::CParam::~CParam() {}
|
|
std::wstring Diagram::CParam::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CParam::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CParam::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
ReadAttributes(oReader);
|
|
|
|
if (!oReader.IsEmptyNode())
|
|
oReader.ReadTillEnd();
|
|
}
|
|
EElementType Diagram::CParam::getType() const
|
|
{
|
|
return et_dgm_Param;
|
|
}
|
|
void Diagram::CParam::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_oVal = pReader->GetString2();
|
|
else if (1 == _at)
|
|
{
|
|
m_oType.Init();
|
|
m_oType->SetValueFromByte(pReader->GetUChar());
|
|
}
|
|
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CParam::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteString2(0, m_oVal);
|
|
if (m_oType.IsInit()) pWriter->WriteByte1(1, m_oType->GetValue());
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
}
|
|
void Diagram::CParam::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:param");
|
|
|
|
pWriter->StartAttributes();
|
|
if (m_oType.IsInit()) pWriter->WriteAttribute(L"type", m_oType->ToString());
|
|
pWriter->WriteAttribute(L"val", m_oVal);
|
|
pWriter->EndAttributes();
|
|
pWriter->WriteNodeEnd(L"dgm:param");
|
|
}
|
|
void Diagram::CParam::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"type", m_oType)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"val", m_oVal)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CPresOf::CPresOf() {}
|
|
Diagram::CPresOf::~CPresOf() {}
|
|
std::wstring Diagram::CPresOf::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CPresOf::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CPresOf::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"dgm:extLst" == sName)
|
|
m_oExtLst = oReader;
|
|
}
|
|
|
|
}
|
|
EElementType Diagram::CPresOf::getType() const
|
|
{
|
|
return et_dgm_PresOf;
|
|
}
|
|
void Diagram::CPresOf::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (1 == _at) m_arSt.push_back(pReader->GetLong());
|
|
else if (2 == _at) m_arStep.push_back(pReader->GetLong());
|
|
else if (3 == _at) m_arHideLastTrans.push_back(pReader->GetBool());
|
|
else if (4 == _at) m_arCnt.push_back(pReader->GetLong());
|
|
else if (5 == _at)
|
|
{
|
|
SimpleTypes::CAxisTypes axis; axis.SetValueFromByte(pReader->GetUChar());
|
|
m_arAxis.push_back(axis);
|
|
}
|
|
else if (6 == _at)
|
|
{
|
|
SimpleTypes::CElementTypes ptType; ptType.SetValueFromByte(pReader->GetUChar());
|
|
m_arPtType.push_back(ptType);
|
|
}
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CPresOf::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
for (size_t i = 0; i < m_arSt.size(); ++i)
|
|
pWriter->WriteInt1(1, m_arSt[i]);
|
|
for (size_t i = 0; i < m_arStep.size(); ++i)
|
|
pWriter->WriteInt1(2, m_arStep[i]);
|
|
for (size_t i = 0; i < m_arHideLastTrans.size(); ++i)
|
|
pWriter->WriteBool1(3, m_arHideLastTrans[i]);
|
|
for (size_t i = 0; i < m_arCnt.size(); ++i)
|
|
pWriter->WriteInt1(4, m_arCnt[i]);
|
|
for (size_t i = 0; i < m_arAxis.size(); ++i)
|
|
pWriter->WriteByte1(5, m_arAxis[i].GetValue());
|
|
for (size_t i = 0; i < m_arPtType.size(); ++i)
|
|
pWriter->WriteByte1(6, m_arPtType[i].GetValue());
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
}
|
|
void Diagram::CPresOf::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:presOf");
|
|
if (false == m_arAxis.empty())
|
|
{
|
|
std::wstring sAxis;
|
|
for (size_t i = 0; i < m_arAxis.size(); ++i) sAxis += L" " + m_arAxis[i].ToString();
|
|
pWriter->WriteAttribute(L"axis", sAxis.substr(1));
|
|
}
|
|
if (false == m_arPtType.empty())
|
|
{
|
|
std::wstring sPtType;
|
|
for (size_t i = 0; i < m_arPtType.size(); ++i) sPtType += L" " + m_arPtType[i].ToString();
|
|
pWriter->WriteAttribute(L"ptType", sPtType.substr(1));
|
|
}
|
|
if (false == m_arSt.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arSt.size(); ++i) sRes += L" " + std::to_wstring(m_arSt[i]);
|
|
pWriter->WriteAttribute(L"st", sRes.substr(1));
|
|
}
|
|
if (false == m_arHideLastTrans.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arHideLastTrans.size(); ++i) sRes += (m_arHideLastTrans[i] ? L" 1" : L" 0");
|
|
pWriter->WriteAttribute(L"hideLastTrans", sRes.substr(1));
|
|
}
|
|
if (false == m_arCnt.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arCnt.size(); ++i) sRes += L" " + std::to_wstring(m_arCnt[i]);
|
|
pWriter->WriteAttribute(L"cnt", sRes.substr(1));
|
|
}
|
|
if (false == m_arStep.empty())
|
|
{
|
|
std::wstring sRes;
|
|
for (size_t i = 0; i < m_arStep.size(); ++i) sRes += L" " + std::to_wstring(m_arStep[i]);
|
|
pWriter->WriteAttribute(L"step", sRes.substr(1));
|
|
}
|
|
pWriter->EndAttributes();
|
|
pWriter->WriteNodeEnd(L"dgm:presOf");
|
|
}
|
|
void Diagram::CPresOf::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
nullable_string sPtTypes, sAxis, sCnt, sStep, sHideLastTrans, sSt;
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"axis", sAxis)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"cnt", sCnt)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"hideLastTrans", sHideLastTrans)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"ptType", sPtTypes)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"st", sSt)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"step", sStep)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
|
|
if (sAxis.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sAxis, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arAxis.push_back(SimpleTypes::CAxisTypes(arStr[i]));
|
|
}
|
|
if (sPtTypes.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sPtTypes, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arPtType.push_back(SimpleTypes::CElementTypes(arStr[i]));
|
|
}
|
|
if (sSt.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sSt, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arSt.push_back(XmlUtils::GetInteger(arStr[i]));
|
|
}
|
|
if (sCnt.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sCnt, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arCnt.push_back(XmlUtils::GetInteger(arStr[i]));
|
|
}
|
|
if (sStep.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sStep, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arStep.push_back(XmlUtils::GetInteger(arStr[i]));
|
|
}
|
|
if (sHideLastTrans.IsInit())
|
|
{
|
|
std::vector<std::wstring> arStr;
|
|
boost::algorithm::split(arStr, *sHideLastTrans, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
|
|
for (size_t i = 0; i < arStr.size(); ++i)
|
|
m_arHideLastTrans.push_back(SimpleTypes::COnOff(arStr[i]).ToBool());
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CShapeAdjust::CShapeAdjust() {}
|
|
Diagram::CShapeAdjust::~CShapeAdjust() {}
|
|
std::wstring Diagram::CShapeAdjust::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CShapeAdjust::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CShapeAdjust::fromXML(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
ReadAttributes(oReader);
|
|
|
|
if (!oReader.IsEmptyNode())
|
|
oReader.ReadTillEnd();
|
|
}
|
|
EElementType Diagram::CShapeAdjust::getType() const
|
|
{
|
|
return et_dgm_ShapeAdjust;
|
|
}
|
|
void Diagram::CShapeAdjust::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_oIdx = pReader->GetULong();
|
|
else if (1 == _at) m_oVal = pReader->GetDoubleReal();
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CShapeAdjust::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteUInt2(0, m_oIdx);
|
|
pWriter->WriteDoubleReal2(1, m_oVal);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
}
|
|
void Diagram::CShapeAdjust::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:adj");
|
|
|
|
pWriter->StartAttributes();
|
|
pWriter->WriteAttribute2(L"idx", m_oIdx);
|
|
pWriter->WriteAttribute(L"val", m_oVal);
|
|
pWriter->EndAttributes();
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:adj");
|
|
}
|
|
void Diagram::CShapeAdjust::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"idx", m_oIdx)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"val", m_oVal)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
|
|
Diagram::CShape::CShape() {}
|
|
Diagram::CShape::~CShape() {}
|
|
std::wstring Diagram::CShape::toXML() const
|
|
{
|
|
NSBinPptxRW::CXmlWriter oWriter;
|
|
toXmlWriter(&oWriter);
|
|
|
|
return oWriter.GetXmlString();
|
|
}
|
|
void Diagram::CShape::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
}
|
|
void Diagram::CShape::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"dgm:adjLst" == sName)
|
|
m_oAdjLst = oReader;
|
|
else if (L"dgm:extLst" == sName)
|
|
m_oExtLst = oReader;
|
|
}
|
|
}
|
|
EElementType Diagram::CShape::getType() const
|
|
{
|
|
return et_dgm_Shape;
|
|
}
|
|
void Diagram::CShape::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
pReader->Skip(1); // attribute start
|
|
while (true)
|
|
{
|
|
BYTE _at = pReader->GetUChar_TypeNode();
|
|
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
|
|
break;
|
|
|
|
else if (0 == _at) m_sBlip = pReader->GetString2();
|
|
else if (1 == _at) m_bBlipPhldr = pReader->GetBool();
|
|
else if (2 == _at) m_bHideGeom = pReader->GetBool();
|
|
else if (3 == _at) m_bLkTxEntry = pReader->GetBool();
|
|
else if (4 == _at) m_dRot = pReader->GetDoubleReal();
|
|
else if (5 == _at) m_nZOrderOff = pReader->GetLong();
|
|
else if (6 == _at) m_oType = pReader->GetString2();
|
|
}
|
|
while (pReader->GetPos() < end)
|
|
{
|
|
BYTE _rec = pReader->GetUChar();
|
|
|
|
switch (_rec)
|
|
{
|
|
case 0:
|
|
{
|
|
m_oAdjLst.Init();
|
|
m_oAdjLst->fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
{
|
|
pReader->SkipRecord();
|
|
}break;
|
|
}
|
|
}
|
|
pReader->Seek(end);
|
|
}
|
|
void Diagram::CShape::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteString2(0, m_sBlip);
|
|
pWriter->WriteBool2(1, m_bBlipPhldr);
|
|
pWriter->WriteBool2(2, m_bHideGeom);
|
|
pWriter->WriteBool2(3, m_bLkTxEntry);
|
|
pWriter->WriteDoubleReal2(4, m_dRot);
|
|
pWriter->WriteInt2(5, m_nZOrderOff);
|
|
pWriter->WriteString2(6, m_oType);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
|
|
pWriter->WriteRecord2(0, m_oAdjLst);
|
|
}
|
|
void Diagram::CShape::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"dgm:shape");
|
|
pWriter->WriteAttribute(L"rot", m_dRot);
|
|
pWriter->WriteAttribute(L"type", m_oType);
|
|
pWriter->WriteAttribute(L"r:blip", m_sBlip.get_value_or(L""));
|
|
pWriter->WriteAttribute(L"blipPhldr", m_bBlipPhldr);
|
|
pWriter->WriteAttribute(L"lkTxEntry", m_bLkTxEntry);
|
|
pWriter->WriteAttribute(L"zOrderOff", m_nZOrderOff);
|
|
pWriter->WriteAttribute(L"hideGeom", m_bHideGeom);
|
|
pWriter->EndAttributes();
|
|
|
|
if (m_oAdjLst.IsInit()) m_oAdjLst->toXmlWriter(pWriter);
|
|
|
|
pWriter->WriteNodeEnd(L"dgm:shape");
|
|
}
|
|
void Diagram::CShape::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
WritingElement_ReadAttributes_Start(oReader)
|
|
WritingElement_ReadAttributes_Read_if(oReader, L"blip", m_sBlip)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"blipPhldr", m_bBlipPhldr)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"hideGeom", m_bHideGeom)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"lkTxEntry", m_bLkTxEntry)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"rot", m_dRot)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"zOrderOff", m_nZOrderOff)
|
|
WritingElement_ReadAttributes_Read_else_if(oReader, L"type", m_oType)
|
|
WritingElement_ReadAttributes_End(oReader)
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
} // namespace OOX
|