pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-07-11 07:23:34 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
feature/libxml2
core/MsBinaryFile/PptFile/PPTXWriter/ShapeWriter.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

3043 lines
105 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 "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)
{// duplication of CTextPFRun and CTextCFRun with ShapeWriter - todo - extract separately
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)) // background for image with transparency
{
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=\"");
{
double val = 360 - brush.LinearAngle;
val += 90;
if (val < 0) val += 360;
if (val >= 360) val -= 360;
std::wstring str = std::to_wstring((int)(val * 60000));
brush_writer.WriteString(str);
}
brush_writer.WriteString(L"\"");
//brush_writer.WriteString(L" scaled = \"1\"");
brush_writer.WriteString(L"/>");
brush_writer.WriteString(L"</a:gradFill>");
}
else if(brush.Type == c_BrushTypePattern)
{// types don't exist in ppt - pattern-image is used instead
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())
{// sometimes various junk is saved
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>"));// modifiers
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; // "magic"
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)
{// order is important - line, fill, shadow !!!
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 only
// 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 - link to file on disk
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;
}
//-------- Functions for working with page --------------------------------------------------
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;
}
//-------- Functions for text output --------------------------------------------------------
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;
}
//-------- Command markers ---------------------------------------------------------------
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;
}
//-------- Functions for working with 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;
}
//-------- Functions for image output ---------------------------------------------------
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