2180 lines
60 KiB
C++
2180 lines
60 KiB
C++
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2023
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
#pragma once
|
|
|
|
#include "../CommonInclude.h"
|
|
|
|
#include "ChartStyle.h"
|
|
#include "ChartColors.h"
|
|
|
|
namespace OOX
|
|
{
|
|
namespace Drawing
|
|
{
|
|
class COfficeArtExtensionList;
|
|
}
|
|
namespace Spreadsheet
|
|
{
|
|
enum ST_PageSetupOrientation
|
|
{
|
|
st_pagesetuporientationDEFAULT = 0,
|
|
st_pagesetuporientationPORTRAIT = 1,
|
|
st_pagesetuporientationLANDSCAPE = 2
|
|
};
|
|
enum ST_DispBlanksAs
|
|
{
|
|
st_dispblanksasSPAN = 0,
|
|
st_dispblanksasGAP = 1,
|
|
st_dispblanksasZERO = 2
|
|
};
|
|
enum ST_LegendPos
|
|
{
|
|
st_legendposB = 0,
|
|
st_legendposTR = 1,
|
|
st_legendposL = 2,
|
|
st_legendposR = 3,
|
|
st_legendposT = 4
|
|
};
|
|
enum ST_LayoutTarget
|
|
{
|
|
st_layouttargetINNER = 0,
|
|
st_layouttargetOUTER = 1
|
|
};
|
|
enum ST_LayoutMode
|
|
{
|
|
st_layoutmodeEDGE = 0,
|
|
st_layoutmodeFACTOR = 1
|
|
};
|
|
enum ST_Orientation
|
|
{
|
|
st_orientationMAXMIN = 0,
|
|
st_orientationMINMAX = 1
|
|
};
|
|
enum ST_AxPos
|
|
{
|
|
st_axposB = 0,
|
|
st_axposL = 1,
|
|
st_axposR = 2,
|
|
st_axposT = 3
|
|
};
|
|
enum ST_TickMark
|
|
{
|
|
st_tickmarkCROSS = 0,
|
|
st_tickmarkIN = 1,
|
|
st_tickmarkNONE = 2,
|
|
st_tickmarkOUT = 3
|
|
};
|
|
enum ST_TickLblPos
|
|
{
|
|
st_ticklblposHIGH = 0,
|
|
st_ticklblposLOW = 1,
|
|
st_ticklblposNEXTTO = 2,
|
|
st_ticklblposNONE = 3
|
|
};
|
|
enum ST_Crosses
|
|
{
|
|
st_crossesAUTOZERO = 0,
|
|
st_crossesMAX = 1,
|
|
st_crossesMIN = 2
|
|
};
|
|
enum ST_TimeUnit
|
|
{
|
|
st_timeunitDAYS = 0,
|
|
st_timeunitMONTHS = 1,
|
|
st_timeunitYEARS = 2
|
|
};
|
|
enum ST_LblAlgn
|
|
{
|
|
st_lblalgnCTR = 0,
|
|
st_lblalgnL = 1,
|
|
st_lblalgnR = 2
|
|
};
|
|
enum ST_BuiltInUnit
|
|
{
|
|
st_builtinunitHUNDREDS = 0,
|
|
st_builtinunitTHOUSANDS = 1,
|
|
st_builtinunitTENTHOUSANDS = 2,
|
|
st_builtinunitHUNDREDTHOUSANDS = 3,
|
|
st_builtinunitMILLIONS = 4,
|
|
st_builtinunitTENMILLIONS = 5,
|
|
st_builtinunitHUNDREDMILLIONS = 6,
|
|
st_builtinunitBILLIONS = 7,
|
|
st_builtinunitTRILLIONS = 8
|
|
};
|
|
enum ST_CrossBetween
|
|
{
|
|
st_crossbetweenBETWEEN = 0,
|
|
st_crossbetweenMIDCAT = 1
|
|
};
|
|
enum ST_SizeRepresents
|
|
{
|
|
st_sizerepresentsAREA = 0,
|
|
st_sizerepresentsW = 1
|
|
};
|
|
enum ST_MarkerStyle
|
|
{
|
|
st_markerstyleCIRCLE = 0,
|
|
st_markerstyleDASH = 1,
|
|
st_markerstyleDIAMOND = 2,
|
|
st_markerstyleDOT = 3,
|
|
st_markerstyleNONE = 4,
|
|
st_markerstylePICTURE = 5,
|
|
st_markerstylePLUS = 6,
|
|
st_markerstyleSQUARE = 7,
|
|
st_markerstyleSTAR = 8,
|
|
st_markerstyleTRIANGLE = 9,
|
|
st_markerstyleX = 10,
|
|
st_markerstyleAUTO = 11
|
|
};
|
|
enum ST_PictureFormat
|
|
{
|
|
st_pictureformatSTRETCH = 0,
|
|
st_pictureformatSTACK = 1,
|
|
st_pictureformatSTACKSCALE = 2
|
|
};
|
|
enum ST_DLblPos
|
|
{
|
|
st_dlblposBESTFIT = 0,
|
|
st_dlblposB = 1,
|
|
st_dlblposCTR = 2,
|
|
st_dlblposINBASE = 3,
|
|
st_dlblposINEND = 4,
|
|
st_dlblposL = 5,
|
|
st_dlblposOUTEND = 6,
|
|
st_dlblposR = 7,
|
|
st_dlblposT = 8
|
|
};
|
|
enum ST_TrendlineType
|
|
{
|
|
st_trendlinetypeEXP = 0,
|
|
st_trendlinetypeLINEAR = 1,
|
|
st_trendlinetypeLOG = 2,
|
|
st_trendlinetypeMOVINGAVG = 3,
|
|
st_trendlinetypePOLY = 4,
|
|
st_trendlinetypePOWER = 5
|
|
};
|
|
enum ST_ErrDir
|
|
{
|
|
st_errdirX = 0,
|
|
st_errdirY = 1
|
|
};
|
|
enum ST_ErrBarType
|
|
{
|
|
st_errbartypeBOTH = 0,
|
|
st_errbartypeMINUS = 1,
|
|
st_errbartypePLUS = 2
|
|
};
|
|
enum ST_ErrValType
|
|
{
|
|
st_errvaltypeCUST = 0,
|
|
st_errvaltypeFIXEDVAL = 1,
|
|
st_errvaltypePERCENTAGE = 2,
|
|
st_errvaltypeSTDDEV = 3,
|
|
st_errvaltypeSTDERR = 4
|
|
};
|
|
enum ST_SplitType
|
|
{
|
|
st_splittypeAUTO = 0,
|
|
st_splittypeCUST = 1,
|
|
st_splittypePERCENT = 2,
|
|
st_splittypePOS = 3,
|
|
st_splittypeVAL = 4
|
|
};
|
|
enum ST_OfPieType
|
|
{
|
|
st_ofpietypePIE = 0,
|
|
st_ofpietypeBAR = 1
|
|
};
|
|
enum ST_BarDir
|
|
{
|
|
st_bardirBAR = 0,
|
|
st_bardirCOL = 1
|
|
};
|
|
enum ST_BarGrouping
|
|
{
|
|
st_bargroupingPERCENTSTACKED = 0,
|
|
st_bargroupingCLUSTERED = 1,
|
|
st_bargroupingSTANDARD = 2,
|
|
st_bargroupingSTACKED = 3
|
|
};
|
|
enum ST_Shape
|
|
{
|
|
st_shapeCONE = 0,
|
|
st_shapeCONETOMAX = 1,
|
|
st_shapeBOX = 2,
|
|
st_shapeCYLINDER = 3,
|
|
st_shapePYRAMID = 4,
|
|
st_shapePYRAMIDTOMAX = 5
|
|
};
|
|
enum ST_ScatterStyle
|
|
{
|
|
st_scatterstyleNONE = 0,
|
|
st_scatterstyleLINE = 1,
|
|
st_scatterstyleLINEMARKER = 2,
|
|
st_scatterstyleMARKER = 3,
|
|
st_scatterstyleSMOOTH = 4,
|
|
st_scatterstyleSMOOTHMARKER = 5
|
|
};
|
|
enum ST_RadarStyle
|
|
{
|
|
st_radarstyleSTANDARD = 0,
|
|
st_radarstyleMARKER = 1,
|
|
st_radarstyleFILLED = 2
|
|
};
|
|
enum ST_Grouping
|
|
{
|
|
st_groupingPERCENTSTACKED = 0,
|
|
st_groupingSTANDARD = 1,
|
|
st_groupingSTACKED = 2
|
|
};
|
|
bool ToXml_ST_DispBlanksAs(ST_DispBlanksAs val, std::wstring& sOut);
|
|
bool FromXml_ST_DispBlanksAs(const std::wstring& val, ST_DispBlanksAs& eOut);
|
|
|
|
DEFINE_SIMPLE_TYPE(CGrouping, ST_Grouping, st_groupingSTANDARD)
|
|
DEFINE_SIMPLE_TYPE(CRadarStyle, ST_RadarStyle, st_radarstyleSTANDARD)
|
|
DEFINE_SIMPLE_TYPE(CScatterStyle, ST_ScatterStyle, st_scatterstyleMARKER)
|
|
DEFINE_SIMPLE_TYPE(CShapeType, ST_Shape, st_shapeBOX)
|
|
DEFINE_SIMPLE_TYPE(CBarGrouping, ST_BarGrouping, st_bargroupingCLUSTERED)
|
|
DEFINE_SIMPLE_TYPE(CBarDir, ST_BarDir, st_bardirBAR)
|
|
DEFINE_SIMPLE_TYPE(COfPieType, ST_OfPieType, st_ofpietypePIE)
|
|
DEFINE_SIMPLE_TYPE(CSplitType, ST_SplitType, st_splittypeAUTO)
|
|
DEFINE_SIMPLE_TYPE(CErrValType, ST_ErrValType, st_errvaltypeSTDERR)
|
|
DEFINE_SIMPLE_TYPE(CErrBarType, ST_ErrBarType, st_errbartypeBOTH)
|
|
DEFINE_SIMPLE_TYPE(CErrDir, ST_ErrDir, st_errdirX)
|
|
DEFINE_SIMPLE_TYPE(CTrendlineType, ST_TrendlineType, st_trendlinetypeLINEAR)
|
|
DEFINE_SIMPLE_TYPE(CDLblPos, ST_DLblPos, st_dlblposBESTFIT)
|
|
DEFINE_SIMPLE_TYPE(CPictureFormat, ST_PictureFormat, st_pictureformatSTRETCH)
|
|
DEFINE_SIMPLE_TYPE(CMarkerStyle, ST_MarkerStyle, st_markerstyleAUTO)
|
|
DEFINE_SIMPLE_TYPE(CSizeRepresents, ST_SizeRepresents, st_sizerepresentsAREA)
|
|
DEFINE_SIMPLE_TYPE(CCrossBetween, ST_CrossBetween, st_crossbetweenBETWEEN)
|
|
DEFINE_SIMPLE_TYPE(CBuiltInUnit, ST_BuiltInUnit, st_builtinunitHUNDREDS)
|
|
DEFINE_SIMPLE_TYPE(CLblAlgn, ST_LblAlgn, st_lblalgnCTR)
|
|
DEFINE_SIMPLE_TYPE(CTimeUnit, ST_TimeUnit, st_timeunitYEARS)
|
|
DEFINE_SIMPLE_TYPE(CCrosses, ST_Crosses, st_crossesAUTOZERO)
|
|
DEFINE_SIMPLE_TYPE(CTickLblPos, ST_TickLblPos, st_ticklblposNEXTTO)
|
|
DEFINE_SIMPLE_TYPE(CTickMark, ST_TickMark, st_tickmarkCROSS)
|
|
DEFINE_SIMPLE_TYPE(CAxPos, ST_AxPos, st_axposB)
|
|
DEFINE_SIMPLE_TYPE(COrientation, ST_Orientation, st_orientationMINMAX)
|
|
DEFINE_SIMPLE_TYPE(CLayoutMode, ST_LayoutMode, st_layoutmodeEDGE)
|
|
DEFINE_SIMPLE_TYPE(CLayoutTarget, ST_LayoutTarget, st_layouttargetINNER)
|
|
DEFINE_SIMPLE_TYPE(CLegendPos, ST_LegendPos, st_legendposR)
|
|
DEFINE_SIMPLE_TYPE(CDispBlanksAs, ST_DispBlanksAs, st_dispblanksasZERO)
|
|
DEFINE_SIMPLE_TYPE(CPageSetupOrientation, ST_PageSetupOrientation, st_pagesetuporientationDEFAULT)
|
|
//----------------------------
|
|
template<class T>
|
|
class nullableComplexVal : public nullable<T>
|
|
{
|
|
public:
|
|
nullableComplexVal() : nullable<T>()
|
|
{
|
|
}
|
|
nullableComplexVal(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
if (oReader.IsValid())
|
|
{
|
|
T* pType = new T();
|
|
|
|
WritingElement_ReadAttributes_Start_No_NS(oReader)
|
|
WritingElement_ReadAttributes_ReadSingle(oReader, L"val", *pType)
|
|
WritingElement_ReadAttributes_End_No_NS(oReader)
|
|
|
|
if (!oReader.IsEmptyNode())
|
|
oReader.ReadTillEnd();
|
|
|
|
this->m_pPointer = pType;
|
|
}
|
|
else
|
|
this->m_pPointer = NULL;
|
|
}
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
|
|
{
|
|
if (this->m_pPointer)
|
|
{
|
|
writer.WriteString(L"<" + sNodeName + L" val=\"" + this->m_pPointer->ToString() + L"\"/>");
|
|
}
|
|
}
|
|
};
|
|
class nullableBoolVal : public nullable_bool
|
|
{
|
|
public:
|
|
nullableBoolVal() : nullable_bool()
|
|
{
|
|
}
|
|
void operator=(const bool& value)
|
|
{
|
|
nullable_bool::operator=(value);
|
|
}
|
|
nullableBoolVal(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
if (oReader.IsValid())
|
|
{
|
|
WritingElement_ReadAttributes_Start_No_NS(oReader)
|
|
if (L"val" == wsName)
|
|
{
|
|
this->m_pPointer = new bool(XmlUtils::GetBoolean2(oReader.GetText()));
|
|
break;
|
|
}
|
|
WritingElement_ReadAttributes_End_No_NS(oReader)
|
|
|
|
if (!oReader.IsEmptyNode())
|
|
oReader.ReadTillEnd();
|
|
}
|
|
else
|
|
this->m_pPointer = NULL;
|
|
}
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
|
|
{
|
|
if (this->m_pPointer)
|
|
{
|
|
writer.WriteString(L"<" + sNodeName + L" val=\"" + (*this->m_pPointer ? L"1" : L"0") + L"\"/>");
|
|
}
|
|
}
|
|
};
|
|
class nullableIntVal : public nullable_int
|
|
{
|
|
public:
|
|
nullableIntVal() : nullable_int()
|
|
{
|
|
}
|
|
void operator=(const int& value)
|
|
{
|
|
nullable_int::operator=(value);
|
|
}
|
|
nullableIntVal(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
if (oReader.IsValid())
|
|
{
|
|
WritingElement_ReadAttributes_Start_No_NS(oReader)
|
|
if (L"val" == wsName)
|
|
{
|
|
this->m_pPointer = new int(XmlUtils::GetInteger(oReader.GetText()));
|
|
break;
|
|
}
|
|
WritingElement_ReadAttributes_End_No_NS(oReader)
|
|
|
|
if (!oReader.IsEmptyNode())
|
|
oReader.ReadTillEnd();
|
|
}
|
|
else
|
|
this->m_pPointer = NULL;
|
|
}
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
|
|
{
|
|
if (this->m_pPointer)
|
|
{
|
|
writer.WriteString(L"<" + sNodeName + L" val=\"" + std::to_wstring(*this->m_pPointer) + L"\"/>");
|
|
}
|
|
}
|
|
};
|
|
class nullableUintVal : public nullable_uint
|
|
{
|
|
public:
|
|
nullableUintVal() : nullable_uint()
|
|
{
|
|
}
|
|
void operator=(const unsigned int& value)
|
|
{
|
|
nullable_uint::operator=(value);
|
|
}
|
|
nullableUintVal(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
if (oReader.IsValid())
|
|
{
|
|
WritingElement_ReadAttributes_Start_No_NS(oReader)
|
|
if (L"val" == wsName)
|
|
{
|
|
this->m_pPointer = new unsigned int(XmlUtils::GetUInteger(oReader.GetText()));
|
|
break;
|
|
}
|
|
WritingElement_ReadAttributes_End_No_NS(oReader)
|
|
|
|
if (!oReader.IsEmptyNode())
|
|
oReader.ReadTillEnd();
|
|
}
|
|
else
|
|
this->m_pPointer = NULL;
|
|
}
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
|
|
{
|
|
if (this->m_pPointer)
|
|
{
|
|
writer.WriteString(L"<" + sNodeName + L" val=\"" + std::to_wstring(*this->m_pPointer) + L"\"/>");
|
|
}
|
|
}
|
|
};
|
|
class nullableDoubleVal : public nullable_double
|
|
{
|
|
public:
|
|
nullableDoubleVal() : nullable_double()
|
|
{
|
|
}
|
|
void operator=(const double& value)
|
|
{
|
|
nullable_double::operator=(value);
|
|
}
|
|
nullableDoubleVal(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
if (oReader.IsValid())
|
|
{
|
|
WritingElement_ReadAttributes_Start_No_NS(oReader)
|
|
if (L"val" == wsName)
|
|
{
|
|
this->m_pPointer = new double(XmlUtils::GetDouble(oReader.GetText()));
|
|
break;
|
|
}
|
|
WritingElement_ReadAttributes_End_No_NS(oReader)
|
|
|
|
if (!oReader.IsEmptyNode())
|
|
oReader.ReadTillEnd();
|
|
}
|
|
else
|
|
this->m_pPointer = NULL;
|
|
}
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
|
|
{
|
|
if (this->m_pPointer)
|
|
{
|
|
writer.WriteString(L"<" + sNodeName + L" val=\"" + std::to_wstring(*this->m_pPointer) + L"\"/>");
|
|
}
|
|
}
|
|
};
|
|
class nullableStringVal : public nullable_string
|
|
{
|
|
public:
|
|
nullableStringVal() : nullable_string()
|
|
{
|
|
}
|
|
void operator=(const std::wstring& value)
|
|
{
|
|
nullable_string::operator=(value);
|
|
}
|
|
nullableStringVal(XmlUtils::CXmlLiteReader& oReader)
|
|
{
|
|
if (oReader.IsValid())
|
|
{
|
|
std::wstring* pType = new std::wstring();
|
|
|
|
WritingElement_ReadAttributes_Start_No_NS(oReader)
|
|
WritingElement_ReadAttributes_ReadSingle(oReader, L"val", *pType)
|
|
WritingElement_ReadAttributes_End_No_NS(oReader)
|
|
|
|
if (!oReader.IsEmptyNode())
|
|
oReader.ReadTillEnd();
|
|
|
|
this->m_pPointer = pType;
|
|
}
|
|
else
|
|
this->m_pPointer = NULL;
|
|
}
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
|
|
{
|
|
if (this->m_pPointer)
|
|
{
|
|
writer.WriteString(L"<" + sNodeName + L" val=\"" + XmlUtils::EncodeXmlString(*this->m_pPointer) + L"\"/>");
|
|
}
|
|
}
|
|
};
|
|
//----------------------------
|
|
enum ItemsChoiceType3
|
|
{
|
|
itemschoicetype3DLBLPOS = 0,
|
|
itemschoicetype3DELETE = 1,
|
|
itemschoicetype3LEADERLINES = 2,
|
|
itemschoicetype3NUMFMT = 3,
|
|
itemschoicetype3SEPARATOR = 4,
|
|
itemschoicetype3SHOWBUBBLESIZE = 5,
|
|
itemschoicetype3SHOWCATNAME = 6,
|
|
itemschoicetype3SHOWLEADERLINES = 7,
|
|
itemschoicetype3SHOWLEGENDKEY = 8,
|
|
itemschoicetype3SHOWPERCENT = 9,
|
|
itemschoicetype3SHOWSERNAME = 10,
|
|
itemschoicetype3SHOWVAL = 11,
|
|
itemschoicetype3SPPR = 12,
|
|
itemschoicetype3TXPR = 13
|
|
};
|
|
enum ItemsChoiceType4
|
|
{
|
|
itemschoicetype4DLBLPOS = 0,
|
|
itemschoicetype4DELETE = 1,
|
|
itemschoicetype4LAYOUT = 2,
|
|
itemschoicetype4NUMFMT = 3,
|
|
itemschoicetype4SEPARATOR = 4,
|
|
itemschoicetype4SHOWBUBBLESIZE = 5,
|
|
itemschoicetype4SHOWCATNAME = 6,
|
|
itemschoicetype4SHOWLEGENDKEY = 7,
|
|
itemschoicetype4SHOWPERCENT = 8,
|
|
itemschoicetype4SHOWSERNAME = 9,
|
|
itemschoicetype4SHOWVAL = 10,
|
|
itemschoicetype4SPPR = 11,
|
|
itemschoicetype4TX = 12,
|
|
itemschoicetype4TXPR = 13
|
|
};
|
|
enum ItemsChoiceType5 // -> to BaseChart
|
|
{
|
|
itemschoicetype5AREA3DCHART = 0,
|
|
itemschoicetype5AREACHART = 1,
|
|
itemschoicetype5BAR3DCHART = 2,
|
|
itemschoicetype5BARCHART = 3,
|
|
itemschoicetype5BUBBLECHART = 4,
|
|
itemschoicetype5DOUGHNUTCHART = 5,
|
|
itemschoicetype5LINE3DCHART = 6,
|
|
itemschoicetype5LINECHART = 7,
|
|
itemschoicetype5OFPIECHART = 8,
|
|
itemschoicetype5PIE3DCHART = 9,
|
|
itemschoicetype5PIECHART = 10,
|
|
itemschoicetype5RADARCHART = 11,
|
|
itemschoicetype5SCATTERCHART = 12,
|
|
itemschoicetype5STOCKCHART = 13,
|
|
itemschoicetype5SURFACE3DCHART = 14,
|
|
itemschoicetype5SURFACECHART = 15
|
|
};
|
|
enum ItemsChoiceType6
|
|
{
|
|
itemschoicetype6CATAX = 0,
|
|
itemschoicetype6DATEAX = 1,
|
|
itemschoicetype6SERAX = 2,
|
|
itemschoicetype6VALAX = 3
|
|
};
|
|
//---------------------------------------------------------------------------------------------------
|
|
class CT_Style
|
|
{
|
|
public:
|
|
std::wstring m_namespace;
|
|
nullable_uint m_val;
|
|
|
|
CT_Style();
|
|
~CT_Style();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private:
|
|
void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
|
|
};
|
|
class AlternateContentChoice
|
|
{
|
|
public:
|
|
CT_Style* m_style;
|
|
nullable_string m_Requires;
|
|
|
|
AlternateContentChoice();
|
|
~AlternateContentChoice();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private:
|
|
void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
|
|
};
|
|
class AlternateContentFallback
|
|
{
|
|
public:
|
|
CT_Style* m_style;
|
|
|
|
AlternateContentFallback();
|
|
~AlternateContentFallback();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class AlternateContent
|
|
{
|
|
public:
|
|
std::vector<AlternateContentChoice*> m_Choice;
|
|
AlternateContentFallback* m_Fallback;
|
|
|
|
AlternateContent();
|
|
~AlternateContent();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
|
|
class CT_RelId
|
|
{
|
|
public:
|
|
nullable_string m_id;
|
|
|
|
CT_RelId();
|
|
~CT_RelId();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private:
|
|
void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
|
|
};
|
|
|
|
class CT_PageSetup
|
|
{
|
|
public:
|
|
nullable_uint m_paperSize;
|
|
nullable_string m_paperHeight;
|
|
nullable_string m_paperWidth;
|
|
nullable_uint m_firstPageNumber;
|
|
nullable<CPageSetupOrientation> m_orientation;
|
|
nullable_bool m_blackAndWhite;
|
|
nullable_bool m_draft;
|
|
nullable_bool m_useFirstPageNumber;
|
|
nullable_uint m_horizontalDpi; // -?
|
|
nullable_uint m_verticalDpi;
|
|
nullable_uint m_copies;
|
|
|
|
CT_PageSetup();
|
|
~CT_PageSetup();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private:
|
|
void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
|
|
};
|
|
class CT_PageMargins
|
|
{
|
|
public:
|
|
nullable_double m_l;
|
|
nullable_double m_r;
|
|
nullable_double m_t;
|
|
nullable_double m_b;
|
|
nullable_double m_header;
|
|
nullable_double m_footer;
|
|
|
|
CT_PageMargins();
|
|
~CT_PageMargins();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private: void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
|
|
};
|
|
class CT_HeaderFooter
|
|
{
|
|
public:
|
|
nullable_string m_oddHeader;
|
|
nullable_string m_oddFooter;
|
|
nullable_string m_evenHeader;
|
|
nullable_string m_evenFooter;
|
|
nullable_string m_firstHeader;
|
|
nullable_string m_firstFooter;
|
|
|
|
nullable_bool m_alignWithMargins;
|
|
nullable_bool m_differentOddEven;
|
|
nullable_bool m_differentFirst;
|
|
|
|
CT_HeaderFooter();
|
|
~CT_HeaderFooter();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private:
|
|
void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
|
|
};
|
|
class CT_PrintSettings
|
|
{
|
|
public:
|
|
CT_HeaderFooter* m_headerFooter;
|
|
CT_PageMargins* m_pageMargins;
|
|
CT_PageSetup* m_pageSetup;
|
|
|
|
CT_PrintSettings();
|
|
~CT_PrintSettings();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_ExternalData
|
|
{
|
|
public:
|
|
nullableBoolVal m_autoUpdate;
|
|
nullable_string m_id;
|
|
|
|
CT_ExternalData();
|
|
~CT_ExternalData();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private: void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
|
|
};
|
|
class CT_LegendEntry
|
|
{
|
|
public:
|
|
nullableUintVal m_idx;
|
|
nullableBoolVal m_delete;
|
|
nullable<PPTX::Logic::TxBody> m_txPr;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_LegendEntry();
|
|
~CT_LegendEntry();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_ManualLayout
|
|
{
|
|
public:
|
|
nullableComplexVal<CLayoutTarget> m_layoutTarget;
|
|
nullableComplexVal<CLayoutMode> m_xMode;
|
|
nullableComplexVal<CLayoutMode> m_yMode;
|
|
nullableComplexVal<CLayoutMode> m_wMode;
|
|
nullableComplexVal<CLayoutMode> m_hMode;
|
|
nullableDoubleVal m_x;
|
|
nullableDoubleVal m_y;
|
|
nullableDoubleVal m_w;
|
|
nullableDoubleVal m_h;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_ManualLayout();
|
|
~CT_ManualLayout();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Layout
|
|
{
|
|
public:
|
|
CT_ManualLayout* m_manualLayout;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Layout();
|
|
~CT_Layout();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Legend
|
|
{
|
|
public:
|
|
nullableComplexVal<CLegendPos> m_legendPos;
|
|
std::vector<CT_LegendEntry*> m_legendEntry;
|
|
CT_Layout *m_layout;
|
|
nullableBoolVal m_overlay;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullable<PPTX::Logic::TxBody> m_txPr;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
/*--------------------------------------------------*/
|
|
CT_Legend();
|
|
~CT_Legend();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
|
|
class CT_DTable
|
|
{
|
|
public:
|
|
nullableBoolVal m_showHorzBorder;
|
|
nullableBoolVal m_showVertBorder;
|
|
nullableBoolVal m_showOutline;
|
|
nullableBoolVal m_showKeys;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullable<PPTX::Logic::TxBody> m_txPr;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_DTable();
|
|
~CT_DTable();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Scaling
|
|
{
|
|
public:
|
|
nullableDoubleVal m_logBase;
|
|
nullableComplexVal<COrientation> m_orientation;
|
|
nullableDoubleVal m_max;
|
|
nullableDoubleVal m_min;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Scaling();
|
|
~CT_Scaling();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_ChartLines
|
|
{
|
|
public:
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
/*--------------------------------------------------------------*/
|
|
CT_ChartLines();
|
|
~CT_ChartLines();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_StrVal
|
|
{
|
|
public:
|
|
nullable_string m_v;
|
|
nullable_uint m_idx;
|
|
|
|
CT_StrVal();
|
|
~CT_StrVal();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private:
|
|
void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
|
|
};
|
|
class CT_StrData : public WritingElement
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_StrData)
|
|
|
|
nullableUintVal m_ptCount;
|
|
std::vector<CT_StrVal*> m_pt;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_StrData();
|
|
~CT_StrData();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
virtual std::wstring toXML() const;
|
|
void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_StrRef
|
|
{
|
|
public:
|
|
nullable_string m_f;
|
|
CT_StrData * m_strCache;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_StrRef();
|
|
~CT_StrRef();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Tx : public WritingElement
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_Tx)
|
|
|
|
nullable<PPTX::Logic::TxBody> m_oRich;
|
|
CT_StrRef *m_strRef;
|
|
|
|
CT_Tx();
|
|
virtual ~CT_Tx();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
virtual std::wstring toXML() const;
|
|
void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Title
|
|
{
|
|
public:
|
|
CT_Tx *m_tx;
|
|
CT_Layout *m_layout;
|
|
nullableBoolVal m_overlay;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullable<PPTX::Logic::TxBody> m_txPr;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Title();
|
|
~CT_Title();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_NumFmt
|
|
{
|
|
public:
|
|
nullable_string m_formatCode;
|
|
nullable_bool m_sourceLinked;
|
|
|
|
CT_NumFmt();
|
|
~CT_NumFmt();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private:
|
|
void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
|
|
};
|
|
|
|
class CBaseAx
|
|
{
|
|
public:
|
|
CBaseAx();
|
|
virtual ~CBaseAx();
|
|
|
|
bool fromXML(const std::wstring & nodeName, XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
|
|
nullableIntVal m_axId;
|
|
CT_Scaling *m_scaling;
|
|
nullableBoolVal m_delete;
|
|
nullableComplexVal<CAxPos> m_axPos;
|
|
CT_ChartLines *m_majorGridlines;
|
|
CT_ChartLines *m_minorGridlines;
|
|
CT_Title *m_title;
|
|
CT_NumFmt *m_numFmt;
|
|
nullableComplexVal<CTickMark> m_majorTickMark;
|
|
nullableComplexVal<CTickMark> m_minorTickMark;
|
|
nullableComplexVal<CTickLblPos> m_tickLblPos;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullable<PPTX::Logic::TxBody> m_txPr;
|
|
nullableIntVal m_crossAx;
|
|
nullableComplexVal<CCrosses> m_crosses;
|
|
nullableDoubleVal m_crossesAt;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
};
|
|
class CT_SerAx : public CBaseAx
|
|
{
|
|
public:
|
|
nullableUintVal m_tickLblSkip;
|
|
nullableUintVal m_tickMarkSkip;
|
|
|
|
CT_SerAx();
|
|
virtual ~CT_SerAx();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_DateAx : public CBaseAx
|
|
{
|
|
public:
|
|
nullableBoolVal m_auto;
|
|
nullableStringVal m_lblOffset;
|
|
nullableComplexVal<CTimeUnit> m_baseTimeUnit;
|
|
nullableDoubleVal m_majorUnit;
|
|
nullableComplexVal<CTimeUnit> m_majorTimeUnit;
|
|
nullableDoubleVal m_minorUnit;
|
|
nullableComplexVal<CTimeUnit> m_minorTimeUnit;
|
|
|
|
CT_DateAx();
|
|
virtual ~CT_DateAx();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
|
|
class CT_CatAx : public CBaseAx
|
|
{
|
|
public:
|
|
nullableBoolVal m_auto;
|
|
nullableComplexVal<CLblAlgn> m_lblAlgn;
|
|
nullableStringVal m_lblOffset;
|
|
nullableUintVal m_tickLblSkip;
|
|
nullableUintVal m_tickMarkSkip;
|
|
nullableBoolVal m_noMultiLvlLbl;
|
|
|
|
CT_CatAx();
|
|
virtual ~CT_CatAx();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_DispUnitsLbl
|
|
{
|
|
public:
|
|
CT_Layout* m_layout;
|
|
CT_Tx* m_tx;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullable<PPTX::Logic::TxBody> m_txPr;
|
|
|
|
CT_DispUnitsLbl();
|
|
~CT_DispUnitsLbl();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_DispUnits
|
|
{
|
|
public:
|
|
nullableComplexVal<CBuiltInUnit> m_builtInUnit;
|
|
nullableDoubleVal m_custUnit;
|
|
CT_DispUnitsLbl* m_dispUnitsLbl;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_DispUnits();
|
|
~CT_DispUnits();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_ValAx : public CBaseAx
|
|
{
|
|
public:
|
|
nullableComplexVal<CCrossBetween> m_crossBetween;
|
|
nullableDoubleVal m_majorUnit;
|
|
nullableDoubleVal m_minorUnit;
|
|
CT_DispUnits* m_dispUnits;
|
|
|
|
CT_ValAx();
|
|
virtual ~CT_ValAx();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_SerTx
|
|
{
|
|
public:
|
|
CT_StrRef* m_strRef;
|
|
nullable_string m_v;
|
|
|
|
CT_SerTx();
|
|
~CT_SerTx();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_DLbl : public WritingElement
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_DLbl)
|
|
|
|
nullableUintVal m_idx;
|
|
std::vector<ItemsChoiceType4*> m_ItemsElementName0;
|
|
std::vector<void*> m_Items;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
//ext
|
|
nullableBoolVal m_xForSave;
|
|
nullableBoolVal m_showDataLabelsRange;
|
|
//CT_DlblFieldTable* m_dlblFieldTable
|
|
|
|
nullableBoolVal m_showLeaderLines; //for CT_DLbls
|
|
CT_ChartLines* m_leaderLines; //for CT_DLbls
|
|
|
|
CT_DLbl();
|
|
~CT_DLbl();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
virtual std::wstring toXML() const;
|
|
void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
void toXMLEntry(const std::wstring& sNodeNS, NSStringUtils::CStringBuilder& writer) const;
|
|
|
|
EElementType getType();
|
|
private:
|
|
void toXML(NSStringUtils::CStringBuilder& writer, bool bIsAttribute, ItemsChoiceType4 eType, void* pVal, const std::wstring & nodeNS) const;
|
|
void toDelete(ItemsChoiceType4 eType, void* pVal);
|
|
};
|
|
class CT_DLbls
|
|
{
|
|
public:
|
|
std::vector<CT_DLbl*> m_dLbl;
|
|
std::vector<ItemsChoiceType3*> m_ItemsElementName0;
|
|
std::vector<void*> m_Items;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_DLbls();
|
|
~CT_DLbls();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private:
|
|
void toXML(NSStringUtils::CStringBuilder& writer, bool bIsAttribute, ItemsChoiceType3 eType, void* pVal) const;
|
|
void toDelete(ItemsChoiceType3 eType, void* pVal);
|
|
};
|
|
class CT_lvl
|
|
{
|
|
public:
|
|
std::vector<CT_StrVal*> m_pt;
|
|
|
|
CT_lvl();
|
|
~CT_lvl();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_MultiLvlStrData
|
|
{
|
|
public:
|
|
nullableUintVal m_ptCount;
|
|
std::vector<CT_lvl*> m_lvl;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_MultiLvlStrData();
|
|
~CT_MultiLvlStrData();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_MultiLvlStrRef
|
|
{
|
|
public:
|
|
nullable_string m_f;
|
|
CT_MultiLvlStrData* m_multiLvlStrCache;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_MultiLvlStrRef();
|
|
~CT_MultiLvlStrRef();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_NumVal
|
|
{
|
|
public:
|
|
nullable_string m_v;
|
|
nullable_uint m_idx;
|
|
nullable_string m_formatCode;
|
|
|
|
CT_NumVal();
|
|
~CT_NumVal();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private: void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
|
|
};
|
|
class CT_NumData
|
|
{
|
|
public:
|
|
nullable_string m_formatCode;
|
|
nullableUintVal m_ptCount;
|
|
std::vector<CT_NumVal*> m_pt;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_NumData();
|
|
~CT_NumData();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_NumRef
|
|
{
|
|
public:
|
|
nullable_string m_f;
|
|
CT_NumData* m_numCache;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_NumRef();
|
|
~CT_NumRef();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_NumDataSource
|
|
{
|
|
public:
|
|
CT_NumData* m_numLit;
|
|
CT_NumRef* m_numRef;
|
|
|
|
CT_NumDataSource();
|
|
~CT_NumDataSource();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_AxDataSource : public WritingElement
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_AxDataSource)
|
|
|
|
CT_MultiLvlStrRef* m_multiLvlStrRef;
|
|
CT_NumData* m_numLit;
|
|
CT_NumRef* m_numRef;
|
|
CT_StrData* m_strLit;
|
|
CT_StrRef* m_strRef;
|
|
|
|
CT_AxDataSource();
|
|
virtual ~CT_AxDataSource();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
virtual std::wstring toXML() const;
|
|
void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Marker : public WritingElement
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_Marker)
|
|
|
|
nullableComplexVal<CMarkerStyle> m_symbol;
|
|
nullableUintVal m_size;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Marker();
|
|
~CT_Marker();
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
virtual std::wstring toXML() const;
|
|
void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_PictureOptions
|
|
{
|
|
public:
|
|
nullableBoolVal m_applyToFront;
|
|
nullableBoolVal m_applyToSides;
|
|
nullableBoolVal m_applyToEnd;
|
|
nullableComplexVal<CPictureFormat> m_pictureFormat;
|
|
nullableDoubleVal m_pictureStackUnit;
|
|
|
|
CT_PictureOptions();
|
|
~CT_PictureOptions();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_DPt
|
|
{
|
|
public:
|
|
nullableUintVal m_idx;
|
|
nullableBoolVal m_invertIfNegative;
|
|
CT_Marker* m_marker;
|
|
nullableBoolVal m_bubble3D;
|
|
nullableUintVal m_explosion;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
CT_PictureOptions* m_pictureOptions;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_DPt();
|
|
~CT_DPt();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_TrendlineLbl
|
|
{
|
|
public:
|
|
CT_Layout* m_layout;
|
|
CT_Tx* m_tx;
|
|
CT_NumFmt* m_numFmt;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullable<PPTX::Logic::TxBody> m_txPr;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_TrendlineLbl();
|
|
~CT_TrendlineLbl();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Trendline
|
|
{
|
|
public:
|
|
nullable_string m_name;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullableComplexVal<CTrendlineType> m_trendlineType;
|
|
nullableUintVal m_order;
|
|
nullableUintVal m_period;
|
|
nullableDoubleVal m_forward;
|
|
nullableDoubleVal m_backward;
|
|
nullableDoubleVal m_intercept;
|
|
nullableBoolVal m_dispRSqr;
|
|
nullableBoolVal m_dispEq;
|
|
CT_TrendlineLbl* m_trendlineLbl;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Trendline();
|
|
~CT_Trendline();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_ErrBars
|
|
{
|
|
public:
|
|
nullableComplexVal<CErrDir> m_errDir;
|
|
nullableComplexVal<CErrBarType> m_errBarType;
|
|
nullableComplexVal<CErrValType> m_errValType;
|
|
nullableBoolVal m_noEndCap;
|
|
CT_NumDataSource* m_plus;
|
|
CT_NumDataSource* m_minus;
|
|
nullableDoubleVal m_val;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_ErrBars();
|
|
~CT_ErrBars();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CBaseSer : public WritingElement
|
|
{
|
|
public:
|
|
CBaseSer();
|
|
virtual ~CBaseSer();
|
|
|
|
nullableUintVal m_idx;
|
|
nullableUintVal m_order;
|
|
CT_SerTx* m_tx;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
bool fromXML(const std::wstring nodeName, XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
virtual std::wstring toXML() const
|
|
{
|
|
return L"";
|
|
}
|
|
};
|
|
//---------------------------------------------------------------------------------------------------
|
|
class CT_BubbleSer : public CBaseSer
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_BubbleSer)
|
|
|
|
nullableBoolVal m_invertIfNegative;
|
|
std::vector<CT_DPt*> m_dPt;
|
|
std::vector<CT_Trendline*> m_trendline;
|
|
std::vector<CT_ErrBars*> m_errBars;
|
|
CT_DLbls* m_dLbls;
|
|
CT_AxDataSource* m_xVal;
|
|
CT_NumDataSource* m_yVal;
|
|
CT_NumDataSource* m_bubbleSize;
|
|
nullableBoolVal m_bubble3D;
|
|
|
|
CT_BubbleSer();
|
|
virtual ~CT_BubbleSer();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
|
|
class CT_BubbleChart
|
|
{
|
|
public:
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_BubbleSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
nullableBoolVal m_bubble3D;
|
|
nullableStringVal m_bubbleScale;
|
|
nullableBoolVal m_showNegBubbles;
|
|
nullableComplexVal<CSizeRepresents> m_sizeRepresents;
|
|
std::vector<_INT32> m_axId;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_BubbleChart();
|
|
~CT_BubbleChart();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_BandFmt
|
|
{
|
|
public:
|
|
nullableUintVal m_idx;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
|
|
CT_BandFmt();
|
|
~CT_BandFmt();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_bandFmts
|
|
{
|
|
public:
|
|
std::vector<CT_BandFmt*> m_bandFmt;
|
|
|
|
CT_bandFmts();
|
|
~CT_bandFmts();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_SurfaceSer : public CBaseSer
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_SurfaceSer)
|
|
|
|
CT_AxDataSource* m_cat;
|
|
CT_NumDataSource* m_val;
|
|
|
|
CT_SurfaceSer();
|
|
virtual ~CT_SurfaceSer();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Surface3DChart
|
|
{
|
|
public:
|
|
nullableBoolVal m_wireframe;
|
|
std::vector<CT_SurfaceSer*> m_ser;
|
|
CT_bandFmts* m_bandFmts;
|
|
std::vector<_INT32> m_axId;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Surface3DChart();
|
|
~CT_Surface3DChart();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
|
|
class CT_SurfaceChart
|
|
{
|
|
public:
|
|
nullableBoolVal m_wireframe;
|
|
std::vector<CT_SurfaceSer*> m_ser;
|
|
CT_bandFmts* m_bandFmts;
|
|
std::vector<_INT32> m_axId;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_SurfaceChart();
|
|
~CT_SurfaceChart();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_custSplit
|
|
{
|
|
public:
|
|
std::vector<unsigned int> m_secondPiePt;
|
|
|
|
CT_custSplit();
|
|
~CT_custSplit();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_PieSer : public CBaseSer
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_PieSer)
|
|
|
|
nullableUintVal m_explosion;
|
|
std::vector<CT_DPt*> m_dPt;
|
|
CT_DLbls* m_dLbls;
|
|
CT_AxDataSource* m_cat;
|
|
CT_NumDataSource* m_val;
|
|
|
|
CT_PieSer();
|
|
virtual ~CT_PieSer();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_OfPieChart
|
|
{
|
|
public:
|
|
nullableComplexVal<COfPieType> m_ofPieType;
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_PieSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
nullableStringVal m_gapWidth;
|
|
nullableComplexVal<CSplitType> m_splitType;
|
|
nullableDoubleVal m_splitPos;
|
|
CT_custSplit* m_custSplit;
|
|
nullableStringVal m_secondPieSize;
|
|
std::vector<CT_ChartLines*> m_serLines;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_OfPieChart();
|
|
~CT_OfPieChart();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_BarSer : public CBaseSer
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_BarSer)
|
|
|
|
nullableBoolVal m_invertIfNegative;
|
|
CT_PictureOptions* m_pictureOptions;
|
|
std::vector<CT_DPt*> m_dPt;
|
|
CT_DLbls* m_dLbls;
|
|
std::vector<CT_Trendline*> m_trendline;
|
|
CT_ErrBars* m_errBars;
|
|
CT_AxDataSource* m_cat;
|
|
CT_NumDataSource* m_val;
|
|
nullableComplexVal<CShapeType> m_shape;
|
|
|
|
CT_BarSer();
|
|
virtual ~CT_BarSer();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Bar3DChart
|
|
{
|
|
public:
|
|
nullableComplexVal<CBarDir> m_barDir;
|
|
nullableComplexVal<CBarGrouping> m_grouping;
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_BarSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
nullableStringVal m_gapWidth;
|
|
nullableStringVal m_gapDepth;
|
|
nullableComplexVal<CShapeType> m_shape;
|
|
std::vector<_INT32> m_axId;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Bar3DChart();
|
|
~CT_Bar3DChart();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_BarChart
|
|
{
|
|
public:
|
|
nullableComplexVal<CBarDir> m_barDir;
|
|
nullableComplexVal<CBarGrouping> m_grouping;
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_BarSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
nullableStringVal m_gapWidth;
|
|
nullableStringVal m_overlap;
|
|
std::vector<CT_ChartLines*> m_serLines;
|
|
std::vector<_INT32> m_axId;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_BarChart();
|
|
~CT_BarChart();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_DoughnutChart
|
|
{
|
|
public:
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_PieSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
nullableUintVal m_firstSliceAng;
|
|
nullableStringVal m_holeSize;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_DoughnutChart();
|
|
~CT_DoughnutChart();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Pie3DChart
|
|
{
|
|
public:
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_PieSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Pie3DChart();
|
|
~CT_Pie3DChart();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_PieChart
|
|
{
|
|
public:
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_PieSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
nullableUintVal m_firstSliceAng;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_PieChart();
|
|
~CT_PieChart();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_ScatterSer : public CBaseSer
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_ScatterSer)
|
|
|
|
CT_Marker* m_marker;
|
|
std::vector<CT_DPt*> m_dPt;
|
|
CT_DLbls* m_dLbls;
|
|
std::vector<CT_Trendline*> m_trendline;
|
|
std::vector<CT_ErrBars*> m_errBars;
|
|
CT_AxDataSource* m_xVal;
|
|
CT_NumDataSource* m_yVal;
|
|
nullableBoolVal m_smooth;
|
|
|
|
CT_ScatterSer();
|
|
virtual ~CT_ScatterSer();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_ScatterChart
|
|
{
|
|
public:
|
|
nullableComplexVal<CScatterStyle> m_scatterStyle;
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_ScatterSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
std::vector<_INT32> m_axId;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_ScatterChart();
|
|
~CT_ScatterChart();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_RadarSer : public CBaseSer
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_RadarSer)
|
|
|
|
CT_Marker* m_marker;
|
|
std::vector<CT_DPt*> m_dPt;
|
|
CT_DLbls* m_dLbls;
|
|
CT_AxDataSource* m_cat;
|
|
CT_NumDataSource* m_val;
|
|
|
|
CT_RadarSer();
|
|
virtual ~CT_RadarSer();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_RadarChart
|
|
{
|
|
public:
|
|
nullableComplexVal<CRadarStyle> m_radarStyle;
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_RadarSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
std::vector<_INT32> m_axId;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_RadarChart();
|
|
~CT_RadarChart();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_UpDownBar
|
|
{
|
|
public:
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
|
|
CT_UpDownBar();
|
|
~CT_UpDownBar();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_UpDownBars
|
|
{
|
|
public:
|
|
nullableStringVal m_gapWidth;
|
|
CT_UpDownBar* m_upBars;
|
|
CT_UpDownBar* m_downBars;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_UpDownBars();
|
|
~CT_UpDownBars();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_LineSer : public CBaseSer
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_LineSer)
|
|
|
|
CT_Marker* m_marker;
|
|
std::vector<CT_DPt*> m_dPt;
|
|
CT_DLbls* m_dLbls;
|
|
std::vector<CT_Trendline*> m_trendline;
|
|
CT_ErrBars* m_errBars;
|
|
CT_AxDataSource* m_cat;
|
|
CT_NumDataSource* m_val;
|
|
nullableBoolVal m_smooth;
|
|
|
|
CT_LineSer();
|
|
virtual ~CT_LineSer();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
|
|
class CT_StockChart
|
|
{
|
|
public:
|
|
std::vector<CT_LineSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
CT_ChartLines* m_dropLines;
|
|
CT_ChartLines* m_hiLowLines;
|
|
CT_UpDownBars* m_upDownBars;
|
|
std::vector<_INT32> m_axId;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_StockChart();
|
|
~CT_StockChart();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Line3DChart
|
|
{
|
|
public:
|
|
nullableComplexVal<CGrouping> m_grouping;
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_LineSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
CT_ChartLines* m_dropLines;
|
|
nullableStringVal m_gapDepth;
|
|
std::vector<_INT32> m_axId;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Line3DChart();
|
|
~CT_Line3DChart();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_LineChart
|
|
{
|
|
public:
|
|
nullableComplexVal<CGrouping> m_grouping;
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_LineSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
CT_ChartLines* m_dropLines;
|
|
CT_ChartLines* m_hiLowLines;
|
|
CT_UpDownBars* m_upDownBars;
|
|
nullableBoolVal m_marker;
|
|
nullableBoolVal m_smooth;
|
|
std::vector<_INT32> m_axId;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_LineChart();
|
|
~CT_LineChart();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_AreaSer : public CBaseSer
|
|
{
|
|
public:
|
|
WritingElement_AdditionMethods(CT_AreaSer)
|
|
|
|
CT_PictureOptions* m_pictureOptions;
|
|
std::vector<CT_DPt*> m_dPt;
|
|
CT_DLbls* m_dLbls;
|
|
std::vector<CT_Trendline*> m_trendline;
|
|
std::vector<CT_ErrBars*> m_errBars;
|
|
CT_AxDataSource* m_cat;
|
|
CT_NumDataSource* m_val;
|
|
|
|
CT_AreaSer();
|
|
virtual ~CT_AreaSer();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& node)
|
|
{}
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Area3DChart
|
|
{
|
|
public:
|
|
nullableComplexVal<CGrouping> m_grouping;
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_AreaSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
CT_ChartLines* m_dropLines;
|
|
nullableStringVal m_gapDepth;
|
|
std::vector<_INT32> m_axId;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Area3DChart();
|
|
~CT_Area3DChart();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_AreaChart
|
|
{
|
|
public:
|
|
nullableComplexVal<CGrouping> m_grouping;
|
|
nullableBoolVal m_varyColors;
|
|
std::vector<CT_AreaSer*> m_ser;
|
|
CT_DLbls* m_dLbls;
|
|
CT_ChartLines* m_dropLines;
|
|
std::vector<_INT32> m_axId;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_AreaChart();
|
|
~CT_AreaChart();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_PlotArea
|
|
{
|
|
public:
|
|
CT_Layout* m_layout;
|
|
std::vector<ItemsChoiceType5*> m_ItemsElementName0;
|
|
std::vector<void*> m_Items;
|
|
std::vector<ItemsChoiceType6*> m_ItemsElementName1;
|
|
std::vector<void*> m_Items1;
|
|
CT_DTable* m_dTable;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_PlotArea();
|
|
~CT_PlotArea();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
private:
|
|
void toXML(NSStringUtils::CStringBuilder& writer, bool bIsAttribute, ItemsChoiceType5 eType, void* pVal) const;
|
|
void toDelete(ItemsChoiceType5 eType, void* pVal);
|
|
void toXML(NSStringUtils::CStringBuilder& writer, bool bIsAttribute, ItemsChoiceType6 eType, void* pVal) const;
|
|
void toDelete(ItemsChoiceType6 eType, void* pVal);
|
|
};
|
|
class CT_Surface
|
|
{
|
|
public:
|
|
nullableStringVal m_thickness;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
CT_PictureOptions* m_pictureOptions;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Surface();
|
|
~CT_Surface();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_View3D
|
|
{
|
|
public:
|
|
nullableIntVal m_rotX;
|
|
nullableUintVal m_rotY;
|
|
nullableStringVal m_hPercent;
|
|
nullableStringVal m_depthPercent;
|
|
nullableBoolVal m_rAngAx;
|
|
nullableUintVal m_perspective;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_View3D();
|
|
~CT_View3D();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_PivotFmt
|
|
{
|
|
public:
|
|
nullableUintVal m_idx;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullable<PPTX::Logic::TxBody> m_txPr;
|
|
CT_Marker* m_marker;
|
|
CT_DLbl* m_dLbl;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_PivotFmt();
|
|
~CT_PivotFmt();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_pivotFmts
|
|
{
|
|
public:
|
|
std::vector<CT_PivotFmt*> m_pivotFmt;
|
|
|
|
CT_pivotFmts();
|
|
~CT_pivotFmts();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Chart
|
|
{
|
|
public:
|
|
CT_Title* m_title;
|
|
CT_pivotFmts* m_pivotFmts;
|
|
CT_View3D* m_view3D;
|
|
CT_Surface* m_floor;
|
|
CT_Surface* m_sideWall;
|
|
CT_Surface* m_backWall;
|
|
CT_PlotArea* m_plotArea;
|
|
CT_Legend* m_legend;
|
|
nullableBoolVal m_autoTitleDeleted;
|
|
nullableBoolVal m_plotVisOnly;
|
|
nullableComplexVal<CDispBlanksAs> m_dispBlanksAs;
|
|
nullableBoolVal m_showDLblsOverMax;
|
|
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_Chart();
|
|
~CT_Chart();
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_Protection
|
|
{
|
|
public:
|
|
nullableBoolVal m_chartObject;
|
|
nullableBoolVal m_data;
|
|
nullableBoolVal m_formatting;
|
|
nullableBoolVal m_selection;
|
|
nullableBoolVal m_userInterface;
|
|
|
|
CT_Protection();
|
|
~CT_Protection();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_PivotSource
|
|
{
|
|
public:
|
|
nullable_string m_name;
|
|
nullableIntVal m_fmtId;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_PivotSource();
|
|
~CT_PivotSource();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
class CT_ChartSpace
|
|
{
|
|
public:
|
|
nullableBoolVal m_date1904;
|
|
nullableStringVal m_lang;
|
|
nullableBoolVal m_roundedCorners;
|
|
AlternateContent* m_AlternateContent;
|
|
CT_Style* m_style;
|
|
CT_PivotSource* m_pivotSource;
|
|
CT_Protection* m_protection;
|
|
CT_Chart* m_chart;
|
|
|
|
nullable<PPTX::Logic::ClrMap> m_oClrMapOvr;
|
|
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullable<PPTX::Logic::TxBody> m_txPr;
|
|
|
|
CT_ExternalData* m_externalData;
|
|
CT_PrintSettings* m_printSettings;
|
|
CT_RelId* m_userShapes;
|
|
nullable<OOX::Drawing::COfficeArtExtensionList> m_extLst;
|
|
|
|
CT_ChartSpace();
|
|
~CT_ChartSpace();
|
|
|
|
void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const;
|
|
EElementType getType();
|
|
};
|
|
|
|
class CSeriesDataLabelsRange : public WritingElement
|
|
{//c15
|
|
public:
|
|
WritingElement_AdditionMethods(CSeriesDataLabelsRange)
|
|
|
|
CSeriesDataLabelsRange();
|
|
virtual ~CSeriesDataLabelsRange();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& oNode);
|
|
virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
|
|
virtual std::wstring toXML() const;
|
|
virtual void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
|
|
virtual EElementType getType() const;
|
|
|
|
nullable<CT_StrData> m_dlblRangeCache;
|
|
nullable_string m_f;
|
|
};
|
|
|
|
class CCategoryFilterException : public WritingElement
|
|
{//c15
|
|
public:
|
|
WritingElement_AdditionMethods(CCategoryFilterException)
|
|
|
|
CCategoryFilterException();
|
|
virtual ~CCategoryFilterException();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& oNode);
|
|
virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
|
|
virtual std::wstring toXML() const;
|
|
virtual void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
virtual EElementType getType() const;
|
|
|
|
nullable_string m_sqref;
|
|
nullable<PPTX::Logic::SpPr> m_spPr;
|
|
nullableUintVal m_explosion;
|
|
nullableBoolVal m_invertIfNegative;
|
|
nullableBoolVal m_bubble3D;
|
|
nullable<CT_Marker> m_marker;
|
|
nullable<CT_DLbl> m_dLbl;
|
|
|
|
};
|
|
class CCategoryFilterExceptions : public WritingElementWithChilds<CCategoryFilterException>
|
|
{//c15
|
|
public:
|
|
WritingElement_AdditionMethods(CCategoryFilterExceptions)
|
|
|
|
CCategoryFilterExceptions();
|
|
virtual ~CCategoryFilterExceptions();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& oNode);
|
|
virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
|
|
virtual std::wstring toXML() const;
|
|
virtual void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
virtual EElementType getType() const;
|
|
};
|
|
|
|
class CSeriesFiltering : public WritingElement
|
|
{//c15
|
|
public:
|
|
WritingElement_AdditionMethods(CSeriesFiltering)
|
|
|
|
CSeriesFiltering();
|
|
virtual ~CSeriesFiltering();
|
|
|
|
virtual void fromXML(XmlUtils::CXmlNode& oNode);
|
|
virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
|
|
|
|
virtual std::wstring toXML() const;
|
|
virtual void toXML(NSStringUtils::CStringBuilder& writer) const;
|
|
virtual EElementType getType() const;
|
|
|
|
nullable<CSeriesDataLabelsRange> m_dataLabelsRange;
|
|
nullable<CT_Tx> m_filteredSeriesTitle;
|
|
nullable<CT_AxDataSource> m_filteredCategoryTitle;
|
|
|
|
nullable<CT_LineSer> m_filteredLineSeries;
|
|
nullable<CT_ScatterSer> m_filteredScatterSeries;
|
|
nullable<CT_RadarSer> m_filteredRadarSeries;
|
|
nullable<CT_BarSer> m_filteredBarSeries;
|
|
nullable<CT_AreaSer> m_filteredAreaSeries;
|
|
nullable<CT_BubbleSer> m_filteredBubbleSeries;
|
|
nullable<CT_SurfaceSer> m_filteredSurfaceSeries;
|
|
nullable<CT_PieSer> m_filteredPieSeries;
|
|
|
|
nullable_string m_fullRef;
|
|
nullable_string m_levelRef;
|
|
nullable_string m_formulaRef;
|
|
|
|
nullable<OOX::Spreadsheet::CCategoryFilterExceptions> m_categoryFilterExceptions;
|
|
};
|
|
}
|
|
}
|
|
|