pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-04-07 13:55:33 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
4d5f328c30438917ceec20b288eb03c17507fdff
core/ASCOfficePPTXFile/Editor/Drawing/Elements.h
ElenaSubbotina d9c6759108 OdfFormatWriter - convert smart art in spreadsheets, ...
2017-01-26 19:40:42 +03:00

1182 lines
43 KiB
C++
Raw Blame History

/*
* (c) Copyright Ascensio System SIA 2010-2017
*
* 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 Lubanas st. 125a-25, Riga, Latvia,
* EU, LV-1021.
*
* 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
*
*/
#pragma once
#include "Theme.h"
#include "Shapes/Shape.h"
#ifndef DISABLE_FILE_DOWNLOADER
#include "../../../Common/FileDownloader/FileDownloader.h"
#endif
#ifdef ENABLE_PPT_TO_PPTX_CONVERT
#include "Shapes/BaseShape/PPTShape/ppt2pptxshapeconverter.h"
#endif
#if defined(PPTX_DEF)
namespace PPTX2EditorAdvanced
{
AVSINLINE OOXMLShapes::ShapeType 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;
}
}
#endif
namespace NSPresentationEditor
{
class CImageElement : public IElement
{
public:
std::wstring m_strImageFileName;
BYTE m_nAlpha;
bool m_bCropEnabled;
long m_lcropFromRight;
long m_lcropFromLeft;
long m_lcropFromTop;
long m_lcropFromBottom;
bool m_bStretch;
bool m_bTile;
bool m_bOLE;
bool m_bImagePresent;
std::wstring m_sImageName;
public:
CImageElement() : IElement()
{
m_etType = etPicture;
m_nAlpha = 0xFF;
m_bCropEnabled = false;
m_lcropFromRight = 0;
m_lcropFromLeft = 0;
m_lcropFromTop = 0;
m_lcropFromBottom = 0;
m_bStretch = true;
m_bTile = false;
m_bOLE = false;
m_bImagePresent = false;
}
virtual ~CImageElement()
{
}
virtual void WriteToXml(XmlUtils::CXmlWriter& oWriter)
{
std::wstring strXml = SaveToXML();
oWriter.WriteString(strXml);
}
virtual void ReadFromXml(XmlUtils::CXmlNode& oNode)
{
}
virtual std::wstring SaveToXML()
{
std::wstring strEffect;
// if (!m_oAnimations.m_arAnimations.empty())
// return ToAnimationXml();
// LONG lFlags = 0;
// if (m_bFlipH)
// lFlags |= 0x0001;
// if (m_bFlipV)
// lFlags |= 0x0002;
// strEffect.Format(_T("<ImagePaint-DrawImageFromFile left='%d' top='%d' right='%d' bottom='%d' angle='%lf' flags='%d' filepath='%ls' metric='0' backcolor='-1' scaletype='-1' scalecolor='255' widthmetric='%d' heightmetric='%d'>\
// <timeline type='1' begin='%lf' end='%lf' fadein='0' fadeout='0' completeness='1.0' /></ImagePaint-DrawImageFromFile>"),
// (LONG)m_rcBounds.left, (LONG)m_rcBounds.top, (LONG)m_rcBounds.right, (LONG)m_rcBounds.bottom,
// m_dRotate, lFlags, m_strImageFileName,
// m_oMetric.m_lMillimetresHor, m_oMetric.m_lMillimetresVer,
// m_dStartTime, m_dEndTime);
return strEffect;
}
// std::wstring ToAnimationXml()
// {
// LONG lFlags = 0;
// if (m_bFlipH)
// lFlags |= 0x0001;
// if (m_bFlipV)
// lFlags |= 0x0002;
// std::wstring strEffect = _T("");
// strEffect.Format(_T("<ImagePaint-DrawImageFromFile left='%d' top='%d' right='%d' bottom='%d' angle='%lf' flags='%d' filepath='%ls' metric='0' backcolor='-1' scaletype='-1' scalecolor='255' widthmetric='%d' heightmetric='%d'>\
// <timeline type='1' begin='%lf' end='%lf' fadein='0' fadeout='0' completeness='1.0' /></ImagePaint-DrawImageFromFile>"),
// (LONG)m_rcBounds.left, (LONG)m_rcBounds.top, (LONG)m_rcBounds.right, (LONG)m_rcBounds.bottom,
// m_dRotate, lFlags, m_strImageFileName,
// m_oMetric.m_lMillimetresHor, m_oMetric.m_lMillimetresVer,
// m_dStartTime, m_dEndTime);
// std::wstring TimeLine;
// TimeLine.Format ( _T("<timeline type = \"1\" begin=\"%f\" end=\"%f\" fadein=\"0\" fadeout=\"0\" completeness=\"1.0\"/> "),
// m_dStartTime, m_dEndTime );
// std::wstring Source = m_oAnimations.ToXml(m_dStartTime, m_dEndTime);
// Source += TimeLine;
// Source += _T("</ImagePaint-DrawImageFromFileAnimate>");
// strEffect.Replace ( _T("</ImagePaint-DrawImageFromFile>"), Source );
// strEffect.Replace ( _T("<ImagePaint-DrawImageFromFile"), _T("<ImagePaint-DrawImageFromFileAnimate") );
// return strEffect;
// }
virtual IElement* CreateDublicate()
{
CImageElement* pImageElement = new CImageElement();
SetProperiesToDublicate((IElement*)pImageElement);
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 (IElement*)pImageElement;
}
virtual void SetupProperty(CSlide* pSlide, CTheme* pTheme, CLayout* pLayout, CElementProperty* pProperty)
{
}
#ifdef ENABLE_PPT_TO_PPTX_CONVERT
AVSINLINE std::wstring ConvertPPTShapeToPPTX(bool bIsNamespace = false)
{
NSGuidesVML::CFormParam pParamCoef;
pParamCoef.m_eType = ptValue;
pParamCoef.m_lParam = 65536;
pParamCoef.m_lCoef = 65536;
return ConvertPPTtoPPTX(/*pPPTShape,*/ pParamCoef, bIsNamespace);
}
std::wstring ConvertPPTtoPPTX(/*CPPTShape* pPPTShape, */const NSGuidesVML::CFormParam& pCoef, bool bIsNamespace = false)
{
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;
}
#endif
AVSINLINE std::wstring DownloadImage(const std::wstring& strFile)
{
#ifndef DISABLE_FILE_DOWNLOADER
CFileDownloader oDownloader(strFile, true);
if ( oDownloader.DownloadSync() )
{
m_strImageFileName = oDownloader.GetFilePath();
}
#endif
return m_strImageFileName;
}
};
class CShapeElement : public IElement
{
public:
NSBaseShape::ClassType m_ClassType;
int m_lShapeType;
CShape m_oShape;
bool m_bShapePreset; // or rect (
CShapeElement(NSBaseShape::ClassType ClassType, int eType) : IElement(), m_lShapeType(eType), m_oShape(ClassType, eType)
{
m_ClassType = ClassType;
m_etType = etShape;
m_oShape.m_rcBounds = m_rcBounds;
m_oShape.m_dStartTime = m_dStartTime;
m_oShape.m_dStartTime = m_dEndTime;
m_bShapePreset = false;
}
CShapeElement() : m_oShape(NSBaseShape::unknown, 0x1000)
{
m_lShapeType = 0x1000;
m_etType = etShape;
m_bShapePreset = false;
}
CShapeElement(const std::wstring& str) : IElement(), m_oShape(NSBaseShape::unknown, 0x1000)
{
m_lShapeType = 0x1000;
m_bShapePreset = false;
m_oShape.LoadFromXML(str);
m_ClassType = m_oShape.m_pShape->GetClassType();
}
virtual void NormalizeCoordsByMetric()
{
IElement::NormalizeCoordsByMetric();
double dScaleX = (double)m_oMetric.m_lUnitsHor / m_oMetric.m_lMillimetresHor;
double dScaleY = (double)m_oMetric.m_lUnitsVer / m_oMetric.m_lMillimetresVer;
m_oShape.m_oText.m_oBounds.left = (int)(dScaleX * m_oShape.m_oText.m_oBounds.left);
m_oShape.m_oText.m_oBounds.right = (int)(dScaleX * m_oShape.m_oText.m_oBounds.right);
m_oShape.m_oText.m_oBounds.top = (int)(dScaleY * m_oShape.m_oText.m_oBounds.top);
m_oShape.m_oText.m_oBounds.bottom = (int)(dScaleY * m_oShape.m_oText.m_oBounds.bottom);
}
virtual ~CShapeElement()
{
}
virtual IElement* CreateDublicate()
{
CShapeElement* pShapeElement = new CShapeElement(m_ClassType, m_lShapeType);
SetProperiesToDublicate((IElement*)pShapeElement);
pShapeElement->m_lShapeType = m_lShapeType;
pShapeElement->m_bShapePreset = m_bShapePreset;
m_oShape.SetToDublicate(&pShapeElement->m_oShape);
return (IElement*)pShapeElement;
}
bool SetUpTextPlaceholder(std::wstring newText);
virtual void SetupProperties(CSlide* pSlide, CTheme* pTheme, CLayout* pLayout)
{
std::map<CElementProperty::Type, CElementProperty>* pMap = &m_oProperties.m_arProperties;
for (std::map<CElementProperty::Type, CElementProperty>::iterator pPair = pMap->begin(); pPair != pMap->end(); ++pPair)
{
CElementProperty oProperty = pPair->second;
SetupProperty(pSlide, pTheme, pLayout, &oProperty);
}
m_oShape.m_oText.m_lPlaceholderType = m_lPlaceholderType;
m_oShape.m_oText.m_lPlaceholderID = m_lPlaceholderID;
m_oShape.m_pShape->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);
}
virtual void SetupTextProperties(CSlide* pSlide, CTheme* pTheme, CLayout* pLayout);
void CalculateColor(CColor& oColor, CSlide* pSlide, CTheme* pTheme, CLayout* pLayout);
virtual void SetupProperty(CSlide* pSlide, CTheme* pTheme, CLayout* pLayout, CElementProperty* pProperty)
{
const LONG _EMU_MM = 36000;
switch (pProperty->m_ID)
{
case CElementProperty::epTextMarginLeft:
{
m_oShape.m_dTextMarginX = (double)pProperty->m_dwValue / _EMU_MM;
break;
}
case CElementProperty::epTextMarginTop:
{
m_oShape.m_dTextMarginY = (double)pProperty->m_dwValue / _EMU_MM;
break;
}
case CElementProperty::epTextMarginRight:
{
m_oShape.m_dTextMarginRight = (double)pProperty->m_dwValue / _EMU_MM;
break;
}
case CElementProperty::epTextMarginBottom:
{
m_oShape.m_dTextMarginBottom = (double)pProperty->m_dwValue / _EMU_MM;
break;
}
case CElementProperty::epText:
{
//m_oShape.m_oText.m_sText = pProperty->m_strAdvanced;
}
case CElementProperty::epTextWrap:
{
m_oShape.m_oText.m_lWrapMode = (LONG)pProperty->m_dwValue;
break;
}
case CElementProperty::epBrushType:
{
m_oBrush.Type = (LONG)pProperty->m_dwValue;
break;
}
case CElementProperty::epBrushColor1:
{
m_oBrush.Color1.SetSBGR(pProperty->m_dwValue);
CalculateColor(m_oBrush.Color1, pSlide, pTheme, pLayout);
break;
}
case CElementProperty::epBrushColor2:
{
m_oBrush.Color2.SetSBGR(pProperty->m_dwValue);
CalculateColor(m_oBrush.Color2, pSlide, pTheme, pLayout);
break;
}
case CElementProperty::epBrushAlpha1:
{
m_oBrush.Alpha1 = (BYTE)pProperty->m_dwValue;
break;
}
case CElementProperty::epBrushAlpha2:
{
m_oBrush.Alpha2 = (BYTE)pProperty->m_dwValue;
break;
}
case CElementProperty::epBrushTxPath:
{
m_oBrush.TexturePath = pProperty->m_strAdvanced;
break;
}
case CElementProperty::epBrushTxMode:
{
m_oBrush.TextureMode = (LONG)pProperty->m_dwValue;
break;
}
case CElementProperty::epFilled:
{
if (0 == pProperty->m_dwValue)
{
m_oBrush.Alpha1 = 0;
}
break;
}
case CElementProperty::epPenColor:
{
m_oPen.Color.SetSBGR(pProperty->m_dwValue);
CalculateColor(m_oPen.Color, pSlide, pTheme, pLayout);
break;
}
case CElementProperty::epPenAlpha:
{
m_oPen.Alpha = (BYTE)pProperty->m_dwValue;
break;
}
case CElementProperty::epPenWidth:
{
m_oPen.Size = (double)pProperty->m_dwValue / 0xFFFF;
break;
}
case CElementProperty::epPenJoin:
{
m_oPen.LineJoin = (BYTE)pProperty->m_dwValue;
break;
}
case CElementProperty::epLineDash:
{
m_oPen.DashStyle = (BYTE)pProperty->m_dwValue;
break;
}
case CElementProperty::epLineStartCap:
{
m_oPen.LineStartCap = (BYTE)pProperty->m_dwValue;
break;
}
case CElementProperty::epLineEndCap:
{
m_oPen.LineEndCap = (BYTE)pProperty->m_dwValue;
break;
}
case CElementProperty::epStroked:
{
if (0 == pProperty->m_dwValue)
m_oPen.Alpha = 0;
break;
}
case CElementProperty::epFontName:
{
m_oShape.m_oText.m_oAttributes.m_oFont.Name = pProperty->m_strAdvanced;
break;
}
case CElementProperty::epFontHorAlign:
{
m_oShape.m_oText.m_oAttributes.m_nTextAlignHorizontal = (int)pProperty->m_dwValue;
break;
}
case CElementProperty::epFontVertAlign:
{
m_oShape.m_oText.m_oAttributes.m_nTextAlignVertical = (int)pProperty->m_dwValue;
break;
}
case CElementProperty::epFontSize:
{
m_oShape.m_oText.m_oAttributes.m_oFont.Size = (double)pProperty->m_dwValue / 0xFFFF;
break;
}
case CElementProperty::epFontBold:
{
m_oShape.m_oText.m_oAttributes.m_oFont.Bold = (pProperty->m_dwValue != 0);
break;
}
case CElementProperty::epFontItalic:
{
m_oShape.m_oText.m_oAttributes.m_oFont.Italic = (pProperty->m_dwValue != 0);
break;
}
case CElementProperty::epFontStrikeout:
{
m_oShape.m_oText.m_oAttributes.m_oFont.Strikeout = (BYTE)pProperty->m_dwValue;
break;
}
default:
break;
}
}
#ifdef ENABLE_PPT_TO_PPTX_CONVERT
AVSINLINE std::wstring ConvertPPTShapeToPPTX(bool bIsNamespace = false)
{
CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(m_oShape.m_pShape);
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 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 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>");
}
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>");
}
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)
{
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
#endif
};
class CAudioElement : public IElement
{
public:
std::wstring m_strAudioFileName;
BYTE m_nAmplify;
bool m_bWithVideo;
double m_dAudioDuration;
double m_dClipStartTime;
double m_dClipEndTime;
bool m_bLoop;
public:
CAudioElement() : IElement()
{
m_etType = etAudio;
m_nAmplify = 100;
m_bWithVideo = false;
m_dAudioDuration = 0.0;
m_bLoop = false;
m_dClipStartTime = 0.0;
m_dClipEndTime = -1.0;
}
virtual ~CAudioElement()
{
}
virtual std::wstring SaveToXML()
{
std::wstring element;
// element.Format(_T("<AudioSource StartTime='%lf' Duration='%lf' Amplify='%lf'>"), m_dStartTime, m_dEndTime-m_dStartTime, (double)m_nAmplify);
// int lIndex = m_strAudioFileName.find(L"file:///");
// if (0 == lIndex)
// {
// m_strAudioFileName = m_strAudioFileName.substr(8);
// //m_strFileName.Replace('/', '\\');
// //m_strFileName.Replace(L"%20", L" ");
// }
// std::wstring strFileName = m_strAudioFileName;
// CorrectXmlString(strFileName);
// std::wstring source;
// source.Format(_T("<Source StartTime='%lf' EndTime='%lf' FilePath='%ls' loop='%d' />"), m_dClipStartTime, m_dClipEndTime, strFileName, m_bLoop);
// element += source;
// std::wstring animations;
// if(!m_oAnimations.m_arAnimations.empty()) // для audio только "media call's" - play - pause - stop
// {
// m_oAnimations.m_dSlideWidth = m_oMetric.m_lMillimetresHor;
// m_oAnimations.m_dSlideHeight = m_oMetric.m_lMillimetresVer;
// animations = m_oAnimations.ToXml(m_dStartTime, m_dEndTime);
// element += animations;
// }
// std::wstring timeLine;
// timeLine.Format ( _T("<timeline type = \"1\" begin=\"%f\" end=\"%f\" fadein=\"0\" fadeout=\"0\" completeness=\"1.0\"/> "), m_dStartTime, m_dEndTime );
// element += timeLine;
// element += _T("</AudioSource>");
return element;
}
virtual void WriteToXml(XmlUtils::CXmlWriter& oWriter)
{
std::wstring strXml = SaveToXML();
oWriter.WriteString(strXml);
}
virtual void ReadFromXml(XmlUtils::CXmlNode& oNode)
{
}
virtual IElement* CreateDublicate()
{
CAudioElement* pAudioElement = new CAudioElement();
SetProperiesToDublicate((IElement*)pAudioElement);
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 (IElement*)pAudioElement;
}
virtual void SetupProperty(CSlide* pSlide, CTheme* pTheme, CLayout* pLayout, CElementProperty* pProperty)
{
}
};
class CVideoElement : public CImageElement
{
public:
std::wstring m_strVideoFileName;
double m_dVideoDuration;
BYTE m_nAlpha;
double m_dClipStartTime;
double m_dClipEndTime;
bool m_bLoop;
public:
CVideoElement() : CImageElement()
{
m_etType = etVideo;
m_dVideoDuration = 0.0;
m_nAlpha = 0xFF;
m_dClipStartTime = -1.0;
m_dClipEndTime = -1.0;
m_bLoop = false;
}
virtual ~CVideoElement()
{
}
virtual void WriteToXml(XmlUtils::CXmlWriter& oWriter)
{
std::wstring strXml = SaveToXML();
oWriter.WriteString(strXml);
}
virtual void ReadFromXml(XmlUtils::CXmlNode& oNode)
{
}
virtual std::wstring SaveToXML()
{
return L""; //GetVideoStream () + GetAudioStream ();
}
std::wstring ToAnimationXml()
{
return L"";
}
virtual IElement* CreateDublicate()
{
CVideoElement* pVideoElement = new CVideoElement();
SetProperiesToDublicate((IElement*)pVideoElement);
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 (IElement*)pVideoElement;
}
virtual void SetupProperty(CSlide* pSlide, CTheme* pTheme, CLayout* pLayout, CElementProperty* pProperty)
{
}
// inline std::wstring GetVideoStream ()
// {
// int lIndex = m_strVideoFileName.find(L"file:///");
// if (0 == lIndex)
// {
// m_strVideoFileName = m_strVideoFileName.substr(8);
// /*m_strFileName.Replace('/', '\\');*/
// }
// std::wstring strFileName = m_strVideoFileName;
// CorrectXmlString(strFileName);
// std::wstring element;
// element.Format ( L"<VideoStream left='%d' top='%d' right='%d' bottom='%d' angle='%f' loop='%d' \
//widthmetric='%d' heightmetric='%d' file='%ls' begin='%f' end='%f' >",
// (LONG)m_rcBounds.left, (LONG)m_rcBounds.top, (LONG)m_rcBounds.right, (LONG)m_rcBounds.bottom, m_dRotate, m_bLoop,
// m_oMetric.m_lMillimetresHor, m_oMetric.m_lMillimetresVer,
// strFileName, m_dClipStartTime, m_dClipEndTime );
// std::wstring animations;
// if(!m_oAnimations.m_arAnimations.empty())
// {
// m_oAnimations.m_dSlideWidth = m_oMetric.m_lMillimetresHor;
// m_oAnimations.m_dSlideHeight = m_oMetric.m_lMillimetresVer;
// animations = m_oAnimations.ToXml(m_dStartTime, m_dEndTime);
// element += animations;
// }
// std::wstring timeLine;
// timeLine.Format ( L"<timeline type = \"1\" begin=\"%f\" end=\"%f\" fadein=\"0\" fadeout=\"0\" completeness=\"1.0\"/> ", m_dStartTime, m_dEndTime );
// element += timeLine;
// element += L"</VideoStream>";
// return element;
// }
// inline std::wstring GetAudioStream ()
// {
// std::wstring element;
// element.Format(L"<AudioSource StartTime='%lf' Duration='%lf' Amplify='%lf' loop='%d' >", m_dStartTime, m_dEndTime - m_dStartTime, 100.0, m_bLoop);
// int lIndex = m_strVideoFileName.find(L"file:///");
// if (0 == lIndex)
// {
// m_strVideoFileName = m_strVideoFileName.substr(8);
// //m_strFileName.Replace('/', '\\');
// //m_strFileName.Replace(L"%20", L" ");
// }
// std::wstring strFileName = m_strVideoFileName;
// CorrectXmlString(strFileName);
// std::wstring source;
// source.Format(L"<Source StartTime='%lf' EndTime='%lf' FilePath='%ls'/>", m_dClipStartTime, m_dClipEndTime, strFileName);
// element += source;
// std::wstring animations;
// if(!m_oAnimations.m_arAnimations.empty()) // для audio только "media call's" - play - pause - stop
// {
// m_oAnimations.m_dSlideWidth = m_oMetric.m_lMillimetresHor;
// m_oAnimations.m_dSlideHeight = m_oMetric.m_lMillimetresVer;
// animations = m_oAnimations.ToXml(m_dStartTime, m_dEndTime);
// element += animations;
// }
// std::wstring timeLine;
// timeLine.Format ( L"<timeline type = \"1\" begin=\"%f\" end=\"%f\" fadein=\"0\" fadeout=\"0\" completeness=\"1.0\"/> ", m_dStartTime, m_dEndTime );
// element += timeLine;
// element += L"</AudioSource>";
// return element;
// }
};
}
Reference in New Issue View Git Blame Copy Permalink