Lea/DocumentServer
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
DocumentServer/ActiveX/Common/OfficeDrawing/Structures.h

1661 lines
37 KiB
C
Raw Normal View History

init repo
2014-07-05 18:22:49 +00:00
/*
* (c) Copyright Ascensio System SIA 2010-2014
*
* This program is a free software product. You can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License (AGPL)
* version 3 as published by the Free Software Foundation. In accordance with
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
* that Ascensio System SIA expressly excludes the warranty of non-infringement
* of any third-party rights.
*
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
*
* You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
* EU, LV-1021.
*
* The interactive user interfaces in modified source and object code versions
* of the Program must display Appropriate Legal Notices, as required under
* Section 5 of the GNU AGPL version 3.
*
* Pursuant to Section 7(b) of the License you must retain the original Product
* logo when distributing the program. Pursuant to Section 7(e) we decline to
* grant you any rights under trademark law for use of our trademarks.
*
* All the Product's GUI elements, including illustrations and icon sets, as
* well as technical writing content are licensed under the terms of the
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
*
*/
#pragma once
#include "Attributes.h"
#include "Shapes\BaseShape\Metric.h"
#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; \
}
using namespace NSAttributes;
class CTextAttributesEx;
struct SPointAtom
{
LONG X;
LONG Y;
CString ToString()
{
CString str = _T("");
str.Format(_T("<Point info='(%d,%d)' />"), X, Y);
return str;
}
void FromStream(IStream* pStream)
{
X = StreamUtils::ReadLONG(pStream);
Y = StreamUtils::ReadLONG(pStream);
}
};
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 = 0;
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;
}
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;
}
void FromStream(IStream* pStream)
{
R = StreamUtils::ReadBYTE(pStream);
G = StreamUtils::ReadBYTE(pStream);
B = StreamUtils::ReadBYTE(pStream);
Index = StreamUtils::ReadBYTE(pStream);
bPaletteIndex = (0x01 == (Index & 0x01));
bPaletteRGB = (0x02 == (Index & 0x02));
bSystemRGB = (0x04 == (Index & 0x04));
bSchemeIndex = (0x08 == (Index & 0x08));
bSysIndex = (0x10 == (Index & 0x10));
}
void FromValue(BYTE _R, BYTE _G, BYTE _B)
{
R = _R;
G = _G;
B = _B;
Index = 0x00;
}
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));
}
void ToColor(CColor_* pColor)
{
pColor->R = R;
pColor->G = G;
pColor->B = B;
}
};
struct STextRange
{
UINT Begin;
UINT End;
CString ToString()
{
CString str = _T("");
str.Format(_T("TextRange(%d,%d)"), Begin, End);
return str;
}
};
class CElementsContainer;
struct STextPFRun
{
BOOL bIsExt;
DWORD lCount;
WORD lIndentLevel;
bool hasBullet_;
bool bulletHasFont_;
bool bulletHasColor_;
bool bulletHasSize_;
bool bulletFont_;
bool bulletColor_;
bool bulletSize_;
bool bulletChar_;
bool leftMargin_;
bool indent_;
bool align_;
bool lineSpacing_;
bool spaceBefore_;
bool spaceAfter_;
bool defaultTabSize_;
bool fontAlign_;
bool charWrap_;
bool wordWrap_;
bool overflow_;
bool tabStops_;
bool textDirection_;
bool bulletBlip_;
bool bulletScheme_;
bool bulletHasScheme_;
WORD bulletFlag;
WCHAR bulletChar;
WORD bulletFontRef;
WORD bulletSize;
SColorAtom bulletColor;
WORD textAlignment;
LONG lineSpacing;
LONG spaceBefore;
LONG spaceAfter;
LONG leftMargin;
LONG indent;
LONG defaultTabSize;
CAtlArray<DWORD> tabsStops;
WORD fontAlign;
WORD wrapFlags;
WORD textDirectional;
STextPFRun()
{
bIsExt = TRUE;
lCount = 0;
lIndentLevel = 0;
hasBullet_ = false;
bulletHasFont_ = false;
bulletHasColor_ = false;
bulletHasSize_ = false;
bulletFont_ = false;
bulletColor_ = false;
bulletSize_ = false;
bulletChar_ = false;
leftMargin_ = false;
indent_ = false;
align_ = false;
lineSpacing_ = false;
spaceBefore_ = false;
spaceAfter_ = false;
defaultTabSize_ = false;
fontAlign_ = false;
charWrap_ = false;
wordWrap_ = false;
overflow_ = false;
tabStops_ = false;
textDirection_ = false;
bulletBlip_ = false;
bulletScheme_ = false;
bulletHasScheme_ = false;
bulletFlag = 0;
bulletChar = L'0';
bulletFontRef = 0;
bulletSize = 0;
textAlignment = 0;
lineSpacing = 0;
spaceBefore = 0;
spaceAfter = 0;
leftMargin = 0;
indent = 0;
defaultTabSize = 0;
fontAlign = 0;
wrapFlags = 0;
textDirectional = 0;
}
STextPFRun(const STextPFRun& oSrc)
{
*this = oSrc;
}
STextPFRun& operator =(const STextPFRun& oSrc)
{
bIsExt = oSrc.bIsExt;
lCount = oSrc.lCount;
lIndentLevel = oSrc.lIndentLevel;
hasBullet_ = oSrc.hasBullet_;
bulletHasFont_ = oSrc.bulletHasFont_;
bulletHasColor_ = oSrc.bulletHasColor_;
bulletHasSize_ = oSrc.bulletHasSize_;
bulletFont_ = oSrc.bulletFont_;
bulletColor_ = oSrc.bulletColor_;
bulletSize_ = oSrc.bulletSize_;
bulletChar_ = oSrc.bulletChar_;
leftMargin_ = oSrc.leftMargin_;
indent_ = oSrc.indent_;
align_ = oSrc.align_;
lineSpacing_ = oSrc.lineSpacing_;
spaceBefore_ = oSrc.spaceBefore_;
spaceAfter_ = oSrc.spaceAfter_;
defaultTabSize_ = oSrc.defaultTabSize_;
fontAlign_ = oSrc.fontAlign_;
charWrap_ = oSrc.charWrap_;
wordWrap_ = oSrc.wordWrap_;
overflow_ = oSrc.overflow_;
tabStops_ = oSrc.tabStops_;
textDirection_ = oSrc.textDirection_;
bulletBlip_ = oSrc.bulletBlip_;
bulletScheme_ = oSrc.bulletScheme_;
bulletHasScheme_ = oSrc.bulletHasScheme_;
bulletFlag = oSrc.bulletFlag;
bulletChar = oSrc.bulletChar;
bulletFontRef = oSrc.bulletFontRef;
bulletSize = oSrc.bulletSize;
textAlignment = oSrc.textAlignment;
lineSpacing = oSrc.lineSpacing;
spaceBefore = oSrc.spaceBefore;
spaceAfter = oSrc.spaceAfter;
leftMargin = oSrc.leftMargin;
indent = oSrc.indent;
defaultTabSize = oSrc.defaultTabSize;
fontAlign = oSrc.fontAlign;
wrapFlags = oSrc.wrapFlags;
textDirectional = oSrc.textDirectional;
tabsStops.Copy(oSrc.tabsStops);
return *this;
}
void ApplyBefore(const STextPFRun& oSrc)
{
bool bIsBulletFlag = (hasBullet_ || bulletHasFont_ || bulletHasColor_ || bulletHasSize_);
bool bIsBulletFlagSrc = (oSrc.hasBullet_ || oSrc.bulletHasFont_ || oSrc.bulletHasColor_ || oSrc.bulletHasSize_);
if (!bIsBulletFlag && bIsBulletFlagSrc)
{
hasBullet_ = oSrc.hasBullet_;
bulletHasFont_ = oSrc.bulletHasFont_;
bulletHasColor_ = oSrc.bulletHasColor_;
bulletHasSize_ = oSrc.bulletHasSize_;
bulletFlag = oSrc.bulletFlag;
}
DEFAULT_BEFORE(bulletChar_, bulletChar_)
DEFAULT_BEFORE(bulletFont_, bulletFontRef)
DEFAULT_BEFORE(bulletSize_, bulletSize)
DEFAULT_BEFORE(bulletColor_, bulletColor);
DEFAULT_BEFORE(align_, textAlignment);
DEFAULT_BEFORE(lineSpacing_, lineSpacing);
DEFAULT_BEFORE(spaceBefore_, spaceBefore);
DEFAULT_BEFORE(spaceAfter_, spaceAfter);
DEFAULT_BEFORE(leftMargin_, leftMargin);
DEFAULT_BEFORE(indent_, indent);
DEFAULT_BEFORE(defaultTabSize_, defaultTabSize);
DEFAULT_BEFORE(fontAlign_, fontAlign);
bool bWrap = charWrap_ || wordWrap_ || overflow_;
bool bWrapSrc = oSrc.charWrap_ || oSrc.wordWrap_ || oSrc.overflow_;
if (!bWrap || bWrapSrc)
{
wrapFlags = oSrc.wrapFlags;
}
DEFAULT_BEFORE(textDirection_, textDirectional);
if (!tabStops_ && oSrc.tabStops_)
{
tabsStops.Copy(oSrc.tabsStops);
}
}
void ApplyAfter(const STextPFRun& oSrc)
{
bool bIsBulletFlagSrc = (oSrc.hasBullet_ || oSrc.bulletHasFont_ || oSrc.bulletHasColor_ || oSrc.bulletHasSize_);
if (bIsBulletFlagSrc)
{
hasBullet_ = oSrc.hasBullet_;
bulletHasFont_ = oSrc.bulletHasFont_;
bulletHasColor_ = oSrc.bulletHasColor_;
bulletHasSize_ = oSrc.bulletHasSize_;
bulletFlag = oSrc.bulletFlag;
}
APPLY_AFTER(bulletChar_, bulletChar_)
APPLY_AFTER(bulletFont_, bulletFontRef)
APPLY_AFTER(bulletSize_, bulletSize)
APPLY_AFTER(bulletColor_, bulletColor);
APPLY_AFTER(align_, textAlignment);
APPLY_AFTER(lineSpacing_, lineSpacing);
APPLY_AFTER(spaceBefore_, spaceBefore);
APPLY_AFTER(spaceAfter_, spaceAfter);
APPLY_AFTER(leftMargin_, leftMargin);
APPLY_AFTER(indent_, indent);
APPLY_AFTER(defaultTabSize_, defaultTabSize);
APPLY_AFTER(fontAlign_, fontAlign);
bool bWrapSrc = oSrc.charWrap_ || oSrc.wordWrap_ || oSrc.overflow_;
if (bWrapSrc)
{
wrapFlags = oSrc.wrapFlags;
}
APPLY_AFTER(textDirection_, textDirectional);
if (oSrc.tabStops_)
{
tabsStops.Copy(oSrc.tabsStops);
}
}
void ReadFromStream(IStream* pStream);
CString ToString()
{
XmlUtils::CXmlWriter oWriter;
oWriter.WriteNodeBegin(_T("Paragraph"), TRUE);
oWriter.WriteAttribute(_T("count"), CDirectory::ToString(lCount));
if (bIsExt)
{
oWriter.WriteAttribute(_T("indentlevel"), CDirectory::ToString(lIndentLevel));
}
oWriter.WriteNodeEnd(_T("Paragraph"), TRUE, FALSE);
if ((hasBullet_ || bulletHasFont_ || bulletHasColor_ || bulletHasSize_))
CDirectory::WriteValueToNode(_T("bulletflag"), (DWORD)bulletFlag, &oWriter);
if (bulletChar_)
{
char pData[2] = { '<EFBFBD>', 0 };
CStringW str(pData);
CDirectory::WriteValueToNode(_T("bulletchar"), StreamUtils::ConvertCStringWToCString(str), &oWriter);
}
if (bulletFont_)
CDirectory::WriteValueToNode(_T("bulletfontref"), (DWORD)bulletFontRef, &oWriter);
if (bulletSize_)
CDirectory::WriteValueToNode(_T("bulletsize"), (DWORD)bulletSize, &oWriter);
if (bulletColor_)
{
CDirectory::WriteValueToNode(_T("bulletcolor"), bulletColor.ToValue(), &oWriter);
}
if (align_)
{
CDirectory::WriteValueToNode(_T("textalignment"), (DWORD)textAlignment, &oWriter);
}
if (lineSpacing_)
CDirectory::WriteValueToNode(_T("linespacing"), (LONG)lineSpacing, &oWriter);
if (spaceBefore_)
CDirectory::WriteValueToNode(_T("spacebefore"), (LONG)spaceBefore, &oWriter);
if (spaceAfter_)
CDirectory::WriteValueToNode(_T("spaceafter"), (LONG)spaceAfter, &oWriter);
if (leftMargin_)
CDirectory::WriteValueToNode(_T("leftmargin"), (LONG)leftMargin, &oWriter);
if (indent_)
CDirectory::WriteValueToNode(_T("indent"), (LONG)(indent), &oWriter);
if (defaultTabSize_)
CDirectory::WriteValueToNode(_T("defaulttabsize"), (DWORD)defaultTabSize, &oWriter);
if (fontAlign_)
CDirectory::WriteValueToNode(_T("fontalign"), (DWORD)fontAlign, &oWriter);
if (charWrap_ || wordWrap_ || overflow_)
{
DWORD lIsWord = 1;
if (0x02 == (0x02 & wrapFlags))
{
lIsWord = 0;
}
CDirectory::WriteValueToNode(_T("wrapflags"), lIsWord, &oWriter);
}
if (textDirection_)
CDirectory::WriteValueToNode(_T("textdirectional"), (DWORD)textDirectional, &oWriter);
if (tabStops_)
{
oWriter.WriteNodeBegin(_T("tabstops"));
for (size_t i = 0; i < tabsStops.GetCount(); ++i)
{
CDirectory::WriteValueToNode(_T("tabstop"), tabsStops[i], &oWriter);
}
oWriter.WriteNodeEnd(_T("tabstops"));
}
oWriter.WriteNodeEnd(_T("Paragraph"));
return oWriter.GetXmlString();
}
void ApplyProperties(CElementsContainer* pSlide, CTextAttributesEx* pTextAttributes);
};
struct STextCFRun
{
BOOL bIsExt;
DWORD lCount;
bool hasBold;
bool hasItalic;
bool hasUnderline;
BYTE StrikeOut;
bool hasShadow;
bool hasFehint;
bool hasKimi;
bool hasEmboss;
BYTE hasStyle;
bool hasTypeface;
bool hasSize;
bool hasColor;
bool hasPosition;
bool hasPp10ext;
bool hasOldEATypeface;
bool hasAnsiTypeface;
bool hasSymbolTypeface;
bool hasNewEATypeface;
bool hasCsTypeface;
bool hasPp11ext;
WORD fontStyle;
WORD fontRef;
WORD fontEAFontRef;
WORD ansiFontRef;
WORD symbolFontRef;
WORD fontSize;
SColorAtom oColor;
WORD position;
bool hasBaselineOffset;
double BaselineOffset;
CStringW strFontName;
CString fontPanose;
CString fontPitchFamily;
LONG fontFixed;
CSimpleArray<BYTE> fontCharset;
STextCFRun()
{
bIsExt = TRUE;
lCount = 0;
hasBold = false;
hasItalic = false;
hasUnderline = false;
StrikeOut = 0;
hasShadow = false;
hasFehint = false;
hasKimi = false;
hasEmboss = false;
hasStyle = 0;
hasTypeface = false;
hasSize = false;
hasColor = false;
hasPosition = false;
hasPp10ext = false;
hasOldEATypeface = false;
hasAnsiTypeface = false;
hasSymbolTypeface = false;
hasNewEATypeface = false;
hasCsTypeface = false;
hasPp11ext = false;
fontStyle = 0;
fontRef = 0;
fontEAFontRef = 0;
ansiFontRef = 0;
symbolFontRef = 0;
fontSize = 0;
position = 0;
hasBaselineOffset = false;
BaselineOffset = 0.0;
fontPanose = _T("");
fontPitchFamily = _T("unknown");
fontCharset.RemoveAll();
fontCharset.Add(1);
fontFixed = -1;
}
STextCFRun(const STextCFRun& oSrc)
{
*this = oSrc;
}
STextCFRun& operator =(const STextCFRun& oSrc)
{
bIsExt = oSrc.bIsExt;
lCount = oSrc.lCount;
hasBold = oSrc.hasBold;
hasItalic = oSrc.hasItalic;
hasUnderline = oSrc.hasUnderline;
StrikeOut = oSrc.StrikeOut;
hasShadow = oSrc.hasShadow;
hasFehint = oSrc.hasFehint;
hasKimi = oSrc.hasKimi;
hasEmboss = oSrc.hasEmboss;
hasStyle = oSrc.hasStyle;
hasTypeface = oSrc.hasTypeface;
hasSize = oSrc.hasSize;
hasColor = oSrc.hasColor;
hasPosition = oSrc.hasPosition;
hasPp10ext = oSrc.hasPp10ext;
hasOldEATypeface = oSrc.hasOldEATypeface;
hasAnsiTypeface = oSrc.hasAnsiTypeface;
hasSymbolTypeface = oSrc.hasSymbolTypeface;
hasNewEATypeface = oSrc.hasNewEATypeface;
hasCsTypeface = oSrc.hasCsTypeface;
hasPp11ext = oSrc.hasPp11ext;
fontStyle = oSrc.fontStyle;
fontRef = oSrc.fontRef;
fontEAFontRef = oSrc.fontEAFontRef;
ansiFontRef = oSrc.ansiFontRef;
symbolFontRef = oSrc.symbolFontRef;
fontSize = oSrc.fontSize;
oColor = oSrc.oColor;
position = oSrc.position;
strFontName = oSrc.strFontName;
fontPanose = oSrc.fontPanose;
fontPitchFamily = oSrc.fontPitchFamily;
fontCharset = oSrc.fontCharset;
fontFixed = oSrc.fontFixed;
hasBaselineOffset = oSrc.hasBaselineOffset;
BaselineOffset = oSrc.BaselineOffset;
return *this;
}
void ApplyBefore(const STextCFRun& oSrc)
{
bool bIsFontStylePresent = (hasBold || hasItalic || hasUnderline || hasShadow ||
hasFehint || hasKimi || hasEmboss || hasStyle != 0);
bool bIsFontStylePresentSrc = (oSrc.hasBold || oSrc.hasItalic || oSrc.hasUnderline || oSrc.hasShadow ||
oSrc.hasFehint || oSrc.hasKimi || oSrc.hasEmboss || oSrc.hasStyle != 0);
if (!bIsFontStylePresent && bIsFontStylePresentSrc)
{
hasBold = oSrc.hasBold;
hasItalic = oSrc.hasItalic;
hasUnderline = oSrc.hasUnderline;
hasShadow = oSrc.hasShadow;
fontStyle = oSrc.fontStyle;
}
DEFAULT_BEFORE(hasTypeface, fontRef);
DEFAULT_BEFORE(hasOldEATypeface, fontEAFontRef);
DEFAULT_BEFORE(hasAnsiTypeface, ansiFontRef);
DEFAULT_BEFORE(hasSymbolTypeface, symbolFontRef);
DEFAULT_BEFORE(hasSize, fontSize);
DEFAULT_BEFORE(hasColor, oColor);
DEFAULT_BEFORE(hasPosition, position);
}
void ApplyAfter(const STextCFRun& oSrc)
{
bool bIsFontStylePresentSrc = (oSrc.hasBold || oSrc.hasItalic || oSrc.hasUnderline || oSrc.hasShadow ||
oSrc.hasFehint || oSrc.hasKimi || oSrc.hasEmboss || oSrc.hasStyle != 0);
if (bIsFontStylePresentSrc)
{
hasBold = oSrc.hasBold;
hasItalic = oSrc.hasItalic;
hasUnderline = oSrc.hasUnderline;
hasShadow = oSrc.hasShadow;
fontStyle = oSrc.fontStyle;
}
APPLY_AFTER(hasTypeface, fontRef);
APPLY_AFTER(hasOldEATypeface, fontEAFontRef);
APPLY_AFTER(hasAnsiTypeface, ansiFontRef);
APPLY_AFTER(hasSymbolTypeface, symbolFontRef);
APPLY_AFTER(hasSize, fontSize);
APPLY_AFTER(hasColor, oColor);
APPLY_AFTER(hasPosition, position);
}
void ReadFromStream(IStream* pStream);
CString ToString()
{
XmlUtils::CXmlWriter oWriter;
oWriter.WriteNodeBegin(_T("CFRun"), TRUE);
oWriter.WriteAttribute(_T("count"), CDirectory::ToString(lCount));
oWriter.WriteNodeEnd(_T("CFRun"), TRUE, FALSE);
bool bIsFontStylePresent = ((StrikeOut != 0)|| hasBold || hasItalic || hasUnderline || hasShadow ||
hasFehint || hasKimi || hasEmboss || hasStyle != 0);
if (bIsFontStylePresent)
{
if (hasBold)
{
bool bBold__ = (0x01 == (0x01 & fontStyle));
CDirectory::WriteValueToNode(_T("bold"), bBold__, &oWriter);
}
if (hasItalic)
{
bool bItalic__ = (0x02 == (0x02 & fontStyle));
CDirectory::WriteValueToNode(_T("italic"), bItalic__, &oWriter);
}
if (hasUnderline)
{
bool bUnderline__ = (0x04 == (0x04 & fontStyle));
CDirectory::WriteValueToNode(_T("underline"), bUnderline__, &oWriter);
}
if (hasShadow)
{
bool bShadow__ = (0x10 == (0x10 & fontStyle));
CDirectory::WriteValueToNode(_T("shadow"), bShadow__, &oWriter);
}
if (StrikeOut != 0)
CDirectory::WriteValueToNode(_T("strikeout"), (DWORD)StrikeOut, &oWriter);
}
if (hasTypeface)
{
CDirectory::WriteValueToNode(_T("fontRef"), (DWORD)fontRef, &oWriter);
}
if (hasOldEATypeface)
CDirectory::WriteValueToNode(_T("fontEAFontRef"), (DWORD)fontEAFontRef, &oWriter);
if (hasAnsiTypeface)
CDirectory::WriteValueToNode(_T("ansiFontRef"), (DWORD)ansiFontRef, &oWriter);
if (hasSymbolTypeface)
CDirectory::WriteValueToNode(_T("symbolFontRef"), (DWORD)symbolFontRef, &oWriter);
if (hasSize)
{
CDirectory::WriteValueToNode(_T("fontSize"), (DWORD)fontSize, &oWriter);
}
if (hasColor)
{
oWriter.WriteString(oColor.ToString());
}
if (hasPosition)
CDirectory::WriteValueToNode(_T("baseline-shift"), (LONG)((SHORT)position), &oWriter);
if(hasBaselineOffset)
{
CString str = _T("");
str.Format(_T("%.6f"), BaselineOffset);
CDirectory::WriteValueToNode(_T("baseline-shift"), str, &oWriter);
}
oWriter.WriteNodeBegin(_T("FontProperties"), TRUE);
oWriter.WriteNodeEnd(_T("FontProperties"), TRUE, FALSE);
oWriter.WriteNodeBegin(_T("Name"), TRUE);
oWriter.WriteAttribute(_T("value"), strFontName);
oWriter.WriteNodeEnd(_T("Name"), TRUE);
if (0 < fontCharset.GetSize())
{
oWriter.WriteNodeBegin(_T("Charset"), TRUE);
oWriter.WriteAttribute(_T("value"), CDirectory::ToString(fontCharset[0]));
oWriter.WriteNodeEnd(_T("Charset"), TRUE);
}
if (_T("unknown") != fontPitchFamily)
{
oWriter.WriteNodeBegin(_T("FamilyClass"), TRUE);
oWriter.WriteAttribute(_T("name"), fontPitchFamily);
oWriter.WriteNodeEnd(_T("FamilyClass"), TRUE);
}
oWriter.WriteNodeBegin(_T("Style"), TRUE);
oWriter.WriteAttribute(_T("bold"), CDirectory::ToString(hasBold));
oWriter.WriteAttribute(_T("italic"), CDirectory::ToString(hasItalic));
oWriter.WriteNodeEnd(_T("Style"), TRUE);
if (-1 != fontFixed)
{
oWriter.WriteNodeBegin(_T("FixedWidth"), TRUE);
oWriter.WriteAttribute(_T("value"), CDirectory::ToString(fontFixed));
oWriter.WriteNodeEnd(_T("FixedWidth"), TRUE);
}
if (_T("") != fontPanose)
{
oWriter.WriteNodeBegin(_T("Panose"), TRUE);
oWriter.WriteAttribute(_T("value"), fontPanose);
oWriter.WriteNodeEnd(_T("Panose"), TRUE);
}
oWriter.WriteNodeEnd(_T("FontProperties"));
oWriter.WriteNodeEnd(_T("CFRun"));
return oWriter.GetXmlString();
}
CString ToString2()
{
XmlUtils::CXmlWriter oWriter;
oWriter.WriteNodeBegin(_T("Character"), TRUE);
oWriter.WriteAttribute(_T("count"), CDirectory::ToString(lCount));
oWriter.WriteNodeEnd(_T("Character"), TRUE, FALSE);
oWriter.WriteNodeBegin(_T("Attributes"));
bool bIsFontStylePresent = ((StrikeOut != 0) || hasBold || hasItalic || hasUnderline || hasShadow ||
hasFehint || hasKimi || hasEmboss || hasStyle != 0);
if (strFontName.GetLength() > 0)
{
CDirectory::WriteValueToNode(_T("font-name"), StreamUtils::ConvertCStringWToCString(strFontName), &oWriter);
}
if (bIsFontStylePresent)
{
if (hasBold)
{
bool bBold__ = (0x01 == (0x01 & fontStyle));
CDirectory::WriteValueToNode(_T("font-bold"), bBold__, &oWriter);
}
if (hasItalic)
{
bool bItalic__ = (0x02 == (0x02 & fontStyle));
CDirectory::WriteValueToNode(_T("font-italic"), bItalic__, &oWriter);
}
if (hasUnderline)
{
bool bUnderline__ = (0x04 == (0x04 & fontStyle));
CDirectory::WriteValueToNode(_T("font-underline"), bUnderline__, &oWriter);
}
if (hasShadow)
{
bool bShadow__ = (0x10 == (0x10 & fontStyle));
CDirectory::WriteValueToNode(_T("shadow-visible"), bShadow__, &oWriter);
}
if(StrikeOut != 0)
CDirectory::WriteValueToNode(_T("strikeout"), (DWORD)StrikeOut, &oWriter);
}
if (hasSize)
{
CDirectory::WriteValueToNode(_T("font-size"), (DWORD)fontSize, &oWriter);
}
if (hasColor)
{
CDirectory::WriteValueToNode(_T("brush-color1"), oColor.ToValue(), &oWriter);
}
if (hasPosition)
{
CDirectory::WriteValueToNode(_T("baseline-shift"), (LONG)((SHORT)position), &oWriter);
}
if(hasBaselineOffset)
{
CString str = _T("");
str.Format(_T("%.6f"), BaselineOffset);
CDirectory::WriteValueToNode(_T("baseline-shift"), str, &oWriter);
}
oWriter.WriteNodeEnd(_T("Attributes"));
oWriter.WriteNodeBegin(_T("FontProperties"), TRUE);
oWriter.WriteNodeEnd(_T("FontProperties"), TRUE, FALSE);
oWriter.WriteNodeBegin(_T("Name"), TRUE);
oWriter.WriteAttribute(_T("value"), strFontName);
oWriter.WriteNodeEnd(_T("Name"), TRUE);
if (0 < fontCharset.GetSize())
{
oWriter.WriteNodeBegin(_T("Charset"), TRUE);
oWriter.WriteAttribute(_T("value"), CDirectory::ToString(fontCharset[0]));
oWriter.WriteNodeEnd(_T("Charset"), TRUE);
}
if (_T("unknown") != fontPitchFamily)
{
oWriter.WriteNodeBegin(_T("FamilyClass"), TRUE);
oWriter.WriteAttribute(_T("name"), fontPitchFamily);
oWriter.WriteNodeEnd(_T("FamilyClass"), TRUE);
}
oWriter.WriteNodeBegin(_T("Style"), TRUE);
oWriter.WriteAttribute(_T("bold"), CDirectory::ToString(hasBold));
oWriter.WriteAttribute(_T("italic"), CDirectory::ToString(hasItalic));
oWriter.WriteNodeEnd(_T("Style"), TRUE);
if (-1 != fontFixed)
{
oWriter.WriteNodeBegin(_T("FixedWidth"), TRUE);
oWriter.WriteAttribute(_T("value"), CDirectory::ToString(fontFixed));
oWriter.WriteNodeEnd(_T("FixedWidth"), TRUE);
}
if (_T("") != fontPanose)
{
oWriter.WriteNodeBegin(_T("Panose"), TRUE);
oWriter.WriteAttribute(_T("value"), fontPanose);
oWriter.WriteNodeEnd(_T("Panose"), TRUE);
}
oWriter.WriteNodeEnd(_T("FontProperties"));
oWriter.WriteNodeEnd(_T("Character"));
return oWriter.GetXmlString();
}
void ApplyProperties(CElementsContainer* pSlide, CTextAttributesEx* pTextAttributes);
};
struct STextRuler
{
bool bDefaultTabSize;
bool bCLevels;
bool bTabStops;
bool bLeftMargin1;
bool bLeftMargin2;
bool bLeftMargin3;
bool bLeftMargin4;
bool bLeftMargin5;
bool bIndent1;
bool bIndent2;
bool bIndent3;
bool bIndent4;
bool bIndent5;
SHORT DefaultTabSize;
SHORT CLevels;
SHORT TabStops;
SHORT LeftMargin1;
SHORT LeftMargin2;
SHORT LeftMargin3;
SHORT LeftMargin4;
SHORT LeftMargin5;
SHORT Indent1;
SHORT Indent2;
SHORT Indent3;
SHORT Indent4;
SHORT Indent5;
CAtlArray<DWORD> tabsStops;
STextRuler()
{
bDefaultTabSize = false;
bCLevels = false;
bTabStops = false;
bLeftMargin1 = false;
bLeftMargin2 = false;
bLeftMargin3 = false;
bLeftMargin4 = false;
bLeftMargin5 = false;
bIndent1 = false;
bIndent2 = false;
bIndent3 = false;
bIndent4 = false;
bIndent5 = false;
DefaultTabSize = 0;
CLevels = 0;
TabStops = 0;
LeftMargin1 = 0;
LeftMargin2 = 0;
LeftMargin3 = 0;
LeftMargin4 = 0;
LeftMargin5 = 0;
Indent1 = 0;
Indent2 = 0;
Indent3 = 0;
Indent4 = 0;
Indent5 = 0;
}
STextRuler(const STextRuler& oSrc)
{
*this = oSrc;
}
STextRuler& operator =(const STextRuler& oSrc)
{
bDefaultTabSize = oSrc.bDefaultTabSize;
bCLevels = oSrc.bCLevels;
bTabStops = oSrc.bTabStops;
bLeftMargin1 = oSrc.bLeftMargin1;
bLeftMargin2 = oSrc.bLeftMargin2;
bLeftMargin3 = oSrc.bLeftMargin3;
bLeftMargin4 = oSrc.bLeftMargin4;
bLeftMargin5 = oSrc.bLeftMargin5;
bIndent1 = oSrc.bIndent1;
bIndent2 = oSrc.bIndent2;
bIndent3 = oSrc.bIndent3;
bIndent4 = oSrc.bIndent4;
bIndent5 = oSrc.bIndent5;
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.Copy(oSrc.tabsStops);
return *this;
}
void ApplyBefore(const STextRuler& oSrc)
{
DEFAULT_BEFORE(bDefaultTabSize, DefaultTabSize)
DEFAULT_BEFORE(bCLevels, CLevels)
DEFAULT_BEFORE(bLeftMargin1, LeftMargin1)
DEFAULT_BEFORE(bLeftMargin2, LeftMargin2)
DEFAULT_BEFORE(bLeftMargin3, LeftMargin3)
DEFAULT_BEFORE(bLeftMargin4, LeftMargin4)
DEFAULT_BEFORE(bLeftMargin5, LeftMargin5)
DEFAULT_BEFORE(bIndent1, Indent1)
DEFAULT_BEFORE(bIndent2, Indent2)
DEFAULT_BEFORE(bIndent3, Indent3)
DEFAULT_BEFORE(bIndent4, Indent4)
DEFAULT_BEFORE(bIndent5, Indent5)
if (!bTabStops && oSrc.bTabStops)
{
tabsStops.Copy(oSrc.tabsStops);
}
}
void ReadFromStream(IStream* pStream)
{
DWORD dwFlags = StreamUtils::ReadDWORD(pStream);
BYTE flag1 = (BYTE)(dwFlags);
BYTE flag2 = (BYTE)(dwFlags >> 8);
BYTE flag3 = (BYTE)(dwFlags >> 16);
BYTE flag4 = (BYTE)(dwFlags >> 24);
bDefaultTabSize = (0x01 == (0x01 & flag1));
bCLevels = (0x02 == (0x02 & flag1));
bTabStops = (0x04 == (0x04 & flag1));
bLeftMargin1 = (0x08 == (0x08 & flag1));
bLeftMargin2 = (0x10 == (0x10 & flag1));
bLeftMargin3 = (0x20 == (0x20 & flag1));
bLeftMargin4 = (0x40 == (0x40 & flag1));
bLeftMargin5 = (0x80 == (0x80 & flag1));
bIndent1 = (0x01 == (0x01 & flag2));
bIndent2 = (0x02 == (0x02 & flag2));
bIndent3 = (0x04 == (0x04 & flag2));
bIndent4 = (0x08 == (0x08 & flag2));
bIndent5 = (0x10 == (0x10 & flag2));
if (bCLevels)
{
CLevels = StreamUtils::ReadSHORT(pStream);
}
if (bDefaultTabSize)
{
DefaultTabSize = StreamUtils::ReadSHORT(pStream);
}
if (bTabStops)
{
WORD tabStopsCount = StreamUtils::ReadWORD(pStream);
tabsStops.RemoveAll();
for (int i = 0; i < (int)tabStopsCount; ++i)
{
tabsStops.Add(StreamUtils::ReadDWORD(pStream));
}
}
if (bLeftMargin1)
{
LeftMargin1 = StreamUtils::ReadSHORT(pStream);
}
if (bIndent1)
{
Indent1 = StreamUtils::ReadSHORT(pStream);
}
if (bLeftMargin2)
{
LeftMargin2 = StreamUtils::ReadSHORT(pStream);
}
if (bIndent2)
{
Indent2 = StreamUtils::ReadSHORT(pStream);
}
if (bLeftMargin3)
{
LeftMargin3 = StreamUtils::ReadSHORT(pStream);
}
if (bIndent3)
{
Indent3 = StreamUtils::ReadSHORT(pStream);
}
if (bLeftMargin4)
{
LeftMargin4 = StreamUtils::ReadSHORT(pStream);
}
if (bIndent4)
{
Indent4 = StreamUtils::ReadSHORT(pStream);
}
if (bLeftMargin5)
{
LeftMargin5 = StreamUtils::ReadSHORT(pStream);
}
if (bIndent5)
{
Indent5 = StreamUtils::ReadSHORT(pStream);
}
}
CString ToString()
{
XmlUtils::CXmlWriter oWriter;
oWriter.WriteNodeBegin(_T("TextRuler"));
if (bCLevels)
{
CDirectory::WriteValueToNode(_T("CLevels"), (DWORD)CLevels, &oWriter);
}
if (bDefaultTabSize)
{
CDirectory::WriteValueToNode(_T("DefaultTabSize"), (LONG)DefaultTabSize, &oWriter);
}
if (bLeftMargin1)
{
CDirectory::WriteValueToNode(_T("LeftMargin1"), (LONG)LeftMargin1, &oWriter);
}
if (bIndent1)
{
CDirectory::WriteValueToNode(_T("Indent1"), (LONG)Indent1, &oWriter);
}
if (bLeftMargin2)
{
CDirectory::WriteValueToNode(_T("LeftMargin2"), (LONG)LeftMargin2, &oWriter);
}
if (bIndent2)
{
CDirectory::WriteValueToNode(_T("Indent2"), (LONG)Indent2, &oWriter);
}
if (bLeftMargin3)
{
CDirectory::WriteValueToNode(_T("LeftMargin3"), (LONG)LeftMargin3, &oWriter);
}
if (bIndent3)
{
CDirectory::WriteValueToNode(_T("Indent3"), (LONG)Indent3, &oWriter);
}
if (bLeftMargin4)
{
CDirectory::WriteValueToNode(_T("LeftMargin4"), (LONG)LeftMargin4, &oWriter);
}
if (bIndent4)
{
CDirectory::WriteValueToNode(_T("Indent4"), (LONG)Indent4, &oWriter);
}
if (bLeftMargin5)
{
CDirectory::WriteValueToNode(_T("LeftMargin5"), (LONG)LeftMargin5, &oWriter);
}
if (bIndent5)
{
CDirectory::WriteValueToNode(_T("Indent5"), (LONG)Indent5, &oWriter);
}
if (bTabStops)
{
oWriter.WriteNodeBegin(_T("TabStops"));
for (size_t i = 0; i < tabsStops.GetCount(); ++i)
{
CDirectory::WriteValueToNode(_T("tabStop"), tabsStops[i], &oWriter);
}
oWriter.WriteNodeEnd(_T("TabStops"));
}
oWriter.WriteNodeEnd(_T("TextRuler"));
return oWriter.GetXmlString();
}
void ApplyProperties(CElementsContainer* pSlide, CTextAttributesEx* pTextAttributes);
void CorrectRuler(CTextAttributesEx* pTextAttributes);
};
struct STextSIRun
{
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;
CAtlArray<DWORD> arSmartTags;
STextSIRun()
{
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;
}
STextSIRun(const STextSIRun& oSrc)
{
*this = oSrc;
}
STextSIRun& operator =(const STextSIRun& 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.Copy(oSrc.arSmartTags);
return *this;
}
void ApplyBefore(const STextSIRun& oSrc)
{
DEFAULT_BEFORE(bSpell, Spell);
DEFAULT_BEFORE(bLang, Lang);
DEFAULT_BEFORE(bAltLang, AltLang);
DEFAULT_BEFORE(bBidi, Bidi);
DEFAULT_BEFORE(bPp10ext, pp10runid);
if (!bGramma)
{
bGramma = oSrc.bGramma;
}
}
void ReadFromStream(IStream* pStream);
CString ToString()
{
XmlUtils::CXmlWriter oWriter;
oWriter.WriteNodeBegin(_T("SIRun"));
if (bSpell)
{
CDirectory::WriteValueToNode(_T("Spell"), (DWORD)Spell, &oWriter);
}
if (bLang)
{
CDirectory::WriteValueToNode(_T("Lang"), (DWORD)Lang, &oWriter);
}
if (bAltLang)
{
CDirectory::WriteValueToNode(_T("AltLang"), (DWORD)AltLang, &oWriter);
}
if (bBidi)
{
CDirectory::WriteValueToNode(_T("Bidi"), (DWORD)Bidi, &oWriter);
}
if (bPp10ext)
{
CDirectory::WriteValueToNode(_T("pp10runid"), (DWORD)pp10runid, &oWriter);
CDirectory::WriteValueToNode(_T("bGramma"), bGramma, &oWriter);
}
if (bSmartTag)
{
oWriter.WriteNodeBegin(_T("SmartTags"));
for (size_t i = 0; i < arSmartTags.GetCount(); ++i)
{
CDirectory::WriteValueToNode(_T("tag"), arSmartTags[i], &oWriter);
}
oWriter.WriteNodeEnd(_T("SmartTags"));
}
oWriter.WriteNodeEnd(_T("SIRun"));
return oWriter.GetXmlString();
}
void ApplyProperties(CElementsContainer* pSlide, CTextAttributesEx* pTextAttributes);
};
struct STextMasterStyleLevel
{
BOOL bLevelPresent;
WORD cLevel;
STextPFRun oPFRun;
STextCFRun oCFRun;
STextMasterStyleLevel()
{
bLevelPresent = FALSE;
cLevel = 0;
oPFRun.bIsExt = FALSE;
oCFRun.bIsExt = FALSE;
}
void ReadFromStream(IStream* pStream);
void ApplyProperties(CElementsContainer* CElementsContainer, CTextAttributesEx* pTextAttributes);
CString ToString()
{
XmlUtils::CXmlWriter oWriter;
oWriter.WriteNodeBegin(_T("TextMasterStyleLevel"));
if (bLevelPresent)
{
CDirectory::WriteValueToNode(_T("Level"), (DWORD)cLevel, &oWriter);
}
oWriter.WriteString(oPFRun.ToString());
oWriter.WriteString(oCFRun.ToString());
oWriter.WriteNodeEnd(_T("TextMasterStyleLevel"));
return oWriter.GetXmlString();
}
void ApplyBefore(STextMasterStyleLevel& oLevelBefore)
{
oPFRun.ApplyBefore(oLevelBefore.oPFRun);
oCFRun.ApplyBefore(oLevelBefore.oCFRun);
}
};
class CTextFullInfo
{
public:
STextPFRun m_oPF;
STextCFRun m_oCF;
STextRuler m_oRuler;
STextSIRun 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 CTextMasterStyle
{
public:
DWORD m_nTextType;
public:
WORD m_lLevels;
CAtlArray<STextMasterStyleLevel> m_arrLevels;
public:
void ReadFromStream(IStream* pStream, BOOL bIsLevelsPresent)
{
m_arrLevels.RemoveAll();
m_lLevels = StreamUtils::ReadWORD(pStream);
if (0 < m_lLevels)
{
m_arrLevels.Add();
m_arrLevels[0].bLevelPresent = bIsLevelsPresent;
m_arrLevels[0].ReadFromStream(pStream);
}
if (1 < m_lLevels)
{
m_arrLevels.Add();
m_arrLevels[1].bLevelPresent = bIsLevelsPresent;
m_arrLevels[1].ReadFromStream(pStream);
}
if (2 < m_lLevels)
{
m_arrLevels.Add();
m_arrLevels[2].bLevelPresent = bIsLevelsPresent;
m_arrLevels[2].ReadFromStream(pStream);
}
if (3 < m_lLevels)
{
m_arrLevels.Add();
m_arrLevels[3].bLevelPresent = bIsLevelsPresent;
m_arrLevels[3].ReadFromStream(pStream);
}
if (4 < m_lLevels)
{
m_arrLevels.Add();
m_arrLevels[4].bLevelPresent = bIsLevelsPresent;
m_arrLevels[4].ReadFromStream(pStream);
}
Calculate();
}
virtual CString ToString()
{
CString str = _T("");
for (size_t nIndex = 0; nIndex < m_arrLevels.GetCount(); ++nIndex)
{
str += m_arrLevels[nIndex].ToString();
}
return str;
}
void Calculate()
{
LONG lCount = (LONG)m_arrLevels.GetCount();
for (LONG i = lCount - 1; i > 0; --i)
{
for (LONG j = i - 1; j >= 0; --j)
{
m_arrLevels[i].ApplyBefore(m_arrLevels[j]);
}
}
}
};
class CTextAttributesEx
{
public:
DWORD m_lMasterTextType;
DWORD m_lTextType;
CStringW m_sText;
RECT m_oBounds;
CTextAttributes m_oAttributes;
BOOL m_bVertical;
BOOL m_bRightToLeft;
CAtlArray<STextPFRun> m_arPFs;
CAtlArray<STextCFRun> m_arCFs;
CAtlArray<STextSIRun> m_arSIs;
STextRuler m_oRuler;
LONG m_lWrapMode;
public:
CTextAttributesEx();
CTextAttributesEx(const CTextAttributesEx& oSrc);
CTextAttributesEx& operator =(const CTextAttributesEx& oSrc);
CString ToString(CGeomShapeInfo& oInfo, CMetricInfo& pMetricInfo, double dStartTime, double dEndTime);
public:
void ApplyProperties(CElementsContainer* pContainer);
LONG GetIndentLevelCF(size_t nIndex);
void RecalcParagraphs();
};
Reference in a new issue Copy permalink