pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-07-14 17:26:41 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
e1acff706f4bfe42a41fb7eabd86c6aac1754e95
core/MsBinaryFile/PptFile/Drawing/Elements.cpp
Ivan Morozov b0fe9d0c5b Added .cpp files for all files
2022-11-28 18:49:17 +03:00

915 lines
36 KiB
C++
Raw Blame History

/*
* (c) Copyright Ascensio System SIA 2010-2019
*
* 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-12 Ernesta Birznieka-Upisha
* 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 "Slide.h"
#ifndef DISABLE_FILE_DOWNLOADER
#include "../../../Common/Network/FileTransporter/include/FileTransporter.h"
#include "../../../DesktopEditor/raster/ImageFileFormatChecker.h"
#endif
CImageElement::CImageElement() : CElement()
{
m_etType = etPicture;
m_nAlpha = 0xFF;
m_bCropEnabled = false;
m_lcropFromRight = 0;
m_lcropFromLeft = 0;
m_lcropFromTop = 0;
m_lcropFromBottom = 0;
m_lpictureContrast = 0x10000;
m_lpictureBrightness = 0;
m_bStretch = true;
m_bTile = false;
m_bOLE = false;
m_bImagePresent = false;
}
CImageElement::~CImageElement()
{
}
CElementPtr CImageElement::CreateDublicate()
{
CImageElement* pImageElement = new CImageElement();
CElementPtr pElement = CElementPtr( pImageElement );
SetProperiesToDublicate(pElement);
pImageElement->m_strImageFileName = m_strImageFileName;
pImageElement->m_nAlpha = m_nAlpha;
pImageElement->m_bCropEnabled = m_bCropEnabled;
pImageElement->m_lcropFromRight = m_lcropFromRight;
pImageElement->m_lcropFromLeft = m_lcropFromLeft;
pImageElement->m_lcropFromTop = m_lcropFromTop;
pImageElement->m_lcropFromBottom = m_lcropFromBottom;
pImageElement->m_bStretch = m_bStretch;
pImageElement->m_bTile = m_bTile;
pImageElement->m_bImagePresent = m_bImagePresent;
pImageElement->m_bOLE = m_bOLE;
return pElement;
}
std::wstring CImageElement::ConvertPPTShapeToPPTX(bool bIsNamespace)
{
NSGuidesVML::CFormParam pParamCoef;
pParamCoef.m_eType = ptValue;
pParamCoef.m_lParam = 65536;
pParamCoef.m_lCoef = 65536;
return ConvertPPTtoPPTX(/*pPPTShape,*/ pParamCoef, bIsNamespace);
}
std::wstring CImageElement::ConvertPPTtoPPTX(const CFormParam &pCoef, bool bIsNamespace)
{
if (bIsNamespace)
{
return _T("<a:prstGeom xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" prst=\"rect\"><a:avLst/></a:prstGeom>");
}
return _T("<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom>");
std::wstring strXmlPPTX = bIsNamespace ? _T("<a:custGeom xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">") : _T("<a:custGeom>");
strXmlPPTX += _T("</a:custGeom>");
return strXmlPPTX;
}
std::wstring PPT_FORMAT::CImageElement::DownloadImage(const std::wstring& strFile)
{
#ifndef DISABLE_FILE_DOWNLOADER
NSNetwork::NSFileTransport::CFileDownloader oDownloader(strFile, true);
if ( oDownloader.DownloadSync() )
{
m_strImageFileName = oDownloader.GetFilePath();
CImageFileFormatChecker checker;
if (false == checker.isImageFile(m_strImageFileName))
{
m_strImageFileName.clear();
}
}
#endif
return m_strImageFileName;
}
void PPT_FORMAT::CShapeElement::CalculateColor(CColor& oColor, CSlide* pSlide, CTheme* pTheme, CLayout* pLayout)
{
LONG lOldIndex = oColor.m_lSchemeIndex;
if (-1 == oColor.m_lSchemeIndex)
return;
std::vector<CColor>* pArray = NULL;
if (pTheme) pArray = &pTheme->m_arColorScheme;
if ((NULL != pLayout) && (!pLayout->m_bUseThemeColorScheme))
pArray = &pLayout->m_arColorScheme;
if (NULL != pSlide)
{
if (!pSlide->m_bUseLayoutColorScheme)
pArray = &pSlide->m_arColorScheme;
}
if ((0 > oColor.m_lSchemeIndex) || ((pArray) && (oColor.m_lSchemeIndex >= (LONG)pArray->size())))
return;
if (pArray)
{
oColor = pArray->at(oColor.m_lSchemeIndex);
}
oColor.m_lSchemeIndex = lOldIndex;
}
std::wstring CShapeElement::ConvertPPTShapeToPPTX(bool bIsNamespace)
{
CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(m_pShape->getBaseShape().get());
if (NULL == pPPTShape)
{
// такого быть не может
return _T("");
}
NSGuidesVML::CFormParam pParamCoef;
pParamCoef.m_eType = ptValue;
pParamCoef.m_lParam = 65536;
pParamCoef.m_lCoef = 65536;
return ConvertPPTtoPPTX(pPPTShape, pParamCoef, bIsNamespace);
}
#ifndef OPTIMIZE_COMPILE_CONVERT_PPT_TO_PPTX
std::wstring CShapeElement::ConvertPPTtoPPTX(CPPTShape* pPPTShape, const NSGuidesVML::CFormParam& pCoef, bool bIsNamespace = false)
{
if (pPPTShape->m_eType == PPTShapes::sptCRect)
{
if (bIsNamespace)
{
return _T("<a:prstGeom xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" prst=\"rect\"><a:avLst/></a:prstGeom>");
}
return _T("<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom>");
}
std::wstring strXmlPPTX = bIsNamespace ? _T("<a:custGeom xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">") : _T("<a:custGeom>");
CFormulaConverter pFormulaConverter;
//coeff
pFormulaConverter.ConvertCoef ( pCoef );
//guids----------------------------------------
int nGuidCount = pPPTShape->m_oManager.m_arFormulas.size();
if (0 != nGuidCount)
{
pFormulaConverter.ConvertFormula ( pPPTShape->m_oManager.m_arFormulas);
}
//path------------------------------------------
int nPathCount = pPPTShape->m_strPath.GetLength();
if (0 != nPathCount && pPPTShape->m_eType != 1)
{
pFormulaConverter.ConvertPath (pPPTShape->m_strPath, pPPTShape->m_oPath);
//string rect
int nRectCount = (int)pPPTShape->m_arStringTextRects.GetCount();
if (0 != nRectCount)
{
pFormulaConverter.ConvertTextRect ( pPPTShape->m_arStringTextRects[0] );
}
int nHandlesCount = pPPTShape->m_arHandles.size();
int nAdjCount = pPPTShape->m_arAdjustments.size();
//handles
if (0 != nHandlesCount || 0 != nAdjCount)
{
pFormulaConverter.ConvertHandle (pPPTShape->m_arHandles, pPPTShape->m_arAdjustments, pPPTShape->m_eType);
}
pFormulaConverter.strGuidsRes = pFormulaConverter.strCoef + pFormulaConverter.strGuidsRes;
//adj----------------------------
if (pFormulaConverter.strAdjRes.GetLength() == 0)
strXmlPPTX += _T("<a:avLst/>");
else
strXmlPPTX += _T("<a:avLst>") + pFormulaConverter.strAdjRes + _T("</a:avLst>");
//guids--------------------------
if (pFormulaConverter.strGuidsRes.GetLength() == 0)
strXmlPPTX += _T("<a:gdLst/>");
else
strXmlPPTX += _T("<a:gdLst>") + pFormulaConverter.strGuidsRes + _T("</a:gdLst>");
//handles---------------------------
if (pFormulaConverter.strHandleRes.GetLength() == 0)
strXmlPPTX += _T("<a:ahLst/>");
else
strXmlPPTX += _T("<a:ahLst>") + pFormulaConverter.strHandleRes + _T("</a:ahLst>");
//connectors-------------------------
strXmlPPTX += _T("<a:cxnLst/>");
//textRect---------------------------
if (pFormulaConverter.strTextRect.GetLength() != 0)
strXmlPPTX += pFormulaConverter.strTextRect;
//path------------------------------
strXmlPPTX += _T("<a:pathLst>");
strXmlPPTX += pFormulaConverter.strPathRes;
strXmlPPTX += _T("</a:pathLst>");
}
strXmlPPTX += _T("</a:custGeom>");
return strXmlPPTX;
}
#else
std::wstring CShapeElement::ConvertPPTtoPPTX(CPPTShape *pPPTShape, const CFormParam &pCoef, bool bIsNamespace)
{
if (pPPTShape->m_eType == PPTShapes::sptCRect || pPPTShape->m_eType == PPTShapes::sptCFrame || pPPTShape->m_eType == PPTShapes::sptCTextBox)
{
if (bIsNamespace)
{
return _T("<a:prstGeom xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" prst=\"rect\"><a:avLst/></a:prstGeom>");
}
return _T("<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom>");
}
else if (pPPTShape->m_eType == PPTShapes::sptCLine)
{
if (bIsNamespace)
{
return _T("<a:prstGeom xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" prst=\"line\"><a:avLst/></a:prstGeom>");
}
return _T("<a:prstGeom prst=\"line\"><a:avLst/></a:prstGeom>");
}
else if (pPPTShape->m_eType == PPTShapes::sptCEllipse)
{
if (bIsNamespace)
{
return _T("<a:prstGeom xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" prst=\"ellipse\"><a:avLst/></a:prstGeom>");
}
return _T("<a:prstGeom prst=\"ellipse\"><a:avLst/></a:prstGeom>");
}
std::wstring strXmlPPTX = bIsNamespace ? _T("<a:custGeom xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">") : _T("<a:custGeom>");
CFormulaConverter pFormulaConverter;
//coeff
pFormulaConverter.ConvertCoef(pCoef);
//guids----------------------------------------
int nGuidCount = (int)pPPTShape->m_oManager.m_arFormulas.size();
if (0 != nGuidCount)
{
pFormulaConverter.ConvertFormula(pPPTShape->m_oManager.m_arFormulas);
}
//path------------------------------------------
int nPathCount = (int)pPPTShape->m_strPath.length();
if (0 != nPathCount && pPPTShape->m_eType != 1)
{
pFormulaConverter.ConvertPath(pPPTShape->m_strPath, pPPTShape->m_oPath);
//string rect
int nRectCount = (int)pPPTShape->m_arStringTextRects.size();
if (0 != nRectCount && !pPPTShape->m_arStringTextRects[0].empty())
{
if (pPPTShape->m_eType == PPTShapes::sptCNotchedCircularArrow)
{
pFormulaConverter.SetTextRectDefault();
}
else
{
pFormulaConverter.ConvertTextRect(pPPTShape->m_arStringTextRects[0]);
}
}
int nHandlesCount = (int)pPPTShape->m_arHandles.size();
int nAdjCount = (int)pPPTShape->m_arAdjustments.size();
//handles
if (0 != nHandlesCount || 0 != nAdjCount)
{
pFormulaConverter.ConvertHandle(pPPTShape->m_arHandles, pPPTShape->m_arAdjustments, pPPTShape->m_eType);
}
//adj----------------------------
if (pFormulaConverter.m_oAdjRes.GetSize() == 0)
strXmlPPTX += _T("<a:avLst/>");
else
strXmlPPTX += _T("<a:avLst>") + pFormulaConverter.m_oAdjRes.GetXmlString() + _T("</a:avLst>");
//guids--------------------------
if (pFormulaConverter.m_oGuidsRes.GetSize() == 0)
strXmlPPTX += _T("<a:gdLst>") + pFormulaConverter.m_oCoef.GetXmlString() + _T("</a:gdLst>");
else
strXmlPPTX += _T("<a:gdLst>") + pFormulaConverter.m_oCoef.GetXmlString() + pFormulaConverter.m_oGuidsRes.GetXmlString() + _T("</a:gdLst>");
//handles---------------------------
if (pFormulaConverter.m_oHandleRes.GetSize() == 0)
strXmlPPTX += _T("<a:ahLst/>");
else
strXmlPPTX += _T("<a:ahLst>") + pFormulaConverter.m_oHandleRes.GetXmlString() + _T("</a:ahLst>");
//connectors-------------------------
strXmlPPTX += _T("<a:cxnLst/>");
//textRect---------------------------
if (pFormulaConverter.m_oTextRect.GetSize() != 0)
strXmlPPTX += pFormulaConverter.m_oTextRect.GetXmlString();
//path------------------------------
strXmlPPTX += _T("<a:pathLst>");
strXmlPPTX += pFormulaConverter.m_oPathRes.GetXmlString();
strXmlPPTX += _T("</a:pathLst>");
}
else
{
return _T("<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom>");
}
strXmlPPTX += _T("</a:custGeom>");
return strXmlPPTX;
}
#endif
void PPT_FORMAT::CShapeElement::SetupTextProperties(CSlide* pSlide, CTheme* pTheme, CLayout* pLayout)
{
PPT_FORMAT::CTextAttributesEx* pAttributes = &m_pShape->m_oText;
int nCountColors = 0;
if (NULL != pTheme)
nCountColors = (int)pTheme->m_arColorScheme.size();
size_t nCount = pAttributes->m_arParagraphs.size();
for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
{
if (pAttributes->m_arParagraphs[nIndex].m_oPFRun.bulletColor.is_init())
{
int nColorIndex = (int)pAttributes->m_arParagraphs[nIndex].m_oPFRun.bulletColor->m_lSchemeIndex;
if (0 <= nColorIndex && nColorIndex < nCountColors)
{
CalculateColor(pAttributes->m_arParagraphs[nIndex].m_oPFRun.bulletColor.get(), pSlide, pTheme, pLayout);
pAttributes->m_arParagraphs[nIndex].m_oPFRun.bulletColor->m_lSchemeIndex = nColorIndex;
}
}
size_t nCountCFs = pAttributes->m_arParagraphs[nIndex].m_arSpans.size();
for (size_t i = 0; i < nCountCFs; ++i)
{
CTextCFRun* pRun = &pAttributes->m_arParagraphs[nIndex].m_arSpans[i].m_oRun;
if (pRun->Color.is_init())
{
int nColorIndex = (int)pRun->Color->m_lSchemeIndex;
if (0 <= nColorIndex && nColorIndex < nCountColors)
{
CalculateColor(pRun->Color.get(), pSlide, pTheme, pLayout);
pRun->Color->m_lSchemeIndex = nColorIndex;
}
}
if (NULL != pTheme)
{
if ((pRun->fontRef.is_init()) && (pRun->fontRef.get() < pTheme->m_arFonts.size()))
{
pRun->font.font = new CFontProperty(pTheme->m_arFonts[pRun->fontRef.get()]);
//if (1 < pRun->fontRef.get())
// pRun->fontRef.reset();
}
if ((pRun->ansiFontRef.is_init()) && (pRun->ansiFontRef.get() < pTheme->m_arFonts.size()))
{
pRun->font.ansi = new CFontProperty(pTheme->m_arFonts[pRun->ansiFontRef.get()]);
}
if ((pRun->eaFontRef.is_init()) && (pRun->eaFontRef.get() < pTheme->m_arFonts.size()))
{
pRun->font.ea = new CFontProperty(pTheme->m_arFonts[pRun->eaFontRef.get()]);
}
if ((pRun->symbolFontRef.is_init()) && (pRun->symbolFontRef.get() < pTheme->m_arFonts.size()))
{
pRun->font.sym = new CFontProperty(pTheme->m_arFonts[pRun->symbolFontRef.get()]);
}
}
}
}
}
CShapeElement::CShapeElement(ClassType ClassType, int eType) : CElement()
{
m_lShapeType = eType;
m_ClassType = ClassType;
m_etType = etShape;
m_pShape = CShapePtr( new CShape(ClassType, eType));
m_pShape->m_rcBounds = m_bChildAnchorEnabled ? m_rcChildAnchor : m_rcAnchor;
m_pShape->m_dStartTime = m_dStartTime;
m_pShape->m_dEndTime = m_dEndTime;
m_bShapePreset = false;
}
CShapeElement::CShapeElement() : CElement()
{
m_lShapeType = 0x1000;
m_etType = etShape;
m_bShapePreset = false;
m_pShape = CShapePtr( new CShape(NSBaseShape::unknown, 0x1000));
}
CShapeElement::CShapeElement(const std::wstring &str) : CElement()
{
m_lShapeType = 0x1000;
m_bShapePreset = false;
m_pShape = CShapePtr( new CShape(NSBaseShape::unknown, 0x1000));
m_pShape->LoadFromXML(str);
m_ClassType = m_pShape->getBaseShape()->GetClassType();
}
CShapeElement::~CShapeElement()
{
}
CElementPtr CShapeElement::CreateDublicate()
{
CShapeElement* pShapeElement = new CShapeElement(m_ClassType, m_lShapeType);
CElementPtr pElement = CElementPtr( pShapeElement );
SetProperiesToDublicate(pElement);
pShapeElement->m_lShapeType = m_lShapeType;
pShapeElement->m_bShapePreset = m_bShapePreset;
m_pShape->SetToDublicate(pShapeElement->m_pShape.get());
return pElement;
}
bool PPT_FORMAT::CShapeElement::SetUpTextPlaceholder(std::wstring newText)
{
bool result = false;
PPT_FORMAT::CTextAttributesEx* pText = &m_pShape->m_oText;
for (size_t p = 0 ; p < pText->m_arParagraphs.size(); p++) //тут по всем -> 1-(33).ppt
{
if (pText->m_arParagraphs[p].m_arSpans.size() >0)//??? по всем?
{
int pos = (int)pText->m_arParagraphs[p].m_arSpans[0].m_strText.find(L"*");
if (pos >= 0)
{
CSpan first = pText->m_arParagraphs[p].m_arSpans[0];
CSpan last = pText->m_arParagraphs[p].m_arSpans[0];
first.m_strText = pText->m_arParagraphs[p].m_arSpans[0].m_strText.substr(0, pos);
last.m_strText = pText->m_arParagraphs[p].m_arSpans[0].m_strText.substr(pos + 1);
pText->m_arParagraphs[p].m_arSpans[0].m_strText = newText;
pText->m_arParagraphs[p].m_arSpans[0].m_bField = true;
if (last.m_strText.empty() == false)
pText->m_arParagraphs[p].m_arSpans.insert(pText->m_arParagraphs[p].m_arSpans.begin() + 1, last);
if (first.m_strText.empty() == false)
pText->m_arParagraphs[p].m_arSpans.insert(pText->m_arParagraphs[p].m_arSpans.begin(), first);
result = true;
}
}
}
return result;
}
void CShapeElement::SetupProperties(CSlide *pSlide, CTheme *pTheme, CLayout *pLayout)
{
m_pShape->m_oText.m_lPlaceholderType = m_lPlaceholderType;
m_pShape->m_oText.m_lPlaceholderID = m_lPlaceholderID;
m_pShape->getBaseShape()->ReCalculate();
SetupTextProperties(pSlide, pTheme, pLayout);
CalculateColor(m_oPen.Color , pSlide, pTheme, pLayout);
CalculateColor(m_oBrush.Color1 , pSlide, pTheme, pLayout);
CalculateColor(m_oBrush.Color2 , pSlide, pTheme, pLayout);
}
OOXMLShapes::ShapeType PPTX2EditorAdvanced::GetShapeTypeFromStr(const std::wstring &str)//const
{
if(str == _T(""))
return OOXMLShapes::sptNil;
switch((CHAR)str[0])
{
case 'a':
if (str == _T("accentBorderCallout1")) return OOXMLShapes::sptCAccentBorderCallout1;
if (str == _T("accentBorderCallout2")) return OOXMLShapes::sptCAccentBorderCallout2;
if (str == _T("accentBorderCallout3")) return OOXMLShapes::sptCAccentBorderCallout3;
if (str == _T("accentCallout1")) return OOXMLShapes::sptCAccentCallout1;
if (str == _T("accentCallout2")) return OOXMLShapes::sptCAccentCallout2;
if (str == _T("accentCallout3")) return OOXMLShapes::sptCAccentCallout3;
if (str == _T("actionButtonBackPrevious")) return OOXMLShapes::sptCActionButtonBackPrevious;
if (str == _T("actionButtonBeginning")) return OOXMLShapes::sptCActionButtonBeginning;
if (str == _T("actionButtonBlank")) return OOXMLShapes::sptCActionButtonBlank;
if (str == _T("actionButtonDocument")) return OOXMLShapes::sptCActionButtonDocument;
if (str == _T("actionButtonEnd")) return OOXMLShapes::sptCActionButtonEnd;
if (str == _T("actionButtonForwardNext")) return OOXMLShapes::sptCActionButtonForwardNext;
if (str == _T("actionButtonHelp")) return OOXMLShapes::sptCActionButtonHelp;
if (str == _T("actionButtonHome")) return OOXMLShapes::sptCActionButtonHome;
if (str == _T("actionButtonInformation")) return OOXMLShapes::sptCActionButtonInformation;
if (str == _T("actionButtonMovie")) return OOXMLShapes::sptCActionButtonMovie;
if (str == _T("actionButtonReturn")) return OOXMLShapes::sptCActionButtonReturn;
if (str == _T("actionButtonSound")) return OOXMLShapes::sptCActionButtonSound;
if (str == _T("arc")) return OOXMLShapes::sptCArc;
break;
case 'b':
if (str == _T("bentArrow")) return OOXMLShapes::sptCBentArrow;
if (str == _T("bentConnector2")) return OOXMLShapes::sptCBentConnector2;
if (str == _T("bentConnector3")) return OOXMLShapes::sptCBentConnector3;
if (str == _T("bentConnector4")) return OOXMLShapes::sptCBentConnector4;
if (str == _T("bentConnector5")) return OOXMLShapes::sptCBentConnector5;
if (str == _T("bentUpArrow")) return OOXMLShapes::sptCBentUpArrow;
if (str == _T("bevel")) return OOXMLShapes::sptCBevel;
if (str == _T("blockArc")) return OOXMLShapes::sptCBlockArc;
if (str == _T("borderCallout1")) return OOXMLShapes::sptCBorderCallout1;
if (str == _T("borderCallout2")) return OOXMLShapes::sptCBorderCallout2;
if (str == _T("borderCallout3")) return OOXMLShapes::sptCBorderCallout3;
if (str == _T("bracePair")) return OOXMLShapes::sptCBracePair;
if (str == _T("bracketPair")) return OOXMLShapes::sptCBracketPair;
break;
case 'c':
if (str == _T("callout1")) return OOXMLShapes::sptCCallout1;
if (str == _T("callout2")) return OOXMLShapes::sptCCallout2;
if (str == _T("callout3")) return OOXMLShapes::sptCCallout3;
if (str == _T("can")) return OOXMLShapes::sptCCan;
if (str == _T("chartPlus")) return OOXMLShapes::sptCChartPlus;
if (str == _T("chartStar")) return OOXMLShapes::sptCChartStar;
if (str == _T("chartX")) return OOXMLShapes::sptCChartX;
if (str == _T("chevron")) return OOXMLShapes::sptCChevron;
if (str == _T("chord")) return OOXMLShapes::sptCChord;
if (str == _T("circularArrow")) return OOXMLShapes::sptCCircularArrow;
if (str == _T("cloud")) return OOXMLShapes::sptCCloud;
if (str == _T("cloudCallout")) return OOXMLShapes::sptCCloudCallout;
if (str == _T("corner")) return OOXMLShapes::sptCCorner;
if (str == _T("cornerTabs")) return OOXMLShapes::sptCCornerTabs;
if (str == _T("cube")) return OOXMLShapes::sptCCube;
if (str == _T("curvedConnector2")) return OOXMLShapes::sptCCurvedConnector2;
if (str == _T("curvedConnector3")) return OOXMLShapes::sptCCurvedConnector3;
if (str == _T("curvedConnector4")) return OOXMLShapes::sptCCurvedConnector4;
if (str == _T("curvedConnector5")) return OOXMLShapes::sptCCurvedConnector5;
if (str == _T("curvedDownArrow")) return OOXMLShapes::sptCCurvedDownArrow;
if (str == _T("curvedLeftArrow")) return OOXMLShapes::sptCCurvedLeftArrow;
if (str == _T("curvedRightArrow")) return OOXMLShapes::sptCCurvedRightArrow;
if (str == _T("curvedUpArrow")) return OOXMLShapes::sptCCurvedUpArrow;
break;
case 'd':
if (str == _T("decagon")) return OOXMLShapes::sptCDecagon;
if (str == _T("diagStripe")) return OOXMLShapes::sptCDiagStripe;
if (str == _T("diamond")) return OOXMLShapes::sptCDiamond;
if (str == _T("dodecagon")) return OOXMLShapes::sptCDodecagon;
if (str == _T("donut")) return OOXMLShapes::sptCDonut;
if (str == _T("doubleWave")) return OOXMLShapes::sptCDoubleWave;
if (str == _T("downArrow")) return OOXMLShapes::sptCDownArrow;
if (str == _T("downArrowCallout")) return OOXMLShapes::sptCDownArrowCallout;
break;
case 'e':
if (str == _T("ellipse")) return OOXMLShapes::sptCEllipse;
if (str == _T("ellipseRibbon")) return OOXMLShapes::sptCEllipseRibbon;
if (str == _T("ellipseRibbon2")) return OOXMLShapes::sptCEllipseRibbon2;
break;
case 'f':
if (str == _T("flowChartAlternateProcess")) return OOXMLShapes::sptCFlowChartAlternateProcess;
if (str == _T("flowChartCollate")) return OOXMLShapes::sptCFlowChartCollate;
if (str == _T("flowChartConnector")) return OOXMLShapes::sptCFlowChartConnector;
if (str == _T("flowChartDecision")) return OOXMLShapes::sptCFlowChartDecision;
if (str == _T("flowChartDelay")) return OOXMLShapes::sptCFlowChartDelay;
if (str == _T("flowChartDisplay")) return OOXMLShapes::sptCFlowChartDisplay;
if (str == _T("flowChartDocument")) return OOXMLShapes::sptCFlowChartDocument;
if (str == _T("flowChartExtract")) return OOXMLShapes::sptCFlowChartExtract;
if (str == _T("flowChartInputOutput")) return OOXMLShapes::sptCFlowChartInputOutput;
if (str == _T("flowChartInternalStorage")) return OOXMLShapes::sptCFlowChartInternalStorage;
if (str == _T("flowChartMagneticDisk")) return OOXMLShapes::sptCFlowChartMagneticDisk;
if (str == _T("flowChartMagneticDrum")) return OOXMLShapes::sptCFlowChartMagneticDrum;
if (str == _T("flowChartMagneticTape")) return OOXMLShapes::sptCFlowChartMagneticTape;
if (str == _T("flowChartManualInput")) return OOXMLShapes::sptCFlowChartManualInput;
if (str == _T("flowChartManualOperation")) return OOXMLShapes::sptCFlowChartManualOperation;
if (str == _T("flowChartMerge")) return OOXMLShapes::sptCFlowChartMerge;
if (str == _T("flowChartMultidocument")) return OOXMLShapes::sptCFlowChartMultidocument;
if (str == _T("flowChartOfflineStorage")) return OOXMLShapes::sptCFlowChartOfflineStorage;
if (str == _T("flowChartOffpageConnector")) return OOXMLShapes::sptCFlowChartOffpageConnector;
if (str == _T("flowChartOnlineStorage")) return OOXMLShapes::sptCFlowChartOnlineStorage;
if (str == _T("flowChartOr")) return OOXMLShapes::sptCFlowChartOr;
if (str == _T("flowChartPredefinedProcess")) return OOXMLShapes::sptCFlowChartPredefinedProcess;
if (str == _T("flowChartPreparation")) return OOXMLShapes::sptCFlowChartPreparation;
if (str == _T("flowChartProcess")) return OOXMLShapes::sptCFlowChartProcess;
if (str == _T("flowChartPunchedCard")) return OOXMLShapes::sptCFlowChartPunchedCard;
if (str == _T("flowChartPunchedTape")) return OOXMLShapes::sptCFlowChartPunchedTape;
if (str == _T("flowChartSort")) return OOXMLShapes::sptCFlowChartSort;
if (str == _T("flowChartSummingJunction")) return OOXMLShapes::sptCFlowChartSummingJunction;
if (str == _T("flowChartTerminator")) return OOXMLShapes::sptCFlowChartTerminator;
if (str == _T("foldedCorner")) return OOXMLShapes::sptCFoldedCorner;
if (str == _T("frame")) return OOXMLShapes::sptCFrame;
if (str == _T("funnel")) return OOXMLShapes::sptCFunnel;
break;
case 'g':
if (str == _T("gear6")) return OOXMLShapes::sptCGear6;
if (str == _T("gear9")) return OOXMLShapes::sptCGear9;
break;
case 'h':
if (str == _T("halfFrame")) return OOXMLShapes::sptCHalfFrame;
if (str == _T("heart")) return OOXMLShapes::sptCHeart;
if (str == _T("heptagon")) return OOXMLShapes::sptCHeptagon;
if (str == _T("hexagon")) return OOXMLShapes::sptCHexagon;
if (str == _T("homePlate")) return OOXMLShapes::sptCHomePlate;
if (str == _T("horizontalScroll")) return OOXMLShapes::sptCHorizontalScroll;
break;
case 'i':
if (str == _T("irregularSeal1")) return OOXMLShapes::sptCIrregularSeal1;
if (str == _T("irregularSeal2")) return OOXMLShapes::sptCIrregularSeal2;
break;
case 'l':
if (str == _T("leftArrow")) return OOXMLShapes::sptCLeftArrow;
if (str == _T("leftArrowCallout")) return OOXMLShapes::sptCLeftArrowCallout;
if (str == _T("leftBrace")) return OOXMLShapes::sptCLeftBrace;
if (str == _T("leftBracket")) return OOXMLShapes::sptCLeftBracket;
if (str == _T("leftCircularArrow")) return OOXMLShapes::sptCLeftCircularArrow;
if (str == _T("leftRightArrow")) return OOXMLShapes::sptCLeftRightArrow;
if (str == _T("leftRightArrowCallout")) return OOXMLShapes::sptCLeftRightArrowCallout;
if (str == _T("leftRightCircularArrow")) return OOXMLShapes::sptCLeftRightCircularArrow;
if (str == _T("leftRightRibbon")) return OOXMLShapes::sptCLeftRightRibbon;
if (str == _T("leftRightUpArrow")) return OOXMLShapes::sptCLeftRightUpArrow;
if (str == _T("leftUpArrow")) return OOXMLShapes::sptCLeftUpArrow;
if (str == _T("lightningBolt")) return OOXMLShapes::sptCLightningBolt;
if (str == _T("line")) return OOXMLShapes::sptCLine;
if (str == _T("lineInv")) return OOXMLShapes::sptCLineInv;
break;
case 'm':
if (str == _T("mathDivide")) return OOXMLShapes::sptCMathDivide;
if (str == _T("mathEqual")) return OOXMLShapes::sptCMathEqual;
if (str == _T("mathMinus")) return OOXMLShapes::sptCMathMinus;
if (str == _T("mathMultiply")) return OOXMLShapes::sptCMathMultiply;
if (str == _T("mathNotEqual")) return OOXMLShapes::sptCMathNotEqual;
if (str == _T("mathPlus")) return OOXMLShapes::sptCMathPlus;
if (str == _T("moon")) return OOXMLShapes::sptCMoon;
break;
case 'n':
if (str == _T("nonIsoscelesTrapezoid")) return OOXMLShapes::sptCNonIsoscelesTrapezoid;
if (str == _T("noSmoking")) return OOXMLShapes::sptCNoSmoking;
if (str == _T("notchedRightArrow")) return OOXMLShapes::sptCNotchedRightArrow;
break;
case 'o':
if (str == _T("octagon")) return OOXMLShapes::sptCOctagon;
break;
case 'p':
if (str == _T("parallelogram")) return OOXMLShapes::sptCParallelogram;
if (str == _T("pentagon")) return OOXMLShapes::sptCPentagon;
if (str == _T("pie")) return OOXMLShapes::sptCPie;
if (str == _T("pieWedge")) return OOXMLShapes::sptCPieWedge;
if (str == _T("plaque")) return OOXMLShapes::sptCPlaque;
if (str == _T("plaqueTabs")) return OOXMLShapes::sptCPlaqueTabs;
if (str == _T("plus")) return OOXMLShapes::sptCPlus;
break;
case 'q':
if (str == _T("quadArrow")) return OOXMLShapes::sptCQuadArrow;
if (str == _T("quadArrowCallout")) return OOXMLShapes::sptCQuadArrowCallout;
break;
case 'r':
if (str == _T("rect")) return OOXMLShapes::sptCRect;
if (str == _T("ribbon")) return OOXMLShapes::sptCRibbon;
if (str == _T("ribbon2")) return OOXMLShapes::sptCRibbon2;
if (str == _T("rightArrow")) return OOXMLShapes::sptCRightArrow;
if (str == _T("rightArrowCallout")) return OOXMLShapes::sptCRightArrowCallout;
if (str == _T("rightBrace")) return OOXMLShapes::sptCRightBrace;
if (str == _T("rightBracket")) return OOXMLShapes::sptCRightBracket;
if (str == _T("round1Rect")) return OOXMLShapes::sptCRound1Rect;
if (str == _T("round2DiagRect")) return OOXMLShapes::sptCRound2DiagRect;
if (str == _T("round2SameRect")) return OOXMLShapes::sptCRound2SameRect;
if (str == _T("roundRect")) return OOXMLShapes::sptCRoundRect;
if (str == _T("rtTriangle")) return OOXMLShapes::sptCRtTriangle;
break;
case 's':
if (str == _T("smileyFace")) return OOXMLShapes::sptCSmileyFace;
if (str == _T("snip1Rect")) return OOXMLShapes::sptCSnip1Rect;
if (str == _T("snip2DiagRect")) return OOXMLShapes::sptCSnip2DiagRect;
if (str == _T("snip2SameRect")) return OOXMLShapes::sptCSnip2SameRect;
if (str == _T("snipRoundRect")) return OOXMLShapes::sptCSnipRoundRect;
if (str == _T("squareTabs")) return OOXMLShapes::sptCSquareTabs;
if (str == _T("star10")) return OOXMLShapes::sptCStar10;
if (str == _T("star12")) return OOXMLShapes::sptCStar12;
if (str == _T("star16")) return OOXMLShapes::sptCStar16;
if (str == _T("star24")) return OOXMLShapes::sptCStar24;
if (str == _T("star32")) return OOXMLShapes::sptCStar32;
if (str == _T("star4")) return OOXMLShapes::sptCStar4;
if (str == _T("star5")) return OOXMLShapes::sptCStar5;
if (str == _T("star6")) return OOXMLShapes::sptCStar6;
if (str == _T("star7")) return OOXMLShapes::sptCStar7;
if (str == _T("star8")) return OOXMLShapes::sptCStar8;
if (str == _T("straightConnector1")) return OOXMLShapes::sptCStraightConnector1;
if (str == _T("stripedRightArrow")) return OOXMLShapes::sptCStripedRightArrow;
if (str == _T("sun")) return OOXMLShapes::sptCSun;
if (str == _T("swooshArrow")) return OOXMLShapes::sptCSwooshArrow;
break;
case 't':
if (str == _T("teardrop")) return OOXMLShapes::sptCTeardrop;
if (str == _T("trapezoid")) return OOXMLShapes::sptCTrapezoid;
if (str == _T("triangle")) return OOXMLShapes::sptCTriangle;
break;
case 'u':
if (str == _T("upArrow")) return OOXMLShapes::sptCUpArrow;
if (str == _T("upArrowCallout")) return OOXMLShapes::sptCUpArrowCallout;
if (str == _T("upDownArrow")) return OOXMLShapes::sptCUpDownArrow;
if (str == _T("upDownArrowCallout")) return OOXMLShapes::sptCUpDownArrowCallout;
if (str == _T("uturnArrow")) return OOXMLShapes::sptCUturnArrow;
break;
case 'v':
if (str == _T("verticalScroll")) return OOXMLShapes::sptCVerticalScroll;
break;
case 'w':
if (str == _T("wave")) return OOXMLShapes::sptCWave;
if (str == _T("wedgeEllipseCallout")) return OOXMLShapes::sptCWedgeEllipseCallout;
if (str == _T("wedgeRectCallout")) return OOXMLShapes::sptCWedgeRectCallout;
if (str == _T("wedgeRoundRectCallout")) return OOXMLShapes::sptCWedgeRoundRectCallout;
break;
}
return OOXMLShapes::sptNil;
}
CAudioElement::CAudioElement() : CImageElement()
{
m_etType = etAudio;
m_nAmplify = 100;
m_bWithVideo = false;
m_dAudioDuration = 0.0;
m_bLoop = false;
m_dClipStartTime = 0.0;
m_dClipEndTime = -1.0;
}
CAudioElement::~CAudioElement()
{
}
CElementPtr CAudioElement::CreateDublicate()
{
CAudioElement* pAudioElement = new CAudioElement();
CElementPtr pElement = CElementPtr( pAudioElement );
SetProperiesToDublicate(pElement);
pAudioElement->m_strAudioFileName = m_strAudioFileName;
pAudioElement->m_nAmplify = m_nAmplify;
pAudioElement->m_bWithVideo = m_bWithVideo;
pAudioElement->m_dAudioDuration = m_dAudioDuration;
pAudioElement->m_bLoop = m_bLoop;
pAudioElement->m_dClipStartTime = m_dClipStartTime;
pAudioElement->m_dClipEndTime = m_dClipEndTime;
return pElement;
}
CVideoElement::CVideoElement() : CImageElement()
{
m_etType = etVideo;
m_dVideoDuration = 0.0;
m_nAlpha = 0xFF;
m_dClipStartTime = -1.0;
m_dClipEndTime = -1.0;
m_bLoop = false;
}
CVideoElement::~CVideoElement()
{
}
CElementPtr CVideoElement::CreateDublicate()
{
CVideoElement* pVideoElement = new CVideoElement();
CElementPtr pElement = CElementPtr( pVideoElement );
SetProperiesToDublicate(pElement);
pVideoElement->m_strVideoFileName = m_strVideoFileName;
pVideoElement->m_nAlpha = m_nAlpha;
pVideoElement->m_dVideoDuration = m_dVideoDuration;
pVideoElement->m_dClipStartTime = m_dClipStartTime;
pVideoElement->m_dClipEndTime = m_dClipEndTime;
pVideoElement->m_bLoop = m_bLoop;
return pElement;
}
CGroupElement::CGroupElement() : CElement()
{
m_etType = etGroup;
}
CGroupElement::~CGroupElement()
{
}
CElementPtr CGroupElement::CreateDublicate()
{
CGroupElement* pGroupElement = new CGroupElement();
CElementPtr pElement = CElementPtr( pGroupElement );
SetProperiesToDublicate(pElement);
return pElement;
}
std::wstring CGroupElement::ConvertPPTShapeToPPTX(bool bIsNamespace)
{
return L"";
}
CTableElement::CTableElement() : CElement()
{
m_etType = etTable;
}
CTableElement::~CTableElement()
{
}
CElementPtr CTableElement::CreateDublicate()
{
CTableElement* pTableElement = new CTableElement();
CElementPtr pElement = CElementPtr( pTableElement );
SetProperiesToDublicate(pElement);
return pElement;
}
int CTableElement::GetWidth() const
{
double multip = m_bAnchorEnabled ? 1587.5 : 1;
return round(m_rcAnchor.GetWidth() * multip);
}
int CTableElement::GetHeight() const
{
double multip = m_bAnchorEnabled ? 1587.5 : 1;
return round(m_rcAnchor.GetHeight() * multip);
}
std::wstring CTableElement::ConvertPPTShapeToPPTX(bool bIsNamespace)
{
return L"";
}
Reference in New Issue View Git Blame Copy Permalink