Yajbir-Malik/DocumentServer-v-9.2.0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
f1b860b25cb1d7a8ea40624ec6d194eb163ff321
DocumentServer-v-9.2.0/core/OOXML/PPTXFormat/Logic/SpTree.cpp
T
Yajbir Singh f1b860b25c
check / markdownlint (push) Has been cancelled
Details
check / spellchecker (push) Has been cancelled
Details
updated
2025-12-11 19:03:17 +05:30

628 lines
18 KiB
C++
Raw Blame History

/*
* (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 "SpTree.h"
#include "Shape.h"
#include "Pic.h"
#include "../Theme.h"
#include "ClrMap.h"
#include "../../DocxFormat/Logic/Pict.h"
namespace PPTX
{
namespace Logic
{
SpTree::SpTree(std::wstring ns) : nvGrpSpPr(ns), grpSpPr(ns)
{
m_namespace = ns;
m_lGroupIndex = 0;
}
SpTree& SpTree::operator=(const SpTree& oSrc)
{
parentFile = oSrc.parentFile;
parentElement = oSrc.parentElement;
nvGrpSpPr = oSrc.nvGrpSpPr;
grpSpPr = oSrc.grpSpPr;
for (size_t i=0; i < oSrc.SpTreeElems.size(); i++)
SpTreeElems.push_back(oSrc.SpTreeElems[i]);
m_namespace = oSrc.m_namespace;
m_lGroupIndex = oSrc.m_lGroupIndex;
return *this;
}
OOX::EElementType SpTree::getType () const
{
return OOX::et_p_ShapeTree;
}
void SpTree::FillParentPointersForChilds()
{
nvGrpSpPr.SetParentPointer(this);
grpSpPr.SetParentPointer(this);
for (size_t i = 0; i < SpTreeElems.size(); ++i)
{
SpTreeElems[i].SetParentPointer(this);
}
}
void SpTree::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
m_namespace = XmlUtils::GetNamespace(oReader.GetName());
SpTreeElems.clear();
if (oReader.IsEmptyNode())
return;
int nParentDepth = oReader.GetDepth();
while (oReader.ReadNextSiblingNode(nParentDepth))
{
std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
if (strName == L"nvGrpSpPr")
nvGrpSpPr.fromXML(oReader);
else if (strName == L"grpSpPr")
grpSpPr.fromXML(oReader);
else if (_T("cNvPr") == strName)
{
nvGrpSpPr.cNvPr = oReader;
}
else if (_T("cNvGrpSpPr") == strName)
{
nvGrpSpPr.cNvGrpSpPr = oReader;
}
else
{
SpTreeElem elem(oReader);
if (elem.is_init())
{
if (elem.getType() == OOX::et_p_ShapeTree)
{
smart_ptr<SpTree> e = elem.GetElem().smart_dynamic_cast<SpTree>();
e->m_lGroupIndex = m_lGroupIndex + 1;
}
SpTreeElems.push_back(elem);
}
}
}
FillParentPointersForChilds();
}
void SpTree::fromXML(XmlUtils::CXmlNode& node)
{
m_namespace = XmlUtils::GetNamespace(node.GetName());
nvGrpSpPr = node.ReadNodeNoNS(_T("nvGrpSpPr"));
grpSpPr = node.ReadNodeNoNS(_T("grpSpPr"));
SpTreeElems.clear();
std::vector<XmlUtils::CXmlNode> oNodes;
if (node.GetNodes(_T("*"), oNodes))
{
size_t nCount = oNodes.size();
for (size_t i = 0; i < nCount; ++i)
{
XmlUtils::CXmlNode& oNode = oNodes[i];
std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
if (_T("cNvPr") == strName)
{
nvGrpSpPr.cNvPr = oNode;
}
else if (_T("cNvGrpSpPr") == strName)
{
nvGrpSpPr.cNvGrpSpPr = oNode;
}
else
{
SpTreeElem elem(oNode);
if (elem.is_init())
{
if (elem.getType() == OOX::et_p_ShapeTree)
{
smart_ptr<SpTree> e = elem.GetElem().smart_dynamic_cast<SpTree>();
e->m_lGroupIndex = m_lGroupIndex + 1;
}
SpTreeElems.push_back(elem);
}
}
}
}
FillParentPointersForChilds();
}
std::wstring SpTree::toXML() const
{
std::wstring name_;
if (m_namespace == L"wp")
{
if (m_lGroupIndex == 0) name_ = L"wpg:wgp";
else name_ = L"wpg:grpSp";
}
else if (m_namespace == L"xdr") name_ = L"xdr:grpSp";
else if (m_namespace == L"dsp") name_ = L"dsp:grpSp";
else
{
if (m_lGroupIndex == 0) name_ = L"p:spTree";
else name_ = L"p:grpSp";
}
XmlUtils::CNodeValue oValue;
oValue.Write(nvGrpSpPr);
oValue.Write(grpSpPr);
oValue.WriteArray(SpTreeElems);
return XmlUtils::CreateNode(name_, oValue);
}
void SpTree::toXmlWriterVML(NSBinPptxRW::CXmlWriter *pWriter, NSCommon::smart_ptr<PPTX::Theme>& oTheme, NSCommon::smart_ptr<PPTX::Logic::ClrMap>& oClrMap, NSCommon::smart_ptr<OOX::IFileContainer>& pContainer, bool in_group)
{
pWriter->StartNode(_T("v:group"));
pWriter->StartAttributes();
std::wstring strId = L"group " + std::to_wstring(pWriter->m_lObjectIdVML);
std::wstring strSpid = L"_x0000_s" + XmlUtils::ToString(0xFFFF & (pWriter->m_lObjectIdVML >> 16), L"%04d");
pWriter->m_lObjectIdVML++;
if (pWriter->m_strId.empty())
{
if (XMLWRITER_DOC_TYPE_XLSX == pWriter->m_lDocType)
{
pWriter->WriteAttribute(L"id", strSpid); //??
}
else
{
pWriter->WriteAttribute(L"id", strId);
pWriter->WriteAttribute(L"o:spid", strSpid);
}
}
else
{
pWriter->WriteAttribute(L"id", pWriter->m_strId);
pWriter->WriteAttribute(L"o:spid", strSpid);
pWriter->m_strId.clear();
}
NSBinPptxRW::CXmlWriter oStylesWriter;
if (pWriter->m_strStyleMain.empty())
{
int dL = 0, dT = 0, dW = 0, dH = 0;
if (grpSpPr.xfrm.is_init())
{
if (grpSpPr.xfrm->offX.is_init()) dL = *grpSpPr.xfrm->offX;
if (grpSpPr.xfrm->offY.is_init()) dT = *grpSpPr.xfrm->offY;
if (grpSpPr.xfrm->extX.is_init()) dW = *grpSpPr.xfrm->extX;
if (grpSpPr.xfrm->extY.is_init()) dH = *grpSpPr.xfrm->extY;
}
oStylesWriter.WriteAttributeCSS(L"position", L"absolute");
if (in_group)
{
oStylesWriter.WriteAttributeCSS_int(L"left", dL / 100);
oStylesWriter.WriteAttributeCSS_int(L"top", dT / 100);
oStylesWriter.WriteAttributeCSS_int(L"width", dW / 100);
oStylesWriter.WriteAttributeCSS_int(L"height", dH / 100);
}
else
{
oStylesWriter.WriteAttributeCSS_int_pt(L"left", dL / 12700);
oStylesWriter.WriteAttributeCSS_int_pt(L"top", dT / 12700);
oStylesWriter.WriteAttributeCSS_int_pt(L"width", dW / 12700);
oStylesWriter.WriteAttributeCSS_int_pt(L"height", dH / 12700);
}
}
if (grpSpPr.xfrm.is_init())
{
if (grpSpPr.xfrm->rot.is_init())
{
int nRot = (int)((double)(*(grpSpPr.xfrm->rot)) / 60000.0);
oStylesWriter.WriteAttributeCSS_int(_T("rotation"), nRot);
}
bool bIsFH = grpSpPr.xfrm->flipH.get_value_or(false);
bool bIsFV = grpSpPr.xfrm->flipV.get_value_or(false);
if (bIsFH && bIsFV)
{
oStylesWriter.WriteAttributeCSS(_T("flip"), _T("xy"));
}
else if (bIsFH)
{
oStylesWriter.WriteAttributeCSS(_T("flip"), _T("x"));
}
else if (bIsFV)
{
oStylesWriter.WriteAttributeCSS(_T("flip"), _T("y"));
}
}
pWriter->WriteAttribute(_T("style"), pWriter->m_strStyleMain + pWriter->m_strStyleWrap + oStylesWriter.GetXmlString());
pWriter->m_strStyleMain.clear();
pWriter->m_strStyleWrap.clear();
if (false == pWriter->m_strAttributesMain.empty())
{
pWriter->WriteString(pWriter->m_strAttributesMain);
pWriter->m_strAttributesMain.clear();
}
int dL = 0, dT = 0, dW = 0, dH = 0;
if (grpSpPr.xfrm.is_init())
{
if (grpSpPr.xfrm->chOffX.is_init()) dL = *grpSpPr.xfrm->chOffX;
if (grpSpPr.xfrm->chOffY.is_init()) dT = *grpSpPr.xfrm->chOffY;
if (grpSpPr.xfrm->chExtX.is_init()) dW = *grpSpPr.xfrm->chExtX;
if (grpSpPr.xfrm->chExtY.is_init()) dH = *grpSpPr.xfrm->chExtY;
}
oStylesWriter.ClearNoAttack();
oStylesWriter.m_oWriter.AddSize(30);
oStylesWriter.m_oWriter.AddIntNoCheck(dL / 100);
oStylesWriter.m_oWriter.AddCharNoCheck(WCHAR(','));
oStylesWriter.m_oWriter.AddIntNoCheck(dT / 100);
pWriter->WriteAttribute(_T("coordorigin"), oStylesWriter.GetXmlString());
oStylesWriter.ClearNoAttack();
oStylesWriter.m_oWriter.AddSize(30);
oStylesWriter.m_oWriter.AddIntNoCheck(dW / 100);
oStylesWriter.m_oWriter.AddCharNoCheck(WCHAR(','));
oStylesWriter.m_oWriter.AddIntNoCheck(dH / 100);
pWriter->WriteAttribute(_T("coordsize"), oStylesWriter.GetXmlString());
pWriter->EndAttributes();
size_t nCount = SpTreeElems.size();
for (size_t i = 0; i < nCount; ++i)
{
if (SpTreeElems[i].is<PPTX::Logic::Shape>())
{
SpTreeElems[i].as<PPTX::Logic::Shape>().toXmlWriterVML(pWriter, oTheme, oClrMap, pContainer, true);
}
else if (SpTreeElems[i].is<PPTX::Logic::Pic>())
{
SpTreeElems[i].as<PPTX::Logic::Pic>().toXmlWriterVML(pWriter, oTheme, oClrMap, true);
}
else if (SpTreeElems[i].is<PPTX::Logic::SpTree>())
{
SpTreeElems[i].as<PPTX::Logic::SpTree>().toXmlWriterVML(pWriter, oTheme, oClrMap, pContainer, true);
}
}
pWriter->WriteString(pWriter->m_strNodes);
pWriter->m_strNodes = _T("");
pWriter->EndNode(_T("v:group"));
}
void SpTree::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
{
std::wstring name_;
if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX ||
pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX_GLOSSARY)
{
if (pWriter->m_lGroupIndex == 0) name_ = L"wpg:wgp";
else name_ = L"wpg:grpSp";
}
else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX) name_ = L"xdr:grpSp";
else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_CHART_DRAWING) name_ = L"cdr:grpSp";
else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DIAGRAM) name_ = L"dgm:grpSp";
else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_GRAPHICS) name_ = L"a:grpSp";
else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DSP_DRAWING)
{
if (pWriter->m_lGroupIndex == 0) name_ = L"dsp:spTree";
else name_ = L"dsp:grpSp";
}
else
{
if (pWriter->m_lGroupIndex == 0) name_ = L"p:spTree";
else name_ = L"p:grpSp";
}
pWriter->StartNode(name_);
pWriter->EndAttributes();
if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX ||
pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX_GLOSSARY)
{
nvGrpSpPr.cNvGrpSpPr.toXmlWriter2(L"wpg", pWriter);
}
else
nvGrpSpPr.toXmlWriter(pWriter);
grpSpPr.toXmlWriter(pWriter);
pWriter->m_lGroupIndex++;
for (size_t i = 0; i < SpTreeElems.size(); ++i)
SpTreeElems[i].toXmlWriter(pWriter);
pWriter->m_lGroupIndex--;
pWriter->EndNode(name_);
}
void SpTree::NormalizeRect(Aggplus::RECT& rect)const
{
if (grpSpPr.xfrm.IsInit())
{
if ((grpSpPr.xfrm->chExtX.get_value_or(0) != 0) && (grpSpPr.xfrm->chExtY.get_value_or(0) != 0))
{
double ScaleX = grpSpPr.xfrm->extX.get_value_or(0) / (double(grpSpPr.xfrm->chExtX.get()));
double ScaleY = grpSpPr.xfrm->extY.get_value_or(0) / (double(grpSpPr.xfrm->chExtY.get()));
double RectWidth = ScaleX * (rect.right - rect.left);
double RectHeight = ScaleY * (rect.bottom - rect.top);
rect.left = (LONG)((rect.left - grpSpPr.xfrm->chOffX.get()) * ScaleX + grpSpPr.xfrm->offX.get());
rect.top = (LONG)((rect.top - grpSpPr.xfrm->chOffY.get()) * ScaleY + grpSpPr.xfrm->offY.get());
rect.right = (LONG)(rect.left + RectWidth);
rect.bottom = (LONG)(rect.top + RectHeight);
}
}
if (parentIs<Logic::SpTree>())
parentAs<Logic::SpTree>().NormalizeRect(rect);
}
void SpTree::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
{
if (getType() == OOX::et_lc_LockedCanvas)
pWriter->StartRecord(SPTREE_TYPE_LOCKED_CANVAS);
else
pWriter->StartRecord(SPTREE_TYPE_SPTREE);
pWriter->WriteRecord1(0, nvGrpSpPr);
pWriter->WriteRecord1(1, grpSpPr);
//---------------------------------------------------------------------------------------
//pWriter->WriteRecordArray(2, 0, SpTreeElems);
pWriter->StartRecord(2);
_UINT32 len = (_UINT32)SpTreeElems.size();
pWriter->WriteULONG(len);
double oldCxCurShape = pWriter->m_dCxCurShape;
double oldCyCurShape = pWriter->m_dCyCurShape;
for (_UINT32 i = 0; i < len; ++i)
{
pWriter->WriteRecord1(0, SpTreeElems[i]);
pWriter->m_dCxCurShape = oldCxCurShape;
pWriter->m_dCyCurShape = oldCyCurShape;
}
pWriter->EndRecord();
//---------------------------------------------------------------------------------------
pWriter->EndRecord();
}
void SpTree::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
{
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
pReader->Skip(5); //+ len
while (pReader->GetPos() < _end_rec)
{
BYTE _at = pReader->GetUChar();
switch (_at)
{
case 0:
{
nvGrpSpPr.fromPPTY(pReader);
}break;
case 1:
{
grpSpPr.fromPPTY(pReader);
}break;
case 2:
{
pReader->Skip(4); // len
ULONG _c = pReader->GetULong();
for (ULONG i = 0; i < _c; ++i)
{
pReader->Skip(1); // type (0)
LONG nElemLength = pReader->GetLong(); // len
//SpTreeElem::fromPPTY сразу делает GetChar, а toPPTY ничего не пишет если не инициализирован
if (nElemLength > 0)
{
SpTreeElem elm;
elm.fromPPTY(pReader);
if (elm.is_init())
{
if (elm.getType() == OOX::et_p_ShapeTree)
{
smart_ptr<SpTree> e = elm.GetElem().smart_dynamic_cast<SpTree>();
e->m_lGroupIndex = m_lGroupIndex + 1;
}
SpTreeElems.push_back(elm);
}
}
}
}break;
default:
{
pReader->SkipRecord();
}break;
}
}
pReader->Seek(_end_rec);
}
LockedCanvas::LockedCanvas() : SpTree(L"a")
{
}
LockedCanvas& LockedCanvas::operator=(const LockedCanvas& oSrc)
{
parentFile = oSrc.parentFile;
parentElement = oSrc.parentElement;
nvGrpSpPr = oSrc.nvGrpSpPr;
grpSpPr = oSrc.grpSpPr;
for (size_t i=0; i < oSrc.SpTreeElems.size(); i++)
SpTreeElems.push_back(oSrc.SpTreeElems[i]);
m_lGroupIndex = oSrc.m_lGroupIndex;
return *this;
}
OOX::EElementType LockedCanvas::getType () const
{
return OOX::et_lc_LockedCanvas;
}
void LockedCanvas::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
SpTree::fromXML(oReader);
}
void LockedCanvas::fromXML(XmlUtils::CXmlNode& node)
{
SpTree::fromXML(node);
}
std::wstring LockedCanvas::toXML() const
{
XmlUtils::CAttribute oAttr;
oAttr.Write(L"xmlns:lc", L"http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas");
XmlUtils::CNodeValue oValue;
oValue.Write(nvGrpSpPr);
oValue.Write(grpSpPr);
oValue.WriteArray(SpTreeElems);
return XmlUtils::CreateNode(L"lc:lockedCanvas", oAttr, oValue);
}
void LockedCanvas::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
{
BYTE lDocType = pWriter->m_lDocType;
pWriter->m_lDocType = XMLWRITER_DOC_TYPE_GRAPHICS;
pWriter->StartNode(L"lc:lockedCanvas");
pWriter->StartAttributes();
pWriter->WriteAttribute(L"xmlns:lc", L"http://schemas.openxmlformats.org/drawingml/2006/lockedCanvas");
pWriter->EndAttributes();
nvGrpSpPr.toXmlWriter(pWriter);
grpSpPr.toXmlWriter(pWriter);
pWriter->m_lGroupIndex++;
for (size_t i = 0; i < SpTreeElems.size(); ++i)
{
SpTreeElems[i].toXmlWriter(pWriter);
}
pWriter->m_lGroupIndex--;
pWriter->EndNode(L"lc:lockedCanvas");
pWriter->m_lDocType = lDocType;
}
void LockedCanvas::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
{
BinDocxRW::CDocxSerializer* docx = pWriter->m_pMainDocument;
pWriter->m_pMainDocument = NULL;
pWriter->StartRecord(SPTREE_TYPE_LOCKED_CANVAS);
pWriter->WriteRecord1(0, nvGrpSpPr);
pWriter->WriteRecord1(1, grpSpPr);
pWriter->WriteRecordArray(2, 0, SpTreeElems);
pWriter->EndRecord();
pWriter->m_pMainDocument = docx;
}
void LockedCanvas::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
{
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
pReader->Skip(5); // type + len
BinDocxRW::CDocxSerializer* docx = pReader->m_pMainDocument;
pReader->m_pMainDocument = NULL;
while (pReader->GetPos() < _end_rec)
{
BYTE _at = pReader->GetUChar();
switch (_at)
{
case 0:
{
nvGrpSpPr.fromPPTY(pReader);
break;
}
case 1:
{
grpSpPr.fromPPTY(pReader);
break;
}
case 2:
{
pReader->Skip(4); // len
ULONG _c = pReader->GetULong();
for (ULONG i = 0; i < _c; ++i)
{
pReader->Skip(1); // type (0)
LONG nElemLength = pReader->GetLong(); // len
//SpTreeElem::fromPPTY сразу делает GetChar, а toPPTY ничего не пишет если не инициализирован
if(nElemLength > 0)
{
SpTreeElem elm;
elm.fromPPTY(pReader);
if (elm.is_init())
{
if (elm.getType() == OOX::et_p_ShapeTree)
{
smart_ptr<SpTree> e = elm.GetElem().smart_dynamic_cast<SpTree>();
e->m_lGroupIndex = m_lGroupIndex + 1;
}
SpTreeElems.push_back(elm);
}
}
}
}
default:
{
break;
}
}
}
pReader->Seek(_end_rec);
pReader->m_pMainDocument = docx;
}
}
}
Reference in New Issue View Git Blame Copy Permalink