Skip to content

O
onlyoffice_core
Commit c6879804 authored by Elen.Subbotina's avatar Elen.Subbotina Committed by Alexander Trofimov
Browse files
Options

..... 

git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@65750 954022d7-b5bf-4e40-9824-e11837661b57
parent ad95d6ab
Hide whitespace changes
Inline Side-by-side
Showing with 10234 additions and 0 deletions
ASCOfficePPTXFile/Editor/PPTXElements/Animations.h 0 → 100644
View file @ c6879804
#pragma once
#include "Attributes.h"
namespace NSPresentationEditor
{
enum PointPathType
{
etMoveTo = 0,
etLineTo = 1,
etCurveTo = 2,
etCloseLoop = 3,
etHorzTo = 4,
etVertTo = 5,
etEnd = 6
// add arc, c3, c2 ????
};
enum EffectType
{
FadeInType = 1,
FadeExitType = 2,
EmphasisEffect = 3,
MotionEffect = 4,
VerbEffect = 5,
MediaCallEffect = 6
};
class CMotionPath
{
private:
struct PathPoint
{
int Type;
double X [ 4 ];
double Y [ 4 ];
};
public:
inline bool FromStr (const CString& Str)
{
m_Points.clear();
int To = 0;
CString Tokens = _T(" mlczevh");
double dEndX = 0.0;
double dEndY = 0.0;
PathPoint oPoint;
for ( int i = 0; i < Str.GetLength (); ++i )
{
if ( _T('m') == Str [ i ] ) oPoint.Type = etMoveTo;
else if ( _T('l') == Str [ i ] ) oPoint.Type = etLineTo;
else if ( _T('c') == Str [ i ] ) oPoint.Type = etCurveTo;
else if ( _T('z') == Str [ i ] ) oPoint.Type = etCloseLoop; // This action requires no points.
else if ( _T('e') == Str [ i ] ) oPoint.Type = etEnd; // This action requires no points.
else if ( _T('h') == Str [ i ] ) oPoint.Type = etHorzTo; //
else if ( _T('v') == Str [ i ] ) oPoint.Type = etVertTo; //
else if ( _T('M') == Str [ i ] ) oPoint.Type = etMoveTo;
else if ( _T('L') == Str [ i ] ) oPoint.Type = etLineTo;
else if ( _T('C') == Str [ i ] ) oPoint.Type = etCurveTo;
else if ( _T('Z') == Str [ i ] ) oPoint.Type = etCloseLoop;
else if ( _T('E') == Str [ i ] ) oPoint.Type = etEnd;
else continue;
To = i + 1;
if ( etMoveTo == oPoint.Type )
{
oPoint.X [ 0 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
oPoint.Y [ 0 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
dEndX = oPoint.X [ 0 ];
dEndY = oPoint.Y [ 0 ];
continue;
}
if ( etLineTo == oPoint.Type )
{
oPoint.X [ 0 ] = dEndX;
oPoint.Y [ 0 ] = dEndY;
oPoint.X [ 1 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
oPoint.Y [ 1 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
dEndX = oPoint.X [ 1 ];
dEndY = oPoint.Y [ 1 ];
}
if ( etHorzTo == oPoint.Type )
{
oPoint.Type = etLineTo;
oPoint.X [ 0 ] = dEndX;
oPoint.Y [ 0 ] = dEndY;
oPoint.X [ 1 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
oPoint.Y [ 1 ] = oPoint.Y [ 0 ];
dEndX = oPoint.X [ 1 ];
dEndY = oPoint.Y [ 1 ];
}
if ( etVertTo == oPoint.Type )
{
oPoint.Type = etLineTo;
oPoint.X [ 0 ] = dEndX;
oPoint.Y [ 0 ] = dEndY;
oPoint.X [ 1 ] = oPoint.X [ 0 ];
oPoint.Y [ 1 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
dEndX = oPoint.X [ 1 ];
dEndY = oPoint.Y [ 1 ];
}
if ( etCurveTo == oPoint.Type )
{
oPoint.X [ 0 ] = dEndX;
oPoint.Y [ 0 ] = dEndY;
oPoint.X [ 1 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
oPoint.Y [ 1 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
oPoint.X [ 2 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
oPoint.Y [ 2 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
oPoint.X [ 3 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
oPoint.Y [ 3 ] = _tstof ( Str.Tokenize ( Tokens, To ) ); if ( -1 == To ) break;
dEndX = oPoint.X [ 3 ];
dEndY = oPoint.Y [ 3 ];
}
m_Points.push_back ( oPoint );
}
return ( m_Points.size() >= 2 );
}
inline CString ToXml (double dW, double dH)
{
CString Xml;
for ( long i = 0; i < (long)m_Points.size(); ++i )
{
CString Fmt;
if ( etMoveTo == m_Points [ i ].Type )
{
Fmt.Format ( _T("<move x = '%f' y = '%f' />"),
m_Points [ i ].X [ 0 ] * dW, m_Points [ i ].Y [ 0 ] * dH );
}
if ( etLineTo == m_Points [ i ].Type )
{
Fmt.Format ( _T("<line x0 = '%f' y0 = '%f' x1 = '%f' y1 = '%f' />"),
m_Points [ i ].X [ 0 ] * dW, m_Points [ i ].Y [ 0 ] * dH,
m_Points [ i ].X [ 1 ] * dW, m_Points [ i ].Y [ 1 ] * dH );
}
if ( etCurveTo == m_Points [ i ].Type )
{
Fmt.Format ( _T("<curve x0 = '%f' y0 = '%f' x1 = '%f' y1 = '%f' x2 = '%f' y2 = '%f' x3 = '%f' y3 = '%f' />"),
m_Points [ i ].X [ 0 ] * dW, m_Points [ i ].Y [ 0 ] * dH,
m_Points [ i ].X [ 1 ] * dW, m_Points [ i ].Y [ 1 ] * dH,
m_Points [ i ].X [ 2 ] * dW, m_Points [ i ].Y [ 2 ] * dH,
m_Points [ i ].X [ 3 ] * dW, m_Points [ i ].Y [ 3 ] * dH );
}
Xml += Fmt;
}
return Xml;
}
inline CString ToStr ()
{
return _T("");
}
private:
std::vector <PathPoint> m_Points;
};
class CAnimationSimple
{
public:
CAnimationSimple()
{
m_nRefID = -1;
m_nBeginTime = 0;
m_nDuration = 0;
m_nEffectID = 0;
m_nEffectDir = 0;
m_nEffectType = 0;
m_nEffectNodeType = 0;
m_dSX = 1.0;
m_dSY = 1.0;
m_dRotateAngle = 0.0;
m_dTransparency = 1.0;
m_nSchemeColor = 0;
m_nColorTo = 0;
m_dTimeAccel = 0.0;
m_dTimeDecel = 0.0;
m_bIgnoreShape = false;
m_nTextSequence = -1;
m_bRemoveEmptyBlocks = false;
m_nMediaCMD = -1;
}
public:
unsigned long m_nRefID;
double m_nBeginTime;
double m_nDuration;
unsigned long m_nEffectID;
unsigned long m_nEffectDir;
unsigned long m_nEffectType;
unsigned long m_nEffectNodeType;
CString m_MotionPath;
double m_dSX;
double m_dSY;
double m_dRotateAngle;
double m_dTransparency;
int m_nSchemeColor;
unsigned long m_nColorTo;
double m_dTimeAccel;
double m_dTimeDecel;
int m_nTextSequence;
bool m_bIgnoreShape;
bool m_bRemoveEmptyBlocks;
long m_nMediaCMD;
};
class CAnimationInfo
{
public:
std::vector<CAnimationSimple> m_arAnimations;
double m_dSlideWidth;
double m_dSlideHeight;
std::vector <CString> m_oQuery;
public:
CAnimationInfo() : m_arAnimations()
{
}
CAnimationInfo& operator=(const CAnimationInfo& oSrc)
{
m_dSlideWidth = oSrc.m_dSlideWidth;
m_dSlideHeight = oSrc.m_dSlideHeight;
m_arAnimations.insert(m_arAnimations.end(), oSrc.m_arAnimations.begin(), oSrc.m_arAnimations.end());
return *this;
}
CAnimationInfo(const CAnimationInfo& oSrc)
{
*this = oSrc;
}
~CAnimationInfo()
{
}
public:
CString ToXml(const double& dStartTime, const double& dEndTime, bool bIgnore = false)
{
CString baseXML;
baseXML.Format ( _T("<animations width = '%f' height = '%f'>"), m_dSlideWidth, m_dSlideHeight );
CString Source;
for ( long i = 0; i < (long)m_arAnimations.size(); ++i )
{
CAnimationSimple* pEffect = &m_arAnimations[i];
if (NULL==pEffect)
continue;
if (bIgnore)
{
if (pEffect->m_bIgnoreShape)
continue;
}
double dEffectBegin = dStartTime + pEffect->m_nBeginTime;
m_oQuery.clear ();
m_oQuery.push_back ( _T(" id = '") + NSPresentationEditor::ToString (pEffect->m_nEffectID) + _T("' "));
m_oQuery.push_back ( _T(" type = '") + NSPresentationEditor::ToString (pEffect->m_nEffectType) + _T("' "));
m_oQuery.push_back ( _T(" dir = '") + NSPresentationEditor::ToString (pEffect->m_nEffectDir) + _T("' "));
m_oQuery.push_back ( _T(" begin = '") + NSPresentationEditor::ToString (dEffectBegin) + _T("' "));
m_oQuery.push_back ( _T(" dur = '") + NSPresentationEditor::ToString (pEffect->m_nDuration) + _T("' "));
m_oQuery.push_back ( _T(" accel = '") + NSPresentationEditor::ToString (pEffect->m_dTimeAccel) + _T("' "));
m_oQuery.push_back ( _T(" decel = '") + NSPresentationEditor::ToString (pEffect->m_dTimeDecel) + _T("' "));
m_oQuery.push_back ( _T(" sx = '") + NSPresentationEditor::ToString (pEffect->m_dSX) + _T("' "));
m_oQuery.push_back ( _T(" sy = '") + NSPresentationEditor::ToString (pEffect->m_dSY) + _T("' "));
m_oQuery.push_back ( _T(" alpha = '") + NSPresentationEditor::ToString (pEffect->m_dTransparency) + _T("' "));
m_oQuery.push_back ( _T(" angle = '") + NSPresentationEditor::ToString (pEffect->m_dRotateAngle) + _T("' "));
m_oQuery.push_back ( _T(" color = '") + NSPresentationEditor::ToString (pEffect->m_nColorTo) + _T("' "));
m_oQuery.push_back ( _T(" block = '") + NSPresentationEditor::ToString (pEffect->m_nTextSequence) + _T("' "));
m_oQuery.push_back ( _T(" removeemptyblocks = '") + NSPresentationEditor::ToString (pEffect->m_bRemoveEmptyBlocks) + _T("' "));
CString Effect;
if (MotionEffect == pEffect->m_nEffectType || pEffect->m_MotionPath.GetLength())
{
CMotionPath oPath;
if ( oPath.FromStr ( pEffect->m_MotionPath ) )
{
Effect.Format ( _T("<animateMotion %s >%s</animateMotion>"), FormatXml (), oPath.ToXml(1.0,1.0));
Source += Effect;
}
}
if ( FadeInType == pEffect->m_nEffectType )
{
Effect.Format ( _T("<animateFadeIn %s />"), FormatXml ());
Source += Effect;
}
if ( FadeExitType == pEffect->m_nEffectType )
{
Effect.Format ( _T("<animateFadeExit %s />"), FormatXml ());
Source += Effect;
}
if (EmphasisEffect == pEffect->m_nEffectType )
{
if (6 == pEffect->m_nEffectID) // GrowAndShrink Effect
{
Effect.Format ( _T("<animateScale %s />"), FormatXml ());
}
else if (8 == pEffect->m_nEffectID || 32 == pEffect->m_nEffectID) // Spin Effect || Teeter Effect
{
Effect.Format ( _T("<animateRotate %s />"), FormatXml ());
}
else if (9 == pEffect->m_nEffectID || 35 == pEffect->m_nEffectID) // Blink - 36 -
{
Effect.Format ( _T("<animateAlpha %s />"), FormatXml ());
}
else if (26 == pEffect->m_nEffectID) // FlashBulb Effect ( )
{
Effect.Format ( _T("<animateAlpha %s />"), FormatXml ());
Source += Effect;
Effect.Format ( _T("<animateScale %s />"), FormatXml ());
Source += Effect;
continue;
}
else if (27 == pEffect->m_nEffectID // Flicker ( )
|| 1 == pEffect->m_nEffectID // ChangeFillColor - fill color
|| 3 == pEffect->m_nEffectID // ChangeFillColor - font color
|| 7 == pEffect->m_nEffectID // ChangeFillColor - fill lines
|| 19 == pEffect->m_nEffectID) // ColorBlend - object fill color
{
Effect.Format ( _T("<animateColor %s />"), FormatXml ());
}
else
{
Effect.Format ( _T("<animateEmphasis %s />"), FormatXml ());
}
Source += Effect;
}
if (MediaCallEffect == pEffect->m_nEffectType )
{
CString sTime;
sTime.Format(_T(" begin='%f' dur='%f' accel='%f' decel='%f' "), dStartTime + pEffect->m_nBeginTime, pEffect->m_nDuration, pEffect->m_dTimeAccel, pEffect->m_dTimeDecel);
Effect.Format(_T("<mediaCall id='%d' %s event='%d' />"), pEffect->m_nEffectID, sTime, pEffect->m_nMediaCMD);
Source += Effect;
}
}
if (bIgnore)
{
if (0 == Source.GetLength())
return _T("");
}
baseXML += Source;
baseXML += CString(_T("</animations>"));
return baseXML;
}
inline CString FormatXml ()
{
CString Xml;
for ( long i = 0; i < (long)m_oQuery.size(); ++i )
Xml += m_oQuery[i];
return Xml;
}
};
}
ASCOfficePPTXFile/Editor/PPTXElements/Attributes.h 0 → 100644
View file @ c6879804
#pragma once
#if defined(_WIN32) || defined(_WIN64)
#include <atlcoll.h>
#include <gdiplus.h>
#else
#include "../../ASCOfficePPTXFile/PPTXLib/Linux/PPTXFormatLib/linux_gdiplus.h"
#endif
#include "Metric.h"
#include "Effects.h"
//#include "../../Common/DocxFormat/Source/XML/xmlutils.h"
#include "../../Common/ASCUtils.h"
#include "./XmlWriter.h"
#include "../../DesktopEditor/graphics/IRenderer.h"
#include "../../DesktopEditor/graphics/structures.h"
namespace NSPresentationEditor
{
static void ReplaceAll(std::wstring & str, const std::wstring& from, const std::wstring& to)
{
size_t start_pos = 0;
while((start_pos = str.find(from, start_pos)) != std::wstring::npos)
{
str.replace(start_pos, from.length(), to);
start_pos += to.length();
}
}
class CExFilesInfo
{
public:
enum ExFilesType
{
eftNone = 0,
eftVideo = 1,
eftAudio = 2,
eftHyperlink= 3,
eftObject = 4
};
public:
DWORD m_dwID;
std::wstring m_strFilePath;
// clip
double m_dStartTime;
double m_dEndTime;
// loop
bool m_bLoop;
public:
CExFilesInfo()
{
m_dwID = 0;
m_strFilePath = _T("");
m_dStartTime = 0.0;
m_dEndTime = -1.0;
m_bLoop = false;
}
CExFilesInfo(const CExFilesInfo& oSrc)
{
*this = oSrc;
}
CExFilesInfo& operator=(const CExFilesInfo& oSrc)
{
m_dwID = oSrc.m_dwID;
m_strFilePath = oSrc.m_strFilePath;
m_dStartTime = oSrc.m_dStartTime;
m_dEndTime = oSrc.m_dEndTime;
m_bLoop = oSrc.m_bLoop;
return *this;
}
};
class CExMedia
{
public:
std::wstring m_strPresentationDirectory;
std::wstring m_strSourceDirectory;
std::vector<CExFilesInfo> m_arVideos;
std::vector<CExFilesInfo> m_arImages;
std::vector<CExFilesInfo> m_arAudios;
std::vector<CExFilesInfo> m_arHyperlinks;
std::vector<CExFilesInfo> m_arAudioCollection;
public:
void Clear()
{
m_arVideos.clear();
m_arImages.clear();
m_arAudios.clear();
m_arAudioCollection.clear();
}
public:
CExMedia() : m_arVideos(), m_arImages(), m_arAudios()
{
m_strPresentationDirectory = _T("");
m_strSourceDirectory = _T("");
}
CExMedia(const CExMedia& oSrc)
{
*this = oSrc;
}
CExMedia& operator=(const CExMedia& oSrc)
{
m_strPresentationDirectory = oSrc.m_strPresentationDirectory;
m_strSourceDirectory = oSrc.m_strSourceDirectory;
for (int i=0; i < oSrc.m_arVideos.size(); i++)
m_arVideos.push_back(oSrc.m_arVideos[i]);
for (int i=0; i < oSrc.m_arVideos.size(); i++)
m_arImages.push_back(oSrc.m_arImages[i]);
for (int i=0; i < oSrc.m_arVideos.size(); i++)
m_arAudios.push_back(oSrc.m_arAudios[i]);
return *this;
}
CExFilesInfo* LockHyperlink(DWORD dwID)
{
size_t nCount = m_arHyperlinks.size();
for (size_t i = 0; i < nCount; ++i)
{
if (dwID == m_arHyperlinks[i].m_dwID)
{
return &m_arHyperlinks[i];
}
}
return NULL;
}
CExFilesInfo* LockVideo(DWORD dwID)
{
size_t nCount = m_arVideos.size();
for (size_t i = 0; i < nCount; ++i)
{
if (dwID == m_arVideos[i].m_dwID)
{
return &m_arVideos[i];
}
}
return NULL;
}
CExFilesInfo* LockImage(DWORD dwID)
{
size_t nCount = m_arImages.size();
for (size_t i = 0; i < nCount; ++i)
{
if (dwID == m_arImages[i].m_dwID)
{
return &m_arImages[i];
}
}
return NULL;
}
CExFilesInfo* LockAudio(DWORD dwID)
{
size_t nCount = m_arAudios.size();
for (size_t i = 0; i < nCount; ++i)
{
if (dwID == m_arAudios[i].m_dwID)
{
return &m_arAudios[i];
}
}
return NULL;
}
CExFilesInfo* LockAudioFromCollection(DWORD dwID)
{
size_t nCount = m_arAudioCollection.size();
for (size_t i = 0; i < nCount; ++i)
{
if (dwID == m_arAudioCollection[i].m_dwID)
{
return &m_arAudioCollection[i];
}
}
return NULL;
}
CExFilesInfo* Lock(DWORD dwID, CExFilesInfo::ExFilesType& eType)
{
CExFilesInfo* pInfo = NULL;
pInfo = LockHyperlink(dwID);
if (NULL != pInfo)
{
eType = CExFilesInfo::eftHyperlink;
return pInfo;
}
pInfo = LockVideo(dwID);
if (NULL != pInfo)
{
eType = CExFilesInfo::eftVideo;
return pInfo;
}
pInfo = LockAudio(dwID);
if (NULL != pInfo)
{
eType = CExFilesInfo::eftAudio;
return pInfo;
}
eType = CExFilesInfo::eftNone;
return LockImage(dwID);
}
};
#if defined(_WIN32) || defined(_WIN64)
static void CorrectXmlString2(CString & strText)
{
strText.Replace(L"&apos;", L"'");
strText.Replace(L"&lt;", L"<");
strText.Replace(L"&gt;", L">");
strText.Replace(L"&quot;", L"\"");
strText.Replace(L"&amp;", L"&");
}
static void CorrectXmlString(CString & strText)
{
strText.Replace(L"&", L"&amp;");
strText.Replace(L"'", L"&apos;");
strText.Replace(L"<", L"&lt;");
strText.Replace(L">", L"&gt;");
strText.Replace(L"\"", L"&quot;");
}
#endif
static void CorrectXmlString2(std::wstring & strText)
{
ReplaceAll(strText, L"&apos;", L"'");
ReplaceAll(strText, L"&lt;", L"<");
ReplaceAll(strText, L"&gt;", L">");
ReplaceAll(strText, L"&quot;", L"\"");
ReplaceAll(strText, L"&amp;", L"&");
}
static void CorrectXmlString(std::wstring & strText)
{
ReplaceAll(strText, L"&", L"&amp;");
ReplaceAll(strText, L"'", L"&apos;");
ReplaceAll(strText, L"<", L"&lt;");
ReplaceAll(strText, L">", L"&gt;");
ReplaceAll(strText, L"\"", L"&quot;");
}
static inline CString BoolToString(bool bValue)
{
if (bValue)
return _T("1");
return _T("0");
}
static inline CString ToString(int val)
{
CString str = _T("");
str.Format(_T("%d"), val);
return str;
}
static inline CString ToString(DWORD val)
{
CString str = _T("");
str.Format(_T("%d"), val);
return str;
}
static inline CString ToString(long val)
{
CString str = _T("");
str.Format(_T("%d"), val);
return str;
}
static inline CString ToString(double val)
{
CString str = _T("");
str.Format(_T("%lf"), val);
return str;
}
class CColor
{
public:
BYTE R;
BYTE G;
BYTE B;
BYTE A;
LONG m_lSchemeIndex;
public:
CColor()
{
R = 0;
G = 0;
B = 0;
A = 255;
m_lSchemeIndex = -1;
}
CColor& operator =(const CColor& oSrc)
{
R = oSrc.R;
G = oSrc.G;
B = oSrc.B;
A = oSrc.A;
m_lSchemeIndex = oSrc.m_lSchemeIndex;
return (*this);
}
AVSINLINE bool IsEqual(const CColor& oSrc)
{
return ((R == oSrc.R) && (G == oSrc.G) && (B == oSrc.B) && (m_lSchemeIndex == oSrc.m_lSchemeIndex));
}
static CColor CreateColor(DWORD dwColor)
{
CColor oColor;
oColor.R = (BYTE)(dwColor >> 16);
oColor.G = (BYTE)(dwColor >> 8);
oColor.B = (BYTE)(dwColor);
oColor.A = 0xFF;
oColor.m_lSchemeIndex = -1;
return oColor;
}
CColor& operator =(const DWORD& oSrc)
{
R = (BYTE)(oSrc >> 8);
G = (BYTE)(oSrc >> 16);
B = (BYTE)(oSrc >> 24);
A = (BYTE)oSrc;
m_lSchemeIndex = -1;
return (*this);
}
void SetSBGR(const DWORD& lBGR)
{
R = (BYTE)(lBGR);
G = (BYTE)(lBGR >> 8);
B = (BYTE)(lBGR >> 16);
if (lBGR & 0xFF000000)
m_lSchemeIndex = R;
}
void SetBGR(const LONG& lBGR)
{
R = (BYTE)(lBGR);
G = (BYTE)(lBGR >> 8);
B = (BYTE)(lBGR >> 16);
m_lSchemeIndex = -1;
}
void SetRGB(BYTE r, BYTE g, BYTE b)
{
R = r;
G = g;
B = b;
m_lSchemeIndex = -1;
}
void SetR(BYTE r){ R = r; }
void SetG(BYTE g){ G = g; }
void SetB(BYTE b){ B = b; }
BYTE GetR(){ return R; }
BYTE GetG(){ return G; }
BYTE GetB(){ return B; }
friend bool operator==(const CColor& color1, const CColor& color2)
{
return ((color1.R == color2.R) && (color1.G == color2.G) && (color1.B == color2.B));
}
LONG GetLONG() const
{
LONG dwColor = 0;
dwColor |= R;
dwColor |= (G << 8);
dwColor |= (B << 16);
return dwColor;
}
LONG GetLONG_RGB() const
{
LONG dwColor = 0;
dwColor |= B;
dwColor |= (G << 8);
dwColor |= (R << 16);
return dwColor;
}
CString ToString()
{
DWORD dwColor = 0;
dwColor |= R;
dwColor |= (G << 8);
dwColor |= (B << 16);
return NSPresentationEditor::ToString((int)dwColor);
}
void FromString(CString str)
{
int lColor;
if (str.Find(_T("#")) == 0)
{
lColor = XmlUtils::GetColor(str.Mid(1, 6));
R = (BYTE)(lColor);
G = (BYTE)(lColor >> 8);
B = (BYTE)(lColor >> 16);
A = 255;
}
else
{
int nLen = str.GetLength();
TCHAR* pBuffer = str.GetBuffer();
TCHAR* pBuffer1 = pBuffer;
TCHAR* pBuffer2 = pBuffer;
TCHAR* pBufferEnd = pBuffer + nLen;
while ((pBuffer1 < pBufferEnd) && !XmlUtils::IsDigit(*pBuffer1))
++pBuffer1;
pBuffer2 = pBuffer1;
while ((pBuffer2 < pBufferEnd) && XmlUtils::IsDigit(*pBuffer2))
++pBuffer2;
R = _GetColor(pBuffer1, pBuffer2);
pBuffer1 = pBuffer2;
while ((pBuffer1 < pBufferEnd) && !XmlUtils::IsDigit(*pBuffer1))
++pBuffer1;
pBuffer2 = pBuffer1;
while ((pBuffer2 < pBufferEnd) && XmlUtils::IsDigit(*pBuffer2))
++pBuffer2;
G = _GetColor(pBuffer1, pBuffer2);
pBuffer1 = pBuffer2;
while ((pBuffer1 < pBufferEnd) && !XmlUtils::IsDigit(*pBuffer1))
++pBuffer1;
pBuffer2 = pBuffer1;
while ((pBuffer2 < pBufferEnd) && XmlUtils::IsDigit(*pBuffer2))
++pBuffer2;
B = _GetColor(pBuffer1, pBuffer2);
A = 0xFF;
m_lSchemeIndex = -1;
}
}
void FromDWORD(DWORD dwVal)
{
}
private:
BYTE _GetColor(TCHAR* pChar1, TCHAR* pChar2)
{
if (pChar1 == pChar2)
return 0;
CString s(pChar1, (int)(pChar2 - pChar1));
return (BYTE)XmlUtils::GetInteger(s);
}
};
class CPen
{
public:
CColor Color;
long Alpha;
double Size;
BYTE DashStyle;
BYTE LineStartCap;
BYTE LineEndCap;
BYTE LineJoin;
double* DashPattern;
long Count;
double DashOffset;
LONG Align;
double MiterLimit;
CColor Color2; //backLine
public:
void GetDashPattern(double* arrDashPattern, long& nCount) const
{
if (nCount == Count)
{
for (int i = 0; i < Count; ++i)
{
arrDashPattern[i] = DashPattern[i];
}
}
}
void SetDashPattern(double* arrDashPattern, long nCount)
{
if ((arrDashPattern == NULL) || (nCount == 0))
{
Count = 0;
RELEASEARRAYOBJECTS(DashPattern);
}
else
{
if (Count != nCount)
{
Count = nCount;
RELEASEARRAYOBJECTS(DashPattern);
DashPattern = new double[Count];
}
for (int i = 0; i < Count; ++i)
{
DashPattern[i] = arrDashPattern[i];
}
}
}
void ScaleAlpha( double dScale )
{
long dNewAlpha = long(Alpha * dScale + 0.5);
if( dNewAlpha > 255 ) dNewAlpha = 255;
else if( dNewAlpha < 0 ) dNewAlpha = 0;
Alpha = dNewAlpha;
}
bool IsEqual(CPen* pPen)
{
if (NULL == pPen)
return false;
return ((Color == pPen->Color) && (Alpha == pPen->Alpha) && (Size == pPen->Size) &&
(DashStyle == pPen->DashStyle) && (LineStartCap == pPen->LineStartCap) &&
(LineEndCap == pPen->LineEndCap) && (LineJoin == pPen->LineJoin));
}
void SetToRenderer(IRenderer *pRenderer)
{
if (-1 == Color.m_lSchemeIndex)
pRenderer->put_PenColor(Color.GetLONG());
else
{
LONG lColor = Color.GetLONG();
lColor |= (0xFF000000 & ((Color.m_lSchemeIndex + 1 + 100) << 24));
pRenderer->put_PenColor(lColor);
}
pRenderer->put_PenAlpha(Alpha);
pRenderer->put_PenSize(Size);
pRenderer->put_PenDashStyle(DashStyle);
pRenderer->put_PenLineStartCap(LineStartCap);
pRenderer->put_PenLineEndCap(LineEndCap);
pRenderer->put_PenLineJoin(LineJoin);
pRenderer->put_PenAlign(Align);
if (DashStyle != Gdiplus::DashStyleSolid)
{
pRenderer->PenDashPattern(DashPattern, Count);
pRenderer->put_PenDashOffset(DashOffset);
}
}
void SetDefaultParams()
{
Alpha = 255;
Size = 0.26458;
DashStyle = 0;
LineStartCap = 0;
LineEndCap = 0;
LineJoin = 0;
DashPattern = NULL;
Count = 0;
Color.SetRGB (0x00, 0x00, 0x00);
Color2.SetRGB (0xff, 0xff, 0xff);
DashOffset = 0;
Align = Gdiplus::PenAlignmentCenter;
MiterLimit = 0.5;
}
public:
CPen()
{
SetDefaultParams();
}
CPen( const CPen& other )
{
*this = other;
}
CPen& operator=(const CPen& other)
{
Color = other.Color;
Color2 = other.Color2;
Alpha = other.Alpha;
Size = other.Size;
DashStyle = other.DashStyle;
LineStartCap = other.LineStartCap;
LineEndCap = other.LineEndCap;
LineJoin = other.LineJoin;
RELEASEARRAYOBJECTS(DashPattern);
Count = other.Count;
if (Count != 0)
{
DashPattern = new double[Count];
for (int i = 0; i < Count; ++i)
{
DashPattern[i] = other.DashPattern[i];
}
}
DashOffset = other.DashOffset;
Align = other.Align;
MiterLimit = other.MiterLimit;
return *this;
}
virtual ~CPen()
{
RELEASEARRAYOBJECTS(DashPattern);
}
};
class CBrush
{
public:
long Type;
CColor Color1;
CColor Color2;
long Alpha1;
long Alpha2;
std::wstring TexturePath;
long TextureAlpha;
long TextureMode;
bool Rectable;
Gdiplus::RectF Rect;
double LinearAngle;
public:
inline LONG ConstantCompatible(LONG nConstant)
{
if( c_BrushTypeDiagonal1_ == nConstant )
nConstant = c_BrushTypeDiagonal2_;
else if( c_BrushTypeDiagonal2_ == nConstant )
nConstant = c_BrushTypeDiagonal1_;
if (1000 <= nConstant)
return nConstant;
if (c_BrushTypeSolid_ == nConstant)
return nConstant + 1000;
if (c_BrushTypeHorizontal_ <= nConstant && c_BrushTypePathGradient2_ >= nConstant)
return nConstant + 2000;
if (c_BrushTypeTexture_ == nConstant)
return nConstant + 3000;
if (c_BrushTypeHatch1_ <= nConstant && c_BrushTypeHatch53_ >= nConstant)
return nConstant + 4000;
if (c_BrushTypeGradient1_ <= nConstant && c_BrushTypeGradient6_ >= nConstant)
return nConstant + 2000 - 61;
return 1000;
}
void ScaleAlpha1( double dScale )
{
long dNewAlpha = long(Alpha1 * dScale + 0.5);
if( dNewAlpha > 255 ) dNewAlpha = 255;
else if( dNewAlpha < 0 ) dNewAlpha = 0;
Alpha1 = dNewAlpha;
}
void ScaleAlpha2( double dScale )
{
long dNewAlpha = long(Alpha2 * dScale + 0.5);
if( dNewAlpha > 255 ) dNewAlpha = 255;
else if( dNewAlpha < 0 ) dNewAlpha = 0;
Alpha2 = dNewAlpha;
}
void ScaleTextureAlpha( double dScale )
{
long dNewAlpha = long(TextureAlpha * dScale + 0.5);
if( dNewAlpha > 255 ) dNewAlpha = 255;
else if( dNewAlpha < 0 ) dNewAlpha = 0;
TextureAlpha = dNewAlpha;
}
bool IsEqual(CBrush* pBrush)
{
if (NULL == pBrush)
return false;
/*return ((Type == pBrush->Type) &&
(Color1 == pBrush->Color1) && (Color2 == pBrush->Color2) &&
(Alpha1 == pBrush->Alpha1) && (Alpha2 == pBrush->Alpha2));*/
return ((Type == pBrush->Type) &&
(Color1 == pBrush->Color1) && (Color2 == pBrush->Color2) &&
(Alpha1 == pBrush->Alpha1) && (Alpha2 == pBrush->Alpha2) && (LinearAngle == pBrush->LinearAngle) &&
(TexturePath == pBrush->TexturePath) && (TextureAlpha == pBrush->TextureAlpha) && (TextureMode == pBrush->TextureMode) &&
(Rectable == pBrush->Rectable) && (Rect.Equals(pBrush->Rect)));
}
void SetDefaultParams()
{
Type = c_BrushTypeNoFill;
Color1 = 0xFFFFFFFF;
Alpha1 = 255;
Color2 = 0xFFFFFFFF;
Alpha2 = 255;
TextureAlpha = 255;
TextureMode = c_BrushTextureModeStretch;
LinearAngle = 0;
TexturePath = _T("");
Rectable = false;
Rect.X = 0.0F;
Rect.Y = 0.0F;
Rect.Width = 0.0F;
Rect.Height = 0.0F;
}
public:
CBrush()
{
SetDefaultParams();
}
CBrush( const CBrush& other )
{
Type = other.Type;
Color1 = other.Color1;
Alpha1 = other.Alpha1;
Color2 = other.Color2;
Alpha2 = other.Alpha2;
TexturePath = other.TexturePath;
TextureAlpha = other.TextureAlpha;
TextureMode = other.TextureMode;
Rectable = other.Rectable;
Rect = other.Rect;
LinearAngle = other.LinearAngle;
}
CBrush& operator=(const CBrush& other)
{
Type = other.Type;
Color1 = other.Color1;
Alpha1 = other.Alpha1;
Color2 = other.Color2;
Alpha2 = other.Alpha2;
TexturePath = other.TexturePath;
TextureAlpha = other.TextureAlpha;
TextureMode = other.TextureMode;
Rectable = other.Rectable;
Rect = other.Rect;
LinearAngle = other.LinearAngle;
return *this;
}
virtual ~CBrush()
{
}
bool IsTexture()
{
return (c_BrushTypeTexture == Type);
}
bool IsOneColor()
{
return (c_BrushTypeSolid == Type);
}
bool IsTwoColor()
{
return ((c_BrushTypeHorizontal <= Type && c_BrushTypeCylinderVer >= Type) ||
(c_BrushTypeHatch1 <= Type && c_BrushTypeHatch53 >= Type));
}
void SetToRenderer(IRenderer *pRenderer)
{
Type = ConstantCompatible(Type);
pRenderer->put_BrushType(Type);
if (IsOneColor())
{
//pRenderer->put_BrushColor1(Color1.GetLONG());
if (-1 == Color1.m_lSchemeIndex)
pRenderer->put_BrushColor1(Color1.GetLONG());
else
{
LONG lColor = Color1.GetLONG();
lColor |= (0xFF000000 & ((Color1.m_lSchemeIndex + 1 + 100) << 24));
pRenderer->put_BrushColor1(lColor);
}
pRenderer->put_BrushAlpha1(Alpha1);
}
else if (IsTexture())
{
//BSTR bstrTexturePath = TexturePath.AllocSysString();
pRenderer->put_BrushTexturePath(TexturePath);
//SysFreeString(bstrTexturePath);
pRenderer->put_BrushTextureMode(TextureMode);
pRenderer->put_BrushTextureAlpha(TextureAlpha);
pRenderer->BrushRect(Rectable, Rect.X, Rect.Y, Rect.Width, Rect.Height);
}
else if (IsTwoColor())
{
//pRenderer->put_BrushColor1(Color1.GetLONG());
if (-1 == Color1.m_lSchemeIndex)
pRenderer->put_BrushColor1(Color1.GetLONG());
else
{
LONG lColor = Color1.GetLONG();
lColor |= (0xFF000000 & ((Color1.m_lSchemeIndex + 1 + 100) << 24));
pRenderer->put_BrushColor1(lColor);
}
pRenderer->put_BrushAlpha1(Alpha1);
pRenderer->put_BrushColor2(Color2.GetLONG());
pRenderer->put_BrushAlpha2(Alpha2);
}
}
public:
};
class CFont
{
public:
std::wstring Path;
std::wstring Name;
double Size;
bool Bold;
bool Italic;
BYTE Underline;
BYTE Strikeout;
bool StringGID;
double CharSpace;
std::wstring PitchFamily;
BYTE Charset;
std::wstring Panose;
bool Monospace;
public:
bool IsEqual(CFont* pFont)
{
if (NULL == pFont)
return false;
return ((Name == pFont->Name) && (Path == pFont->Path) && (StringGID == pFont->StringGID) && (Size == pFont->Size) &&
(Bold == pFont->Bold) && (Italic == pFont->Italic) &&
(Underline == pFont->Underline) && (Strikeout == pFont->Strikeout));
}
bool IsEqual2(CFont* pFont)
{
if (NULL == pFont)
return false;
return ((Name == pFont->Name) && (Path == pFont->Path) && (StringGID == pFont->StringGID) && (Size == pFont->Size) &&
(Bold == pFont->Bold) && (Italic == pFont->Italic));
}
LONG GetStyle() const
{
LONG lStyle = 0;
if (Bold)
lStyle |= 0x01;
if (Italic)
lStyle |= 0x02;
lStyle |= Underline << 2;
lStyle |= Strikeout << 7;
return lStyle;
}
void SetStyle(LONG const& lStyle)
{
Bold = (0x01 == (0x01 & lStyle));
Italic = (0x02 == (0x02 & lStyle));
Underline = (BYTE)(0x7C & lStyle) >> 2;
Strikeout = (BYTE)(0x0180 & lStyle) >> 7;
}
void SetToRenderer(IRenderer *pRenderer)
{
pRenderer->put_FontName(Name);
pRenderer->put_FontPath(Path);
pRenderer->put_FontSize(Size);
pRenderer->put_FontStyle(GetStyle());
pRenderer->put_FontStringGID(StringGID);
pRenderer->put_FontCharSpace(CharSpace);
}
void SetDefaultParams()
{
Name = _T("Arial");
Path = _T("");
Size = 0;
Bold = false;
Italic = false;
Underline = 0;
Strikeout = 0;
StringGID = false;
CharSpace = 0.0;
PitchFamily = _T("");
Charset = 0;
Panose = _T("");
Monospace = false;
}
public:
CFont()
{
SetDefaultParams();
}
CFont( const CFont& other )
{
*this = other;
}
CFont& operator=(const CFont& other)
{
Name = other.Name;
Path = other.Path;
Size = other.Size;
Bold = other.Bold;
Italic = other.Italic;
Underline = other.Underline;
Strikeout = other.Strikeout;
StringGID = other.StringGID;
CharSpace = other.CharSpace;
PitchFamily = other.PitchFamily;
Charset = other.Charset;
Panose = other.Panose;
Monospace = other.Monospace;
return *this;
}
virtual ~CFont()
{
}
};
class CShadow
{
public:
bool Visible;
double DistanceX;
double DistanceY;
double OriginX;
double OriginY;
double BlurSize;
CColor Color;
long Alpha;
int Type;
double ScaleXToX;
double ScaleXToY;
double ScaleYToX;
double ScaleYToY;
int PerspectiveX;
int PerspectiveY;
public:
void SetDefaultParams()
{
Visible = false;
DistanceX = 0.5;
DistanceY = 0.5;
BlurSize = 0;
Alpha = 255;
OriginX = 0;
OriginY = 0;
Type = -1;
ScaleXToX = 1.;
ScaleXToY = 1.;
ScaleYToX = 1.;
ScaleYToY = 1.;
PerspectiveX = 0;
PerspectiveY = 0;
Color.SetRGB(0x80, 0x80, 0x80);
}
public:
CShadow()
{
SetDefaultParams();
}
CShadow( const CShadow& other )
{
Visible = other.Visible;
DistanceX = other.DistanceX;
DistanceY = other.DistanceY;
OriginX = other.OriginX;
OriginY = other.OriginY;
BlurSize = other.BlurSize;
Color = other.Color;
Alpha = other.Alpha;
Type = other.Type;
ScaleXToX = other.ScaleXToX;
ScaleXToY = other.ScaleXToY;
ScaleYToX = other.ScaleYToX;
ScaleYToY = other.ScaleYToY;
PerspectiveX= other.PerspectiveX;
PerspectiveY= other.PerspectiveY;
}
CShadow& operator=(const CShadow& other)
{
Visible = other.Visible;
DistanceX = other.DistanceX;
DistanceY = other.DistanceY;
OriginX = other.OriginX;
OriginY = other.OriginY;
BlurSize = other.BlurSize;
Color = other.Color;
Alpha = other.Alpha;
Type = other.Type;
PerspectiveX= other.PerspectiveX;
PerspectiveY= other.PerspectiveY;
ScaleXToX = other.ScaleXToX;
ScaleXToY = other.ScaleXToY;
ScaleYToX = other.ScaleYToX;
ScaleYToY = other.ScaleYToY;
return *this;
}
virtual ~CShadow()
{
}
};
class CEdgeText
{
public:
long Visible;
double Dist;
CColor Color;
long Alpha;
public:
void SetDefaultParams()
{
Visible = 0;
Dist = 5;
Color = 0;
Alpha = 255;
}
public:
CEdgeText()
{
SetDefaultParams();
}
CEdgeText( const CEdgeText& other )
{
Visible = other.Visible;
Dist = other.Dist;
Color = other.Color;
Alpha = other.Alpha;
}
CEdgeText& operator=(const CEdgeText& other)
{
Visible = other.Visible;
Dist = other.Dist;
Color = other.Color;
Alpha = other.Alpha;
return *this;
}
virtual ~CEdgeText()
{
}
};
class CTextAttributes
{
public:
CFont m_oFont;
CBrush m_oTextBrush;
CShadow m_oTextShadow;
CEdgeText m_oTextEdge;
int m_nTextAlignHorizontal;
int m_nTextAlignVertical;
double m_dTextRotate;
public:
CTextAttributes() : m_oFont(), m_oTextBrush(), m_oTextShadow(), m_oTextEdge()
{
m_oFont.Size = 36;
m_oTextBrush.Color1 = 0xFF;
m_nTextAlignHorizontal = 0;
m_nTextAlignVertical = -1; //not set
m_dTextRotate = 0;
}
CTextAttributes& operator =(const CTextAttributes& oSrc)
{
m_oFont = oSrc.m_oFont;
m_oTextBrush = oSrc.m_oTextBrush;
m_oTextShadow = oSrc.m_oTextShadow;
m_oTextEdge = oSrc.m_oTextEdge;
m_nTextAlignHorizontal = oSrc.m_nTextAlignHorizontal;
m_nTextAlignVertical = oSrc.m_nTextAlignVertical;
m_dTextRotate = oSrc.m_dTextRotate;
return (*this);
}
};
static void ParseString(CString strDelimeters, CString strSource,
std::vector<CString>* pArrayResults, bool bIsCleared = true)
{
if (NULL == pArrayResults)
return;
if (bIsCleared)
pArrayResults->clear();
CString resToken;
int curPos= 0;
resToken = strSource.Tokenize(strDelimeters, curPos);
while (resToken != _T(""))
{
pArrayResults->push_back(resToken);
resToken = strSource.Tokenize(strDelimeters, curPos);
};
}
}
ASCOfficePPTXFile/Editor/PPTXElements/AudioOverlay.h 0 → 100644
View file @ c6879804
#pragma once
#include "Elements.h"
namespace NSPresentationEditor
{
class CAudioPart
{
public:
std::wstring m_strFile;
double m_dStartTime;
double m_dEndTime;
double m_dClipStartTime;
double m_dClipEndTime;
double m_dAudioDuration;
bool m_bLoop;
bool m_bStop;
bool m_bIsTransition;
double m_dAmplify;
public:
CAudioPart()
{
m_strFile = _T("");
m_dStartTime = 0.0;
m_dEndTime = -1.0;
m_dClipStartTime = 0.0;
m_dClipEndTime = -1.0;
m_dAudioDuration = 0.0;
m_bLoop = false;
m_bStop = false;
m_bIsTransition = false;
m_dAmplify = 100.0;
}
~CAudioPart()
{
}
CAudioPart(const CAudioPart& oSrc)
{
*this = oSrc;
}
CAudioPart& operator=(const CAudioPart& oSrc)
{
m_strFile = oSrc.m_strFile;
m_dStartTime = oSrc.m_dStartTime;
m_dEndTime = oSrc.m_dEndTime;
m_dClipStartTime = oSrc.m_dClipStartTime;
m_dClipEndTime = oSrc.m_dClipEndTime;
m_dAudioDuration = oSrc.m_dAudioDuration;
m_bLoop = oSrc.m_bLoop;
m_bStop = oSrc.m_bStop;
m_bIsTransition = oSrc.m_bIsTransition;
m_dAmplify = oSrc.m_dAmplify;
return *this;
}
CAudioPart(CAudioElement* pAudioElem)
{
if (NULL == pAudioElem)
{
m_strFile = _T("");
m_dStartTime = 0.0;
m_dEndTime = -1.0;
m_dClipStartTime = 0.0;
m_dClipEndTime = -1.0;
m_dAudioDuration = 0.0;
m_bLoop = false;
m_bStop = false;
m_bIsTransition = false;
m_dAmplify = 100.0;
}
else
{
m_strFile = pAudioElem->m_strAudioFileName;
m_dStartTime = pAudioElem->m_dStartTime;
m_dEndTime = pAudioElem->m_dEndTime;
m_dClipStartTime = pAudioElem->m_dClipStartTime;
m_dClipEndTime = pAudioElem->m_dClipEndTime;
m_dAudioDuration = pAudioElem->m_dAudioDuration;
m_bLoop = ( pAudioElem->m_bLoop == TRUE) ? true : false;;
m_bStop = false;
m_bIsTransition = false;
m_dAmplify = 100.0;
}
}
public:
void CalculateDuration()
{
if (0.0 < m_dAudioDuration || _T("") == m_strFile)
return;
}
};
class CAudioOverlay
{
public:
std::vector<CAudioPart> m_arParts;
double m_dAllDuration;
public:
CAudioOverlay() : m_arParts(), m_dAllDuration(0.0)
{
}
~CAudioOverlay()
{
}
CAudioOverlay(const CAudioOverlay& oSrc)
{
*this = oSrc;
}
CAudioOverlay& operator=(const CAudioOverlay& oSrc)
{
m_arParts.insert(m_arParts.end(), oSrc.m_arParts.begin(), oSrc.m_arParts.end());
m_dAllDuration = oSrc.m_dAllDuration;
return *this;
}
public:
void Calculate()
{
size_t nCount = m_arParts.size();
//
for (size_t i = 0; i < nCount; ++i)
{
CAudioPart* pPart = &m_arParts[i];
pPart->CalculateDuration();
if (pPart->m_dStartTime < 0.0)
pPart->m_dStartTime = 0.0;
pPart->m_dEndTime = pPart->m_dStartTime + pPart->m_dAudioDuration;
if (pPart->m_dEndTime > m_dAllDuration)
{
pPart->m_dEndTime = m_dAllDuration;
}
if (pPart->m_bLoop)
{
pPart->m_dEndTime = m_dAllDuration;
}
}
//
for (size_t i = 0; i < nCount; ++i)
{
CAudioPart* pPart = &m_arParts[i];
if (pPart->m_bIsTransition)
{
if (pPart->m_bStop)
{
//
for (size_t j = 0; j < nCount; ++j)
{
if (j == i)
continue;
CAudioPart* pMem = &m_arParts[j];
if (pMem->m_dStartTime <= pPart->m_dStartTime && pMem->m_dEndTime > pPart->m_dStartTime)
{
pMem->m_dEndTime = pPart->m_dStartTime;
}
}
}
if (pPart->m_bLoop)
{
//
double dMin = m_dAllDuration;
for (size_t j = 0; j < nCount; ++j)
{
if (j == i)
continue;
CAudioPart* pMem = &m_arParts[j];
if (pMem->m_dStartTime > pPart->m_dEndTime)
{
if (dMin > pMem->m_dStartTime)
dMin = pMem->m_dStartTime;
}
}
pPart->m_dEndTime = dMin;
}
}
else
{
if (pPart->m_bLoop)
{
pPart->m_dEndTime = m_dAllDuration;
}
}
}
}
CString GetAudioOverlay()
{
CString strRes = _T("");
size_t nCount = m_arParts.size();
for (size_t i = 0; i < nCount; ++i)
{
CAudioPart* pPart = &m_arParts[i];
CString strOverlay1 = _T("");
CString strOverlay2 = _T("");
strOverlay1.Format(_T("<AudioSource StartTime='%lf' Duration='%lf' Amplify='%lf'>"),
pPart->m_dStartTime, pPart->m_dEndTime - pPart->m_dStartTime, pPart->m_dAmplify);
int lIndex = pPart->m_strFile.find(L"file:///");
if (0 == lIndex)
{
pPart->m_strFile = pPart->m_strFile.substr(8);
//pPart->m_strFile.Replace('/', '\\');
//pPart->m_strFile.Replace(L"%20", L" ");
}
CString strFile_ = std_string2string(pPart->m_strFile);
CorrectXmlString(strFile_);
strOverlay2.Format(_T("<Source StartTime='%lf' EndTime='%lf' FilePath='%s'/></AudioSource>"),
pPart->m_dClipStartTime, pPart->m_dClipEndTime, strFile_);
strOverlay1 += strOverlay2;
strRes += strOverlay1;
}
return strRes;
}
};
}
\ No newline at end of file
ASCOfficePPTXFile/Editor/PPTXElements/Document.h 0 → 100644
View file @ c6879804
#pragma once
#include "AudioOverlay.h"
#include "Slide.h"
namespace NSPresentationEditor
{
class CDocument
{
public:
std::vector<CTheme> m_arThemes;
std::vector<CSlide*> m_arSlides;
CMetricInfo m_oInfo;
public:
CDocument() : m_arThemes(), m_arSlides()
{
}
~CDocument()
{
}
CDocument& operator=(const CDocument& oSrc)
{
m_arThemes = oSrc.m_arThemes;
m_arSlides = oSrc.m_arSlides;
m_oInfo = oSrc.m_oInfo;
return *this;
}
CDocument(const CDocument& oSrc)
{
*this = oSrc;
}
public:
inline void Clear()
{
ClearThemes();
try
{
ClearSlides();
}catch(...)
{
}
}
//
inline void ClearThemes()
{
m_arThemes.clear();
}
inline void AddTheme(const CTheme& oTheme)
{
m_arThemes.push_back(oTheme);
}
inline void UpdateTheme(size_t nIndex, const CTheme& oTheme)
{
if (nIndex >= m_arThemes.size())
return;
m_arThemes[nIndex] = oTheme;
}
//
inline void ClearSlides()
{
for (int i = 0 ; i < m_arSlides.size(); i++)
{
RELEASEOBJECT(m_arSlides[i]);
}
m_arSlides.clear();
}
inline void AddSlide(CSlide* oSlide)
{
m_arSlides.push_back(oSlide);
}
public:
//
CString GetXmlSlideTransition ( CSlide& oSlide/*, CAudioOverlay& oAudioOverlay*/ )
{
CString Source = CString ( _T("") );
int EffectID = 1;
int lEffectDirection = oSlide.m_oSlideShow.m_oTransition.m_nEffectDirection;
switch ( oSlide.m_oSlideShow.m_oTransition.m_nEffectType )
{
case 0 : // Cut
{
// ( , ms )
}
break;
case 1 : // Random //
{
//
EffectID = 1; // Fade Solid Smal
}
break;
case 2 : // Blinds
{
if ( 0x00 == lEffectDirection ) // Vertical // Slide Side Top To Bottom
EffectID = 1003;
if ( 0x01 == lEffectDirection ) // Horizontal // Slide Side Left To Righ
EffectID = 1001;
}
break;
case 3 : // Checker
{
if ( 0x00 == lEffectDirection ) // Horizontal // WipeCheckerRightToLef
EffectID = 2901;
if ( 0x01 == lEffectDirection ) // Vertical // WipeCheckerTopToBottom
EffectID = 2903;
}
break;
case 4 : // Cover
{
//0x00 Left
#pragma message ("TODO : Cover - ImageStudio")
//0x01 Up
//0x02 Right
//0x03 Down
//0x04 Left Up
//0x05 Right Up
//0x06 Left Down
//0x07 Right Down
}
break;
case 5 : // Dissolve
{
#pragma message ("TODO : Dissolve - ImageStudio")
EffectID = 1; // Fade Solid Smal
}
break;
case 6 : // Fade
{
EffectID = 4904; // Flash Dark
}
break;
case 7 : // Uncover
{
#pragma message ("TODO : Uncover - ImageStudio")
//0x00 Left
//0x01 Up
//0x02 Right
//0x03 Down
//0x04 Left Up
//0x05 Right Up
//0x06 Left Down
//0x07 Right Down
}
break;
case 8 : // Random Bars
{
if ( 0x00 == lEffectDirection ) // Horizontal
EffectID = 5331;
if ( 0x01 == lEffectDirection ) // Vertical
EffectID = 5332;
}
break;
case 9 : // Strips
{
if ( 0x04 == lEffectDirection ) // Left Up // Mosaic Right Bottom
EffectID = 110;
if ( 0x05 == lEffectDirection ) // Right Up // Mosaic Left Bottom
EffectID = 111;
if ( 0x06 == lEffectDirection ) // Left Down // Mosaic Right Top
EffectID = 109;
if ( 0x07 == lEffectDirection ) // Right Down // Mosaic Left Top
EffectID = 108;
}
break;
case 10: // Wipe
{
if ( 0x00 == lEffectDirection ) // Left // Reveal, Left
EffectID = 5322;
if ( 0x01 == lEffectDirection ) // Up // Reveal, Up
EffectID = 5323;
if ( 0x02 == lEffectDirection ) // Right // Reveal, Right
EffectID = 5321;
if ( 0x03 == lEffectDirection ) // Down // Reveal, Down
EffectID = 5320;
}
break;
case 11: // Box In/Out
{
if ( 0x00 == lEffectDirection ) // Wipe Center Box Out
EffectID = 702;
if ( 0x01 == lEffectDirection ) // Wipe Center Box In
EffectID = 701;
}
break;
case 13 :// Split
{
if ( 0x00 == lEffectDirection ) // Horizontally out // Split, Horizontal
EffectID = 5324;
#pragma message ("TODO : Split Horizontal In - ImageStudio")
if ( 0x01 == lEffectDirection ) // Horizontally in //
EffectID = 5324;
if ( 0x02 == lEffectDirection ) // Vertically out // Split, Vertical
EffectID = 5325;
#pragma message ("TODO : Split Vertical In - ImageStudio")
if ( 0x03 == lEffectDirection ) // Vertically in //
EffectID = 5325;
}
break;
case 17 : // Diamond
{
EffectID = 704; // Wipe Center Diamond Out
}
break;
case 18 : // Plus
{
EffectID = 708; // Wipe Center Cross Out
}
break;
case 19 : // Wedge
{
EffectID = 3006; // Clock Top Opposite
}
break;
case 20 : // Push
{
if ( 0x00 == lEffectDirection ) // Left // Push Side Right To Left
EffectID = 1402;
if ( 0x01 == lEffectDirection ) // Up // Push Side Bottom To Top
EffectID = 1404;
if ( 0x02 == lEffectDirection ) // Right // Push Side Left To Right
EffectID = 1401;
if ( 0x03 == lEffectDirection ) // Down // Push Side Top To Bottom
EffectID = 1403;
}
break;
case 21 : // Comb
{
if ( 0x00 == lEffectDirection ) // Horizontal // MosaicStrips
EffectID = 103;
#pragma message ("TODO : MosaicStrips Vertical - ImageStudio")
if ( 0x01 == lEffectDirection ) // Vertical // MosaicStrips
EffectID = 103;
}
break;
case 22 : // Newsflash
{
EffectID = 313; // Rotate Twice Out Clockwise
}
break;
case 23 :// AlphaFade
{
EffectID = 1; // Fade Solid Smal
}
break;
case 26 : // Wheel
{
if ( 0x01 == lEffectDirection ) // ClockBottomReverse
EffectID = 3004;
if ( 0x02 == lEffectDirection ) // Clock2AnglesClockwise
EffectID = 3013;
if ( 0x03 == lEffectDirection ) // Clock4AnglesClockwise
EffectID = 3017;
if ( 0x04 == lEffectDirection ) // Clock6AnglesClockwise
EffectID = 3019;
if ( 0x08 == lEffectDirection ) // Clock8AnglesClockwise
EffectID = 3021;
}
break;
case 27 : // Circle
{
EffectID = 706; // Wipe Center Circle Out
}
break;
default :
{
return Source;
}
break;
}
Source.Format ( _T("<VideoCompose Time = \"%lf\" effectid=\"%d\" />"), oSlide.m_oSlideShow.m_oTransition.m_dSpeed, EffectID );
/*
if (oSlide.m_oSlideShow.m_oTransition.m_bAudioPresent)
{
CAudioElement oAudioElem;
oAudioElem.m_dStartTime = oSlide.m_dStartTime - oSlide.m_oSlideShow.m_oTransition.m_dSpeed;
oAudioElem.m_dEndTime = oAudioOverlay.m_dAllDuration;
oAudioElem.m_strFileName = oSlide.m_oSlideShow.m_oTransition.m_oAudio.m_strFileName;
CAudioPart oPart(&oAudioElem);
oPart.m_bStop = oSlide.m_oSlideShow.m_oTransition.m_bStopSound;
oPart.m_bLoop = oSlide.m_oSlideShow.m_oTransition.m_bLoopSound;
oPart.m_bIsTransition = true;
oAudioOverlay.m_arParts.Add(oPart);
}
*/
return Source;
}
double CalculateTimes(CAudioOverlay& oAudioOverlay)
{
CaclulateSlideTimes();
int lCount = (LONG)m_arSlides.size();
double dAllDuration = 0;
if (lCount > 0)
{
dAllDuration = m_arSlides[lCount - 1]->m_dEndTime;
}
oAudioOverlay.m_dAllDuration = dAllDuration;
for (LONG i = 0; i < lCount; ++i)
{
CalculateSlideElements(i, oAudioOverlay);
}
return dAllDuration;
}
void CaclulateSlideTimes()
{
double Transition1 = 0;
double Duration = 0;
double Transition2 = 0;
int nCount = (int)m_arSlides.size();
for (int i = 0; i < nCount; ++i)
{
CSlide* pSlide = m_arSlides[i];
double dSlideDuration = 0;
if (pSlide->m_oSlideShow.m_dSlideDuration > 0)
{
dSlideDuration = m_arSlides[i]->m_oSlideShow.m_dSlideDuration;
}
if (0 == dSlideDuration)
{
// : -
// , . - ,
//
size_t nSize = pSlide->m_arElements.size();
for (size_t j = 0; j < nSize; ++j)
{
if (etVideo == pSlide->m_arElements[j]->m_etType)
{
dSlideDuration = (std::max)(dSlideDuration, ((CVideoElement*)pSlide->m_arElements[j])->m_dVideoDuration);
}
}
if (0 == dSlideDuration)
{
dSlideDuration = pSlide->m_dDuration;
}
}
pSlide->m_dDuration = dSlideDuration;
Transition1 = pSlide->m_oSlideShow.m_oTransition.m_dSpeed;
if (i < (nCount - 1))
Transition2 = m_arSlides[i + 1]->m_oSlideShow.m_oTransition.m_dSpeed;
Duration = pSlide->m_dDuration;
if (i == 0)
{
pSlide->m_dStartTime = Transition1;
}
else
{
pSlide->m_dStartTime = m_arSlides[i-1]->m_dStartTime + m_arSlides[i-1]->m_dDuration;
}
pSlide->m_dDuration = Transition1 + Duration + Transition2;
pSlide->m_dEndTime = pSlide->m_dStartTime + pSlide->m_dDuration;
}
}
void CalculateSlideElements(int nIndex, CAudioOverlay& oAudioOverlay)
{
double dStartTime = m_arSlides[nIndex]->m_dStartTime;
double dEndTime = m_arSlides[nIndex]->m_dEndTime;
double dDuration = m_arSlides[nIndex]->m_dDuration;
CSlide* pSlide = m_arSlides[nIndex];
size_t nCountElems = pSlide->m_arElements.size();
for (size_t i = 0; i < nCountElems; ++i)
{
IElement* pElement = pSlide->m_arElements[i];
switch (pElement->m_etType)
{
//case etPicture:
//case etShape:
//case etVideo:
//case etText:
// {
// //pElement->m_dStartTime = 0;
// //pElement->m_dEndTime = dDuration;
//
// break;
// }
case etAudio:
{
CAudioElement* pAudioElem = dynamic_cast<CAudioElement*>(pElement);
if (NULL != pAudioElem)
{
//
if (pAudioElem->m_bWithVideo)
{
pElement->m_dStartTime = dStartTime;
pElement->m_dEndTime = dEndTime;
}
else if (pAudioElem->m_bLoop)
{
pElement->m_dStartTime = dStartTime;
pElement->m_dEndTime = oAudioOverlay.m_dAllDuration/* - dStartTime*/;
}
else
{
pElement->m_dStartTime = dStartTime;
pElement->m_dEndTime = (std::min)(dStartTime + pAudioElem->m_dAudioDuration, oAudioOverlay.m_dAllDuration/* - dStartTime*/);
}
CAudioPart oPart(pAudioElem);
oAudioOverlay.m_arParts.push_back(oPart);
}
break;
}
default:
//{
//pElement->m_dStartTime = 0;
//pElement->m_dEndTime = dDuration;
break;
//}
};
}
}
public:
void ResetAutoText(IElement *pElement, vector_string const (&placeholdersReplaceString)[3])
{
CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement);
if (NULL == pShape) return;
if (pElement->m_lPlaceholderType == NSOfficePPT::MasterSlideNumber) pShape->SetUpTextPlaceholder(L"<#>");
int ind = -1;
if (pElement->m_lPlaceholderType == NSOfficePPT::MasterDate) ind = 0;
if (pElement->m_lPlaceholderType == NSOfficePPT::MasterFooter) ind = 2;
if (pElement->m_lPlaceholderUserStr >= 0 && ind >= 0)
{
if (pElement->m_lPlaceholderUserStr < placeholdersReplaceString[ind].size())
pShape->SetUpTextPlaceholder( placeholdersReplaceString[ind][pElement->m_lPlaceholderUserStr] );
else pShape->SetUpTextPlaceholder(L"");
}
else
{
if (pElement->m_lPlaceholderType == NSOfficePPT::MasterDate)
pShape->SetUpTextPlaceholder(L"*"); //
}
}
void CalculateEditor(const NSPresentationEditor::CMetricInfo& oInfo, bool bIsPlaceholderSetUp = false)
{
//
m_oInfo = oInfo;
double dScaleX = (double)m_oInfo.m_lMillimetresHor / m_oInfo.m_lUnitsHor;
double dScaleY = (double)m_oInfo.m_lMillimetresVer / m_oInfo.m_lUnitsVer;
size_t nCountThemes = m_arThemes.size();
for (size_t i = 0; i < nCountThemes; ++i)
{
CTheme* pTheme = &m_arThemes[i];
pTheme->CalculateStyles();
size_t nCountElems = pTheme->m_arElements.size();
for (size_t nIndexEl = 0; nIndexEl < nCountElems; ++nIndexEl)
{
IElement* pElement = pTheme->m_arElements[nIndexEl];
if (pElement->m_lPlaceholderType > 0)
{
ResetAutoText(pElement, pTheme->m_PlaceholdersReplaceString);
}
pElement->m_pTheme = pTheme;
pElement->m_pLayout = NULL;
pElement->m_oMetric = m_oInfo;
pElement->NormalizeCoords(dScaleX, dScaleY);
pElement->SetupProperties(NULL, pTheme, NULL);
}
size_t nCountLayouts = pTheme->m_arLayouts.size();
for (size_t nIndexL = 0; nIndexL < nCountLayouts; ++nIndexL)
{
CLayout* pLayout = &pTheme->m_arLayouts[nIndexL];
pLayout->m_lOriginalWidth = m_oInfo.m_lUnitsHor;
pLayout->m_lOriginalHeight = m_oInfo.m_lUnitsVer;
pLayout->m_lWidth = m_oInfo.m_lMillimetresHor;
pLayout->m_lHeight = m_oInfo.m_lMillimetresVer;
size_t nCountLayoutElements = pLayout->m_arElements.size();
for (size_t nIndexLayoutEl = 0; nIndexLayoutEl < nCountLayoutElements; ++nIndexLayoutEl)
{
IElement* pElement = pLayout->m_arElements[nIndexLayoutEl];
if (pElement->m_lPlaceholderType > 0)
{
ResetAutoText(pElement, pLayout->m_PlaceholdersReplaceString);
}
pElement->m_oMetric = m_oInfo;
pElement->NormalizeCoords(dScaleX, dScaleY);
pElement->m_pTheme = pTheme;
pElement->m_pLayout = NULL;
CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement);
if (!pLayout->m_bUseThemeColorScheme && NULL != pShape)
{
int lPhType = pElement->m_lPlaceholderType;
int lIndex = 0;
if (isTitlePlaceholder(lPhType)) lIndex = 1;
else if (isBodyPlaceholder(lPhType)) lIndex = 2;
else if (-1 != lPhType) lIndex = 3;
CTextStyles* pThemeStyles = &pTheme->m_pStyles[lIndex];
for (int nIndexLevel = 0; nIndexLevel < 10; ++nIndexLevel)
{
if (!pThemeStyles->m_pLevels[nIndexLevel].is_init())
continue;
if (!pThemeStyles->m_pLevels[nIndexLevel]->m_oCFRun.Color.is_init())
continue;
if (pThemeStyles->m_pLevels[nIndexLevel]->m_oCFRun.Color->m_lSchemeIndex == -1)
continue;
if (pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0].is_init())
{
if (pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color.is_init())
{
if (pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->m_lSchemeIndex != -1)
continue;
LONG lIndexSchemeT = pThemeStyles->m_pLevels[nIndexLevel]->m_oCFRun.Color->m_lSchemeIndex;
pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->m_lSchemeIndex = -1;
pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->R = pLayout->m_arColorScheme[lIndexSchemeT].R;
pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->G = pLayout->m_arColorScheme[lIndexSchemeT].G;
pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->B = pLayout->m_arColorScheme[lIndexSchemeT].B;
bIsPlaceholderSetUp = true;
}
}
}
}
pElement->SetupProperties(NULL, pTheme, pLayout);
}
}
}
size_t nCountSlides = m_arSlides.size();
for (size_t i = 0; i < nCountSlides; ++i)
{
CSlide* pSlide = m_arSlides[i];
pSlide->m_lOriginalWidth = m_oInfo.m_lUnitsHor;
pSlide->m_lOriginalHeight = m_oInfo.m_lUnitsVer;
pSlide->m_lWidth = m_oInfo.m_lMillimetresHor;
pSlide->m_lHeight = m_oInfo.m_lMillimetresVer;
CTheme* pTheme = NULL;
if ((0 <= pSlide->m_lThemeID) && (pSlide->m_lThemeID < (LONG)nCountThemes))
pTheme = &m_arThemes[pSlide->m_lThemeID];
CLayout* pLayout = NULL;
if (NULL != pTheme)
{
if ((0 <= pSlide->m_lLayoutID) && (pSlide->m_lLayoutID < (LONG)pTheme->m_arLayouts.size()))
pLayout = &pTheme->m_arLayouts[pSlide->m_lLayoutID];
}
size_t nCountElems = pSlide->m_arElements.size();
for (size_t nIndexEl = 0; nIndexEl < nCountElems; ++nIndexEl)
{
IElement* pElement = pSlide->m_arElements[nIndexEl];
if (pElement->m_lPlaceholderType > 0)
{
ResetAutoText(pElement, pSlide->m_PlaceholdersReplaceString);
}
pElement->m_pTheme = pTheme;
pElement->m_pLayout = pLayout;
pElement->m_oMetric = m_oInfo;
pElement->SetupProperties(pSlide, pTheme, pLayout);
}
if (NULL != pLayout && bIsPlaceholderSetUp)
pSlide->SetUpPlaceholderStyles(pLayout);
}
}
};
}
ASCOfficePPTXFile/Editor/PPTXElements/Effects.h 0 → 100644
View file @ c6879804
#pragma once
#include <vector>
#if defined(_WIN32) || defined (_WIN64)
#include <atlbase.h>
#include <atlstr.h>
#else
#include "../../Common/DocxFormat/Source/Base/ASCString.h"
#endif
namespace NSPresentationEditor
{
class CEffect
{
public:
CString m_strEffect;
public:
CEffect() : m_strEffect(_T(""))
{
}
CEffect& operator=(const CEffect& oSrc)
{
m_strEffect = oSrc.m_strEffect;
return *this;
}
CEffect(const CEffect& oSrc)
{
*this = oSrc;
}
~CEffect()
{
}
};
class CEffects
{
public:
std::vector<CEffect> m_arEffects;
public:
CEffects() : m_arEffects()
{
}
CEffects& operator=(const CEffects& oSrc)
{
m_arEffects.insert(m_arEffects.end(), oSrc.m_arEffects.begin(), oSrc.m_arEffects.end());
return *this;
}
CEffects(const CEffects& oSrc)
{
*this = oSrc;
}
~CEffects()
{
}
};
}
ASCOfficePPTXFile/Editor/PPTXElements/Element.h 0 → 100644
View file @ c6879804
#pragma once
#include "TextAttributesEx.h"
#include "Interactive.h"
#include "Animations.h"
#include "ElementProperties.h"
namespace NSPresentationEditor
{
enum ElementType
{
etVideo = 0,
etAudio = 1,
etPicture = 2,
etShape = 3,
etText = 4
};
enum enumPlaceholderType
{
PT_None = 0,
PT_MasterTitle,
PT_MasterBody,
PT_MasterCenterTitle,
PT_MasterSubTitle,
PT_MasterNotesSlideImage,
PT_MasterNotesBody,
PT_MasterDate,
PT_MasterSlideNumber,
PT_MasterFooter,
PT_MasterHeader,
PT_NotesSlideImage,
PT_NotesBody,
PT_Title,
PT_Body,
PT_CenterTitle,
PT_SubTitle,
PT_VerticalTitle,
PT_VerticalBody,
PT_Object,
PT_Graph,
PT_Table,
PT_ClipArt,
PT_OrgChart,
PT_Media,
PT_VerticalObject,
PT_Picture
};
static void CorrectPlaceholderType(int & type)
{
switch (type)
{
case PT_MasterTitle: type = PT_Title; break;
case PT_MasterBody: type = PT_Body; break;
case PT_MasterCenterTitle: type = PT_CenterTitle; break;
case PT_MasterSubTitle: type = PT_SubTitle; break;
case PT_MasterNotesSlideImage: type = PT_NotesSlideImage; break;
case PT_MasterNotesBody: type = PT_NotesBody; break;
}
}
static bool isTitlePlaceholder(int type)
{
switch (type)
{
case PT_MasterTitle:
case PT_MasterCenterTitle:
case PT_Title:
case PT_CenterTitle:
case PT_VerticalTitle:
return true;
default:
return false;
}
}
static bool isBodyPlaceholder(int type)
{
switch (type)
{
case PT_MasterBody:
case PT_Body:
case PT_VerticalBody:
return true;
default:
return false;
}
}
class CTheme;
class CLayout;
class CSlide;
class IElement
{
public:
ElementType m_etType;
CDoubleRect m_rcBounds;
CDoubleRect m_rcBoundsOriginal;
bool m_bBoundsEnabled;
double m_dStartTime;
double m_dEndTime;
CInteractiveInfo m_oActions;
CAnimationInfo m_oAnimations;
CEffects m_oEffects;
CPen m_oPen;
CBrush m_oBrush;
CShadow m_oShadow;
int m_lID;
int m_lLayoutID;
int m_lPlaceholderID;
int m_lPlaceholderType;
bool m_bPlaceholderSet;
int m_lPlaceholderSizePreset;
int m_lPlaceholderUserStr;
int m_nFormatDate;
//
CMetricInfo m_oMetric;
double m_dRotate; //
bool m_bFlipH; //
bool m_bFlipV; //
bool m_bLine;
bool m_bIsBackground;
bool m_bHaveAnchor;
bool m_bIsChangeable; //
CElementProperties m_oProperties;
CTheme* m_pTheme;
CLayout* m_pLayout;
std::wstring m_sName;
std::wstring m_sDescription;
std::wstring m_sHyperlink;
protected:
ULONG m_lCountRef;
public:
virtual ULONG AddRef()
{
++m_lCountRef;
return m_lCountRef;
}
virtual ULONG Release()
{
--m_lCountRef;
if (0 == m_lCountRef)
{
delete this;
return 0;
}
return m_lCountRef;
}
public:
IElement()
{
m_bIsBackground = false;
m_bHaveAnchor = true;
m_bIsChangeable = true;
m_lID = -1;
m_lLayoutID = -1;
m_lPlaceholderID = -1;
m_lPlaceholderType = -1;
m_bPlaceholderSet = false;
m_lPlaceholderSizePreset = -1;
m_lPlaceholderUserStr = -1;
m_nFormatDate = 1;
m_etType = etPicture;
m_bBoundsEnabled = true;
m_rcBounds.left = 0;
m_rcBounds.top = 0;
m_rcBounds.right = 1;
m_rcBounds.bottom = 1;
m_rcBoundsOriginal.left = 0;
m_rcBoundsOriginal.top = 0;
m_rcBoundsOriginal.right = 1;
m_rcBoundsOriginal.bottom = 1;
m_dStartTime = 0.0;
m_dEndTime = 30.0;
m_dRotate = 0.0;
m_bFlipH = false;
m_bFlipV = false;
m_bLine = true;
m_lCountRef = 1;
m_pTheme = NULL;
m_pLayout = NULL;
}
virtual ~IElement()
{
}
virtual void NormalizeCoords(double dScaleX, double dScaleY)
{
m_rcBounds.left = dScaleX * m_rcBoundsOriginal.left;
m_rcBounds.right = dScaleX * m_rcBoundsOriginal.right;
m_rcBounds.top = dScaleY * m_rcBoundsOriginal.top;
m_rcBounds.bottom = dScaleY * m_rcBoundsOriginal.bottom;
}
virtual void NormalizeCoordsByMetric()
{
double dScaleX = (double)m_oMetric.m_lUnitsHor / m_oMetric.m_lMillimetresHor;
double dScaleY = (double)m_oMetric.m_lUnitsVer / m_oMetric.m_lMillimetresVer;
m_rcBoundsOriginal.left = dScaleX * m_rcBounds.left;
m_rcBoundsOriginal.right = dScaleX * m_rcBounds.right;
m_rcBoundsOriginal.top = dScaleY * m_rcBounds.top;
m_rcBoundsOriginal.bottom = dScaleY * m_rcBounds.bottom;
}
protected:
virtual void SetProperiesToDublicate(IElement* pDublicate)
{
if (NULL == pDublicate)
return;
pDublicate->m_bBoundsEnabled = m_bBoundsEnabled;
pDublicate->m_bIsBackground = m_bIsBackground;
pDublicate->m_bHaveAnchor = m_bHaveAnchor;
pDublicate->m_bIsChangeable = m_bIsChangeable;
pDublicate->m_etType = m_etType;
pDublicate->m_rcBounds = m_rcBounds;
pDublicate->m_rcBoundsOriginal = m_rcBoundsOriginal;
pDublicate->m_dStartTime = m_dStartTime;
pDublicate->m_dEndTime = m_dEndTime;
pDublicate->m_lID = m_lID;
pDublicate->m_lLayoutID = m_lLayoutID;
pDublicate->m_oActions = m_oActions;
pDublicate->m_oAnimations = m_oAnimations;
pDublicate->m_oEffects = m_oEffects;
pDublicate->m_lPlaceholderID = m_lPlaceholderID;
pDublicate->m_lPlaceholderType = m_lPlaceholderType;
pDublicate->m_bPlaceholderSet = m_bPlaceholderSet;
pDublicate->m_lPlaceholderSizePreset = m_lPlaceholderSizePreset;
pDublicate->m_lPlaceholderUserStr = m_lPlaceholderUserStr;
pDublicate->m_nFormatDate = m_nFormatDate;
pDublicate->m_oMetric = m_oMetric;
pDublicate->m_oProperties = m_oProperties;
pDublicate->m_dRotate = m_dRotate;
pDublicate->m_bFlipH = m_bFlipH;
pDublicate->m_bFlipV = m_bFlipV;
pDublicate->m_bLine = m_bLine;
pDublicate->m_pTheme = m_pTheme;
pDublicate->m_pLayout = m_pLayout;
pDublicate->m_oPen = m_oPen;
pDublicate->m_oBrush = m_oBrush;
pDublicate->m_oShadow = m_oShadow;
}
public:
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);
}
}
virtual void SetupProperty(CSlide* pSlide, CTheme* pTheme, CLayout* pLayout, CElementProperty* pProperty) = 0;
virtual IElement* CreateDublicate() = 0;
virtual CString SerializeToXml()
{
CString strElement = _T("");
strElement.Format(_T("<Element type='%d' id='%d' lid='%d' pid='%d' ptp='%d' />"),
(int)m_etType, m_lID, m_lLayoutID, m_lPlaceholderID, m_lPlaceholderType);
return strElement;
}
};
}
\ No newline at end of file
ASCOfficePPTXFile/Editor/PPTXElements/ElementProperties.h 0 → 100644
View file @ c6879804
#pragma once
#include <map>
namespace NSPresentationEditor
{
class CElementProperty
{
public:
enum Type
{
epNil = 0,
//----------Transform----------------
epTop = 1,
epLeft = 2,
epRight = 3,
epBottom = 4,
epRotate = 5,
epFlipV = 6,
epFlipH = 7,
//----------Geometry-----------------
epAdjustments = 10,
epGuides = 11,
epPath = 12,
//----------Pen properties-----------
epPenIndex = 20,
epPenColor = 21,
epPenAlpha = 22,
epPenWidth = 23,
epPenJoin = 24,
epLineDash = 25,
epLineEndCap = 26,
epLineStartCap = 27,
epStroked = 28,
//----------Brush properties----------
epBrushTypeIndex = 40,
epBrushType = 41,
epBrushColor1 = 42,
epBrushColor2 = 43,
epBrushAlpha1 = 44,
epBrushAlpha2 = 45,
epBrushTxMode = 46,
epBrushLinearAngle = 47,
epBrushColors = 48,
epBrushTxPath = 49,
epFilled = 50,
//----------Text----------------------
epText = 60,
epTextMarginLeft = 61,
epTextMarginTop = 62,
epTextMarginRight = 63,
epTextMarginBottom = 64,
epTextWrap = 65,
//----------Font----------------------
epFontName = 80,
epFontSize = 81,
epFontVertAlign = 82,
epFontHorAlign = 83,
epFontItalic = 84,
epFontBold = 85,
epFontStrikeout = 86,
epFontUnderline = 87,
//----------Effects-------------------
epEffectIndex = 100,
//----------3D------------------------
//----------Shadow--------------------
//----------Edge----------------------
};
public:
CElementProperty(const Type& type = epNil)
{
m_ID = type;
m_dwValue = 0;
}
CElementProperty(const CElementProperty& oSrc)
{
*this = oSrc;
}
CElementProperty& operator=(const CElementProperty& oSrc)
{
m_ID = oSrc.m_ID;
m_dwValue = oSrc.m_dwValue;
m_strAdvanced = oSrc.m_strAdvanced;
return *this;
}
public:
Type m_ID;
DWORD m_dwValue;
std::wstring m_strAdvanced;
};
class CElementProperties
{
public:
std::map<CElementProperty::Type, CElementProperty> m_arProperties;
public:
CElementProperties() : m_arProperties()
{
}
public:
CElementProperties& operator=(const CElementProperties& oSrc)
{
m_arProperties.clear();
for (std::map<CElementProperty::Type, CElementProperty>::const_iterator pPair = oSrc.m_arProperties.begin(); pPair != oSrc.m_arProperties.end(); ++pPair)
{
CElementProperty oProperty = pPair->second;
m_arProperties[oProperty.m_ID] = oProperty;
}
return *this;
}
CElementProperties(const CElementProperties& oSrc)
{
*this = oSrc;
}
virtual ~CElementProperties()
{
m_arProperties.clear();
}
inline void SetAt(const CElementProperty::Type& eType, const DWORD& dwValue)
{
CElementProperty oProp(eType);
oProp.m_dwValue = dwValue;
m_arProperties[eType] = oProp;
}
inline void SetAt(const CElementProperty::Type& eType, const BYTE& nValue)
{
CElementProperty oProp(eType);
oProp.m_dwValue = (DWORD)nValue;
m_arProperties[eType] = oProp;
}
inline void SetAt(const CElementProperty::Type& eType, const long& lValue)
{
CElementProperty oProp(eType);
oProp.m_dwValue = (DWORD)lValue;
m_arProperties[eType] = oProp;
}
inline void SetAt(const CElementProperty::Type& eType, const bool& bValue)
{
CElementProperty oProp(eType);
oProp.m_dwValue = (true == bValue) ? 1 : 0;
m_arProperties[eType] = oProp;
}
inline void SetAt(const CElementProperty::Type& eType, std::wstring strValue)
{
CElementProperty oProp(eType);
oProp.m_dwValue = strValue.length() + 1;
oProp.m_strAdvanced = strValue;
m_arProperties[eType] = oProp;
}
};
}
/*
enum PropertyId
{
//Transform
left=0,
top=1,
right=2,
bottom=3,
rotation=4,
gvPage=5,
fChangePage=61,
fFlipV=62,
fFlipH=63,
//Protection
fLockAgainstUngrouping=118,
fLockRotation=119,
fLockAspectRatio=120,
fLockPosition=121,
fLockAgainstSelect=122,
fLockCropping=123,
fLockVertices=124,
fLockText=125,
fLockAdjustHandles=126,
fLockAgainstGrouping=127,
//Text
lTxid=128,
dxTextLeft=129,
dyTextTop=130,
dxTextRight=131,
dyTextBottom=132,
WrapText=133,
scaleText=134,
anchorText=135,
txflTextFlow=136,
cdirFont=137,
hspNext=138,
txdir=139,
ccol=140,
dzColMargin=141,
fSelectText=187,
fAutoTextMargin=188,
fRotateText=189,
fFitShapeToText=190,
fFitTextToShape=191,
//GeoText
gtextUNICODE=192,
gtextRTF=193,
gtextAlign=194,
gtextSize=195,
gtextSpacing=196,
gtextFont=197,
gtextCSSFont=198,
gtextFReverseRows=240,
fGtext=241,
gtextFVertical=242,
gtextFKern=243,
gtextFTight=244,
gtextFStretch=245,
gtextFShrinkFit=246,
gtextFBestFit=247,
gtextFNormalize=248,
gtextFDxMeasure=249,
gtextFBold=250,
gtextFItalic=251,
gtextFUnderline=252,
gtextFShadow=253,
gtextFSmallcaps=254,
gtextFStrikethrough=255,
//BLIP
cropFromTop=256,
cropFromBottom=257,
cropFromLeft=258,
cropFromRight=259,
Pib=260,
pibName=261,
pibFlags=262,
pictureTransparent=263,
pictureContrast=264,
pictureBrightness=265,
pictureGamma=266,
pictureId=267,
pictureDblCrMod=268,
pictureFillCrMod=269,
pictureLineCrMod=270,
pibPrint=271,
pibPrintName=272,
pibPrintFlags=273,
movie=274,
pictureRecolor=282,
picturePreserveGrays=313,
fRewind=314,
fLooping=315,
pictureGray=317,
pictureBiLevel=318,
pictureActive=319,
//Geometry
geoLeft=320,
geoTop=321,
geoRight=322,
geoBottom=323,
shapePath=324,
pVertices=325,
pSegmentInfo=326,
adjustValue=327,
adjust2Value=328,
adjust3Value=329,
adjust4Value=330,
adjust5Value=331,
adjust6Value=332,
adjust7Value=333,
adjust8Value=334,
adjust9Value=335,
adjust10Value=336,
pConnectionSites=337,
pConnectionSitesDir=338,
xLimo=339,
yLimo=340,
pAdjustHandles=341,
pGuides=342,
pInscribe=343,
cxk=344,
pFragments=345,
fColumnLineOK=377,
fShadowOK=378,
f3DOK=379,
fLineOK=380,
fGtextOK=381,
fFillShadeShapeOK=382,
fFillOK=383,
//Fill Style
fillType=384,
fillColor=385,
fillOpacity=386,
fillBackColor=387,
fillBackOpacity=388,
fillCrMod=389,
fillBlip=390,
fillBlipName=391,
fillBlipFlags=392,
fillWidth=393,
fillHeight=394,
fillAngle=395,
fillFocus=396,
fillToLeft=397,
fillToTop=398,
fillToRight=399,
fillToBottom=400,
fillRectLeft=401,
fillRectTop=402,
fillRectRight=403,
fillRectBottom=404,
fillDztype=405,
fillShadePreset=406,
fillShadeColors=407,
fillOriginX=408,
fillOriginY=409,
fillShapeOriginX=410,
fillShapeOriginY=411,
fillShadeType=412,
fRecolorFillAsPicture=441,
fUseShapeAnchor=442,
fFilled=443,
fHitTestFill=444,
fillShape=445,
fillUseRect=446,
fNoFillHitTest=447,
//Line Style
lineColor=448,
lineOpacity=449,
lineBackColor=450,
lineCrMod=451,
lineType=452,
lineFillBlip=453,
lineFillBlipName=454,
lineFillBlipFlags=455,
lineFillWidth=456,
lineFillHeight=457,
lineFillDztype=458,
lineWidth=459,
lineMiterLimit=460,
lineStyle=461,
lineDashing=462,
lineDashStyle=463,
lineStartArrowhead=464,
lineEndArrowhead=465,
lineStartArrowWidth=466,
lineStartArrowLength=467,
lineEndArrowWidth=468,
lineEndArrowLength=469,
lineJoinStyle=470,
lineEndCapStyle=471,
fInsetPen=505,
fInsetPenOK=506,
fArrowheadsOK=507,
fLine=508,
fHitTestLine=509,
lineFillShape=510,
fNoLineDrawDash=511,
//Shadow Style
shadowType=512,
shadowColor=513,
shadowHighlight=514,
shadowCrMod=515,
shadowOpacity=516,
shadowOffsetX=517,
shadowOffsetY=518,
shadowSecondOffsetX=519,
shadowSecondOffsetY=520,
shadowScaleXToX=521,
shadowScaleYToX=522,
shadowScaleXToY=523,
shadowScaleYToY=524,
shadowPerspectiveX=525,
shadowPerspectiveY=526,
shadowWeight=527,
shadowOriginX=528,
shadowOriginY=529,
fShadow=574,
fshadowObscured=575,
//Perspective Style
perspectiveType=576,
perspectiveOffsetX=577,
perspectiveOffsetY=578,
perspectiveScaleXToX=579,
perspectiveScaleYToX=580,
perspectiveScaleXToY=581,
perspectiveScaleYToY=582,
perspectivePerspectiveX=583,
perspectivePerspectiveY=584,
perspectiveWeight=585,
perspectiveOriginX=586,
perspectiveOriginY=587,
fPerspective=639,
//3D Object
c3DSpecularAmt=640,
c3DDiffuseAmt=641,
c3DShininess=642,
c3DEdgeThickness=643,
C3DExtrudeForward=644,
c3DExtrudeBackward=645,
c3DExtrudePlane=646,
c3DExtrusionColor=647,
c3DCrMod=648,
f3D=700,
fc3DMetallic=701,
fc3DUseExtrusionColor=702,
fc3DLightFace=703,
//3D Style
c3DYRotationAngle=704,
c3DXRotationAngle=705,
c3DRotationAxisX=706,
c3DRotationAxisY=707,
c3DRotationAxisZ=708,
c3DRotationAngle=709,
c3DRotationCenterX=710,
c3DRotationCenterY=711,
c3DRotationCenterZ=712,
c3DRenderMode=713,
c3DTolerance=714,
c3DXViewpoint=715,
c3DYViewpoint=716,
c3DZViewpoint=717,
c3DOriginX=718,
c3DOriginY=719,
c3DSkewAngle=720,
c3DSkewAmount=721,
c3DAmbientIntensity=722,
c3DKeyX=723,
c3DKeyY=724,
c3DKeyZ=725,
c3DKeyIntensity=726,
c3DFillX=727,
c3DFillY=728,
c3DFillZ=729,
c3DFillIntensity=730,
fc3DConstrainRotation=763,
fc3DRotationCenterAuto=764,
fc3DParallel=765,
fc3DKeyHarsh=766,
fc3DFillHarsh=767,
//Shape
hspMaster=769,
cxstyle=771,
bWMode=772,
bWModePureBW=773,
bWModeBW=774,
idDiscussAnchor=775,
dgmLayout=777,
dgmNodeKind=778,
dgmLayoutMRU=779,
wzEquationXML=780,
fPolicyLabel=822,
fPolicyBarcode=823,
fFlipHQFE5152=824,
fFlipVQFE5152=825,
fPreferRelativeResize=827,
fLockShapeType=828,
fInitiator=829,
fDeleteAttachedObject=830,
fBackground=831,
//Callout
spcot=832,
dxyCalloutGap=833,
spcoa=834,
spcod=835,
dxyCalloutDropSpecified=836,
dxyCalloutLengthSpecified=837,
fCallout=889,
fCalloutAccentBar=890,
fCalloutTextBorder=891,
fCalloutMinusX=892,
fCalloutMinusY=893,
fCalloutDropAuto=894,
fCalloutLengthSpecified=895,
//Groupe Shape
wzName=896,
wzDescription=897,
pihlShape=898,
pWrapPolygonVertices=899,
dxWrapDistLeft=900,
dyWrapDistTop=901,
dxWrapDistRight=902,
dyWrapDistBottom=903,
lidRegroup=904,
groupLeft=905,
groupTop=906,
groupRight=907,
groupBottom=908,
wzTooltip=909,
wzScript=910,
posh=911,
posrelh=912,
posv=913,
posrelv=914,
pctHR=915,
alignHR=916,
dxHeightHR=917,
dxWidthHR=918,
wzScriptExtAttr=919,
scriptLang=920,
wzScriptIdAttr=921,
wzScriptLangAttr=922,
borderTopColor=923,
borderLeftColor=924,
borderBottomColor=925,
borderRightColor=926,
tableProperties=927,
tableRowProperties=928,
scriptHtmlLocation=929,
wzApplet=930,
wzFrameTrgtUnused=932,
wzWebBot=933,
wzAppletArg=934,
wzAccessBlob=936,
metroBlob=937,
dhgt=938,
fLayoutInCell=944,
fIsBullet=945,
fStandardHR=946,
fNoshadeHR=947,
fHorizRule=948,
fUserDrawn=949,
fAllowOverlap=950,
fReallyHidden=951,
fScriptAnchor=952,
//Unknown HTML
wzLineId=1026,
wzFillId=1027,
wzPictureId=1028,
wzPathId=1029,
wzShadowId=1030,
wzPerspectiveId=1031,
wzGtextId=1032,
wzFormulaeId=1033,
wzHandlesId=1034,
wzCalloutId=1035,
wzLockId=1036,
wzTextId=1037,
wzThreeDId=1038,
FakeShapeType=1039,
fFakeMaster=1086,
//Diagramm
dgmt=1280,
dgmStyle=1281,
pRelationTbl=1284,
dgmScaleX=1285,
dgmScaleY=1286,
dgmDefaultFontSize=1287,
dgmConstrainBounds=1288,
dgmBaseTextScale=1289,
fBorderlessCanvas=1338,
fNonStickyInkCanvas=1339,
fDoFormat=1340,
fReverse=1341,
fDoLayout=1342,
fPseudoInline=1343,
// dashing
lineLeftDashStyle=1359,
lineTopDashStyle=1423,
lineRightDashStyle=1487,
lineBottomDashStyle=1551,
//Web Component
webComponentWzHtml=1664,
webComponentWzName=1665,
webComponentWzUrl=1666,
webComponentWzProperties=1667,
fIsWebComponent=1727,
//Clip
pVerticesClip=1728,
pSegmentInfoClip=1729,
shapePathClip=1730,
fClipToWrap=1790,
fClippedOK=1791,
//Ink
pInkData=1792,
fInkAnnotation=1852,
fHitTestInk=1853,
fRenderShape=1854,
fRenderInk=1855,
//Signature
wzSigSetupId=1921,
wzSigSetupProvId=192,
wzSigSetupSuggSigner=1923,
wzSigSetupSuggSigner2=1924,
wzSigSetupSuggSignerEmail=1925,
wzSigSetupSignInst=1926,
wzSigSetupAddlXml=1927,
wzSigSetupProvUrl=1928,
fSigSetupShowSignDate=1980,
fSigSetupAllowComments=1981,
fSigSetupSignInstSet=1982,
fIsSignatureLine=1983,
//Groupe Shape 2
pctHoriz=1984,
pctVert=1985,
pctHorizPos=1986,
pctVertPos=1987,
sizerelh=1988,
sizerelv=1989,
colStart=1990,
colSpan=1991
};
*/
\ No newline at end of file
ASCOfficePPTXFile/Editor/PPTXElements/Elements.cpp 0 → 100644
View file @ c6879804

#include "Slide.h"
void NSPresentationEditor::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;
}
void NSPresentationEditor::CShapeElement::SetupTextProperties(CSlide* pSlide, CTheme* pTheme, CLayout* pLayout)
{
NSPresentationEditor::CTextAttributesEx* pAttributes = &m_oShape.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->Typeface.is_init()) && (pRun->Typeface.get() < pTheme->m_arFonts.size()))
{
pRun->FontProperties = new CFontProperties();
pRun->FontProperties->SetFont(pTheme->m_arFonts[pRun->Typeface.get()]);
if (1 < pRun->Typeface.get())
pRun->Typeface.reset();
}
if ((pRun->EAFontRef.is_init()) && (pRun->EAFontRef.get() < pTheme->m_arFonts.size()))
{
pRun->FontPropertiesEA = new CFontProperties();
pRun->FontPropertiesEA->SetFont(pTheme->m_arFonts[pRun->EAFontRef.get()]);
}
if ((pRun->SymbolFontRef.is_init()) && (pRun->SymbolFontRef.get() < pTheme->m_arFonts.size()))
{
pRun->FontPropertiesSym = new CFontProperties();
pRun->FontPropertiesSym->SetFont(pTheme->m_arFonts[pRun->SymbolFontRef.get()]);
}
}
}
}
}
bool NSPresentationEditor::CShapeElement::SetUpTextPlaceholder(std::wstring newText)
{
bool result = false;
NSPresentationEditor::CTextAttributesEx* pText = &m_oShape.m_oText;
for (int p = 0 ; p < pText->m_arParagraphs.size(); p++) //тут по всем -> 1-(33).ppt
{
if (pText->m_arParagraphs[p].m_arSpans.size() >0)//??? по всем?
{
int pos = 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;
}
\ No newline at end of file
ASCOfficePPTXFile/Editor/PPTXElements/Elements.h 0 → 100644
View file @ c6879804
#pragma once
#include "Theme.h"
#include "Shapes/Shape.h"
#ifndef DISABLE_FILE_DOWNLOADER
#include "../../Common/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 CString& 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)
{
CString strXml = SaveToXML();
oWriter.WriteString(strXml);
}
virtual void ReadFromXml(XmlUtils::CXmlNode& oNode)
{
}
virtual CString SaveToXML()
{
if (!m_oAnimations.m_arAnimations.empty())
return ToAnimationXml();
LONG lFlags = 0;
if (m_bFlipH)
lFlags |= 0x0001;
if (m_bFlipV)
lFlags |= 0x0002;
CString 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);
return strEffect;
}
CString ToAnimationXml()
{
LONG lFlags = 0;
if (m_bFlipH)
lFlags |= 0x0001;
if (m_bFlipV)
lFlags |= 0x0002;
CString 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);
CString TimeLine;
TimeLine.Format ( _T("<timeline type = \"1\" begin=\"%f\" end=\"%f\" fadein=\"0\" fadeout=\"0\" completeness=\"1.0\"/> "),
m_dStartTime, m_dEndTime );
CString 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 CString ConvertPPTShapeToPPTX(bool bIsNamespace = false)
{
NSGuidesVML::CFormParam pParamCoef;
pParamCoef.m_eType = ptValue;
pParamCoef.m_lParam = 65536;
pParamCoef.m_lCoef = 65536;
return ConvertPPTtoPPTX(/*pPPTShape,*/ pParamCoef, bIsNamespace);
}
CString 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>");
CString 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);
oDownloader.Start( 1 );
while ( oDownloader.IsRunned() )
{
::Sleep( 10 );
}
if ( oDownloader.IsFileDownloaded() )
{
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 CString& 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 *= dScaleX;
m_oShape.m_oText.m_oBounds.right *= dScaleX;
m_oShape.m_oText.m_oBounds.top *= dScaleY;
m_oShape.m_oText.m_oBounds.bottom *= dScaleY;
}
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 = (bool)pProperty->m_dwValue;
break;
}
case CElementProperty::epFontItalic:
{
m_oShape.m_oText.m_oAttributes.m_oFont.Italic = (bool)pProperty->m_dwValue;
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 CString 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
CString 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>");
}
CString 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
CString 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>");
}
CString 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.size();
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);
}
//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 CString SaveToXML()
{
CString element = _T("");
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" ");
}
CString strFileName = std_string2string(m_strAudioFileName);
CorrectXmlString(strFileName);
CString source;
source.Format(_T("<Source StartTime='%lf' EndTime='%lf' FilePath='%ls' loop='%d' />"), m_dClipStartTime, m_dClipEndTime, strFileName, m_bLoop);
element += source;
CString 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;
}
CString 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)
{
CString 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)
{
CString strXml = SaveToXML();
oWriter.WriteString(strXml);
}
virtual void ReadFromXml(XmlUtils::CXmlNode& oNode)
{
}
virtual CString SaveToXML()
{
return GetVideoStream () + GetAudioStream ();
}
CString ToAnimationXml()
{
return _T("");
}
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 CString GetVideoStream ()
{
int lIndex = m_strVideoFileName.find(L"file:///");
if (0 == lIndex)
{
m_strVideoFileName = m_strVideoFileName.substr(8);
/*m_strFileName.Replace('/', '\\');*/
}
CString strFileName = std_string2string(m_strVideoFileName);
CorrectXmlString(strFileName);
CString element;
element.Format ( _T("<VideoStream left='%d' top='%d' right='%d' bottom='%d' angle='%f' loop='%d' ")
_T(" widthmetric='%d' heightmetric='%d' ")
_T(" 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 );
CString 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;
}
CString 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("</VideoStream>");
return element;
}
inline CString GetAudioStream ()
{
CString element = _T("");
element.Format(_T("<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" ");
}
CString strFileName = std_string2string(m_strVideoFileName);
CorrectXmlString(strFileName);
CString source;
source.Format(_T("<Source StartTime='%lf' EndTime='%lf' FilePath='%ls'/>"), m_dClipStartTime, m_dClipEndTime, strFileName);
element += source;
CString 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;
}
CString 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;
}
};
}
namespace NSStrings
{
class CTextItem
{
protected:
wchar_t* m_pData;
size_t m_lSize;
wchar_t* m_pDataCur;
size_t m_lSizeCur;
public:
CTextItem()
{
m_pData = NULL;
m_lSize = 0;
m_pDataCur = m_pData;
m_lSizeCur = m_lSize;
}
CTextItem(const CTextItem& oSrc)
{
m_pData = NULL;
*this = oSrc;
}
CTextItem& operator=(const CTextItem& oSrc)
{
RELEASEMEM(m_pData);
m_lSize = oSrc.m_lSize;
m_lSizeCur = oSrc.m_lSizeCur;
m_pData = (wchar_t*)malloc(m_lSize * sizeof(wchar_t));
memcpy(m_pData, oSrc.m_pData, m_lSizeCur * sizeof(wchar_t));
m_pDataCur = m_pData + m_lSizeCur;
return *this;
}
CTextItem(const size_t& nLen)
{
m_lSize = nLen;
m_pData = (wchar_t*)malloc(m_lSize * sizeof(wchar_t));
m_lSizeCur = 0;
m_pDataCur = m_pData;
}
CTextItem(wchar_t* pData, const size_t& nLen)
{
m_lSize = nLen;
m_pData = (wchar_t*)malloc(m_lSize * sizeof(wchar_t));
memcpy(m_pData, pData, m_lSize * sizeof(wchar_t));
m_lSizeCur = m_lSize;
m_pDataCur = m_pData + m_lSize;
}
CTextItem(wchar_t* pData, BYTE* pUnicodeChecker = NULL)
{
size_t nLen = GetStringLen(pData);
m_lSize = nLen;
m_pData = (wchar_t*)malloc(m_lSize * sizeof(wchar_t));
memcpy(m_pData, pData, m_lSize * sizeof(wchar_t));
m_lSizeCur = m_lSize;
m_pDataCur = m_pData + m_lSize;
if (NULL != pUnicodeChecker)
{
wchar_t* pMemory = m_pData;
while (pMemory < m_pDataCur)
{
if (!pUnicodeChecker[*pMemory])
*pMemory = wchar_t(' ');
++pMemory;
}
}
}
virtual ~CTextItem()
{
RELEASEMEM(m_pData);
}
AVSINLINE void AddSize(const size_t& nSize)
{
if (NULL == m_pData)
{
m_lSize = (std::max)(nSize, (size_t) 1000);
m_pData = (wchar_t*)malloc(m_lSize * sizeof(wchar_t));
m_lSizeCur = 0;
m_pDataCur = m_pData;
return;
}
if ((m_lSizeCur + nSize) > m_lSize)
{
while ((m_lSizeCur + nSize) > m_lSize)
{
m_lSize *= 2;
}
wchar_t* pRealloc = (wchar_t*)realloc(m_pData, m_lSize * sizeof(wchar_t));
if (NULL != pRealloc)
{
//
m_pData = pRealloc;
m_pDataCur = m_pData + m_lSizeCur;
}
else
{
wchar_t* pMalloc = (wchar_t*)malloc(m_lSize * sizeof(wchar_t));
memcpy(pMalloc, m_pData, m_lSizeCur * sizeof(wchar_t));
free(m_pData);
m_pData = pMalloc;
m_pDataCur = m_pData + m_lSizeCur;
}
}
}
public:
AVSINLINE void operator+=(const CTextItem& oTemp)
{
WriteString(oTemp.m_pData, oTemp.m_lSizeCur);
}
#if defined(_WIN32) || defined (_WIN64)
AVSINLINE void operator+=(_bstr_t& oTemp)
{
size_t nLen = oTemp.length();
WriteString(oTemp.GetBSTR(), nLen);
}
#endif
AVSINLINE void operator+=(CString& oTemp)
{
size_t nLen = (size_t)oTemp.GetLength();
#ifdef _UNICODE
WriteString(oTemp.GetBuffer(), nLen);
#else
CStringW str = (CStringW)oTemp;
WriteString(str.GetBuffer(), nLen);
#endif
}
AVSINLINE wchar_t operator[](const size_t& nIndex)
{
if (nIndex < m_lSizeCur)
return m_pData[nIndex];
return 0;
}
AVSINLINE void SetText(BSTR& bsText)
{
ClearNoAttack();
#if defined(_WIN32) || defined (_WIN64)
size_t nLen = GetStringLen(bsText);
WriteString(bsText, nLen);
#else
size_t nLen = bsText.length();
WriteString(bsText.c_str(), nLen);
#endif
for (size_t i = 0; i < nLen; ++i)
{
if (WCHAR(8233) == m_pData[i])
m_pData[i] = WCHAR(' ');
}
}
AVSINLINE void AddSpace()
{
AddSize(1);
*m_pDataCur = wchar_t(' ');
++m_lSizeCur;
++m_pDataCur;
}
AVSINLINE void CorrectUnicode(const BYTE* pUnicodeChecker)
{
if (NULL != pUnicodeChecker)
{
wchar_t* pMemory = m_pData;
while (pMemory < m_pDataCur)
{
if (!pUnicodeChecker[*pMemory])
*pMemory = wchar_t(' ');
++pMemory;
}
}
}
AVSINLINE void RemoveLastSpaces()
{
wchar_t* pMemory = m_pDataCur - 1;
while ((pMemory > m_pData) && (wchar_t(' ') == *pMemory))
{
--pMemory;
--m_lSizeCur;
--m_pDataCur;
}
}
AVSINLINE bool IsSpace()
{
if (1 != m_lSizeCur)
return false;
return (wchar_t(' ') == *m_pData);
}
public:
AVSINLINE void WriteString(const wchar_t* pString, const size_t& nLen)
{
AddSize(nLen);
memcpy(m_pDataCur, pString, nLen * sizeof(wchar_t));
//memcpy(m_pDataCur, pString, nLen << 1);
m_pDataCur += nLen;
m_lSizeCur += nLen;
}
AVSINLINE size_t GetCurSize()
{
return m_lSizeCur;
}
AVSINLINE size_t GetSize()
{
return m_lSize;
}
AVSINLINE void Clear()
{
RELEASEMEM(m_pData);
m_pData = NULL;
m_lSize = 0;
m_pDataCur = m_pData;
m_lSizeCur = 0;
}
AVSINLINE void ClearNoAttack()
{
m_pDataCur = m_pData;
m_lSizeCur = 0;
}
AVSINLINE size_t GetStringLen(wchar_t* pData)
{
wchar_t* s = pData;
for (; *s != 0; ++s);
return (size_t)(s - pData);
}
AVSINLINE CString GetCString()
{
CString str(m_pData, (int)m_lSizeCur);
return str;
}
AVSINLINE wchar_t* GetBuffer()
{
return m_pData;
}
};
class CStringWriter : public CTextItem
{
public:
CStringWriter() : CTextItem()
{
}
virtual ~CStringWriter()
{
}
public:
#if defined(_WIN32) || defined (_WIN64)
AVSINLINE void WriteString(_bstr_t& bsString)
{
size_t nLen = bsString.length();
CTextItem::WriteString(bsString.GetBSTR(), nLen);
}
#endif
AVSINLINE void WriteString(CString& sString)
{
size_t nLen = (size_t)sString.GetLength();
#ifdef _UNICODE
CTextItem::WriteString(sString.GetBuffer(), nLen);
#else
CStringW str = (CStringW)sString;
WriteString(str.GetBuffer(), nLen);
#endif
}
AVSINLINE void WriteString(wchar_t* pString, const size_t& nLen)
{
CTextItem::WriteString(pString, nLen);
}
AVSINLINE void Write(CStringWriter& oWriter)
{
CTextItem::WriteString(oWriter.m_pData, oWriter.m_lSizeCur);
}
};
}
ASCOfficePPTXFile/Editor/PPTXElements/Enums.h 0 → 100644
View file @ c6879804
#pragma once
namespace NSOfficePPT
{
enum SlideSizeType
{
OnScreen = 0,
LetterSizedPaper = 1,
A4Paper = 2,
Size35mm = 3,
Overhead = 4,
Banner = 5,
Custom = 6
};
enum StyleMask
{
None = 0,
IsBold = 1 << 0,
IsItalic = 1 << 1,
IsUnderlined = 1 << 2,
HasShadow = 1 << 4,
HasAsianSmartQuotes = 1 << 5,
HasHorizonNumRendering = 1 << 7,
IsEmbossed = 1 << 9,
ExtensionNibble = 0xF << 10
};
enum CharacterMask
{
_None = 0,
StyleFlagsFieldPresent = 0xFFFF,
TypefacePresent = 1 << 16,
SizePresent = 1 << 17,
ColorPresent = 1 << 18,
PositionPresent = 1 << 19,
FEOldTypefacePresent = 1 << 21,
ANSITypefacePresent = 1 << 22,
SymbolTypefacePresent = 1 << 23
};
enum PlaceholderEnum
{
__None = 0,
MasterTitle = 1,
MasterBody = 2,
MasterCenteredTitle = 3,
MasterSubtitle = 4,
MasterNotesSlideImage = 5,
MasterNotesBody = 6,
MasterDate = 7,
MasterSlideNumber = 8,
MasterFooter = 9,
MasterHeader = 10,
NotesSlideImage = 11,
NotesBody = 12,
Title = 13,
Body = 14,
CenteredTitle = 15,
Subtitle = 16,
VerticalTextTitle = 17,
VerticalTextBody = 18,
Object = 19,
Graph = 20,
Table = 21,
ClipArt = 22,
OrganizationChart = 23,
MediaClip = 24
};
enum ParagraphMask
{
___None = 0,
HasBullet = 1 << 0,
BulletHasFont = 1 << 1,
BulletHasColor = 1 << 2,
BulletHasSize = 1 << 3,
BulletFlagsFieldExists = HasBullet | BulletHasFont | BulletHasColor | BulletHasSize,
BulletFont = 1 << 4,
BulletColor = 1 << 5,
BulletSize = 1 << 6,
BulletChar = 1 << 7,
LeftMargin = 1 << 8,
Indent = 1 << 10,
Align = 1 << 11,
LineSpacing = 1 << 12,
SpaceBefore = 1 << 13,
SpaceAfter = 1 << 14,
DefaultTabSize = 1 << 15,
FontAlign = 1 << 16,
CharWrap = 1 << 17,
WordWrap = 1 << 18,
Overflow = 1 << 19,
WrapFlagsFieldExists = CharWrap | WordWrap | Overflow,
TabStops = 1 << 20,
TextDirection = 1 << 21,
BulletBlip = 1 << 23,
BulletScheme = 1 << 24,
BulletHasScheme = 1 << 25
};
enum Instances
{
CollectionOfSlides = 0,
CollectionOfMasterSlides = 1,
CollectionOfNotesSlides = 2
};
enum SlideLayoutType
{
TitleSlide = 0,
TitleAndBody = 1,
TitleMaster = 2,
MasterNotes = 4,
NotesTitleAndBody = 5,
Handout = 6,
TitleOnly = 7,
TwoColumnsAndTitle = 8,
TwoRowsAndTitle = 9,
TwoColumnsRightTwoRows = 10,
TwoColumnsLeftTwoRows = 11,
TwoRowsBottomTwoColumns = 12,
TwoRowsTopTwoColumns = 13,
FourObjects = 14,
BigObject = 15,
Blank = 16,
VerticalTitleRightBodyLeft = 17,
VerticalTitleRightBodyLeftTwoRows = 18
};
enum TextType
{
_Title = 0,
_Body = 1,
Notes = 2,
Outline = 3,
Other = 4,
CenterBody = 5,
CenterTitle = 6,
HalfBody = 7,
QuarterBody = 8,
NoPresent = 0xFF
};
enum ActionTable
{
NoAction = 0,
MacroAction = 1,
RunProgramAction = 2,
JumpAction = 3,
HyperlinkAction = 4,
OLEAction = 5,
MediaAction = 6,
CustomShowAction = 7
};
enum JumpTable
{
NoJump = 0,
NextSlide = 1,
PreviousSlide = 2,
FirstSlide = 3,
LastSlide = 4,
LastSlideViewed = 5,
EndShow = 6,
SlideId = 7
};
}
namespace NSOfficeDrawing
{
enum ShapePath
{
shapeLines, // A line of straight segments
shapeLinesClosed, // A closed polygonal object
shapeCurves, // A line of Bezier curve segments
shapeCurvesClosed, // A closed shape with curved edges
shapeComplex // pSegmentInfo must be non-empty
};
enum WrapMode
{
wrapSquare,
wrapByPoints,
wrapNone,
wrapTopBottom,
wrapThrough
};
enum BwMode
{
bwColor, // only used for predefined shades
bwAutomatic, // depends on object type
bwGrayScale, // shades of gray only
bwLightGrayScale, // shades of light gray only
bwInverseGray, // dark gray mapped to light gray, etc.
bwGrayOutline, // pure gray and white
bwBlackTextLine, // black text and lines, all else grayscale
bwHighContrast, // pure black and white mode (no grays)
bwBlack, // solid black
bwWhite, // solid white
bwDontShow, // object not drawn
bwNumModes // number of Black and white modes
};
enum AnchorMode
{
anchorTop,
anchorMiddle,
anchorBottom,
anchorTopCentered,
anchorMiddleCentered,
anchorBottomCentered,
anchorTopBaseline,
anchorBottomBaseline,
anchorTopCenteredBaseline,
anchorBottomCenteredBaseline
};
enum CdirMode
{
cdir0, // Right
cdir90, // Down
cdir180, // Left
cdir270 // Up
};
enum CxStyle
{
cxstyleStraight = 0,
cxstyleBent,
cxstyleCurved,
cxstyleNone
};
enum CXKMode
{
cxkNone = 0, // No connection sites
cxkSegments = 1, // Connection sites at the segments
cxkCustom = 2, // Sites defined by pidPConnectionSites
cxkRect = 3 // Use the connection sites for a rectangle
};
enum TxflMode
{
txflHorzN, //Horizontal non-@
txflTtoBA, //Top to Bottom @-font
txflBtoT, //Bottom to Top non-@
txflTtoBN, //Top to Bottom non-@
txflHorzA, //Horizontal @-font
txflVertN //Vertical, non-@
};
enum TxDirMode
{
txdirLTR, // left-to-right text direction
txdirRTL, // right-to-left text direction
txdirContext // context text direction
};
enum SpcotMode
{
spcotRightAngle = 1,
spcotOneSegment = 2,
spcotTwoSegment = 3,
spcotThreeSegment = 4
};
enum SpcoaMode
{
spcoaAny,
spcoa30,
spcoa45,
spcoa60,
spcoa90,
spcoa0
};
enum SpcodMode
{
spcodTop,
spcodCenter,
spcodBottom,
spcodSpecified
};
enum GeoTextAlign
{
alignTextStretch, /* Stretch each line of text to fit width. */
alignTextCenter, /* Center text on width. */
alignTextLeft, /* Left justify. */
alignTextRight, /* Right justify. */
alignTextLetterJust, /* Spread letters out to fit width. */
alignTextWordJust, /* Spread words out to fit width. */
alignTextInvalid /* Invalid */
};
enum BlipFlags
{
blipflagDefault = 0,
blipflagComment = 0, // Blip name is a comment
blipflagFile, // Blip name is a file name
blipflagURL, // Blip name is a full URL
blipflagType = 3, // Mask to extract type
/* Or the following flags with any of the above. */
blipflagDontSave = 4, // A "dont" is the depression in the metal
// body work of an automobile caused when a
// cyclist violently thrusts his or her nose
// at it, thus a DontSave is another name for
// a cycle lane.
blipflagDoNotSave = 4, // For those who prefer English
blipflagLinkToFile = 8
};
enum e3DRenderMode
{
FullRender, // Generate a full rendering
Wireframe, // Generate a wireframe
BoundingCube // Generate a bounding cube
};
enum XFormType
{
xformAbsolute, // Apply transform in absolute space centered on shape
xformShape, // Apply transform to shape geometry
xformDrawing // Apply transform in drawing space
};
enum ShadowType
{
shadowOffset, // N pixel offset shadow
shadowDouble, // Use second offset too
shadowRich, // Rich perspective shadow (cast relative to shape)
shadowShape, // Rich perspective shadow (cast in shape space)
shadowDrawing, // Perspective shadow cast in drawing space
shadowEmbossOrEngrave
};
enum DzType
{
dztypeMin = 0,
dztypeDefault = 0, // Default size, ignore the values
dztypeA = 1, // Values are in EMUs
dztypeV = 2, // Values are in pixels
dztypeShape = 3, // Values are 16.16 fractions of shape size
dztypeFixedAspect = 4, // Aspect ratio is fixed
dztypeAFixed = 5, // EMUs, fixed aspect ratio
dztypeVFixed = 6, // Pixels, fixed aspect ratio
dztypeShapeFixed = 7, // Proportion of shape, fixed aspect ratio
dztypeFixedAspectEnlarge = 8, // Aspect ratio is fixed, favor larger size
dztypeAFixedBig = 9, // EMUs, fixed aspect ratio
dztypeVFixedBig = 10, // Pixels, fixed aspect ratio
dztypeShapeFixedBig = 11, // Proportion of shape, fixed aspect ratio
dztypeMax = 11
};
enum FillType
{
fillSolid, // Fill with a solid color
fillPattern, // Fill with a pattern (bitmap)
fillTexture, // A texture (pattern with its own color map)
fillPicture, // Center a picture in the shape
fillShade, // Shade from start to end points
fillShadeCenter, // Shade from bounding rectangle to end point
fillShadeShape, // Shade from shape outline to end point
fillShadeScale, // Similar to fillShade, but the fillAngle
// is additionally scaled by the aspect ratio of
// the shape. If shape is square, it is the
// same as fillShade.
fillShadeTitle, // special type - shade to title --- for PP
fillBackground // Use the background fill color/pattern
};
enum ShadeType
{
shadeNone = 0, // Interpolate without correction between RGBs
shadeGamma = 1, // Apply gamma correction to colors
shadeSigma = 2, // Apply a sigma transfer function to position
shadeBand = 4, // Add a flat band at the start of the shade
shadeOneColor = 8, // This is a one color shade
/* A parameter for the band or sigma function can be stored in the top
16 bits of the value - this is a proportion of *each* band of the
shade to make flat (or the approximate equal value for a sigma
function). NOTE: the parameter is not used for the sigma function,
instead a built in value is used. This value should not be changed
from the default! */
shadeParameterShift = 16,
shadeParameterMask = 0xFFFF0000,
shadeDefault = (shadeGamma | shadeSigma | (16384 << shadeParameterShift))
};
enum LinesStyle
{
lineSimple, // Single line (of width lineWidth)
lineDouble, // Double lines of equal width
lineThickThin, // Double lines, one thick, one thin
lineThinThick, // Double lines, reverse order
lineTriple // Three lines, thin, thick, thin
};
enum LineType
{
lineSolidType, // Fill with a solid color
linePattern, // Fill with a pattern (bitmap)
lineTexture, // A texture (pattern with its own color map)
linePicture // Center a picture in the shape
};
enum LineDashing
{
lineSolid, // Solid (continuous) pen
lineDashSys, // PS_DASH system dash style
lineDotSys, // PS_DOT system dash style
lineDashDotSys, // PS_DASHDOT system dash style
lineDashDotDotSys, // PS_DASHDOTDOT system dash style
lineDotGEL, // square dot style
lineDashGEL, // dash style
lineLongDashGEL, // long dash style
lineDashDotGEL, // dash short dash
lineLongDashDotGEL, // long dash short dash
lineLongDashDotDotGEL // long dash short dash short dash
};
enum LineEnd
{
lineNoEnd,
lineArrowEnd,
lineArrowStealthEnd,
lineArrowDiamondEnd,
lineArrowOvalEnd,
lineArrowOpenEnd
};
enum LineEndWidth
{
lineNarrowArrow,
lineMediumWidthArrow,
lineWideArrow
};
enum LineEndLength
{
lineShortArrow,
lineMediumLenArrow,
lineLongArrow
};
enum _LineJoin
{
lineJoinBevel, // Join edges by a straight line
lineJoinMiter, // Extend edges until they join
lineJoinRound // Draw an arc between the two edges
};
enum _LineCap
{
lineEndCapRound, // Rounded ends - the default
lineEndCapSquare, // Square protrudes by half line width
lineEndCapFlat // Line ends at end point
};
enum SGF
{
// Arithmetic
sgfSum, // guide := value + parameter1 - parameter2
sgfProduct, // guide := value * parameter1 / parameter2 (MulDiv)
sgfMid, // guide := (value + param1)/2
// Logical
sgfAbsolute, // guide := fabs(value)
sgfMin, // guide := min(value, param1)
sgfMax, // guide := max(value, param1)
sgfIf, // guide := vaule > 0 ? param1 : param2
// Polar arithmetic - angles are 16.16 degrees
sgfMod, // guide := sqrt(value^2 + param1^2 + param2^2)
sgfATan2, // guide := atan2(param1, value) [param2 ignored]
sgfSin, // guide := value * sin(param1) [param2 ignored]
sgfCos, // guide := value * cos(param1) [param2 ignored]
sgfCosATan2, // guide := value * cos(atan2(param2, param1))
sgfSinATan2, // guide := value * sin(atan2(param2, param1))
sgfSqrt, // guide := sqrt(value) [param1 and param2 ignored]
sgfSumAngle,
sgfEllipse,
sgfTan // guide := value * tan(param1) [param2 ignored]
};
enum SGVT
{
sgvtV = 0x2000, // Value is adjust value or guide
sgvtP1 = 0x4000, // Parameter1 is adjust value or guide
sgvtP2 = 0x8000 // Parameter2 is adjust value or guide
};
enum _Effects
{
efFillEffect,
efClrRepl,
efFillOverlay,
efClrChange,
efGlow,
efBlur,
efGrayscl,
efBlend,
efHslEffect,
efBiLevel,
efInnerShdw,
efAlphaRepl,
efAlphaOutset,
efLumEffect,
efAlphaModFix,
efOuterShdw,
efAlphaMod,
efPrstShdw,
efAlphaInv,
efReflection,
efAlphaFloor,
efRelOff,
efAlphaCeiling,
efAlphaBiLevel,
efSoftEdge,
efDuotone,
efTintEffect,
efXfrmEffect
};
enum _Transitions
{
etBlinds,
etChecker,
etCircle,
etComb,
etCover,
etCut,
etDiamond,
etDissolve,
etFade,
etNewsflash,
etPlus,
etPull,
etPush,
etRandom,
etRandomBar,
etSplit,
etStrips,
etWedge,
etWheel,
etWipe,
etZoom
}
///////////////////////////////////////////////////////////////
// ...?
///////////////////////////////////////////////////////////////
/*
// Value index: The first set define the value as an adjust handle property.
const USHORT sgvAdjust1 = pidAdjustValue;
const USHORT sgvAdjust2 = pidAdjust2Value;
const USHORT sgvAdjust3 = pidAdjust3Value;
const USHORT sgvAdjust4 = pidAdjust4Value;
const USHORT sgvAdjust5 = pidAdjust5Value;
const USHORT sgvAdjust6 = pidAdjust6Value;
const USHORT sgvAdjust7 = pidAdjust7Value;
const USHORT sgvAdjust8 = pidAdjust8Value;
// Geometry width and height
const USHORT sgvWidth = pidGeoRight;
const USHORT sgvHeight = pidGeoBottom;
// Other geometry properties
const USHORT sgvXCenter = pidGeoLeft;
const USHORT sgvYCenter = pidGeoTop;
const USHORT sgvXLimo = pidXLimo;
const USHORT sgvYLimo = pidYLimo;
// The guide properties
#define sgvGuide_(n) (USHORT(pidLast + 1 + (n)))
// View coordinate properties in V units (pixesl) and EMU,
// the EMU scaling is the average of the width/height scaling
const USHORT sgvLineWidth = sgvGuide_(247); // line width in pixels
const USHORT sgvDxvAnchor = sgvGuide_(248); // width in pixels
const USHORT sgvDyvAnchor = sgvGuide_(249); // height in pixels
const USHORT sgvDxeAnchor = sgvGuide_(252); // width of a shape in the view in emus
const USHORT sgvDyeAnchor = sgvGuide_(253); // Height of a shape in the view in emus
const USHORT sgvXeAnchorCenter = sgvGuide_(254);
const USHORT sgvYeAnchorCenter = sgvGuide_(255);
*/
////////////////////////////////////////////////////////////
// <- ...?
////////////////////////////////////////////////////////////
enum BlipUsage
{
blipUsageDefault, // All non-texture fill blips get this.
blipUsageTexture,
blipUsageMax = 255 // Since this is stored in a byte
};
enum BlipType
{
// GEL provided types...
blipERROR = 0, // An error occured during loading
blipUNKNOWN, // An unknown blip type
blipEMF, // Windows Enhanced Metafile
blipWMF, // Windows Metafile
blipPICT, // Macintosh PICT
blipJPEG, // JFIF
blipPNG, // PNG or GIF
blipDIB, // Windows DIB
blipTIFF = 17, // TIFF
blipCMYKJPEG = 18, // JPEG data in YCCK or CMYK color space
blipFirstClient = 32, // First client defined blip type
blipLastClient = 255 // Last client defined blip type
};
enum BlipSignature
{
biUNKNOWN = 0,
biWMF = 0x216, // Metafile header then compressed WMF
biEMF = 0x3D4, // Metafile header then compressed EMF
biPICT = 0x542, // Metafile header then compressed PICT
biPNG = 0x6E0, // One byte tag then PNG data
biJFIF = 0x46A, // One byte tag then JFIF data
biJPEG = biJFIF,
biDIB = 0x7A8, // One byte tag then DIB data
biCMYKJPEG = 0x6E2, // One byte tag then CMYK/YCCK JPEG data
biTIFF = 0x6e4, // One byte tag then TIFF data
biClient = 0x800, // Clients should set this bit
};
enum BlipFilter
{
filterAdaptive = 0,
filterNone = 254,
filterTest = 255
};
enum DGMNK
{
dgmnkMin = 0,
dgmnkNode = dgmnkMin,
dgmnkRoot,
dgmnkAssistant,
dgmnkCoWorker,
dgmnkSubordinate,
dgmnkAuxNode,
dgmnkDefault, // used for the orgchart split bar
dgmnkMax,
dgmnkLast = dgmnkMax - 1,
dgmnkNil = 0xFFFF
};
enum DGMLO
{
dgmloFirst = 0,
dgmloMin = dgmloFirst,
dgmloMinLessOne = dgmloMin - 1,
// OrgChart layout
dgmloOrgChartMin,
dgmloOrgChartStd = 0,
dgmloOrgChartBothHanging,
dgmloOrgChartRightHanging,
dgmloOrgChartLeftHanging,
dgmloOrgChartMax,
dgmloOrgChartLast = dgmloOrgChartMax - 1,
// Cycle layout
dgmloCycleMin, dgmloCycleMinLessOne = dgmloCycleMin - 1,
dgmloCycleStd,
dgmloCycleMax,
dgmloCycleLast = dgmloCycleMax - 1,
// Radial layout
dgmloRadialMin, dgmloRadialMinLessOne = dgmloRadialMin - 1,
dgmloRadialStd,
dgmloRadialMax, dgmloRadialLast = dgmloRadialMax - 1,
// Stacked layout
dgmloStackedMin, dgmloStackedMinLessOne = dgmloStackedMin - 1,
dgmloStackedStd,
dgmloStackedMax, dgmloStackedLast = dgmloStackedMax - 1,
// Venn layout
dgmloVennMin, dgmloVennMinLessOne = dgmloVennMin - 1,
dgmloVennStd,
dgmloVennMax, dgmloVennLast = dgmloVennMax - 1,
// BullsEye layout
dgmloBullsEyeMin, dgmloBullsEyeMinLessOne = dgmloBullsEyeMin - 1,
dgmloBullsEyeStd,
dgmloBullsEyeMax, dgmloBullsEyeLast = dgmloBullsEyeMax - 1,
dgmloMax, dgmloLast = dgmloMax - 1,
dgmloNil = 0xFF
};
enum ODGMT
{
dgmtMin = 0,
dgmtCanvas = dgmtMin,
dgmtFirstDiagramType = 1,
dgmtOrgChart = dgmtFirstDiagramType,
dgmtRadial = 2,
dgmtCycle = 3,
dgmtStacked = 4,
dgmtVenn = 5,
dgmtBullsEye = 6,
dgmtMax, dgmtLast = dgmtMax - 1,
dgmtNil = 0x0FFF
};
enum DGMST
{
/***WARNING: This is written out to the file format! ***/
/***NOTE: If you add a new style enum, you need to update vrgdgmstdesc ***/
dgmstMin = 0, dgmstFirst = dgmstMin ,
// OrgChart styles
dgmstOrgChartFirst = dgmstFirst,
dgmstOrgChart2,
dgmstOrgChart3,
dgmstOrgChart4,
dgmstOrgChart5,
dgmstOrgChart6,
dgmstOrgChart7,
dgmstOrgChart8,
dgmstOrgChart9,
dgmstOrgChart10,
dgmstOrgChart11,
dgmstOrgChart12,
dgmstOrgChart13,
dgmstOrgChart14,
dgmstOrgChart15,
dgmstOrgChart16,
dgmstOrgChart17,
dgmstOrgChartMax,
dgmstOrgChartLast = dgmstOrgChartMax - 1,
// Radial styles
dgmstRadialFirst = dgmstFirst,
dgmstRadial2,
dgmstRadial3,
dgmstRadial4,
dgmstRadial5,
dgmstRadial6,
dgmstRadial7,
dgmstRadial8,
dgmstRadial9,
dgmstRadial10,
dgmstRadialMax,
dgmstRadialLast = dgmstRadialMax - 1,
// Cycle styles
dgmstCycleFirst = dgmstFirst,
dgmstCycle2,
dgmstCycle3,
dgmstCycle4,
dgmstCycle5,
dgmstCycle6,
dgmstCycle7,
dgmstCycle8,
dgmstCycle9,
dgmstCycle10,
dgmstCycle2First,
dgmstCycle11 = dgmstCycle2First,
dgmstCycle12,
dgmstCycle13,
dgmstCycle14,
dgmstCycle15,
dgmstCycle16,
dgmstCycle17,
dgmstCycle18,
dgmstCycle19,
dgmstCycle20,
dgmstCycle21,
dgmstCycleMax,
dgmstCycleLast = dgmstCycleMax - 1,
// Stacked styles
dgmstStackedFirst = dgmstFirst,
dgmstStacked2,
dgmstStacked3,
dgmstStacked4,
dgmstStacked5,
dgmstStacked6,
dgmstStacked7,
dgmstStacked8,
dgmstStacked9,
dgmstStacked10,
dgmstStackedMax,
dgmstStackedLast = dgmstStackedMax - 1,
// Venn styles
dgmstVennFirst = dgmstFirst,
dgmstVenn2,
dgmstVenn3,
dgmstVenn4,
dgmstVenn5,
dgmstVenn6,
dgmstVenn7,
dgmstVenn8,
dgmstVenn9,
dgmstVenn10,
dgmstVennMax,
dgmstVennLast = dgmstVennMax - 1,
// BullsEyeChart styles
dgmstBullsEyeFirst = dgmstFirst,
dgmstBullsEye2,
dgmstBullsEye3,
dgmstBullsEye4,
dgmstBullsEye5,
dgmstBullsEye6,
dgmstBullsEye7,
dgmstBullsEye8,
dgmstBullsEye9,
dgmstBullsEye10,
dgmstBullsEyeMax,
dgmstBullsEyeLast = dgmstBullsEyeMax - 1,
dgmstNil = 0xFFFF
};
enum SPT
{
sptMin = 0,
sptNotPrimitive = sptMin,
sptRectangle = 1,
sptRoundRectangle = 2,
sptEllipse = 3,
sptDiamond = 4,
sptIsocelesTriangle = 5,
sptRightTriangle = 6,
sptParallelogram = 7,
sptTrapezoid = 8,
sptHexagon = 9,
sptOctagon = 10,
sptPlus = 11,
sptStar = 12,
sptArrow = 13,
sptThickArrow = 14,
sptHomePlate = 15,
sptCube = 16,
sptBalloon = 17,
sptSeal = 18,
sptArc = 19,
sptLine = 20,
sptPlaque = 21,
sptCan = 22,
sptDonut = 23,
sptTextSimple = 24,
sptTextOctagon = 25,
sptTextHexagon = 26,
sptTextCurve = 27,
sptTextWave = 28,
sptTextRing = 29,
sptTextOnCurve = 30,
sptTextOnRing = 31,
sptStraightConnector1 = 32,
sptBentConnector2 = 33,
sptBentConnector3 = 34,
sptBentConnector4 = 35,
sptBentConnector5 = 36,
sptCurvedConnector2 = 37,
sptCurvedConnector3 = 38,
sptCurvedConnector4 = 39,
sptCurvedConnector5 = 40,
sptCallout1 = 41,
sptCallout2 = 42,
sptCallout3 = 43,
sptAccentCallout1 = 44,
sptAccentCallout2 = 45,
sptAccentCallout3 = 46,
sptBorderCallout1 = 47,
sptBorderCallout2 = 48,
sptBorderCallout3 = 49,
sptAccentBorderCallout1 = 50,
sptAccentBorderCallout2 = 51,
sptAccentBorderCallout3 = 52,
sptRibbon = 53,
sptRibbon2 = 54,
sptChevron = 55,
sptPentagon = 56,
sptNoSmoking = 57,
sptSeal8 = 58,
sptSeal16 = 59,
sptSeal32 = 60,
sptWedgeRectCallout = 61,
sptWedgeRRectCallout = 62,
sptWedgeEllipseCallout = 63,
sptWave = 64,
sptFoldedCorner = 65,
sptLeftArrow = 66,
sptDownArrow = 67,
sptUpArrow = 68,
sptLeftRightArrow = 69,
sptUpDownArrow = 70,
sptIrregularSeal1 = 71,
sptIrregularSeal2 = 72,
sptLightningBolt = 73,
sptHeart = 74,
sptPictureFrame = 75,
sptQuadArrow = 76,
sptLeftArrowCallout = 77,
sptRightArrowCallout = 78,
sptUpArrowCallout = 79,
sptDownArrowCallout = 80,
sptLeftRightArrowCallout = 81,
sptUpDownArrowCallout = 82,
sptQuadArrowCallout = 83,
sptBevel = 84,
sptLeftBracket = 85,
sptRightBracket = 86,
sptLeftBrace = 87,
sptRightBrace = 88,
sptLeftUpArrow = 89,
sptBentUpArrow = 90,
sptBentArrow = 91,
sptSeal24 = 92,
sptStripedRightArrow = 93,
sptNotchedRightArrow = 94,
sptBlockArc = 95,
sptSmileyFace = 96,
sptVerticalScroll = 97,
sptHorizontalScroll = 98,
sptCircularArrow = 99,
sptNotchedCircularArrow = 100,
sptUturnArrow = 101,
sptCurvedRightArrow = 102,
sptCurvedLeftArrow = 103,
sptCurvedUpArrow = 104,
sptCurvedDownArrow = 105,
sptCloudCallout = 106,
sptEllipseRibbon = 107,
sptEllipseRibbon2 = 108,
sptFlowChartProcess = 109,
sptFlowChartDecision = 110,
sptFlowChartInputOutput = 111,
sptFlowChartPredefinedProcess = 112,
sptFlowChartInternalStorage = 113,
sptFlowChartDocument = 114,
sptFlowChartMultidocument = 115,
sptFlowChartTerminator = 116,
sptFlowChartPreparation = 117,
sptFlowChartManualInput = 118,
sptFlowChartManualOperation = 119,
sptFlowChartConnector = 120,
sptFlowChartPunchedCard = 121,
sptFlowChartPunchedTape = 122,
sptFlowChartSummingJunction = 123,
sptFlowChartOr = 124,
sptFlowChartCollate = 125,
sptFlowChartSort = 126,
sptFlowChartExtract = 127,
sptFlowChartMerge = 128,
sptFlowChartOfflineStorage = 129,
sptFlowChartOnlineStorage = 130,
sptFlowChartMagneticTape = 131,
sptFlowChartMagneticDisk = 132,
sptFlowChartMagneticDrum = 133,
sptFlowChartDisplay = 134,
sptFlowChartDelay = 135,
sptTextPlainText = 136,
sptTextStop = 137,
sptTextTriangle = 138,
sptTextTriangleInverted = 139,
sptTextChevron = 140,
sptTextChevronInverted = 141,
sptTextRingInside = 142,
sptTextRingOutside = 143,
sptTextArchUpCurve = 144,
sptTextArchDownCurve = 145,
sptTextCircleCurve = 146,
sptTextButtonCurve = 147,
sptTextArchUpPour = 148,
sptTextArchDownPour = 149,
sptTextCirclePour = 150,
sptTextButtonPour = 151,
sptTextCurveUp = 152,
sptTextCurveDown = 153,
sptTextCascadeUp = 154,
sptTextCascadeDown = 155,
sptTextWave1 = 156,
sptTextWave2 = 157,
sptTextWave3 = 158,
sptTextWave4 = 159,
sptTextInflate = 160,
sptTextDeflate = 161,
sptTextInflateBottom = 162,
sptTextDeflateBottom = 163,
sptTextInflateTop = 164,
sptTextDeflateTop = 165,
sptTextDeflateInflate = 166,
sptTextDeflateInflateDeflate = 167,
sptTextFadeRight = 168,
sptTextFadeLeft = 169,
sptTextFadeUp = 170,
sptTextFadeDown = 171,
sptTextSlantUp = 172,
sptTextSlantDown = 173,
sptTextCanUp = 174,
sptTextCanDown = 175,
sptFlowChartAlternateProcess = 176,
sptFlowChartOffpageConnector = 177,
sptCallout90 = 178,
sptAccentCallout90 = 179,
sptBorderCallout90 = 180,
sptAccentBorderCallout90 = 181,
sptLeftRightUpArrow = 182,
sptSun = 183,
sptMoon = 184,
sptBracketPair = 185,
sptBracePair = 186,
sptSeal4 = 187,
sptDoubleWave = 188,
sptActionButtonBlank = 189,
sptActionButtonHome = 190,
sptActionButtonHelp = 191,
sptActionButtonInformation = 192,
sptActionButtonForwardNext = 193,
sptActionButtonBackPrevious = 194,
sptActionButtonEnd = 195,
sptActionButtonBeginning = 196,
sptActionButtonReturn = 197,
sptActionButtonDocument = 198,
sptActionButtonSound = 199,
sptActionButtonMovie = 200,
sptHostControl = 201,
sptTextBox = 202,
sptMax,
sptNil = 0x0FFF
};
enum PropertyId
{
//Transform
left=0,
top=1,
right=2,
bottom=3,
rotation=4,
gvPage=5,
fChangePage=61,
fFlipV=62,
fFlipH=63,
//Protection
fLockAgainstUngrouping=118,
fLockRotation=119,
fLockAspectRatio=120,
fLockPosition=121,
fLockAgainstSelect=122,
fLockCropping=123,
fLockVertices=124,
fLockText=125,
fLockAdjustHandles=126,
fLockAgainstGrouping=127,
//Text
lTxid=128,
dxTextLeft=129,
dyTextTop=130,
dxTextRight=131,
dyTextBottom=132,
WrapText=133,
scaleText=134,
anchorText=135,
txflTextFlow=136,
cdirFont=137,
hspNext=138,
txdir=139,
ccol=140,
dzColMargin=141,
fSelectText=187,
fAutoTextMargin=188,
fRotateText=189,
fFitShapeToText=190,
fFitTextToShape=191,
//GeoText
gtextUNICODE=192,
gtextRTF=193,
gtextAlign=194,
gtextSize=195,
gtextSpacing=196,
gtextFont=197,
gtextCSSFont=198,
gtextFReverseRows=240,
fGtext=241,
gtextFVertical=242,
gtextFKern=243,
gtextFTight=244,
gtextFStretch=245,
gtextFShrinkFit=246,
gtextFBestFit=247,
gtextFNormalize=248,
gtextFDxMeasure=249,
gtextFBold=250,
gtextFItalic=251,
gtextFUnderline=252,
gtextFShadow=253,
gtextFSmallcaps=254,
gtextFStrikethrough=255,
//BLIP
cropFromTop=256,
cropFromBottom=257,
cropFromLeft=258,
cropFromRight=259,
Pib=260,
pibName=261,
pibFlags=262,
pictureTransparent=263,
pictureContrast=264,
pictureBrightness=265,
pictureGamma=266,
pictureId=267,
pictureDblCrMod=268,
pictureFillCrMod=269,
pictureLineCrMod=270,
pibPrint=271,
pibPrintName=272,
pibPrintFlags=273,
movie=274,
pictureRecolor=282,
picturePreserveGrays=313,
fRewind=314,
fLooping=315,
pictureGray=317,
pictureBiLevel=318,
pictureActive=319,
//Geometry
geoLeft=320,
geoTop=321,
geoRight=322,
geoBottom=323,
shapePath=324,
pVertices=325,
pSegmentInfo=326,
adjustValue=327,
adjust2Value=328,
adjust3Value=329,
adjust4Value=330,
adjust5Value=331,
adjust6Value=332,
adjust7Value=333,
adjust8Value=334,
adjust9Value=335,
adjust10Value=336,
pConnectionSites=337,
pConnectionSitesDir=338,
xLimo=339,
yLimo=340,
pAdjustHandles=341,
pGuides=342,
pInscribe=343,
cxk=344,
pFragments=345,
fColumnLineOK=377,
fShadowOK=378,
f3DOK=379,
fLineOK=380,
fGtextOK=381,
fFillShadeShapeOK=382,
fFillOK=383,
//Fill Style
fillType=384,
fillColor=385,
fillOpacity=386,
fillBackColor=387,
fillBackOpacity=388,
fillCrMod=389,
fillBlip=390,
fillBlipName=391,
fillBlipFlags=392,
fillWidth=393,
fillHeight=394,
fillAngle=395,
fillFocus=396,
fillToLeft=397,
fillToTop=398,
fillToRight=399,
fillToBottom=400,
fillRectLeft=401,
fillRectTop=402,
fillRectRight=403,
fillRectBottom=404,
fillDztype=405,
fillShadePreset=406,
fillShadeColors=407,
fillOriginX=408,
fillOriginY=409,
fillShapeOriginX=410,
fillShapeOriginY=411,
fillShadeType=412,
fRecolorFillAsPicture=441,
fUseShapeAnchor=442,
fFilled=443,
fHitTestFill=444,
fillShape=445,
fillUseRect=446,
fNoFillHitTest=447,
//Line Style
lineColor=448,
lineOpacity=449,
lineBackColor=450,
lineCrMod=451,
lineType=452,
lineFillBlip=453,
lineFillBlipName=454,
lineFillBlipFlags=455,
lineFillWidth=456,
lineFillHeight=457,
lineFillDztype=458,
lineWidth=459,
lineMiterLimit=460,
lineStyle=461,
lineDashing=462,
lineDashStyle=463,
lineStartArrowhead=464,
lineEndArrowhead=465,
lineStartArrowWidth=466,
lineStartArrowLength=467,
lineEndArrowWidth=468,
lineEndArrowLength=469,
lineJoinStyle=470,
lineEndCapStyle=471,
fInsetPen=505,
fInsetPenOK=506,
fArrowheadsOK=507,
fLine=508,
fHitTestLine=509,
lineFillShape=510,
fNoLineDrawDash=511,
//Shadow Style
shadowType=512,
shadowColor=513,
shadowHighlight=514,
shadowCrMod=515,
shadowOpacity=516,
shadowOffsetX=517,
shadowOffsetY=518,
shadowSecondOffsetX=519,
shadowSecondOffsetY=520,
shadowScaleXToX=521,
shadowScaleYToX=522,
shadowScaleXToY=523,
shadowScaleYToY=524,
shadowPerspectiveX=525,
shadowPerspectiveY=526,
shadowWeight=527,
shadowOriginX=528,
shadowOriginY=529,
fShadow=574,
fshadowObscured=575,
//Perspective Style
perspectiveType=576,
perspectiveOffsetX=577,
perspectiveOffsetY=578,
perspectiveScaleXToX=579,
perspectiveScaleYToX=580,
perspectiveScaleXToY=581,
perspectiveScaleYToY=582,
perspectivePerspectiveX=583,
perspectivePerspectiveY=584,
perspectiveWeight=585,
perspectiveOriginX=586,
perspectiveOriginY=587,
fPerspective=639,
//3D Object
c3DSpecularAmt=640,
c3DDiffuseAmt=641,
c3DShininess=642,
c3DEdgeThickness=643,
C3DExtrudeForward=644,
c3DExtrudeBackward=645,
c3DExtrudePlane=646,
c3DExtrusionColor=647,
c3DCrMod=648,
f3D=700,
fc3DMetallic=701,
fc3DUseExtrusionColor=702,
fc3DLightFace=703,
//3D Style
c3DYRotationAngle=704,
c3DXRotationAngle=705,
c3DRotationAxisX=706,
c3DRotationAxisY=707,
c3DRotationAxisZ=708,
c3DRotationAngle=709,
c3DRotationCenterX=710,
c3DRotationCenterY=711,
c3DRotationCenterZ=712,
c3DRenderMode=713,
c3DTolerance=714,
c3DXViewpoint=715,
c3DYViewpoint=716,
c3DZViewpoint=717,
c3DOriginX=718,
c3DOriginY=719,
c3DSkewAngle=720,
c3DSkewAmount=721,
c3DAmbientIntensity=722,
c3DKeyX=723,
c3DKeyY=724,
c3DKeyZ=725,
c3DKeyIntensity=726,
c3DFillX=727,
c3DFillY=728,
c3DFillZ=729,
c3DFillIntensity=730,
fc3DConstrainRotation=763,
fc3DRotationCenterAuto=764,
fc3DParallel=765,
fc3DKeyHarsh=766,
fc3DFillHarsh=767,
//Shape
hspMaster=769,
cxstyle=771,
bWMode=772,
bWModePureBW=773,
bWModeBW=774,
idDiscussAnchor=775,
dgmLayout=777,
dgmNodeKind=778,
dgmLayoutMRU=779,
wzEquationXML=780,
fPolicyLabel=822,
fPolicyBarcode=823,
fFlipHQFE5152=824,
fFlipVQFE5152=825,
fPreferRelativeResize=827,
fLockShapeType=828,
fInitiator=829,
fDeleteAttachedObject=830,
fBackground=831,
//Callout
spcot=832,
dxyCalloutGap=833,
spcoa=834,
spcod=835,
dxyCalloutDropSpecified=836,
dxyCalloutLengthSpecified=837,
fCallout=889,
fCalloutAccentBar=890,
fCalloutTextBorder=891,
fCalloutMinusX=892,
fCalloutMinusY=893,
fCalloutDropAuto=894,
fCalloutLengthSpecified=895,
//Groupe Shape
wzName=896,
wzDescription=897,
pihlShape=898,
pWrapPolygonVertices=899,
dxWrapDistLeft=900,
dyWrapDistTop=901,
dxWrapDistRight=902,
dyWrapDistBottom=903,
lidRegroup=904,
groupLeft=905,
groupTop=906,
groupRight=907,
groupBottom=908,
wzTooltip=909,
wzScript=910,
posh=911,
posrelh=912,
posv=913,
posrelv=914,
pctHR=915,
alignHR=916,
dxHeightHR=917,
dxWidthHR=918,
wzScriptExtAttr=919,
scriptLang=920,
wzScriptIdAttr=921,
wzScriptLangAttr=922,
borderTopColor=923,
borderLeftColor=924,
borderBottomColor=925,
borderRightColor=926,
tableProperties=927,
tableRowProperties=928,
scriptHtmlLocation=929,
wzApplet=930,
wzFrameTrgtUnused=932,
wzWebBot=933,
wzAppletArg=934,
wzAccessBlob=936,
metroBlob=937,
dhgt=938,
fLayoutInCell=944,
fIsBullet=945,
fStandardHR=946,
fNoshadeHR=947,
fHorizRule=948,
fUserDrawn=949,
fAllowOverlap=950,
fReallyHidden=951,
fScriptAnchor=952,
//Unknown HTML
wzLineId=1026,
wzFillId=1027,
wzPictureId=1028,
wzPathId=1029,
wzShadowId=1030,
wzPerspectiveId=1031,
wzGtextId=1032,
wzFormulaeId=1033,
wzHandlesId=1034,
wzCalloutId=1035,
wzLockId=1036,
wzTextId=1037,
wzThreeDId=1038,
FakeShapeType=1039,
fFakeMaster=1086,
//Diagramm
dgmt=1280,
dgmStyle=1281,
pRelationTbl=1284,
dgmScaleX=1285,
dgmScaleY=1286,
dgmDefaultFontSize=1287,
dgmConstrainBounds=1288,
dgmBaseTextScale=1289,
fBorderlessCanvas=1338,
fNonStickyInkCanvas=1339,
fDoFormat=1340,
fReverse=1341,
fDoLayout=1342,
fPseudoInline=1343,
// dashing
lineLeftDashStyle=1359,
lineTopDashStyle=1423,
lineRightDashStyle=1487,
lineBottomDashStyle=1551,
//Web Component
webComponentWzHtml=1664,
webComponentWzName=1665,
webComponentWzUrl=1666,
webComponentWzProperties=1667,
fIsWebComponent=1727,
//Clip
pVerticesClip=1728,
pSegmentInfoClip=1729,
shapePathClip=1730,
fClipToWrap=1790,
fClippedOK=1791,
//Ink
pInkData=1792,
fInkAnnotation=1852,
fHitTestInk=1853,
fRenderShape=1854,
fRenderInk=1855,
//Signature
wzSigSetupId=1921,
wzSigSetupProvId=192,
wzSigSetupSuggSigner=1923,
wzSigSetupSuggSigner2=1924,
wzSigSetupSuggSignerEmail=1925,
wzSigSetupSignInst=1926,
wzSigSetupAddlXml=1927,
wzSigSetupProvUrl=1928,
fSigSetupShowSignDate=1980,
fSigSetupAllowComments=1981,
fSigSetupSignInstSet=1982,
fIsSignatureLine=1983,
//Groupe Shape 2
pctHoriz=1984,
pctVert=1985,
pctHorizPos=1986,
pctVertPos=1987,
sizerelh=1988,
sizerelv=1989,
colStart=1990,
colSpan=1991
};
namespace NSAnimation
{
enum ConditionType
{
_NA, // obsolete identifier; not used
ctBegin,
ctEnd,
Next,
Previous,
EndSync,
ConditionType_MaxEnumIDs
};
enum TLTimeNodeType
{
TLTimeNodeTypeParallel = 0,
TLTimeNodeTypeSequential,
TLTimeNodeTypeExclusive,
TLTimeNodeTypeBehaviorType,
TLTimeNodeTypeMediaType,
TLTimeNodeType_MaxEnumIDs
};
enum TLTimeNodeRestartType
{
TLR_NoRestartType = 0,
TLR_AlwaysRestart = 1,
TLR_RestartWhenOff = 2,
TLR_NeverRestart = 3,
TLTimeNodeRestartType_MaxEnumIDs = 4
};
enum TLTimeNodeFillType
{
TLF_NoFillType = 0,
TLF_FillRemove = 1,
TLF_FillFreeze = 2,
TLF_FillHold = 3,
TLF_FillTransition = 4,
TLTimeNodeFillType_MaxEnumIDs = 5
};
enum TLTimeNodeSyncType
{
TLS_NoSyncType = 0,
TLS_CanSlipSyncType = 1,
TLS_LockedSyncType = 2,
TLTimeNodeSyncType_MaxEnumIDs = 3
};
// property bit flag for propertiesSet
const int fillProperty = (1 << 0);
const int restartProperty = (1 << 1);
const int syncBehaviorProperty = (1 << 2);
const int groupingTypeProperty = (1 << 3);
const int durationProperty = (1 << 4);
enum TotEventType
{
totNone,
totVisualElement,
totTimeNode,
totRuntimeNodeRef,
TriggerObjectType_MaxEnumIDs
};
enum TriggerEventType
{
tetNone = 0,
tetOnBegin,
tetOnEnd,
tetBegin,
tetEnd,
tetOnClick,
tetOnDoubleClick,
tetOnMouseOver,
tetOnMouseOut,
tetOnNext, // PPT-specific
tetOnPrev, // PPT-specific
tetOnStopAudio,
TriggerEventType_MaxEnumIDs
};
enum RuntimeNodeReferenceType
{
rnrtWithFirstChild,
rnrtWithLastChild,
rnrtAllChildren,
RuntimeNodeReferenceType_MaxEnumIDs
};
enum Type
{
RepeatCount = 0, // The number of times to repeat
RepeatDur, // Duration of repeats
Speed, // Fraction indicating how much faster
// or slower to go than the normal duration.
Accelerate, // Fraction between 0 and 1 indicating
// portion of the duration over which to accelerate.
Decelerate, // Fraction between 0 and 1 indicating portion of the
// duration over which to decelerate.
AutoReverse, // The node should play forward then reverse.
Type_MaxEnumIDs
};
enum PropertyUsedFlag
{
PUF_NONE = 0,
PUF_Additive = 1 << 0,
PUF_Accumulate = 1 << 1,
PUF_AttributeNames = 1 << 2,
PUF_TransformType = 1 << 3,
PUF_FromFormula = 1 << 4,
PUF_ToFormula = 1 << 5,
PUF_ByFormula = 1 << 6
};
enum Additive
{
BaseAdditive,
SumAdditive,
ReplaceAdditive,
MultiplyAdditive,
NoAdditive,
Additive_MaxEnumIDs
};
enum Accumulate
{
NoAccumulate,
AlwaysAccumulate,
Accumulate_MaxEnumIDs
};
enum TransformType
{
PropertyTransformType,
ImageTransformType,
TransformType_MaxEnumIDs
};
enum CalcMode
{
DiscreteMode,
LinearMode,
FormulaMode,
CalcMode_MaxEnumIDs
};
enum AnimatePropertyUsedFlag
{
APUF_NONE = 0,
APUF_By = 1 << 0,
APUF_From = 1 << 1,
APUF_To = 1 << 2,
APUF_CalcMode = 1 << 3,
APUF_AnimationValues = 1 << 4,
APUF_ValueType = 1 << 5
};
enum ValueType
{
StringType,
NumberType,
ColorType,
ValueType_MaxEnumIDs
};
enum AnimateColorPropertyUsedFlag
{
ACPUF_NONE = 0,
ACPUF_By = 1 << 0,
ACPUF_From = 1 << 1,
ACPUF_To = 1 << 2,
ACPUF_ColorSpace = 1 << 3,
ACPUF_Direction = 1 << 4
};
enum ColorModel
{
RGBColorModel = 0,
HSLColorModel = 1,
IndexColorModel = 2,
ColorModel_MaxEnumIDs
};
enum AnimateEffectPropertyUsedFlag
{
AEPUF_NONE = 0,
AEPUF_Transition = 1 << 0,
AEPUF_Type = 1 << 1,
AEPUF_Progress = 1 << 2,
AEPUF_RuntimeContext_Obsolete = 1 << 3 // Keep this for backward binary persistence
};
enum Transition
{
TransitionIn,
TransitionOut,
TransitionNone,
Transition_MaxEnumIDs
};
enum AnimateMotionPropertyUsedFlag
{
AMPUF_NONE = 0,
AMPUF_By = 1 << 0,
AMPUF_From = 1 << 1,
AMPUF_To = 1 << 2,
AMPUF_Origin = 1 << 3,
AMPUF_Path = 1 << 4,
AMPUF_Rotation = 1 << 5,
AMPUF_EditRotation = 1 << 6,
AMPUF_PointsTypes = 1 << 7
};
enum Origin
{
DefaultOrigin,
ParentOrigin,
LayoutOrigin,
Origin_MaxEnumIDs
};
enum AnimateRotationPropertyUsedFlag
{
ARPUF_NONE = 0,
ARPUF_By = 1 << 0,
ARPUF_From = 1 << 1,
ARPUF_To = 1 << 2,
ARPUF_Direction = 1 << 3
};
enum Direction
{
Clockwise,
CounterClockwise,
Direction_MaxEnumIDs
};
enum AnimateScalePropertyUsedFlag
{
ASPUF_NONE = 0,
ASPUF_By = 1 << 0,
ASPUF_From = 1 << 1,
ASPUF_To = 1 << 2,
ASPUF_ZoomContents = 1 << 3
};
enum SetPropertyUsedFlag
{
SPUF_NONE = 0,
SPUF_To = 1 << 0,
SPUF_ValueType = 1 << 1
};
enum CommandPropertyUsedFlag
{
CPUF_NONE = 0,
CPUF_Type = 1 << 0,
CPUF_Command = 1 << 1
};
enum CommandType
{
EventType,
CallType,
OleVerbType,
CommandType_MaxEnumIDs
};
enum TLTimePropertyID
{
tpidUnknown = 0,
tpidID = 1, // string
tpidDisplay = 2,
tpidMasterPos = 5,
tpidSubNodeType = 6,
tpidParagraphLevel = 7,
tpidGraphLevel = 8,
tpidEffectID = 9,
tpidEffectDir = 10,
tpidEffectType = 11,
tpidAfterEffect = 13,
tpidDiagramLevel = 14,
tpidSlideCount = 15, // integer
tpidTimeFilter = 16, // string
tpidEventFilter = 17, // string
tpidHideWhenStopped = 18, // boolean
tpidGroupID = 19,
tpidPPTType = 20,
tpidPlaceholderNode = 21,
tpidMediaVolume = 22,
tpidMediaMute = 23,
tpidXMLUnknownAttribs = 24,
tpidXMLAttribsUnknownValues = 25,
tpidZoomToFullScreen = 26,
tpidShowControls = 27,
tpidDVDTitle = 28,
tpidDVDStartTime = 29,
tpidDVDEndTime = 30
};
enum IterationType
{
AllAtOnce,
ByWord,
ByLetter,
IterationType_MaxEnumIDs
};
enum IntervalType
{
Seconds,
Percentage,
IntervalType_MaxEnumIDs
};
enum _Direction
{
Backwards,
Forwards,
_Direction_MaxEnumIDs
};
enum PropertyUsed
{
DirectionProperty = 1 << 0,
IterationTypeProperty = 1 << 1,
IntervalProperty = 1 << 2,
IntervalTypeProperty = 1 << 3,
};
enum ConcurrencyType
{
Disabled,
Enabled,
ConcurrencyType_MaxEnumIDs
};
enum NextActionType
{
NoNextActionType,
Seek,
NextActionType_MaxEnumIDs
};
enum PreviousActionType
{
NoPreviousActionType,
SkipTimed,
PreviousActionType_MaxEnumIDs
};
enum EnableNextType
{
End,
Begin,
EnableNextType_MaxEnumIDs
};
// TLTimeSequenceData flags:
const int SF_Concurrency = (1 << 0);
const int SF_NextAction = (1 << 1);
const int SF_PreviousAction = (1 << 2);
const int SF_EnableNext = (1 << 3);
enum _Type
{
None = -1,
Bool = 0,
Int = 1,
Float = 2,
String = 3,
};
}
}
ASCOfficePPTXFile/Editor/PPTXElements/Interactive.h 0 → 100644
View file @ c6879804
#pragma once
#include "Attributes.h"
#if !defined(_WIN32) && !defined(_WIN64)
#include "../../DesktopEditor/common/ASCVariant.h"
#endif
namespace NSPresentationEditor
{
class CTextRange
{
public:
int m_lStart;
int m_lEnd;
public:
CTextRange()
{
m_lStart = 0;
m_lEnd = 0;
}
CTextRange& operator=(const CTextRange& oSrc)
{
m_lStart = oSrc.m_lStart;
m_lEnd = oSrc.m_lEnd;
return *this;
}
CTextRange(const CTextRange& oSrc)
{
*this = oSrc;
}
};
class CInteractiveInfo
{
private:
long m_lType;
VARIANT m_varParameter;
public:
bool m_bPresent;
std::vector<CTextRange> m_arRanges;
public:
CInteractiveInfo()
{
m_bPresent = false;
}
~CInteractiveInfo()
{
}
CInteractiveInfo& operator=(const CInteractiveInfo& oSrc)
{
m_lType = oSrc.m_lType;
m_varParameter = oSrc.m_varParameter;
m_bPresent = oSrc.m_bPresent;
m_arRanges.insert(m_arRanges.end(), oSrc.m_arRanges.begin(), oSrc.m_arRanges.end());
return *this;
}
CInteractiveInfo(const CInteractiveInfo& oSrc)
{
*this = oSrc;
}
};
}
ASCOfficePPTXFile/Editor/PPTXElements/Layout.h 0 → 100644
View file @ c6879804
#pragma once
#include "Element.h"
namespace NSPresentationEditor
{
class CLayout
{
public:
std::vector<IElement*> m_arElements;
std::vector<CColor> m_arColorScheme;
std::multimap<int,int> m_mapPlaceholders;
bool m_bUseThemeColorScheme;
// ""( ),
long m_lOriginalWidth;
long m_lOriginalHeight;
bool m_bIsBackground;
CBrush m_oBackground;
//
long m_lWidth;
long m_lHeight;
CMetricInfo m_oInfo;
bool m_bHasDate;
bool m_bHasSlideNumber;
bool m_bHasFooter;
int m_nFormatDate;
vector_string m_PlaceholdersReplaceString[3]; //0-dates, 1 - headers, 2 - footers
bool m_bShowMasterShapes;
std::wstring m_strLayoutType;
std::wstring m_sName;
public:
CLayout()
{
Clear();
}
CLayout(const CLayout& oSrc)
{
*this = oSrc;
}
CLayout& operator=(const CLayout& oSrc)
{
Clear();
m_arElements = oSrc.m_arElements;
size_t nCount = m_arElements.size();
for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
{
ADDREFINTERFACE((m_arElements[nIndex]));
}
m_mapPlaceholders = oSrc.m_mapPlaceholders;
m_arColorScheme = oSrc.m_arColorScheme;
m_bUseThemeColorScheme = oSrc.m_bUseThemeColorScheme;
m_lOriginalWidth = oSrc.m_lOriginalWidth;
m_lOriginalHeight = oSrc.m_lOriginalHeight;
m_lWidth = oSrc.m_lWidth;
m_lHeight = oSrc.m_lHeight;
m_bIsBackground = oSrc.m_bIsBackground;
m_oBackground = oSrc.m_oBackground;
m_bHasDate = oSrc.m_bHasDate;
m_bHasSlideNumber = oSrc.m_bHasSlideNumber;
m_bHasFooter = oSrc.m_bHasFooter;
m_nFormatDate = oSrc.m_nFormatDate;
for (int i = 0 ; i < 3 ; i++) m_PlaceholdersReplaceString[i] = oSrc.m_PlaceholdersReplaceString[i];
m_bShowMasterShapes = oSrc.m_bShowMasterShapes;
m_strLayoutType = oSrc.m_strLayoutType;
m_sName = oSrc.m_sName;
return *this;
}
void SetMetricInfo(const CMetricInfo& oInfo)
{
m_oInfo = oInfo;
m_lWidth = m_oInfo.m_lMillimetresHor;
m_lHeight = m_oInfo.m_lMillimetresVer;
m_lOriginalWidth = m_oInfo.m_lUnitsHor;
m_lOriginalHeight = m_oInfo.m_lUnitsVer;
}
public:
void Clear()
{
size_t nCount = m_arElements.size();
for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
{
RELEASEINTERFACE((m_arElements[nIndex]));
}
m_arElements.clear();
m_mapPlaceholders.clear();
m_bHasDate = false;
m_bHasSlideNumber = false;
m_bHasFooter = false;
m_nFormatDate = 1;
for (int i = 0 ; i < 3 ; i++) m_PlaceholdersReplaceString[i].clear();
m_bUseThemeColorScheme = true;
m_bShowMasterShapes = true;
m_strLayoutType = _T("obj");
m_bIsBackground = false;
m_lWidth = m_lHeight = m_lOriginalWidth = m_lOriginalHeight = 0;
}
void CreateDublicateElements()
{
//
for (size_t nIndex = 0; nIndex < m_arElements.size(); ++nIndex)
{
IElement* pElem = m_arElements[nIndex];
if (NULL != pElem)
{
m_arElements[nIndex] = pElem->CreateDublicate();
}
RELEASEINTERFACE(pElem);
}
}
CLayout* CreateDublicate()
{
CLayout* pNew = new CLayout(*this);
pNew->CreateDublicateElements();
return pNew;
}
IElement* GetPlaceholder(LONG lID, bool bIsAddRef)
{
size_t nCount = m_arElements.size();
for (size_t i = 0; i < nCount; ++i)
{
IElement* pElem = m_arElements[i];
if (pElem->m_lPlaceholderType == lID)
{
if (bIsAddRef)
ADDREFINTERFACE(pElem);
return pElem;
}
}
return NULL;
}
LONG GetCountPlaceholderWithType(LONG lType)
{
LONG lFound = 0;
for (size_t i = 0; i < m_arElements.size(); ++i)
{
if (m_arElements[i]->m_lPlaceholderType == lType)
{
++lFound;
}
}
return lFound;
}
public:
NSPresentationEditor::CColor GetColor(const LONG& lIndexScheme)
{
if (lIndexScheme < (LONG)m_arColorScheme.size())
{
return m_arColorScheme[lIndexScheme];
}
return NSPresentationEditor::CColor();
}
static void CheckPlaceholderStyle(CString strStyleName, LONG& lType, LONG& lLevel, LONG& lTypeStyle)
{
int nLen = strStyleName.GetLength();
TCHAR* pData = strStyleName.GetBuffer();
lType = 0;
lLevel = 0;
lTypeStyle = -1;
TCHAR* pDataEnd = pData + nLen;
TCHAR* pDataMem = pData + 1;
for (; ((pDataMem < pDataEnd) && XmlUtils::IsDigit(*pDataMem)); ++pDataMem)
{
lType *= 10;
lType += (*pDataMem - ((TCHAR)'0'));
}
pDataMem += 4;
for (; ((pDataMem < pDataEnd) && XmlUtils::IsDigit(*pDataMem)); ++pDataMem)
{
lLevel *= 10;
lLevel += (*pDataMem - ((TCHAR)'0'));
}
++pDataMem;
if (pDataMem + 1 < pDataEnd)
{
if ((TCHAR('c') == pDataMem[0]) && (TCHAR('f') == pDataMem[1]))
lTypeStyle = 1;
if ((TCHAR('p') == pDataMem[0]) && (TCHAR('f') == pDataMem[1]))
lTypeStyle = 0;
}
}
};
}
ASCOfficePPTXFile/Editor/PPTXElements/Metric.h 0 → 100644
View file @ c6879804
#pragma once
#include <math.h>
#if !defined(_WIN32) && !defined(_WIN64)
#include "./../../DesktopEditor/common/ASCVariant.h"
#include "../../Common/DocxFormat/Source/Base/ASCString.h"
#endif
namespace NSPresentationEditor
{
const double c_dMasterUnitsToInchKoef = 1.0 / 576;
const double c_dInchToMillimetreKoef = 25.4;
const double c_dMasterUnitsToMillimetreKoef = c_dMasterUnitsToInchKoef * c_dInchToMillimetreKoef;
class CMetricInfo
{
public:
DWORD m_lUnitsHor;
DWORD m_lUnitsVer;
DWORD m_lMillimetresHor;
DWORD m_lMillimetresVer;
public:
CMetricInfo()
{
m_lUnitsHor = 5000;
m_lUnitsVer = 5000;
m_lMillimetresHor = 5000;
m_lMillimetresVer = 5000;
}
CMetricInfo& operator =(const CMetricInfo& oSrc)
{
m_lUnitsHor = oSrc.m_lUnitsHor;
m_lUnitsVer = oSrc.m_lUnitsVer;
m_lMillimetresHor = oSrc.m_lMillimetresHor;
m_lMillimetresVer = oSrc.m_lMillimetresVer;
return *this;
}
void SetUnitsContainerSize(DWORD lSizeX, DWORD lSizeY)
{
m_lUnitsHor = lSizeX;
m_lUnitsVer = lSizeY;
m_lMillimetresHor = (DWORD)(m_lUnitsHor * c_dMasterUnitsToMillimetreKoef);
m_lMillimetresVer = (DWORD)(m_lUnitsVer * c_dMasterUnitsToMillimetreKoef);
}
};
class CDoubleRect
{
public:
double left;
double top;
double right;
double bottom;
public:
CDoubleRect()
{
left = 0;
top = 0;
right = 0;
bottom = 0;
}
CDoubleRect& operator=(const CDoubleRect& oSrc)
{
left = oSrc.left;
top = oSrc.top;
right = oSrc.right;
bottom = oSrc.bottom;
return *this;
}
CDoubleRect(const CDoubleRect& oSrc)
{
*this = oSrc;
}
inline bool IsEqual(const CDoubleRect& oSrc, double dEps = 0.01)
{
return ((fabs(left - oSrc.left) < dEps) && (fabs(top - oSrc.top) < dEps) &&
(fabs(right - oSrc.right) < dEps) && (fabs(bottom - oSrc.bottom) < dEps));
}
inline double GetWidth() const
{
return right - left;
}
inline double GetHeight() const
{
return bottom - top;
}
inline void Scale(const double& dKoef)
{
left *= dKoef;
top *= dKoef;
right *= dKoef;
bottom *= dKoef;
}
};
//class CRectF
//{
//public:
// float X;
// float Y;
// float Width;
// float Height;
//public:
// CRectF()
// {
// X = 0;
// Y = 0;
// Width = 0;
// Height = 0;
// }
// CRectF(const CRectF& oSrc)
// {
// *this = oSrc;
// }
// CRectF& operator=(const CRectF& oSrc)
// {
// X = oSrc.X;
// Y = oSrc.Y;
// Width = oSrc.Width;
// Height = oSrc.Height;
// return *this;
// }
// bool Equals(const CRect& oSrc)
// {
// return ((X == oSrc.X) && (Y == oSrc.Y) && (Width == oSrc.Width) && (Height == oSrc.Height));
// }
//};
class CGeomShapeInfo
{
public:
class CPointD
{
public:
double dX;
double dY;
public:
CPointD()
{
dX = 0;
dY = 0;
}
CPointD& operator= (const CPointD& oSrc)
{
dX = oSrc.dX;
dY = oSrc.dY;
return *this;
}
CPointD(const CPointD& oSrc)
{
*this = oSrc;
}
};
public:
double m_dLeft;
double m_dTop;
double m_dWidth;
double m_dHeight;
double m_dLimoX;
double m_dLimoY;
// (limo)
CPointD m_oCurPoint;
double m_dRotate;
bool m_bFlipH;
bool m_bFlipV;
LONG m_lOriginalWidth;
LONG m_lOriginalHeight;
public:
CGeomShapeInfo()
{
m_dLeft = 0;
m_dTop = 0;
m_dWidth = 720;
m_dHeight = 576;
m_dLimoX = 0;
m_dLimoY = 0;
m_oCurPoint.dX = 0;
m_oCurPoint.dY = 0;
m_dRotate = 0.0;
m_bFlipH = false;
m_bFlipV = false;
m_lOriginalWidth = 0;
m_lOriginalHeight = 0;
}
~CGeomShapeInfo()
{
}
CGeomShapeInfo& operator =(const CGeomShapeInfo& oSrc)
{
m_dLeft = oSrc.m_dLeft;
m_dTop = oSrc.m_dTop;
m_dWidth = oSrc.m_dWidth;
m_dHeight = oSrc.m_dHeight;
m_dLimoX = oSrc.m_dLimoX;
m_dLimoY = oSrc.m_dLimoY;
m_oCurPoint = oSrc.m_oCurPoint;
m_dRotate = oSrc.m_dRotate;
m_bFlipH = oSrc.m_bFlipH;
m_bFlipV = oSrc.m_bFlipV;
m_lOriginalWidth = oSrc.m_lOriginalWidth;
m_lOriginalHeight = oSrc.m_lOriginalHeight;
return (*this);
}
inline void SetBounds(const CDoubleRect& oRect)
{
m_dLeft = oRect.left;
m_dTop = oRect.top;
m_dWidth = oRect.GetWidth();
m_dHeight = oRect.GetHeight();
}
inline LONG GetFlags()
{
LONG lFlags = 0;
if (m_bFlipH)
lFlags |= 0x0001;
if (m_bFlipV)
lFlags |= 0x0002;
return lFlags;
}
};
}
ASCOfficePPTXFile/Editor/PPTXElements/Slide.h 0 → 100644
View file @ c6879804
#pragma once
#include "SlideShow.h"
#include "Theme.h"
namespace NSPresentationEditor
{
class CSlide
{
public:
LONG m_lThemeID;
LONG m_lLayoutID;
std::vector<IElement*> m_arElements;
CSlideShowInfo m_oSlideShow;
std::multimap<int,int> m_mapPlaceholders;
//
long m_lWidth;
long m_lHeight;
// - "" ( ),
long m_lOriginalWidth;
long m_lOriginalHeight;
double m_dStartTime;
double m_dEndTime;
double m_dDuration;
bool m_bIsBackground;
CBrush m_oBackground;
std::vector<CColor> m_arColorScheme;
bool m_bUseLayoutColorScheme;
bool m_bShowMasterShapes;
CMetricInfo m_oInfo;
vector_string m_PlaceholdersReplaceString[3];
std::wstring m_strComment;
std::wstring m_sName;
public:
CSlide() : m_arElements(), m_oSlideShow()
{
Clear();
}
~CSlide()
{
Clear();
}
void Clear()
{
for (size_t nIndex = 0; nIndex < m_arElements.size(); ++nIndex)
{
IElement* pElem = m_arElements[nIndex];
RELEASEINTERFACE(pElem);
}
m_arColorScheme.clear();
m_arElements.clear();
m_lThemeID = -1;
m_lLayoutID = -1;
m_lWidth = 270;
m_lHeight = 190;
m_lOriginalWidth = 6000;
m_lOriginalHeight = 5000;
m_dStartTime = 0.0;
m_dEndTime = 0.0;
m_dDuration = 30000.0;
m_bShowMasterShapes = true;
m_strComment.clear();
m_sName.clear();
for (int i = 0 ; i < 3 ; i++) m_PlaceholdersReplaceString[i].clear();
}
CSlide(const CSlide& oSrc)
{
Clear();
size_t nCount = oSrc.m_arElements.size();
for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
{
m_arElements.push_back(oSrc.m_arElements[nIndex]->CreateDublicate());
}
m_arColorScheme = oSrc.m_arColorScheme;
m_oSlideShow = oSrc.m_oSlideShow;
m_lThemeID = oSrc.m_lThemeID;
m_lLayoutID = oSrc.m_lLayoutID;
m_lWidth = oSrc.m_lWidth;
m_lHeight = oSrc.m_lHeight;
m_lOriginalWidth = oSrc.m_lOriginalWidth;
m_lOriginalHeight = oSrc.m_lOriginalHeight;
m_dStartTime = oSrc.m_dStartTime;
m_dEndTime = oSrc.m_dEndTime;
m_dDuration = oSrc.m_dDuration;
m_bIsBackground = oSrc.m_bIsBackground;
m_oBackground = oSrc.m_oBackground;
m_bShowMasterShapes = oSrc.m_bShowMasterShapes;
for (int i = 0 ; i < 3 ; i++) m_PlaceholdersReplaceString[i] = oSrc.m_PlaceholdersReplaceString[i];
m_strComment = oSrc.m_strComment;
m_sName = oSrc.m_sName;
}
public:
void SetMetricInfo(const CMetricInfo& oInfo)
{
m_oInfo = oInfo;
m_lWidth = m_oInfo.m_lMillimetresHor;
m_lHeight = m_oInfo.m_lMillimetresVer;
m_lOriginalWidth = m_oInfo.m_lUnitsHor;
m_lOriginalHeight = m_oInfo.m_lUnitsVer;
}
virtual void ReadFromXml(XmlUtils::CXmlNode& oNode)
{
}
virtual void WriteToXml(XmlUtils::CXmlWriter& oWriter)
{
}
void SetUpPlaceholderStyles(NSPresentationEditor::CLayout* pLayout)
{
size_t nCountElements = m_arElements.size();
for (size_t nEl = 0; nEl < nCountElements; ++nEl)
{
if (-1 != m_arElements[nEl]->m_lPlaceholderType && etShape == m_arElements[nEl]->m_etType)
{
CShapeElement* pSlideElement = dynamic_cast<CShapeElement*>(m_arElements[nEl]);
if (NULL != pSlideElement)
{
LONG lCountThisType = pLayout->GetCountPlaceholderWithType(pSlideElement->m_lPlaceholderType);
size_t nCountLayout = pLayout->m_arElements.size();
for (size_t i = 0; i < nCountLayout; ++i)
{
if (1 == lCountThisType)
{
if ((pLayout->m_arElements[i]->m_lPlaceholderType == pSlideElement->m_lPlaceholderType) &&
(pLayout->m_arElements[i]->m_etType == etShape))
{
CShapeElement* pLayoutElement = dynamic_cast<CShapeElement*>(pLayout->m_arElements[i]);
if (NULL != pLayoutElement)
{
pSlideElement->m_oShape.m_oText.m_oLayoutStyles = pLayoutElement->m_oShape.m_oText.m_oStyles;
}
}
}
else
{
if ((pLayout->m_arElements[i]->m_lPlaceholderType == pSlideElement->m_lPlaceholderType) &&
(pLayout->m_arElements[i]->m_lPlaceholderID == pSlideElement->m_lPlaceholderID) &&
(pLayout->m_arElements[i]->m_etType == etShape))
{
CShapeElement* pLayoutElement = dynamic_cast<CShapeElement*>(pLayout->m_arElements[i]);
if (NULL != pLayoutElement)
{
pSlideElement->m_oShape.m_oText.m_oLayoutStyles = pLayoutElement->m_oShape.m_oText.m_oStyles;
}
}
}
}
}
}
}
}
NSPresentationEditor::CColor GetColor(const LONG& lIndexScheme)
{
if (lIndexScheme < (LONG)m_arColorScheme.size())
{
return m_arColorScheme[lIndexScheme];
}
return NSPresentationEditor::CColor();
}
};
}
ASCOfficePPTXFile/Editor/PPTXElements/SlideShow.h 0 → 100644
View file @ c6879804
#pragma once
#include "Elements.h"
namespace NSPresentationEditor
{
class CTransition
{
public:
bool m_bAudioPresent; //
CAudioElement m_oAudio; //
BYTE m_nEffectDirection; //
BYTE m_nEffectType; //
bool m_bLoopSound; //
bool m_bStopSound; //
double m_dSpeed; //
public:
CTransition() : m_oAudio()
{
m_bAudioPresent = false;
m_nEffectType = 0;
m_nEffectDirection = 0;
m_bLoopSound = false;
m_bStopSound = false;
m_dSpeed = 500.0;
}
~CTransition()
{
}
CTransition& operator=(const CTransition& oSrc)
{
m_bAudioPresent = oSrc.m_bAudioPresent;
m_nEffectType = oSrc.m_nEffectType;
m_nEffectDirection = oSrc.m_nEffectDirection;
m_bLoopSound = oSrc.m_bLoopSound;
m_bStopSound = oSrc.m_bStopSound;
m_dSpeed = oSrc.m_dSpeed;
return *this;
}
CTransition(const CTransition& oSrc)
{
*this = oSrc;
}
};
class CSlideShowInfo
{
public:
double m_dSlideDuration; // ( )
bool m_bHidden; //
CTransition m_oTransition; //
bool m_bOnlyClick; //
public:
CSlideShowInfo() : m_oTransition()
{
m_dSlideDuration = 30000.0;
m_bHidden = false;
m_bOnlyClick = false;
}
~CSlideShowInfo()
{
}
CSlideShowInfo& operator=(const CSlideShowInfo& oSrc)
{
m_dSlideDuration = oSrc.m_dSlideDuration;
m_bHidden = oSrc.m_bHidden;
m_bOnlyClick = oSrc.m_bOnlyClick;
m_oTransition = oSrc.m_oTransition;
return *this;
}
CSlideShowInfo(const CSlideShowInfo& oSrc)
{
*this = oSrc;
}
};
}
\ No newline at end of file
ASCOfficePPTXFile/Editor/PPTXElements/Structures.h 0 → 100644
View file @ c6879804
#pragma once
#include "Attributes.h"
#define GETBIT(from, num) ((from & (1 << num)) != 0)
#define GETBITS(from, numL, numH) ((from & (((1 << (numH - numL + 1)) - 1) << numL)) >> numL)
typedef std::vector<std::wstring> vector_string;
namespace NSPresentationEditor
{
static void CorrectColorPPT(LONG& lSchemeIndex)
{
//0x00 //Background color
//0x01 //Text color
//0x02 //Shadow color
//0x03 //Title text color
//0x04 //Fill color
//0x05 //Accent 1 color
//0x06 //Accent 2 color
//0x07 //Accent 3 color
// [0]);//0
// [1]);//1
// [2]);//2
// [3]);//3
// [0]);//4
// [4]);//5 //accent1
// [5]);//6 //accent2
// [0]);//7 //accent3
// [5]);//8 //accent4
// [4]);//9 //accent5
// [7]);//10 //accent6
// [6]);//11 //hlink
// [7]);//12 //folHlink
// [0]);//13 //lt1
// [1]);//14 //dk1
// [2]);//15 //lt2
// [3]);//16 //dk2
switch (lSchemeIndex)
{
case 0:
lSchemeIndex = 13;
break;
case 1:
lSchemeIndex = 14;
break;
case 2:
lSchemeIndex = 15;
break;
case 3:
lSchemeIndex = 16;
break;
case 4:
lSchemeIndex = 5;
break;
case 5:
lSchemeIndex = 6;
break;
case 6:
lSchemeIndex = 11;
break;
case 7:
lSchemeIndex = 12;
break;
default:
lSchemeIndex = -1;
break;
}
}
struct SPointAtom
{
LONG X;
LONG Y;
CString ToString()
{
CString str = _T("");
str.Format(_T("<Point info='(%d,%d)' />"), X, Y);
return str;
}
};
struct SRectAtom
{
LONG Left;
LONG Top;
LONG Right;
LONG Bottom;
CString ToString()
{
CString str = _T("");
str.Format(_T("<Rect info='(%d,%d,%d,%d)' />"), Left, Top, Right, Bottom);
return str;
}
};
struct SSmallRectAtom
{
SHORT Left;
SHORT Top;
SHORT Right;
SHORT Bottom;
CString ToString()
{
CString str = _T("");
str.Format(_T("Rect(%d,%d,%d,%d)"), Left, Top, Right, Bottom);
return str;
}
};
struct SColorAtom
{
BYTE R;
BYTE G;
BYTE B;
BYTE Index;
bool bPaletteIndex;
bool bPaletteRGB;
bool bSystemRGB;
bool bSchemeIndex;
bool bSysIndex;
SColorAtom()
{
R = 0;
G = 0;
B = 0;
Index = -1;
bPaletteIndex = false;
bPaletteRGB = false;
bSystemRGB = false;
bSchemeIndex = false;
bSysIndex = false;
}
SColorAtom(const SColorAtom& oSrc)
{
*this = oSrc;
}
SColorAtom& operator=(const SColorAtom& oSrc)
{
R = oSrc.R;
G = oSrc.G;
B = oSrc.B;
Index = oSrc.Index;
bPaletteIndex = oSrc.bPaletteIndex;
bPaletteRGB = oSrc.bPaletteRGB;
bSystemRGB = oSrc.bSystemRGB;
bSchemeIndex = oSrc.bSchemeIndex;
bSysIndex = oSrc.bSysIndex;
return *this;
}
SColorAtom& operator=(const CColor& oSrc)
{
R = oSrc.R;
G = oSrc.G;
B = oSrc.B;
return *this;
}
CString ToString()
{
CString str = _T("");
str.Format(_T("<Color R='%d' G='%d' B='%d' index='%d' />"), R, G, B, Index);
return str;
}
CString ToString(CString name)
{
CString str = _T("");
str.Format(_T(" R='%d' G='%d' B='%d' index='%d' />"), R, G, B, Index);
str = _T("<Color_") + name + str;
return str;
}
DWORD ToValue()
{
DWORD dwVal = (R | (G << 8) | (B << 16));
return dwVal;
}
DWORD ToValue_RGB()
{
DWORD dwVal = (B | (G << 8) | (R << 16));
return dwVal;
}
DWORD ToValueProperty()
{
DWORD dwVal = 0;
if (!bSchemeIndex)
{
dwVal = (R | (G << 8) | (B << 16));
}
else
{
dwVal = (R | 0x01000000);
}
return dwVal;
}
void FromValue(BYTE _R, BYTE _G, BYTE _B)
{
R = _R;
G = _G;
B = _B;
Index = -1;
}
void FromValue(DWORD dwValue)
{
//R = (BYTE)(dwValue);
//G = (BYTE)(dwValue >> 8);
//B = (BYTE)(dwValue >> 16);
//Index = (BYTE)(dwValue >> 24);
//bPaletteIndex = (0x01 == (Index & 0x01));
//bPaletteRGB = (0x02 == (Index & 0x02));
//bSystemRGB = (0x04 == (Index & 0x04));
//bSchemeIndex = (0x08 == (Index & 0x08));
//bSysIndex = (0x10 == (Index & 0x10));
R = static_cast<unsigned char>(GETBITS(dwValue, 0, 7));
G = static_cast<unsigned char>(GETBITS(dwValue, 8, 15));
B = static_cast<unsigned char>(GETBITS(dwValue, 16, 23));
Index = -1;
bPaletteIndex = GETBIT(dwValue, 24);
bPaletteRGB = GETBIT(dwValue, 25);
bSystemRGB = GETBIT(dwValue, 26);
bSchemeIndex = GETBIT(dwValue, 27);
bSysIndex = GETBIT(dwValue, 28);
/*if(!bSchemeIndex && !bPaletteIndex && !bSysIndex)
{
colorRGB = STR::toRGB(red, green, blue);
}
else */
if(bSchemeIndex)
{
Index = R;
}
else if(bPaletteIndex)
{
Index = ((G) << 8) + R;
}
else if(bSysIndex)
{
Index = ((G) << 8) + R;
}
}
void ToColor(CColor* pColor)
{
pColor->R = R;
pColor->G = G;
pColor->B = B;
pColor->m_lSchemeIndex = -1;
if (bSchemeIndex || bSysIndex)
{
pColor->m_lSchemeIndex = R;
CorrectColorPPT(pColor->m_lSchemeIndex);
}
}
};
struct STextRange
{
UINT Begin;
UINT End;
CString ToString()
{
CString str = _T("");
str.Format(_T("TextRange(%d,%d)"), Begin, End);
return str;
}
};
class CElemInfo
{
public:
bool m_bIsBackground;
bool m_bIsChangeable;
LONG m_lID;
public:
CElemInfo()
{
m_bIsBackground = false;
m_bIsChangeable = false;
m_lID = 0;
}
CElemInfo(const CElemInfo& oSrc)
{
*this = oSrc;
}
CElemInfo& operator=(const CElemInfo& oSrc)
{
m_bIsBackground = oSrc.m_bIsBackground;
m_bIsChangeable = oSrc.m_bIsChangeable;
m_lID = oSrc.m_lID;
return *this;
}
};
}
\ No newline at end of file
ASCOfficePPTXFile/Editor/PPTXElements/TextAttributesEx.cpp 0 → 100644
View file @ c6879804
#include "TextAttributesEx.h"
#include "Theme.h"
namespace NSPresentationEditor
{
void CTextAttributesEx::RecalcParagraphsPPT()
{
for (int i = 0; i < m_arParagraphs.size(); ++i)
{
bool bIsBreak = true;
int lCountCFs = m_arParagraphs[i].m_arSpans.size();
for (int j = 0; j < lCountCFs; ++j)
{
int s_size = m_arParagraphs[i].m_arSpans[j].m_strText.length();
int lFound1 = m_arParagraphs[i].m_arSpans[j].m_strText.find((TCHAR)13);
int lFound2 = m_arParagraphs[i].m_arSpans[j].m_strText.find((TCHAR)11);
int lFoundEnter = (lFound1>=0 && lFound2>=0) ? (std::min)(lFound1, lFound2) : (lFound1>=0 ? lFound1 : (lFound2>=0 ? lFound2 : -1));
if( lFoundEnter >= 0 && (s_size > 1 || (s_size == 1 && m_arParagraphs[i].m_arSpans.size() > 1)))
{//"" span -
//
CParagraph oNewPar = m_arParagraphs[i];
if (lCountCFs - (j + 1) > 0)
{
m_arParagraphs[i].m_arSpans.erase(m_arParagraphs[i].m_arSpans.begin() + (j + 1), m_arParagraphs[i].m_arSpans.begin() + lCountCFs );
}
LONG lCountTx = m_arParagraphs[i].m_arSpans[j].m_strText.length();
m_arParagraphs[i].m_arSpans[j].m_strText.erase(lFoundEnter, lCountTx - lFoundEnter);
if (j > 0)
oNewPar.m_arSpans.erase(oNewPar.m_arSpans.begin(), oNewPar.m_arSpans.begin() + j);
if (lFoundEnter == (lCountTx - 1))
oNewPar.m_arSpans.erase(oNewPar.m_arSpans.begin(), oNewPar.m_arSpans.begin() + 1);
else
oNewPar.m_arSpans[0].m_strText.erase(0, lFoundEnter + 1);
if (0 != oNewPar.m_arSpans.size())
m_arParagraphs.insert(m_arParagraphs.begin() +i + 1, oNewPar);
break;
}
else
{
bIsBreak = false;
}
}
}
}
void CTextAttributesEx::RecalcParagraphs(CTheme* pTheme)
{
#ifdef PPT_DEF
RecalcParagraphsPPT();
ApplyThemeStyle(pTheme);
#else
size_t nCount = m_arParagraphs.size();
for (size_t i = 0; i < nCount; ++i)
{
m_arParagraphs[i].CheckErrors();
}
#endif
}
void CTextAttributesEx::ApplyThemeStyle(CTheme* pTheme)
{
if (NULL != pTheme)
{
size_t nCountPFs = m_arParagraphs.size();
for (size_t nIndexP = 0; nIndexP < nCountPFs; ++nIndexP)
{
LONG lLevel = m_arParagraphs[nIndexP].m_lTextLevel;
nullable_base<bool> hasBullet;
nullable_base<CColor> bulletColor;
nullable_base<WORD> bulletFontRef;
nullable_base<WORD> bulletSize;
nullable_base<WCHAR> bulletChar;
nullable_base<LONG> indent;
nullable_base<LONG> margin;
nullable_base<LONG> spaceBefore;
if (-1 != m_lStyleThemeIndex && m_lStyleThemeIndex < 4 && pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel].is_init())
{
if (pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.hasBullet.is_init())
{
hasBullet = pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.hasBullet;
if (pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.bulletColor.is_init())
bulletColor = pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.bulletColor;
if (pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.bulletChar.is_init() )
{
bulletFontRef = pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.bulletFontRef;
bulletChar = pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.bulletChar;
}
if (pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.bulletSize.is_init())
bulletSize = pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.bulletSize;
}
if (pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.leftMargin.is_init())
margin = pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.leftMargin;
if (pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.indent.is_init())
indent = pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.indent;
if (pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.spaceBefore.is_init())
spaceBefore = pTheme->m_pStyles[m_lStyleThemeIndex].m_pLevels[lLevel]->m_oPFRun.spaceBefore;
}
if (m_oLayoutStyles.m_pLevels[lLevel].is_init())
{
if (m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.hasBullet.is_init())
{
hasBullet = m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.hasBullet;
if (m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.bulletColor.is_init())
bulletColor = m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.bulletColor;
if (m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.bulletSize.is_init())
bulletSize = m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.bulletSize;
if (m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.bulletChar.is_init() )
{
bulletChar = m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.bulletChar;
bulletFontRef = m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.bulletFontRef;
}
}
if (m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.leftMargin.is_init())
margin = m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.leftMargin;
if (m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.indent.is_init())
indent = m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.indent;
if (m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.spaceBefore.is_init())
spaceBefore = m_oLayoutStyles.m_pLevels[lLevel]->m_oPFRun.spaceBefore;
}
if (m_oStyles.m_pLevels[lLevel].is_init())
{
if (m_oStyles.m_pLevels[lLevel]->m_oPFRun.hasBullet.is_init())
{
hasBullet = m_oStyles.m_pLevels[lLevel]->m_oPFRun.hasBullet;
if (m_oStyles.m_pLevels[lLevel]->m_oPFRun.bulletColor.is_init())
bulletColor = m_oStyles.m_pLevels[lLevel]->m_oPFRun.bulletColor;
if (m_oStyles.m_pLevels[lLevel]->m_oPFRun.bulletChar.is_init())
{
bulletFontRef = m_oStyles.m_pLevels[lLevel]->m_oPFRun.bulletFontRef;
bulletChar = m_oStyles.m_pLevels[lLevel]->m_oPFRun.bulletChar;
}
if (m_oStyles.m_pLevels[lLevel]->m_oPFRun.bulletSize.is_init())
bulletSize = m_oStyles.m_pLevels[lLevel]->m_oPFRun.bulletSize;
}
if (m_oStyles.m_pLevels[lLevel]->m_oPFRun.leftMargin.is_init())
margin = m_oStyles.m_pLevels[lLevel]->m_oPFRun.leftMargin;
if (m_oStyles.m_pLevels[lLevel]->m_oPFRun.indent.is_init())
indent = m_oStyles.m_pLevels[lLevel]->m_oPFRun.indent;
if (m_oStyles.m_pLevels[lLevel]->m_oPFRun.spaceBefore.is_init())
spaceBefore = m_oStyles.m_pLevels[lLevel]->m_oPFRun.spaceBefore;
}
if (!m_arParagraphs[nIndexP].m_oPFRun.hasBullet.is_init())
{
m_arParagraphs[nIndexP].m_oPFRun.hasBullet = hasBullet;
if (!m_arParagraphs[nIndexP].m_oPFRun.bulletColor.is_init())
m_arParagraphs[nIndexP].m_oPFRun.bulletColor = bulletColor;
if (!m_arParagraphs[nIndexP].m_oPFRun.bulletSize.is_init())
m_arParagraphs[nIndexP].m_oPFRun.bulletSize = bulletSize;
if (!m_arParagraphs[nIndexP].m_oPFRun.bulletChar.is_init())
{
m_arParagraphs[nIndexP].m_oPFRun.bulletChar = bulletChar;
m_arParagraphs[nIndexP].m_oPFRun.bulletFontRef = bulletFontRef;
}
}
if (!m_arParagraphs[nIndexP].m_oPFRun.leftMargin.is_init())
m_arParagraphs[nIndexP].m_oPFRun.leftMargin = margin;
if (!m_arParagraphs[nIndexP].m_oPFRun.indent.is_init())
m_arParagraphs[nIndexP].m_oPFRun.indent = indent;
if (!m_arParagraphs[nIndexP].m_oPFRun.spaceBefore.is_init())
m_arParagraphs[nIndexP].m_oPFRun.spaceBefore = spaceBefore;
m_arParagraphs[nIndexP].m_oPFRun.bulletFontProperties.reset();
if (m_arParagraphs[nIndexP].m_oPFRun.bulletFontRef.is_init())
{
m_arParagraphs[nIndexP].m_oPFRun.bulletFontProperties = new CFontProperties();
int ref = m_arParagraphs[nIndexP].m_oPFRun.bulletFontRef.get();
if (ref < pTheme->m_arFonts.size())
{
m_arParagraphs[nIndexP].m_oPFRun.bulletFontProperties->SetFont(pTheme->m_arFonts[ref]);
}
}
}
}
size_t nCount = m_arParagraphs.size();
for (size_t i = 0; i < nCount; ++i)
{
m_arParagraphs[i].CheckErrors();
}
ApplyRuler(pTheme);
}
void CTextAttributesEx::ApplyRuler(CTheme* pTheme)
{
if (m_oRuler.tabsStops.size() > 0 || m_oRuler.DefaultTabSize.is_init())//presentacio1.ppt 2
{
for (long i = 0; i < 9 ;i++)
{
if (m_oStyles.m_pLevels[i].is_init() == false)
{
m_oStyles.m_pLevels[i] = pTheme->m_pStyles[0].m_pLevels[i];
}
if (m_oRuler.tabsStops.size() > 0)
{
m_oStyles.m_pLevels[i]->m_oPFRun.tabStops = m_oRuler.tabsStops;
}
if (m_oRuler.DefaultTabSize.is_init())
{
m_oStyles.m_pLevels[i]->m_oPFRun.defaultTabSize = m_oRuler.DefaultTabSize;
}
}
}
size_t lCount = m_arParagraphs.size();
for (size_t i = 0; i < lCount; ++i)
{
CTextPFRun* pPar = &m_arParagraphs[i].m_oPFRun;
if (m_oRuler.tabsStops.size() > 0)
{
pPar->tabStops = m_oRuler.tabsStops;
//if (pPar->defaultTabSize.is_init() == false)
// pPar->defaultTabSize = m_oRuler.tabsStops[0];
}
if (m_oRuler.DefaultTabSize.is_init())
{
pPar->defaultTabSize = m_oRuler.DefaultTabSize;
}
WORD lIndentLevel = (WORD)m_arParagraphs[i].m_lTextLevel;
switch (lIndentLevel)
{
case 0:
{
if (m_oRuler.LeftMargin1.is_init())
pPar->leftMargin = (LONG)m_oRuler.LeftMargin1.get();
if (m_oRuler.Indent1.is_init())
pPar->indent = (LONG)m_oRuler.Indent1.get();
if (pPar->indent.is_init() && pPar->leftMargin.is_init())
pPar->indent = pPar->indent.get() - pPar->leftMargin.get();
break;
}
case 1:
{
if (m_oRuler.LeftMargin2.is_init())
pPar->leftMargin = (LONG)m_oRuler.LeftMargin2.get();
if (m_oRuler.Indent2.is_init())
pPar->indent = (LONG)m_oRuler.Indent2.get();
if (pPar->indent.is_init() && pPar->leftMargin.is_init())
pPar->indent = pPar->indent.get() - pPar->leftMargin.get();
break;
}
case 2:
{
if (m_oRuler.LeftMargin3.is_init())
pPar->leftMargin = (LONG)m_oRuler.LeftMargin3.get();
if (m_oRuler.Indent3.is_init())
pPar->indent = (LONG)m_oRuler.Indent3.get();
if (pPar->indent.is_init() && pPar->leftMargin.is_init())
pPar->indent = pPar->indent.get() - pPar->leftMargin.get();
break;
}
case 3:
{
if (m_oRuler.LeftMargin4.is_init())
pPar->leftMargin = (LONG)m_oRuler.LeftMargin4.get();
if (m_oRuler.Indent4.is_init())
pPar->indent = (LONG)m_oRuler.Indent4.get();
if (pPar->indent.is_init() && pPar->leftMargin.is_init())
pPar->indent = pPar->indent.get() - pPar->leftMargin.get();
break;
}
case 4:
{
if (m_oRuler.LeftMargin5.is_init())
pPar->leftMargin = (LONG)m_oRuler.LeftMargin5.get();
if (m_oRuler.Indent5.is_init())
pPar->indent = (LONG)m_oRuler.Indent5.get();
if (pPar->indent.is_init() && pPar->leftMargin.is_init())
pPar->indent = pPar->indent.get() - pPar->leftMargin.get();
break;
}
default:
break;
}
}
}
void CTextAttributesEx::ApplyRuler (CTextPFRun* pPar, WORD lIndentLevel)
{
switch (lIndentLevel)
{
case 0:
{
if (m_oRuler.LeftMargin1.is_init())
pPar->leftMargin = (LONG)m_oRuler.LeftMargin1.get();
if (m_oRuler.Indent1.is_init())
pPar->indent = (LONG)m_oRuler.Indent1.get();
if (pPar->indent.is_init() && pPar->leftMargin.get())
pPar->indent.get() -= pPar->leftMargin.get();
break;
}
case 1:
{
if (m_oRuler.LeftMargin2.is_init())
pPar->leftMargin = (LONG)m_oRuler.LeftMargin2.get();
if (m_oRuler.Indent2.is_init())
pPar->indent = (LONG)m_oRuler.Indent2.get();
if (pPar->indent.is_init() && pPar->leftMargin.get())
pPar->indent.get() -= pPar->leftMargin.get();
break;
}
case 2:
{
if (m_oRuler.LeftMargin3.is_init())
pPar->leftMargin = (LONG)m_oRuler.LeftMargin3.get();
if (m_oRuler.Indent3.is_init())
pPar->indent = (LONG)m_oRuler.Indent3.get();
if (pPar->indent.is_init() && pPar->leftMargin.get())
pPar->indent.get() -= pPar->leftMargin.get();
break;
}
case 3:
{
if (m_oRuler.LeftMargin4.is_init())
pPar->leftMargin = (LONG)m_oRuler.LeftMargin4.get();
if (m_oRuler.Indent4.is_init())
pPar->indent = (LONG)m_oRuler.Indent4.get();
if (pPar->indent.is_init() && pPar->leftMargin.get())
pPar->indent.get() -= pPar->leftMargin.get();
break;
}
case 4:
{
if (m_oRuler.LeftMargin5.is_init())
pPar->leftMargin = (LONG)m_oRuler.LeftMargin5.get();
if (m_oRuler.Indent5.is_init())
pPar->indent = (LONG)m_oRuler.Indent5.get();
if (pPar->indent.is_init() && pPar->leftMargin.get())
pPar->indent.get() -= pPar->leftMargin.get();
break;
}
default:
break;
};
}
}
ASCOfficePPTXFile/Editor/PPTXElements/TextAttributesEx.h 0 → 100644
View file @ c6879804
#pragma once
#include "Structures.h"
#include "TextStructures.h"
#if !defined(_WIN32) && !defined (_WIN64)
#include "../../DesktopEditor/graphics/aggplustypes.h"
#endif
namespace NSPresentationEditor
{
class CTheme;
class CLayout;
class CTextAttributesEx
{
public:
LONG m_lTextMasterType; // only ppt property
public:
DWORD m_lTextType;
DWORD m_lStyleThemeIndex;
int m_lPlaceholderType;
int m_lPlaceholderID;
//
Aggplus::RECT m_oBounds;
// -
CTextAttributes m_oAttributes;
std::vector<CParagraph> m_arParagraphs;
bool m_bVertical;
bool m_bAutoFit;
int m_lWrapMode; // 0 - square, default; 1 - none wrap
// .
CTextRuler m_oRuler;
CTextStyles m_oLayoutStyles;
CTextStyles m_oStyles;
//
bool m_bIsSlideFontRef;
int m_lFontRef;
public:
CTextAttributesEx() :
m_oAttributes(),
m_arParagraphs(),
m_oRuler(),
m_oLayoutStyles(),
m_oStyles()
{
m_lTextType = -1;
m_lPlaceholderType = -1;
m_lPlaceholderID = -1;
m_lStyleThemeIndex = -1;
m_lFontRef = -1;
m_bIsSlideFontRef = false;
m_oBounds.left = 0;
m_oBounds.top = 0;
m_oBounds.right = 50;
m_oBounds.bottom = 50;
m_bVertical = false;
m_bAutoFit = false;
m_lWrapMode = 0;
m_lTextMasterType = -1;
}
CTextAttributesEx& operator =(const CTextAttributesEx& oSrc)
{
m_oBounds = oSrc.m_oBounds;
m_lTextType = oSrc.m_lTextType;
m_lPlaceholderType = oSrc.m_lPlaceholderType;
m_lPlaceholderID = oSrc.m_lPlaceholderID;
m_lFontRef = oSrc.m_lFontRef;
m_bIsSlideFontRef = oSrc.m_bIsSlideFontRef;
m_oAttributes = oSrc.m_oAttributes;
m_bVertical = oSrc.m_bVertical;
m_lWrapMode = oSrc.m_lWrapMode;
m_bAutoFit = oSrc.m_bAutoFit;
m_arParagraphs.insert(m_arParagraphs.end(), oSrc.m_arParagraphs.begin(), oSrc.m_arParagraphs.end());
m_oRuler = oSrc.m_oRuler;
m_oLayoutStyles = oSrc.m_oLayoutStyles;
m_oStyles = oSrc.m_oStyles;
m_lTextMasterType = oSrc.m_lTextMasterType;
return *this;
}
CTextAttributesEx(const CTextAttributesEx& oSrc)
{
*this = oSrc;
}
~CTextAttributesEx()
{
m_arParagraphs.clear();
}
public:
inline void NormalizeString(CString& strText)
{
strText.Replace(_T("&"), _T("&amp;"));
strText.Replace(_T("'"), _T("&apos;"));
strText.Replace(_T("<"), _T("&lt;"));
strText.Replace(_T(">"), _T("&gt;"));
strText.Replace(_T("\""), _T("&quot;"));
}
void RecalcParagraphs (CTheme* pTheme = NULL);
void RecalcParagraphsPPT();
void ApplyThemeStyle (CTheme* pTheme = NULL);
void ApplyRuler (CTheme* pTheme);
void ApplyRuler (CTextPFRun* pPar, WORD lIndentLevel);
bool IsEmptyText()
{
return (0 == m_arParagraphs.size()) ? true : false;
}
};
}
ASCOfficePPTXFile/Editor/PPTXElements/TextStructures.h 0 → 100644
View file @ c6879804
#pragma once
#include "Structures.h"
#include "../../Common/DocxFormat/Source/Base/Nullable.h"
namespace NSPresentationEditor
{
#define DEFAULT_BEFORE(EXIST_PARAM, PARAM) \
if (!EXIST_PARAM && oSrc.##EXIST_PARAM) \
{ \
EXIST_PARAM = true; \
PARAM = oSrc.##PARAM; \
}
#define APPLY_AFTER(EXIST_PARAM, PARAM) \
if (oSrc.##EXIST_PARAM) \
{ \
EXIST_PARAM = true; \
PARAM = oSrc.##PARAM; \
}
static CString ToNode(const NSCommon::nullable_base<WORD>& prop, const CString& strName)
{
if (!prop.is_init())
return _T("");
int n = (int)prop.get();
CString strVal = XmlUtils::IntToString(n);
return _T("<") + strName + _T(">") + strVal + _T("</") + strName + _T(">");
}
static CString ToNode(const NSCommon::nullable_base<LONG>& prop, const CString& strName)
{
if (!prop.is_init())
return _T("");
int n = (int)prop.get();
CString strVal = XmlUtils::IntToString(n);
return _T("<") + strName + _T(">") + strVal + _T("</") + strName + _T(">");
}
static CString ToNode(const NSCommon::nullable_base<DWORD>& prop, const CString& strName)
{
if (!prop.is_init())
return _T("");
CString strVal = XmlUtils::UIntToString((size_t)prop.get());
return _T("<") + strName + _T(">") + strVal + _T("</") + strName + _T(">");
}
static CString ToNode(const NSCommon::nullable_base<double>& prop, const CString& strName)
{
if (!prop.is_init())
return _T("");
CString strVal = XmlUtils::DoubleToString(prop.get());
return _T("<") + strName + _T(">") + strVal + _T("</") + strName + _T(">");
}
static CString ToNode(const NSCommon::nullable_base<CColor>& prop, const CString& strName)
{
if (!prop.is_init())
return _T("");
CString strVal = XmlUtils::UIntToString(prop->GetLONG());
return _T("<") + strName + _T(">") + strVal + _T("</") + strName + _T(">");
}
class CFontProperties
{
public:
BYTE FontNameProp;
std::wstring strFontName;
std::wstring strPanose;
std::wstring strPitchFamily;
LONG lFontFixed;
std::vector<BYTE> arFontCharsets;
public:
CFontProperties() : FontNameProp(0), strFontName(_T("")), strPanose(_T("")), strPitchFamily(_T("")), lFontFixed(0), arFontCharsets()
{
}
~CFontProperties()
{
}
CFontProperties(const CFontProperties& oSrc)
{
*this = oSrc;
}
CFontProperties& operator=(const CFontProperties& oSrc)
{
FontNameProp = oSrc.FontNameProp;
strFontName = oSrc.strFontName;
strPanose = oSrc.strPanose;
strPitchFamily = oSrc.strPitchFamily;
lFontFixed = oSrc.lFontFixed;
for (int i =0 ; i< oSrc.arFontCharsets.size(); i++)
arFontCharsets.push_back(oSrc.arFontCharsets[i]);
return *this;
}
AVSINLINE void SetFont(CFont& oFont)
{
strFontName = oFont.Name;
strPanose = oFont.Panose;
strPitchFamily = oFont.PitchFamily;
lFontFixed = (LONG)oFont.Monospace;
arFontCharsets.clear();
arFontCharsets.push_back(oFont.Charset);
}
};
class CTextCFRun
{
public:
NSCommon::nullable_base<bool> FontBold;
NSCommon::nullable_base<bool> FontItalic;
NSCommon::nullable_base<bool> FontUnderline;
NSCommon::nullable_base<bool> FontStrikeout;
NSCommon::nullable_base<bool> FontShadow;
NSCommon::nullable_base<WORD> Typeface; // fontRef
NSCommon::nullable_base<WORD> EAFontRef; // eaFontRef
NSCommon::nullable_base<WORD> AnsiFontRef; // ansiFontRef
NSCommon::nullable_base<WORD> SymbolFontRef; // SymbolFontRef
NSCommon::nullable_base<double> BaseLineOffset; // baseline offset
NSCommon::nullable_base<CColor> Color; // text color
NSCommon::nullable_base<WORD> Size; // font size
NSCommon::nullable_base<WORD> Cap; // 0 - none, 1 - TEXT, 2 - text
NSCommon::nullable_base<WORD> Language;
NSCommon::nullable_base<CFontProperties> FontProperties;
NSCommon::nullable_base<CFontProperties> FontPropertiesEA;
NSCommon::nullable_base<CFontProperties> FontPropertiesSym;
public:
CTextCFRun() : FontBold(), FontItalic(), FontUnderline(), FontStrikeout(), FontShadow(),
Typeface(), EAFontRef(), AnsiFontRef(), SymbolFontRef(),
BaseLineOffset(), Color(), Size(), FontProperties(), Cap()
{
}
CTextCFRun(const CTextCFRun& oSrc)
{
*this = oSrc;
}
CTextCFRun& operator=(const CTextCFRun& oSrc)
{
FontBold = oSrc.FontBold;
FontItalic = oSrc.FontItalic;
FontUnderline = oSrc.FontUnderline;
FontStrikeout = oSrc.FontStrikeout;
FontShadow = oSrc.FontShadow;
Typeface = oSrc.Typeface;
EAFontRef = oSrc.EAFontRef;
AnsiFontRef = oSrc.AnsiFontRef;
SymbolFontRef = oSrc.SymbolFontRef;
BaseLineOffset = oSrc.BaseLineOffset;
Color = oSrc.Color;
Size = oSrc.Size;
FontProperties = oSrc.FontProperties;
Cap = oSrc.Cap;
Language = oSrc.Language;
return *this;
}
~CTextCFRun()
{
}
AVSINLINE void ApplyBefore(const CTextCFRun& oSrc)
{
if (!FontBold.is_init()) FontBold = oSrc.FontBold;
if (!FontItalic.is_init()) FontItalic = oSrc.FontItalic;
if (!FontUnderline.is_init()) FontUnderline = oSrc.FontUnderline;
if (!FontStrikeout.is_init()) FontStrikeout = oSrc.FontStrikeout;
if (!FontShadow.is_init()) FontShadow = oSrc.FontShadow;
if (!Typeface.is_init()) Typeface = oSrc.Typeface;
if (!EAFontRef.is_init()) EAFontRef = oSrc.EAFontRef;
if (!AnsiFontRef.is_init()) AnsiFontRef = oSrc.AnsiFontRef;
if (!SymbolFontRef.is_init()) SymbolFontRef = oSrc.SymbolFontRef;
if (!BaseLineOffset.is_init()) BaseLineOffset = oSrc.BaseLineOffset;
if (!Color.is_init()) Color = oSrc.Color;
if (!Size.is_init()) Size = oSrc.Size;
if (!Cap.is_init()) Cap = oSrc.Cap;
if (!FontProperties.is_init()) FontProperties = oSrc.FontProperties;
if (!Language.is_init()) Language = oSrc.Language;
}
AVSINLINE void ApplyAfter(const CTextCFRun& oSrc)
{
if (oSrc.FontBold.is_init()) FontBold = oSrc.FontBold;
if (oSrc.FontItalic.is_init()) FontItalic = oSrc.FontItalic;
if (oSrc.FontUnderline.is_init()) FontUnderline = oSrc.FontUnderline;
if (oSrc.FontStrikeout.is_init()) FontStrikeout = oSrc.FontStrikeout;
if (oSrc.FontShadow.is_init()) FontShadow = oSrc.FontShadow;
bool bTypefaceSetUp = false;
if (oSrc.Typeface.is_init())
{
Typeface = oSrc.Typeface;
bTypefaceSetUp = true;
}
if (oSrc.EAFontRef.is_init()) EAFontRef = oSrc.EAFontRef;
if (oSrc.AnsiFontRef.is_init()) AnsiFontRef = oSrc.AnsiFontRef;
if (oSrc.SymbolFontRef.is_init()) SymbolFontRef = oSrc.SymbolFontRef;
if (oSrc.BaseLineOffset.is_init()) BaseLineOffset = oSrc.BaseLineOffset;
if (oSrc.Color.is_init()) Color = oSrc.Color;
if (oSrc.Size.is_init()) Size = oSrc.Size;
if (oSrc.Cap.is_init()) Cap = oSrc.Cap;
if (oSrc.FontProperties.is_init())
{
FontProperties = oSrc.FontProperties;
if (!bTypefaceSetUp)
Typeface.reset();
}
if (oSrc.Language.is_init())
Language = oSrc.Language;
}
};
class CTextPFRun
{
public:
NSCommon::nullable_base<bool> hasBullet;
NSCommon::nullable_base<WORD> bulletFontRef;
NSCommon::nullable_base<WORD> bulletSize;
NSCommon::nullable_base<WCHAR> bulletChar;
NSCommon::nullable_base<CColor> bulletColor;
NSCommon::nullable_base<CFontProperties> bulletFontProperties;
NSCommon::nullable_base<WORD> textAlignment;
NSCommon::nullable_base<LONG> lineSpacing;
NSCommon::nullable_base<LONG> spaceBefore;
NSCommon::nullable_base<LONG> spaceAfter;
NSCommon::nullable_base<LONG> leftMargin;
NSCommon::nullable_base<LONG> indent;
NSCommon::nullable_base<LONG> defaultTabSize;
std::vector<std::pair<int, int>> tabStops;
bool bIsOneLine;
NSCommon::nullable_base<WORD> fontAlign;
NSCommon::nullable_base<WORD> textDirection;
NSCommon::nullable_base<WORD> wrapFlags;
CTextPFRun() : hasBullet(), bulletFontRef(), bulletSize(), bulletChar(), bulletColor(),
textAlignment(), lineSpacing(), spaceBefore(), spaceAfter(), leftMargin(), indent(),
defaultTabSize(), tabStops(), bIsOneLine(false), fontAlign(), wrapFlags()
{
}
CTextPFRun(const CTextPFRun& oSrc)
{
*this = oSrc;
}
CTextPFRun& operator =(const CTextPFRun& oSrc)
{
hasBullet = oSrc.hasBullet;
bulletFontRef = oSrc.bulletFontRef;
bulletSize = oSrc.bulletSize;
bulletChar = oSrc.bulletChar;
bulletColor = oSrc.bulletColor;
bulletFontProperties = oSrc.bulletFontProperties;
textAlignment = oSrc.textAlignment;
lineSpacing = oSrc.lineSpacing;
spaceBefore = oSrc.spaceBefore;
spaceAfter = oSrc.spaceAfter;
leftMargin = oSrc.leftMargin;
indent = oSrc.indent;
defaultTabSize = oSrc.defaultTabSize;
tabStops = oSrc.tabStops;
fontAlign = oSrc.fontAlign;
textDirection = oSrc.textDirection;
wrapFlags = oSrc.wrapFlags;
bIsOneLine = oSrc.bIsOneLine;
return *this;
}
void ApplyBefore(const CTextPFRun& oSrc)
{
if (!hasBullet.is_init())
{
hasBullet = oSrc.hasBullet;
bulletSize = oSrc.bulletSize;
bulletChar = oSrc.bulletChar;
bulletFontRef = oSrc.bulletFontRef;
bulletColor = oSrc.bulletColor;
bulletFontProperties.reset();
}
if (!textAlignment.is_init()) textAlignment = oSrc.textAlignment;
if (!lineSpacing.is_init()) lineSpacing = oSrc.lineSpacing;
if (!spaceBefore.is_init()) spaceBefore = oSrc.spaceBefore;
if (!spaceAfter.is_init()) spaceAfter = oSrc.spaceAfter;
if (!leftMargin.is_init()) leftMargin = oSrc.leftMargin;
if (!indent.is_init()) indent = oSrc.indent;
if (!defaultTabSize.is_init()) defaultTabSize = oSrc.defaultTabSize;
if (!fontAlign.is_init()) fontAlign = oSrc.fontAlign;
if (!textDirection.is_init()) textDirection = oSrc.textDirection;
if (!wrapFlags.is_init()) wrapFlags = oSrc.wrapFlags;
if ((0 == tabStops.size()) && (0 != oSrc.tabStops.size()))
{
tabStops.insert(tabStops.end(), oSrc.tabStops.begin(), oSrc.tabStops.end());
}
}
void ApplyAfter(const CTextPFRun& oSrc)
{
if (oSrc.hasBullet.is_init())
{
hasBullet = oSrc.hasBullet;
bulletSize = oSrc.bulletSize;
bulletChar = oSrc.bulletChar;
bulletFontRef = oSrc.bulletFontRef;
bulletColor = oSrc.bulletColor;
bulletFontProperties.reset();
}
if (oSrc.textAlignment.is_init()) textAlignment = oSrc.textAlignment;
if (oSrc.lineSpacing.is_init()) lineSpacing = oSrc.lineSpacing;
if (oSrc.spaceBefore.is_init()) spaceBefore = oSrc.spaceBefore;
if (oSrc.spaceAfter.is_init()) spaceAfter = oSrc.spaceAfter;
if (oSrc.leftMargin.is_init()) leftMargin = oSrc.leftMargin;
if (oSrc.indent.is_init()) indent = oSrc.indent;
if (oSrc.defaultTabSize.is_init()) defaultTabSize = oSrc.defaultTabSize;
if (oSrc.fontAlign.is_init()) fontAlign = oSrc.fontAlign;
if (oSrc.textDirection.is_init()) textDirection = oSrc.textDirection;
if (oSrc.wrapFlags.is_init()) wrapFlags = oSrc.wrapFlags;
if (!oSrc.tabStops.empty()) tabStops = oSrc.tabStops;
}
CString ToString(LONG lCount)
{
return L"";
}
};
class CTextRuler
{
public:
NSCommon::nullable_base<LONG> DefaultTabSize;
NSCommon::nullable_base<SHORT> CLevels;
NSCommon::nullable_base<SHORT> TabStops;
std::vector<std::pair<int,int>> tabsStops;
NSCommon::nullable_base<LONG> LeftMargin1;
NSCommon::nullable_base<LONG> LeftMargin2;
NSCommon::nullable_base<LONG> LeftMargin3;
NSCommon::nullable_base<LONG> LeftMargin4;
NSCommon::nullable_base<LONG> LeftMargin5;
NSCommon::nullable_base<LONG> Indent1;
NSCommon::nullable_base<LONG> Indent2;
NSCommon::nullable_base<LONG> Indent3;
NSCommon::nullable_base<LONG> Indent4;
NSCommon::nullable_base<LONG> Indent5;
public:
CTextRuler() : DefaultTabSize(), CLevels(), TabStops(),
LeftMargin1(), LeftMargin2(), LeftMargin3(), LeftMargin4(), LeftMargin5(),
Indent1(), Indent2(), Indent3(), Indent4(), Indent5(), tabsStops()
{
}
CTextRuler(const CTextRuler& oSrc)
{
*this = oSrc;
}
CTextRuler& operator =(const CTextRuler& oSrc)
{
DefaultTabSize = oSrc.DefaultTabSize;
CLevels = oSrc.CLevels;
TabStops = oSrc.TabStops;
LeftMargin1 = oSrc.LeftMargin1;
LeftMargin2 = oSrc.LeftMargin2;
LeftMargin3 = oSrc.LeftMargin3;
LeftMargin4 = oSrc.LeftMargin4;
LeftMargin5 = oSrc.LeftMargin5;
Indent1 = oSrc.Indent1;
Indent2 = oSrc.Indent2;
Indent3 = oSrc.Indent3;
Indent4 = oSrc.Indent4;
Indent5 = oSrc.Indent5;
tabsStops = oSrc.tabsStops;
return *this;
}
~CTextRuler()
{
tabsStops.clear();
}
void ApplyBefore(const CTextRuler& oSrc)
{
if (!DefaultTabSize.is_init()) DefaultTabSize = oSrc.DefaultTabSize;
if (!CLevels.is_init()) CLevels = oSrc.CLevels;
if (!LeftMargin1.is_init()) LeftMargin1 = oSrc.LeftMargin1;
if (!LeftMargin2.is_init()) LeftMargin2 = oSrc.LeftMargin2;
if (!LeftMargin3.is_init()) LeftMargin3 = oSrc.LeftMargin3;
if (!LeftMargin4.is_init()) LeftMargin4 = oSrc.LeftMargin4;
if (!LeftMargin5.is_init()) LeftMargin5 = oSrc.LeftMargin5;
if (!Indent1.is_init()) Indent1 = oSrc.Indent1;
if (!Indent2.is_init()) Indent2 = oSrc.Indent2;
if (!Indent3.is_init()) Indent3 = oSrc.Indent3;
if (!Indent4.is_init()) Indent4 = oSrc.Indent4;
if (!Indent5.is_init()) Indent5 = oSrc.Indent5;
if (!tabsStops.empty()) tabsStops = oSrc.tabsStops;
}
CString ToString()
{
return L"";
}
};
class CTextSIRun
{
public:
bool bIsExt;
DWORD lCount;
bool bSpell;
bool bLang;
bool bAltLang;
bool bPp10ext;
bool bBidi;
bool bSmartTag;
WORD Spell;
WORD Lang;
WORD AltLang;
WORD Bidi;
BYTE pp10runid;
bool bGramma;
std::vector<DWORD> arSmartTags;
public:
CTextSIRun()
{
bIsExt = true;
lCount = 0;
bSpell = false;
bLang = false;
bAltLang = false;
bPp10ext = false;
bBidi = false;
bSmartTag = false;
Spell = 0;
Lang = 0;
AltLang = 0;
Bidi = 0;
pp10runid = 0;
bGramma = false;
}
CTextSIRun(const CTextSIRun& oSrc)
{
*this = oSrc;
}
CTextSIRun& operator =(const CTextSIRun& oSrc)
{
bIsExt = oSrc.bIsExt;
lCount = oSrc.lCount;
bSpell = oSrc.bSpell;
bLang = oSrc.bLang;
bAltLang = oSrc.bAltLang;
bPp10ext = oSrc.bPp10ext;
bBidi = oSrc.bBidi;
bSmartTag = oSrc.bSmartTag;
Spell = oSrc.Spell;
Lang = oSrc.Lang;
AltLang = oSrc.AltLang;
Bidi = oSrc.Bidi;
pp10runid = oSrc.pp10runid;
bGramma = oSrc.bGramma;
arSmartTags = oSrc.arSmartTags;
return *this;
}
void ApplyBefore(const CTextSIRun& oSrc)
{
/*
* gcc 4.8 doesn't understand this construction:
*
DEFAULT_BEFORE(bSpell, Spell);
DEFAULT_BEFORE(bLang, Lang);
DEFAULT_BEFORE(bAltLang, AltLang);
DEFAULT_BEFORE(bBidi, Bidi);
DEFAULT_BEFORE(bPp10ext, pp10runid);
*/
if (!bSpell && oSrc.bSpell)
{
bSpell = true;
Spell = oSrc.Spell;
}
if (!bLang && oSrc.bLang)
{
bLang = true;
Lang = oSrc.Lang;
}
if (!bAltLang && oSrc.bAltLang)
{
bAltLang = true;
AltLang = oSrc.AltLang;
}
if (!bBidi && oSrc.bBidi)
{
bBidi = true;
Bidi = oSrc.Bidi;
}
if (!bPp10ext && oSrc.bPp10ext)
{
bPp10ext = true;
pp10runid = oSrc.pp10runid;
}
if (!bGramma)
{
bGramma = oSrc.bGramma;
}
}
CString ToString()
{
return L"";
}
};
class CSpan
{
public:
CTextCFRun m_oRun;
std::wstring m_strText;
bool m_bField;
CSpan() : m_oRun(), m_strText(_T("")), m_bField(false)
{
}
CSpan(const CSpan& oSrc)
{
*this = oSrc;
}
CSpan& operator=(const CSpan& oSrc)
{
m_oRun = oSrc.m_oRun;
m_strText = oSrc.m_strText;
m_bField = oSrc.m_bField;
return *this;
}
~CSpan()
{
}
};
class CTextStyleLevel
{
public:
CTextPFRun m_oPFRun;
CTextCFRun m_oCFRun;
public:
CTextStyleLevel() : m_oPFRun(), m_oCFRun()
{
}
CTextStyleLevel(const CTextStyleLevel& oSrc)
{
*this = oSrc;
}
CTextStyleLevel& operator=(const CTextStyleLevel& oSrc)
{
m_oPFRun = oSrc.m_oPFRun;
m_oCFRun = oSrc.m_oCFRun;
return *this;
}
void ApplyAfter(const CTextStyleLevel& oSrc)
{
m_oPFRun.ApplyAfter(oSrc.m_oPFRun);
m_oCFRun.ApplyAfter(oSrc.m_oCFRun);
}
void ApplyBefore(const CTextStyleLevel& oSrc)
{
m_oPFRun.ApplyBefore(oSrc.m_oPFRun);
m_oCFRun.ApplyBefore(oSrc.m_oCFRun);
}
};
// ???
//class CTextFullInfo
//{
//public:
// CTextPFRun m_oPF;
// CTextCFRun m_oCF;
// CTextRuler m_oRuler;
// CTextSIRun m_oSI;
//public:
// CTextFullInfo() : m_oPF(), m_oCF(), m_oRuler(), m_oSI()
// {
// }
// CTextFullInfo(const CTextFullInfo& oSrc)
// {
// *this = oSrc;
// }
// CTextFullInfo& operator=(const CTextFullInfo& oSrc)
// {
// m_oPF = oSrc.m_oPF;
// m_oCF = oSrc.m_oCF;
// m_oRuler = oSrc.m_oRuler;
// m_oSI = oSrc.m_oSI;
// return *this;
// }
//};
class CTextStyles
{
public:
NSCommon::nullable_base<CTextStyleLevel> m_pLevels[10];
public:
CTextStyles()
{
for (int i = 0; i < 10; ++i)
{
m_pLevels[i] = NULL;
}
}
CTextStyles(const CTextStyles& oSrc)
{
*this = oSrc;
}
CTextStyles& operator=(const CTextStyles& oSrc)
{
for (int i = 0; i < 10; ++i)
{
m_pLevels[i] = oSrc.m_pLevels[i];
}
return *this;
}
void SetStyles(CTextStyles* pStyles)
{
for (int i = 0; i < 10; ++i)
{
m_pLevels[i] = pStyles->m_pLevels[i];
}
}
void SetLanguage(nullable<WORD> & language)
{
if (!language.is_init()) return;
for (int i = 0; i < 10; ++i)
{
if (m_pLevels[i].is_init())
{
m_pLevels[i]->m_oCFRun.Language = language;
}
}
}
void ApplyAfter(const CTextStyles& oSrc)
{
for (int i = 0; i < 10; ++i)
{
if (!m_pLevels[i].is_init())
{
m_pLevels[i] = oSrc.m_pLevels[i];
}
else if (oSrc.m_pLevels[i].is_init())
{
m_pLevels[i]->ApplyAfter(oSrc.m_pLevels[i].get());
}
}
}
void ApplyBefore(const CTextStyles& oSrc)
{
for (int i = 0; i < 10; ++i)
{
if (!m_pLevels[i].is_init())
{
m_pLevels[i] = oSrc.m_pLevels[i];
}
else if (oSrc.m_pLevels[i].is_init())
{
m_pLevels[i]->ApplyBefore(oSrc.m_pLevels[i].get());
}
}
}
};
class CParagraph
{
public:
int m_lTextType;
int m_lTextLevel;
int m_lStyleThemeIndex;
CTextPFRun m_oPFRun;
std::vector<CSpan> m_arSpans;
public:
CParagraph() : m_oPFRun(), m_arSpans()
{
m_lTextType = -1;
m_lTextLevel = 0;
m_lStyleThemeIndex = -1;
}
CParagraph(const CParagraph& oSrc)
{
*this = oSrc;
}
CParagraph& operator=(const CParagraph& oSrc)
{
m_lTextLevel = oSrc.m_lTextLevel;
m_lTextType = oSrc.m_lTextType;
m_lStyleThemeIndex = oSrc.m_lStyleThemeIndex;
m_oPFRun = oSrc.m_oPFRun;
m_arSpans = oSrc.m_arSpans;
return *this;
}
~CParagraph()
{
m_arSpans.clear();
}
AVSINLINE void CheckErrors()
{
//if (IsEmpty())
//{
// m_oPFRun.hasBullet = false;
//}
size_t nCountS = m_arSpans.size();
for (size_t i = 0; i < nCountS; ++i)
{
std::replace( m_arSpans[i].m_strText.begin(), m_arSpans[i].m_strText.end(), (TCHAR)(11), (TCHAR)(13));
}
}
AVSINLINE bool IsEmpty()
{
size_t nCountSpans = m_arSpans.size();
for (size_t i = 0; i < nCountSpans; ++i)
{
int nLen = m_arSpans[i].m_strText.length();
if (nLen > 1)
return false;
if ((nLen == 1) && ((TCHAR)(13) != m_arSpans[i].m_strText[0]))
return false;
}
return true;
}
};
}
ASCOfficePPTXFile/Editor/PPTXElements/Theme.cpp 0 → 100644
View file @ c6879804
#include "Elements.h"
namespace NSPresentationEditor
{
}
ASCOfficePPTXFile/Editor/PPTXElements/Theme.h 0 → 100644
View file @ c6879804
#pragma once
#include "Structures.h"
#include "Layout.h"
//#include "../PPTXWriter/CSS.h"
namespace NSPresentationEditor
{
const long g_ThemeTextStylesCount = 4;
class CTheme
{
public:
std::map<_UINT64, LONG> m_mapGeomToLayout;//
std::map<DWORD, LONG> m_mapTitleLayout; //
std::multimap<int,int> m_mapPlaceholders;
std::vector<CColor> m_arColorScheme;
std::vector<CFont> m_arFonts;
std::vector<CBrush> m_arBrushes;
std::vector<CPen> m_arPens;
std::vector<CEffects> m_arEffects;
CTextStyles m_pStyles[g_ThemeTextStylesCount];
std::vector<CLayout> m_arLayouts;
bool m_bIsBackground;
CBrush m_oBackground;
std::vector<IElement*> m_arElements;
CMetricInfo m_oInfo;
std::wstring m_sThemeName;
std::vector<std::vector<CColor>>m_arExtraColorScheme;
long m_lOriginalWidth;
long m_lOriginalHeight;
bool m_bHasDate;
bool m_bHasSlideNumber;
bool m_bHasFooter;
int m_nFormatDate;//1- current, 2 - user
vector_string m_PlaceholdersReplaceString[3]; //0-dates, 1 - headers, 2 - footers
//------------------------------------------------------------------------------------
CTheme() : m_arColorScheme(), m_arFonts(), m_arBrushes(),
m_arPens(), m_arEffects(), m_arLayouts()
{
Clear();
}
CTheme(const CTheme& oSrc)
{
*this = oSrc;
}
CTheme& operator=(const CTheme& oSrc)
{
m_arColorScheme = oSrc.m_arColorScheme;
m_arFonts = oSrc.m_arFonts;
m_arBrushes = oSrc.m_arBrushes;
m_arPens = oSrc.m_arPens;
m_arEffects = oSrc.m_arEffects;
m_sThemeName = oSrc.m_sThemeName;
m_lOriginalWidth = oSrc.m_lOriginalWidth ;
m_lOriginalHeight = oSrc.m_lOriginalHeight;
m_bHasDate = oSrc.m_bHasDate;
m_bHasSlideNumber = oSrc.m_bHasSlideNumber;
m_bHasFooter = oSrc.m_bHasFooter;
m_nFormatDate = oSrc.m_nFormatDate;
for (int i = 0 ; i < 3 ; i++) m_PlaceholdersReplaceString[i] = oSrc.m_PlaceholdersReplaceString[i];
for (int i = 0; i < oSrc.m_arExtraColorScheme.size(); ++i)
{
m_arExtraColorScheme.push_back(oSrc.m_arExtraColorScheme[i]);
}
for (int i = 0; i < g_ThemeTextStylesCount; ++i)
m_pStyles[i] = oSrc.m_pStyles[i];
m_arLayouts = oSrc.m_arLayouts;
m_mapTitleLayout = oSrc.m_mapTitleLayout;
m_mapGeomToLayout = oSrc.m_mapGeomToLayout;
m_mapPlaceholders = oSrc.m_mapPlaceholders;
m_bIsBackground = oSrc.m_bIsBackground;
m_oBackground = oSrc.m_oBackground;
// layout'
size_t nCount = m_arLayouts.size();
for (size_t i = 0; i < nCount; ++i)
{
m_arLayouts[i].CreateDublicateElements();
}
m_arElements = oSrc.m_arElements;
nCount = m_arElements.size();
for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
{
ADDREFINTERFACE((m_arElements[nIndex]));
}
CreateDublicateElements();
for (long nIndexStyle = 0; nIndexStyle < g_ThemeTextStylesCount; ++nIndexStyle)
{
m_pStyles[nIndexStyle] = oSrc.m_pStyles[nIndexStyle];
}
return (*this);
}
void CreateDublicateElements()
{
//
size_t nCount = m_arElements.size();
for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
{
IElement* pElem = m_arElements[nIndex];
if (NULL != pElem)
{
m_arElements[nIndex] = pElem->CreateDublicate();
}
RELEASEINTERFACE(pElem);
}
}
void Clear()
{
size_t nCount = m_arElements.size();
for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
{
RELEASEINTERFACE((m_arElements[nIndex]));
}
m_arElements.clear();
m_arLayouts.clear();
m_mapTitleLayout.clear();
m_mapGeomToLayout.clear();
m_mapPlaceholders.clear();
m_lOriginalWidth = m_lOriginalHeight = 0;
m_sThemeName = L"Default";
m_bHasDate = false;
m_bHasSlideNumber = false;
m_bHasFooter = false;
m_nFormatDate = 1;
for (int i = 0 ; i < 3 ; i++) m_PlaceholdersReplaceString[i].clear();
}
~CTheme()
{
}
public:
NSPresentationEditor::CColor GetColor(const LONG& lIndexScheme)
{
if (lIndexScheme < (LONG)m_arColorScheme.size())
{
return m_arColorScheme[lIndexScheme];
}
return NSPresentationEditor::CColor();
}
void CalculateStyles()
{
LONG lCountColors = (LONG)m_arColorScheme.size();
for (int pos = 0; pos < g_ThemeTextStylesCount; ++pos)
{
NSPresentationEditor::CTextStyles& oStyle = m_pStyles[pos];
size_t nLevels = 10;
for (size_t i = 0; i < nLevels; ++i)
{
if (!oStyle.m_pLevels[i].is_init())
continue;
CTextStyleLevel* pLevel = oStyle.m_pLevels[i].operator ->();
if (pLevel->m_oPFRun.bulletColor.is_init())
{
CColor& oColor = pLevel->m_oPFRun.bulletColor.get();
if ((0 <= oColor.m_lSchemeIndex) && (oColor.m_lSchemeIndex < lCountColors))
{
oColor.R = m_arColorScheme[oColor.m_lSchemeIndex].R;
oColor.G = m_arColorScheme[oColor.m_lSchemeIndex].G;
oColor.B = m_arColorScheme[oColor.m_lSchemeIndex].B;
oColor.A = m_arColorScheme[oColor.m_lSchemeIndex].A;
}
}
if (pLevel->m_oCFRun.Color.is_init())
{
CColor& oColor = pLevel->m_oCFRun.Color.get();
if ((0 <= oColor.m_lSchemeIndex) && (oColor.m_lSchemeIndex < lCountColors))
{
oColor.R = m_arColorScheme[oColor.m_lSchemeIndex].R;
oColor.G = m_arColorScheme[oColor.m_lSchemeIndex].G;
oColor.B = m_arColorScheme[oColor.m_lSchemeIndex].B;
oColor.A = m_arColorScheme[oColor.m_lSchemeIndex].A;
}
}
if (pLevel->m_oCFRun.Typeface.IsInit())
{
WORD lFontIndex = pLevel->m_oCFRun.Typeface.get();
if (lFontIndex < (WORD)m_arFonts.size())
{
if (!pLevel->m_oCFRun.FontProperties.is_init())
pLevel->m_oCFRun.FontProperties = new CFontProperties();
pLevel->m_oCFRun.FontProperties->SetFont(m_arFonts[lFontIndex]);
}
}
if (pLevel->m_oPFRun.bulletFontRef.IsInit())
{
WORD lFontIndex = pLevel->m_oPFRun.bulletFontRef.get();
if (lFontIndex < (WORD)m_arFonts.size())
{
if (!pLevel->m_oPFRun.bulletFontProperties.is_init())
pLevel->m_oPFRun.bulletFontProperties = new CFontProperties();
pLevel->m_oPFRun.bulletFontProperties->SetFont(m_arFonts[lFontIndex]);
}
}
}
}
}
static void CalculateStyle(CTheme* pTheme, CTextStyles& oStyle)
{
LONG lCountColors = (LONG)pTheme->m_arColorScheme.size();
//
size_t nLevels = 10;
for (size_t i = 0; i < nLevels; ++i)
{
if (!oStyle.m_pLevels[i].is_init())
continue;
CTextStyleLevel* pLevel = oStyle.m_pLevels[i].operator ->();
if (pLevel->m_oPFRun.bulletColor.is_init())
{
CColor& oColor = pLevel->m_oPFRun.bulletColor.get();
if ((0 <= oColor.m_lSchemeIndex) && (oColor.m_lSchemeIndex < lCountColors))
{
oColor.R = pTheme->m_arColorScheme[oColor.m_lSchemeIndex].R;
oColor.G = pTheme->m_arColorScheme[oColor.m_lSchemeIndex].G;
oColor.B = pTheme->m_arColorScheme[oColor.m_lSchemeIndex].B;
oColor.A = pTheme->m_arColorScheme[oColor.m_lSchemeIndex].A;
}
}
if (pLevel->m_oCFRun.Color.is_init())
{
CColor& oColor = pLevel->m_oCFRun.Color.get();
if ((0 <= oColor.m_lSchemeIndex) && (oColor.m_lSchemeIndex < lCountColors))
{
oColor.R = pTheme->m_arColorScheme[oColor.m_lSchemeIndex].R;
oColor.G = pTheme->m_arColorScheme[oColor.m_lSchemeIndex].G;
oColor.B = pTheme->m_arColorScheme[oColor.m_lSchemeIndex].B;
oColor.A = pTheme->m_arColorScheme[oColor.m_lSchemeIndex].A;
}
}
if (pLevel->m_oCFRun.Typeface.IsInit())
{
WORD lFontIndex = pLevel->m_oCFRun.Typeface.get();
if (lFontIndex < (WORD)pTheme->m_arFonts.size())
{
if (!pLevel->m_oCFRun.FontProperties.is_init())
pLevel->m_oCFRun.FontProperties = new CFontProperties();
pLevel->m_oCFRun.FontProperties->SetFont(pTheme->m_arFonts[lFontIndex]);
}
}
}
}
};
}
\ No newline at end of file
ASCOfficePPTXFile/Editor/PPTXElements/XmlWriter.h 0 → 100644
View file @ c6879804
#pragma once
#include "../../Common/DocxFormat/Source/SystemUtility/File.h"
namespace NSPresentationEditor
{
static std::wstring g_bstr_nodeopen = L"<";
static std::wstring g_bstr_nodeclose = L">";
static std::wstring g_bstr_nodeopen_slash = L"</";
static std::wstring g_bstr_nodeclose_slash = L"/>";
static std::wstring g_bstr_node_space = L" ";
static std::wstring g_bstr_node_equal = L"=";
static std::wstring g_bstr_node_quote = L"\"";
static std::wstring g_bstr_boolean_true = L"true";
static std::wstring g_bstr_boolean_false = L"false";
inline static double FABS(double dVal)
{
return (dVal >= 0) ? dVal : -dVal;
}
inline static int round(double dVal)
{
return (int)(dVal + 0.5);
}
class CStringWriter
{
private:
wchar_t* m_pData;
size_t m_lSize;
wchar_t* m_pDataCur;
size_t m_lSizeCur;
public:
CStringWriter()
{
m_pData = NULL;
m_lSize = 0;
m_pDataCur = m_pData;
m_lSizeCur = m_lSize;
}
~CStringWriter()
{
RELEASEMEM(m_pData);
}
AVSINLINE void AddSize(size_t nSize)
{
if (NULL == m_pData)
{
m_lSize = (std::max)(nSize, (size_t) 1000);
m_pData = (wchar_t*)malloc(m_lSize * sizeof(wchar_t));
memset(m_pData, 0, m_lSize * sizeof(wchar_t));
m_lSizeCur = 0;
m_pDataCur = m_pData;
return;
}
if ((m_lSizeCur + nSize) > m_lSize)
{
while ((m_lSizeCur + nSize) > m_lSize)
{
m_lSize *= 2;
}
wchar_t* pRealloc = (wchar_t*)realloc(m_pData, m_lSize * sizeof(wchar_t));
if (NULL != pRealloc)
{
//
m_pData = pRealloc;
m_pDataCur = m_pData + m_lSizeCur;
}
else
{
wchar_t* pMalloc = (wchar_t*)malloc(m_lSize * sizeof(wchar_t));
memset(pMalloc, 0, m_lSize * sizeof(wchar_t));
memcpy(pMalloc, m_pData, m_lSizeCur * sizeof(wchar_t));
free(m_pData);
m_pData = pMalloc;
m_pDataCur = m_pData + m_lSizeCur;
}
}
}
public:
AVSINLINE void WriteString(const wchar_t* pString, size_t& nLen)
{
AddSize(nLen);
// memcpy(m_pDataCur, pString, nLen * sizeof(wchar_t));
// wstring has 4 bytes length (not 2 in WIN32) in linux/macos
memcpy(m_pDataCur, pString, (2 == sizeof (wchar_t)) ? (nLen << 1) : (nLen << 2));
m_pDataCur += nLen;
m_lSizeCur += nLen;
}
#if defined(_WIN32) || defined(_WIN64)
AVSINLINE void WriteString(_bstr_t& bsString)
{
size_t nLen = bsString.length();
WriteString(bsString.GetBSTR(), nLen);
}
#endif // #if defined(_WIN32) || defined(_WIN64)
AVSINLINE void WriteStringXML(const std::wstring & wString)
{
std::wstring buffer;
buffer.reserve(wString.size());
for(size_t pos = 0; pos != wString.size(); ++pos)
{
switch(wString[pos])
{
case '&': buffer.append(_T("&amp;")); break;
case '\"': buffer.append(_T("&quot;")); break;
case '\'': buffer.append(_T("&apos;")); break;
case '<': buffer.append(_T("&lt;")); break;
case '>': buffer.append(_T("&gt;")); break;
default: buffer.append(&wString[pos], 1); break;
}
}
WriteString(buffer);
}
AVSINLINE void WriteString(const std::wstring & wString)
{
size_t nLen = wString.length();
WriteString(wString.c_str(), nLen);
}
AVSINLINE void WriteString(const CString & sString)
{
size_t nLen = (size_t)sString.GetLength();
#ifdef _UNICODE
CString str = sString;
WriteString(str.GetBuffer(), nLen);
#else
CStringW str = (CStringW)sString;
WriteString(str.GetBuffer(), nLen);
#endif
}
AVSINLINE size_t GetCurSize()
{
return m_lSizeCur;
}
AVSINLINE void Write(CStringWriter& oWriter)
{
WriteString(oWriter.m_pData, oWriter.m_lSizeCur);
}
inline void Clear()
{
RELEASEMEM(m_pData);
m_pData = NULL;
m_lSize = 0;
m_pDataCur = m_pData;
m_lSizeCur = 0;
}
inline void ClearNoAttack()
{
m_pDataCur = m_pData;
if (m_pData) m_pData[0] = 0;
m_lSizeCur = 0;
}
CString GetData()
{
CString str(m_pData, (int)m_lSizeCur);
return str;
}
void CorrectUnicodeString()
{
BYTE m_mapUnicode[0x10000];
memset(m_mapUnicode, 0, 0x10000);
m_mapUnicode[0x0009] = 1;
m_mapUnicode[0x000A] = 1;
m_mapUnicode[0x000D] = 1;
memset(m_mapUnicode + 0x0020, 1, 0xD7FF - 0x0020 + 1);
memset(m_mapUnicode + 0xE000, 1, 0xFFFD - 0xE000 + 1);
wchar_t* pMemory = m_pData;
while (pMemory < m_pDataCur)
{
if (!m_mapUnicode[*pMemory])
*pMemory = wchar_t(' ');
++pMemory;
}
}
};
//class CXmlWriter
//{
// CStringWriter m_oWriter;
//
//public:
// CXmlWriter() : m_oWriter()
// {
// }
//
// inline CString GetXmlString()
// {
// return m_oWriter.GetData();
// }
// // write value
// AVSINLINE void WriteString(CString strValue)
// {
// m_oWriter.WriteString(strValue);
// }
// AVSINLINE void WriteDouble(const double& val)
// {
// CString str = _T("");
// str.Format(_T("%lf"), val);
// m_oWriter.WriteString(str);
// }
// AVSINLINE void WriteLONG(const long& val)
// {
// CString str = _T("");
// str.Format(_T("%d"), val);
// m_oWriter.WriteString(str);
// }
// AVSINLINE void WriteDWORD(const DWORD& val)
// {
// CString str = _T("");
// str.Format(_T("%u"), val);
// m_oWriter.WriteString(str);
// }
// AVSINLINE void WriteDWORD_hex(const DWORD& val)
// {
// CString str = _T("");
// str.Format(_T("%x"), val);
// m_oWriter.WriteString(str);
// }
// // write attribute
// AVSINLINE void WriteAttributeString(const CString& strAttributeName, const CString& val)
// {
// m_oWriter.WriteString(g_bstr_node_space);
// m_oWriter.WriteString(strAttributeName);
// m_oWriter.WriteString(g_bstr_node_equal);
// m_oWriter.WriteString(g_bstr_node_quote);
// m_oWriter.WriteString(val);
// m_oWriter.WriteString(g_bstr_node_quote);
// }
// AVSINLINE void WriteAttributeDouble(const CString& strAttributeName, const double& val)
// {
// m_oWriter.WriteString(g_bstr_node_space);
// m_oWriter.WriteString(strAttributeName);
// m_oWriter.WriteString(g_bstr_node_equal);
// m_oWriter.WriteString(g_bstr_node_quote);
// WriteDouble(val);
// m_oWriter.WriteString(g_bstr_node_quote);
// }
// AVSINLINE void WriteAttributeLONG(const CString& strAttributeName, const LONG& val)
// {
// m_oWriter.WriteString(g_bstr_node_space);
// m_oWriter.WriteString(strAttributeName);
// m_oWriter.WriteString(g_bstr_node_equal);
// m_oWriter.WriteString(g_bstr_node_quote);
// WriteLONG(val);
// m_oWriter.WriteString(g_bstr_node_quote);
// }
// AVSINLINE void WriteAttributeDWORD(const CString& strAttributeName, const DWORD& val)
// {
// m_oWriter.WriteString(g_bstr_node_space);
// m_oWriter.WriteString(strAttributeName);
// m_oWriter.WriteString(g_bstr_node_equal);
// m_oWriter.WriteString(g_bstr_node_quote);
// WriteDWORD(val);
// m_oWriter.WriteString(g_bstr_node_quote);
// }
// AVSINLINE void WriteAttributeDWORD_hex(const CString& strAttributeName, const DWORD& val)
// {
// m_oWriter.WriteString(g_bstr_node_space);
// m_oWriter.WriteString(strAttributeName);
// m_oWriter.WriteString(g_bstr_node_equal);
// m_oWriter.WriteString(g_bstr_node_quote);
// WriteDWORD_hex(val);
// m_oWriter.WriteString(g_bstr_node_quote);
// }
// // document methods
// AVSINLINE void WriteNodeBegin(CString strNodeName, bool bAttributed = false)
// {
// m_oWriter.WriteString(g_bstr_nodeopen);
// m_oWriter.WriteString(strNodeName);
//
// if (!bAttributed)
// m_oWriter.WriteString(g_bstr_nodeclose);
// }
// AVSINLINE void WriteNodeEnd(CString strNodeName, bool bEmptyNode = false, bool bEndNode = true)
// {
// if (bEmptyNode)
// {
// if (bEndNode)
// m_oWriter.WriteString(g_bstr_nodeclose_slash);
// else
// m_oWriter.WriteString(g_bstr_nodeclose);
// }
// else
// {
// m_oWriter.WriteString(g_bstr_nodeopen_slash);
// m_oWriter.WriteString(strNodeName);
// m_oWriter.WriteString(g_bstr_nodeclose);
// }
// }
// // write node values
// AVSINLINE void WriteNodeValueString(const CString& strNodeName, const CString& val)
// {
// WriteNodeBegin(strNodeName);
// WriteString(val);
// WriteNodeEnd(strNodeName);
// }
// AVSINLINE void WriteNodeValueBool(const CString& strNodeName, const bool& val)
// {
// WriteNodeBegin(strNodeName);
//
// if (val)
// WriteString(_T("1"));
// else
// WriteString(_T("0"));
// WriteNodeEnd(strNodeName);
// }
// AVSINLINE void WriteNodeValueDouble(const CString& strNodeName, const double& val)
// {
// WriteNodeBegin(strNodeName);
// WriteDouble(val);
// WriteNodeEnd(strNodeName);
// }
// AVSINLINE void WriteNodeValueLONG(const CString& strNodeName, const LONG& val)
// {
// WriteNodeBegin(strNodeName);
// WriteLONG(val);
// WriteNodeEnd(strNodeName);
// }
// AVSINLINE void WriteNodeValueDWORD(const CString& strNodeName, const DWORD& val)
// {
// WriteNodeBegin(strNodeName);
// WriteDWORD(val);
// WriteNodeEnd(strNodeName);
// }
// AVSINLINE void WriteNodeValueDWORD_hex(const CString& strNodeName, const DWORD& val)
// {
// WriteNodeBegin(strNodeName);
// WriteDWORD_hex(val);
// WriteNodeEnd(strNodeName);
// }
//
// bool SaveToFile(CString strFilePath, bool bEncodingToUTF8 = false)
// {
// CString strData = m_oWriter.GetData();
// if (!bEncodingToUTF8)
// {
// CFile oFile;
// oFile.CreateFile(strFilePath);
// oFile.WriteFile((void*)strData.GetBuffer(), strData.GetLength());
// oFile.CloseFile();
// }
// else
// {
// CDirectory::SaveToFile(strFilePath, strData);
// }
//
// return true;
// }
//};
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7