1570 lines
40 KiB
C++
1570 lines
40 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
|
|
*
|
|
*/
|
|
|
|
#include "VisioThemeElements.h"
|
|
|
|
namespace PPTX
|
|
{
|
|
namespace nsTheme
|
|
{
|
|
VariationStyleSchemeLst& VariationStyleSchemeLst::operator=(const VariationStyleSchemeLst& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
m_arrItems.clear();
|
|
for (auto elm : oSrc.m_arrItems)
|
|
m_arrItems.push_back(elm);
|
|
|
|
return *this;
|
|
}
|
|
void VariationStyleSchemeLst::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
|
|
if (L"variationStyleScheme" == strName)
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromXML(oNode);
|
|
}
|
|
}
|
|
}
|
|
FillParentPointersForChilds();
|
|
}
|
|
std::wstring VariationStyleSchemeLst::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
oValue.WriteArray(m_arrItems);
|
|
|
|
return XmlUtils::CreateNode(L"vt:variationStyleSchemeLst", oAttr, oValue);
|
|
}
|
|
void VariationStyleSchemeLst::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
for (auto elm : m_arrItems)
|
|
pWriter->WriteRecord1(0, elm);
|
|
}
|
|
void VariationStyleSchemeLst::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:variationStyleSchemeLst");
|
|
pWriter->WriteAttribute(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
pWriter->EndAttributes();
|
|
|
|
pWriter->WriteArray2(m_arrItems);
|
|
|
|
pWriter->EndNode(_T("vt:variationStyleSchemeLst"));
|
|
}
|
|
void VariationStyleSchemeLst::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
void VariationStyleSchemeLst::FillParentPointersForChilds()
|
|
{
|
|
for (auto elm : m_arrItems)
|
|
elm.SetParentPointer(this);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
FontStyles& FontStyles::operator=(const FontStyles& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
node_name = oSrc.node_name;
|
|
|
|
m_arrItems.clear();
|
|
for (auto elm : oSrc.m_arrItems)
|
|
m_arrItems.push_back(elm);
|
|
|
|
return *this;
|
|
}
|
|
void FontStyles::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
node_name = node.GetName();
|
|
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
|
|
if (L"fontProps" == strName)
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromXML(oNode);
|
|
}
|
|
}
|
|
}
|
|
FillParentPointersForChilds();
|
|
}
|
|
std::wstring FontStyles::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
XmlUtils::CNodeValue oValue;
|
|
oValue.WriteArray(m_arrItems);
|
|
|
|
return XmlUtils::CreateNode(node_name, oAttr, oValue);
|
|
}
|
|
void FontStyles::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
for (auto elm : m_arrItems)
|
|
pWriter->WriteRecord1(0, elm);
|
|
}
|
|
void FontStyles::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(node_name);
|
|
pWriter->EndAttributes();
|
|
|
|
pWriter->WriteArray2(m_arrItems);
|
|
|
|
pWriter->EndNode(node_name);
|
|
}
|
|
void FontStyles::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
void FontStyles::FillParentPointersForChilds()
|
|
{
|
|
for (auto elm : m_arrItems)
|
|
elm.SetParentPointer(this);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
SchemeLineStyles& SchemeLineStyles::operator=(const SchemeLineStyles& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
node_name = oSrc.node_name;
|
|
|
|
m_arrItems.clear();
|
|
for (auto elm : oSrc.m_arrItems)
|
|
m_arrItems.push_back(elm);
|
|
|
|
return *this;
|
|
}
|
|
void SchemeLineStyles::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
node_name = node.GetName();
|
|
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
|
|
if (L"lineStyle" == strName)
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromXML(oNode);
|
|
}
|
|
}
|
|
}
|
|
FillParentPointersForChilds();
|
|
}
|
|
std::wstring SchemeLineStyles::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
XmlUtils::CNodeValue oValue;
|
|
oValue.WriteArray(m_arrItems);
|
|
|
|
return XmlUtils::CreateNode(node_name, oAttr, oValue);
|
|
}
|
|
void SchemeLineStyles::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
for (auto elm : m_arrItems)
|
|
pWriter->WriteRecord1(0, elm);
|
|
}
|
|
void SchemeLineStyles::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(node_name);
|
|
pWriter->EndAttributes();
|
|
|
|
pWriter->WriteArray2(m_arrItems);
|
|
|
|
pWriter->EndNode(node_name);
|
|
}
|
|
void SchemeLineStyles::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
void SchemeLineStyles::FillParentPointersForChilds()
|
|
{
|
|
for (auto elm : m_arrItems)
|
|
elm.SetParentPointer(this);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
FillStyles& FillStyles::operator=(const FillStyles& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
m_arrItems.clear();
|
|
for (auto elm : oSrc.m_arrItems)
|
|
m_arrItems.push_back(elm);
|
|
|
|
return *this;
|
|
}
|
|
void FillStyles::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
|
|
if (L"fillProps" == strName)
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromXML(oNode);
|
|
}
|
|
}
|
|
}
|
|
FillParentPointersForChilds();
|
|
}
|
|
std::wstring FillStyles::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
oValue.WriteArray(m_arrItems);
|
|
|
|
return XmlUtils::CreateNode(L"vt:fillStyles", oAttr, oValue);
|
|
}
|
|
void FillStyles::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
for (auto elm : m_arrItems)
|
|
pWriter->WriteRecord1(0, elm);
|
|
}
|
|
void FillStyles::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:fillStyles");
|
|
pWriter->WriteAttribute(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
pWriter->EndAttributes();
|
|
|
|
pWriter->WriteArray2(m_arrItems);
|
|
|
|
pWriter->EndNode(L"vt:fillStyles");
|
|
}
|
|
void FillStyles::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
void FillStyles::FillParentPointersForChilds()
|
|
{
|
|
for (auto elm : m_arrItems)
|
|
elm.SetParentPointer(this);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
VariationStyleScheme& VariationStyleScheme::operator=(const VariationStyleScheme& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
embellishment = oSrc.embellishment;
|
|
|
|
m_arrItems.clear();
|
|
for (auto elm : oSrc.m_arrItems)
|
|
m_arrItems.push_back(elm);
|
|
|
|
return *this;
|
|
}
|
|
void VariationStyleScheme::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
XmlMacroReadAttributeBase(node, L"embellishment", embellishment);
|
|
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
|
|
if (L"varStyle" == strName)
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromXML(oNode);
|
|
}
|
|
}
|
|
}
|
|
FillParentPointersForChilds();
|
|
}
|
|
std::wstring VariationStyleScheme::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"embellishment", embellishment);
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
oValue.WriteArray(m_arrItems);
|
|
|
|
return XmlUtils::CreateNode(L"vt:variationStyleScheme", oAttr, oValue);
|
|
}
|
|
void VariationStyleScheme::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteUInt2(0, embellishment);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
|
|
for (auto elm : m_arrItems)
|
|
pWriter->WriteRecord1(0, elm);
|
|
}
|
|
void VariationStyleScheme::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:variationStyleScheme");
|
|
pWriter->WriteAttribute2(L"embellishment", embellishment);
|
|
pWriter->EndAttributes();
|
|
|
|
pWriter->WriteArray2(m_arrItems);
|
|
|
|
pWriter->EndNode(L"vt:variationStyleScheme");
|
|
}
|
|
void VariationStyleScheme::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:
|
|
{
|
|
embellishment = pReader->GetULong();
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
void VariationStyleScheme::FillParentPointersForChilds()
|
|
{
|
|
for (auto elm : m_arrItems)
|
|
elm.SetParentPointer(this);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
FontStylesGroup& FontStylesGroup::operator=(const FontStylesGroup& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
connectorFontStyles = oSrc.connectorFontStyles;
|
|
fontStyles = oSrc.fontStyles;
|
|
|
|
return *this;
|
|
}
|
|
void FontStylesGroup::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
|
|
if (L"connectorFontStyles" == strName)
|
|
{
|
|
connectorFontStyles.fromXML(oNode);
|
|
}
|
|
else if (L"fontStyles" == strName)
|
|
{
|
|
fontStyles.fromXML(oNode);
|
|
}
|
|
}
|
|
}
|
|
FillParentPointersForChilds();
|
|
}
|
|
std::wstring FontStylesGroup::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
oValue.Write(connectorFontStyles);
|
|
oValue.Write(fontStyles);
|
|
|
|
return XmlUtils::CreateNode(L"vt:fontStylesGroup", oAttr, oValue);
|
|
}
|
|
void FontStylesGroup::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteRecord1(0, connectorFontStyles);
|
|
pWriter->WriteRecord1(1, fontStyles);
|
|
}
|
|
void FontStylesGroup::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:fontStylesGroup");
|
|
pWriter->WriteAttribute(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
pWriter->EndAttributes();
|
|
|
|
connectorFontStyles.toXmlWriter(pWriter);
|
|
fontStyles.toXmlWriter(pWriter);
|
|
|
|
pWriter->EndNode(L"vt:fontStylesGroup");
|
|
}
|
|
void FontStylesGroup::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
connectorFontStyles.node_name = L"vt:connectorFontStyles";
|
|
connectorFontStyles.fromPPTY(pReader);
|
|
}break;
|
|
case 1:
|
|
{
|
|
fontStyles.node_name = L"vt:fontStyles";
|
|
fontStyles.fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
void FontStylesGroup::FillParentPointersForChilds()
|
|
{
|
|
connectorFontStyles.SetParentPointer(this);
|
|
fontStyles.SetParentPointer(this);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
LineStyles& LineStyles::operator=(const LineStyles& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
fmtConnectorSchemeLineStyles = oSrc.fmtConnectorSchemeLineStyles;
|
|
fmtSchemeLineStyles = oSrc.fmtSchemeLineStyles;
|
|
|
|
return *this;
|
|
}
|
|
void LineStyles::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
|
|
if (L"fmtConnectorSchemeLineStyles" == strName)
|
|
{
|
|
fmtConnectorSchemeLineStyles.fromXML(oNode);
|
|
}
|
|
else if (L"fmtSchemeLineStyles" == strName)
|
|
{
|
|
fmtSchemeLineStyles.fromXML(oNode);
|
|
}
|
|
}
|
|
}
|
|
FillParentPointersForChilds();
|
|
}
|
|
std::wstring LineStyles::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
oValue.Write(fmtConnectorSchemeLineStyles);
|
|
oValue.Write(fmtSchemeLineStyles);
|
|
|
|
return XmlUtils::CreateNode(L"vt:lineStyles", oAttr, oValue);
|
|
}
|
|
void LineStyles::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteRecord1(0, fmtConnectorSchemeLineStyles);
|
|
pWriter->WriteRecord1(1, fmtSchemeLineStyles);
|
|
}
|
|
void LineStyles::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:lineStyles");
|
|
pWriter->WriteAttribute(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
pWriter->EndAttributes();
|
|
|
|
fmtConnectorSchemeLineStyles.toXmlWriter(pWriter);
|
|
fmtSchemeLineStyles.toXmlWriter(pWriter);
|
|
|
|
pWriter->EndNode(L"vt:lineStyles");
|
|
}
|
|
void LineStyles::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
fmtConnectorSchemeLineStyles.node_name = L"vt:fmtConnectorSchemeLineStyles";
|
|
fmtConnectorSchemeLineStyles.fromPPTY(pReader);
|
|
}break;
|
|
case 1:
|
|
{
|
|
fmtSchemeLineStyles.node_name = L"vt:fmtSchemeLineStyles";
|
|
fmtSchemeLineStyles.fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
void LineStyles::FillParentPointersForChilds()
|
|
{
|
|
fmtConnectorSchemeLineStyles.SetParentPointer(this);
|
|
fmtSchemeLineStyles.SetParentPointer(this);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
VarStyle& VarStyle::operator=(const VarStyle& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
fillIdx = oSrc.fillIdx;
|
|
lineIdx = oSrc.lineIdx;
|
|
effectIdx = oSrc.effectIdx;
|
|
fontIdx = oSrc.fontIdx;
|
|
|
|
return *this;
|
|
}
|
|
void VarStyle::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
XmlMacroReadAttributeBase(node, L"fillIdx", fillIdx);
|
|
XmlMacroReadAttributeBase(node, L"lineIdx", lineIdx);
|
|
XmlMacroReadAttributeBase(node, L"effectIdx", effectIdx);
|
|
XmlMacroReadAttributeBase(node, L"fontIdx", fontIdx);
|
|
}
|
|
std::wstring VarStyle::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"fillIdx", fillIdx);
|
|
oAttr.Write(L"lineIdx", lineIdx);
|
|
oAttr.Write(L"effectIdx", effectIdx);
|
|
oAttr.Write(L"fontIdx", fontIdx);
|
|
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
|
|
return XmlUtils::CreateNode(L"vt:varStyle", oAttr, oValue);
|
|
}
|
|
void VarStyle::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteUInt2(0, fillIdx);
|
|
pWriter->WriteUInt2(1, lineIdx);
|
|
pWriter->WriteUInt2(2, effectIdx);
|
|
pWriter->WriteUInt2(3, fontIdx);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
}
|
|
void VarStyle::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:varStyle");
|
|
pWriter->WriteAttribute2(L"fillIdx", fillIdx);
|
|
pWriter->WriteAttribute2(L"lineIdx", lineIdx);
|
|
pWriter->WriteAttribute2(L"effectIdx", effectIdx);
|
|
pWriter->WriteAttribute2(L"fontIdx", fontIdx);
|
|
pWriter->EndAttributes();
|
|
|
|
pWriter->EndNode(L"vt:varStyle");
|
|
}
|
|
void VarStyle::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:
|
|
{
|
|
fillIdx = pReader->GetULong();
|
|
}break;
|
|
case 1:
|
|
{
|
|
lineIdx = pReader->GetULong();
|
|
}break;
|
|
case 2:
|
|
{
|
|
effectIdx = pReader->GetULong();
|
|
}break;
|
|
case 3:
|
|
{
|
|
fontIdx = pReader->GetULong();
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
FillProps& FillProps::operator=(const FillProps& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
pattern = oSrc.pattern;
|
|
return *this;
|
|
}
|
|
void FillProps::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
XmlMacroReadAttributeBase(node, L"pattern", pattern);
|
|
}
|
|
std::wstring FillProps::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"pattern", pattern);
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
|
|
return XmlUtils::CreateNode(L"vt:fillProps", oAttr, oValue);
|
|
}
|
|
void FillProps::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteUInt2(0, pattern);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
}
|
|
void FillProps::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:fillProps");
|
|
pWriter->WriteAttribute2(L"pattern", pattern);
|
|
pWriter->EndAttributes();
|
|
pWriter->EndNode(L"vt:fillProps");
|
|
}
|
|
void FillProps::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:
|
|
{
|
|
pattern = pReader->GetULong();
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
Sketch& Sketch::operator=(const Sketch& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
lnAmp = oSrc.lnAmp;
|
|
fillAmp = oSrc.fillAmp;
|
|
lnWeight = oSrc.lnWeight;
|
|
numPts = oSrc.numPts;
|
|
|
|
return *this;
|
|
}
|
|
void Sketch::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
XmlMacroReadAttributeBase(node, L"lnAmp", lnAmp);
|
|
XmlMacroReadAttributeBase(node, L"fillAmp", fillAmp);
|
|
XmlMacroReadAttributeBase(node, L"lnWeight", lnWeight);
|
|
XmlMacroReadAttributeBase(node, L"numPts", numPts);
|
|
}
|
|
std::wstring Sketch::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"lnAmp", lnAmp);
|
|
oAttr.Write(L"fillAmp", fillAmp);
|
|
oAttr.Write(L"lnWeight", lnWeight);
|
|
oAttr.Write(L"numPts", numPts);
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
|
|
return XmlUtils::CreateNode(L"vt:sketch", oAttr, oValue);
|
|
}
|
|
void Sketch::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteUInt2(0, lnAmp);
|
|
pWriter->WriteUInt2(1, fillAmp);
|
|
pWriter->WriteUInt2(2, lnWeight);
|
|
pWriter->WriteUInt2(3, numPts);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
}
|
|
void Sketch::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:sketch");
|
|
pWriter->WriteAttribute2(L"lnAmp", lnAmp);
|
|
pWriter->WriteAttribute2(L"fillAmp", fillAmp);
|
|
pWriter->WriteAttribute2(L"lnWeight", lnWeight);
|
|
pWriter->WriteAttribute2(L"numPts", numPts);
|
|
pWriter->EndAttributes();
|
|
|
|
pWriter->EndNode(L"vt:sketch");
|
|
}
|
|
void Sketch::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:
|
|
{
|
|
lnAmp = pReader->GetULong();
|
|
}break;
|
|
case 1:
|
|
{
|
|
fillAmp = pReader->GetULong();
|
|
}break;
|
|
case 2:
|
|
{
|
|
lnWeight = pReader->GetULong();
|
|
}break;
|
|
case 3:
|
|
{
|
|
numPts = pReader->GetULong();
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
FontProps& FontProps::operator=(const FontProps& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
style = oSrc.style;
|
|
color = oSrc.color;
|
|
|
|
return *this;
|
|
}
|
|
void FontProps::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
XmlMacroReadAttributeBase(node, L"style", style);
|
|
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
|
|
if (L"color" == strName)
|
|
{
|
|
color.GetColorFrom(oNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
std::wstring FontProps::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"style", style);
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
oValue.Write(L"vt:color", color);
|
|
|
|
return XmlUtils::CreateNode(L"vt:fontProps", oAttr, oValue);
|
|
}
|
|
void FontProps::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteUInt2(0, style);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
|
|
pWriter->WriteRecord1(0, color);
|
|
}
|
|
void FontProps::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:fontProps");
|
|
pWriter->WriteAttribute2(L"style", style);
|
|
pWriter->EndAttributes();
|
|
|
|
if (color.is_init())
|
|
{
|
|
pWriter->WriteString(L"<vt:color>");
|
|
color.toXmlWriter(pWriter);
|
|
pWriter->WriteString(L"</vt:color>");
|
|
}
|
|
|
|
pWriter->EndNode(L"vt:fontProps");
|
|
}
|
|
void FontProps::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:
|
|
{
|
|
style = pReader->GetULong();
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
color.fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
LineEx& LineEx::operator=(const LineEx& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
rndg = oSrc.rndg;
|
|
start = oSrc.start;
|
|
startSize = oSrc.startSize;
|
|
end = oSrc.end;
|
|
endSize = oSrc.endSize;
|
|
pattern = oSrc.pattern;
|
|
|
|
return *this;
|
|
}
|
|
void LineEx::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
XmlMacroReadAttributeBase(node, L"rndg", rndg);
|
|
XmlMacroReadAttributeBase(node, L"start", start);
|
|
XmlMacroReadAttributeBase(node, L"startSize", startSize);
|
|
XmlMacroReadAttributeBase(node, L"end", end);
|
|
XmlMacroReadAttributeBase(node, L"endSize", endSize);
|
|
XmlMacroReadAttributeBase(node, L"pattern", pattern);
|
|
}
|
|
std::wstring LineEx::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"rndg", rndg);
|
|
oAttr.Write(L"start", start);
|
|
oAttr.Write(L"startSize", startSize);
|
|
oAttr.Write(L"end", end);
|
|
oAttr.Write(L"endSize", endSize);
|
|
oAttr.Write(L"pattern", pattern);
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
|
|
return XmlUtils::CreateNode(L"vt:lineEx", oAttr, oValue);
|
|
}
|
|
void LineEx::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteUInt2(0, rndg);
|
|
pWriter->WriteUInt2(1, start);
|
|
pWriter->WriteUInt2(2, startSize);
|
|
pWriter->WriteUInt2(3, end);
|
|
pWriter->WriteUInt2(4, endSize);
|
|
pWriter->WriteUInt2(5, pattern);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
}
|
|
void LineEx::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:lineEx");
|
|
pWriter->WriteAttribute2(L"rndg", rndg);
|
|
pWriter->WriteAttribute2(L"start", start);
|
|
pWriter->WriteAttribute2(L"startSize", startSize);
|
|
pWriter->WriteAttribute2(L"end", end);
|
|
pWriter->WriteAttribute2(L"endSize", endSize);
|
|
pWriter->WriteAttribute2(L"pattern", pattern);
|
|
pWriter->EndAttributes();
|
|
pWriter->EndNode(L"vt:lineEx");
|
|
}
|
|
void LineEx::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:
|
|
{
|
|
rndg = pReader->GetULong();
|
|
}break;
|
|
case 1:
|
|
{
|
|
start = pReader->GetULong();
|
|
}break;
|
|
case 2:
|
|
{
|
|
startSize = pReader->GetULong();
|
|
}break;
|
|
case 3:
|
|
{
|
|
end = pReader->GetULong();
|
|
}break;
|
|
case 4:
|
|
{
|
|
endSize = pReader->GetULong();
|
|
}break;
|
|
case 5:
|
|
{
|
|
pattern = pReader->GetULong();
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
LineStyle& LineStyle::operator=(const LineStyle& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
lineEx = oSrc.lineEx;
|
|
sketch = oSrc.sketch;
|
|
|
|
return *this;
|
|
}
|
|
void LineStyle::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
|
|
if (L"lineEx" == strName)
|
|
{
|
|
lineEx.fromXML(oNode);
|
|
}
|
|
else if (L"sketch" == strName)
|
|
{
|
|
sketch = oNode;
|
|
}
|
|
}
|
|
}
|
|
FillParentPointersForChilds();
|
|
}
|
|
std::wstring LineStyle::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
oValue.Write(lineEx);
|
|
oValue.WriteNullable(sketch);
|
|
|
|
return XmlUtils::CreateNode(L"vt:lineStyle", oAttr, oValue);
|
|
}
|
|
void LineStyle::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteRecord1(0, lineEx);
|
|
pWriter->WriteRecord2(1, sketch);
|
|
}
|
|
void LineStyle::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:lineStyle");
|
|
pWriter->EndAttributes();
|
|
|
|
lineEx.toXmlWriter(pWriter);
|
|
pWriter->Write(sketch);
|
|
|
|
pWriter->EndNode(L"vt:lineStyle");
|
|
}
|
|
void LineStyle::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
lineEx.fromPPTY(pReader);
|
|
}break;
|
|
case 1:
|
|
{
|
|
sketch.Init();
|
|
sketch->fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
void LineStyle::FillParentPointersForChilds()
|
|
{
|
|
lineEx.SetParentPointer(this);
|
|
if (sketch.IsInit()) sketch->SetParentPointer(this);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
VariationClrScheme& VariationClrScheme::operator=(const VariationClrScheme& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
for (size_t i = 0; i < 7; ++i)
|
|
{
|
|
varColor[i] = oSrc.varColor[i];
|
|
}
|
|
return *this;
|
|
}
|
|
void VariationClrScheme::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
|
|
if (0 == strName.find(L"varColor"))
|
|
{
|
|
int ind = XmlUtils::GetInteger(strName.substr(8)) - 1;
|
|
if (ind >= 0 && ind < 7)
|
|
varColor[ind].GetColorFrom(oNode);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
std::wstring VariationClrScheme::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
|
|
for (size_t i = 0; i < 7; ++i)
|
|
{
|
|
std::wstring name = L"vt:varColor" + std::to_wstring(i + 1);
|
|
oValue.Write(name, varColor[i]);
|
|
}
|
|
|
|
return XmlUtils::CreateNode(L"vt:variationClrScheme", oAttr, oValue);
|
|
}
|
|
void VariationClrScheme::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
for (size_t i = 0; i < 7; ++i)
|
|
{
|
|
pWriter->WriteRecord1(i, varColor[i]);
|
|
}
|
|
}
|
|
void VariationClrScheme::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:variationClrScheme");
|
|
pWriter->EndAttributes();
|
|
|
|
for (size_t i = 0; i < 7; ++i)
|
|
{
|
|
if (varColor[i].is_init())
|
|
{
|
|
std::wstring name = L"vt:varColor" + std::to_wstring(i + 1);
|
|
pWriter->WriteString(L"<" + name + L">");
|
|
varColor[i].toXmlWriter(pWriter);
|
|
pWriter->WriteString(L"</" + name + L">");
|
|
}
|
|
}
|
|
|
|
pWriter->EndNode(L"vt:variationClrScheme");
|
|
}
|
|
void VariationClrScheme::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
|
|
if (_at >= 0 && _at < 7)
|
|
{
|
|
varColor[_at].fromPPTY(pReader);
|
|
}
|
|
}
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
VariationClrSchemeLst& VariationClrSchemeLst::operator=(const VariationClrSchemeLst& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
m_arrItems.clear();
|
|
for (auto elm : oSrc.m_arrItems)
|
|
m_arrItems.push_back(elm);
|
|
|
|
return *this;
|
|
}
|
|
void VariationClrSchemeLst::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
|
|
if (L"variationClrScheme" == strName)
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromXML(oNode);
|
|
}
|
|
}
|
|
}
|
|
FillParentPointersForChilds();
|
|
}
|
|
std::wstring VariationClrSchemeLst::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
XmlUtils::CNodeValue oValue;
|
|
oValue.WriteArray(m_arrItems);
|
|
|
|
return XmlUtils::CreateNode(L"vt:variationClrSchemeLst", oAttr, oValue);
|
|
}
|
|
void VariationClrSchemeLst::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
for (auto elm : m_arrItems)
|
|
pWriter->WriteRecord1(0, elm);
|
|
}
|
|
void VariationClrSchemeLst::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:variationClrSchemeLst");
|
|
pWriter->WriteAttribute(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
pWriter->EndAttributes();
|
|
|
|
pWriter->WriteArray2(m_arrItems);
|
|
|
|
pWriter->EndNode(L"vt:variationClrSchemeLst");
|
|
}
|
|
void VariationClrSchemeLst::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
m_arrItems.emplace_back();
|
|
m_arrItems.back().fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
void VariationClrSchemeLst::FillParentPointersForChilds()
|
|
{
|
|
for (auto elm : m_arrItems)
|
|
elm.SetParentPointer(this);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
Bkgnd& Bkgnd::operator=(const Bkgnd& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
color = oSrc.color;
|
|
|
|
return *this;
|
|
}
|
|
void Bkgnd::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
color.GetColorFrom(node);
|
|
}
|
|
std::wstring Bkgnd::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
|
|
return XmlUtils::CreateNode(L"vt:bkgnd", oAttr, color.toXML());
|
|
}
|
|
void Bkgnd::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteRecord1(0, color);
|
|
}
|
|
void Bkgnd::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:bkgnd");
|
|
pWriter->WriteAttribute(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
pWriter->EndAttributes();
|
|
|
|
if (color.is_init())
|
|
{
|
|
color.toXmlWriter(pWriter);
|
|
}
|
|
pWriter->EndNode(L"vt:bkgnd");
|
|
}
|
|
void Bkgnd::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
color.fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
SchemeID& SchemeID::operator=(const SchemeID& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
schemeEnum = oSrc.schemeEnum;
|
|
schemeGUID = oSrc.schemeGUID;
|
|
|
|
return *this;
|
|
}
|
|
void SchemeID::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
XmlMacroReadAttributeBase(node, L"schemeEnum", schemeEnum);
|
|
XmlMacroReadAttributeBase(node, L"schemeGUID", schemeGUID);
|
|
}
|
|
std::wstring SchemeID::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
if (bSchemas)
|
|
{
|
|
oAttr.Write(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
}
|
|
oAttr.Write(L"schemeEnum", schemeEnum);
|
|
oAttr.Write(L"schemeGUID", schemeGUID);
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
|
|
return XmlUtils::CreateNode(L"vt:schemeID", oAttr, oValue);
|
|
}
|
|
void SchemeID::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
|
|
pWriter->WriteUInt2(0, schemeEnum);
|
|
pWriter->WriteString2(1, schemeGUID);
|
|
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
|
|
}
|
|
void SchemeID::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(L"vt:schemeID");
|
|
if (bSchemas)
|
|
{
|
|
pWriter->WriteAttribute(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
}
|
|
pWriter->WriteAttribute2(L"schemeEnum", schemeEnum);
|
|
pWriter->WriteAttribute2(L"schemeGUID", schemeGUID);
|
|
pWriter->EndAttributes();
|
|
pWriter->EndNode(L"vt:schemeID");
|
|
}
|
|
void SchemeID::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:
|
|
{
|
|
schemeEnum = pReader->GetULong();
|
|
}break;
|
|
case 1:
|
|
{
|
|
schemeGUID = pReader->GetString2();
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
//-----------------------------------------------------------------------------------------
|
|
Scheme& Scheme::operator=(const Scheme& oSrc)
|
|
{
|
|
parentFile = oSrc.parentFile;
|
|
parentElement = oSrc.parentElement;
|
|
|
|
node_name = oSrc.node_name;
|
|
schemeID = oSrc.schemeID;
|
|
|
|
return *this;
|
|
}
|
|
void Scheme::fromXML(XmlUtils::CXmlNode& node)
|
|
{
|
|
node_name = node.GetName();
|
|
|
|
std::vector<XmlUtils::CXmlNode> oNodes;
|
|
if (node.GetNodes(L"*", oNodes))
|
|
{
|
|
for (size_t i = 0; i < oNodes.size(); ++i)
|
|
{
|
|
XmlUtils::CXmlNode& oNode = oNodes[i];
|
|
|
|
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
|
|
if (L"schemeID" == strName)
|
|
{
|
|
schemeID = oNode;
|
|
}
|
|
}
|
|
}
|
|
FillParentPointersForChilds();
|
|
}
|
|
std::wstring Scheme::toXML() const
|
|
{
|
|
XmlUtils::CAttribute oAttr;
|
|
oAttr.Write(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
|
|
XmlUtils::CNodeValue oValue;
|
|
oValue.WriteNullable(schemeID);
|
|
|
|
return XmlUtils::CreateNode(node_name, oAttr, oValue);
|
|
}
|
|
void Scheme::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
|
|
{
|
|
pWriter->WriteRecord2(0, schemeID);
|
|
}
|
|
void Scheme::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
|
|
{
|
|
pWriter->StartNode(node_name);
|
|
pWriter->WriteAttribute(L"xmlns:vt", L"http://schemas.microsoft.com/office/visio/2012/theme");
|
|
pWriter->EndAttributes();
|
|
|
|
pWriter->Write(schemeID);
|
|
|
|
pWriter->EndNode(node_name);
|
|
}
|
|
void Scheme::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
|
|
{
|
|
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
|
|
|
|
while (pReader->GetPos() < _end_rec)
|
|
{
|
|
BYTE _at = pReader->GetUChar();
|
|
switch (_at)
|
|
{
|
|
case 0:
|
|
{
|
|
schemeID.Init();
|
|
schemeID->fromPPTY(pReader);
|
|
}break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
pReader->Seek(_end_rec);
|
|
}
|
|
void Scheme::FillParentPointersForChilds()
|
|
{
|
|
if (schemeID.IsInit())
|
|
schemeID->SetParentPointer(this);
|
|
}
|
|
} // namespace nsTheme
|
|
} // namespace PPTX
|