Yajbir-Malik/DocumentServer-v-9.2.0
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
DocumentServer-v-9.2.0/core/MsBinaryFile/PptFile/PPTXWriter/ShapeWriter.cpp
Yajbir Singh f1b860b25c
Some checks failed
check / markdownlint (push) Has been cancelled
Details
check / spellchecker (push) Has been cancelled
Details
updated
2025-12-11 19:03:17 +05:30

3039 lines
105 KiB
C++
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* (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 "ShapeWriter.h"
#include "StylesWriter.h"
#include "BulletsConverter.h"
#include "../Drawing/Theme.h"
#include "../../XlsFile/Converter/ShapeType.h"
#include "../../../OOXML/Base/Unit.h"
#include "../../../OOXML/PPTXFormat/Logic/SpTreeElem.h"
#include "../../../OOXML/PPTXFormat/Logic/Shape.h"
#include "../../../OOXML/PPTXFormat/Logic/SpTree.h"
#include <algorithm>
using namespace PPT;
static UINT nRTCounter = 1;
CStylesWriter::CStylesWriter() : m_pTheme(NULL) {}
CStylesWriter::CStylesWriter(PPT::CTheme* pTheme) : m_pTheme(pTheme) {}
void CStylesWriter::ConvertStyleLevel(PPT::CTextStyleLevel& oLevel, PPT::CStringWriter& oWriter, const int& nLevel)
{//дублирование CTextPFRun и CTextCFRun с ShapeWriter - todooo - вынести отдельно
std::wstring str1;
if (nLevel == 9)
str1 = L"<a:defPPr";
else
{
str1 = L"<a:lvl" + std::to_wstring(nLevel + 1) + L"pPr";
}
oWriter.WriteString(str1);
// <a:pPr>
auto pPPr = new PPTX::Logic::TextParagraphPr;
BulletsConverter buConverter;
buConverter.ConvertPFRun(*pPPr, &oLevel.m_oPFRun);
std::wstring strPPr = pPPr->toXML().substr(6); // remove <a:pPr
strPPr = strPPr.substr(0, strPPr.size() - 8); // remove </a:pPr>
delete pPPr;
oWriter.WriteString(strPPr);
oWriter.WriteString(L"<a:defRPr");
PPT::CTextCFRun* pCF = &oLevel.m_oCFRun;
if (pCF->Language.is_init())
{
std::wstring str_lang = m_lcidConverter.get_wstring(pCF->Language.get());
if (str_lang.length() > 0)
oWriter.WriteString(std::wstring(L" lang=\"") + str_lang + L"\"");
}
if (pCF->Size.is_init())
{
std::wstring str = std::to_wstring((int)(100 * pCF->Size.get()));
oWriter.WriteString(L" sz=\"" + str + L"\"");
}
if (pCF->FontBold.is_init())
{
if (pCF->FontBold.get())
oWriter.WriteString(L" b=\"1\"");
else
oWriter.WriteString(L" b=\"0\"");
}
if (pCF->FontItalic.is_init())
{
if (pCF->FontItalic.get())
oWriter.WriteString(std::wstring(L" i=\"1\""));
else
oWriter.WriteString(std::wstring(L" i=\"0\""));
}
oWriter.WriteString(std::wstring(L">"));
if (pCF->Color.is_init())
{
if (pCF->Color->m_lSchemeIndex != -1)
{
oWriter.WriteString(L"<a:solidFill><a:schemeClr val=\"" + GetColorInScheme(pCF->Color->m_lSchemeIndex) + L"\"/></a:solidFill>");
}
else
{
std::wstring color = XmlUtils::ToString(pCF->Color->GetLONG_RGB(), L"%06X");
oWriter.WriteString(L"<a:solidFill><a:srgbClr val=\"" + color + L"\"/></a:solidFill>");
}
}
if ((pCF->font.ansi.is_init()) && (!pCF->font.ansi->Name.empty()))
{
oWriter.WriteString(L"<a:latin typeface=\"" + pCF->font.ansi->Name + L"\"/>");
}
else if (pCF->fontRef.is_init())
{
if ((m_pTheme) && (pCF->fontRef.get() < m_pTheme->m_arFonts.size()))
{
oWriter.WriteString(L"<a:latin typeface=\"" + m_pTheme->m_arFonts[pCF->fontRef.get()].Name + L"\"/>");
}
else
{
if (0 == pCF->fontRef.get())
{
oWriter.WriteString(L"<a:latin typeface=\"+mj-lt\"/>");
}
else
{
oWriter.WriteString(L"<a:latin typeface=\"+mn-lt\"/>");
}
}
}
if (pCF->font.ea.is_init())
{
oWriter.WriteString(L"<a:ea typeface=\"" + pCF->font.ea->Name + L"\"/>");
}
if (pCF->font.sym.is_init())
{
oWriter.WriteString(L"<a:sym typeface=\"" + pCF->font.sym->Name + L"\"/>");
}
oWriter.WriteString(L"</a:defRPr>");
std::wstring str3;
if (nLevel == 9)
str3 = L"</a:defPPr>";
else
str3 = L"</a:lvl" + std::to_wstring(nLevel + 1) + L"pPr>";
oWriter.WriteString(str3);
}
std::wstring CShapeWriter::getOWriterStr() const
{
return m_oWriter.GetData();
}
PPT::CShapeWriter::CShapeWriter()
{
m_pTheme = NULL;
m_pRels = NULL;
m_lNextShapeID = 1000;
m_bWordArt = false;
m_bTextBox = false;
//////////////////////////////////////////////////////////////////////
m_dDpiX = 96.0;
m_dDpiY = 96.0;
m_lClipMode = c_nClipRegionTypeWinding;
m_pSimpleGraphicsConverter = new Aggplus::CGraphicsPathSimpleConverter();
//m_pSimpleGraphicsConverter->SetRenderer(this);
m_dTransformAngle = 0.0;
m_pFontManager = NULL;
}
bool PPT::CShapeWriter::SetElement(CElementPtr pElem)
{
m_pElement = pElem;
m_pSimpleGraphicsConverter->PathCommandEnd();
m_bWordArt = false;
m_bTextBox = false;
m_xmlGeomAlternative.clear();
m_xmlTxBodyAlternative.clear();
m_xmlAlternative.clear();
m_oWriter.ClearNoAttack();
m_oWriterPath.ClearNoAttack();
m_oWriterVML.ClearNoAttack();
return (m_pElement != NULL);
}
std::wstring PPT::CShapeWriter::ConvertLine(CPen & pen)
{
PPT::CStringWriter line_writer;
std::wstring strL;
switch(pen.LineStyle)
{
case 1: strL = L" cmpd=\"dbl\""; break;
case 2: strL = L" cmpd=\"thickThin\""; break;
case 3: strL = L" cmpd=\"thinThick\""; break;
case 4: strL = L" cmpd=\"tri\""; break;
}
line_writer.WriteString(L"<a:ln w=\"" + std::to_wstring(pen.Size) + L"\"" + strL + L">");
line_writer.WriteString(L"<a:solidFill>");
line_writer.WriteString(ConvertColor(pen.Color, pen.Alpha));
line_writer.WriteString(L"</a:solidFill>");
switch(pen.DashStyle)
{
case 1: line_writer.WriteString(L"<a:prstDash val=\"sysDash\"/>"); break;
case 2: line_writer.WriteString(L"<a:prstDash val=\"sysDot\"/>"); break;
case 3: line_writer.WriteString(L"<a:prstDash val=\"sysDashDot\"/>"); break;
case 4: line_writer.WriteString(L"<a:prstDash val=\"sysDashDotDot\"/>"); break;
case 5: line_writer.WriteString(L"<a:prstDash val=\"dot\"/>"); break;
case 6: line_writer.WriteString(L"<a:prstDash val=\"dash\"/>"); break;
case 7: line_writer.WriteString(L"<a:prstDash val=\"lgDash\"/>"); break;
case 8: line_writer.WriteString(L"<a:prstDash val=\"dashDot\"/>"); break;
case 9: line_writer.WriteString(L"<a:prstDash val=\"lgDashDot\"/>"); break;
case 10:line_writer.WriteString(L"<a:prstDash val=\"lgDashDotDot\"/>"); break;
}
switch(pen.LineJoin)
{
case 0: line_writer.WriteString(L"<a:bevel/>"); break;
case 1: line_writer.WriteString(L"<a:miter/>"); break;
case 2: line_writer.WriteString(L"<a:round/>"); break;
}
line_writer.WriteString(L"<a:headEnd" + ConvertLineEnd(pen.LineStartCap, pen.LineStartLength, pen.LineStartWidth) + L"/>");
line_writer.WriteString(L"<a:tailEnd" + ConvertLineEnd(pen.LineEndCap, pen.LineEndLength, pen.LineEndWidth) + L"/>");
line_writer.WriteString(L"</a:ln>");
return line_writer.GetData();
}
std::wstring PPT::CShapeWriter::ConvertLineEnd(unsigned char cap, unsigned char length, unsigned char width)
{
if (cap < 1) return L"";
std::wstring sResult;
switch(cap)
{
case 1: sResult += L" type=\"triangle\""; break;
case 2: sResult += L" type=\"stealth\""; break;
case 3: sResult += L" type=\"diamond\""; break;
case 4: sResult += L" type=\"oval\""; break;
case 5: sResult += L" type=\"arrow\""; break;
}
switch(length)
{
case 0: sResult += L" len=\"sm\""; break;
case 1: sResult += L" len=\"med\""; break;
case 2: sResult += L" len=\"lg\""; break;
}
switch(width)
{
case 0: sResult += L" w=\"sm\""; break;
case 1: sResult += L" w=\"med\""; break;
case 2: sResult += L" w=\"lg\""; break;
}
return sResult;
}
std::wstring PPT::CShapeWriter::ConvertBrush(CBrush & brush)
{
PPT::CStringWriter brush_writer;
if (brush.Type == c_BrushTypeTexture)
{
if (m_pElement && ( m_pElement->m_etType == etPicture ||
m_pElement->m_etType == etAudio ||
m_pElement->m_etType == etVideo)) //фон для картинки с празрачностью
{
brush_writer.WriteString(L"<a:noFill/>");
}
else
{
std::wstring strRid = m_pRels->WriteImage(brush.TexturePath);
brush_writer.WriteString(L"<a:blipFill dpi=\"0\" rotWithShape=\"1\"><a:blip r:embed=\"" + strRid + L"\"");
if (false)
{
brush_writer.WriteString(L"><a:duotone><a:schemeClr val=\"bg1\"/>");
brush_writer.WriteString(ConvertColor(brush.Color2, brush.Alpha2));
brush_writer.WriteString(L"</a:duotone></a:blip><a:srcRect/>");
} else
{
brush_writer.WriteString(L"/><a:srcRect/>");
}
if ( brush.TextureMode == c_BrushTextureModeTile)
brush_writer.WriteString(L"<a:tile/>");
else
brush_writer.WriteString(L"<a:stretch><a:fillRect/></a:stretch>");
brush_writer.WriteString(L"</a:blipFill>");
}
}
else if ( brush.Type == c_BrushTypeNoFill )
{
brush_writer.WriteString(L"<a:noFill/>");
}
else if ( brush.Type == c_BrushTypePathGradient1 ||
brush.Type == c_BrushTypePathGradient2 ||
brush.Type == c_BrushTypeCenter ||
brush.Type == c_BrushTypeHorizontal ||
brush.Type == c_BrushTypeVertical)
{
brush_writer.WriteString(L"<a:gradFill><a:gsLst>");
if (brush.ColorsPosition.empty() == false)
{
for (size_t i = 0; i < brush.ColorsPosition.size(); i++)
{
std::wstring str = std::to_wstring( (int)(brush.ColorsPosition[i].second * 1000));
brush_writer.WriteString(L"<a:gs pos=\"" + str + L"\">");
brush_writer.WriteString(ConvertColor(brush.ColorsPosition[i].first, 255));
brush_writer.WriteString(L"</a:gs>");
}
}
else
{
brush_writer.WriteString(L"<a:gs pos=\"0\">");
brush_writer.WriteString(ConvertColor(brush.Color1, brush.Alpha1));
brush_writer.WriteString(L"</a:gs>");
brush_writer.WriteString(L"<a:gs pos=\"100000\">");
brush_writer.WriteString(ConvertColor(brush.Color2, brush.Alpha2));
brush_writer.WriteString(L"</a:gs>");
}
brush_writer.WriteString(L"</a:gsLst>");
brush_writer.WriteString(L"<a:lin ang=\"");
{
if (brush.LinearAngle < -180) brush.LinearAngle += 180;
if (brush.LinearAngle > 180) brush.LinearAngle -= 180;
double val = (90 - brush.LinearAngle) ;
if (val < 0) val = 0;
if (val > 360) val -= 360;
std::wstring str = std::to_wstring((int)(val * 60000));
brush_writer.WriteString(str);
}
brush_writer.WriteString(L"\" scaled=\"1\"/>");
brush_writer.WriteString(L"</a:gradFill>");
}
else if(brush.Type == c_BrushTypePattern)
{//типов нету в ппт - вместо них шаблон-картинка
brush_writer.WriteString(L"<a:pattFill prst=\"pct80\">");
brush_writer.WriteString(L"<a:fgClr>");
brush_writer.WriteString(ConvertColor(brush.Color1, brush.Alpha1));
brush_writer.WriteString(L"</a:fgClr>");
brush_writer.WriteString(L"<a:bgClr>");
brush_writer.WriteString(ConvertColor(brush.Color2, brush.Alpha2));
brush_writer.WriteString(L"</a:bgClr>");
brush_writer.WriteString(L"</a:pattFill>");
}
else if (brush.Type != c_BrushTypeNotSet)
{
brush_writer.WriteString(std::wstring(L"<a:solidFill>"));
brush_writer.WriteString(ConvertColor(brush.Color1, brush.Alpha1));
brush_writer.WriteString(std::wstring(L"</a:solidFill>"));
}
return brush_writer.GetData();
}
std::wstring PPT::CShapeWriter::ConvertShadow(CShadow & shadow)
{
std::wstring Preset;
bool Inner = false;
if (shadow.Visible == false) return L"";
double dist = sqrt(shadow.DistanceY * shadow.DistanceY + shadow.DistanceX * shadow.DistanceX);
double dir = 0;
if (fabs(shadow.DistanceY) > 0)
{
dir = 180 * atan(shadow.DistanceX / shadow.DistanceY) / 3.1415926;
if (dir < 0) dir += 180;
if (shadow.DistanceX < 0 && shadow.DistanceY < 0) dir *= 10;
}
if (shadow.Type == 1) Preset = L"shdw13";
if (shadow.Type == 5)
{
if (shadow.DistanceX < 0 && shadow.DistanceY < 0) Preset = L"shdw18";
else Preset = L"shdw17";
}
if (shadow.Type == 2 && shadow.OriginX < 0)
{
if (shadow.OriginX < -1.4)
{
if (shadow.ScaleYToY < 0) Preset = L"shdw15";
else Preset = L"shdw11";
}
else
{
if (shadow.ScaleYToY < 0) Preset = L"shdw16";
else Preset = L"shdw12";
}
}
std::wstring strDir;
std::wstring strDist;
if (shadow.DistanceY != 0 && shadow.DistanceX != 0)
{
if (shadow.DistanceY < 0 && shadow.DistanceX < 0) dir /=2;
strDir = L" dir=\"" + std::to_wstring((int)(dir * 60000)) + L"\"";
strDist = L" dist=\"" + std::to_wstring((int)dist) + L"\"";
}
std::wstring strSY;
if (shadow.ScaleYToY < 1 || shadow.ScaleYToY > 1)
{
strSY = L" sy=\"" + std::to_wstring((int)(shadow.ScaleYToY * 100000)) + L"\"";
}
std::wstring strSX;
if (shadow.ScaleYToX < 1 || shadow.ScaleYToX > 1)
{
strSX = L" kx=\"" + std::to_wstring((int)((shadow.ScaleYToX + 0.5) * 360000)) + L"\"";
}
PPT::CStringWriter shadow_writer;
shadow_writer.WriteString(L"<a:effectLst>");
bool needHiddenEffect = false;
if (!Preset.empty())
{
shadow_writer.WriteString(L"<a:prstShdw");
shadow_writer.WriteString(L" prst=\"" + Preset + L"\"");
//shadow_writer.WriteString(std::wstring(L" rotWithShape=\"0\" algn=\"ctr\""));
shadow_writer.WriteString(strDir);
shadow_writer.WriteString(strDist);
shadow_writer.WriteString(L">");
shadow_writer.WriteString(ConvertColor(shadow.Color,shadow.Alpha));
shadow_writer.WriteString(L"</a:prstShdw>");
}
else if (Inner)
{
shadow_writer.WriteString(L"<a:innerShdw");
shadow_writer.WriteString(L" rotWithShape=\"0\"");
if (strSX.empty() && strSY.empty())
{
shadow_writer.WriteString(L" algn=\"ctr\"");
}
shadow_writer.WriteString(strSX);
shadow_writer.WriteString(strSY);
shadow_writer.WriteString(strDir);
shadow_writer.WriteString(strDist);
shadow_writer.WriteString(L">");
shadow_writer.WriteString(ConvertColor(shadow.Color,shadow.Alpha));
shadow_writer.WriteString(L"</a:innerShdw>");
}
else
{
// needHiddenEffect = shadow.Visible;
shadow_writer.WriteString(L"<a:outerShdw");
shadow_writer.WriteString(strDist);
shadow_writer.WriteString(strDir);
if (strSX.empty() && strSY.empty())
{
shadow_writer.WriteString(L" algn=\"ctr\"");
}
shadow_writer.WriteString(strSX);
shadow_writer.WriteString(strSY);
shadow_writer.WriteString(L" rotWithShape=\"0\"");
shadow_writer.WriteString(L">");
shadow_writer.WriteString(ConvertColor(shadow.Color,shadow.Alpha));
shadow_writer.WriteString(L"</a:outerShdw>");
}
shadow_writer.WriteString(L"</a:effectLst>");
// if (needHiddenEffect)
// {
// std::wstring STRshadow;
// STRshadow = L"<a:extLst><a:ext uri=\"{AF507438-7753-43E0-B8FC-AC1667EBCBE1}\"><a14:hiddenEffects xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\">";
// STRshadow += shadow_writer.GetData();
// STRshadow += L"</a14:hiddenEffects></a:ext><a:ext uri=\"{53640926-AAD7-44D8-BBD7-CCE9431645EC}\"><a14:shadowObscured xmlns:a14=\"http://schemas.microsoft.com/office/drawing/2010/main\" val=\"1\"/></a:ext></a:extLst>";
// return STRshadow;
// }
return shadow_writer.GetData();
}
std::wstring PPT::CShapeWriter::ConvertColor(CColor & color, long alpha)
{
PPT::CStringWriter color_writer;
if (color.m_lSchemeIndex == -1)
{
if (255 == alpha)
{
auto strColor = XmlUtils::ToString(color.GetLONG_RGB(), L"%06X");
color_writer.WriteString(L"<a:srgbClr val=\"" + strColor + L"\"/>");
}
else
{
auto strColor = XmlUtils::ToString(color.GetLONG_RGB(), L"%06X");
color_writer.WriteString(L"<a:srgbClr val=\"" + strColor + L"\">" +
L"<a:alpha val=\"" + std::to_wstring((int)(alpha * 100000 / 255)) + L"\"/></a:srgbClr>");
}
}
else
{
if (255 == alpha)
{
color_writer.WriteString(L"<a:schemeClr val=\"" + CStylesWriter::GetColorInScheme(color.m_lSchemeIndex) + L"\"/>");
}
else
{
std::wstring strAlpha = std::to_wstring((int)(alpha * 100000 / 255));
color_writer.WriteString(L"<a:schemeClr val=\"" + CStylesWriter::GetColorInScheme(color.m_lSchemeIndex) + L"\"><a:alpha val=\"" + strAlpha + L"\"/></a:schemeClr>");
}
}
return color_writer.GetData();
}
void PPT::CShapeWriter::WriteImageInfo()
{
CImageElement* pImageElement = dynamic_cast<CImageElement*>(m_pElement.get());
if (!pImageElement) return;
CAudioElement* pAudioElement = dynamic_cast<CAudioElement*>(pImageElement);
CVideoElement* pVideoElement = dynamic_cast<CVideoElement*>(pImageElement);
m_oWriter.WriteString(std::wstring(L"<p:nvPicPr>"));
if (pImageElement->m_lID < 0)
pImageElement->m_lID = m_lNextShapeID;
COleObjectElement* pOleObjectElement = dynamic_cast<COleObjectElement*>(m_pElement.get());
std::wstring strShapeID = std::to_wstring(pOleObjectElement ? 0 : pImageElement->m_lID);
m_oWriter.WriteString(std::wstring(L"<p:cNvPr id=\"") + strShapeID + L"\"" );
if (pImageElement->m_sName.empty())
{
if (pAudioElement) pImageElement->m_sName = std::wstring(L"Audio ") + strShapeID;
else if (pVideoElement) pImageElement->m_sName = std::wstring(L"Video ") + strShapeID;
else pImageElement->m_sName = std::wstring(L"Image ") + strShapeID;
}
if (pImageElement->m_bHidden) m_oWriter.WriteString(std::wstring(L" hidden=\"1\""));
m_oWriter.WriteString(std::wstring(L" name=\""));
m_oWriter.WriteStringXML(pImageElement->m_sName);
m_oWriter.WriteString(std::wstring(L"\""));
if (!pImageElement->m_sDescription.empty())
{//бывает всякая разная бяка сохранена
m_oWriter.WriteString(std::wstring(L" descr=\""));
m_oWriter.WriteString(XmlUtils::EncodeXmlStringExtend(pImageElement->m_sDescription, true));
m_oWriter.WriteString(std::wstring(L"\""));
}
m_oWriter.WriteString(std::wstring(L">"));
WriteHyperlink(m_pElement->m_arrActions);
m_oWriter.WriteString(std::wstring(L"</p:cNvPr><p:cNvPicPr><a:picLocks"));
if (false == m_pElement->m_bChildAnchorEnabled)
{
m_oWriter.WriteString(std::wstring(L" noGrp=\"1\""));
}
m_oWriter.WriteString(std::wstring(L" noChangeAspect=\"1\"/></p:cNvPicPr>"));
++m_lNextShapeID;
m_oWriter.WriteString(std::wstring(L"<p:nvPr>"));
if (-1 != pImageElement->m_lPlaceholderType)
{
m_oWriter.WriteString(std::wstring(L"<p:ph"));
if (pImageElement->m_lPlaceholderType > 0 && pImageElement->m_lPlaceholderType != PT_Body_Empty)
m_oWriter.WriteString(std::wstring(L" type=\"") + GetPhType(pImageElement->m_lPlaceholderType) + L"\"");
else if (pImageElement->m_lPlaceholderID == -1)
m_oWriter.WriteString(std::wstring(L" type=\"obj\""));
if (-1 != pImageElement->m_lPlaceholderID)
{
std::wstring strIdx = std::to_wstring(pImageElement->m_lPlaceholderID );
m_oWriter.WriteString(std::wstring(L" idx=\"") + strIdx + L"\"");
}
m_oWriter.WriteString(std::wstring(L"/>"));
}
std::wstring sMediaFile;
if ((pVideoElement) && (!pVideoElement->m_strVideoFileName.empty()))
{
bool bExternal = false;
std::wstring strRid = m_pRels->WriteVideo(pVideoElement->m_strVideoFileName, bExternal);
m_oWriter.WriteString(L"<a:videoFile r:link=\"" + strRid + L"\"/>");
sMediaFile = bExternal ? L"" : pVideoElement->m_strVideoFileName;
}
if ((pAudioElement) && (!pAudioElement->m_strAudioFileName.empty()))
{
bool bExternal = false;
std::wstring strRid = m_pRels->WriteAudio(pAudioElement->m_strAudioFileName, bExternal);
// if ((int)pAudioElement->m_strAudioFileName.find(L".WAV") == -1 &&
// (int)pAudioElement->m_strAudioFileName.find(L".wav") == -1)
// m_oWriter.WriteString(L"<a:wavAudioFile r:embed=\"" + strRid + L"\"/>");
// else
m_oWriter.WriteString(L"<a:audioFile r:link=\"" + strRid + L"\"/>"); // todo for anim connection
sMediaFile = bExternal ? L"" : pAudioElement->m_strAudioFileName;
}
if (sMediaFile.empty() == false)
{
std::wstring strRid = m_pRels->WriteImage(pImageElement->m_strImageFileName);
if (!strRid.empty() && false)
{
m_oWriter.WriteString(L"<p:extLst><p:ext uri=\"{DAA4B4D4-6D71-4841-9C94-3DE7FCFB9230}\">\
<p14:media xmlns:p14=\"http://schemas.microsoft.com/office/powerpoint/2010/main\" r:embed=\"" + strRid + L"\"/></p:ext></p:extLst>");
}
}
m_oWriter.WriteString(std::wstring(L"</p:nvPr>"));
std::wstring str2 = L"</p:nvPicPr>";
m_oWriter.WriteString(str2);
}
void PPT::CShapeWriter::WriteGroupInfo()
{
CGroupElement* pGroupElement = dynamic_cast<CGroupElement*>(m_pElement.get());
if (!pGroupElement) return;
m_oWriter.WriteString(std::wstring(L"<p:nvGrpSpPr>"));
if (pGroupElement->m_lID < 0)
pGroupElement->m_lID = m_lNextShapeID;
std::wstring strShapeID = std::to_wstring(pGroupElement->m_lID);
m_oWriter.WriteString(std::wstring(L"<p:cNvPr id=\"") + strShapeID + L"\"");
if (pGroupElement->m_sName.empty()) pGroupElement->m_sName = std::wstring(L"Group ") + strShapeID;
if (pGroupElement->m_bHidden) m_oWriter.WriteString(std::wstring(L" hidden=\"1\""));
m_oWriter.WriteString(std::wstring(L" name=\""));
m_oWriter.WriteStringXML(pGroupElement->m_sName);
m_oWriter.WriteString(std::wstring(L"\""));
if (!pGroupElement->m_sDescription.empty())
{
m_oWriter.WriteString(std::wstring(L" descr=\""));
m_oWriter.WriteStringXML(XmlUtils::EncodeXmlStringExtend(pGroupElement->m_sDescription));
m_oWriter.WriteString(std::wstring(L"\""));
}
m_oWriter.WriteString(std::wstring(L">"));
if (!pGroupElement->m_sHyperlink.empty())
{
std::wstring rId = m_pRels->WriteHyperlink(pGroupElement->m_sHyperlink);
if (false == rId.empty())
{
m_oWriter.WriteString(std::wstring(L"<a:hlinkClick"));
m_oWriter.WriteString(std::wstring(L" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\""));
m_oWriter.WriteString(std::wstring(L" r:id=\"" + rId));
m_oWriter.WriteString(std::wstring(L"\"></a:hlinkClick>"));
}
}
m_oWriter.WriteString(std::wstring(L"</p:cNvPr>"));
m_oWriter.WriteString(std::wstring(L"<p:cNvGrpSpPr><a:grpSpLocks/></p:cNvGrpSpPr>"));
++m_lNextShapeID;
m_oWriter.WriteString(std::wstring(L"<p:nvPr/>"));
std::wstring str2 = L"</p:nvGrpSpPr>";
m_oWriter.WriteString(str2);
}
void PPT::CShapeWriter::WriteOleObjectInfo(const std::wstring& strRid, const std::wstring& xfrm)
{
COleObjectElement* pOleObjectElement = dynamic_cast<COleObjectElement*>(m_pElement.get());
if (!pOleObjectElement) return;
m_oWriter.WriteString(std::wstring(L"<p:graphicFrame>"));
m_oWriter.WriteString(std::wstring(L"<p:nvGraphicFramePr>"));
if (pOleObjectElement->m_lID < 0)
pOleObjectElement->m_lID = m_lNextShapeID;
std::wstring strTableID = std::to_wstring(pOleObjectElement->m_lID);
m_oWriter.WriteString(std::wstring(L"<p:cNvPr id=\"") + strTableID + L"\"");
if (pOleObjectElement->m_sName.empty()) pOleObjectElement->m_sName = std::wstring(L"Group ") + strTableID;
if (pOleObjectElement->m_bHidden) m_oWriter.WriteString(std::wstring(L" hidden=\"1\""));
m_oWriter.WriteString(std::wstring(L" name=\""));
m_oWriter.WriteStringXML(pOleObjectElement->m_sName);
m_oWriter.WriteString(std::wstring(L"\""));
if (!pOleObjectElement->m_sDescription.empty())
{
m_oWriter.WriteString(std::wstring(L" descr=\""));
m_oWriter.WriteStringXML(XmlUtils::EncodeXmlStringExtend(pOleObjectElement->m_sDescription));
m_oWriter.WriteString(std::wstring(L"\""));
}
m_oWriter.WriteString(std::wstring(L">"));
if (!pOleObjectElement->m_sHyperlink.empty())
{
std::wstring rId = m_pRels->WriteHyperlink(pOleObjectElement->m_sHyperlink);
if (false == rId.empty())
{
m_oWriter.WriteString(std::wstring(L"<a:hlinkClick"));
m_oWriter.WriteString(std::wstring(L" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\""));
m_oWriter.WriteString(std::wstring(L" r:id=\"" + rId));
m_oWriter.WriteString(std::wstring(L"\"></a:hlinkClick>"));
}
}
m_oWriter.WriteString(std::wstring(L"</p:cNvPr>"));
m_oWriter.WriteString(std::wstring(L"<p:cNvGraphicFramePr><a:graphicFrameLocks noChangeAspect=\"1\"/></p:cNvGraphicFramePr>"));
++m_lNextShapeID;
m_oWriter.WriteString(std::wstring(L"<p:nvPr/>"));
m_oWriter.WriteString(std::wstring(L"</p:nvGraphicFramePr>"));
if (pOleObjectElement->m_bChildAnchorEnabled || pOleObjectElement->m_bAnchorEnabled)
{
m_oWriter.WriteString(std::wstring(L"<p:xfrm") + xfrm + std::wstring(L"</p:xfrm>"));
}
m_oWriter.WriteString(std::wstring(L"<a:graphic>"));
m_oWriter.WriteString(std::wstring(L"<a:graphicData uri=\"http://schemas.openxmlformats.org/presentationml/2006/ole\">"));
m_oWriter.WriteString(std::wstring(L"<p:oleObj"));
if (false == pOleObjectElement->m_strOleName.empty())
{
m_oWriter.WriteString(std::wstring(L" name=\"") + pOleObjectElement->m_strOleName + L"\"");
}
m_oWriter.WriteString(std::wstring(L" r:id=\"") + strRid + L"\"");
_INT64 width = (_INT64)(pOleObjectElement->m_bChildAnchorEnabled ? pOleObjectElement->m_rcChildAnchor.GetWidth() : pOleObjectElement->m_rcAnchor.GetWidth()) / 1.78;
_INT64 height = (_INT64)(pOleObjectElement->m_bChildAnchorEnabled ? pOleObjectElement->m_rcChildAnchor.GetHeight() : pOleObjectElement->m_rcAnchor.GetHeight()) / 1.78;
m_oWriter.WriteString(std::wstring(L" imgW=\"") + std::to_wstring(width) + L"\"");
m_oWriter.WriteString(std::wstring(L" imgH=\"") + std::to_wstring(height) + L"\"");
if (false == pOleObjectElement->m_strProgId.empty())
{
m_oWriter.WriteString(std::wstring(L" progId=\"") + pOleObjectElement->m_strProgId + L"\"");
}
m_oWriter.WriteString(std::wstring(L"><p:embed/>"));
}
void PPT::CShapeWriter::WriteTableInfo()
{
CGroupElement* pGroupElement = dynamic_cast<CGroupElement*>(m_pElement.get());
if (!pGroupElement) return;
m_oWriter.WriteString(std::wstring(L"<p:nvGraphicFramePr>"));
if (pGroupElement->m_lID < 0)
pGroupElement->m_lID = m_lNextShapeID;
std::wstring strTableID = std::to_wstring(pGroupElement->m_lID);
m_oWriter.WriteString(std::wstring(L"<p:cNvPr id=\"") + strTableID + L"\"");
if (pGroupElement->m_sName.empty()) pGroupElement->m_sName = std::wstring(L"Group ") + strTableID;
if (pGroupElement->m_bHidden) m_oWriter.WriteString(std::wstring(L" hidden=\"1\""));
m_oWriter.WriteString(std::wstring(L" name=\""));
m_oWriter.WriteStringXML(pGroupElement->m_sName);
m_oWriter.WriteString(std::wstring(L"\""));
if (!pGroupElement->m_sDescription.empty())
{
m_oWriter.WriteString(std::wstring(L" descr=\""));
m_oWriter.WriteStringXML(XmlUtils::EncodeXmlStringExtend(pGroupElement->m_sDescription));
m_oWriter.WriteString(std::wstring(L"\""));
}
m_oWriter.WriteString(std::wstring(L">"));
if (!pGroupElement->m_sHyperlink.empty())
{
std::wstring rId = m_pRels->WriteHyperlink(pGroupElement->m_sHyperlink);
if (false == rId.empty())
{
m_oWriter.WriteString(std::wstring(L"<a:hlinkClick"));
m_oWriter.WriteString(std::wstring(L" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\""));
m_oWriter.WriteString(std::wstring(L" r:id=\"" + rId));
m_oWriter.WriteString(std::wstring(L"\"></a:hlinkClick>"));
}
}
m_oWriter.WriteString(std::wstring(L"</p:cNvPr>"));
m_oWriter.WriteString(std::wstring(L"<p:cNvGraphicFramePr><a:graphicFrameLocks noGrp=\"1\"/></p:cNvGraphicFramePr>"));
++m_lNextShapeID;
m_oWriter.WriteString(std::wstring(L"<p:nvPr/>"));
std::wstring str2 = L"</p:nvGraphicFramePr>";
m_oWriter.WriteString(str2);
}
void PPT::CShapeWriter::WriteShapeInfo()
{
CShapeElement* pShapeElement = dynamic_cast<CShapeElement*>(m_pElement.get());
if (!pShapeElement) return;
m_oWriter.WriteString(std::wstring(L"<p:nvSpPr>"));
if (pShapeElement->m_lID < 0)
pShapeElement->m_lID = m_lNextShapeID;
std::wstring strShapeID = std::to_wstring(pShapeElement->m_lID);
m_oWriter.WriteString(std::wstring(L"<p:cNvPr id=\"") + strShapeID + L"\"");
if (pShapeElement->m_sName.empty()) pShapeElement->m_sName = std::wstring(L"Shape ") + strShapeID;
if (pShapeElement->m_bHidden) m_oWriter.WriteString(std::wstring(L" hidden=\"1\""));
m_oWriter.WriteString(std::wstring(L" name=\""));
m_oWriter.WriteStringXML(pShapeElement->m_sName);
m_oWriter.WriteString(std::wstring(L"\""));
if (!pShapeElement->m_sDescription.empty())
{
m_oWriter.WriteString(std::wstring(L" descr=\""));
m_oWriter.WriteStringXML(XmlUtils::EncodeXmlStringExtend(pShapeElement->m_sDescription, true));
m_oWriter.WriteString(std::wstring(L"\""));
}
m_oWriter.WriteString(std::wstring(L">"));
WriteHyperlink(m_pElement->m_arrActions);
if (!pShapeElement->m_sHyperlink.empty())
{
std::wstring rId = m_pRels->WriteHyperlink(pShapeElement->m_sHyperlink);
if (false == rId.empty())
{
m_oWriter.WriteString(std::wstring(L"<a:hlinkClick"));
m_oWriter.WriteString(std::wstring(L" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\""));
m_oWriter.WriteString(std::wstring(L" r:id=\"" + rId));
m_oWriter.WriteString(std::wstring(L"\"></a:hlinkClick>"));
}
}
m_oWriter.WriteString(std::wstring(L"</p:cNvPr>"));
m_oWriter.WriteString(std::wstring(L"<p:cNvSpPr"));
if (m_bTextBox)
m_oWriter.WriteString(std::wstring(L" txBox=\"1\""));
m_oWriter.WriteString(std::wstring(L"><a:spLocks"));
if (false == m_pElement->m_bChildAnchorEnabled)
{
m_oWriter.WriteString(std::wstring(L" noGrp=\"1\""));
}
m_oWriter.WriteString(std::wstring(L" noChangeShapeType=\"1\"/>"));
m_oWriter.WriteString(std::wstring(L"</p:cNvSpPr>"));
++m_lNextShapeID;
if (-1 != pShapeElement->m_lPlaceholderType)
{
m_oWriter.WriteString(std::wstring(L"<p:nvPr><p:ph"));
if (pShapeElement->m_lPlaceholderType > 0 && pShapeElement->m_lPlaceholderType != PT_Body_Empty)
m_oWriter.WriteString(std::wstring(L" type=\"") + GetPhType(pShapeElement->m_lPlaceholderType) + L"\"");
else if (pShapeElement->m_lPlaceholderID == -1)
m_oWriter.WriteString(std::wstring(L" type=\"obj\""));
if ( pShapeElement->m_lPlaceholderID != -1)
{
std::wstring strIdx = std::to_wstring( pShapeElement->m_lPlaceholderID );
m_oWriter.WriteString(std::wstring(L" idx=\"") + strIdx + L"\"");
}
if (pShapeElement->m_lPlaceholderSizePreset > 1 && !isTitlePlaceholder(pShapeElement->m_lPlaceholderType))
{
if (pShapeElement->m_lPlaceholderSizePreset == 1)
m_oWriter.WriteString(std::wstring(L" size=\"half\""));
else if (pShapeElement->m_lPlaceholderSizePreset == 2)
m_oWriter.WriteString(std::wstring(L" size=\"quarter\""));
else if (pShapeElement->m_lPlaceholderSizePreset == 3)
{
if (isBodyPlaceholder(pShapeElement->m_lPlaceholderType))
m_oWriter.WriteString(std::wstring(L" size=\"half\""));
else
m_oWriter.WriteString(std::wstring(L" size=\"quarter\""));
}
}
m_oWriter.WriteString(std::wstring(L"/></p:nvPr>"));
}
else
{
m_oWriter.WriteString(std::wstring(L"<p:nvPr/>"));
}
std::wstring str2 = L"</p:nvSpPr>";
m_oWriter.WriteString(str2);
}
void PPT::CShapeWriter::Write3dShape()
{
CShapeElement* pShapeElement = dynamic_cast<CShapeElement*>(m_pElement.get());
if (!pShapeElement) return;
CPPTShape *pPPTShape = dynamic_cast<CPPTShape *>(pShapeElement->m_pShape->getBaseShape().get());
if (!pPPTShape) return;
if (!pPPTShape->m_3dOptions.bEnabled) return;
//{
// std::cout << "........................................................................\n";
// std::wcout << pShapeElement->m_sName << L"\n";
// if (pPPTShape->m_3dOptions.dSpecularAmt)
// {
// std::cout << "SpecularAmt\t" << (*pPPTShape->m_3dOptions.dSpecularAmt) << "\n";
// }
// if (pPPTShape->m_3dOptions.dDiffuseAmt)
// {
// std::cout << "iffuseAmt\t" << (*pPPTShape->m_3dOptions.dDiffuseAmt) << "\n";
// }
// if (pPPTShape->m_3dOptions.dShininess)
// {
// std::cout << "Shininess\t" << (*pPPTShape->m_3dOptions.dShininess) << "\n";
// }
// if (pPPTShape->m_3dOptions.dXRotationAngle)
// {
// std::cout << "XRotationAngle\t" << (*pPPTShape->m_3dOptions.dXRotationAngle) << "\n";
// }
// if (pPPTShape->m_3dOptions.dYRotationAngle)
// {
// std::cout << "YRotationAngle\t" << (*pPPTShape->m_3dOptions.dYRotationAngle) << "\n";
// }
// if (pPPTShape->m_3dOptions.dRotationAxisX)
// {
// std::cout << "RotationAxisX\t" << (*pPPTShape->m_3dOptions.dRotationAxisX) << "\n";
// }
// if (pPPTShape->m_3dOptions.dRotationAxisY)
// {
// std::cout << "RotationAxisY\t" << (*pPPTShape->m_3dOptions.dRotationAxisY) << "\n";
// }
// if (pPPTShape->m_3dOptions.dRotationAxisZ)
// {
// std::cout << "RotationAxisZ\t" << (*pPPTShape->m_3dOptions.dRotationAxisZ) << "\n";
// }
// if (pPPTShape->m_3dOptions.dRotationAngle)
// {
// std::cout << "RotationAngle\t" << (*pPPTShape->m_3dOptions.dRotationAngle) << "\n";
// }
// if (pPPTShape->m_3dOptions.dRotationCenterX)
// {
// std::cout << "RotationCenterX\t" << (*pPPTShape->m_3dOptions.dRotationCenterX) << "\n";
// }
// if (pPPTShape->m_3dOptions.dRotationCenterY)
// {
// std::cout << "RotationCenterY\t" << (*pPPTShape->m_3dOptions.dRotationCenterY) << "\n";
// }
// if (pPPTShape->m_3dOptions.dRotationCenterZ)
// {
// std::cout << "RotationCenterZ\t" << (*pPPTShape->m_3dOptions.dRotationCenterZ) << "\n";
// }
// if (pPPTShape->m_3dOptions.dTolerance)
// {
// std::cout << "Tolerance\t" << (*pPPTShape->m_3dOptions.dTolerance) << "\n";
// }
// std::cout << "XViewpoint\t" << (pPPTShape->m_3dOptions.dXViewpoint) << "\n";
// std::cout << "YViewpoint\t" << (pPPTShape->m_3dOptions.dYViewpoint) << "\n";
// if (pPPTShape->m_3dOptions.dZViewpoint)
// {
// std::cout << "ZViewpoint\t" << (*pPPTShape->m_3dOptions.dZViewpoint) << "\n";
// }
// std::cout << "OriginX\t" << (pPPTShape->m_3dOptions.dOriginX) << "\n";
// std::cout << "OriginY\t" << (pPPTShape->m_3dOptions.dOriginY) << "\n";
// std::cout << "SkewAngle\t" << (pPPTShape->m_3dOptions.dSkewAngle) << "\n";
// std::cout << "SkewAmount\t" << (pPPTShape->m_3dOptions.nSkewAmount) << "\n";
// if (pPPTShape->m_3dOptions.dAmbientIntensity)
// {
// std::cout << "AmbientIntensity\t" << (*pPPTShape->m_3dOptions.dAmbientIntensity) << "\n";
// }
// if (pPPTShape->m_3dOptions.dKeyIntensity)
// {
// std::cout << "KeyIntensity\t" << (*pPPTShape->m_3dOptions.dKeyIntensity) << "\n";
// }
// std::cout << "KeyX\t" << (pPPTShape->m_3dOptions.dKeyX) << "\n";
// std::cout << "KeyY\t" << (pPPTShape->m_3dOptions.dKeyY) << "\n";
// if (pPPTShape->m_3dOptions.dKeyZ)
// {
// std::cout << "KeyZ\t" << (*pPPTShape->m_3dOptions.dKeyZ) << "\n";
// }
// std::cout << "FillIntensity\t" << (pPPTShape->m_3dOptions.dFillIntensity) << "\n";
// std::cout << "FillX\t" << (pPPTShape->m_3dOptions.dFillX) << "\n";
// std::cout << "FillY\t" << (pPPTShape->m_3dOptions.dFillY) << "\n";
// if (pPPTShape->m_3dOptions.dFillZ)
// {
// std::cout << "FillZ\t" << (*pPPTShape->m_3dOptions.dFillZ) << "\n";
// }
// std::cout << "........................................................................\n";
//}
m_oWriter.WriteString(std::wstring(L"<a:scene3d>"));
m_oWriter.WriteString(std::wstring(L"<a:camera"));
std::wstring sAngle;
if (pPPTShape->m_3dOptions.dSkewAngle < 10) sAngle = L"Left";
else if (pPPTShape->m_3dOptions.dSkewAngle >= 10 && pPPTShape->m_3dOptions.dSkewAngle < 80) sAngle = L"BottomLeft";
else if (pPPTShape->m_3dOptions.dSkewAngle >= 80 && pPPTShape->m_3dOptions.dSkewAngle < 100) sAngle = L"Bottom";
else if (pPPTShape->m_3dOptions.dSkewAngle >= 100 && pPPTShape->m_3dOptions.dSkewAngle < 145) sAngle = L"BottomRight";
else if (pPPTShape->m_3dOptions.dSkewAngle >= 145 && pPPTShape->m_3dOptions.dSkewAngle < 190) sAngle = L"Right";
else if (pPPTShape->m_3dOptions.dSkewAngle >= 190 && pPPTShape->m_3dOptions.dSkewAngle < 235) sAngle = L"TopRight";
else if (pPPTShape->m_3dOptions.dSkewAngle >= 235 && pPPTShape->m_3dOptions.dSkewAngle < 280) sAngle = L"Top";
else if (pPPTShape->m_3dOptions.dSkewAngle >= 280 && pPPTShape->m_3dOptions.dSkewAngle < 325) sAngle = L"TopLeft";
else sAngle = L"Front";
if (pPPTShape->m_3dOptions.bParallel)
m_oWriter.WriteString(std::wstring(L" prst=\"legacyOblique" + sAngle + L"\""));
else
m_oWriter.WriteString(std::wstring(L" prst=\"legacyPerspective" + sAngle + L"\""));
m_oWriter.WriteString(std::wstring(L">"));
if (pPPTShape->m_3dOptions.bConstrainRotation)
{
m_oWriter.WriteString(std::wstring(L"<a:rot"));
m_oWriter.WriteString(std::wstring(L" lat=\"" + std::to_wstring((int)(60000 * pPPTShape->m_3dOptions.dXRotationAngle.get_value_or(0))) + L"\""));
m_oWriter.WriteString(std::wstring(L" lon=\"" + std::to_wstring((int)(60000 * pPPTShape->m_3dOptions.dYRotationAngle.get_value_or(0))) + L"\""));
m_oWriter.WriteString(std::wstring(L" rev=\"" + std::to_wstring((int)(60000 * pPPTShape->m_3dOptions.dRotationAngle.get_value_or(0))) + L"\""));
m_oWriter.WriteString(std::wstring(L"/>"));
}
m_oWriter.WriteString(std::wstring(L"</a:camera>"));
m_oWriter.WriteString(std::wstring(L"<a:lightRig"));
if (pPPTShape->m_3dOptions.dFillIntensity < 0.3)
m_oWriter.WriteString(std::wstring(L" rig=\"legacyHarsh3\""));
else if (pPPTShape->m_3dOptions.dFillIntensity < 0.4)
m_oWriter.WriteString(std::wstring(L" rig=\"legacyFlat4\""));
else if (pPPTShape->m_3dOptions.dFillIntensity > 0.6 ||
(pPPTShape->m_3dOptions.dKeyX < 0.1 && pPPTShape->m_3dOptions.dFillX < 0.1 &&
pPPTShape->m_3dOptions.dKeyY < 0.1 && pPPTShape->m_3dOptions.dFillY < 0.1))
m_oWriter.WriteString(std::wstring(L" rig=\"legacyFlat1\""));
else
m_oWriter.WriteString(std::wstring(L" rig=\"legacyFlat3\""));
if (pPPTShape->m_3dOptions.dKeyX < 0.1 && pPPTShape->m_3dOptions.dFillX < 0.1)
{
if (pPPTShape->m_3dOptions.dKeyY < 0.1 && pPPTShape->m_3dOptions.dFillY < 0.1)
m_oWriter.WriteString(std::wstring(L" dir=\"t\""));
else if (pPPTShape->m_3dOptions.dKeyY < 0) m_oWriter.WriteString(std::wstring(L" dir=\"r\""));
else m_oWriter.WriteString(std::wstring(L" dir=\"l\""));
}
else
{
if (pPPTShape->m_3dOptions.dKeyX < 0) m_oWriter.WriteString(std::wstring(L" dir=\"t\""));
else m_oWriter.WriteString(std::wstring(L" dir=\"b\""));
}
m_oWriter.WriteString(std::wstring(L"/>"));
m_oWriter.WriteString(std::wstring(L"</a:scene3d>"));
m_oWriter.WriteString(std::wstring(L"<a:sp3d"));
m_oWriter.WriteString(std::wstring(L" extrusionH=\"" + std::to_wstring(pPPTShape->m_3dOptions.nExtrudeBackward) + L"\""));
switch(pPPTShape->m_3dOptions.nRenderMode)
{
case 0x00000000://solid
{
if (pPPTShape->m_3dOptions.bMetallic)
m_oWriter.WriteString(std::wstring(L" prstMaterial=\"legacyMetal\""));
else
m_oWriter.WriteString(std::wstring(L" prstMaterial=\"legacyMatte\""));
}break;
case 0x00000001: m_oWriter.WriteString(std::wstring(L" prstMaterial=\"legacyWireframe\"")); break; //wireframe
case 0x00000002: m_oWriter.WriteString(std::wstring(L" prstMaterial=\"legacyWireframe\"")); break; //bounding cube ????
}
m_oWriter.WriteString(std::wstring(L">"));
m_oWriter.WriteString(std::wstring(L"<a:bevelT w=\"13500\" h=\"13500\" prst=\"angle\"/>"));
m_oWriter.WriteString(std::wstring(L"<a:bevelB w=\"13500\" h=\"13500\" prst=\"angle\"/>"));
std::wstring strExtrusionClr;
if (pPPTShape->m_3dOptions.oExtrusionColor)
{
strExtrusionClr = ConvertColor(*pPPTShape->m_3dOptions.oExtrusionColor);
}
else
{
if (pShapeElement->m_oBrush.Type != c_BrushTypeNoFill)
{
strExtrusionClr = ConvertColor(pShapeElement->m_oBrush.Color1, pShapeElement->m_oBrush.Alpha1);
}
else
{
strExtrusionClr = ConvertColor(pShapeElement->m_oPen.Color, pShapeElement->m_oPen.Alpha);
}
}
m_oWriter.WriteString(std::wstring(L"<a:extrusionClr>"));
m_oWriter.WriteString(strExtrusionClr);
m_oWriter.WriteString(std::wstring(L"</a:extrusionClr>"));
m_oWriter.WriteString(std::wstring(L"<a:contourClr>"));
m_oWriter.WriteString(strExtrusionClr);
m_oWriter.WriteString(std::wstring(L"</a:contourClr>"));
m_oWriter.WriteString(std::wstring(L"</a:sp3d>"));
}
void PPT::CShapeWriter::WriteTextInfo(PPT::CTextCFRun* pLastCF)
{
CShapeElement* pShapeElement = dynamic_cast<CShapeElement*>(m_pElement.get());
if (!pShapeElement) return;
CDoubleRect oTextRect;
size_t nCount = pShapeElement->m_pShape->m_oText.m_arParagraphs.size();
m_oWriter.WriteString(std::wstring(L"<p:txBody>"));
m_oWriter.WriteString(std::wstring(L"<a:bodyPr" ));
pShapeElement->m_pShape->GetTextRect(oTextRect);
std::wstring str;
if (pShapeElement->m_pShape->m_oText.m_lWrapMode == 2)
str = L" wrap=\"none\"";
else
str = L" lIns=\"" + std::to_wstring((int)oTextRect.left) + L"\" tIns=\"" + std::to_wstring((int)oTextRect.top) +
L"\" rIns=\"" + std::to_wstring((int)oTextRect.right) + L"\" bIns=\"" + std::to_wstring((int)oTextRect.bottom) + L"\"";
m_oWriter.WriteString(str);
// m_oWriter.WriteString(std::wstring(L" lIns=\"0\" tIns=\"0\" rIns=\"0\" bIns=\"0\""));
if (pShapeElement->m_pShape->m_oText.m_oAttributes.m_nTextAlignVertical == 0 )
m_oWriter.WriteString(L" anchor=\"t\"");
else if (pShapeElement->m_pShape->m_oText.m_oAttributes.m_nTextAlignVertical == 2 )
m_oWriter.WriteString(L" anchor=\"b\"");
else if (pShapeElement->m_pShape->m_oText.m_oAttributes.m_nTextAlignVertical == 1 )
{
m_oWriter.WriteString(L" anchor=\"ctr\"");
m_oWriter.WriteString(L" anchorCtr=\"0\"");
}
if (pShapeElement->m_pShape->m_oText.m_oAttributes.m_dTextRotate > 0)
{
std::wstring strProp = std::to_wstring((int)(pShapeElement->m_pShape->m_oText.m_oAttributes.m_dTextRotate * 60000));
m_oWriter.WriteString(L" rot=\"" + strProp + L"\"");
}
if (pShapeElement->m_pShape->m_oText.m_nTextFlow >= 0)
{
switch(pShapeElement->m_pShape->m_oText.m_nTextFlow)
{
case 1:
case 3: m_oWriter.WriteString(L" vert=\"vert\""); break;
case 2: m_oWriter.WriteString(L" vert=\"vert270\""); break;
case 5: m_oWriter.WriteString(L" vert=\"wordArtVert\""); break;
}
}
else if (pShapeElement->m_pShape->m_oText.m_bVertical)
{
m_oWriter.WriteString(L" vert=\"eaVert\"");
}
m_oWriter.WriteString(L">");
if (m_bWordArt)
{
std::wstring prstTxWarp = oox::Spt2WordArtShapeType((oox::MSOSPT)pShapeElement->m_lShapeType);
m_oWriter.WriteString(std::wstring(L"<a:prstTxWarp"));
m_oWriter.WriteString(std::wstring(L" prst=\"") + prstTxWarp + L"\">");
m_oWriter.WriteString(std::wstring(L"<a:avLst>"));//модификаторы
CPPTShape *pPPTShape = dynamic_cast<CPPTShape *>(pShapeElement->m_pShape->getBaseShape().get());
std::wstring strVal;
for (size_t i = 0 ; (pPPTShape) && (i < pPPTShape->m_arAdjustments.size()); i++)
{
switch(pShapeElement->m_lShapeType)
{
case oox::msosptTextFadeUp:
{
double kf = 4.63; //"волшебный"
std::wstring strVal = std::to_wstring((int)(kf * pPPTShape->m_arAdjustments[i]));
m_oWriter.WriteString(L"<a:gd name=\"adj\" fmla=\"val ");
m_oWriter.WriteString(strVal + L"\"/>");
}break;
}
}
m_oWriter.WriteString(L"</a:avLst>");
m_oWriter.WriteString(L"</a:prstTxWarp>");
}
if (pShapeElement->m_pShape->m_oText.m_bAutoFit)
{
m_oWriter.WriteString(L"<a:spAutoFit/>");
}
m_oWriter.WriteString(L"</a:bodyPr>");
if (0 == nCount)
{
if (pLastCF && pLastCF->Size.is_init())
{
int sz = pLastCF->Size.get() * 100;
m_oWriter.WriteString(L"<a:lstStyle/><a:p><a:endParaRPr sz=\"" + std::to_wstring(sz) + L"\" dirty=\"0\"/></a:p></p:txBody>");
} else
{
m_oWriter.WriteString(L"<a:lstStyle/><a:p><a:endParaRPr sz=\"1400\" dirty=\"0\"/></a:p></p:txBody>");
}
return;
}
m_oWriter.WriteString(L"<a:lstStyle>");
if (!m_bWordArt)
{
CStylesWriter styleWriter(m_pTheme);
styleWriter.ConvertStyles(pShapeElement->m_pShape->m_oText.m_oStyles, m_oWriter);
}
m_oWriter.WriteString(std::wstring(L"</a:lstStyle>"));
for (size_t nIndexPar = 0; nIndexPar < nCount; ++nIndexPar)
{
PPT::CParagraph* pParagraph = &pShapeElement->m_pShape->m_oText.m_arParagraphs[nIndexPar];
//if (m_bWordArt && nIndexPar == nCount-1)
//{
// if (pParagraph->m_arSpans.size() < 1) break;
// if (pParagraph->m_arSpans.size() == 1 && pParagraph->m_arSpans[0].m_strText.empty()) break;
//}
m_oWriter.WriteString(L"<a:p>");
// <a:pPr>
auto pPPr = new PPTX::Logic::TextParagraphPr;
BulletsConverter buConverter(m_pRels);
buConverter.FillPPr(*pPPr, *pParagraph);
m_oWriter.WriteString(pPPr->toXML());
delete pPPr;
std::wstring typeRun = L"a:r";
size_t nCountSpans = pParagraph->m_arSpans.size();
for (size_t nSpan = 0; nSpan < nCountSpans; ++nSpan)
{
if (true)
{
if ((nSpan == (nCountSpans - 1)) && (L"\n" == pParagraph->m_arSpans[nSpan].m_strText || pParagraph->m_arSpans[nSpan].m_strText.empty()))
{
PPT::CTextCFRun* pCF = &pParagraph->m_arSpans[nSpan].m_oRun;
if ((pCF->Size.is_init()) && (pCF->Size.get() > 0) && (pCF->Size.get() < 4001))
{
m_oWriter.WriteString(L"<a:endParaRPr lang=\"en-US\" sz=\"" + std::to_wstring((int)(100 * pCF->Size.get())) + L"\"/>");
}
else
{
m_oWriter.WriteString(std::wstring(L"<a:endParaRPr lang=\"en-US\"/>"));
}
continue;
}
}
PPT::CTextCFRun* pCF = &pParagraph->m_arSpans[nSpan].m_oRun;
pLastCF = pCF;
int span_sz = pParagraph->m_arSpans[nSpan].m_strText.length() ;
if ((span_sz==1 && ( pParagraph->m_arSpans[nSpan].m_strText[0] == (wchar_t)13 )) ||
((span_sz==2 && ( pParagraph->m_arSpans[nSpan].m_strText[0] == (wchar_t)13 ) && ( pParagraph->m_arSpans[nSpan].m_strText[1] == (wchar_t)13 ))))
{
continue;
}
if (pParagraph->m_arSpans[nSpan].m_strText.empty() && !pParagraph->m_arSpans[nSpan].m_bBreak) continue;
if (pParagraph->m_arSpans[nSpan].m_bBreak)
{
m_oWriter.WriteString(std::wstring(L"<a:br><a:rPr"));
}
else
{
if (pShapeElement->m_lPlaceholderType == PT_MasterSlideNumber/* && pParagraph->m_arSpans[nSpan].m_bField*/)
{
m_oWriter.WriteString(std::wstring(L"<a:fld id=\"{D038279B-FC19-497E-A7D1-5ADD9CAF016F}\" type=\"slidenum\"><a:rPr"));
}
else if (pShapeElement->m_lPlaceholderType == PT_MasterDate && pShapeElement->m_nFormatDate == 1/* && pParagraph->m_arSpans[nSpan].m_bField*/)
{
m_oWriter.WriteString(std::wstring(L"<a:fld id=\"{D7E01130-044F-4930-9A27-C729C70D8524}\" type=\"datetime1\"><a:rPr"));
}
else
{
m_oWriter.WriteString(std::wstring(L"<a:r><a:rPr"));
}
}
if (pCF->Language.is_init())
{
std::wstring str_lang = m_lcidConverter.get_wstring(pCF->Language.get());
if (str_lang.length() > 0)
m_oWriter.WriteString(std::wstring(L" lang=\"") + str_lang + L"\"");
}
if ((pCF->Size.is_init()) && (pCF->Size.get() > 0) && (pCF->Size.get() < 4001))
{
m_oWriter.WriteString(L" sz=\"" + std::to_wstring((int)(100 * pCF->Size.get())) + L"\"");
}
if (pCF->FontBold.is_init())
{
if (pCF->FontBold.get())
m_oWriter.WriteString(std::wstring(L" b=\"1\""));
else
m_oWriter.WriteString(std::wstring(L" b=\"0\""));
}
if (pCF->FontItalic.is_init())
{
if (pCF->FontItalic.get())
m_oWriter.WriteString(std::wstring(L" i=\"1\""));
else
m_oWriter.WriteString(std::wstring(L" i=\"0\""));
}
if (pCF->BaseLineOffset.is_init())
{
m_oWriter.WriteString(L" baseline=\"" + std::to_wstring((int)(1000 * pCF->BaseLineOffset.get())) + L"\"");
}
if (pCF->FontUnderline.is_init())
{
if (pCF->FontUnderline.get())
m_oWriter.WriteString(std::wstring(L" u=\"sng\""));
else
m_oWriter.WriteString(std::wstring(L" u=\"none\""));
}
m_oWriter.WriteString(std::wstring(L">"));
if (m_bWordArt)
{//порядок важен - линия, заливка, тень !!!
if (pShapeElement->m_bLine)
{
m_oWriter.WriteString(ConvertLine(pShapeElement->m_oPen));
}
m_oWriter.WriteString(ConvertBrush(pShapeElement->m_oBrush));
m_oWriter.WriteString(ConvertShadow(pShapeElement->m_oShadow));
}
else
{
if (pCF->Color.is_init())
{
if (pCF->Color->m_lSchemeIndex != -1)
{
std::wstring strProp = L"<a:solidFill><a:schemeClr val=\"" + CStylesWriter::GetColorInScheme(pCF->Color->m_lSchemeIndex) + L"\"/></a:solidFill>";
m_oWriter.WriteString(strProp);
}
else
{
std::wstring strColor = XmlUtils::ToString(pCF->Color->GetLONG_RGB(), L"%06X");
m_oWriter.WriteString(L"<a:solidFill><a:srgbClr val=\"" + strColor + L"\"/></a:solidFill>");
}
}
}
if (pCF->font.font.is_init())
{
m_oWriter.WriteString(L"<a:latin");
m_oWriter.WriteString(pCF->font.font->getXmlArgsStr());
m_oWriter.WriteString(L"/>");
}
else if (pCF->fontRef.is_init())
{
if ((m_pTheme) && (pCF->fontRef.get() < m_pTheme->m_arFonts.size()))
{
m_oWriter.WriteString(L"<a:latin typeface=\"" + m_pTheme->m_arFonts[pCF->fontRef.get()].Name + L"\"/>");
}
else
{
if (0 == pCF->fontRef.get())
{
m_oWriter.WriteString(L"<a:latin typeface=\"+mj-lt\"/>");
}
else
{
m_oWriter.WriteString(L"<a:latin typeface=\"+mn-lt\"/>");
}
}
}
if (pCF->font.ea.is_init())
{
m_oWriter.WriteString(L"<a:ea");
m_oWriter.WriteString(pCF->font.ea->getXmlArgsStr());
m_oWriter.WriteString(L"/>");
}
if (pCF->font.sym.is_init())
{
m_oWriter.WriteString(L"<a:sym");
m_oWriter.WriteString(pCF->font.sym->getXmlArgsStr());
m_oWriter.WriteString(L"/>");
}
// WriteHyperlink(nIndexPar);
WriteHyperlink(pParagraph->m_arSpans[nSpan].m_arrInteractive);
if (pCF->FontShadow.get_value_or(false))
{
m_oWriter.WriteString(L"<a:effectLst><a:outerShdw blurRad=\"38100\" dist=\"38100\" dir=\"2700000\" algn=\"tl\"><a:srgbClr val=\"000000\"><a:alpha val=\"43137\"/></a:srgbClr></a:outerShdw></a:effectLst>");
}
m_oWriter.WriteString(std::wstring(L"</a:rPr>"));
if (pParagraph->m_arSpans[nSpan].m_bBreak)
{
m_oWriter.WriteString(std::wstring(L"</a:br>"));
}
else
{
std::wstring strT1 = L"<a:t>";
m_oWriter.WriteString(strT1);
std::wstring strT = pParagraph->m_arSpans[nSpan].m_strText;
CorrectXmlString(strT);
m_oWriter.WriteString(strT);
std::wstring strT2 = L"</a:t>";
m_oWriter.WriteString(strT2);
if ((pShapeElement->m_lPlaceholderType == PT_MasterSlideNumber ||
(pShapeElement->m_lPlaceholderType == PT_MasterDate && pShapeElement->m_nFormatDate == 1))/* && pParagraph->m_arSpans[nSpan].m_bField*/)
{
m_oWriter.WriteString(std::wstring(L"</a:fld>"));
}
else
m_oWriter.WriteString(std::wstring(L"</a:r>"));
}
}
std::wstring strEndPar = L"</a:p>";
m_oWriter.WriteString(strEndPar);
}
std::wstring str5 = L"</p:txBody>";
m_oWriter.WriteString(str5);
}
std::wstring CShapeWriter::WriteBullets(CTextPFRun *pPF, CRelsGenerator* pRels)
{
CStringWriter buWrt;
if (pPF->hasBullet.is_init())
{
if (pPF->hasBullet.get())
{
if (pPF->bulletColor.is_init())
{
buWrt.WriteString(std::wstring(L"<a:buClr>"));
buWrt.WriteString(ConvertColor(pPF->bulletColor.get(), 255));
buWrt.WriteString(std::wstring(L"</a:buClr>"));
}
if (pPF->bulletSize.is_init())
{
if (pPF->bulletSize.get() > 24 && pPF->bulletSize.get() < 401)
{
std::wstring strProp = std::to_wstring(pPF->bulletSize.get() * 1000 );
buWrt.WriteString(L"<a:buSzPct val=\"" + strProp + L"\"/>");
}
if (pPF->bulletSize.get() < 0 && pPF->bulletSize.get() > -4001)
{
std::wstring strProp = std::to_wstring(- pPF->bulletSize.get() );
buWrt.WriteString(L"<a:buSzPts val=\"" + strProp + L"\"/>");
}
}
if (pPF->bulletFontProperties.is_init())
{
buWrt.WriteString(std::wstring(L"<a:buFont typeface=\"") + pPF->bulletFontProperties->Name + L"\"");
if ( pPF->bulletFontProperties->PitchFamily > 0)
{
buWrt.WriteString(std::wstring(L" pitchFamily=\"") + std::to_wstring((char)pPF->bulletFontProperties->PitchFamily) + L"\"");
}
if ( pPF->bulletFontProperties->Charset > 0)
{
buWrt.WriteString(std::wstring(L" charset=\"") + std::to_wstring((char)pPF->bulletFontProperties->Charset) + L"\"");
}
buWrt.WriteString(std::wstring(L"/>"));
}
// Bullets (numbering, else picture, else char, else default)
if (pPF->bulletBlip.is_init() && pPF->bulletBlip->tmpImagePath.size() && pRels != nullptr)
{
auto strRID = pRels->WriteImage(pPF->bulletBlip->tmpImagePath);
if (strRID.empty())
buWrt.WriteString(std::wstring(L"<a:buChar char=\"\x2022\"/>")); // error
else
{
buWrt.WriteString(L"<a:buBlip><a:blip r:embed=\"");
buWrt.WriteString(strRID);
buWrt.WriteString(L"\"/></a:buBlip>");
}
}
else if (pPF->bulletChar.is_init() && (pPF->bulletAutoNum.is_init() ? pPF->bulletAutoNum->isDefault() : true))
{
wchar_t bu = pPF->bulletChar.get();
buWrt.WriteString(std::wstring(L"<a:buChar char=\""));
buWrt.WriteStringXML(std::wstring(&bu, 1));
buWrt.WriteString(std::wstring(L"\"/>"));
}
else if (pPF->bulletAutoNum.is_init())
{
buWrt.WriteString(L"<a:buAutoNum type=\"");
buWrt.WriteString(pPF->bulletAutoNum->type.get());
buWrt.WriteString(L"\"");
if ((pPF->bulletAutoNum->startAt.IsInit()) && (pPF->bulletAutoNum->startAt.get2() != 1))
{
buWrt.WriteString(L" startAt=\"");
buWrt.WriteString(std::to_wstring(pPF->bulletAutoNum->startAt.get2()));
buWrt.WriteString(L"\"");
}
buWrt.WriteString(L"/>");
}
else
{
buWrt.WriteString(std::wstring(L"<a:buChar char=\"\x2022\"/>"));
}
}
else
{
buWrt.WriteString(std::wstring(L"<a:buNone/>"));
}
}
return buWrt.GetData();
}
std::wstring PPT::CShapeWriter::ConvertGroup()
{
CGroupElement* pGroupElement = dynamic_cast<CGroupElement*>(m_pElement.get());
if (!pGroupElement) return L"";
m_oWriter.WriteString(std::wstring(L"<p:grpSp>"));
WriteGroupInfo();
m_pElement->NormalizeCoordsByMetric();
m_oWriter.WriteString(std::wstring(L"<p:grpSpPr>"));
if (pGroupElement->m_bChildAnchorEnabled || pGroupElement->m_bAnchorEnabled)
{
std::wstring str;
m_oWriter.WriteString(std::wstring(L"<a:xfrm"));
if (0 != pGroupElement->m_dRotate)
{
if (pGroupElement->m_bFlipH && pGroupElement->m_dRotate < 180)
pGroupElement->m_dRotate += 180; //Тікбұрышты үшбұрыштарды.ppt slide-7
m_oWriter.WriteString(L" rot=\"" + std::to_wstring((int)(pGroupElement->m_dRotate * 60000)) + L"\"");
}
if (pGroupElement->m_bFlipH)
{
m_oWriter.WriteString(std::wstring(L" flipH=\"1\""));
}
if (pGroupElement->m_bFlipV)
{
m_oWriter.WriteString(std::wstring(L" flipV=\"1\""));
}
m_oWriter.WriteString(std::wstring(L">"));
const bool bChildAnchorEnabled = pGroupElement->m_bChildAnchorEnabled;
int x = bChildAnchorEnabled ? (int)pGroupElement->m_rcChildAnchor.left : (int)pGroupElement->m_rcAnchor.left;
int y = bChildAnchorEnabled ? (int)pGroupElement->m_rcChildAnchor.top : (int)pGroupElement->m_rcAnchor.top;
m_oWriter.WriteString(L"<a:off x=\"" + std::to_wstring(x)
+ L"\" y=\"" + std::to_wstring(y) + L"\"/>");
double width = bChildAnchorEnabled ? pGroupElement->m_rcChildAnchor.GetWidth() : pGroupElement->m_rcAnchor.GetWidth();
double height = bChildAnchorEnabled ? pGroupElement->m_rcChildAnchor.GetHeight() : pGroupElement->m_rcAnchor.GetHeight();
if ( width > 0 && height > 0 )
{
m_oWriter.WriteString(L"<a:ext cx=\"" + std::to_wstring((int)width) + L"\" cy=\"" + std::to_wstring((int)height) + L"\"/>");
}
m_oWriter.WriteString(L"<a:chOff x=\"" + std::to_wstring((int)pGroupElement->m_rcGroupAnchor.left) +
L"\" y=\"" + std::to_wstring((int)pGroupElement->m_rcGroupAnchor.top) + L"\"/>");
m_oWriter.WriteString(L"<a:chExt cx=\"" + std::to_wstring((int)pGroupElement->m_rcGroupAnchor.GetWidth()) +
L"\" cy=\"" + std::to_wstring((int)pGroupElement->m_rcGroupAnchor.GetHeight()) + L"\"/>");
m_oWriter.WriteString(std::wstring(L"</a:xfrm>"));
}
m_oWriter.WriteString(std::wstring(L"</p:grpSpPr>"));
pGroupElement = NULL;
return m_oWriter.GetData();
}
void PPT::CShapeWriter::WriteHyperlink(const std::vector<CInteractiveInfo>& actions)
{
for (unsigned i = 0; i < actions.size(); i++)
{
if (actions[i].m_lType == CInteractiveInfo::over
&& actions[i].m_strAudioFileName.empty()
&& actions[i].m_lType == II_NoAction)
continue;
if (actions[i].m_strHyperlink.empty() && actions[i].m_lType != LT_CustomShow)
continue;
PPTX::Logic::Hyperlink hlink;
if (actions[i].m_strHyperlink.size() && m_pRels)
{
std::wstring id;
switch (actions[i].m_lHyperlinkType)
{
case LT_SlideNumber: id = m_pRels->WriteSlideRef(actions[i].m_strHyperlink); break;
case LT_Url: id = m_pRels->WriteHyperlink(actions[i].m_strHyperlink, true); break;
case LT_OtherPresentation: id = m_pRels->WriteFile(actions[i].m_strHyperlink); break;
case LT_OtherFile: id = m_pRels->WriteFile(actions[i].m_strHyperlink); break;
}
if (!id.empty())
hlink.id = id;
}
if (actions[i].m_strAudioFileName.size() && m_pRels)
{
hlink.snd = new PPTX::Logic::WavAudioFile;
bool bExternal = false;
hlink.snd->embed = m_pRels->WriteAudio(actions[i].m_strAudioFileName, bExternal);
hlink.snd->m_name = L"snd";
hlink.snd->name = actions[i].m_strAudioName;
hlink.id = std::wstring(L"");
}
if (actions[i].m_eActivation == CInteractiveInfo::over)
hlink.m_name = L"hlinkHover";
// if (actions[i].m_bVisited)
// hlink.highlightClick = true;
switch (actions[i].m_lType)
{
case II_NoAction:
{
hlink.action = L"ppaction://noaction";
break;
}
case II_MacroAction:
{
if (actions[i].m_macro.size())
hlink.action = L"ppaction://macro?name=" + actions[i].m_macro;
else
hlink.action = L"ppaction://noaction";
break;
}
case II_JumpAction:
{
std::wstring strJump(L"ppaction://hlinkshowjump?jump=");
switch (actions[i].m_lJump)
{
case II_NextSlide:
{
strJump += L"nextslide";
break;
}
case II_PreviousSlide:
{
strJump += L"previousslide";
break;
}
case II_FirstSlide:
{
strJump += L"firstslide";
break;
}
case II_LastSlide:
{
strJump += L"lastslide";
break;
}
case II_LastSlideViewed:
{
strJump += L"lastslideviewed";
break;
}
case II_EndShow:
{
strJump += L"endshow";
break;
}
}
hlink.action = strJump;
hlink.id = L"";
break;
}
case II_HyperlinkAction:
{
switch (actions[i].m_lHyperlinkType)
{
case LT_SlideNumber:
{
if (hlink.id.is_init())
hlink.action = L"ppaction://hlinksldjump";
break;
}
case LT_Url:
{
// TODO need check 1713 and hyperlink there
break; // break;
}
case LT_OtherPresentation:
{
if (hlink.id.is_init())
hlink.action = L"ppaction://hlinkpres?slideindex=1&slidetitle=";
break;
}
case LT_OtherFile:
{
break;
}
}
break;
}
case II_MediaAction:
{
hlink.action = L"ppaction://media";
hlink.id = L"";
break;
}
default:
hlink.action = L"ppaction://noaction";
}
m_oWriter.WriteString(hlink.toXML());
}
}
std::vector<CInteractiveInfo> CShapeWriter::getActionsByNum(const int num)
{
auto& actions = m_pElement->m_arrActions;
// Need to check paragraph or button
if (num == -1 && actions.size() > 2) // paragraph inside shape
return {};
else if (num == -1) // button inside shape
return actions;
bool wasClick = false;
int currentNum = 0;
std::vector<CInteractiveInfo> actionsForOneParagraph;
for (const auto& act : actions)
{
if (act.m_eActivation == CInteractiveInfo::click)
wasClick = true;
else if (act.m_eActivation == CInteractiveInfo::over && wasClick == true)
{
currentNum--;
wasClick = false;
}
if (currentNum == num)
actionsForOneParagraph.push_back(act);
currentNum++;
if (currentNum > num)
break;
}
return actionsForOneParagraph;
}
// TODO! Not work correct
std::wstring PPT::CShapeWriter::ConvertTable()
{
CGroupElement* pGroupElement = dynamic_cast<CGroupElement*>(m_pElement.get());
if (!pGroupElement) return L"";
m_oWriter.WriteString(std::wstring(L"<p:graphicFrame>"));
WriteTableInfo();
m_pElement->NormalizeCoordsByMetric();
if (pGroupElement->m_bChildAnchorEnabled || pGroupElement->m_bAnchorEnabled)
{
std::wstring str;
m_oWriter.WriteString(std::wstring(L"<p:xfrm"));
if (0 != pGroupElement->m_dRotate)
{
if (pGroupElement->m_bFlipH && pGroupElement->m_dRotate < 180)
pGroupElement->m_dRotate += 180; //Тікбұрышты үшбұрыштарды.ppt slide-7
m_oWriter.WriteString(L" rot=\"" + std::to_wstring((int)(pGroupElement->m_dRotate * 60000)) + L"\"");
}
if (pGroupElement->m_bFlipH)
{
m_oWriter.WriteString(std::wstring(L" flipH=\"1\""));
}
if (pGroupElement->m_bFlipV)
{
m_oWriter.WriteString(std::wstring(L" flipV=\"1\""));
}
m_oWriter.WriteString(std::wstring(L">"));
m_oWriter.WriteString(L"<a:off x=\"" +
std::to_wstring(pGroupElement->m_bChildAnchorEnabled ? (int)pGroupElement->m_rcChildAnchor.left : (int)pGroupElement->m_rcAnchor.left)
+ L"\" y=\"" +
std::to_wstring(pGroupElement->m_bChildAnchorEnabled ? (int)pGroupElement->m_rcChildAnchor.top : (int)pGroupElement->m_rcAnchor.top) +
L"\"/>");
double width = pGroupElement->m_bChildAnchorEnabled ? pGroupElement->m_rcChildAnchor.GetWidth() : pGroupElement->m_rcAnchor.GetWidth();
double height = pGroupElement->m_bChildAnchorEnabled ? pGroupElement->m_rcChildAnchor.GetHeight() : pGroupElement->m_rcAnchor.GetHeight();
if ( width > 0 && height > 0 )
{
m_oWriter.WriteString(L"<a:ext cx=\"" + std::to_wstring((int)width) + L"\" cy=\"" + std::to_wstring((int)height) + L"\"/>");
}
m_oWriter.WriteString(std::wstring(L"</p:xfrm>"));
}
m_oWriter.WriteString(std::wstring(L"<a:graphic><a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/table\"><a:tbl><a:tblPr firstRow=\"1\" bandRow=\"1\"><a:tableStyleId>"));
m_oWriter.WriteString(std::wstring(L"</a:tableStyleId></a:tblPr>"));
pGroupElement = NULL;
return m_oWriter.GetData();
}
std::wstring PPT::CShapeWriter::ConvertTableCells()
{
CGroupElement* pGroupElement = dynamic_cast<CGroupElement*>(m_pElement.get());
if (!pGroupElement) return L"";
//TODO
return L"";
}
std::wstring PPT::CShapeWriter::ConvertShape()
{
CImageElement* pImageElement = dynamic_cast<CImageElement*>(m_pElement.get());
CGroupElement* pGroupElement = dynamic_cast<CGroupElement*>(m_pElement.get());
CShapeElement* pShapeElement = dynamic_cast<CShapeElement*>(m_pElement.get());
if (pImageElement) return ConvertImage();
if (pGroupElement) return ConvertGroup();
if (pShapeElement == NULL) return L"";
std::wstring prstTxWarp;
std::wstring prstGeom = oox::Spt2ShapeType_mini((oox::MSOSPT)pShapeElement->m_lShapeType);
//rect, ellipse, line
if (prstGeom.empty())
{
prstTxWarp = oox::Spt2WordArtShapeType((oox::MSOSPT)pShapeElement->m_lShapeType);
if (prstTxWarp.empty() == false)
{
m_bWordArt = true;
m_bTextBox = true;
prstGeom = L"rect";
m_oBrush.Type = c_BrushTypeNoFill;
}
}
else
{
if (oox::msosptTextBox == (oox::MSOSPT)pShapeElement->m_lShapeType)
m_bTextBox = true;
if (oox::msosptLine == (oox::MSOSPT)pShapeElement->m_lShapeType)
pShapeElement->m_bLine = true;
}
if (pShapeElement->m_pShape && !pShapeElement->m_pShape->m_strXmlString.empty())
{
ParseXmlAlternative(pShapeElement->m_pShape->m_strXmlString);
}
m_oWriter.WriteString(std::wstring(L"<p:sp>"));
WriteShapeInfo();
CGeomShapeInfo oInfo;
oInfo.m_lOriginalWidth = m_pElement->m_bChildAnchorEnabled ? (LONG)m_pElement->m_rcChildAnchor.GetWidth() : (LONG)m_pElement->m_rcAnchor.GetWidth();
oInfo.m_lOriginalHeight = m_pElement->m_bChildAnchorEnabled ? (LONG)m_pElement->m_rcChildAnchor.GetHeight() : (LONG)m_pElement->m_rcAnchor.GetHeight();
m_pElement->NormalizeCoordsByMetric();
oInfo.SetBounds(m_pElement->m_bChildAnchorEnabled ? m_pElement->m_rcChildAnchor : m_pElement->m_rcAnchor);
oInfo.m_dRotate = pShapeElement->m_dRotate;
oInfo.m_bFlipH = pShapeElement->m_bFlipH;
oInfo.m_bFlipV = pShapeElement->m_bFlipV;
m_oWriter.WriteString(std::wstring(L"<p:spPr>"));
if (pShapeElement->m_bChildAnchorEnabled || pShapeElement->m_bAnchorEnabled)
{
std::wstring str;
m_oWriter.WriteString(std::wstring(L"<a:xfrm"));
if (0 != pShapeElement->m_dRotate)
{
if (pShapeElement->m_bFlipH && pShapeElement->m_dRotate < 180)
pShapeElement->m_dRotate += 180; //Тікбұрышты үшбұрыштарды.ppt slide-7
m_oWriter.WriteString(L" rot=\"" + std::to_wstring((int)(pShapeElement->m_dRotate * 60000)) + L"\"");
}
if (pShapeElement->m_bFlipH)
{
m_oWriter.WriteString(std::wstring(L" flipH=\"1\""));
}
if (pShapeElement->m_bFlipV)
{
m_oWriter.WriteString(std::wstring(L" flipV=\"1\""));
}
m_oWriter.WriteString(std::wstring(L">"));
m_oWriter.WriteString(L"<a:off x=\"" +
std::to_wstring(pShapeElement->m_bChildAnchorEnabled ? (int)pShapeElement->m_rcChildAnchor.left : (int)pShapeElement->m_rcAnchor.left)
+ L"\" y=\"" +
std::to_wstring(pShapeElement->m_bChildAnchorEnabled ? (int)pShapeElement->m_rcChildAnchor.top : (int)pShapeElement->m_rcAnchor.top) +
L"\"/>");
double width = pShapeElement->m_bChildAnchorEnabled ? pShapeElement->m_rcChildAnchor.GetWidth() : pShapeElement->m_rcAnchor.GetWidth();
double height = pShapeElement->m_bChildAnchorEnabled ? pShapeElement->m_rcChildAnchor.GetHeight() : pShapeElement->m_rcAnchor.GetHeight();
if (( width > 0 && height > 0 ) || (pShapeElement->m_lShapeType == oox::msosptLine))
{
m_oWriter.WriteString(L"<a:ext cx=\"" + std::to_wstring((int)width) + L"\" cy=\"" + std::to_wstring((int)height) + L"\"/>");
}
m_oWriter.WriteString(std::wstring(L"</a:xfrm>"));
}
CBaseShapePtr shape = pShapeElement->m_pShape->getBaseShape();
if (pShapeElement->m_pShape->m_lDrawType & c_ShapeDrawType_Graphic || shape->m_bCustomShape)
{
pShapeElement->m_pShape->ToRenderer(dynamic_cast<IRenderer*>(this), oInfo, 0.0, 1.0);
}
bool wasGeomAltWrote = false;
if (!m_xmlGeomAlternative.empty())
{
auto prstGeomStart = m_xmlGeomAlternative.find(L"<a:prstGeom");
auto prstGeomEnd = m_xmlGeomAlternative.find(L"</a:prstGeom>");
if (prstGeomStart != std::wstring::npos && prstGeomEnd != std::wstring::npos)
{
UINT prstGeomLen = prstGeomEnd - prstGeomStart + 13; // len </a:prstGeom>
auto strPrstGeom = m_xmlGeomAlternative.substr(prstGeomStart, prstGeomLen);
m_oWriter.WriteString(strPrstGeom);
wasGeomAltWrote = true;
}
}
if (wasGeomAltWrote == false)
{
if ((prstGeom.empty() == false || pShapeElement->m_bShapePreset) && prstTxWarp.empty() && !shape->m_bCustomShape)
{
if (prstGeom.empty()) prstGeom = L"rect";
m_oWriter.WriteString(std::wstring(L"<a:prstGeom"));
{
m_oWriter.WriteString(std::wstring(L" prst=\"") + prstGeom + std::wstring(L"\">"));
if (!m_bWordArt)
{
m_oWriter.WriteString(std::wstring(L"<a:avLst/>"));
}
}
m_oWriter.WriteString(std::wstring(L"</a:prstGeom>"));
}
else if (prstTxWarp.empty())
{
m_oWriter.WriteString(pShapeElement->ConvertPPTShapeToPPTX());
}
else
{
//word art
m_oWriter.WriteString(std::wstring(L"<a:prstGeom prst=\"rect\"/>"));
}
}
if (!m_bWordArt)
{
m_oWriter.WriteString(ConvertBrush(pShapeElement->m_oBrush));
if (pShapeElement->m_bLine)
{
m_oWriter.WriteString(ConvertLine(pShapeElement->m_oPen));
}
m_oWriter.WriteString(ConvertShadow(pShapeElement->m_oShadow));
}
Write3dShape();
m_oWriter.WriteString(std::wstring(L"</p:spPr>"));
WriteTextInfo();
m_oWriter.WriteString(std::wstring(L"</p:sp>"));
pShapeElement = NULL;
return m_oWriter.GetData();
}
void PPT::CShapeWriter::ParseXmlAlternative(const std::wstring & xml)
{
XmlUtils::CXmlLiteReader oReader;
if ( !oReader.FromString( xml ) )
return;
if ( !oReader.ReadNextNode() )
return;
std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
nullable<PPTX::Logic::SpTreeElem> oElement;
if ( L"graphicFrame" == sName || L"pic" == sName || L"sp" == sName || L"grpSp" == sName || L"cxnSp" == sName || L"AlternateContent" == sName
|| L"spTree" )
{
oElement = oReader;
}
if (oElement.IsInit())
{
smart_ptr<PPTX::Logic::Shape> shape = oElement->GetElem().smart_dynamic_cast<PPTX::Logic::Shape>();
if (shape.IsInit())
{
NSBinPptxRW::CXmlWriter writer(XMLWRITER_DOC_TYPE_PPTX);
// shape->spPr.Geometry.toXmlWriter(&writer);
shape->toXmlWriter(&writer);
m_xmlGeomAlternative = writer.GetXmlString();
// writer.ClearNoAttack();
// if ((shape->txBody.IsInit()) && (shape->txBody->bodyPr.IsInit()) && (shape->txBody->bodyPr->prstTxWarp.IsInit()))
// {//только WordArt
// shape->txBody->toXmlWriter(&writer);
// m_xmlTxBodyAlternative = writer.GetXmlString();
}
}
smart_ptr<PPTX::Logic::SpTree> groupShape = oElement->GetElem().smart_dynamic_cast<PPTX::Logic::SpTree>();
if (groupShape.IsInit())
{//smartArt
NSBinPptxRW::CXmlWriter writer(XMLWRITER_DOC_TYPE_PPTX);
groupShape->toXmlWriter(&writer);
m_xmlAlternative = writer.GetXmlString();
}
}
std::wstring PPT::CShapeWriter::ConvertImage()
{
CImageElement* pImageElement = dynamic_cast<CImageElement*>(m_pElement.get());
if (!pImageElement) return L"";
if (pImageElement->m_bImagePresent == false)
{
if (pImageElement->m_sName.empty()) return L"";
//ppt_presentation.ppt - ссылка на файл на диске
pImageElement->m_strImageFileName.clear();
pImageElement->m_bImagePresent = true;
}
std::wstring strRid;
if (!pImageElement->m_strImageFileName.empty())
{
strRid = m_pRels->WriteImage(pImageElement->m_strImageFileName);
}
else if (!pImageElement->m_sImageName.empty())
{
strRid = m_pRels->WriteHyperlinkImage(CorrectXmlString3(pImageElement->m_sImageName));
}
if (strRid.empty()) return L"";
std::wstring strAnchor;
CGeomShapeInfo oInfo;
oInfo.m_lOriginalWidth = m_pElement->m_bChildAnchorEnabled ? (LONG)m_pElement->m_rcChildAnchor.GetWidth() : (LONG)m_pElement->m_rcAnchor.GetWidth();
oInfo.m_lOriginalHeight = m_pElement->m_bChildAnchorEnabled ? (LONG)m_pElement->m_rcChildAnchor.GetHeight() : (LONG)m_pElement->m_rcAnchor.GetHeight();
m_pElement->NormalizeCoordsByMetric();
oInfo.SetBounds(m_pElement->m_bChildAnchorEnabled ? m_pElement->m_rcChildAnchor : m_pElement->m_rcAnchor);
oInfo.m_dRotate = pImageElement->m_dRotate;
oInfo.m_bFlipH = pImageElement->m_bFlipH;
oInfo.m_bFlipV = pImageElement->m_bFlipV;
if (pImageElement->m_bChildAnchorEnabled || pImageElement->m_bAnchorEnabled)
{
if (0 != pImageElement->m_dRotate)
{
strAnchor += L" rot=\"" + std::to_wstring((int)(pImageElement->m_dRotate * 60000)) + L"\"";
}
if (pImageElement->m_bFlipH)
{
strAnchor += L" flipH=\"1\"";
}
if (pImageElement->m_bFlipV)
{
strAnchor += L" flipV=\"1\"";
}
strAnchor += L">";
strAnchor += L"<a:off x=\"" +
std::to_wstring(pImageElement->m_bChildAnchorEnabled ? (int)pImageElement->m_rcChildAnchor.left : (int)pImageElement->m_rcAnchor.left)
+ L"\" y=\"" +
std::to_wstring(pImageElement->m_bChildAnchorEnabled ? (int)pImageElement->m_rcChildAnchor.top : (int)pImageElement->m_rcAnchor.top) +
L"\"/>";
_INT64 width = (_INT64)(pImageElement->m_bChildAnchorEnabled ? pImageElement->m_rcChildAnchor.GetWidth() : pImageElement->m_rcAnchor.GetWidth());
_INT64 height = (_INT64)(pImageElement->m_bChildAnchorEnabled ? pImageElement->m_rcChildAnchor.GetHeight() : pImageElement->m_rcAnchor.GetHeight());
if ((width > 0 && height > 0) && ((_UINT64)width) < 0xffffffffffff && ((_UINT64)height) < 0xffffffffffff)
{
strAnchor += L"<a:ext cx=\"" + std::to_wstring(width) + L"\" cy=\"" + std::to_wstring(height) + L"\"/>";
}
else
{
strAnchor += L"<a:ext cx=\"0\" cy=\"0\"/>";
}
}
COleObjectElement* pOleObjectElement = dynamic_cast<COleObjectElement*>(m_pElement.get());
if (pOleObjectElement)
{
std::wstring strRidOleObject = m_pRels->WriteOleObject(pOleObjectElement->m_strBinFileName);
if (false == strRidOleObject.empty())
{
WriteOleObjectInfo(strRidOleObject, strAnchor);
}
else pOleObjectElement = NULL;
}
m_oWriter.WriteString(std::wstring(L"<p:pic>"));
WriteImageInfo();
m_oWriter.WriteString(std::wstring(L"<p:blipFill>"));
std::wstring strWrite = L"<a:blip r:embed=\"" + strRid + L"\"";
m_oWriter.WriteString(strWrite);
if (pImageElement->m_lpictureBrightness != 0 || pImageElement->m_lpictureContrast != 0x10000)
{
m_oWriter.WriteString(L"><a:lum");
if (pImageElement->m_lpictureBrightness != 0)
{
int bright = std::round(3.051705 * pImageElement->m_lpictureBrightness); // -100000 - min, backgrpund. 50000 - usually. 100000 - max,white
if (bright < -100000 || bright > 100000)
bright = 50000;
m_oWriter.WriteString(L" bright=\"" + std::to_wstring(bright) + L"\"");
}
if (pImageElement->m_lpictureContrast != 0x10000)
{
int contrast; // -100000 - min white. 0 - usually. 100000 - color max
if (pImageElement->m_lpictureContrast < 0x10000)
{
contrast = (0x10000 - pImageElement->m_lpictureContrast) * -1.5259;
}
else
{
// contrast = (pImageElement->m_lpictureContrast - 0x10000) * 0.76294; // 0.76294 - not correct, * - not correct
contrast = 0;
}
if (contrast < -100000)
contrast = -100000;
m_oWriter.WriteString(L" contrast=\"" + std::to_wstring(contrast) + L"\"");
}
m_oWriter.WriteString(L"/></a:blip>");
}else
{
m_oWriter.WriteString(L"/>");
}
m_oWriter.WriteString(std::wstring(L"<a:srcRect"));
if (pImageElement->m_bCropEnabled)
{//124-125 Q3 V2 Win File 3.ppt
m_oWriter.WriteString(L" l=\"" + std::to_wstring((_INT64)(pImageElement->m_lcropFromLeft *1.5)) + L"\"");
m_oWriter.WriteString(L" t=\"" + std::to_wstring((_INT64)(pImageElement->m_lcropFromTop *1.5)) + L"\"");
m_oWriter.WriteString(L" r=\"" + std::to_wstring((_INT64)(pImageElement->m_lcropFromRight *1.5)) + L"\"");
m_oWriter.WriteString(L" b=\"" + std::to_wstring((_INT64)(pImageElement->m_lcropFromBottom*1.5)) + L"\"");
}
m_oWriter.WriteString(std::wstring(L"/>"));
if (pImageElement->m_bTile)
{
m_oWriter.WriteString(std::wstring(L"<a:tile/>"));
}
else if (pImageElement->m_bStretch)
{
m_oWriter.WriteString(std::wstring(L"<a:stretch><a:fillRect/></a:stretch>"));
}
m_oWriter.WriteString(std::wstring(L"</p:blipFill>"));
m_oWriter.WriteString(std::wstring(L"<p:spPr>"));
if (pImageElement->m_bChildAnchorEnabled || pImageElement->m_bAnchorEnabled)
{
m_oWriter.WriteString(std::wstring(L"<a:xfrm") + strAnchor + std::wstring(L"</a:xfrm>"));
}
m_oWriter.WriteString(std::wstring(L"<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom>"));
m_oWriter.WriteString(ConvertBrush(pImageElement->m_oBrush));
if (pImageElement->m_bLine)
{
m_oWriter.WriteString(ConvertLine(pImageElement->m_oPen));
}
m_oWriter.WriteString(std::wstring(L"</p:spPr>"));
m_oWriter.WriteString(std::wstring(L"</p:pic>"));
if (pOleObjectElement)
{
m_oWriter.WriteString(std::wstring(L"</p:oleObj>"));
m_oWriter.WriteString(std::wstring(L"</a:graphicData>"));
m_oWriter.WriteString(std::wstring(L"</a:graphic>"));
m_oWriter.WriteString(std::wstring(L"</p:graphicFrame>"));
}
pImageElement = NULL;
return m_oWriter.GetData();
}
HRESULT PPT::CShapeWriter::get_Type(LONG* lType)
{
if (NULL == lType)
return S_FALSE;
*lType = c_nSVGConverter;
return S_OK;
}
//-------- Функции для работы со страницей --------------------------------------------------
HRESULT PPT::CShapeWriter::NewPage()
{
return S_OK;
}
HRESULT PPT::CShapeWriter::get_Height(double* dHeight)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::put_Height(const double& dHeight)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::get_Width(double* dWidth)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::put_Width(const double& dWidth)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::get_DpiX(double* dDpiX)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::get_DpiY(double* dDpiY)
{
return S_OK;
}
// pen --------------------------------------------------------------------------------------
HRESULT PPT::CShapeWriter::SetPen(std::wstring bsXML)
{
//m_oPen.FromXmlString((std::wstring)bsXML);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_PenColor(LONG* lColor)
{
*lColor = m_oPen.Color.GetLONG();
return S_OK;
}
HRESULT PPT::CShapeWriter::put_PenColor(const LONG& lColor)
{
BYTE lScheme = ((_UINT32)(lColor)) >> 24;
if (0xFF != lScheme)
m_oPen.Color.SetBGR(lColor);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_PenAlpha(LONG* lAlpha)
{
*lAlpha = m_oPen.Alpha;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_PenAlpha(const LONG& lAlpha)
{
m_oPen.Alpha = lAlpha;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_PenSize(double* dSize)
{
*dSize = m_oPen.Size;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_PenSize(const double& dSize)
{
m_oPen.Size = (long)(dSize * 25.4 / 96.0);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_PenDashStyle(BYTE* val)
{
*val = m_oPen.DashStyle;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_PenDashStyle(const BYTE& val)
{
m_oPen.DashStyle = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_PenLineStartCap(BYTE* val)
{
*val = m_oPen.LineStartCap;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_PenLineStartCap(const BYTE& val)
{
m_oPen.LineStartCap = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_PenLineEndCap(BYTE* val)
{
*val = m_oPen.LineEndCap;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_PenLineEndCap(const BYTE& val)
{
m_oPen.LineEndCap = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_PenLineJoin(BYTE* val)
{
*val = m_oPen.LineJoin;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_PenLineJoin(const BYTE& val)
{
m_oPen.LineJoin = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_PenDashOffset(double* val)
{
*val = m_oPen.DashOffset;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_PenDashOffset(const double& val)
{
m_oPen.DashOffset = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_PenAlign(LONG* val)
{
*val = m_oPen.Align;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_PenAlign(const LONG& val)
{
m_oPen.Align = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_PenMiterLimit(double* val)
{
*val = m_oPen.MiterLimit;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_PenMiterLimit(const double& val)
{
m_oPen.MiterLimit = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::PenDashPattern(double* pPattern, LONG lCount)
{
if (NULL != pPattern)
{
m_oPen.SetDashPattern(pPattern, lCount);
}
return S_OK;
}
// brush ------------------------------------------------------------------------------------
HRESULT PPT::CShapeWriter::SetBrush(std::wstring bsXML)
{
//m_oBrush.FromXmlString((std::wstring)bsXML);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_BrushType(LONG* lType)
{
*lType = m_oBrush.Type;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_BrushType(const LONG& lType)
{
m_oBrush.Type = lType;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_BrushColor1(LONG* lColor)
{
*lColor = m_oBrush.Color1.GetLONG();
return S_OK;
}
HRESULT PPT::CShapeWriter::put_BrushColor1(const LONG& lColor)
{
BYTE lScheme = ((_UINT32)(lColor)) >> 24;
if (0xFF != lScheme)
m_oBrush.Color1.SetBGR(lColor);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_BrushAlpha1(LONG* lAlpha)
{
*lAlpha = m_oBrush.Alpha1;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_BrushAlpha1(const LONG& lAlpha)
{
m_oBrush.Alpha1 = lAlpha;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_BrushColor2(LONG* lColor)
{
*lColor = m_oBrush.Color2.GetLONG();
return S_OK;
}
HRESULT PPT::CShapeWriter::put_BrushColor2(const LONG& lColor)
{
m_oBrush.Color2.SetBGR(lColor);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_BrushAlpha2(LONG* lAlpha)
{
*lAlpha = m_oBrush.Alpha2;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_BrushAlpha2(const LONG& lAlpha)
{
m_oBrush.Alpha2 = lAlpha;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_BrushTexturePath(std::wstring* bsPath)
{
if (bsPath == NULL) return S_OK;
*bsPath = m_oBrush.TexturePath;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_BrushTexturePath(const std::wstring& bsPath)
{
m_oBrush.TexturePath = bsPath;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_BrushTextureMode(LONG* lMode)
{
*lMode = m_oBrush.TextureMode;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_BrushTextureMode(const LONG& lMode)
{
m_oBrush.TextureMode = lMode;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_BrushTextureAlpha(LONG* lTxAlpha)
{
*lTxAlpha = m_oBrush.TextureAlpha;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_BrushTextureAlpha(const LONG& lTxAlpha)
{
m_oBrush.TextureAlpha = lTxAlpha;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_BrushLinearAngle(double* dAngle)
{
*dAngle = m_oBrush.LinearAngle;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_BrushLinearAngle(const double& dAngle)
{
m_oBrush.LinearAngle = dAngle;
return S_OK;
}
HRESULT PPT::CShapeWriter::BrushRect(const INT& val, const double& left, const double& top, const double& width, const double& height)
{
m_oBrush.Rectable = val;
m_oBrush.Rect.X = (float)left;
m_oBrush.Rect.Y = (float)top;
m_oBrush.Rect.Width = (float)width;
m_oBrush.Rect.Height = (float)height;
return S_OK;
}
HRESULT PPT::CShapeWriter::BrushBounds(const double& left, const double& top, const double& width, const double& height)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::put_BrushGradientColors(LONG* lColors, double* pPositions, LONG nCount)
{
return S_OK;
}
// font -------------------------------------------------------------------------------------
HRESULT PPT::CShapeWriter::SetFont(std::wstring bsXML)
{
//m_oFont.FromXmlString((std::wstring)bsXML);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_FontName(std::wstring* bsName)
{
if (bsName == NULL) return S_OK;
*bsName = m_oFont.Name;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_FontName(const std::wstring& bsName)
{
m_oFont.Name = bsName;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_FontPath(std::wstring* bsName)
{
if (bsName == NULL) return S_OK;
*bsName = m_oFont.Path;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_FontPath(const std::wstring& bsName)
{
m_oFont.Path = bsName;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_FontSize(double* dSize)
{
*dSize = m_oFont.Size;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_FontSize(const double& dSize)
{
m_oFont.Size = dSize;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_FontStyle(LONG* lStyle)
{
*lStyle = m_oFont.GetStyle();
return S_OK;
}
HRESULT PPT::CShapeWriter::put_FontStyle(const LONG& lStyle)
{
m_oFont.SetStyle(lStyle);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_FontStringGID(INT* bGID)
{
*bGID = m_oFont.StringGID;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_FontStringGID(const INT& bGID)
{
m_oFont.StringGID = bGID;
m_pFontManager->SetStringGID(bGID);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_FontCharSpace(double* dSpace)
{
*dSpace = m_oFont.CharSpace;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_FontCharSpace(const double& dSpace)
{
m_oFont.CharSpace = dSpace;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_FontFaceIndex(int* lFaceIndex)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::put_FontFaceIndex(const int& lFaceIndex)
{
return S_OK;
}
// shadow -----------------------------------------------------------------------------------
HRESULT PPT::CShapeWriter::SetShadow(std::wstring bsXML)
{
//m_oShadow.FromXmlString((std::wstring)bsXML);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_ShadowDistanceX(double* val)
{
*val = m_oShadow.DistanceX;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_ShadowDistanceX(double val)
{
m_oShadow.DistanceX = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_ShadowDistanceY(double* val)
{
*val = m_oShadow.DistanceY;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_ShadowDistanceY(double val)
{
m_oShadow.DistanceY = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_ShadowBlurSize(double* val)
{
*val = m_oShadow.BlurSize;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_ShadowBlurSize(double val)
{
m_oShadow.BlurSize = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_ShadowColor(LONG* val)
{
*val = m_oShadow.Color.GetLONG();
return S_OK;
}
HRESULT PPT::CShapeWriter::put_ShadowColor(LONG val)
{
m_oShadow.Color.SetBGR(val);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_ShadowAlpha(LONG* val)
{
*val = m_oShadow.Alpha;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_ShadowAlpha(LONG val)
{
m_oShadow.Alpha = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_ShadowVisible(bool* val)
{
*val = m_oShadow.Visible;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_ShadowVisible(bool val)
{
m_oShadow.Visible = val;
return S_OK;
}
// edge -------------------------------------------------------------------------------------
HRESULT PPT::CShapeWriter::SetEdgeText(std::wstring bsXML)
{
//m_oEdge.FromXmlString((std::wstring)bsXML);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_EdgeVisible(LONG* val)
{
*val = m_oEdge.Visible;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_EdgeVisible(LONG val)
{
m_oEdge.Visible = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_EdgeColor(LONG* val)
{
*val = m_oEdge.Color.GetLONG();
return S_OK;
}
HRESULT PPT::CShapeWriter::put_EdgeColor(LONG val)
{
m_oEdge.Color.SetBGR(val);
return S_OK;
}
HRESULT PPT::CShapeWriter::get_EdgeAlpha(LONG* val)
{
*val = m_oEdge.Alpha;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_EdgeAlpha(LONG val)
{
m_oEdge.Alpha = val;
return S_OK;
}
HRESULT PPT::CShapeWriter::get_EdgeDist(double* val)
{
*val = m_oEdge.Dist;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_EdgeDist(double val)
{
m_oEdge.Dist = val;
return S_OK;
}
//-------- Функции для вывода текста --------------------------------------------------------
HRESULT PPT::CShapeWriter::CommandDrawText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h)
{
if (c_nHyperlinkType == m_lCurrentCommandType)
return S_OK;
if (true)
{
PathCommandEnd();
BeginCommand(c_nPathType);
PathCommandText(bsText, x, y, w, h);
DrawPath(c_nWindingFillMode);
EndCommand(c_nPathType);
PathCommandEnd();
return S_OK;
}
return S_OK;
}
HRESULT PPT::CShapeWriter::CommandDrawTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::CommandDrawTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandTextCHAR(const LONG& c, const double& x, const double& y, const double& w, const double& h)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandTextExCHAR(const LONG& c, const LONG& gid, const double& x, const double& y, const double& w, const double& h)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::CommandLong(const LONG& lType, const LONG& lCommand)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::CommandDouble(const LONG& lType, const double& dCommand)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::CommandString(const LONG& lType, const std::wstring& sCommand)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::CommandDrawTextEx(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h)
{
if (true)
{
PathCommandEnd();
BeginCommand(c_nPathType);
PathCommandTextEx(bsUnicodeText, pGids, nGidsCount ,x, y, w, h);
DrawPath(c_nWindingFillMode);
EndCommand(c_nPathType);
PathCommandEnd();
return S_OK;
}
return S_OK;
}
//-------- Маркеры для команд ---------------------------------------------------------------
HRESULT PPT::CShapeWriter::BeginCommand(const _UINT32& lType)
{
if (c_nPathType == lType)
{
m_pSimpleGraphicsConverter->PathCommandEnd();
}
m_lCurrentCommandType = lType;
return S_OK;
}
HRESULT PPT::CShapeWriter::EndCommand(const _UINT32& lType)
{
m_lCurrentCommandType = -1;
return S_OK;
}
//-------- Функции для работы с Graphics Path -----------------------------------------------
HRESULT PPT::CShapeWriter::PathCommandMoveTo(const double& x, const double& y)
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
MoveTo(x, y);
}
else
{
m_pSimpleGraphicsConverter->PathCommandMoveTo(x, y);
}
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandLineTo(const double& x, const double& y)
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
LineTo(x, y);
}
else
{
m_pSimpleGraphicsConverter->PathCommandLineTo(x, y);
}
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandLinesTo(double* points, const int& count)
{
m_pSimpleGraphicsConverter->PathCommandLinesTo(points, count);
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandCurveTo(const double& x1, const double& y1, const double& x2, const double& y2, const double& x3, const double& y3)
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
CurveTo(x1, y1, x2, y2, x3, y3);
}
else
{
m_pSimpleGraphicsConverter->PathCommandCurveTo(x1, y1, x2, y2, x3, y3);
}
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandCurvesTo(double* points, const int& count)
{
m_pSimpleGraphicsConverter->PathCommandCurvesTo(points, count);
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandArcTo(const double& x, const double& y, const double& w, const double& h, const double& startAngle, const double& sweepAngle)
{
m_pSimpleGraphicsConverter->PathCommandArcTo(x, y, w, h, startAngle, sweepAngle);
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandClose()
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
Close();
}
else
{
m_pSimpleGraphicsConverter->PathCommandClose();
}
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandEnd()
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
End();
}
else
{
m_pSimpleGraphicsConverter->PathCommandEnd();
}
return S_OK;
}
HRESULT PPT::CShapeWriter::DrawPath(const LONG& nType)
{
bool bIsStroke = ((0x01 == (nType & 0x01)) && (0 != m_oPen.Alpha));
bool bIsFill = ((0xFF < nType) && (0 != m_oBrush.Alpha1));
if (bIsStroke && bIsFill)
{
m_oWriterVML.WriteString(L"<a:path w=\"43200\" h=\"43200\">");
m_oWriterVML.Write(m_oWriterPath);
m_oWriterVML.WriteString(std::wstring(L"</a:path>"));
}
else if (bIsStroke)
{
m_oWriterVML.WriteString(L"<a:path w=\"43200\" h=\"43200\" fill=\"none\">");
m_oWriterVML.Write(m_oWriterPath);
m_oWriterVML.WriteString(std::wstring(L"</a:path>"));
}
else if (bIsFill)
{
m_oWriterVML.WriteString(L"<a:path w=\"43200\" h=\"43200\" stroke=\"0\">");
m_oWriterVML.Write(m_oWriterPath);
m_oWriterVML.WriteString(std::wstring(L"</a:path>"));
}
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandStart()
{
if (c_nSimpleGraphicType == m_lCurrentCommandType)
{
Start();
}
else
{
m_pSimpleGraphicsConverter->PathCommandEnd();
m_pSimpleGraphicsConverter->PathCommandStart();
}
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandGetCurrentPoint(double* fX, double* fY)
{
m_pSimpleGraphicsConverter->PathCommandGetCurrentPoint(fX, fY);
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandText(const std::wstring& bsText, const double& x, const double& y, const double& w, const double& h)
{
_SetFont();
m_pSimpleGraphicsConverter->PathCommandText(bsText, m_pFontManager, x, y, w, h, 0);
return S_OK;
}
HRESULT PPT::CShapeWriter::PathCommandTextEx(const std::wstring& bsUnicodeText, const unsigned int* pGids, const unsigned int nGidsCount, const double& x, const double& y, const double& w, const double& h)
{
bool bGid = m_oFont.StringGID;
//TODOO
//if (NULL != bsGidText)
//{
// m_oFont.StringGID = true;
// PathCommandText(bsUnicodeText, x, y, w, h, baselineOffset);
//}
m_oFont.StringGID = false;
PathCommandText(bsUnicodeText, x, y, w, h);
m_oFont.StringGID = bGid;
return S_OK;
}
//-------- Функции для вывода изображений ---------------------------------------------------
HRESULT PPT::CShapeWriter::DrawImage(IGrObject* pImage, const double& x, const double& y, const double& w, const double& h)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::DrawImageFromFile(const std::wstring&, const double& x, const double& y, const double& w, const double& h, const BYTE& lAlpha)
{
return S_OK;
}
// transform --------------------------------------------------------------------------------
HRESULT PPT::CShapeWriter::GetCommandParams(double* dAngle, double* dLeft, double* dTop, double* dWidth, double* dHeight, _UINT32* lFlags)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::SetCommandParams(double dAngle, double dLeft, double dTop, double dWidth, double dHeight, _UINT32 lFlags)
{
if ((dWidth <= 1) || (dHeight <= 1))
lFlags = 0;
bool bFlipX = (0 != (c_nParamFlipX & lFlags));
bool bFlipY = (0 != (c_nParamFlipY & lFlags));
double m11 = bFlipX ? -1.0 : 1.0;
double m22 = bFlipY ? -1.0 : 1.0;
Aggplus::CMatrix oMatrix(1, 0, 0, 1, 0, 0);
if ((0 != dAngle) || (0 != lFlags))
{
double dCentreX = (dLeft + dWidth / 2.0);
double dCentreY = (dTop + dHeight / 2.0);
oMatrix.Translate(-dCentreX, -dCentreY , Aggplus::MatrixOrderAppend);
oMatrix.Rotate(dAngle , Aggplus::MatrixOrderAppend);
oMatrix.Scale(m11, m22 , Aggplus::MatrixOrderAppend);
oMatrix.Translate(dCentreX, dCentreY , Aggplus::MatrixOrderAppend);
}
m_oTransform = oMatrix;
CalculateFullTransform();
return S_OK;
}
HRESULT PPT::CShapeWriter::SetTransform(const double& m1, const double& m2, const double& m3, const double& m4, const double& m5, const double& m6)
{
Aggplus::CMatrix oTrans(m1, m2, m3, m4, m5, m6);
m_oTransform = oTrans;
CalculateFullTransform();
return S_OK;
}
HRESULT PPT::CShapeWriter::GetTransform(double *pdA, double *pdB, double *pdC, double *pdD, double *pdE, double *pdF)
{
return S_OK;
}
HRESULT PPT::CShapeWriter::ResetTransform(void)
{
m_oTransform.Reset();
CalculateFullTransform();
return S_OK;
}
// -----------------------------------------------------------------------------------------
HRESULT PPT::CShapeWriter::get_ClipMode(LONG* plMode)
{
*plMode = m_lClipMode;
return S_OK;
}
HRESULT PPT::CShapeWriter::put_ClipMode(const LONG& lMode)
{
m_lClipMode = lMode;
return S_OK;
}
Reference in New Issue View Git Blame Copy Permalink