pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-07-17 06:13:58 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
develop
core/OOXML/PPTXFormat/Logic/Effects/Reflection.cpp
Alexander Trofimov 76ee07f61c [copyright] Update copyright header 
Co-authored-by: Alexander Trofimov <alexander.trofimov@onlyoffice.com>
Co-committed-by: Alexander Trofimov <alexander.trofimov@onlyoffice.com>
2026-05-14 08:23:56 +00:00

238 lines
8.4 KiB
C++
Raw Permalink Blame History

/*
* Copyright (C) Ascensio System SIA, 2009-2026
*
* 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, together with the
* additional terms provided in the LICENSE file.
*
* 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: https://www.gnu.org/licenses/agpl-3.0.html
*
* You can contact Ascensio System SIA by email at info@onlyoffice.com
* or by postal mail at 20A-6 Ernesta Birznieka-Upisha Street, Riga,
* LV-1050, Latvia, European Union.
*
* The interactive user interfaces in modified versions of the Program
* are required to display Appropriate Legal Notices in accordance with
* Section 5 of the GNU AGPL version 3.
*
* No trademark rights are granted under this License.
*
* All non-code elements of the Product, including illustrations,
* icon sets, and technical writing content, are licensed under the
* Creative Commons Attribution-ShareAlike 4.0 International License:
* https://creativecommons.org/licenses/by-sa/4.0/legalcode
*
* This license applies only to such non-code elements and does not
* modify or replace the licensing terms applicable to the Program's
* source code, which remains licensed under the GNU Affero General
* Public License v3.
*
* SPDX-License-Identifier: AGPL-3.0-only
*/
#include "Reflection.h"
namespace PPTX
{
namespace Logic
{
Reflection& Reflection::operator=(const Reflection& oSrc)
{
parentFile = oSrc.parentFile;
parentElement = oSrc.parentElement;
algn = oSrc.algn;
blurRad = oSrc.blurRad;
stA = oSrc.stA;
endA = oSrc.endA;
stPos = oSrc.stPos;
endPos = oSrc.endPos;
dir = oSrc.dir;
fadeDir = oSrc.fadeDir;
dist = oSrc.dist;
kx = oSrc.kx;
ky = oSrc.ky;
rotWithShape = oSrc.rotWithShape;
sx = oSrc.sx;
sy = oSrc.sy;
return *this;
}
OOX::EElementType Reflection::getType() const
{
return OOX::et_a_reflection;
}
void Reflection::fromXML(XmlUtils::CXmlLiteReader& oReader)
{
ReadAttributes( oReader );
}
void Reflection::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
{
WritingElement_ReadAttributes_Start_No_NS( oReader )
WritingElement_ReadAttributes_Read_if ( oReader, _T("blurRad"), blurRad)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("dir"), dir)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("fadeDir"), fadeDir)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("dist"), dist)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("algn"), algn)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("kx"), kx)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("ky"), ky)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("rotWithShape"), rotWithShape)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("sx"), sx)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("sy"), sy)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("stA"), stA)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("endA"), endA)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("stPos"), stPos)
WritingElement_ReadAttributes_Read_else_if( oReader, _T("endPos"), endPos)
WritingElement_ReadAttributes_End_No_NS( oReader )
Normalize();
}
void Reflection::fromXML(XmlUtils::CXmlNode& node)
{
XmlMacroReadAttributeBase(node, L"algn", algn);
XmlMacroReadAttributeBase(node, L"blurRad", blurRad);
XmlMacroReadAttributeBase(node, L"dir", dir);
XmlMacroReadAttributeBase(node, L"dist", dist);
XmlMacroReadAttributeBase(node, L"kx", kx);
XmlMacroReadAttributeBase(node, L"ky", ky);
XmlMacroReadAttributeBase(node, L"rotWithShape", rotWithShape);
XmlMacroReadAttributeBase(node, L"sx", sx);
XmlMacroReadAttributeBase(node, L"sy", sy);
XmlMacroReadAttributeBase(node, L"stA", stA);
XmlMacroReadAttributeBase(node, L"endA", endA);
XmlMacroReadAttributeBase(node, L"stPos", stPos);
XmlMacroReadAttributeBase(node, L"endPos", endPos);
XmlMacroReadAttributeBase(node, L"fadeDir", fadeDir);
Normalize();
}
std::wstring Reflection::toXML() const
{
XmlUtils::CAttribute oAttr;
oAttr.Write(_T("blurRad"), blurRad);
oAttr.Write(_T("stA"), stA);
oAttr.Write(_T("stPos"), stPos);
oAttr.Write(_T("endA"), endA);
oAttr.Write(_T("endPos"), endPos);
oAttr.Write(_T("dist"), dist);
oAttr.Write(_T("dir"), dir);
oAttr.Write(_T("fadeDir"), fadeDir);
oAttr.Write(_T("sx"), sx);
oAttr.Write(_T("sy"), sy);
oAttr.Write(_T("kx"), kx);
oAttr.Write(_T("ky"), ky);
oAttr.WriteLimitNullable(_T("algn"), algn);
oAttr.Write(_T("rotWithShape"), rotWithShape);
return XmlUtils::CreateNode(_T("a:reflection"), oAttr);
}
void Reflection::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
{
std::wstring sNodeNamespace;
std::wstring sAttrNamespace;
if (XMLWRITER_DOC_TYPE_WORDART == pWriter->m_lDocType)
{
sNodeNamespace = L"w14:";
sAttrNamespace = sNodeNamespace;
}
else
sNodeNamespace = L"a:";
pWriter->StartNode(sNodeNamespace + L"reflection");
pWriter->StartAttributes();
pWriter->WriteAttribute(sAttrNamespace + L"blurRad", blurRad);
pWriter->WriteAttribute(sAttrNamespace + L"stA", stA);
pWriter->WriteAttribute(sAttrNamespace + L"stPos", stPos);
pWriter->WriteAttribute(sAttrNamespace + L"endA", endA);
pWriter->WriteAttribute(sAttrNamespace + L"endPos", endPos);
pWriter->WriteAttribute(sAttrNamespace + L"dist", dist);
pWriter->WriteAttribute(sAttrNamespace + L"dir", dir);
pWriter->WriteAttribute(sAttrNamespace + L"fadeDir", fadeDir);
pWriter->WriteAttribute(sAttrNamespace + L"sx", sx);
pWriter->WriteAttribute(sAttrNamespace + L"sy", sy);
pWriter->WriteAttribute(sAttrNamespace + L"kx", kx);
pWriter->WriteAttribute(sAttrNamespace + L"ky", ky);
pWriter->WriteAttribute(sAttrNamespace + L"algn", algn);
pWriter->WriteAttribute(sAttrNamespace + L"rotWithShape", rotWithShape);
pWriter->EndAttributes();
pWriter->EndNode(sNodeNamespace + L"reflection");
}
void Reflection::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
{
pWriter->StartRecord(EFFECT_TYPE_REFLECTION);
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
pWriter->WriteLimit2(0, algn);
pWriter->WriteInt2(1, blurRad);
pWriter->WriteInt2(2, stA);
pWriter->WriteInt2(3, endA);
pWriter->WriteInt2(4, stPos);
pWriter->WriteInt2(5, endPos);
pWriter->WriteInt2(6, dir);
pWriter->WriteInt2(7, fadeDir);
pWriter->WriteInt2(8, dist);
pWriter->WriteInt2(9, kx);
pWriter->WriteInt2(10, ky);
pWriter->WriteInt2(11, sx);
pWriter->WriteInt2(12, sy);
pWriter->WriteBool2(13, rotWithShape);
pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
pWriter->EndRecord();
}
void Reflection::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
{
pReader->Skip(4); // len
BYTE _type = pReader->GetUChar();
LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
pReader->Skip(1);
while (true)
{
BYTE _at = pReader->GetUChar_TypeNode();
if (_at == NSBinPptxRW::g_nodeAttributeEnd)
break;
switch (_at)
{
case 0: algn = pReader->GetUChar(); break;
case 1: blurRad = pReader->GetLong(); break;
case 2: stA = pReader->GetLong(); break;
case 3: endA = pReader->GetLong(); break;
case 4: stPos = pReader->GetLong(); break;
case 5: endPos = pReader->GetLong(); break;
case 6: dir = pReader->GetLong(); break;
case 7: fadeDir = pReader->GetLong(); break;
case 8: dist = pReader->GetLong(); break;
case 9: kx = pReader->GetLong(); break;
case 10:ky = pReader->GetLong(); break;
case 11:sx = pReader->GetLong(); break;
case 12:sy = pReader->GetLong(); break;
case 13:rotWithShape = pReader->GetBool(); break;
}
}
pReader->Seek(_end_rec);
}
void Reflection::FillParentPointersForChilds(){}
void Reflection::Normalize()
{
blurRad.normalize_positive();
stA.normalize_positive();
endA.normalize_positive();
stPos.normalize_positive();
endPos.normalize_positive();
dist.normalize_positive();
dir.normalize(0, 21600000);
//fadeDir.normalize(0, 27273042316900);
kx.normalize(-5400000, 5400000);
ky.normalize(-5400000, 5400000);
}
} // namespace Logic
} // namespace PPTX
Reference in New Issue View Git Blame Copy Permalink