/*
 * (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
 *
 */

//Generated code
#include "ChartSerialize.h"
#include "../../../DesktopEditor/common/StringExt.h"

namespace OOX
{
namespace Spreadsheet 
{

		bool FromXml_ST_PageSetupOrientation(const std::wstring& val, ST_PageSetupOrientation& eOut)
		{
			bool bRes = true;
			if (L"default" == val)
				eOut = st_pagesetuporientationDEFAULT;
			else if (L"portrait" == val)
				eOut = st_pagesetuporientationPORTRAIT;
			else if (L"landscape" == val)
				eOut = st_pagesetuporientationLANDSCAPE;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_PageSetupOrientation(ST_PageSetupOrientation val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_pagesetuporientationDEFAULT == val)
				sOut = L"default";
			else if (st_pagesetuporientationPORTRAIT == val)
				sOut = L"portrait";
			else if (st_pagesetuporientationLANDSCAPE == val)
				sOut = L"landscape";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_DispBlanksAs(const std::wstring& val, ST_DispBlanksAs& eOut)
		{
			bool bRes = true;
			if (L"span" == val)
				eOut = st_dispblanksasSPAN;
			else if (L"gap" == val)
				eOut = st_dispblanksasGAP;
			else if (L"zero" == val)
				eOut = st_dispblanksasZERO;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_DispBlanksAs(ST_DispBlanksAs val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_dispblanksasSPAN == val)
				sOut = L"span";
			else if (st_dispblanksasGAP == val)
				sOut = L"gap";
			else if (st_dispblanksasZERO == val)
				sOut = L"zero";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_LegendPos(const std::wstring& val, ST_LegendPos& eOut)
		{
			bool bRes = true;
			if (L"b" == val)
				eOut = st_legendposB;
			else if (L"tr" == val)
				eOut = st_legendposTR;
			else if (L"l" == val)
				eOut = st_legendposL;
			else if (L"r" == val)
				eOut = st_legendposR;
			else if (L"t" == val)
				eOut = st_legendposT;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_LegendPos(ST_LegendPos val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_legendposB == val)
				sOut = L"b";
			else if (st_legendposTR == val)
				sOut = L"tr";
			else if (st_legendposL == val)
				sOut = L"l";
			else if (st_legendposR == val)
				sOut = L"r";
			else if (st_legendposT == val)
				sOut = L"t";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_LayoutTarget(const std::wstring& val, ST_LayoutTarget& eOut)
		{
			bool bRes = true;
			if (L"inner" == val)
				eOut = st_layouttargetINNER;
			else if (L"outer" == val)
				eOut = st_layouttargetOUTER;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_LayoutTarget(ST_LayoutTarget val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_layouttargetINNER == val)
				sOut = L"inner";
			else if (st_layouttargetOUTER == val)
				sOut = L"outer";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_LayoutMode(const std::wstring& val, ST_LayoutMode& eOut)
		{
			bool bRes = true;
			if (L"edge" == val)
				eOut = st_layoutmodeEDGE;
			else if (L"factor" == val)
				eOut = st_layoutmodeFACTOR;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_LayoutMode(ST_LayoutMode val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_layoutmodeEDGE == val)
				sOut = L"edge";
			else if (st_layoutmodeFACTOR == val)
				sOut = L"factor";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_Orientation(const std::wstring& val, ST_Orientation& eOut)
		{
			bool bRes = true;
			if (L"maxMin" == val)
				eOut = st_orientationMAXMIN;
			else if (L"minMax" == val)
				eOut = st_orientationMINMAX;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_Orientation(ST_Orientation val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_orientationMAXMIN == val)
				sOut = L"maxMin";
			else if (st_orientationMINMAX == val)
				sOut = L"minMax";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_AxPos(const std::wstring& val, ST_AxPos& eOut)
		{
			bool bRes = true;
			if (L"b" == val)
				eOut = st_axposB;
			else if (L"l" == val)
				eOut = st_axposL;
			else if (L"r" == val)
				eOut = st_axposR;
			else if (L"t" == val)
				eOut = st_axposT;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_AxPos(ST_AxPos val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_axposB == val)
				sOut = L"b";
			else if (st_axposL == val)
				sOut = L"l";
			else if (st_axposR == val)
				sOut = L"r";
			else if (st_axposT == val)
				sOut = L"t";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_TickMark(const std::wstring& val, ST_TickMark& eOut)
		{
			bool bRes = true;
			if (L"cross" == val)
				eOut = st_tickmarkCROSS;
			else if (L"in" == val)
				eOut = st_tickmarkIN;
			else if (L"none" == val)
				eOut = st_tickmarkNONE;
			else if (L"out" == val)
				eOut = st_tickmarkOUT;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_TickMark(ST_TickMark val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_tickmarkCROSS == val)
				sOut = L"cross";
			else if (st_tickmarkIN == val)
				sOut = L"in";
			else if (st_tickmarkNONE == val)
				sOut = L"none";
			else if (st_tickmarkOUT == val)
				sOut = L"out";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_TickLblPos(const std::wstring& val, ST_TickLblPos& eOut)
		{
			bool bRes = true;
			if (L"high" == val)
				eOut = st_ticklblposHIGH;
			else if (L"low" == val)
				eOut = st_ticklblposLOW;
			else if (L"nextTo" == val)
				eOut = st_ticklblposNEXTTO;
			else if (L"none" == val)
				eOut = st_ticklblposNONE;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_TickLblPos(ST_TickLblPos val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_ticklblposHIGH == val)
				sOut = L"high";
			else if (st_ticklblposLOW == val)
				sOut = L"low";
			else if (st_ticklblposNEXTTO == val)
				sOut = L"nextTo";
			else if (st_ticklblposNONE == val)
				sOut = L"none";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_Crosses(const std::wstring& val, ST_Crosses& eOut)
		{
			bool bRes = true;
			if (L"autoZero" == val)
				eOut = st_crossesAUTOZERO;
			else if (L"max" == val)
				eOut = st_crossesMAX;
			else if (L"min" == val)
				eOut = st_crossesMIN;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_Crosses(ST_Crosses val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_crossesAUTOZERO == val)
				sOut = L"autoZero";
			else if (st_crossesMAX == val)
				sOut = L"max";
			else if (st_crossesMIN == val)
				sOut = L"min";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_TimeUnit(const std::wstring& val, ST_TimeUnit& eOut)
		{
			bool bRes = true;
			if (L"days" == val)
				eOut = st_timeunitDAYS;
			else if (L"months" == val)
				eOut = st_timeunitMONTHS;
			else if (L"years" == val)
				eOut = st_timeunitYEARS;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_TimeUnit(ST_TimeUnit val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_timeunitDAYS == val)
				sOut = L"days";
			else if (st_timeunitMONTHS == val)
				sOut = L"months";
			else if (st_timeunitYEARS == val)
				sOut = L"years";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_LblAlgn(const std::wstring& val, ST_LblAlgn& eOut)
		{
			bool bRes = true;
			if (L"ctr" == val)
				eOut = st_lblalgnCTR;
			else if (L"l" == val)
				eOut = st_lblalgnL;
			else if (L"r" == val)
				eOut = st_lblalgnR;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_LblAlgn(ST_LblAlgn val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_lblalgnCTR == val)
				sOut = L"ctr";
			else if (st_lblalgnL == val)
				sOut = L"l";
			else if (st_lblalgnR == val)
				sOut = L"r";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_BuiltInUnit(const std::wstring& val, ST_BuiltInUnit& eOut)
		{
			bool bRes = true;
			if (L"hundreds" == val)
				eOut = st_builtinunitHUNDREDS;
			else if (L"thousands" == val)
				eOut = st_builtinunitTHOUSANDS;
			else if (L"tenThousands" == val)
				eOut = st_builtinunitTENTHOUSANDS;
			else if (L"hundredThousands" == val)
				eOut = st_builtinunitHUNDREDTHOUSANDS;
			else if (L"millions" == val)
				eOut = st_builtinunitMILLIONS;
			else if (L"tenMillions" == val)
				eOut = st_builtinunitTENMILLIONS;
			else if (L"hundredMillions" == val)
				eOut = st_builtinunitHUNDREDMILLIONS;
			else if (L"billions" == val)
				eOut = st_builtinunitBILLIONS;
			else if (L"trillions" == val)
				eOut = st_builtinunitTRILLIONS;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_BuiltInUnit(ST_BuiltInUnit val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_builtinunitHUNDREDS == val)
				sOut = L"hundreds";
			else if (st_builtinunitTHOUSANDS == val)
				sOut = L"thousands";
			else if (st_builtinunitTENTHOUSANDS == val)
				sOut = L"tenThousands";
			else if (st_builtinunitHUNDREDTHOUSANDS == val)
				sOut = L"hundredThousands";
			else if (st_builtinunitMILLIONS == val)
				sOut = L"millions";
			else if (st_builtinunitTENMILLIONS == val)
				sOut = L"tenMillions";
			else if (st_builtinunitHUNDREDMILLIONS == val)
				sOut = L"hundredMillions";
			else if (st_builtinunitBILLIONS == val)
				sOut = L"billions";
			else if (st_builtinunitTRILLIONS == val)
				sOut = L"trillions";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_CrossBetween(const std::wstring& val, ST_CrossBetween& eOut)
		{
			bool bRes = true;
			if (L"between" == val)
				eOut = st_crossbetweenBETWEEN;
			else if (L"midCat" == val)
				eOut = st_crossbetweenMIDCAT;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_CrossBetween(ST_CrossBetween val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_crossbetweenBETWEEN == val)
				sOut = L"between";
			else if (st_crossbetweenMIDCAT == val)
				sOut = L"midCat";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_SizeRepresents(const std::wstring& val, ST_SizeRepresents& eOut)
		{
			bool bRes = true;
			if (L"area" == val)
				eOut = st_sizerepresentsAREA;
			else if (L"w" == val)
				eOut = st_sizerepresentsW;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_SizeRepresents(ST_SizeRepresents val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_sizerepresentsAREA == val)
				sOut = L"area";
			else if (st_sizerepresentsW == val)
				sOut = L"w";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_MarkerStyle(const std::wstring& val, ST_MarkerStyle& eOut)
		{
			bool bRes = true;
			if (L"circle" == val)
				eOut = st_markerstyleCIRCLE;
			else if (L"dash" == val)
				eOut = st_markerstyleDASH;
			else if (L"diamond" == val)
				eOut = st_markerstyleDIAMOND;
			else if (L"dot" == val)
				eOut = st_markerstyleDOT;
			else if (L"none" == val)
				eOut = st_markerstyleNONE;
			else if (L"picture" == val)
				eOut = st_markerstylePICTURE;
			else if (L"plus" == val)
				eOut = st_markerstylePLUS;
			else if (L"square" == val)
				eOut = st_markerstyleSQUARE;
			else if (L"star" == val)
				eOut = st_markerstyleSTAR;
			else if (L"triangle" == val)
				eOut = st_markerstyleTRIANGLE;
			else if (L"x" == val)
				eOut = st_markerstyleX;
			else if (L"auto" == val)
				eOut = st_markerstyleAUTO;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_MarkerStyle(ST_MarkerStyle val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_markerstyleCIRCLE == val)
				sOut = L"circle";
			else if (st_markerstyleDASH == val)
				sOut = L"dash";
			else if (st_markerstyleDIAMOND == val)
				sOut = L"diamond";
			else if (st_markerstyleDOT == val)
				sOut = L"dot";
			else if (st_markerstyleNONE == val)
				sOut = L"none";
			else if (st_markerstylePICTURE == val)
				sOut = L"picture";
			else if (st_markerstylePLUS == val)
				sOut = L"plus";
			else if (st_markerstyleSQUARE == val)
				sOut = L"square";
			else if (st_markerstyleSTAR == val)
				sOut = L"star";
			else if (st_markerstyleTRIANGLE == val)
				sOut = L"triangle";
			else if (st_markerstyleX == val)
				sOut = L"x";
			else if (st_markerstyleAUTO == val)
				sOut = L"auto";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_PictureFormat(const std::wstring& val, ST_PictureFormat& eOut)
		{
			bool bRes = true;
			if (L"stretch" == val)
				eOut = st_pictureformatSTRETCH;
			else if (L"stack" == val)
				eOut = st_pictureformatSTACK;
			else if (L"stackScale" == val)
				eOut = st_pictureformatSTACKSCALE;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_PictureFormat(ST_PictureFormat val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_pictureformatSTRETCH == val)
				sOut = L"stretch";
			else if (st_pictureformatSTACK == val)
				sOut = L"stack";
			else if (st_pictureformatSTACKSCALE == val)
				sOut = L"stackScale";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_DLblPos(const std::wstring& val, ST_DLblPos& eOut)
		{
			bool bRes = true;
			if (L"bestFit" == val)
				eOut = st_dlblposBESTFIT;
			else if (L"b" == val)
				eOut = st_dlblposB;
			else if (L"ctr" == val)
				eOut = st_dlblposCTR;
			else if (L"inBase" == val)
				eOut = st_dlblposINBASE;
			else if (L"inEnd" == val)
				eOut = st_dlblposINEND;
			else if (L"l" == val)
				eOut = st_dlblposL;
			else if (L"outEnd" == val)
				eOut = st_dlblposOUTEND;
			else if (L"r" == val)
				eOut = st_dlblposR;
			else if (L"t" == val)
				eOut = st_dlblposT;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_DLblPos(ST_DLblPos val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_dlblposBESTFIT == val)
				sOut = L"bestFit";
			else if (st_dlblposB == val)
				sOut = L"b";
			else if (st_dlblposCTR == val)
				sOut = L"ctr";
			else if (st_dlblposINBASE == val)
				sOut = L"inBase";
			else if (st_dlblposINEND == val)
				sOut = L"inEnd";
			else if (st_dlblposL == val)
				sOut = L"l";
			else if (st_dlblposOUTEND == val)
				sOut = L"outEnd";
			else if (st_dlblposR == val)
				sOut = L"r";
			else if (st_dlblposT == val)
				sOut = L"t";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_TrendlineType(const std::wstring& val, ST_TrendlineType& eOut)
		{
			bool bRes = true;
			if (L"exp" == val)
				eOut = st_trendlinetypeEXP;
			else if (L"linear" == val)
				eOut = st_trendlinetypeLINEAR;
			else if (L"log" == val)
				eOut = st_trendlinetypeLOG;
			else if (L"movingAvg" == val)
				eOut = st_trendlinetypeMOVINGAVG;
			else if (L"poly" == val)
				eOut = st_trendlinetypePOLY;
			else if (L"power" == val)
				eOut = st_trendlinetypePOWER;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_TrendlineType(ST_TrendlineType val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_trendlinetypeEXP == val)
				sOut = L"exp";
			else if (st_trendlinetypeLINEAR == val)
				sOut = L"linear";
			else if (st_trendlinetypeLOG == val)
				sOut = L"log";
			else if (st_trendlinetypeMOVINGAVG == val)
				sOut = L"movingAvg";
			else if (st_trendlinetypePOLY == val)
				sOut = L"poly";
			else if (st_trendlinetypePOWER == val)
				sOut = L"power";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_ErrDir(const std::wstring& val, ST_ErrDir& eOut)
		{
			bool bRes = true;
			if (L"x" == val)
				eOut = st_errdirX;
			else if (L"y" == val)
				eOut = st_errdirY;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_ErrDir(ST_ErrDir val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_errdirX == val)
				sOut = L"x";
			else if (st_errdirY == val)
				sOut = L"y";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_ErrBarType(const std::wstring& val, ST_ErrBarType& eOut)
		{
			bool bRes = true;
			if (L"both" == val)
				eOut = st_errbartypeBOTH;
			else if (L"minus" == val)
				eOut = st_errbartypeMINUS;
			else if (L"plus" == val)
				eOut = st_errbartypePLUS;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_ErrBarType(ST_ErrBarType val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_errbartypeBOTH == val)
				sOut = L"both";
			else if (st_errbartypeMINUS == val)
				sOut = L"minus";
			else if (st_errbartypePLUS == val)
				sOut = L"plus";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_ErrValType(const std::wstring& val, ST_ErrValType& eOut)
		{
			bool bRes = true;
			if (L"cust" == val)
				eOut = st_errvaltypeCUST;
			else if (L"fixedVal" == val)
				eOut = st_errvaltypeFIXEDVAL;
			else if (L"percentage" == val)
				eOut = st_errvaltypePERCENTAGE;
			else if (L"stdDev" == val)
				eOut = st_errvaltypeSTDDEV;
			else if (L"stdErr" == val)
				eOut = st_errvaltypeSTDERR;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_ErrValType(ST_ErrValType val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_errvaltypeCUST == val)
				sOut = L"cust";
			else if (st_errvaltypeFIXEDVAL == val)
				sOut = L"fixedVal";
			else if (st_errvaltypePERCENTAGE == val)
				sOut = L"percentage";
			else if (st_errvaltypeSTDDEV == val)
				sOut = L"stdDev";
			else if (st_errvaltypeSTDERR == val)
				sOut = L"stdErr";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_SplitType(const std::wstring& val, ST_SplitType& eOut)
		{
			bool bRes = true;
			if (L"auto" == val)
				eOut = st_splittypeAUTO;
			else if (L"cust" == val)
				eOut = st_splittypeCUST;
			else if (L"percent" == val)
				eOut = st_splittypePERCENT;
			else if (L"pos" == val)
				eOut = st_splittypePOS;
			else if (L"val" == val)
				eOut = st_splittypeVAL;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_SplitType(ST_SplitType val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_splittypeAUTO == val)
				sOut = L"auto";
			else if (st_splittypeCUST == val)
				sOut = L"cust";
			else if (st_splittypePERCENT == val)
				sOut = L"percent";
			else if (st_splittypePOS == val)
				sOut = L"pos";
			else if (st_splittypeVAL == val)
				sOut = L"val";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_OfPieType(const std::wstring& val, ST_OfPieType& eOut)
		{
			bool bRes = true;
			if (L"pie" == val)
				eOut = st_ofpietypePIE;
			else if (L"bar" == val)
				eOut = st_ofpietypeBAR;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_OfPieType(ST_OfPieType val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_ofpietypePIE == val)
				sOut = L"pie";
			else if (st_ofpietypeBAR == val)
				sOut = L"bar";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_BarDir(const std::wstring& val, ST_BarDir& eOut)
		{
			bool bRes = true;
			if (L"bar" == val)
				eOut = st_bardirBAR;
			else if (L"col" == val)
				eOut = st_bardirCOL;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_BarDir(ST_BarDir val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_bardirBAR == val)
				sOut = L"bar";
			else if (st_bardirCOL == val)
				sOut = L"col";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_BarGrouping(const std::wstring& val, ST_BarGrouping& eOut)
		{
			bool bRes = true;
			if (L"percentStacked" == val)
				eOut = st_bargroupingPERCENTSTACKED;
			else if (L"clustered" == val)
				eOut = st_bargroupingCLUSTERED;
			else if (L"standard" == val)
				eOut = st_bargroupingSTANDARD;
			else if (L"stacked" == val)
				eOut = st_bargroupingSTACKED;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_BarGrouping(ST_BarGrouping val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_bargroupingPERCENTSTACKED == val)
				sOut = L"percentStacked";
			else if (st_bargroupingCLUSTERED == val)
				sOut = L"clustered";
			else if (st_bargroupingSTANDARD == val)
				sOut = L"standard";
			else if (st_bargroupingSTACKED == val)
				sOut = L"stacked";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_Shape(const std::wstring& val, ST_Shape& eOut)
		{
			bool bRes = true;
			if (L"cone" == val)
				eOut = st_shapeCONE;
			else if (L"coneToMax" == val)
				eOut = st_shapeCONETOMAX;
			else if (L"box" == val)
				eOut = st_shapeBOX;
			else if (L"cylinder" == val)
				eOut = st_shapeCYLINDER;
			else if (L"pyramid" == val)
				eOut = st_shapePYRAMID;
			else if (L"pyramidToMax" == val)
				eOut = st_shapePYRAMIDTOMAX;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_Shape(ST_Shape val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_shapeCONE == val)
				sOut = L"cone";
			else if (st_shapeCONETOMAX == val)
				sOut = L"coneToMax";
			else if (st_shapeBOX == val)
				sOut = L"box";
			else if (st_shapeCYLINDER == val)
				sOut = L"cylinder";
			else if (st_shapePYRAMID == val)
				sOut = L"pyramid";
			else if (st_shapePYRAMIDTOMAX == val)
				sOut = L"pyramidToMax";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_ScatterStyle(const std::wstring& val, ST_ScatterStyle& eOut)
		{
			bool bRes = true;
			if (L"none" == val)
				eOut = st_scatterstyleNONE;
			else if (L"line" == val)
				eOut = st_scatterstyleLINE;
			else if (L"lineMarker" == val)
				eOut = st_scatterstyleLINEMARKER;
			else if (L"marker" == val)
				eOut = st_scatterstyleMARKER;
			else if (L"smooth" == val)
				eOut = st_scatterstyleSMOOTH;
			else if (L"smoothMarker" == val)
				eOut = st_scatterstyleSMOOTHMARKER;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_ScatterStyle(ST_ScatterStyle val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_scatterstyleNONE == val)
				sOut = L"none";
			else if (st_scatterstyleLINE == val)
				sOut = L"line";
			else if (st_scatterstyleLINEMARKER == val)
				sOut = L"lineMarker";
			else if (st_scatterstyleMARKER == val)
				sOut = L"marker";
			else if (st_scatterstyleSMOOTH == val)
				sOut = L"smooth";
			else if (st_scatterstyleSMOOTHMARKER == val)
				sOut = L"smoothMarker";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_RadarStyle(const std::wstring& val, ST_RadarStyle& eOut)
		{
			bool bRes = true;
			if (L"standard" == val)
				eOut = st_radarstyleSTANDARD;
			else if (L"marker" == val)
				eOut = st_radarstyleMARKER;
			else if (L"filled" == val)
				eOut = st_radarstyleFILLED;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_RadarStyle(ST_RadarStyle val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_radarstyleSTANDARD == val)
				sOut = L"standard";
			else if (st_radarstyleMARKER == val)
				sOut = L"marker";
			else if (st_radarstyleFILLED == val)
				sOut = L"filled";
			else
				bRes = false;
			return bRes;
		}
		bool FromXml_ST_Grouping(const std::wstring& val, ST_Grouping& eOut)
		{
			bool bRes = true;
			if (L"percentStacked" == val)
				eOut = st_groupingPERCENTSTACKED;
			else if (L"standard" == val)
				eOut = st_groupingSTANDARD;
			else if (L"stacked" == val)
				eOut = st_groupingSTACKED;
			else
				bRes = false;
			return bRes;
		}
		bool ToXml_ST_Grouping(ST_Grouping val, std::wstring& sOut)
		{
			bool bRes = true;
			if (st_groupingPERCENTSTACKED == val)
				sOut = L"percentStacked";
			else if (st_groupingSTANDARD == val)
				sOut = L"standard";
			else if (st_groupingSTACKED == val)
				sOut = L"stacked";
			else
				bRes = false;
			return bRes;
		}

//-----------------------------------------------------------------------------------------------------------

		CT_ChartSpace::CT_ChartSpace()
		{
			m_AlternateContent = NULL;
			m_style = NULL;
			m_pivotSource = NULL;
			m_protection = NULL;
			m_chart = NULL;
			m_externalData = NULL;
			m_printSettings = NULL;
			m_userShapes = NULL;
		}
		CT_ChartSpace::~CT_ChartSpace()
		{
			if (NULL != m_AlternateContent)
				delete m_AlternateContent;
			if (NULL != m_style)
				delete m_style;
			if (NULL != m_pivotSource)
				delete m_pivotSource;
			if (NULL != m_protection)
				delete m_protection;
			if (NULL != m_chart)
				delete m_chart;
			if (NULL != m_externalData)
				delete m_externalData;
			if (NULL != m_printSettings)
				delete m_printSettings;
			if (NULL != m_userShapes)
				delete m_userShapes;
		}
		void CT_ChartSpace::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"date1904" == sName)
					m_date1904 = oReader;
				else if (L"lang" == sName)
					m_lang = oReader;
				else if (L"roundedCorners" == sName)
					m_roundedCorners = oReader;
				else if (L"AlternateContent" == sName)
				{
					AlternateContent* pNewElem = new AlternateContent;
					pNewElem->fromXML(oReader);
					m_AlternateContent = pNewElem;
				}
				else if (L"style" == sName)
				{
					m_style = new CT_Style;
					m_style->fromXML(oReader);
				}
				else if (L"clrMapOvr" == sName)
				{
					m_oClrMapOvr = oReader;
				}
				else if (L"pivotSource" == sName)
				{
					CT_PivotSource* pNewElem = new CT_PivotSource;
					pNewElem->fromXML(oReader);
					m_pivotSource = pNewElem;
				}
				else if (L"protection" == sName)
				{
					CT_Protection* pNewElem = new CT_Protection;
					pNewElem->fromXML(oReader);
					m_protection = pNewElem;
				}
				else if (L"chart" == sName)
				{
					CT_Chart* pNewElem = new CT_Chart;
					pNewElem->fromXML(oReader);
					m_chart = pNewElem;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"txPr" == sName)
				{
					m_txPr = oReader;
				}
				else if (L"externalData" == sName)
				{
					CT_ExternalData* pNewElem = new CT_ExternalData;
					pNewElem->fromXML(oReader);
					m_externalData = pNewElem;
				}
				else if (L"printSettings" == sName)
				{
					CT_PrintSettings* pNewElem = new CT_PrintSettings;
					pNewElem->fromXML(oReader);
					m_printSettings = pNewElem;
				}
				else if (L"userShapes" == sName)
				{
					CT_RelId* pNewElem = new CT_RelId;
					pNewElem->fromXML(oReader);
					m_userShapes = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_ChartSpace::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<" + sNodeName + L" \
xmlns:c=\"http://schemas.openxmlformats.org/drawingml/2006/chart\" \
xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" \
xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" \
xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
xmlns:c15=\"http://schemas.microsoft.com/office/drawing/2012/chart\" \
xmlns:c14=\"http://schemas.microsoft.com/office/drawing/2007/8/2/chart\" \
xmlns:c16r2=\"http://schemas.microsoft.com/office/drawing/2015/06/chart\"");

			writer.WriteString(L">");
			
			m_date1904.toXML(L"c:date1904", writer);
			
			m_lang.toXML(L"c:lang", writer);

			m_roundedCorners.toXML(L"c:roundedCorners", writer);

			if (NULL != m_AlternateContent)
			{
				m_AlternateContent->toXML(L"mc:AlternateContent", writer);
			}
			if (NULL != m_style)
			{
				m_style->toXML(writer);
			}
			if (m_oClrMapOvr.IsInit())
			{
				writer.WriteString(m_oClrMapOvr->toXML());
			}
			if (NULL != m_pivotSource)
			{
				m_pivotSource->toXML(L"c:pivotSource", writer);
			}
			if (NULL != m_protection)
			{
				m_protection->toXML(L"c:protection", writer);
			}
			if (NULL != m_chart)
			{
				m_chart->toXML(writer);
			}
			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (m_txPr.IsInit())
			{
				m_txPr->m_name = L"c:txPr";
				writer.WriteString(m_txPr->toXML());
			}
			if (NULL != m_externalData)
			{
				m_externalData->toXML(L"c:externalData", writer);
			}
			if (NULL != m_printSettings)
			{
				m_printSettings->toXML(L"c:printSettings", writer);
			}
			if (NULL != m_userShapes)
			{
				m_userShapes->toXML(L"c:userShapes", writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_ChartSpace::getType() { return et_ct_ChartSpace; }

		CT_RelId::CT_RelId()
		{
		}
		CT_RelId::~CT_RelId()
		{
		}
		void CT_RelId::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			ReadAttributes(oReader);

			if (!oReader.IsEmptyNode())
				oReader.ReadTillEnd();
		}
		void CT_RelId::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			
			if ( m_id.IsInit())
			{
				WritingStringAttrEncodeXmlString(L"r:id", *m_id);
			}
			writer.WriteString(L" xmlns:c=\"http://schemas.openxmlformats.org/drawingml/2006/chart\" xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:c14=\"http://schemas.microsoft.com/office/drawing/2007/8/2/chart\"");
			writer.WriteString(L"/>");
		}
		EElementType CT_RelId::getType() { return et_ct_relid; }
		
		void CT_RelId::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start_No_NS(oReader)
				if (L"id" == wsName)
				{
					m_id = oReader.GetText();
					break;
				}
			WritingElement_ReadAttributes_End_No_NS(oReader)
		}
		CT_PageSetup::CT_PageSetup()
		{
		}
		CT_PageSetup::~CT_PageSetup()
		{
		}
		void CT_PageSetup::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);

			if (!oReader.IsEmptyNode())
				oReader.ReadTillEnd();
		}
		void CT_PageSetup::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			if (m_paperSize.IsInit())
			{
				WritingStringAttrInt(L"paperSize", *m_paperSize);
			}
			if (m_paperHeight.IsInit())
			{
				WritingStringAttrEncodeXmlString(L"paperHeight", *m_paperHeight);
			}
			if (m_paperWidth.IsInit())
			{
				WritingStringAttrEncodeXmlString(L"paperWidth", *m_paperWidth);
			}
			if (m_firstPageNumber.IsInit())
			{
				WritingStringAttrInt(L"firstPageNumber", *m_firstPageNumber);
			}
			if (m_orientation.IsInit())
			{
				WritingStringAttrString(L"orientation", m_orientation->ToString());
			}
			if (m_blackAndWhite.IsInit())
			{
				std::wstring sVal;
				if (*m_blackAndWhite)
					sVal = L"1";
				else
					sVal = L"0";
				WritingStringAttrString(L"blackAndWhite", sVal);
			}
			if (m_draft.IsInit())
			{
				std::wstring sVal;
				if (*m_draft)
					sVal = L"1";
				else
					sVal = L"0";
				WritingStringAttrString(L"draft", sVal);
			}
			if (m_useFirstPageNumber.IsInit())
			{
				std::wstring sVal;
				if (*m_useFirstPageNumber)
					sVal = L"1";
				else
					sVal = L"0";
				WritingStringAttrString(L"useFirstPageNumber", sVal);
			}
			if (m_horizontalDpi.IsInit())
			{
				WritingStringAttrInt(L"horizontalDpi", *m_horizontalDpi);
			}
			if (m_verticalDpi.IsInit())
			{
				WritingStringAttrInt(L"verticalDpi", *m_verticalDpi);
			}
			if (m_copies.IsInit())
			{
				WritingStringAttrInt(L"copies", *m_copies);
			}
			writer.WriteString(L"/>");
		}
		EElementType CT_PageSetup::getType() { return et_ct_pagesetup; }
		void CT_PageSetup::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start_No_NS(oReader)
				WritingElement_ReadAttributes_Read_if(oReader, L"paperSize", m_paperSize)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"paperHeight", m_paperHeight)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"paperWidth", m_paperWidth)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"firstPageNumber", m_firstPageNumber)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"orientation", m_orientation)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"blackAndWhite", m_blackAndWhite)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"draft", m_draft)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"useFirstPageNumber", m_useFirstPageNumber)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"horizontalDpi", m_horizontalDpi)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"verticalDpi", m_draft)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"copies", m_copies)
			WritingElement_ReadAttributes_End_No_NS(oReader)
		}
		CT_PageMargins::CT_PageMargins()
		{
		}
		CT_PageMargins::~CT_PageMargins()
		{
		}
		void CT_PageMargins::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			ReadAttributes(oReader);

			if (!oReader.IsEmptyNode())
				oReader.ReadTillEnd();
		}
		void CT_PageMargins::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			if (NULL != m_l.IsInit())
			{
				WritingStringAttrDouble(L"l", *m_l);
			}
			if (m_r.IsInit())
			{
				WritingStringAttrDouble(L"r", *m_r);
			}
			if (m_t.IsInit())
			{
				WritingStringAttrDouble(L"t", *m_t);
			}
			if (m_b.IsInit())
			{
				WritingStringAttrDouble(L"b", *m_b);
			}
			if (m_header.IsInit())
			{
				WritingStringAttrDouble(L"header", *m_header);
			}
			if (m_footer.IsInit())
			{
				WritingStringAttrDouble(L"footer", *m_footer);
			}
			writer.WriteString(L"/>");
		}
		EElementType CT_PageMargins::getType() { return et_ct_pagemargins; }

		void CT_PageMargins::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start_No_NS(oReader)
				WritingElement_ReadAttributes_Read_if(oReader, L"l", m_l)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"r", m_r)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"t", m_t)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"b", m_b)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"header", m_header)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"footer", m_footer)
			WritingElement_ReadAttributes_End_No_NS(oReader)
		}
		CT_HeaderFooter::CT_HeaderFooter()
		{
		}
		CT_HeaderFooter::~CT_HeaderFooter()
		{
		}
		void CT_HeaderFooter::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			ReadAttributes(oReader);

			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"oddHeader" == sName)
				{
					std::wstring* pNewElem = new std::wstring;
					std::wstring sVal = oReader.GetText3();
					*pNewElem = sVal;
					m_oddHeader = pNewElem;
				}
				else if (L"oddFooter" == sName)
				{
					m_oddFooter = oReader.GetText3();
				}
				else if (L"evenHeader" == sName)
				{
					m_evenHeader = oReader.GetText3();
				}
				else if (L"evenFooter" == sName)
				{
					m_evenFooter = oReader.GetText3();
				}
				else if (L"firstHeader" == sName)
				{
					m_firstHeader = oReader.GetText3();
				}
				else if (L"firstFooter" == sName)
				{
					m_firstFooter = oReader.GetText3();
				}
			}
		}
		void CT_HeaderFooter::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			
			if (m_alignWithMargins.IsInit())
			{
				std::wstring sVal;
				if (*m_alignWithMargins)
					sVal = L"1";
				else
					sVal = L"0";
				WritingStringAttrString(L"alignWithMargins", sVal);
			}
			if (m_differentOddEven.IsInit())
			{
				std::wstring sVal;
				if (*m_differentOddEven)
					sVal = L"1";
				else
					sVal = L"0";
				WritingStringAttrString(L"differentOddEven", sVal);
			}
			if (m_differentFirst.IsInit())
			{
				std::wstring sVal;
				if (*m_differentFirst)
					sVal = L"1";
				else
					sVal = L"0";
				WritingStringAttrString(L"differentFirst", sVal);
			}
			writer.WriteString(L">");
			if (m_oddHeader.IsInit())
			{
				if (std::wstring::npos != m_oddHeader->find(' ')&&(  m_oddHeader->at(0) == ' ' || m_oddHeader->at(m_oddHeader->size()-1) == ' ')
				 || std::wstring::npos != m_oddHeader->find('\n')&&(  m_oddHeader->at(0) == '\n' || m_oddHeader->at(m_oddHeader->size()-1) == '\n'))
					writer.WriteString(L"<c:oddHeader xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:oddHeader>");
				writer.WriteEncodeXmlString(*m_oddHeader);
				writer.WriteString(L"</c:oddHeader>");
			}
			if (m_oddFooter.IsInit())
			{
				if (std::wstring::npos != m_oddFooter->find(' ')&&(  m_oddFooter->at(0) == ' ' || m_oddFooter->at(m_oddFooter->size()-1) == ' ')
				 || std::wstring::npos != m_oddFooter->find('\n')&&(  m_oddFooter->at(0) == '\n' || m_oddFooter->at(m_oddFooter->size()-1) == '\n'))
					writer.WriteString(L"<c:oddFooter xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:oddFooter>");
				writer.WriteEncodeXmlString(*m_oddFooter);
				writer.WriteString(L"</c:oddFooter>");
			}
			if (m_evenHeader.IsInit())
			{
				if (std::wstring::npos != m_evenHeader->find(' ')&&(  m_evenHeader->at(0) == ' ' || m_evenHeader->at(m_evenHeader->size()-1) == ' ')
				 || std::wstring::npos != m_evenHeader->find('\n')&&(  m_evenHeader->at(0) == '\n' || m_evenHeader->at(m_evenHeader->size()-1) == '\n'))
					writer.WriteString(L"<c:evenHeader xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:evenHeader>");
				writer.WriteEncodeXmlString(*m_evenHeader);
				writer.WriteString(L"</c:evenHeader>");
			}
			if ( m_evenFooter.IsInit())
			{
				if (std::wstring::npos != m_evenFooter->find(' ')&&(  m_evenFooter->at(0) == ' ' || m_evenFooter->at(m_evenFooter->size()-1) == ' ')
				 || std::wstring::npos != m_evenFooter->find('\n')&&(  m_evenFooter->at(0) == '\n' || m_evenFooter->at(m_evenFooter->size()-1) == '\n'))
					writer.WriteString(L"<c:evenFooter xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:evenFooter>");
				writer.WriteEncodeXmlString(*m_evenFooter);
				writer.WriteString(L"</c:evenFooter>");
			}
			if (m_firstHeader.IsInit())
			{
				if (std::wstring::npos != m_firstHeader->find(' ')&&(  m_firstHeader->at(0) == ' ' || m_firstHeader->at(m_firstHeader->size()-1) == ' ')
				 || std::wstring::npos != m_firstHeader->find('\n')&&(  m_firstHeader->at(0) == '\n' || m_firstHeader->at(m_firstHeader->size()-1) == '\n'))
					writer.WriteString(L"<c:firstHeader xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:firstHeader>");
				writer.WriteEncodeXmlString(*m_firstHeader);
				writer.WriteString(L"</c:firstHeader>");
			}
			if (m_firstFooter.IsInit())
			{
				if (std::wstring::npos != m_firstFooter->find(' ')&&(  m_firstFooter->at(0) == ' ' || m_firstFooter->at(m_firstFooter->size()-1) == ' ')
				 || std::wstring::npos != m_firstFooter->find('\n')&&(  m_firstFooter->at(0) == '\n' || m_firstFooter->at(m_firstFooter->size()-1) == '\n'))
					writer.WriteString(L"<c:firstFooter xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:firstFooter>");
				writer.WriteEncodeXmlString(*m_firstFooter);
				writer.WriteString(L"</c:firstFooter>");
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_HeaderFooter::getType() { return et_ct_headerfooter; }
		
		void CT_HeaderFooter::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start_No_NS(oReader)
				WritingElement_ReadAttributes_Read_if(oReader, L"alignWithMargins", m_alignWithMargins)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"differentOddEven", m_differentOddEven)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"differentFirst", m_differentFirst)
			WritingElement_ReadAttributes_End_No_NS(oReader)
		}
		CT_PrintSettings::CT_PrintSettings()
		{
			m_headerFooter = NULL;
			m_pageMargins = NULL;
			m_pageSetup = NULL;
		}
		CT_PrintSettings::~CT_PrintSettings()
		{
			if (NULL != m_headerFooter)
				delete m_headerFooter;
			if (NULL != m_pageMargins)
				delete m_pageMargins;
			if (NULL != m_pageSetup)
				delete m_pageSetup;
		}
		void CT_PrintSettings::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"headerFooter" == sName)
				{
					CT_HeaderFooter* pNewElem = new CT_HeaderFooter;
					pNewElem->fromXML(oReader);
					m_headerFooter = pNewElem;
				}
				else if (L"pageMargins" == sName)
				{
					CT_PageMargins* pNewElem = new CT_PageMargins;
					pNewElem->fromXML(oReader);
					m_pageMargins = pNewElem;
				}
				else if (L"pageSetup" == sName)
				{
					CT_PageSetup* pNewElem = new CT_PageSetup;
					pNewElem->fromXML(oReader);
					m_pageSetup = pNewElem;
				}
			}
		}
		void CT_PrintSettings::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (NULL != m_headerFooter)
			{
				std::wstring sNodeName = L"c:headerFooter";
				m_headerFooter->toXML(sNodeName, writer);
			}
			if (NULL != m_pageMargins)
			{
				std::wstring sNodeName = L"c:pageMargins";
				m_pageMargins->toXML(sNodeName, writer);
			}
			if (NULL != m_pageSetup)
			{
				std::wstring sNodeName = L"c:pageSetup";
				m_pageSetup->toXML(sNodeName, writer);
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_PrintSettings::getType() { return et_ct_printsettings; }
		
		CT_ExternalData::CT_ExternalData()
		{
		}
		CT_ExternalData::~CT_ExternalData()
		{
		}
		void CT_ExternalData::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);

			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"autoUpdate" == sName)
				{
					m_autoUpdate = oReader;
				}
			}
		}
		void CT_ExternalData::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			if (m_id.IsInit())
			{
				WritingStringAttrEncodeXmlString(L"r:id", *m_id);
			}
			writer.WriteString(L">");
			m_autoUpdate.toXML(L"c:autoUpdate", writer);

			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_ExternalData::getType() { return et_ct_externaldata; }
		void CT_ExternalData::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start_No_NS(oReader)
				if (L"id" == wsName)
				{
					m_id = oReader.GetText();
				}
			WritingElement_ReadAttributes_End_No_NS(oReader)
		}

		CT_LegendEntry::CT_LegendEntry()
		{
		}
		CT_LegendEntry::~CT_LegendEntry()
		{
		}
		void CT_LegendEntry::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"idx" == sName)
				{
					m_idx = oReader;
				}
				else if (L"delete" == sName)
				{
					m_delete = oReader;
				}
				else if (L"txPr" == sName)
				{
					m_txPr = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_LegendEntry::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_idx.toXML(L"c:idx", writer);

			m_delete.toXML(L"c:delete", writer);

			if (m_txPr.IsInit())
			{
				m_txPr->m_name = L"c:txPr";
				writer.WriteString(m_txPr->toXML());
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_LegendEntry::getType() { return et_ct_LegendEntry; }
		
		ST_DispBlanksAs CDispBlanksAs::FromString(const std::wstring &sValue)
		{
			FromXml_ST_DispBlanksAs(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CDispBlanksAs::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_DispBlanksAs(m_eValue, sEnumVal);
			return sEnumVal;
		}
		ST_PageSetupOrientation CPageSetupOrientation::FromString(const std::wstring &sValue)
		{
			FromXml_ST_PageSetupOrientation(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CPageSetupOrientation::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_PageSetupOrientation(m_eValue, sEnumVal);
			return sEnumVal;
		}		
		ST_LegendPos CLegendPos::FromString(const std::wstring &sValue)
		{
			FromXml_ST_LegendPos(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CLegendPos::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_LegendPos(m_eValue, sEnumVal);
			return sEnumVal;
		}		
		ST_SizeRepresents CSizeRepresents::FromString(const std::wstring &sValue)
		{
			FromXml_ST_SizeRepresents(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CSizeRepresents::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_SizeRepresents(m_eValue, sEnumVal);
			return sEnumVal;
		}
		CT_Legend::CT_Legend()
		{
			m_layout = NULL;
		}
		CT_Legend::~CT_Legend()
		{
			for (size_t i = 0; i < m_legendEntry.size(); ++i)
				delete m_legendEntry[i];
			m_legendEntry.clear();
			
			if (NULL != m_layout)
				delete m_layout;
		}
		void CT_Legend::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"legendPos" == sName)
				{
					m_legendPos = oReader;
				}
				else if (L"legendEntry" == sName)
				{
					CT_LegendEntry* pNewElem = new CT_LegendEntry;
					pNewElem->fromXML(oReader);
					m_legendEntry.push_back(pNewElem);
				}
				else if (L"layout" == sName)
				{
					CT_Layout* pNewElem = new CT_Layout;
					pNewElem->fromXML(oReader);
					m_layout = pNewElem;
				}
				else if (L"overlay" == sName)
				{
					m_overlay = oReader;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"txPr" == sName)
				{
					m_txPr = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Legend::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");

			m_legendPos.toXML(L"c:legendPos", writer);

			for (size_t i = 0; i < m_legendEntry.size(); ++i)
			{
				CT_LegendEntry* pElem = m_legendEntry[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:legendEntry";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_layout)
			{
				std::wstring sNodeName = L"c:layout";
				m_layout->toXML(sNodeName, writer);
			}
			m_overlay.toXML(L"c:overlay", writer);

			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (m_txPr.IsInit())
			{
				m_txPr->m_name = L"c:txPr";
				writer.WriteString(m_txPr->toXML());
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Legend::getType() { return et_ct_Legend; }
		CT_Layout::CT_Layout()
		{
			m_manualLayout = NULL;
		}
		CT_Layout::~CT_Layout()
		{
			if (NULL != m_manualLayout)
				delete m_manualLayout;
		}
		void CT_Layout::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"manualLayout" == sName)
				{
					CT_ManualLayout* pNewElem = new CT_ManualLayout;
					pNewElem->fromXML(oReader);
					m_manualLayout = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Layout::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (NULL != m_manualLayout)
			{
				std::wstring sNodeName = L"c:manualLayout";
				m_manualLayout->toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Layout::getType() { return et_ct_layout; }
		CT_ManualLayout::CT_ManualLayout()
		{
		}
		CT_ManualLayout::~CT_ManualLayout()
		{
		}
		void CT_ManualLayout::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"layoutTarget" == sName)
				{
					m_layoutTarget = oReader;
				}
				else if (L"xMode" == sName)
				{
					m_xMode = oReader;
				}
				else if (L"yMode" == sName)
				{
					m_yMode = oReader;
				}
				else if (L"wMode" == sName)
				{
					m_wMode = oReader;
				}
				else if (L"hMode" == sName)
				{
					m_hMode = oReader;
				}
				else if (L"x" == sName)
				{
					m_x = oReader;
				}
				else if (L"y" == sName)
				{
					m_y = oReader;
				}
				else if (L"w" == sName)
				{
					m_w = oReader;
				}
				else if (L"h" == sName)
				{
					m_h = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_ManualLayout::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_layoutTarget.toXML(L"c:layoutTarget", writer);
			m_xMode.toXML(L"c:xMode", writer);
			m_yMode.toXML(L"c:yMode", writer);
			m_wMode.toXML(L"c:wMode", writer);
			m_hMode.toXML(L"c:hMode", writer);
			m_x.toXML(L"c:x", writer);
			m_y.toXML(L"c:y", writer);
			m_w.toXML(L"c:w", writer);
			m_h.toXML(L"c:h", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_ManualLayout::getType() { return et_ct_manuallayout; }
		
		ST_LayoutTarget CLayoutTarget::FromString(const std::wstring &sValue)
		{
			if ((L"inner") == sValue) this->m_eValue = st_layouttargetINNER;
			else if ((L"outer") == sValue) this->m_eValue = st_layouttargetOUTER;
			else this->m_eValue = st_layouttargetINNER;

			return this->m_eValue;
		}

		std::wstring CLayoutTarget::ToString() const
		{
			switch (this->m_eValue)
			{
			case st_layouttargetINNER: return (L"inner");
			case st_layouttargetOUTER: return (L"outer");
			default: return (L"inner");
			}
		}

		std::wstring CLayoutMode::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_LayoutMode(m_eValue, sEnumVal);
			return sEnumVal;
		}		
		ST_LayoutMode CLayoutMode::FromString(const std::wstring &sValue)
		{
			FromXml_ST_LayoutMode(sValue,  this->m_eValue);
			return this->m_eValue;
		}

		CT_DTable::CT_DTable()
		{
		}
		CT_DTable::~CT_DTable()
		{
		}
		void CT_DTable::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"showHorzBorder" == sName)
				{
					m_showHorzBorder = oReader;
				}
				else if (L"showVertBorder" == sName)
				{
					m_showVertBorder = oReader;
				}
				else if (L"showOutline" == sName)
				{
					m_showOutline = oReader;
				}
				else if (L"showKeys" == sName)
				{
					m_showKeys = oReader;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"txPr" == sName)
				{
					m_txPr = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_DTable::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_showHorzBorder.toXML(L"c:showHorzBorder", writer);
			m_showVertBorder.toXML(L"c:showVertBorder", writer);
			m_showOutline.toXML(L"c:showOutline", writer);
			m_showKeys.toXML(L"c:showKeys", writer);

			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (m_txPr.IsInit())
			{
				m_txPr->m_name = L"c:txPr";
				writer.WriteString(m_txPr->toXML());
			}
			if (m_extLst.IsInit())
			{
				std::wstring sNodeName = L"c:extLst";
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_DTable::getType() { return et_ct_dtable; }

		CBaseAx::CBaseAx()
		{
			m_scaling = NULL;
			m_majorGridlines = NULL;
			m_minorGridlines = NULL;
			m_title = NULL;
			m_numFmt = NULL;
		}
		CBaseAx::~CBaseAx()
		{
			if (NULL != m_scaling)
				delete m_scaling;
			if (NULL != m_majorGridlines)
				delete m_majorGridlines;
			if (NULL != m_minorGridlines)
				delete m_minorGridlines;
			if (NULL != m_title)
				delete m_title;
			if (NULL != m_numFmt)
				delete m_numFmt;
		}
		bool CBaseAx::fromXML(const std::wstring & sName, XmlUtils::CXmlLiteReader& oReader)
		{
			bool res = true;
			if (L"axId" == sName)
			{
				m_axId = oReader;
			}
			else if (L"scaling" == sName)
			{
				CT_Scaling* pNewElem = new CT_Scaling;
				pNewElem->fromXML(oReader);
				m_scaling = pNewElem;
			}
			else if (L"delete" == sName)
			{
				m_delete = oReader;
			}
			else if (L"axPos" == sName)
			{
				m_axPos = oReader;
			}
			else if (L"majorGridlines" == sName)
			{
				CT_ChartLines* pNewElem = new CT_ChartLines;
				pNewElem->fromXML(oReader);
				m_majorGridlines = pNewElem;
			}
			else if (L"minorGridlines" == sName)
			{
				CT_ChartLines* pNewElem = new CT_ChartLines;
				pNewElem->fromXML(oReader);
				m_minorGridlines = pNewElem;
			}
			else if (L"title" == sName)
			{
				CT_Title* pNewElem = new CT_Title;
				pNewElem->fromXML(oReader);
				m_title = pNewElem;
			}
			else if (L"numFmt" == sName)
			{
				CT_NumFmt* pNewElem = new CT_NumFmt;
				pNewElem->fromXML(oReader);
				m_numFmt = pNewElem;
			}
			else if (L"majorTickMark" == sName)
			{
				m_majorTickMark = oReader;
			}
			else if (L"minorTickMark" == sName)
			{
				m_minorTickMark = oReader;
			}
			else if (L"tickLblPos" == sName)
			{
				m_tickLblPos = oReader;
			}
			else if (L"spPr" == sName)
			{
				m_spPr = oReader;
			}
			else if (L"txPr" == sName)
			{
				m_txPr = oReader;
			}
			else if (L"crossAx" == sName)
			{
				m_crossAx = oReader;
			}
			else if (L"crosses" == sName)
			{
				m_crosses = oReader;
			}
			else if (L"crossesAt" == sName)
			{
				m_crossesAt = oReader;
			}
			else if (L"extLst" == sName)
			{
				m_extLst = oReader;
			}
			else
				res = false;
			return res;
		}
		void CBaseAx::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			m_axId.toXML(L"c:axId", writer);
			m_scaling->toXML(L"c:scaling", writer);
			m_delete.toXML(L"c:delete", writer);
			m_axPos.toXML(L"c:axPos", writer);

			if (NULL != m_majorGridlines)
			{
				m_majorGridlines->toXML(L"c:majorGridlines", writer);
			}
			if (NULL != m_minorGridlines)
			{
				m_minorGridlines->toXML(L"c:minorGridlines", writer);
			}
			if (NULL != m_title)
			{
				std::wstring sNodeName = L"c:title";
				m_title->toXML(sNodeName, writer);
			}
			if (NULL != m_numFmt)
			{
				std::wstring sNodeName = L"c:numFmt";
				m_numFmt->toXML(sNodeName, writer);
			}
			m_majorTickMark.toXML(L"c:majorTickMark", writer);
			m_minorTickMark.toXML(L"c:minorTickMark", writer);
			m_tickLblPos.toXML(L"c:tickLblPos", writer);

			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (m_txPr.IsInit())
			{
				m_txPr->m_name = L"c:txPr";
				writer.WriteString(m_txPr->toXML());
			}
			m_crossAx.toXML(L"c:crossAx", writer);
			m_crosses.toXML(L"c:crosses", writer);
			m_crossesAt.toXML(L"c:crossesAt", writer);
		}
		CT_SerAx::CT_SerAx()
		{
		}
		CT_SerAx::~CT_SerAx()
		{
		}
		void CT_SerAx::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());

				if (CBaseAx::fromXML(sName, oReader))
				{

				}
				else if (L"tickLblSkip" == sName)
				{
					m_tickLblSkip = oReader;
				}
				else if (L"tickMarkSkip" == sName)
				{
					m_tickMarkSkip = oReader;
				}
			}
		}
		void CT_SerAx::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			CBaseAx::toXML(writer);
			
			if (m_tickLblSkip.IsInit())
			{
				std::wstring sNodeName = L"c:tickLblSkip";
				m_tickLblSkip.toXML(sNodeName, writer);
			}
			if (m_tickMarkSkip.IsInit())
			{
				std::wstring sNodeName = L"c:tickMarkSkip";
				m_tickMarkSkip.toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_SerAx::getType() { return et_ct_serax; }
		CT_Scaling::CT_Scaling()
		{
		}
		CT_Scaling::~CT_Scaling()
		{
		}
		void CT_Scaling::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"logBase" == sName)
				{
					m_logBase = oReader;
				}
				else if (L"orientation" == sName)
				{
					m_orientation = oReader;
				}
				else if (L"max" == sName)
				{
					m_max = oReader;
				}
				else if (L"min" == sName)
				{
					m_min = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Scaling::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_logBase.toXML(L"c:logBase", writer);
			m_orientation.toXML(L"c:orientation", writer);
			m_max.toXML(L"c:max", writer);
			m_min.toXML(L"c:min", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Scaling::getType() { return et_ct_scaling; }

		ST_Orientation COrientation::FromString(const std::wstring &sValue)
		{
			FromXml_ST_Orientation(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring COrientation::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_Orientation(m_eValue, sEnumVal);
			return sEnumVal;
		}

		ST_AxPos CAxPos::FromString(const std::wstring &sValue)
		{
			FromXml_ST_AxPos(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CAxPos::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_AxPos(m_eValue, sEnumVal);
			return sEnumVal;
		}

		CT_ChartLines::CT_ChartLines()
		{
		}
		CT_ChartLines::~CT_ChartLines()
		{
		}
		void CT_ChartLines::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
			}
		}
		void CT_ChartLines::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_ChartLines::getType() { return et_ct_chartlines; }
		CT_Title::CT_Title()
		{
			m_tx = NULL;
			m_layout = NULL;
		}
		CT_Title::~CT_Title()
		{
			if (NULL != m_tx)
				delete m_tx;
			if (NULL != m_layout)
				delete m_layout;
		}
		void CT_Title::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"tx" == sName)
				{
					CT_Tx* pNewElem = new CT_Tx;
					pNewElem->fromXML(oReader);
					m_tx = pNewElem;
				}
				else if (L"layout" == sName)
				{
					CT_Layout* pNewElem = new CT_Layout;
					pNewElem->fromXML(oReader);
					m_layout = pNewElem;
				}
				else if (L"overlay" == sName)
				{
					m_overlay = oReader;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"txPr" == sName)
				{
					m_txPr = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Title::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (NULL != m_tx)
			{
				std::wstring sNodeName = L"c:tx";
				m_tx->toXML(sNodeName, writer);
			}
			if (NULL != m_layout)
			{
				std::wstring sNodeName = L"c:layout";
				m_layout->toXML(sNodeName, writer);
			}
			m_overlay.toXML(L"c:overlay", writer);

			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (m_txPr.IsInit())
			{
				m_txPr->m_name = L"c:txPr";
				writer.WriteString(m_txPr->toXML());
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Title::getType() { return et_ct_title; }
		CT_Tx::CT_Tx()
		{
			m_strRef = NULL;
		}
		CT_Tx::~CT_Tx()
		{
			if (NULL != m_strRef)
				delete m_strRef;
		}
		std::wstring CT_Tx::toXML() const
		{
			return L"";
		}
		void CT_Tx::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			toXML(L"c:tx", writer);
		}
		void CT_Tx::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"rich" == sName)
				{
					m_oRich = oReader;
				}
				else if (L"strRef" == sName)
				{
					CT_StrRef* pNewElem = new CT_StrRef;
					pNewElem->fromXML(oReader);
					m_strRef = pNewElem;
				}
			}
		}
		void CT_Tx::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (m_oRich.IsInit())
			{
				m_oRich->m_name = L"c:rich";
				writer.WriteString(m_oRich->toXML());
			}
			if (NULL != m_strRef)
			{
				std::wstring sNodeName = L"c:strRef";
				m_strRef->toXML(sNodeName, writer);
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Tx::getType() { return et_ct_tx; }
		CT_StrRef::CT_StrRef()
		{
			m_strCache = NULL;
		}
		CT_StrRef::~CT_StrRef()
		{
			if (NULL != m_strCache)
				delete m_strCache;
		}
		void CT_StrRef::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"f" == sName)
				{
					m_f = oReader.GetText3();
				}
				else if (L"strCache" == sName)
				{
					CT_StrData* pNewElem = new CT_StrData;
					pNewElem->fromXML(oReader);
					m_strCache = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_StrRef::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (m_f.IsInit())
			{
				if (std::wstring::npos != m_f->find(' ')&&(  m_f->at(0) == ' ' || m_f->at(m_f->size()-1) == ' ')
				 || std::wstring::npos != m_f->find('\n')&&(  m_f->at(0) == '\n' || m_f->at(m_f->size()-1) == '\n'))
					writer.WriteString(L"<c:f xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:f>");
				writer.WriteEncodeXmlString(*m_f);
				writer.WriteString(L"</c:f>");
			}
			if (NULL != m_strCache)
			{
				std::wstring sNodeName = L"c:strCache";
				m_strCache->toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_StrRef::getType() { return et_ct_strref; }
		CT_StrData::CT_StrData()
		{
		}
		CT_StrData::~CT_StrData()
		{
			for (size_t i = 0; i < m_pt.size(); ++i)
				delete m_pt[i];
			m_pt.clear();
		}
		void CT_StrData::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"ptCount" == sName)
				{
					m_ptCount = oReader;
				}
				else if (L"pt" == sName)
				{
					CT_StrVal* pNewElem = new CT_StrVal;
					pNewElem->fromXML(oReader);
					m_pt.push_back(pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		std::wstring CT_StrData::toXML() const
		{
			return L"";
		}
		void CT_StrData::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			toXML(L"c:strData", writer);
		}
		void CT_StrData::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_ptCount.toXML(L"c:ptCount", writer);

			for (size_t i = 0; i < m_pt.size(); ++i)
			{
				CT_StrVal* pElem = m_pt[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:pt";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_StrData::getType() { return et_ct_strdata; }
		CT_StrVal::CT_StrVal()
		{
		}
		CT_StrVal::~CT_StrVal()
		{
		}
		void CT_StrVal::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);

			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"v" == sName)
				{
					m_v = oReader.GetText3();
				}
			}
		}
		void CT_StrVal::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			if (m_idx.IsInit())
			{
				WritingStringAttrInt(L"idx", *m_idx);
			}
			writer.WriteString(L">");
			
			if (m_v.IsInit())
			{
				if (std::wstring::npos != m_v->find(' ')&&(  m_v->at(0) == ' ' || m_v->at(m_v->size()-1) == ' ')
				 || std::wstring::npos != m_v->find('\n')&&(  m_v->at(0) == '\n' || m_v->at(m_v->size()-1) == '\n'))
					writer.WriteString(L"<c:v xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:v>");
				writer.WriteEncodeXmlString(*m_v);
				writer.WriteString(L"</c:v>");
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_StrVal::getType() { return et_ct_strval; }
		void CT_StrVal::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start_No_NS(oReader)
				if (L"idx" == wsName)
				{
					m_idx = oReader.GetText();
				}
			WritingElement_ReadAttributes_End_No_NS(oReader)
		}
		CT_NumFmt::CT_NumFmt()
		{
		}
		CT_NumFmt::~CT_NumFmt()
		{
		}
		void CT_NumFmt::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);

			if (!oReader.IsEmptyNode())
				oReader.ReadTillEnd();
		}
		void CT_NumFmt::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			if (m_formatCode.IsInit())
			{
				WritingStringAttrEncodeXmlString(L"formatCode", *m_formatCode);
			}
			if (m_sourceLinked.IsInit())
			{
				std::wstring sVal;
				if (*m_sourceLinked)
					sVal = L"1";
				else
					sVal = L"0";
				WritingStringAttrString(L"sourceLinked", sVal);
			}
			writer.WriteString(L"/>");
		}
		EElementType CT_NumFmt::getType() { return et_ct_numfmt; }
		void CT_NumFmt::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start_No_NS(oReader)
				if (L"formatCode" == wsName)
				{
					m_formatCode = oReader.GetText();
				}
				else if (L"sourceLinked" == wsName)
				{
					m_sourceLinked = oReader.GetText();
				}
			WritingElement_ReadAttributes_End_No_NS(oReader)
		}
		ST_TickMark CTickMark::FromString(const std::wstring &sValue)
		{
			FromXml_ST_TickMark(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CTickMark::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_TickMark(m_eValue, sEnumVal);
			return sEnumVal;
		}
		ST_TickLblPos CTickLblPos::FromString(const std::wstring &sValue)
		{
			FromXml_ST_TickLblPos(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CTickLblPos::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_TickLblPos(m_eValue, sEnumVal);
			return sEnumVal;
		}
		ST_Crosses CCrosses::FromString(const std::wstring &sValue)
		{
			FromXml_ST_Crosses(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CCrosses::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_Crosses(m_eValue, sEnumVal);
			return sEnumVal;
		}
		ST_TimeUnit CTimeUnit::FromString(const std::wstring &sValue)
		{
			FromXml_ST_TimeUnit(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CTimeUnit::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_TimeUnit(m_eValue, sEnumVal);
			return sEnumVal;
		}

		CT_DateAx::CT_DateAx()
		{
		}
		CT_DateAx::~CT_DateAx()
		{
		}
		void CT_DateAx::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (CBaseAx::fromXML(sName, oReader))
				{

				}
				else if (L"auto" == sName)
				{
					m_auto = oReader;
				}
				else if (L"lblOffset" == sName)
				{
					m_lblOffset = oReader;
				}
				else if (L"baseTimeUnit" == sName)
				{
					m_baseTimeUnit = oReader;
				}
				else if (L"majorUnit" == sName)
				{
					m_majorUnit = oReader;
				}
				else if (L"majorTimeUnit" == sName)
				{
					m_majorTimeUnit = oReader;
				}
				else if (L"minorUnit" == sName)
				{
					m_minorUnit = oReader;
				}
				else if (L"minorTimeUnit" == sName)
				{
					m_minorTimeUnit = oReader;
				}
			}
		}
		void CT_DateAx::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");

			CBaseAx::toXML(writer);
			
			m_auto.toXML(L"c:auto", writer);
			m_lblOffset.toXML(L"c:lblOffset", writer);
			m_baseTimeUnit.toXML(L"c:baseTimeUnit", writer);
			m_majorUnit.toXML(L"c:majorUnit", writer);
			m_majorTimeUnit.toXML(L"c:majorTimeUnit", writer);
			m_minorUnit.toXML(L"c:minorUnit", writer);
			m_minorTimeUnit.toXML(L"c:minorTimeUnit", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_DateAx::getType() { return et_ct_dateax; }
		
		ST_LblAlgn CLblAlgn::FromString(const std::wstring &sValue)
		{
			FromXml_ST_LblAlgn(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CLblAlgn::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_LblAlgn(m_eValue, sEnumVal);
			return sEnumVal;
		}
		CT_CatAx::CT_CatAx()
		{
		}
		CT_CatAx::~CT_CatAx()
		{
		}
		void CT_CatAx::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (CBaseAx::fromXML(sName, oReader))
				{

				}
				else if (L"auto" == sName)
				{
					m_auto = oReader;
				}
				else if (L"lblAlgn" == sName)
				{
					m_lblAlgn = oReader;
				}
				else if (L"lblOffset" == sName)
				{
					m_lblOffset = oReader;
				}
				else if (L"tickLblSkip" == sName)
				{
					m_tickLblSkip = oReader;
				}
				else if (L"tickMarkSkip" == sName)
				{
					m_tickMarkSkip = oReader;
				}
				else if (L"noMultiLvlLbl" == sName)
				{
					m_noMultiLvlLbl = oReader;
				}
			}
		}
		void CT_CatAx::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			CBaseAx::toXML(writer);

			m_auto.toXML(L"c:auto", writer);
			m_lblAlgn.toXML(L"c:lblAlgn", writer);
			m_lblOffset.toXML(L"c:lblOffset", writer);
			if (m_tickLblSkip.IsInit())
			{
				m_tickLblSkip.toXML(L"c:tickLblSkip", writer);
			}
			if (m_tickMarkSkip.IsInit())
			{
				m_tickMarkSkip.toXML(L"c:tickMarkSkip", writer);
			}
			m_noMultiLvlLbl.toXML(L"c:noMultiLvlLbl", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_CatAx::getType() { return et_ct_catax; }
		CT_DispUnitsLbl::CT_DispUnitsLbl()
		{
			m_layout = NULL;
			m_tx = NULL;
		}
		CT_DispUnitsLbl::~CT_DispUnitsLbl()
		{
			if (NULL != m_layout)
				delete m_layout;
			if (NULL != m_tx)
				delete m_tx;
		}
		void CT_DispUnitsLbl::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"layout" == sName)
				{
					CT_Layout* pNewElem = new CT_Layout;
					pNewElem->fromXML(oReader);
					m_layout = pNewElem;
				}
				else if (L"tx" == sName)
				{
					CT_Tx* pNewElem = new CT_Tx;
					pNewElem->fromXML(oReader);
					m_tx = pNewElem;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"txPr" == sName)
				{
					m_txPr = oReader;
				}
			}
		}
		void CT_DispUnitsLbl::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (NULL != m_layout)
			{
				std::wstring sNodeName = L"c:layout";
				m_layout->toXML(sNodeName, writer);
			}
			if (NULL != m_tx)
			{
				std::wstring sNodeName = L"c:tx";
				m_tx->toXML(sNodeName, writer);
			}
			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (m_txPr.IsInit())
			{
				m_txPr->m_name = L"c:txPr";
				writer.WriteString(m_txPr->toXML());
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_DispUnitsLbl::getType() { return et_ct_dispunitslbl; }
		
		ST_BuiltInUnit CBuiltInUnit::FromString(const std::wstring &sValue)
		{
			FromXml_ST_BuiltInUnit(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CBuiltInUnit::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_BuiltInUnit(m_eValue, sEnumVal);
			return sEnumVal;
		}		
		
		CT_DispUnits::CT_DispUnits()
		{
			m_dispUnitsLbl = NULL;
		}
		CT_DispUnits::~CT_DispUnits()
		{
			if (NULL != m_dispUnitsLbl)
				delete m_dispUnitsLbl;
		}
		void CT_DispUnits::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"builtInUnit" == sName)
				{
					m_builtInUnit = oReader;
				}
				else if (L"custUnit" == sName)
				{
					m_custUnit = oReader;
				}
				else if (L"dispUnitsLbl" == sName)
				{
					CT_DispUnitsLbl* pNewElem = new CT_DispUnitsLbl;
					pNewElem->fromXML(oReader);
					m_dispUnitsLbl = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_DispUnits::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");

			m_builtInUnit.toXML(L"c:builtInUnit", writer);
			m_custUnit.toXML(L"c:custUnit", writer);

			if (NULL != m_dispUnitsLbl)
			{
				m_dispUnitsLbl->toXML(L"c:dispUnitsLbl", writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_DispUnits::getType() { return et_ct_dispunits; }
		
		ST_CrossBetween CCrossBetween::FromString(const std::wstring &sValue)
		{
			FromXml_ST_CrossBetween(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CCrossBetween::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_CrossBetween(m_eValue, sEnumVal);
			return sEnumVal;
		}
		CT_ValAx::CT_ValAx()
		{
			m_dispUnits = NULL;
		}
		CT_ValAx::~CT_ValAx()
		{
			if (m_dispUnits)
				delete m_dispUnits;
		}
		void CT_ValAx::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (CBaseAx::fromXML(sName, oReader))
				{

				}
				else if (L"crossBetween" == sName)
				{
					m_crossBetween = oReader;
				}
				else if (L"majorUnit" == sName)
				{
					m_majorUnit = oReader;
				}
				else if (L"minorUnit" == sName)
				{
					m_minorUnit = oReader;
				}
				else if (L"dispUnits" == sName)
				{
					CT_DispUnits* pNewElem = new CT_DispUnits;
					pNewElem->fromXML(oReader);
					m_dispUnits = pNewElem;
				}
			}
		}
		void CT_ValAx::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			CBaseAx::toXML(writer);

			m_crossBetween.toXML(L"c:crossBetween", writer);
			m_majorUnit.toXML(L"c:majorUnit", writer);
			m_minorUnit.toXML(L"c:minorUnit", writer);
			if (NULL != m_dispUnits)
			{
				m_dispUnits->toXML(L"c:dispUnits", writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_ValAx::getType() { return et_ct_valax; }

		CBaseSer::CBaseSer()
		{
			m_tx = NULL;
		}
		CBaseSer::~CBaseSer()
		{
			if (NULL != m_tx)
				delete m_tx;
		}
		bool CBaseSer::fromXML(const std::wstring sName, XmlUtils::CXmlLiteReader& oReader)
		{
			bool res = true;
			if (L"idx" == sName)
			{
				m_idx = oReader;
			}
			else if (L"order" == sName)
			{
				m_order = oReader;
			}
			else if (L"tx" == sName)
			{
				m_tx = new CT_SerTx;
				m_tx->fromXML(oReader);
			}
			else if (L"spPr" == sName)
			{
				m_spPr = oReader;
			}
			else if (L"extLst" == sName)
			{
				m_extLst = oReader;
			}
			else
				res = false;
			return res;
		}
		void CBaseSer::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			m_idx.toXML(L"c:idx", writer);
			m_order.toXML(L"c:order", writer);

			if (NULL != m_tx)
			{
				std::wstring sNodeName = L"c:tx";
				m_tx->toXML(sNodeName, writer);
			}
			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
		}

		CT_BubbleSer::CT_BubbleSer()
		{
			m_dLbls = NULL;
			m_xVal = NULL;
			m_yVal = NULL;
			m_bubbleSize = NULL;
		}
		CT_BubbleSer::~CT_BubbleSer()
		{
			for (size_t i = 0; i < m_dPt.size(); ++i)
				delete m_dPt[i];
			m_dPt.clear();

			if (NULL != m_dLbls)
				delete m_dLbls;
			for (size_t i = 0; i < m_trendline.size(); ++i)
				delete m_trendline[i];
			m_trendline.clear();
			for (size_t i = 0; i < m_errBars.size(); ++i)
				delete m_errBars[i];
			m_errBars.clear();
			if (NULL != m_xVal)
				delete m_xVal;
			if (NULL != m_yVal)
				delete m_yVal;
			if (NULL != m_bubbleSize)
				delete m_bubbleSize;
		}
		void CT_BubbleSer::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				
				if (CBaseSer::fromXML(sName, oReader))
				{

				}
				else if (L"invertIfNegative" == sName)
				{
					m_invertIfNegative = oReader;
				}
				else if (L"dPt" == sName)
				{
					CT_DPt* pNewElem = new CT_DPt;
					pNewElem->fromXML(oReader);
					m_dPt.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"trendline" == sName)
				{
					CT_Trendline* pNewElem = new CT_Trendline;
					pNewElem->fromXML(oReader);
					m_trendline.push_back(pNewElem);
				}
				else if (L"errBars" == sName)
				{
					CT_ErrBars* pNewElem = new CT_ErrBars;
					pNewElem->fromXML(oReader);
					m_errBars.push_back(pNewElem);
				}
				else if (L"xVal" == sName)
				{
					CT_AxDataSource* pNewElem = new CT_AxDataSource;
					pNewElem->fromXML(oReader);
					m_xVal = pNewElem;
				}
				else if (L"yVal" == sName)
				{
					CT_NumDataSource* pNewElem = new CT_NumDataSource;
					pNewElem->fromXML(oReader);
					m_yVal = pNewElem;
				}
				else if (L"bubbleSize" == sName)
				{
					CT_NumDataSource* pNewElem = new CT_NumDataSource;
					pNewElem->fromXML(oReader);
					m_bubbleSize = pNewElem;
				}
				else if (L"bubble3D" == sName)
				{
					m_bubble3D = oReader;
				}
			}
		}
		void CT_BubbleSer::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");

			CBaseSer::toXML(writer);
			
			m_invertIfNegative.toXML(L"c:invertIfNegative", writer);
			for (size_t i = 0; i < m_dPt.size(); ++i)
			{
				CT_DPt* pElem = m_dPt[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:dPt";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_dLbls)
			{
				std::wstring sNodeName = L"c:dLbls";
				m_dLbls->toXML(sNodeName, writer);
			}
			for (size_t i = 0; i < m_trendline.size(); ++i)
			{
				CT_Trendline* pElem = m_trendline[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:trendline";
					pElem->toXML(sNodeName, writer);
				}
			}
			for (size_t i = 0; i < m_errBars.size(); ++i)
			{
				CT_ErrBars* pElem = m_errBars[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:errBars";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_xVal)
			{
				std::wstring sNodeName = L"c:xVal";
				m_xVal->toXML(sNodeName, writer);
			}
			if (NULL != m_yVal)
			{
				std::wstring sNodeName = L"c:yVal";
				m_yVal->toXML(sNodeName, writer);
			}
			if (NULL != m_bubbleSize)
			{
				std::wstring sNodeName = L"c:bubbleSize";
				m_bubbleSize->toXML(sNodeName, writer);
			}
			m_bubble3D.toXML(L"c:bubble3D", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_BubbleSer::getType() { return et_ct_bubbleser; }
		CT_SerTx::CT_SerTx()
		{
			m_strRef = NULL;
		}
		CT_SerTx::~CT_SerTx()
		{
			if (NULL != m_strRef)
				delete m_strRef;
		}
		void CT_SerTx::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"strRef" == sName)
				{
					CT_StrRef* pNewElem = new CT_StrRef;
					pNewElem->fromXML(oReader);
					m_strRef = pNewElem;
				}
				else if (L"v" == sName)
				{
					m_v = oReader.GetText3();
				}
			}
		}
		void CT_SerTx::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (NULL != m_strRef)
			{
				std::wstring sNodeName = L"c:strRef";
				m_strRef->toXML(sNodeName, writer);
			}
			if (m_v.IsInit())
			{
				if (std::wstring::npos != m_v->find(' ')&&(  m_v->at(0) == ' ' || m_v->at(m_v->size()-1) == ' ')
				 || std::wstring::npos != m_v->find('\n')&&(  m_v->at(0) == '\n' || m_v->at(m_v->size()-1) == '\n'))
					writer.WriteString(L"<c:v xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:v>");
				writer.WriteEncodeXmlString(*m_v);
				writer.WriteString(L"</c:v>");
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_SerTx::getType() { return et_ct_sertx; }
		
		CT_DPt::CT_DPt()
		{
			m_marker = NULL;
			m_pictureOptions = NULL;
		}
		CT_DPt::~CT_DPt()
		{
			if (NULL != m_marker)
				delete m_marker;
			if (NULL != m_pictureOptions)
				delete m_pictureOptions;
		}
		void CT_DPt::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"idx" == sName)
				{
					m_idx = oReader;
				}
				else if (L"invertIfNegative" == sName)
				{
					m_invertIfNegative = oReader;
				}
				else if (L"marker" == sName)
				{
					CT_Marker* pNewElem = new CT_Marker;
					pNewElem->fromXML(oReader);
					m_marker = pNewElem;
				}
				else if (L"bubble3D" == sName)
				{
					m_bubble3D = oReader;
				}
				else if (L"explosion" == sName)
				{
					m_explosion = oReader;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"pictureOptions" == sName)
				{
					CT_PictureOptions* pNewElem = new CT_PictureOptions;
					pNewElem->fromXML(oReader);
					m_pictureOptions = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_DPt::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_idx.toXML(L"c:idx", writer);
			m_invertIfNegative.toXML(L"c:invertIfNegative", writer);

			if (NULL != m_marker)
			{
				m_marker->toXML(L"c:marker", writer);
			}
			m_bubble3D.toXML(L"c:bubble3D", writer);
			m_explosion.toXML(L"c:explosion", writer);

			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (NULL != m_pictureOptions)
			{
				m_pictureOptions->toXML(L"c:pictureOptions", writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_DPt::getType() { return et_ct_dpt; }
		CT_Marker::CT_Marker()
		{
		}
		CT_Marker::~CT_Marker()
		{
		}
		void CT_Marker::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"symbol" == sName)
				{
					m_symbol = oReader;
				}
				else if (L"size" == sName)
				{
					m_size = oReader;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		std::wstring CT_Marker::toXML() const
		{
			return L"";
		}
		void CT_Marker::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			toXML(L"c:marker", writer);
		}
		void CT_Marker::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_symbol.toXML(L"c:symbol", writer);
			m_size.toXML(L"c:size", writer);

			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Marker::getType() { return et_ct_marker; }

		ST_MarkerStyle CMarkerStyle::FromString(const std::wstring &sValue)
		{
			FromXml_ST_MarkerStyle(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CMarkerStyle::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_MarkerStyle(m_eValue, sEnumVal);
			return sEnumVal;
		}

		CT_PictureOptions::CT_PictureOptions()
		{
		}
		CT_PictureOptions::~CT_PictureOptions()
		{
		}
		void CT_PictureOptions::fromXML(XmlUtils::CXmlLiteReader& oReader) {
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"applyToFront" == sName)
				{
					m_applyToFront = oReader;
				}
				else if (L"applyToSides" == sName)
				{
					m_applyToSides = oReader;
				}
				else if (L"applyToEnd" == sName)
				{
					m_applyToEnd = oReader;
				}
				else if (L"pictureFormat" == sName)
				{
					m_pictureFormat = oReader;
				}
				else if (L"pictureStackUnit" == sName)
				{
					m_pictureStackUnit = oReader;
				}
			}
		}
		void CT_PictureOptions::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");			
			
			m_applyToFront.toXML(L"c:applyToFront", writer);
			m_applyToSides.toXML(L"c:applyToSides", writer);
			m_applyToEnd.toXML(L"c:applyToEnd", writer);
			m_pictureFormat.toXML(L"c:pictureFormat", writer);
			m_pictureStackUnit.toXML(L"c:pictureStackUnit", writer);

			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_PictureOptions::getType() { return et_ct_pictureoptions; }		
		
		ST_PictureFormat CPictureFormat::FromString(const std::wstring &sValue)
		{
			FromXml_ST_PictureFormat(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CPictureFormat::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_PictureFormat(m_eValue, sEnumVal);
			return sEnumVal;
		}

		CT_DLbls::CT_DLbls()
		{
		}
		CT_DLbls::~CT_DLbls()
		{
			for (size_t i = 0; i < m_dLbl.size(); ++i)
				delete m_dLbl[i];
			m_dLbl.clear();
			
			for (size_t i = 0, length = m_Items.size(), length2 = m_ItemsElementName0.size(); i < length && i < length2; ++i)
				toDelete(*m_ItemsElementName0[i], m_Items[i]);
			m_Items.clear();
			
			for (size_t i = 0; i < m_ItemsElementName0.size(); ++i)
				delete m_ItemsElementName0[i];
			m_ItemsElementName0.clear();
		}
		void CT_DLbls::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"dLbl" == sName)
				{
					CT_DLbl* pNewElem = new CT_DLbl;
					pNewElem->fromXML(oReader);
					m_dLbl.push_back(pNewElem);
				}
				else if (L"dLblPos" == sName)
				{
					nullableComplexVal<CDLblPos> pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3DLBLPOS;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"delete" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3DELETE;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"leaderLines" == sName)
				{
					CT_ChartLines* pNewElem = new CT_ChartLines;
					pNewElem->fromXML(oReader);
					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3LEADERLINES;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"numFmt" == sName)
				{
					CT_NumFmt* pNewElem = new CT_NumFmt;
					pNewElem->fromXML(oReader);
					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3NUMFMT;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"separator" == sName)
				{
					std::wstring* pNewElem = new std::wstring;
					std::wstring sVal = oReader.GetText3();
					*pNewElem = sVal;
					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3SEPARATOR;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showBubbleSize" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3SHOWBUBBLESIZE;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showCatName" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3SHOWCATNAME;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showLeaderLines" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3SHOWLEADERLINES;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showLegendKey" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3SHOWLEGENDKEY;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showPercent" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3SHOWPERCENT;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showSerName" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3SHOWSERNAME;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showVal" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3SHOWVAL;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"spPr" == sName)
				{
					PPTX::Logic::SpPr* pNewElem = new PPTX::Logic::SpPr;
					pNewElem->fromXML(oReader);
					m_Items.push_back(pNewElem);

					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3SPPR;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"txPr" == sName)
				{
					PPTX::Logic::TxBody* pNewElem = new PPTX::Logic::TxBody;
					pNewElem->fromXML(oReader);
					m_Items.push_back(pNewElem);

					ItemsChoiceType3* eElemtype = new ItemsChoiceType3;
					*eElemtype = itemschoicetype3TXPR;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_DLbls::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			for (size_t i = 0; i < m_dLbl.size(); ++i)
			{
				CT_DLbl* pElem = m_dLbl[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:dLbl";
					pElem->toXML(sNodeName, writer);
				}
			}
			for (size_t i = 0; i < m_Items.size(); ++i)
			{
				ItemsChoiceType3 eType = *m_ItemsElementName0[i];
				toXML(writer, false, eType, m_Items[i]);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_DLbls::getType() { return et_ct_dlbls; }
		
		void CT_DLbls::toXML(NSStringUtils::CStringBuilder& writer, bool bIsAttribute, ItemsChoiceType3 eType, void* pVal) const 
		{
			switch (eType)
			{
				case itemschoicetype3DLBLPOS:
				{
					CDLblPos* pTypeVal = static_cast<CDLblPos*>(pVal);
					if (NULL != pTypeVal)
					{
						if (false == bIsAttribute)
						{
							std::wstring sNodeName = L"c:dLblPos";
							writer.WriteString(L"<" + sNodeName + L" val=\"" + pTypeVal->ToString() + L"\"/>");
						}
					}
				}break;				
				case itemschoicetype3DELETE:
				{
					bool* pTypeVal = static_cast<bool*>(pVal);
					if (NULL != pTypeVal)
					{
						if (false == bIsAttribute)
						{
							std::wstring sNodeName = L"c:delete";
							writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
						}
					}
				}break;				
				case itemschoicetype3LEADERLINES:
				{
					CT_ChartLines* pTypeVal = static_cast<CT_ChartLines*>(pVal);
					if (NULL != pTypeVal)
					{
						if (false == bIsAttribute)
						{
							std::wstring sNodeName = L"c:leaderLines";
							pTypeVal->toXML(sNodeName, writer);
						}
					}
				}break;				
				case itemschoicetype3NUMFMT:
				{
					CT_NumFmt* pTypeVal = static_cast<CT_NumFmt*>(pVal);
					if (NULL != pTypeVal)
					{
						if (false == bIsAttribute)
						{
							std::wstring sNodeName = L"c:numFmt";
							pTypeVal->toXML(sNodeName, writer);
						}
					}
				}break;				
				case itemschoicetype3SEPARATOR:
				{
					std::wstring* pTypeVal = static_cast<std::wstring*>(pVal);
					if (NULL != pTypeVal)
					{
						if (true == bIsAttribute)
						{
							WritingStringAttrEncodeXmlString(L"c:separator", *pTypeVal);
						}
						else
						{
							if (std::wstring::npos != pTypeVal->find(' ')&&(  pTypeVal->at(0) == ' ' || pTypeVal->at(pTypeVal->size()-1) == ' ')
				 			|| std::wstring::npos != pTypeVal->find('\n')&&(  pTypeVal->at(0) == '\n' || pTypeVal->at(pTypeVal->size()-1) == '\n'))
								writer.WriteString(L"<c:separator xml:space=\"preserve\">");
							else
								writer.WriteString(L"<c:separator>");
							writer.WriteEncodeXmlString(*pTypeVal);
							writer.WriteString(L"</c:separator>");
						}
					}
				}break;				
				case itemschoicetype3SHOWBUBBLESIZE:
				{
					bool* pTypeVal = static_cast<bool*>(pVal);
					if (NULL != pTypeVal)
					{
						if (false == bIsAttribute)
						{
							std::wstring sNodeName = L"c:showBubbleSize";
							writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
						}
					}
				}break;				
				case itemschoicetype3SHOWCATNAME:
				{
					bool* pTypeVal = static_cast<bool*>(pVal);
					if (NULL != pTypeVal)
					{
						if (false == bIsAttribute)
						{
							std::wstring sNodeName = L"c:showCatName";
							writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
						}
					}
				}break;				
				case itemschoicetype3SHOWLEADERLINES:
				{
					bool* pTypeVal = static_cast<bool*>(pVal);
					if (NULL != pTypeVal)
					{
						if (false == bIsAttribute)
						{
							std::wstring sNodeName = L"c:showLeaderLines";
							writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
						}
					}
				}break;				
				case itemschoicetype3SHOWLEGENDKEY:
				{
					bool* pTypeVal = static_cast<bool*>(pVal);
					if (NULL != pTypeVal)
					{
						if (false == bIsAttribute)
						{
							std::wstring sNodeName = L"c:showLegendKey";
							writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
						}
					}
				}break;				
				case itemschoicetype3SHOWPERCENT:
				{
					bool* pTypeVal = static_cast<bool*>(pVal);
					if (NULL != pTypeVal)
					{
						if (false == bIsAttribute)
						{
							std::wstring sNodeName = L"c:showPercent";
							writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
						}
					}
				}break;				
				case itemschoicetype3SHOWSERNAME:
				{
					bool* pTypeVal = static_cast<bool*>(pVal);
					if (NULL != pTypeVal)
					{
						if (false == bIsAttribute)
						{
							std::wstring sNodeName = L"c:showSerName";
							writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
						}
					}
				}break;				
				case itemschoicetype3SHOWVAL:
				{
					bool* pTypeVal = static_cast<bool*>(pVal);
					if (NULL != pTypeVal)
					{
						if (false == bIsAttribute)
						{
							std::wstring sNodeName = L"c:showVal";
							writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
						}
					}
				}break;				
				case itemschoicetype3SPPR:
				{
					PPTX::Logic::SpPr* pTypeVal = static_cast<PPTX::Logic::SpPr*>(pVal);
					if (NULL != pTypeVal)
					{
						writer.WriteString(pTypeVal->toXML());
					}
				}break;				
				case itemschoicetype3TXPR:
				{
					PPTX::Logic::TxBody* pTypeVal = static_cast<PPTX::Logic::TxBody*>(pVal);
					if (NULL != pTypeVal)
					{
						pTypeVal->m_name = L"c:txPr";
						writer.WriteString(pTypeVal->toXML());
					}
				}break;				
			}
		}
		void CT_DLbls::toDelete(ItemsChoiceType3 eType, void* pVal) 
		{
			switch (eType)
			{
			case itemschoicetype3DLBLPOS:
			{
				CDLblPos* pTypeVal = static_cast<CDLblPos*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3DELETE:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3LEADERLINES:
			{
				CT_ChartLines* pTypeVal = static_cast<CT_ChartLines*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3NUMFMT:
			{
				CT_NumFmt* pTypeVal = static_cast<CT_NumFmt*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3SEPARATOR:
			{
				std::wstring* pTypeVal = static_cast<std::wstring*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3SHOWBUBBLESIZE:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3SHOWCATNAME:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3SHOWLEADERLINES:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3SHOWLEGENDKEY:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3SHOWPERCENT:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3SHOWSERNAME:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3SHOWVAL:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3SPPR:
			{
				PPTX::Logic::SpPr* pTypeVal = static_cast<PPTX::Logic::SpPr*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype3TXPR:
			{
				PPTX::Logic::TxBody* pTypeVal = static_cast<PPTX::Logic::TxBody*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			}
		}
		CT_DLbl::CT_DLbl()
		{
	//ext
			m_leaderLines = NULL;
		}
		CT_DLbl::~CT_DLbl()
		{
		
			if (NULL != m_leaderLines)
				delete m_leaderLines;

			for (size_t i = 0; i < m_Items.size(), i < m_ItemsElementName0.size(); ++i)
				toDelete(*m_ItemsElementName0[i], m_Items[i]);
			m_Items.clear();
			
			for (size_t i = 0; i < m_ItemsElementName0.size(); ++i)
				delete m_ItemsElementName0[i];
			m_ItemsElementName0.clear();
		}
		void CT_DLbl::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"idx" == sName)
				{
					m_idx = oReader;
				}
				else if (L"dLblPos" == sName)
				{
					nullableComplexVal<CDLblPos> pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4DLBLPOS;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"delete" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4DELETE;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"layout" == sName)
				{
					CT_Layout* pNewElem = new CT_Layout;
					pNewElem->fromXML(oReader);
					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4LAYOUT;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"numFmt" == sName)
				{
					CT_NumFmt* pNewElem = new CT_NumFmt;
					pNewElem->fromXML(oReader);
					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4NUMFMT;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"separator" == sName)
				{
					std::wstring* pNewElem = new std::wstring;
					std::wstring sVal = oReader.GetText3();
					*pNewElem = sVal;
					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4SEPARATOR;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showBubbleSize" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4SHOWBUBBLESIZE;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showCatName" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4SHOWCATNAME;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showLegendKey" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4SHOWLEGENDKEY;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showPercent" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4SHOWPERCENT;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showSerName" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4SHOWSERNAME;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"showVal" == sName)
				{
					nullableBoolVal pNewElem = oReader;
					m_Items.push_back(pNewElem.GetPointerEmptyNullable());

					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4SHOWVAL;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"spPr" == sName)
				{
					PPTX::Logic::SpPr* pNewElem = new PPTX::Logic::SpPr;
					pNewElem->fromXML(oReader);
					m_Items.push_back(pNewElem);

					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4SPPR;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"tx" == sName)
				{
					CT_Tx* pNewElem = new CT_Tx;
					pNewElem->fromXML(oReader);
					m_Items.push_back(pNewElem);

					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4TX;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"txPr" == sName)
				{
					PPTX::Logic::TxBody* pNewElem = new PPTX::Logic::TxBody;
					pNewElem->fromXML(oReader);
					m_Items.push_back(pNewElem);

					ItemsChoiceType4* eElemtype = new ItemsChoiceType4;
					*eElemtype = itemschoicetype4TXPR;
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
				else if (L"xForSave" == sName)
				{
					m_xForSave = oReader;
				}
				else if (L"showDataLabelsRange" == sName)
				{
					m_showDataLabelsRange = oReader;
				}
				else if (L"showLeaderLines" == sName)
				{
					m_showLeaderLines = oReader;
				}
				else if (L"leaderLines" == sName)
				{
					m_leaderLines = new CT_ChartLines;
					m_leaderLines->fromXML(oReader);
				}
			}
		}
		void CT_DLbl::toXMLEntry(const std::wstring& sNodeNS, NSStringUtils::CStringBuilder& writer) const
		{
			if (m_idx.IsInit())
			{
				if (*m_idx > 0x7fffffff)
				{
					writer.WriteString(L"<" + sNodeNS + L":idx val=\"" + std::to_wstring((_INT32)*m_idx) + L"\"/>");
				}
				else
					m_idx.toXML(sNodeNS + L":idx", writer);
			}

			for (size_t i = 0; i < m_Items.size(); ++i)
			{
				ItemsChoiceType4 eType = *m_ItemsElementName0[i];
				toXML(writer, false, eType, m_Items[i], sNodeNS);
			}
			m_xForSave.toXML(sNodeNS + L":xForSave", writer);
			m_showDataLabelsRange.toXML(sNodeNS + L":showDataLabelsRange", writer);
			m_showLeaderLines.toXML(sNodeNS + L":showLeaderLines", writer);
			
			if (m_leaderLines)
				m_leaderLines->toXML(sNodeNS + L":leaderLines", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(sNodeNS + L":"));
			}
		}
		std::wstring CT_DLbl::toXML() const
		{
			return L"";
		}
		void CT_DLbl::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			toXML(L"c:dlbl", writer);
		}
		void CT_DLbl::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");

			toXMLEntry(L"c", writer);

			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_DLbl::getType() { return et_ct_dlbl; }

		void CT_DLbl::toXML(NSStringUtils::CStringBuilder& writer, bool bIsAttribute, ItemsChoiceType4 eType, void* pVal, const std::wstring & nodeNS) const
		{
			switch (eType)
			{
			case itemschoicetype4DLBLPOS:
			{
				CDLblPos* pTypeVal = static_cast<CDLblPos*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = nodeNS + L":dLblPos";
						writer.WriteString(L"<" + sNodeName + L" val=\"" + pTypeVal->ToString() + L"\"/>");
					}
				}
			}
			break;
			case itemschoicetype4DELETE:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = nodeNS + L":delete";
						writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
					}
				}
			}
			break;
			case itemschoicetype4LAYOUT:
			{
				CT_Layout* pTypeVal = static_cast<CT_Layout*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = nodeNS + L":layout";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype4NUMFMT:
			{
				CT_NumFmt* pTypeVal = static_cast<CT_NumFmt*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = nodeNS + L":numFmt";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype4SEPARATOR:
			{
				std::wstring* pTypeVal = static_cast<std::wstring*>(pVal);
				if (NULL != pTypeVal)
				{
					if (true == bIsAttribute)
					{
						WritingStringAttrEncodeXmlString(L"c:separator", *pTypeVal);
					}
					else
					{
						if (std::wstring::npos != pTypeVal->find(' ')&&(  pTypeVal->at(0) == ' ' || pTypeVal->at(pTypeVal->size()-1) == ' ')
				 			|| std::wstring::npos != pTypeVal->find('\n')&&(  pTypeVal->at(0) == '\n' || pTypeVal->at(pTypeVal->size()-1) == '\n'))
							writer.WriteString(L"<c:separator xml:space=\"preserve\">");
						else
							writer.WriteString(L"<c:separator>");
						writer.WriteEncodeXmlString(*pTypeVal);
						writer.WriteString(L"</c:separator>");
					}
				}
			}
			break;
			case itemschoicetype4SHOWBUBBLESIZE:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = nodeNS + L":showBubbleSize";
						writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
					}
				}
			}
			break;
			case itemschoicetype4SHOWCATNAME:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = nodeNS + L":showCatName";
						writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
					}
				}
			}
			break;
			case itemschoicetype4SHOWLEGENDKEY:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = nodeNS + L":showLegendKey";
						writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
					}
				}
			}
			break;
			case itemschoicetype4SHOWPERCENT:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = nodeNS + L":showPercent";
						writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
					}
				}
			}
			break;
			case itemschoicetype4SHOWSERNAME:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = nodeNS + L":showSerName";
						writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
					}
				}
			}
			break;
			case itemschoicetype4SHOWVAL:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = nodeNS + L":showVal";
						writer.WriteString(L"<" + sNodeName + L" val=\"" + (*pTypeVal ? L"1" : L"0") + L"\"/>");
					}
				}
			}
			break;
			case itemschoicetype4SPPR:
			{
				PPTX::Logic::SpPr* pTypeVal = static_cast<PPTX::Logic::SpPr*>(pVal);
				if (NULL != pTypeVal)
				{
					pTypeVal->m_namespace = nodeNS;
					writer.WriteString(pTypeVal->toXML());
				}
			}
			break;
			case itemschoicetype4TX:
			{
				CT_Tx* pTypeVal = static_cast<CT_Tx*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = nodeNS + L":tx";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype4TXPR:
			{
				PPTX::Logic::TxBody* pTypeVal = static_cast<PPTX::Logic::TxBody*>(pVal);
				if (NULL != pTypeVal)
				{
					pTypeVal->m_name = nodeNS + L":txPr";
					writer.WriteString(pTypeVal->toXML());
				}
			}
			break;
			}
		}
		void CT_DLbl::toDelete(ItemsChoiceType4 eType, void* pVal) 
		{
			switch (eType)
			{
			case itemschoicetype4DLBLPOS:
			{
				CDLblPos* pTypeVal = static_cast<CDLblPos*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4DELETE:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4LAYOUT:
			{
				CT_Layout* pTypeVal = static_cast<CT_Layout*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4NUMFMT:
			{
				CT_NumFmt* pTypeVal = static_cast<CT_NumFmt*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4SEPARATOR:
			{
				std::wstring* pTypeVal = static_cast<std::wstring*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4SHOWBUBBLESIZE:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4SHOWCATNAME:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4SHOWLEGENDKEY:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4SHOWPERCENT:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4SHOWSERNAME:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4SHOWVAL:
			{
				bool* pTypeVal = static_cast<bool*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4SPPR:
			{
				PPTX::Logic::SpPr* pTypeVal = static_cast<PPTX::Logic::SpPr*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4TX:
			{
				CT_Tx* pTypeVal = static_cast<CT_Tx*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			case itemschoicetype4TXPR:
			{
				PPTX::Logic::TxBody* pTypeVal = static_cast<PPTX::Logic::TxBody*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}break;			
			}
		}
		
		ST_DLblPos CDLblPos::FromString(const std::wstring &sValue)
		{
			FromXml_ST_DLblPos(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CDLblPos::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_DLblPos(m_eValue, sEnumVal);
			return sEnumVal;
		}
		CT_Trendline::CT_Trendline()
		{
			m_trendlineLbl = NULL;
		}
		CT_Trendline::~CT_Trendline()
		{
			if (NULL != m_trendlineLbl)
				delete m_trendlineLbl;
		}
		void CT_Trendline::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"name" == sName)
				{
					std::wstring* pNewElem = new std::wstring;
					std::wstring sVal = oReader.GetText3();
					*pNewElem = sVal;
					m_name = pNewElem;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"trendlineType" == sName)
				{
					m_trendlineType = oReader;
				}
				else if (L"order" == sName)
				{
					m_order = oReader;
				}
				else if (L"period" == sName)
				{
					m_period = oReader;
				}
				else if (L"forward" == sName)
				{
					m_forward = oReader;
				}
				else if (L"backward" == sName)
				{
					m_backward = oReader;
				}
				else if (L"intercept" == sName)
				{
					m_intercept = oReader;
				}
				else if (L"dispRSqr" == sName)
				{
					m_dispRSqr = oReader;
				}
				else if (L"dispEq" == sName)
				{
					m_dispEq = oReader;
				}
				else if (L"trendlineLbl" == sName)
				{
					CT_TrendlineLbl* pNewElem = new CT_TrendlineLbl;
					pNewElem->fromXML(oReader);
					m_trendlineLbl = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Trendline::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			if (m_name.IsInit())
			{
				if (std::wstring::npos != m_name->find(' ')&&(  m_name->at(0) == ' ' || m_name->at(m_name->size()-1) == ' ')
				 			|| std::wstring::npos != m_name->find('\n')&&(  m_name->at(0) == '\n' || m_name->at(m_name->size()-1) == '\n'))
					writer.WriteString(L"<c:name xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:name>");
				writer.WriteEncodeXmlString(*m_name);
				writer.WriteString(L"</c:name>");
			}
			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			m_trendlineType.toXML(L"c:trendlineType", writer);
			m_order.toXML(L"c:order", writer);
			m_period.toXML(L"c:period", writer);
			m_forward.toXML(L"c:forward", writer);
			m_backward.toXML(L"c:backward", writer);
			m_intercept.toXML(L"c:intercept", writer);
			m_dispRSqr.toXML(L"c:dispRSqr", writer);
			m_dispEq.toXML(L"c:dispEq", writer);

			if (NULL != m_trendlineLbl)
			{
				m_trendlineLbl->toXML(L"c:trendlineLbl", writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Trendline::getType() { return et_ct_trendline; }
		
		ST_TrendlineType CTrendlineType::FromString(const std::wstring &sValue)
		{
			FromXml_ST_TrendlineType(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CTrendlineType::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_TrendlineType(m_eValue, sEnumVal);
			return sEnumVal;
		}	

		CT_TrendlineLbl::CT_TrendlineLbl()
		{
			m_layout = NULL;
			m_tx = NULL;
			m_numFmt = NULL;
		}
		CT_TrendlineLbl::~CT_TrendlineLbl()
		{
			if (NULL != m_layout)
				delete m_layout;
			if (NULL != m_tx)
				delete m_tx;
			if (NULL != m_numFmt)
				delete m_numFmt;
		}
		void CT_TrendlineLbl::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"layout" == sName)
				{
					CT_Layout* pNewElem = new CT_Layout;
					pNewElem->fromXML(oReader);
					m_layout = pNewElem;
				}
				else if (L"tx" == sName)
				{
					CT_Tx* pNewElem = new CT_Tx;
					pNewElem->fromXML(oReader);
					m_tx = pNewElem;
				}
				else if (L"numFmt" == sName)
				{
					CT_NumFmt* pNewElem = new CT_NumFmt;
					pNewElem->fromXML(oReader);
					m_numFmt = pNewElem;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"txPr" == sName)
				{
					m_txPr = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_TrendlineLbl::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (NULL != m_layout)
			{
				std::wstring sNodeName = L"c:layout";
				m_layout->toXML(sNodeName, writer);
			}
			if (NULL != m_tx)
			{
				std::wstring sNodeName = L"c:tx";
				m_tx->toXML(sNodeName, writer);
			}
			if (NULL != m_numFmt)
			{
				std::wstring sNodeName = L"c:numFmt";
				m_numFmt->toXML(sNodeName, writer);
			}
			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (m_txPr.IsInit())
			{
				m_txPr->m_name = L"c:txPr";
				writer.WriteString(m_txPr->toXML());
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_TrendlineLbl::getType() { return et_ct_trendlinelbl; }
		
		CT_ErrBars::CT_ErrBars()
		{
			m_plus = NULL;
			m_minus = NULL;
		}
		CT_ErrBars::~CT_ErrBars()
		{
			if (NULL != m_plus)
				delete m_plus;
			if (NULL != m_minus)
				delete m_minus;
		}
		void CT_ErrBars::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"errDir" == sName)
				{
					m_errDir = oReader;
				}
				else if (L"errBarType" == sName)
				{
					m_errBarType = oReader;
				}
				else if (L"errValType" == sName)
				{
					m_errValType = oReader;
				}
				else if (L"noEndCap" == sName)
				{
					m_noEndCap = oReader;
				}
				else if (L"plus" == sName)
				{
					CT_NumDataSource* pNewElem = new CT_NumDataSource;
					pNewElem->fromXML(oReader);
					m_plus = pNewElem;
				}
				else if (L"minus" == sName)
				{
					CT_NumDataSource* pNewElem = new CT_NumDataSource;
					pNewElem->fromXML(oReader);
					m_minus = pNewElem;
				}
				else if (L"val" == sName)
				{
					m_val = oReader;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_ErrBars::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_errDir.toXML(L"c:errDir", writer);
			m_errBarType.toXML(L"c:errBarType", writer);
			m_errValType.toXML(L"c:errValType", writer);
			m_noEndCap.toXML(L"c:noEndCap", writer);

			if (NULL != m_plus)
			{
				m_plus->toXML(L"c:plus", writer);
			}
			if (NULL != m_minus)
			{
				m_minus->toXML(L"c:minus", writer);
			}
			m_val.toXML(L"c:val", writer);
			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_ErrBars::getType() { return et_ct_errbars; }
		
		ST_ErrDir CErrDir::FromString(const std::wstring &sValue)
		{
			FromXml_ST_ErrDir(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CErrDir::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_ErrDir(m_eValue, sEnumVal);
			return sEnumVal;
		}
		ST_ErrBarType CErrBarType::FromString(const std::wstring &sValue)
		{
			FromXml_ST_ErrBarType(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CErrBarType::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_ErrBarType(m_eValue, sEnumVal);
			return sEnumVal;
		}

		ST_ErrValType CErrValType::FromString(const std::wstring &sValue)
		{
			FromXml_ST_ErrValType(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CErrValType::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_ErrValType(m_eValue, sEnumVal);
			return sEnumVal;
		}

		CT_NumDataSource::CT_NumDataSource()
		{
			m_numLit = NULL;
			m_numRef = NULL;
		}
		CT_NumDataSource::~CT_NumDataSource()
		{
			if (NULL != m_numLit)
				delete m_numLit;
			if (NULL != m_numRef)
				delete m_numRef;
		}
		void CT_NumDataSource::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"numLit" == sName)
				{
					CT_NumData* pNewElem = new CT_NumData;
					pNewElem->fromXML(oReader);
					m_numLit = pNewElem;
				}
				else if (L"numRef" == sName)
				{
					CT_NumRef* pNewElem = new CT_NumRef;
					pNewElem->fromXML(oReader);
					m_numRef = pNewElem;
				}
			}
		}
		void CT_NumDataSource::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (NULL != m_numLit)
			{
				std::wstring sNodeName = L"c:numLit";
				m_numLit->toXML(sNodeName, writer);
			}
			if (NULL != m_numRef)
			{
				std::wstring sNodeName = L"c:numRef";
				m_numRef->toXML(sNodeName, writer);
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_NumDataSource::getType() { return et_ct_numdatasource; }
		
		CT_NumData::CT_NumData()
		{
		}
		CT_NumData::~CT_NumData()
		{
			for (size_t i = 0; i < m_pt.size(); ++i)
				delete m_pt[i];
			m_pt.clear();
		}
		void CT_NumData::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"formatCode" == sName)
				{
					m_formatCode = oReader.GetText3();
				}
				else if (L"ptCount" == sName)
				{
					m_ptCount = oReader;
				}
				else if (L"pt" == sName)
				{
					CT_NumVal* pNewElem = new CT_NumVal;
					pNewElem->fromXML(oReader);
					m_pt.push_back(pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_NumData::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (m_formatCode.IsInit())
			{
				if (std::wstring::npos != m_formatCode->find(' ')&&(  m_formatCode->at(0) == ' ' || m_formatCode->at(m_formatCode->size()-1) == ' ')
				 || std::wstring::npos != m_formatCode->find('\n')&&(  m_formatCode->at(0) == '\n' || m_formatCode->at(m_formatCode->size()-1) == '\n'))
					writer.WriteString(L"<c:formatCode xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:formatCode>");
				writer.WriteEncodeXmlString(*m_formatCode);
				writer.WriteString(L"</c:formatCode>");
			}
			m_ptCount.toXML(L"c:ptCount", writer);

			for (size_t i = 0; i < m_pt.size(); ++i)
			{
				CT_NumVal* pElem = m_pt[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:pt";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_NumData::getType() { return et_ct_numdata; }
		
		CT_NumVal::CT_NumVal()
		{
		}
		CT_NumVal::~CT_NumVal()
		{
		}
		void CT_NumVal::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);

			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"v" == sName)
				{
					m_v = oReader.GetText3();
				}
			}
		}
		void CT_NumVal::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			if (m_idx.IsInit())
			{
				WritingStringAttrInt(L"idx", *m_idx);
			}
			if (m_formatCode.IsInit())
			{
				WritingStringAttrEncodeXmlString(L"formatCode", *m_formatCode);
			}
			writer.WriteString(L">");
			if (m_v.IsInit())
			{
				if (std::wstring::npos != m_v->find(' ')&&(  m_v->at(0) == ' ' || m_v->at(m_v->size()-1) == ' ')
				 || std::wstring::npos != m_v->find('\n')&&(  m_v->at(0) == '\n' || m_v->at(m_v->size()-1) == '\n'))
					writer.WriteString(L"<c:v xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:v>");
				writer.WriteEncodeXmlString(*m_v);
				writer.WriteString(L"</c:v>");
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_NumVal::getType() { return et_ct_numval; }
		
		void CT_NumVal::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start_No_NS(oReader)
				WritingElement_ReadAttributes_Read_if(oReader, L"idx", m_idx)
				WritingElement_ReadAttributes_Read_else_if(oReader, L"formatCode", m_formatCode)
			WritingElement_ReadAttributes_End_No_NS(oReader)
		}
		CT_NumRef::CT_NumRef()
		{
			m_numCache = NULL;
		}
		CT_NumRef::~CT_NumRef()
		{
			if (NULL != m_numCache)
				delete m_numCache;
		}
		void CT_NumRef::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"f" == sName)
				{
					m_f = oReader.GetText3();
				}
				else if (L"numCache" == sName)
				{
					CT_NumData* pNewElem = new CT_NumData;
					pNewElem->fromXML(oReader);
					m_numCache = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_NumRef::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			if (m_f.IsInit())
			{
				if (std::wstring::npos != m_f->find(' ')&&(  m_f->at(0) == ' ' || m_f->at(m_f->size()-1) == ' ')
				 || std::wstring::npos != m_f->find('\n')&&(  m_f->at(0) == '\n' || m_f->at(m_f->size()-1) == '\n'))
					writer.WriteString(L"<c:f xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:f>");
				writer.WriteEncodeXmlString(*m_f);
				writer.WriteString(L"</c:f>");
			}
			if (NULL != m_numCache)
			{
				std::wstring sNodeName = L"c:numCache";
				m_numCache->toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_NumRef::getType() { return et_ct_numref; }
		
		CT_AxDataSource::CT_AxDataSource()
		{
			m_multiLvlStrRef = NULL;
			m_numLit = NULL;
			m_numRef = NULL;
			m_strLit = NULL;
			m_strRef = NULL;
		}
		CT_AxDataSource::~CT_AxDataSource()
		{
			if (NULL != m_multiLvlStrRef)
				delete m_multiLvlStrRef;
			if (NULL != m_numLit)
				delete m_numLit;
			if (NULL != m_numRef)
				delete m_numRef;
			if (NULL != m_strLit)
				delete m_strLit;
			if (NULL != m_strRef)
				delete m_strRef;
		}
		void CT_AxDataSource::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"multiLvlStrRef" == sName)
				{
					CT_MultiLvlStrRef* pNewElem = new CT_MultiLvlStrRef;
					pNewElem->fromXML(oReader);
					m_multiLvlStrRef = pNewElem;
				}
				else if (L"numLit" == sName)
				{
					CT_NumData* pNewElem = new CT_NumData;
					pNewElem->fromXML(oReader);
					m_numLit = pNewElem;
				}
				else if (L"numRef" == sName)
				{
					CT_NumRef* pNewElem = new CT_NumRef;
					pNewElem->fromXML(oReader);
					m_numRef = pNewElem;
				}
				else if (L"strLit" == sName)
				{
					CT_StrData* pNewElem = new CT_StrData;
					pNewElem->fromXML(oReader);
					m_strLit = pNewElem;
				}
				else if (L"strRef" == sName)
				{
					CT_StrRef* pNewElem = new CT_StrRef;
					pNewElem->fromXML(oReader);
					m_strRef = pNewElem;
				}
			}
		}
		std::wstring CT_AxDataSource::toXML() const
		{
			return L"";
		}
		void CT_AxDataSource::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			toXML(L"c:cat", writer);
		}
		void CT_AxDataSource::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (NULL != m_multiLvlStrRef)
			{
				std::wstring sNodeName = L"c:multiLvlStrRef";
				m_multiLvlStrRef->toXML(sNodeName, writer);
			}
			if (NULL != m_numLit)
			{
				std::wstring sNodeName = L"c:numLit";
				m_numLit->toXML(sNodeName, writer);
			}
			if (NULL != m_numRef)
			{
				std::wstring sNodeName = L"c:numRef";
				m_numRef->toXML(sNodeName, writer);
			}
			if (NULL != m_strLit)
			{
				std::wstring sNodeName = L"c:strLit";
				m_strLit->toXML(sNodeName, writer);
			}
			if (NULL != m_strRef)
			{
				std::wstring sNodeName = L"c:strRef";
				m_strRef->toXML(sNodeName, writer);
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_AxDataSource::getType() { return et_ct_axdatasource; }

		CT_MultiLvlStrRef::CT_MultiLvlStrRef()
		{
			m_multiLvlStrCache = NULL;
		}
		CT_MultiLvlStrRef::~CT_MultiLvlStrRef()
		{
			if (NULL != m_multiLvlStrCache)
				delete m_multiLvlStrCache;
		}
		void CT_MultiLvlStrRef::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"f" == sName)
				{
					m_f = oReader.GetText3();
				}
				else if (L"multiLvlStrCache" == sName)
				{
					CT_MultiLvlStrData* pNewElem = new CT_MultiLvlStrData;
					pNewElem->fromXML(oReader);
					m_multiLvlStrCache = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_MultiLvlStrRef::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			if (m_f.IsInit())
			{
				if (std::wstring::npos != m_f->find(' ')&&(  m_f->at(0) == ' ' || m_f->at(m_f->size()-1) == ' ')
				 			|| std::wstring::npos != m_f->find('\n')&&(  m_f->at(0) == '\n' || m_f->at(m_f->size()-1) == '\n'))
					writer.WriteString(L"<c:f xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:f>");
				writer.WriteEncodeXmlString(*m_f);
				writer.WriteString(L"</c:f>");
			}
			if (NULL != m_multiLvlStrCache)
			{
				std::wstring sNodeName = L"c:multiLvlStrCache";
				m_multiLvlStrCache->toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_MultiLvlStrRef::getType() { return et_ct_multilvlstrref; }
		
		CT_lvl::CT_lvl()
		{
		}
		CT_lvl::~CT_lvl()
		{
			for (size_t i = 0; i < m_pt.size(); ++i)
				delete m_pt[i];
			m_pt.clear();
		}
		void CT_lvl::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"pt" == sName)
				{
					CT_StrVal* pNewElem = new CT_StrVal;
					pNewElem->fromXML(oReader);
					m_pt.push_back(pNewElem);
				}
			}
		}
		void CT_lvl::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			for (size_t i = 0; i < m_pt.size(); ++i)
			{
				CT_StrVal* pElem = m_pt[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:pt";
					pElem->toXML(sNodeName, writer);
				}
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_lvl::getType() { return et_ct_lvl; }
		
		CT_MultiLvlStrData::CT_MultiLvlStrData()
		{
		}
		CT_MultiLvlStrData::~CT_MultiLvlStrData()
		{
			for (size_t i = 0; i < m_lvl.size(); ++i)
				delete m_lvl[i];
			m_lvl.clear();
		}
		void CT_MultiLvlStrData::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"ptCount" == sName)
				{
					m_ptCount = oReader;
				}
				else if (L"lvl" == sName)
				{
					CT_lvl* pNewElem = new CT_lvl;
					pNewElem->fromXML(oReader);
					m_lvl.push_back(pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_MultiLvlStrData::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_ptCount.toXML(L"c:ptCount", writer);

			for (size_t i = 0; i < m_lvl.size(); ++i)
			{
				CT_lvl* pElem = m_lvl[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:lvl";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_MultiLvlStrData::getType() { return et_ct_multilvlstrdata; }
		
		CT_BubbleChart::CT_BubbleChart()
		{
			m_dLbls = NULL;
		}
		CT_BubbleChart::~CT_BubbleChart()
		{
			if (NULL != m_dLbls)
				delete m_dLbls;

			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
		}
		void CT_BubbleChart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_BubbleSer* pNewElem = new CT_BubbleSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					m_dLbls = new CT_DLbls;
					m_dLbls->fromXML(oReader);
				}
				else if (L"bubble3D" == sName)
				{
					m_bubble3D = oReader;
				}
				else if (L"bubbleScale" == sName)
				{
					m_bubbleScale = oReader;
				}
				else if (L"showNegBubbles" == sName)
				{
					m_showNegBubbles = oReader;
				}
				else if (L"sizeRepresents" == sName)
				{
					m_sizeRepresents = oReader;
				}
				else if (L"axId" == sName)
				{
					nullableIntVal pNewElem = oReader;
					m_axId.push_back(*pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_BubbleChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_BubbleSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			m_bubble3D.toXML(L"c:bubble3D", writer);
			m_bubbleScale.toXML(L"c:bubbleScale", writer);
			m_showNegBubbles.toXML(L"c:showNegBubbles", writer);
			m_sizeRepresents.toXML(L"c:sizeRepresents", writer);

			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_BubbleChart::getType() { return et_ct_bubblechart; }
		
		CT_bandFmts::CT_bandFmts()
		{
		}
		CT_bandFmts::~CT_bandFmts()
		{
			for (size_t i = 0; i < m_bandFmt.size(); ++i)
				delete m_bandFmt[i];
			m_bandFmt.clear();
		}
		void CT_bandFmts::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"bandFmt" == sName)
				{
					CT_BandFmt* pNewElem = new CT_BandFmt;
					pNewElem->fromXML(oReader);
					m_bandFmt.push_back(pNewElem);
				}
			}
		}
		void CT_bandFmts::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			for (size_t i = 0; i < m_bandFmt.size(); ++i)
			{
				CT_BandFmt* pElem = m_bandFmt[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:bandFmt";
					pElem->toXML(sNodeName, writer);
				}
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_bandFmts::getType() { return et_ct_bandfmts; }
		
		CT_Surface3DChart::CT_Surface3DChart()
		{
			m_bandFmts = NULL;
		}
		CT_Surface3DChart::~CT_Surface3DChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
			if (NULL != m_bandFmts)
				delete m_bandFmts;
		}
		void CT_Surface3DChart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"wireframe" == sName)
				{
					m_wireframe = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_SurfaceSer* pNewElem = new CT_SurfaceSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"bandFmts" == sName)
				{
					CT_bandFmts* pNewElem = new CT_bandFmts;
					pNewElem->fromXML(oReader);
					m_bandFmts = pNewElem;
				}
				else if (L"axId" == sName)
				{
					nullableIntVal pNewElem = oReader;
					m_axId.push_back(*pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Surface3DChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_wireframe.toXML(L"c:wireframe", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_SurfaceSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			m_bandFmts->toXML(L"c:bandFmts", writer);

			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");				
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Surface3DChart::getType() { return et_ct_surface3dchart; }
		
		CT_SurfaceSer::CT_SurfaceSer()
		{
			m_cat = NULL;
			m_val = NULL;
		}
		CT_SurfaceSer::~CT_SurfaceSer()
		{
			if (NULL != m_cat)
				delete m_cat;
			if (NULL != m_val)
				delete m_val;
		}
		void CT_SurfaceSer::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				
				if (CBaseSer::fromXML(sName, oReader))
				{

				}
				else if (L"cat" == sName)
				{
					CT_AxDataSource* pNewElem = new CT_AxDataSource;
					pNewElem->fromXML(oReader);
					m_cat = pNewElem;
				}
				else if (L"val" == sName)
				{
					CT_NumDataSource* pNewElem = new CT_NumDataSource;
					pNewElem->fromXML(oReader);
					m_val = pNewElem;
				}
			}
		}
		void CT_SurfaceSer::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			CBaseSer::toXML(writer);

			if (NULL != m_cat)
			{
				std::wstring sNodeName = L"c:cat";
				m_cat->toXML(sNodeName, writer);
			}
			if (NULL != m_val)
			{
				std::wstring sNodeName = L"c:val";
				m_val->toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_SurfaceSer::getType() { return et_ct_surfaceser; }
		
		CT_BandFmt::CT_BandFmt()
		{
		}
		CT_BandFmt::~CT_BandFmt()
		{
		}
		void CT_BandFmt::fromXML(XmlUtils::CXmlLiteReader& oReader) {
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"idx" == sName)
				{
					m_idx = oReader;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
			}
		}
		void CT_BandFmt::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_idx.toXML(L"c:idx", writer);

			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_BandFmt::getType() { return et_ct_bandfmt; }
		
		CT_SurfaceChart::CT_SurfaceChart()
		{
			m_bandFmts = NULL;
		}
		CT_SurfaceChart::~CT_SurfaceChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
			
			if (NULL != m_bandFmts)
				delete m_bandFmts;
		}
		void CT_SurfaceChart::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"wireframe" == sName)
				{
					m_wireframe = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_SurfaceSer* pNewElem = new CT_SurfaceSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"bandFmts" == sName)
				{
					CT_bandFmts* pNewElem = new CT_bandFmts;
					pNewElem->fromXML(oReader);
					m_bandFmts = pNewElem;
				}
				else if (L"axId" == sName)
				{
					nullableIntVal pNewElem = oReader;
					m_axId.push_back(*pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_SurfaceChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_wireframe.toXML(L"c:wireframe", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_SurfaceSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_bandFmts)
			{
				m_bandFmts->toXML(L"c:bandFmts", writer);
			}
			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_SurfaceChart::getType() { return et_ct_surfacechart; }
		
		ST_SplitType CSplitType::FromString(const std::wstring &sValue)
		{
			FromXml_ST_SplitType(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CSplitType::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_SplitType(m_eValue, sEnumVal);
			return sEnumVal;
		}

		ST_OfPieType COfPieType::FromString(const std::wstring &sValue)
		{
			FromXml_ST_OfPieType(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring COfPieType::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_OfPieType(m_eValue, sEnumVal);
			return sEnumVal;
		}

		CT_custSplit::CT_custSplit()
		{
		}
		CT_custSplit::~CT_custSplit()
		{
		}
		void CT_custSplit::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"secondPiePt" == sName)
				{
					nullableUintVal pNewElem = oReader;
					m_secondPiePt.push_back(*pNewElem);
				}
			}
		}
		void CT_custSplit::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			for (size_t i = 0; i < m_secondPiePt.size(); ++i)
			{
				writer.WriteString(L"<c:secondPiePt val=\"" + std::to_wstring(m_secondPiePt[i]) + L"\"/>");
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_custSplit::getType() { return et_ct_custsplit; }
		
		CT_OfPieChart::CT_OfPieChart()
		{
			m_dLbls = NULL;
			m_custSplit = NULL;
		}
		CT_OfPieChart::~CT_OfPieChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
			
			if (NULL != m_dLbls)
				delete m_dLbls;

			if (NULL != m_custSplit)
				delete m_custSplit;

			for (size_t i = 0; i < m_serLines.size(); ++i)
				delete m_serLines[i];
			m_serLines.clear();
		}
		void CT_OfPieChart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"ofPieType" == sName)
				{
					m_ofPieType = oReader;
				}
				else if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_PieSer* pNewElem = new CT_PieSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"gapWidth" == sName)
				{
					m_gapWidth = oReader;
				}
				else if (L"splitType" == sName)
				{
					m_splitType = oReader;
				}
				else if (L"splitPos" == sName)
				{
					m_splitPos = oReader;
				}
				else if (L"custSplit" == sName)
				{
					CT_custSplit* pNewElem = new CT_custSplit;
					pNewElem->fromXML(oReader);
					m_custSplit = pNewElem;
				}
				else if (L"secondPieSize" == sName)
				{
					m_secondPieSize = oReader;
				}
				else if (L"serLines" == sName)
				{
					CT_ChartLines* pNewElem = new CT_ChartLines;
					pNewElem->fromXML(oReader);
					m_serLines.push_back(pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_OfPieChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_ofPieType.toXML(L"c:ofPieType", writer);
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_PieSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			m_gapWidth.toXML(L"c:gapWidth", writer);
			m_splitType.toXML(L"c:splitType", writer);
			m_splitPos.toXML(L"c:splitPos", writer);

			if (NULL != m_custSplit)
			{
				m_custSplit->toXML(L"c:custSplit", writer);
			}
			m_secondPieSize.toXML(L"c:secondPieSize", writer);

			for (size_t i = 0; i < m_serLines.size(); ++i)
			{
				CT_ChartLines* pElem = m_serLines[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:serLines", writer);
				}
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_OfPieChart::getType() { return et_ct_ofpiechart; }
		
		CT_PieSer::CT_PieSer()
		{
			m_dLbls = NULL;
			m_cat = NULL;
			m_val = NULL;
		}
		CT_PieSer::~CT_PieSer()
		{
			for (size_t i = 0; i < m_dPt.size(); ++i)
				delete m_dPt[i];
			m_dPt.clear();
			
			if (NULL != m_dLbls)
				delete m_dLbls;
			if (NULL != m_cat)
				delete m_cat;
			if (NULL != m_val)
				delete m_val;
		}
		void CT_PieSer::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				
				if (CBaseSer::fromXML(sName, oReader))
				{

				}
				else if (L"explosion" == sName)
				{
					m_explosion = oReader;
				}
				else if (L"dPt" == sName)
				{
					CT_DPt* pNewElem = new CT_DPt;
					pNewElem->fromXML(oReader);
					m_dPt.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"cat" == sName)
				{
					CT_AxDataSource* pNewElem = new CT_AxDataSource;
					pNewElem->fromXML(oReader);
					m_cat = pNewElem;
				}
				else if (L"val" == sName)
				{
					CT_NumDataSource* pNewElem = new CT_NumDataSource;
					pNewElem->fromXML(oReader);
					m_val = pNewElem;
				}
			}
		}
		void CT_PieSer::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			CBaseSer::toXML(writer);

			m_explosion.toXML(L"c:explosion", writer);

			for (size_t i = 0; i < m_dPt.size(); ++i)
			{
				CT_DPt* pElem = m_dPt[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:dPt", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				std::wstring sNodeName = L"c:dLbls";
				m_dLbls->toXML(sNodeName, writer);
			}
			if (NULL != m_cat)
			{
				std::wstring sNodeName = L"c:cat";
				m_cat->toXML(sNodeName, writer);
			}
			if (NULL != m_val)
			{
				std::wstring sNodeName = L"c:val";
				m_val->toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_PieSer::getType() { return et_ct_pieser; }
		
		CT_Bar3DChart::CT_Bar3DChart()
		{
			m_dLbls = NULL;
		}
		CT_Bar3DChart::~CT_Bar3DChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
			
			if (NULL != m_dLbls)
				delete m_dLbls;
		}
		void CT_Bar3DChart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"barDir" == sName)
				{
					m_barDir = oReader;
				}
				else if (L"grouping" == sName)
				{
					m_grouping = oReader;
				}
				else if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_BarSer* pNewElem = new CT_BarSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"gapWidth" == sName)
				{
					m_gapWidth = oReader;
				}
				else if (L"gapDepth" == sName)
				{
					m_gapDepth = oReader;
				}
				else if (L"shape" == sName)
				{
					m_shape = oReader;
				}
				else if (L"axId" == sName)
				{
					nullableIntVal pNewElem = oReader;
					m_axId.push_back(*pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Bar3DChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_barDir.toXML(L"c:barDir", writer);
			m_grouping.toXML(L"c:grouping", writer);
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_BarSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			m_gapWidth.toXML(L"c:gapWidth", writer);
			m_gapDepth.toXML(L"c:gapDepth", writer);
			m_shape.toXML(L"c:shape", writer);

			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Bar3DChart::getType() { return et_ct_bar3dchart; }
		
		ST_BarDir CBarDir::FromString(const std::wstring &sValue)
		{
			FromXml_ST_BarDir(sValue, this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CBarDir::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_BarDir(m_eValue, sEnumVal);
			return sEnumVal;
		}

		ST_BarGrouping CBarGrouping::FromString(const std::wstring &sValue)
		{
			FromXml_ST_BarGrouping(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CBarGrouping::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_BarGrouping(m_eValue, sEnumVal);
			return sEnumVal;
		}

		CT_BarSer::CT_BarSer()
		{
			m_pictureOptions = NULL;
			m_dLbls = NULL;
			m_errBars = NULL;
			m_cat = NULL;
			m_val = NULL;
		}
		CT_BarSer::~CT_BarSer()
		{
			if (NULL != m_pictureOptions)
				delete m_pictureOptions;
			for (size_t i = 0; i < m_dPt.size(); ++i)
				delete m_dPt[i];
			m_dPt.clear();
			if (NULL != m_dLbls)
				delete m_dLbls;
			for (size_t i = 0; i < m_trendline.size(); ++i)
				delete m_trendline[i];
			m_trendline.clear();
			if (NULL != m_errBars)
				delete m_errBars;
			if (NULL != m_cat)
				delete m_cat;
			if (NULL != m_val)
				delete m_val;
		}
		void CT_BarSer::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				
				if (CBaseSer::fromXML(sName, oReader))
				{

				}
				else if (L"invertIfNegative" == sName)
				{
					m_invertIfNegative = oReader;
				}
				else if (L"pictureOptions" == sName)
				{
					CT_PictureOptions* pNewElem = new CT_PictureOptions;
					pNewElem->fromXML(oReader);
					m_pictureOptions = pNewElem;
				}
				else if (L"dPt" == sName)
				{
					CT_DPt* pNewElem = new CT_DPt;
					pNewElem->fromXML(oReader);
					m_dPt.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"trendline" == sName)
				{
					CT_Trendline* pNewElem = new CT_Trendline;
					pNewElem->fromXML(oReader);
					m_trendline.push_back(pNewElem);
				}
				else if (L"errBars" == sName)
				{
					CT_ErrBars* pNewElem = new CT_ErrBars;
					pNewElem->fromXML(oReader);
					m_errBars = pNewElem;
				}
				else if (L"cat" == sName)
				{
					CT_AxDataSource* pNewElem = new CT_AxDataSource;
					pNewElem->fromXML(oReader);
					m_cat = pNewElem;
				}
				else if (L"val" == sName)
				{
					CT_NumDataSource* pNewElem = new CT_NumDataSource;
					pNewElem->fromXML(oReader);
					m_val = pNewElem;
				}
				else if (L"shape" == sName)
				{
					m_shape = oReader;
				}
			}
		}
		void CT_BarSer::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			CBaseSer::toXML(writer);

			m_invertIfNegative.toXML(L"c:invertIfNegative", writer);

			if (NULL != m_pictureOptions)
			{
				m_pictureOptions->toXML(L"c:pictureOptions", writer);
			}
			for (size_t i = 0; i < m_dPt.size(); ++i)
			{
				CT_DPt* pElem = m_dPt[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:dPt", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			for (size_t i = 0; i < m_trendline.size(); ++i)
			{
				CT_Trendline* pElem = m_trendline[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:trendline", writer);
				}
			}
			if (NULL != m_errBars)
			{
				m_errBars->toXML(L"c:errBars", writer);
			}
			if (NULL != m_cat)
			{
				m_cat->toXML(L"c:cat", writer);
			}
			if (NULL != m_val)
			{
				m_val->toXML(L"c:val", writer);
			}
			m_shape.toXML(L"c:shape", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_BarSer::getType() { return et_ct_barser; }
		
		ST_Shape CShapeType::FromString(const std::wstring &sValue)
		{
			FromXml_ST_Shape(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CShapeType::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_Shape(m_eValue, sEnumVal);
			return sEnumVal;
		}

		CT_BarChart::CT_BarChart()
		{
			m_dLbls = NULL;
		}
		CT_BarChart::~CT_BarChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();

			if (NULL != m_dLbls)
				delete m_dLbls;

			for (size_t i = 0; i < m_serLines.size(); ++i)
				delete m_serLines[i];
			m_serLines.clear();
		}
		void CT_BarChart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"barDir" == sName)
				{
					m_barDir = oReader;
				}
				else if (L"grouping" == sName)
				{
					m_grouping = oReader;
				}
				else if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_BarSer* pNewElem = new CT_BarSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"gapWidth" == sName)
				{
					m_gapWidth = oReader;
				}
				else if (L"overlap" == sName)
				{
					m_overlap = oReader;
				}
				else if (L"serLines" == sName)
				{
					CT_ChartLines* pNewElem = new CT_ChartLines;
					pNewElem->fromXML(oReader);
					m_serLines.push_back(pNewElem);
				}
				else if (L"axId" == sName)
				{
					nullableIntVal pNewElem = oReader;
					m_axId.push_back(*pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_BarChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_barDir.toXML(L"c:barDir", writer);
			m_grouping.toXML(L"c:grouping", writer);
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_BarSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				std::wstring sNodeName = L"c:dLbls";
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			m_gapWidth.toXML(L"c:gapWidth", writer);
			m_overlap.toXML(L"c:overlap", writer);

			for (size_t i = 0; i < m_serLines.size(); ++i)
			{
				CT_ChartLines* pElem = m_serLines[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:serLines", writer);
				}
			}
			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_BarChart::getType() { return et_ct_barchart; }
		
		CT_DoughnutChart::CT_DoughnutChart()
		{
			m_dLbls = NULL;
		}
		CT_DoughnutChart::~CT_DoughnutChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();

			if (NULL != m_dLbls)
				delete m_dLbls;
		}
		void CT_DoughnutChart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_PieSer* pNewElem = new CT_PieSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"firstSliceAng" == sName)
				{
					m_firstSliceAng = oReader;
				}
				else if (L"holeSize" == sName)
				{
					m_holeSize = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_DoughnutChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_PieSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			m_firstSliceAng.toXML(L"c:firstSliceAng", writer);
			m_holeSize.toXML(L"c:holeSize", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_DoughnutChart::getType() { return et_ct_doughnutchart; }

		CT_Pie3DChart::CT_Pie3DChart()
		{
			m_dLbls = NULL;
		}
		CT_Pie3DChart::~CT_Pie3DChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
			if (NULL != m_dLbls)
				delete m_dLbls;
		}
		void CT_Pie3DChart::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_PieSer* pNewElem = new CT_PieSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Pie3DChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_PieSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Pie3DChart::getType() { return et_ct_pie3dchart; }
		
		CT_PieChart::CT_PieChart()
		{
			m_dLbls = NULL;
		}
		CT_PieChart::~CT_PieChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();

			if (NULL != m_dLbls)
				delete m_dLbls;
		}
		void CT_PieChart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_PieSer* pNewElem = new CT_PieSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"firstSliceAng" == sName)
				{
					m_firstSliceAng = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_PieChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_PieSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			m_firstSliceAng.toXML(L"c:firstSliceAng", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_PieChart::getType() { return et_ct_piechart; }
		
		CT_ScatterSer::CT_ScatterSer()
		{
			m_marker = NULL;
			m_dLbls = NULL;
			m_xVal = NULL;
			m_yVal = NULL;
		}
		CT_ScatterSer::~CT_ScatterSer()
		{
			if (NULL != m_marker)
				delete m_marker;

			for (size_t i = 0; i < m_dPt.size(); ++i)
				delete m_dPt[i];
			m_dPt.clear();

			if (NULL != m_dLbls)
				delete m_dLbls;
			for (size_t i = 0; i < m_trendline.size(); ++i)
				delete m_trendline[i];
			m_trendline.clear();
			for (size_t i = 0; i < m_errBars.size(); ++i)
				delete m_errBars[i];
			m_errBars.clear();
			if (NULL != m_xVal)
				delete m_xVal;
			if (NULL != m_yVal)
				delete m_yVal;
		}
		void CT_ScatterSer::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				
				if (CBaseSer::fromXML(sName, oReader))
				{

				}
				else if (L"marker" == sName)
				{
					CT_Marker* pNewElem = new CT_Marker;
					pNewElem->fromXML(oReader);
					m_marker = pNewElem;
				}
				else if (L"dPt" == sName)
				{
					CT_DPt* pNewElem = new CT_DPt;
					pNewElem->fromXML(oReader);
					m_dPt.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"trendline" == sName)
				{
					CT_Trendline* pNewElem = new CT_Trendline;
					pNewElem->fromXML(oReader);
					m_trendline.push_back(pNewElem);
				}
				else if (L"errBars" == sName)
				{
					CT_ErrBars* pNewElem = new CT_ErrBars;
					pNewElem->fromXML(oReader);
					m_errBars.push_back(pNewElem);
				}
				else if (L"xVal" == sName)
				{
					CT_AxDataSource* pNewElem = new CT_AxDataSource;
					pNewElem->fromXML(oReader);
					m_xVal = pNewElem;
				}
				else if (L"yVal" == sName)
				{
					CT_NumDataSource* pNewElem = new CT_NumDataSource;
					pNewElem->fromXML(oReader);
					m_yVal = pNewElem;
				}
				else if (L"smooth" == sName)
				{
					m_smooth = oReader;
				}
			}
		}
		void CT_ScatterSer::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			CBaseSer::toXML(writer);

			if (NULL != m_marker)
			{
				std::wstring sNodeName = L"c:marker";
				m_marker->toXML(sNodeName, writer);
			}
			for (size_t i = 0; i < m_dPt.size(); ++i)
			{
				CT_DPt* pElem = m_dPt[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:dPt";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_dLbls)
			{
				std::wstring sNodeName = L"c:dLbls";
				m_dLbls->toXML(sNodeName, writer);
			}
			for (size_t i = 0; i < m_trendline.size(); ++i)
			{
				CT_Trendline* pElem = m_trendline[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:trendline";
					pElem->toXML(sNodeName, writer);
				}
			}
			for (size_t i = 0; i < m_errBars.size(); ++i)
			{
				CT_ErrBars* pElem = m_errBars[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:errBars";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_xVal)
			{
				std::wstring sNodeName = L"c:xVal";
				m_xVal->toXML(sNodeName, writer);
			}
			if (NULL != m_yVal)
			{
				std::wstring sNodeName = L"c:yVal";
				m_yVal->toXML(sNodeName, writer);
			}
			m_smooth.toXML(L"c:smooth", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_ScatterSer::getType() { return et_ct_scatterser; }
		
		ST_ScatterStyle CScatterStyle::FromString(const std::wstring &sValue)
		{
			FromXml_ST_ScatterStyle(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CScatterStyle::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_ScatterStyle(m_eValue, sEnumVal);
			return sEnumVal;
		}
		CT_ScatterChart::CT_ScatterChart()
		{
			m_dLbls = NULL;
		}
		CT_ScatterChart::~CT_ScatterChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
			
			if (NULL != m_dLbls)
				delete m_dLbls;
		}
		void CT_ScatterChart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"scatterStyle" == sName)
				{
					m_scatterStyle = oReader;
				}
				else if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_ScatterSer* pNewElem = new CT_ScatterSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"axId" == sName)
				{
					nullableIntVal pNewElem = oReader;
					m_axId.push_back(*pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_ScatterChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_scatterStyle.toXML(L"c:scatterStyle", writer);
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_ScatterSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_ScatterChart::getType() { return et_ct_scatterchart; }
		CT_RadarSer::CT_RadarSer()
		{
			m_marker = NULL;
			m_dLbls = NULL;
			m_cat = NULL;
			m_val = NULL;
		}
		CT_RadarSer::~CT_RadarSer()
		{
			if (NULL != m_marker)
				delete m_marker;

			for (size_t i = 0; i < m_dPt.size(); ++i)
				delete m_dPt[i];
			m_dPt.clear();

			if (NULL != m_dLbls)
				delete m_dLbls;
			if (NULL != m_cat)
				delete m_cat;
			if (NULL != m_val)
				delete m_val;
		}
		void CT_RadarSer::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				
				if (CBaseSer::fromXML(sName, oReader))
				{

				}
				else if (L"marker" == sName)
				{
					CT_Marker* pNewElem = new CT_Marker;
					pNewElem->fromXML(oReader);
					m_marker = pNewElem;
				}
				else if (L"dPt" == sName)
				{
					CT_DPt* pNewElem = new CT_DPt;
					pNewElem->fromXML(oReader);
					m_dPt.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"cat" == sName)
				{
					CT_AxDataSource* pNewElem = new CT_AxDataSource;
					pNewElem->fromXML(oReader);
					m_cat = pNewElem;
				}
				else if (L"val" == sName)
				{
					CT_NumDataSource* pNewElem = new CT_NumDataSource;
					pNewElem->fromXML(oReader);
					m_val = pNewElem;
				}
			}
		}
		void CT_RadarSer::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			CBaseSer::toXML(writer);

			if (NULL != m_marker)
			{
				std::wstring sNodeName = L"c:marker";
				m_marker->toXML(sNodeName, writer);
			}
			for (size_t i = 0; i < m_dPt.size(); ++i)
			{
				CT_DPt* pElem = m_dPt[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:dPt";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_dLbls)
			{
				std::wstring sNodeName = L"c:dLbls";
				m_dLbls->toXML(sNodeName, writer);
			}
			if (NULL != m_cat)
			{
				std::wstring sNodeName = L"c:cat";
				m_cat->toXML(sNodeName, writer);
			}
			if (NULL != m_val)
			{
				std::wstring sNodeName = L"c:val";
				m_val->toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_RadarSer::getType() { return et_ct_radarser; }
		
		ST_RadarStyle CRadarStyle::FromString(const std::wstring &sValue)
		{
			FromXml_ST_RadarStyle(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CRadarStyle::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_RadarStyle(m_eValue, sEnumVal);
			return sEnumVal;
		}

		CT_RadarChart::CT_RadarChart()
		{
			m_dLbls = NULL;
		}
		CT_RadarChart::~CT_RadarChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
			
			if (NULL != m_dLbls)
				delete m_dLbls;
		}
		void CT_RadarChart::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"radarStyle" == sName)
				{
					m_radarStyle = oReader;
				}
				else if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_RadarSer* pNewElem = new CT_RadarSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"axId" == sName)
				{
					nullableIntVal val = oReader;
					m_axId.push_back(*val);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_RadarChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_radarStyle.toXML(L"c:radarStyle", writer);
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_RadarSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_RadarChart::getType() { return et_ct_radarchart; }
		CT_StockChart::CT_StockChart()
		{
			m_dLbls = NULL;
			m_dropLines = NULL;
			m_hiLowLines = NULL;
			m_upDownBars = NULL;
		}
		CT_StockChart::~CT_StockChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
			if (NULL != m_dLbls)
				delete m_dLbls;
			if (NULL != m_dropLines)
				delete m_dropLines;
			if (NULL != m_hiLowLines)
				delete m_hiLowLines;
			if (NULL != m_upDownBars)
				delete m_upDownBars;
		}
		void CT_StockChart::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"ser" == sName)
				{
					CT_LineSer* pNewElem = new CT_LineSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"dropLines" == sName)
				{
					CT_ChartLines* pNewElem = new CT_ChartLines;
					pNewElem->fromXML(oReader);
					m_dropLines = pNewElem;
				}
				else if (L"hiLowLines" == sName)
				{
					CT_ChartLines* pNewElem = new CT_ChartLines;
					pNewElem->fromXML(oReader);
					m_hiLowLines = pNewElem;
				}
				else if (L"upDownBars" == sName)
				{
					CT_UpDownBars* pNewElem = new CT_UpDownBars;
					pNewElem->fromXML(oReader);
					m_upDownBars = pNewElem;
				}
				else if (L"axId" == sName)
				{
					nullableIntVal pNewElem = oReader;
					m_axId.push_back(*pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_StockChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_LineSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:ser";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_dLbls)
			{
				std::wstring sNodeName = L"c:dLbls";
				m_dLbls->toXML(sNodeName, writer);
			}
			if (NULL != m_dropLines)
			{
				std::wstring sNodeName = L"c:dropLines";
				m_dropLines->toXML(sNodeName, writer);
			}
			if (NULL != m_hiLowLines)
			{
				std::wstring sNodeName = L"c:hiLowLines";
				m_hiLowLines->toXML(sNodeName, writer);
			}
			if (NULL != m_upDownBars)
			{
				std::wstring sNodeName = L"c:upDownBars";
				m_upDownBars->toXML(sNodeName, writer);
			}
			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_StockChart::getType() { return et_ct_stockchart; }
		CT_LineSer::CT_LineSer()
		{
			m_marker = NULL;
			m_dLbls = NULL;
			m_errBars = NULL;
			m_cat = NULL;
			m_val = NULL;
		}
		CT_LineSer::~CT_LineSer()
		{
			if (NULL != m_marker)
				delete m_marker;
			for (size_t i = 0; i < m_dPt.size(); ++i)
				delete m_dPt[i];
			m_dPt.clear();
			if (NULL != m_dLbls)
				delete m_dLbls;
			for (size_t i = 0; i < m_trendline.size(); ++i)
				delete m_trendline[i];
			m_trendline.clear();
			if (NULL != m_errBars)
				delete m_errBars;
			if (NULL != m_cat)
				delete m_cat;
			if (NULL != m_val)
				delete m_val;
		}
		void CT_LineSer::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				
				if (CBaseSer::fromXML(sName, oReader))
				{

				}
				else if (L"marker" == sName)
				{
					CT_Marker* pNewElem = new CT_Marker;
					pNewElem->fromXML(oReader);
					m_marker = pNewElem;
				}
				else if (L"dPt" == sName)
				{
					CT_DPt* pNewElem = new CT_DPt;
					pNewElem->fromXML(oReader);
					m_dPt.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"trendline" == sName)
				{
					CT_Trendline* pNewElem = new CT_Trendline;
					pNewElem->fromXML(oReader);
					m_trendline.push_back(pNewElem);
				}
				else if (L"errBars" == sName)
				{
					CT_ErrBars* pNewElem = new CT_ErrBars;
					pNewElem->fromXML(oReader);
					m_errBars = pNewElem;
				}
				else if (L"cat" == sName)
				{
					CT_AxDataSource* pNewElem = new CT_AxDataSource;
					pNewElem->fromXML(oReader);
					m_cat = pNewElem;
				}
				else if (L"val" == sName)
				{
					CT_NumDataSource* pNewElem = new CT_NumDataSource;
					pNewElem->fromXML(oReader);
					m_val = pNewElem;
				}
				else if (L"smooth" == sName)
				{
					m_smooth = oReader;
				}
			}
		}
		void CT_LineSer::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			CBaseSer::toXML(writer);

			if (NULL != m_marker)
			{
				std::wstring sNodeName = L"c:marker";
				m_marker->toXML(sNodeName, writer);
			}
			for (size_t i = 0; i < m_dPt.size(); ++i)
			{
				CT_DPt* pElem = m_dPt[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:dPt";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_dLbls)
			{
				std::wstring sNodeName = L"c:dLbls";
				m_dLbls->toXML(sNodeName, writer);
			}
			for (size_t i = 0; i < m_trendline.size(); ++i)
			{
				CT_Trendline* pElem = m_trendline[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:trendline";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_errBars)
			{
				std::wstring sNodeName = L"c:errBars";
				m_errBars->toXML(sNodeName, writer);
			}
			if (NULL != m_cat)
			{
				std::wstring sNodeName = L"c:cat";
				m_cat->toXML(sNodeName, writer);
			}
			if (NULL != m_val)
			{
				std::wstring sNodeName = L"c:val";
				m_val->toXML(sNodeName, writer);
			}
			
			m_smooth.toXML(L"c:smooth", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_LineSer::getType() { return et_ct_lineser; }
		CT_UpDownBars::CT_UpDownBars()
		{
			m_upBars = NULL;
			m_downBars = NULL;
		}
		CT_UpDownBars::~CT_UpDownBars()
		{
			if (NULL != m_upBars)
				delete m_upBars;
			if (NULL != m_downBars)
				delete m_downBars;
		}
		void CT_UpDownBars::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"gapWidth" == sName)
				{
					m_gapWidth = oReader;
				}
				else if (L"upBars" == sName)
				{
					CT_UpDownBar* pNewElem = new CT_UpDownBar;
					pNewElem->fromXML(oReader);
					m_upBars = pNewElem;
				}
				else if (L"downBars" == sName)
				{
					CT_UpDownBar* pNewElem = new CT_UpDownBar;
					pNewElem->fromXML(oReader);
					m_downBars = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_UpDownBars::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_gapWidth.toXML(L"c:gapWidth", writer);

			if (NULL != m_upBars)
			{
				std::wstring sNodeName = L"c:upBars";
				m_upBars->toXML(sNodeName, writer);
			}
			if (NULL != m_downBars)
			{
				std::wstring sNodeName = L"c:downBars";
				m_downBars->toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_UpDownBars::getType() { return et_ct_updownbars; }
		CT_UpDownBar::CT_UpDownBar()
		{
		}
		CT_UpDownBar::~CT_UpDownBar()
		{
		}
		void CT_UpDownBar::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
			}
		}
		void CT_UpDownBar::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_UpDownBar::getType() { return et_ct_updownbar; }
		
		CT_Line3DChart::CT_Line3DChart()
		{
			m_dLbls = NULL;
			m_dropLines = NULL;
		}
		CT_Line3DChart::~CT_Line3DChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
			
			if (NULL != m_dLbls)
				delete m_dLbls;
			if (NULL != m_dropLines)
				delete m_dropLines;
		}
		void CT_Line3DChart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"grouping" == sName)
				{
					m_grouping = oReader;
				}
				else if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_LineSer* pNewElem = new CT_LineSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"dropLines" == sName)
				{
					CT_ChartLines* pNewElem = new CT_ChartLines;
					pNewElem->fromXML(oReader);
					m_dropLines = pNewElem;
				}
				else if (L"gapDepth" == sName)
				{
					m_gapDepth = oReader;
				}
				else if (L"axId" == sName)
				{
					nullableIntVal pNewElem = oReader;
					m_axId.push_back(*pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Line3DChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_grouping.toXML(L"c:grouping", writer);
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_LineSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			if (NULL != m_dropLines)
			{
				m_dropLines->toXML(L"c:dropLines", writer);
			}
			m_gapDepth.toXML(L"c:gapDepth", writer);

			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Line3DChart::getType() { return et_ct_line3dchart; }
		
		ST_Grouping CGrouping::FromString(const std::wstring &sValue)
		{
			FromXml_ST_Grouping(sValue,  this->m_eValue);
			return this->m_eValue;
		}
		std::wstring CGrouping::ToString() const
		{
			std::wstring sEnumVal;
			ToXml_ST_Grouping(m_eValue, sEnumVal);
			return sEnumVal;
		}
		CT_LineChart::CT_LineChart()
		{
			m_dLbls = NULL;
			m_dropLines = NULL;
			m_hiLowLines = NULL;
			m_upDownBars = NULL;
		}
		CT_LineChart::~CT_LineChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();

			if (NULL != m_dLbls)
				delete m_dLbls;
			if (NULL != m_dropLines)
				delete m_dropLines;
			if (NULL != m_hiLowLines)
				delete m_hiLowLines;
			if (NULL != m_upDownBars)
				delete m_upDownBars;
		}
		void CT_LineChart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"grouping" == sName)
				{
					m_grouping = oReader;
				}
				else if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_LineSer* pNewElem = new CT_LineSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"dropLines" == sName)
				{
					CT_ChartLines* pNewElem = new CT_ChartLines;
					pNewElem->fromXML(oReader);
					m_dropLines = pNewElem;
				}
				else if (L"hiLowLines" == sName)
				{
					CT_ChartLines* pNewElem = new CT_ChartLines;
					pNewElem->fromXML(oReader);
					m_hiLowLines = pNewElem;
				}
				else if (L"upDownBars" == sName)
				{
					CT_UpDownBars* pNewElem = new CT_UpDownBars;
					pNewElem->fromXML(oReader);
					m_upDownBars = pNewElem;
				}
				else if (L"marker" == sName)
				{
					m_marker = oReader;
				}
				else if (L"smooth" == sName)
				{
					m_smooth = oReader;
				}
				else if (L"axId" == sName)
				{
					nullableIntVal pNewElem = oReader;
					m_axId.push_back(*pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_LineChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_grouping.toXML(L"c:grouping", writer);
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_LineSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			if (NULL != m_dropLines)
			{
				m_dropLines->toXML(L"c:dropLines", writer);
			}
			if (NULL != m_hiLowLines)
			{
				m_hiLowLines->toXML(L"c:hiLowLines", writer);
			}
			if (NULL != m_upDownBars)
			{
				m_upDownBars->toXML(L"c:upDownBars", writer);
			}
			m_marker.toXML(L"c:marker", writer);
			m_smooth.toXML(L"c:smooth", writer);

			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_LineChart::getType() { return et_ct_linechart; }
		
		CT_Area3DChart::CT_Area3DChart()
		{
			m_dLbls = NULL;
			m_dropLines = NULL;
		}
		CT_Area3DChart::~CT_Area3DChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
			if (NULL != m_dLbls)
				delete m_dLbls;
			if (NULL != m_dropLines)
				delete m_dropLines;
		}
		void CT_Area3DChart::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"grouping" == sName)
				{
					m_grouping = oReader;
				}
				else if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_AreaSer* pNewElem = new CT_AreaSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"dropLines" == sName)
				{
					CT_ChartLines* pNewElem = new CT_ChartLines;
					pNewElem->fromXML(oReader);
					m_dropLines = pNewElem;
				}
				else if (L"gapDepth" == sName)
				{
					m_gapDepth = oReader;
				}
				else if (L"axId" == sName)
				{
					nullableIntVal pNewElem = oReader;
					m_axId.push_back(*pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Area3DChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");			
			
			m_grouping.toXML(L"c:grouping", writer);
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_AreaSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			if (NULL != m_dropLines)
			{
				m_dropLines->toXML(L"c:dropLines", writer);
			}
			m_gapDepth.toXML(L"c:gapDepth", writer);

			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Area3DChart::getType() { return et_ct_area3dchart; }
		CT_AreaSer::CT_AreaSer()
		{
			m_pictureOptions = NULL;
			m_dLbls = NULL;
			m_cat = NULL;
			m_val = NULL;
		}
		CT_AreaSer::~CT_AreaSer()
		{
			if (NULL != m_pictureOptions)
				delete m_pictureOptions;
			for (size_t i = 0; i < m_dPt.size(); ++i)
				delete m_dPt[i];
			m_dPt.clear();
			if (NULL != m_dLbls)
				delete m_dLbls;
			for (size_t i = 0; i < m_trendline.size(); ++i)
				delete m_trendline[i];
			m_trendline.clear();
			for (size_t i = 0; i < m_errBars.size(); ++i)
				delete m_errBars[i];
			m_errBars.clear();
			if (NULL != m_cat)
				delete m_cat;
			if (NULL != m_val)
				delete m_val;
		}
		void CT_AreaSer::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				
				if (CBaseSer::fromXML(sName, oReader))
				{

				}
				else if (L"pictureOptions" == sName)
				{
					CT_PictureOptions* pNewElem = new CT_PictureOptions;
					pNewElem->fromXML(oReader);
					m_pictureOptions = pNewElem;
				}
				else if (L"dPt" == sName)
				{
					CT_DPt* pNewElem = new CT_DPt;
					pNewElem->fromXML(oReader);
					m_dPt.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"trendline" == sName)
				{
					CT_Trendline* pNewElem = new CT_Trendline;
					pNewElem->fromXML(oReader);
					m_trendline.push_back(pNewElem);
				}
				else if (L"errBars" == sName)
				{
					CT_ErrBars* pNewElem = new CT_ErrBars;
					pNewElem->fromXML(oReader);
					m_errBars.push_back(pNewElem);
				}
				else if (L"cat" == sName)
				{
					CT_AxDataSource* pNewElem = new CT_AxDataSource;
					pNewElem->fromXML(oReader);
					m_cat = pNewElem;
				}
				else if (L"val" == sName)
				{
					CT_NumDataSource* pNewElem = new CT_NumDataSource;
					pNewElem->fromXML(oReader);
					m_val = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_AreaSer::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			CBaseSer::toXML(writer);

			if (NULL != m_pictureOptions)
			{
				std::wstring sNodeName = L"c:pictureOptions";
				m_pictureOptions->toXML(sNodeName, writer);
			}
			for (size_t i = 0; i < m_dPt.size(); ++i)
			{
				CT_DPt* pElem = m_dPt[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:dPt";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_dLbls)
			{
				std::wstring sNodeName = L"c:dLbls";
				m_dLbls->toXML(sNodeName, writer);
			}
			for (size_t i = 0; i < m_trendline.size(); ++i)
			{
				CT_Trendline* pElem = m_trendline[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:trendline";
					pElem->toXML(sNodeName, writer);
				}
			}
			for (size_t i = 0; i < m_errBars.size(); ++i)
			{
				CT_ErrBars* pElem = m_errBars[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:errBars";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_cat)
			{
				std::wstring sNodeName = L"c:cat";
				m_cat->toXML(sNodeName, writer);
			}
			if (NULL != m_val)
			{
				std::wstring sNodeName = L"c:val";
				m_val->toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_AreaSer::getType() { return et_ct_areaser; }
		
		CT_AreaChart::CT_AreaChart()
		{
			m_dLbls = NULL;
			m_dropLines = NULL;
		}
		CT_AreaChart::~CT_AreaChart()
		{
			for (size_t i = 0; i < m_ser.size(); ++i)
				delete m_ser[i];
			m_ser.clear();
			if (NULL != m_dLbls)
				delete m_dLbls;
			if (NULL != m_dropLines)
				delete m_dropLines;
		}
		void CT_AreaChart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"grouping" == sName)
				{
					m_grouping = oReader;
				}
				else if (L"varyColors" == sName)
				{
					m_varyColors = oReader;
				}
				else if (L"ser" == sName)
				{
					CT_AreaSer* pNewElem = new CT_AreaSer;
					pNewElem->fromXML(oReader);
					m_ser.push_back(pNewElem);
				}
				else if (L"dLbls" == sName)
				{
					CT_DLbls* pNewElem = new CT_DLbls;
					pNewElem->fromXML(oReader);
					m_dLbls = pNewElem;
				}
				else if (L"dropLines" == sName)
				{
					CT_ChartLines* pNewElem = new CT_ChartLines;
					pNewElem->fromXML(oReader);
					m_dropLines = pNewElem;
				}
				else if (L"axId" == sName)
				{
					nullableIntVal pNewElem = oReader;
					m_axId.push_back(*pNewElem);
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_AreaChart::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_grouping.toXML(L"c:grouping", writer);
			m_varyColors.toXML(L"c:varyColors", writer);

			for (size_t i = 0; i < m_ser.size(); ++i)
			{
				CT_AreaSer* pElem = m_ser[i];
				if (NULL != pElem)
				{
					pElem->toXML(L"c:ser", writer);
				}
			}
			if (NULL != m_dLbls)
			{
				m_dLbls->toXML(L"c:dLbls", writer);
			}
			if (NULL != m_dropLines)
			{
				m_dropLines->toXML(L"c:dropLines", writer);
			}
			for (size_t i = 0; i < m_axId.size(); ++i)
			{
				writer.WriteString(L"<c:axId  val=\"" + std::to_wstring(m_axId[i]) + L"\"/>");
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_AreaChart::getType() { return et_ct_areachart; }
		CT_PlotArea::CT_PlotArea()
		{
			m_layout = NULL;
			m_dTable = NULL;
		}
		CT_PlotArea::~CT_PlotArea()
		{
			if (NULL != m_layout)
				delete m_layout;
			for (size_t i = 0; i < m_Items.size() && i < m_ItemsElementName0.size(); ++i)
				toDelete(*m_ItemsElementName0[i], m_Items[i]);
			m_Items.clear();
			for (size_t i = 0; i < m_ItemsElementName0.size(); ++i)
				delete m_ItemsElementName0[i];
			m_ItemsElementName0.clear();
			for (size_t i = 0; i < m_Items1.size() && i < m_ItemsElementName1.size(); ++i)
				toDelete(*m_ItemsElementName1[i], m_Items1[i]);
			m_Items1.clear();
			for (size_t i = 0; i < m_ItemsElementName1.size(); ++i)
				delete m_ItemsElementName1[i];
			m_ItemsElementName1.clear();
			if (NULL != m_dTable)
				delete m_dTable;
		}
		void CT_PlotArea::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"layout" == sName)
				{
					CT_Layout* pNewElem = new CT_Layout;
					pNewElem->fromXML(oReader);
					m_layout = pNewElem;
				}
				else if (L"area3DChart" == sName)
				{
					CT_Area3DChart* pNewElem = new CT_Area3DChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5AREA3DCHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"areaChart" == sName)
				{
					CT_AreaChart* pNewElem = new CT_AreaChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5AREACHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"bar3DChart" == sName)
				{
					CT_Bar3DChart* pNewElem = new CT_Bar3DChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5BAR3DCHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"barChart" == sName)
				{
					CT_BarChart* pNewElem = new CT_BarChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5BARCHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"bubbleChart" == sName)
				{
					CT_BubbleChart* pNewElem = new CT_BubbleChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5BUBBLECHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"doughnutChart" == sName)
				{
					CT_DoughnutChart* pNewElem = new CT_DoughnutChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5DOUGHNUTCHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"line3DChart" == sName)
				{
					CT_Line3DChart* pNewElem = new CT_Line3DChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5LINE3DCHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"lineChart" == sName)
				{
					CT_LineChart* pNewElem = new CT_LineChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5LINECHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"ofPieChart" == sName)
				{
					CT_OfPieChart* pNewElem = new CT_OfPieChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5OFPIECHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"pie3DChart" == sName)
				{
					CT_Pie3DChart* pNewElem = new CT_Pie3DChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5PIE3DCHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"pieChart" == sName)
				{
					CT_PieChart* pNewElem = new CT_PieChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5PIECHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"radarChart" == sName)
				{
					CT_RadarChart* pNewElem = new CT_RadarChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5RADARCHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"scatterChart" == sName)
				{
					CT_ScatterChart* pNewElem = new CT_ScatterChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5SCATTERCHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"stockChart" == sName)
				{
					CT_StockChart* pNewElem = new CT_StockChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5STOCKCHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"surface3DChart" == sName)
				{
					CT_Surface3DChart* pNewElem = new CT_Surface3DChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5SURFACE3DCHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"surfaceChart" == sName)
				{
					CT_SurfaceChart* pNewElem = new CT_SurfaceChart;
					pNewElem->fromXML(oReader);
					ItemsChoiceType5* eElemtype = new ItemsChoiceType5;
					*eElemtype = itemschoicetype5SURFACECHART;
					m_Items.push_back(pNewElem);
					m_ItemsElementName0.push_back(eElemtype);
				}
				else if (L"catAx" == sName)
				{
					CT_CatAx* pNewElem = new CT_CatAx;
					pNewElem->fromXML(oReader);
					ItemsChoiceType6* eElemtype = new ItemsChoiceType6;
					*eElemtype = itemschoicetype6CATAX;
					m_Items1.push_back(pNewElem);
					m_ItemsElementName1.push_back(eElemtype);
				}
				else if (L"dateAx" == sName)
				{
					CT_DateAx* pNewElem = new CT_DateAx;
					pNewElem->fromXML(oReader);
					ItemsChoiceType6* eElemtype = new ItemsChoiceType6;
					*eElemtype = itemschoicetype6DATEAX;
					m_Items1.push_back(pNewElem);
					m_ItemsElementName1.push_back(eElemtype);
				}
				else if (L"serAx" == sName)
				{
					CT_SerAx* pNewElem = new CT_SerAx;
					pNewElem->fromXML(oReader);
					ItemsChoiceType6* eElemtype = new ItemsChoiceType6;
					*eElemtype = itemschoicetype6SERAX;
					m_Items1.push_back(pNewElem);
					m_ItemsElementName1.push_back(eElemtype);
				}
				else if (L"valAx" == sName)
				{
					CT_ValAx* pNewElem = new CT_ValAx;
					pNewElem->fromXML(oReader);
					ItemsChoiceType6* eElemtype = new ItemsChoiceType6;
					*eElemtype = itemschoicetype6VALAX;
					m_Items1.push_back(pNewElem);
					m_ItemsElementName1.push_back(eElemtype);
				}
				else if (L"dTable" == sName)
				{
					CT_DTable* pNewElem = new CT_DTable;
					pNewElem->fromXML(oReader);
					m_dTable = pNewElem;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_PlotArea::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const {
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (NULL != m_layout)
			{
				std::wstring sNodeName = L"c:layout";
				m_layout->toXML(sNodeName, writer);
			}
			for (size_t i = 0; i < m_Items.size(); ++i)
			{
				ItemsChoiceType5 eType = *m_ItemsElementName0[i];
				toXML(writer, false, eType, m_Items[i]);
			}
			for (size_t i = 0; i < m_Items1.size(); ++i)
			{
				ItemsChoiceType6 eType = *m_ItemsElementName1[i];
				toXML(writer, false, eType, m_Items1[i]);
			}
			if (NULL != m_dTable)
			{
				std::wstring sNodeName = L"c:dTable";
				m_dTable->toXML(sNodeName, writer);
			}
			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_PlotArea::getType() { return et_ct_PlotArea; }
		void CT_PlotArea::toXML(NSStringUtils::CStringBuilder& writer, bool bIsAttribute, ItemsChoiceType5 eType, void* pVal) const {
			switch (eType)
			{
			case itemschoicetype5AREA3DCHART:
			{
				CT_Area3DChart* pTypeVal = static_cast<CT_Area3DChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:area3DChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5AREACHART:
			{
				CT_AreaChart* pTypeVal = static_cast<CT_AreaChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:areaChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5BAR3DCHART:
			{
				CT_Bar3DChart* pTypeVal = static_cast<CT_Bar3DChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:bar3DChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5BARCHART:
			{
				CT_BarChart* pTypeVal = static_cast<CT_BarChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:barChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5BUBBLECHART:
			{
				CT_BubbleChart* pTypeVal = static_cast<CT_BubbleChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:bubbleChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5DOUGHNUTCHART:
			{
				CT_DoughnutChart* pTypeVal = static_cast<CT_DoughnutChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:doughnutChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5LINE3DCHART:
			{
				CT_Line3DChart* pTypeVal = static_cast<CT_Line3DChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:line3DChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5LINECHART:
			{
				CT_LineChart* pTypeVal = static_cast<CT_LineChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:lineChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5OFPIECHART:
			{
				CT_OfPieChart* pTypeVal = static_cast<CT_OfPieChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:ofPieChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5PIE3DCHART:
			{
				CT_Pie3DChart* pTypeVal = static_cast<CT_Pie3DChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:pie3DChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5PIECHART:
			{
				CT_PieChart* pTypeVal = static_cast<CT_PieChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:pieChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5RADARCHART:
			{
				CT_RadarChart* pTypeVal = static_cast<CT_RadarChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:radarChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5SCATTERCHART:
			{
				CT_ScatterChart* pTypeVal = static_cast<CT_ScatterChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:scatterChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5STOCKCHART:
			{
				CT_StockChart* pTypeVal = static_cast<CT_StockChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:stockChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5SURFACE3DCHART:
			{
				CT_Surface3DChart* pTypeVal = static_cast<CT_Surface3DChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:surface3DChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype5SURFACECHART:
			{
				CT_SurfaceChart* pTypeVal = static_cast<CT_SurfaceChart*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:surfaceChart";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			}
		}
		void CT_PlotArea::toDelete(ItemsChoiceType5 eType, void* pVal) {
			switch (eType)
			{
			case itemschoicetype5AREA3DCHART:
			{
				CT_Area3DChart* pTypeVal = static_cast<CT_Area3DChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5AREACHART:
			{
				CT_AreaChart* pTypeVal = static_cast<CT_AreaChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5BAR3DCHART:
			{
				CT_Bar3DChart* pTypeVal = static_cast<CT_Bar3DChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5BARCHART:
			{
				CT_BarChart* pTypeVal = static_cast<CT_BarChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5BUBBLECHART:
			{
				CT_BubbleChart* pTypeVal = static_cast<CT_BubbleChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5DOUGHNUTCHART:
			{
				CT_DoughnutChart* pTypeVal = static_cast<CT_DoughnutChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5LINE3DCHART:
			{
				CT_Line3DChart* pTypeVal = static_cast<CT_Line3DChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5LINECHART:
			{
				CT_LineChart* pTypeVal = static_cast<CT_LineChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5OFPIECHART:
			{
				CT_OfPieChart* pTypeVal = static_cast<CT_OfPieChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5PIE3DCHART:
			{
				CT_Pie3DChart* pTypeVal = static_cast<CT_Pie3DChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5PIECHART:
			{
				CT_PieChart* pTypeVal = static_cast<CT_PieChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5RADARCHART:
			{
				CT_RadarChart* pTypeVal = static_cast<CT_RadarChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5SCATTERCHART:
			{
				CT_ScatterChart* pTypeVal = static_cast<CT_ScatterChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5STOCKCHART:
			{
				CT_StockChart* pTypeVal = static_cast<CT_StockChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5SURFACE3DCHART:
			{
				CT_Surface3DChart* pTypeVal = static_cast<CT_Surface3DChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype5SURFACECHART:
			{
				CT_SurfaceChart* pTypeVal = static_cast<CT_SurfaceChart*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			}
		}
		void CT_PlotArea::toXML(NSStringUtils::CStringBuilder& writer, bool bIsAttribute, ItemsChoiceType6 eType, void* pVal) const {
			switch (eType)
			{
			case itemschoicetype6CATAX:
			{
				CT_CatAx* pTypeVal = static_cast<CT_CatAx*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:catAx";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype6DATEAX:
			{
				CT_DateAx* pTypeVal = static_cast<CT_DateAx*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:dateAx";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype6SERAX:
			{
				CT_SerAx* pTypeVal = static_cast<CT_SerAx*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:serAx";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			case itemschoicetype6VALAX:
			{
				CT_ValAx* pTypeVal = static_cast<CT_ValAx*>(pVal);
				if (NULL != pTypeVal)
				{
					if (false == bIsAttribute)
					{
						std::wstring sNodeName = L"c:valAx";
						pTypeVal->toXML(sNodeName, writer);
					}
				}
			}
			break;
			}
		}
		void CT_PlotArea::toDelete(ItemsChoiceType6 eType, void* pVal) {
			switch (eType)
			{
			case itemschoicetype6CATAX:
			{
				CT_CatAx* pTypeVal = static_cast<CT_CatAx*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype6DATEAX:
			{
				CT_DateAx* pTypeVal = static_cast<CT_DateAx*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype6SERAX:
			{
				CT_SerAx* pTypeVal = static_cast<CT_SerAx*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			case itemschoicetype6VALAX:
			{
				CT_ValAx* pTypeVal = static_cast<CT_ValAx*>(pVal);
				RELEASEOBJECT(pTypeVal);
			}
			break;
			}
		}

		CT_Surface::CT_Surface()
		{
			m_pictureOptions = NULL;
		}
		CT_Surface::~CT_Surface()
		{
			if (NULL != m_pictureOptions)
				delete m_pictureOptions;
		}
		void CT_Surface::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"thickness" == sName)
				{
					m_thickness = oReader;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"pictureOptions" == sName)
				{
					CT_PictureOptions* pNewElem = new CT_PictureOptions;
					pNewElem->fromXML(oReader);
					m_pictureOptions = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Surface::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_thickness.toXML(L"c:thickness", writer);

			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (NULL != m_pictureOptions)
			{
				std::wstring sNodeName = L"c:pictureOptions";
				m_pictureOptions->toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Surface::getType() { return et_ct_surface; }
		
		CT_View3D::CT_View3D()
		{
		}
		CT_View3D::~CT_View3D()
		{
		}
		void CT_View3D::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"rotX" == sName)
				{
					m_rotX = oReader;
				}
				else if (L"hPercent" == sName)
				{
					m_hPercent = oReader;
				}
				else if (L"rotY" == sName)
				{
					m_rotY = oReader;
				}
				else if (L"depthPercent" == sName)
				{
					m_depthPercent = oReader;
				}
				else if (L"rAngAx" == sName)
				{
					m_rAngAx = oReader;
				}
				else if (L"perspective" == sName)
				{
					m_perspective = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_View3D::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_rotX.toXML(L"c:rotX", writer);
			m_hPercent.toXML(L"c:hPercent", writer);
			m_rotY.toXML(L"c:rotY", writer);
			m_depthPercent.toXML(L"c:depthPercent", writer);
			m_rAngAx.toXML(L"c:rAngAx", writer);
			m_perspective.toXML(L"c:perspective", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_View3D::getType() { return et_ct_view3d; }
		
		CT_PivotFmt::CT_PivotFmt()
		{
			m_marker = NULL;
			m_dLbl = NULL;
		}
		CT_PivotFmt::~CT_PivotFmt()
		{
			if (NULL != m_marker)
				delete m_marker;
			if (NULL != m_dLbl)
				delete m_dLbl;
		}
		void CT_PivotFmt::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"idx" == sName)
				{
					m_idx = oReader;
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"txPr" == sName)
				{
					m_txPr = oReader;
				}
				else if (L"marker" == sName)
				{
					CT_Marker* pNewElem = new CT_Marker;
					pNewElem->fromXML(oReader);
					m_marker = pNewElem;
				}
				else if (L"dLbl" == sName)
				{
					CT_DLbl* pNewElem = new CT_DLbl;
					pNewElem->fromXML(oReader);
					m_dLbl = pNewElem;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_PivotFmt::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_idx.toXML(L"c:idx", writer);

			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			if (m_txPr.IsInit())
			{
				m_txPr->m_name = L"c:txPr";
				writer.WriteString(m_txPr->toXML());
			}
			if (NULL != m_marker)
			{
				std::wstring sNodeName = L"c:marker";
				m_marker->toXML(sNodeName, writer);
			}
			if (NULL != m_dLbl)
			{
				std::wstring sNodeName = L"c:dLbl";
				m_dLbl->toXML(sNodeName, writer);
			}
			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_PivotFmt::getType() { return et_ct_pivotfmt; }
		
		CT_pivotFmts::CT_pivotFmts()
		{
		}
		CT_pivotFmts::~CT_pivotFmts()
		{
			for (size_t i = 0; i < m_pivotFmt.size(); ++i)
				delete m_pivotFmt[i];
			m_pivotFmt.clear();
		}
		void CT_pivotFmts::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"pivotFmt" == sName)
				{
					CT_PivotFmt* pNewElem = new CT_PivotFmt;
					pNewElem->fromXML(oReader);
					m_pivotFmt.push_back(pNewElem);
				}
			}
		}
		void CT_pivotFmts::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			for (size_t i = 0; i < m_pivotFmt.size(); ++i)
			{
				CT_PivotFmt* pElem = m_pivotFmt[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"c:pivotFmt";
					pElem->toXML(sNodeName, writer);
				}
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_pivotFmts::getType() { return et_ct_pivotfmts; }
		
		CT_Chart::CT_Chart()
		{
			m_title = NULL;
			m_pivotFmts = NULL;
			m_view3D = NULL;
			m_floor = NULL;
			m_sideWall = NULL;
			m_backWall = NULL;
			m_plotArea = NULL;
			m_legend = NULL;
		}
		CT_Chart::~CT_Chart()
		{
			if (NULL != m_title)
				delete m_title;
			if (NULL != m_pivotFmts)
				delete m_pivotFmts;
			if (NULL != m_view3D)
				delete m_view3D;
			if (NULL != m_floor)
				delete m_floor;
			if (NULL != m_sideWall)
				delete m_sideWall;
			if (NULL != m_backWall)
				delete m_backWall;
			if (NULL != m_plotArea)
				delete m_plotArea;
			if (NULL != m_legend)
				delete m_legend;
		}
		void CT_Chart::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"title" == sName)
				{
					CT_Title* pNewElem = new CT_Title;
					pNewElem->fromXML(oReader);
					m_title = pNewElem;
				}
				else if (L"autoTitleDeleted" == sName)
				{
					m_autoTitleDeleted = oReader;
				}
				else if (L"pivotFmts" == sName)
				{
					CT_pivotFmts* pNewElem = new CT_pivotFmts;
					pNewElem->fromXML(oReader);
					m_pivotFmts = pNewElem;
				}
				else if (L"view3D" == sName)
				{
					CT_View3D* pNewElem = new CT_View3D;
					pNewElem->fromXML(oReader);
					m_view3D = pNewElem;
				}
				else if (L"floor" == sName)
				{
					CT_Surface* pNewElem = new CT_Surface;
					pNewElem->fromXML(oReader);
					m_floor = pNewElem;
				}
				else if (L"sideWall" == sName)
				{
					CT_Surface* pNewElem = new CT_Surface;
					pNewElem->fromXML(oReader);
					m_sideWall = pNewElem;
				}
				else if (L"backWall" == sName)
				{
					CT_Surface* pNewElem = new CT_Surface;
					pNewElem->fromXML(oReader);
					m_backWall = pNewElem;
				}
				else if (L"plotArea" == sName)
				{
					CT_PlotArea* pNewElem = new CT_PlotArea;
					pNewElem->fromXML(oReader);
					m_plotArea = pNewElem;
				}
				else if (L"legend" == sName)
				{
					CT_Legend* pNewElem = new CT_Legend;
					pNewElem->fromXML(oReader);
					m_legend = pNewElem;
				}
				else if (L"plotVisOnly" == sName)
				{
					m_plotVisOnly = oReader;
				}
				else if (L"dispBlanksAs" == sName)
				{
					m_dispBlanksAs = oReader;
				}
				else if (L"showDLblsOverMax" == sName)
				{
					m_showDLblsOverMax = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_Chart::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<c:chart>");

			if (NULL != m_title)
			{
				m_title->toXML(L"c:title", writer);
			}
			m_autoTitleDeleted.toXML(L"c:autoTitleDeleted", writer);

			if (NULL != m_pivotFmts)
			{
				m_pivotFmts->toXML(L"c:pivotFmts", writer);
			}
			if (NULL != m_view3D)
			{
				m_view3D->toXML(L"c:view3D", writer);
			}
			if (NULL != m_floor)
			{
				m_floor->toXML(L"c:floor", writer);
			}
			if (NULL != m_sideWall)
			{
				m_sideWall->toXML(L"c:sideWall", writer);
			}
			if (NULL != m_backWall)
			{
				m_backWall->toXML(L"c:backWall", writer);
			}
			if (NULL != m_plotArea)
			{
				m_plotArea->toXML(L"c:plotArea", writer);
			}
			if (NULL != m_legend)
			{
				m_legend->toXML(L"c:legend", writer);
			}
			m_plotVisOnly.toXML(L"c:plotVisOnly", writer);
			m_dispBlanksAs.toXML(L"c:dispBlanksAs", writer);
			m_showDLblsOverMax.toXML(L"c:showDLblsOverMax", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</c:chart>");
		}
		EElementType CT_Chart::getType() { return et_ct_Chart; }
		
		CT_Protection::CT_Protection()
		{
		}
		CT_Protection::~CT_Protection()
		{
		}
		void CT_Protection::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"chartObject" == sName)
				{
					m_chartObject = oReader;
				}
				else if (L"data" == sName)
				{
					m_data = oReader;
				}
				else if (L"formatting" == sName)
				{
					m_formatting = oReader;
				}
				else if (L"selection" == sName)
				{
					m_selection = oReader;
				}
				else if (L"userInterface" == sName)
				{
					m_userInterface = oReader;
				}
			}
		}
		void CT_Protection::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			m_chartObject.toXML(L"c:chartObject", writer);
			m_data.toXML(L"c:data", writer);
			m_formatting.toXML(L"c:formatting", writer);
            m_selection.toXML(L"c:selection", writer);
			m_userInterface.toXML(L"c:userInterface", writer);

			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_Protection::getType() { return et_ct_protection; }
		
		CT_PivotSource::CT_PivotSource()
		{
		}
		CT_PivotSource::~CT_PivotSource()
		{
		}
		void CT_PivotSource::fromXML(XmlUtils::CXmlLiteReader& oReader) 
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"name" == sName)
				{
					m_name = oReader.GetText3();
				}
				else if (L"fmtId" == sName)
				{
					m_fmtId = oReader;
				}
				else if (L"extLst" == sName)
				{
					m_extLst = oReader;
				}
			}
		}
		void CT_PivotSource::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const 
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			
			if (m_name.IsInit())
			{
				if (std::wstring::npos != m_name->find(' ')&&(  m_name->at(0) == ' ' || m_name->at(m_name->size()-1) == ' ')
				 			|| std::wstring::npos != m_name->find('\n')&&(  m_name->at(0) == '\n' || m_name->at(m_name->size()-1) == '\n'))
					writer.WriteString(L"<c:name xml:space=\"preserve\">");
				else
					writer.WriteString(L"<c:name>");
				writer.WriteEncodeXmlString(*m_name);
				writer.WriteString(L"</c:name>");
			}
			m_fmtId.toXML(L"c:fmtId", writer);

			if (m_extLst.IsInit())
			{
				writer.WriteString(m_extLst->toXMLWithNS(L"c:"));
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType CT_PivotSource::getType() { return et_ct_pivotsource; }
		
		CT_Style::CT_Style() : m_namespace(L"c")
		{
		}
		CT_Style::~CT_Style()
		{
		}
		void CT_Style::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			m_namespace = XmlUtils::GetNamespace(oReader.GetName());
			ReadAttributes(oReader);

			if (!oReader.IsEmptyNode())
				oReader.ReadTillEnd();
		}
		void CT_Style::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<" + m_namespace + L":style");
			if (m_val.IsInit())
			{
				WritingStringAttrInt(L"val", *m_val);
			}
			writer.WriteString(L"/>");
		}
		EElementType CT_Style::getType() { return et_ct_style; }		
		void CT_Style::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start_No_NS(oReader)
				WritingElement_ReadAttributes_Read_if(oReader, L"val", m_val)
			WritingElement_ReadAttributes_End_No_NS(oReader)
		}

		AlternateContent::AlternateContent()
		{
			m_Fallback = NULL;
		}
		AlternateContent::~AlternateContent()
		{
			for (size_t i = 0; i < m_Choice.size(); ++i)
				delete m_Choice[i];
			m_Choice.clear();
			if (NULL != m_Fallback)
				delete m_Fallback;
		}
		void AlternateContent::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"Choice" == sName)
				{
					AlternateContentChoice* pNewElem = new AlternateContentChoice;
					pNewElem->fromXML(oReader);
					m_Choice.push_back(pNewElem);
				}
				else if (L"Fallback" == sName)
				{
					AlternateContentFallback* pNewElem = new AlternateContentFallback;
					pNewElem->fromXML(oReader);
					m_Fallback = pNewElem;
				}
			}
		}
		void AlternateContent::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			for (size_t i = 0; i < m_Choice.size(); ++i)
			{
				AlternateContentChoice* pElem = m_Choice[i];
				if (NULL != pElem)
				{
					std::wstring sNodeName = L"mc:Choice";
					pElem->toXML(sNodeName, writer);
				}
			}
			if (NULL != m_Fallback)
			{
				std::wstring sNodeName = L"mc:Fallback";
				m_Fallback->toXML(sNodeName, writer);
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType AlternateContent::getType()
		{
			return et_ct_alternatecontent;
		}
		AlternateContentChoice::AlternateContentChoice()
		{
			m_style = NULL;
		}
		AlternateContentChoice::~AlternateContentChoice()
		{
			if (NULL != m_style)
				delete m_style;
		}
		void AlternateContentChoice::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);

			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"style" == sName)
				{
					m_style = new CT_Style;
					m_style->fromXML(oReader);
				}
			}
		}
		void AlternateContentChoice::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			if (m_Requires.IsInit())
			{
				WritingStringAttrEncodeXmlString(L"Requires", *m_Requires);
			}
			writer.WriteString(L">");
			if (NULL != m_style)
			{
				m_style->m_namespace = L"c14";
				m_style->toXML(writer);
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType AlternateContentChoice::getType()
		{
			return et_ct_alternatecontentchoice;
		}
		void AlternateContentChoice::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start_No_NS(oReader)
				WritingElement_ReadAttributes_Read_if(oReader, L"Requires", m_Requires)
			WritingElement_ReadAttributes_End_No_NS(oReader)
		}
		AlternateContentFallback::AlternateContentFallback()
		{
			m_style = NULL;
		}
		AlternateContentFallback::~AlternateContentFallback()
		{
			if (NULL != m_style)
				delete m_style;
		}
		void AlternateContentFallback::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;
			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"style" == sName)
				{
					m_style = new CT_Style;
					m_style->fromXML(oReader);
				}
			}
		}
		void AlternateContentFallback::toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
			if (NULL != m_style)
			{
				m_style->toXML(writer);
			}
			writer.WriteString(L"</");
			writer.WriteString(sNodeName);
			writer.WriteString(L">");
		}
		EElementType AlternateContentFallback::getType()
		{
			return et_ct_alternatecontentfallback;
		}
//-------------------------------------------------------------------------------------------
		CSeriesDataLabelsRange::CSeriesDataLabelsRange() {}
		CSeriesDataLabelsRange::~CSeriesDataLabelsRange()
		{
		}
		void CSeriesDataLabelsRange::fromXML(XmlUtils::CXmlNode& node) {}
		void CSeriesDataLabelsRange::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"f" == sName)
				{
					m_f = oReader.GetText2();
				}
				else if (L"dlblRangeCache" == sName)
				{
					m_dlblRangeCache = oReader;
				}
			}
		}
		void CSeriesDataLabelsRange::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<c15:datalabelsRange>");

			if (m_f.IsInit())
			{
				writer.WriteString(L"<c15:f>" + *m_f + L"</c15:f>");
			}
			if (m_dlblRangeCache.IsInit())
			{
				m_dlblRangeCache->toXML(L"c15:dlblRangeCache", writer);
			}
			writer.WriteString(L"</c15:datalabelsRange>");
		}
		std::wstring CSeriesDataLabelsRange::toXML() const
		{
			NSStringUtils::CStringBuilder writer;
			toXML(writer);
			return writer.GetData();
		}
		EElementType CSeriesDataLabelsRange::getType() const
		{
			return et_ct_SeriesDataLabelsRange;
		}
		CCategoryFilterException::CCategoryFilterException() {}
		CCategoryFilterException::~CCategoryFilterException()
		{
		}
		void CCategoryFilterException::fromXML(XmlUtils::CXmlNode& node) {}
		void CCategoryFilterException::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"sqref" == sName)
				{
					m_sqref = oReader.GetText2();
				}
				else if (L"spPr" == sName)
				{
					m_spPr = oReader;
				}
				else if (L"explosion" == sName)
				{
					m_explosion = oReader;
				}
				else if (L"marker" == sName)
				{
					m_marker = oReader;
				}
				else if (L"invertIfNegative" == sName)
				{
					m_invertIfNegative = oReader;
				}
				else if (L"bubble3D" == sName)
				{
					m_bubble3D = oReader;
				}
				else if (L"dLbl" == sName)
				{
					m_dLbl = oReader;
				}
			}
		}
		void CCategoryFilterException::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<c15:categoryFilterException>");

			if (m_sqref.IsInit())
			{
				writer.WriteString(L"<c15:sqref>" + *m_sqref + L"</c15:sqref>");
			}
			if (m_spPr.IsInit())
			{
				writer.WriteString(m_spPr->toXML());
			}
			m_explosion.toXML(L"c15:explosion", writer);
			m_invertIfNegative.toXML(L"c15:invertIfNegative", writer);
			m_bubble3D.toXML(L"c15:bubble3D", writer);
			if (m_marker.IsInit())
			{
				m_marker->toXML(L"c15:marker", writer);
			}
			if (m_dLbl.IsInit())
			{
				m_dLbl->toXML(L"c15:dLbl", writer);
			}
			writer.WriteString(L"</c15:categoryFilterException>");
		}
		std::wstring CCategoryFilterException::toXML() const
		{
			NSStringUtils::CStringBuilder writer;
			toXML(writer);
			return writer.GetData();
		}
		EElementType CCategoryFilterException::getType() const
		{
			return et_ct_CategoryFilterException;
		}
		CCategoryFilterExceptions::CCategoryFilterExceptions() {}
		CCategoryFilterExceptions::~CCategoryFilterExceptions()
		{
		}
		void CCategoryFilterExceptions::fromXML(XmlUtils::CXmlNode& node) {}
		void CCategoryFilterExceptions::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"categoryFilterException" == sName)
				{
					CCategoryFilterException* pException = new CCategoryFilterException();
					pException->fromXML(oReader);
					m_arrItems.push_back(pException);
				}
			}
		}
		void CCategoryFilterExceptions::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			if (m_arrItems.empty()) return;
			
			writer.WriteString(L"<c15:categoryFilterExceptions>");
			for (size_t i = 0; i < m_arrItems.size(); ++i)
			{
				if (m_arrItems[i])
				{
					m_arrItems[i]->toXML(writer);
				}
			}
			writer.WriteString(L"</c15:categoryFilterExceptions>");
		}
		std::wstring CCategoryFilterExceptions::toXML() const
		{
			NSStringUtils::CStringBuilder writer;
			toXML(writer);
			return writer.GetData();
		}
		EElementType CCategoryFilterExceptions::getType() const
		{
			return et_ct_CategoryFilterExceptions;
		}
		CSeriesFiltering::CSeriesFiltering() {}
		CSeriesFiltering::~CSeriesFiltering()
		{
		}
		void CSeriesFiltering::fromXML(XmlUtils::CXmlNode& node) {}
		void CSeriesFiltering::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if (oReader.IsEmptyNode())
				return;

			int nParentDepth = oReader.GetDepth();
			while (oReader.ReadNextSiblingNode(nParentDepth))
			{
				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
				if (L"datalabelsRange" == sName)
				{
					m_dataLabelsRange = oReader;
				}
				else if (L"filteredSeriesTitle" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"tx" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_filteredSeriesTitle = oReader;
				}
				else if (L"filteredCategoryTitle" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"cat" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_filteredCategoryTitle = oReader;
				}
				else if (L"filteredLineSeries" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"ser" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_filteredLineSeries = oReader;
				}
				else if (L"filteredScatterSeries" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"ser" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_filteredScatterSeries = oReader;
				}
				else if (L"filteredBarSeries" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"ser" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_filteredBarSeries = oReader;
				}
				else if (L"filteredAreaSeries" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"ser" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_filteredAreaSeries = oReader;
				}
				else if (L"filteredBubbleSeries" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"ser" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_filteredBubbleSeries = oReader;
				}
				else if (L"filteredSurfaceSeries" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"ser" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_filteredSurfaceSeries = oReader;
				}
				else if (L"filteredPieSeries" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"ser" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_filteredPieSeries = oReader;
				}
				else if (L"fullRef" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"sqref" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_fullRef = oReader.GetText2();
				}
				else if (L"levelRef" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"sqref" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_levelRef = oReader.GetText2();
				}
				else if (L"formulaRef" == sName)
				{
					if (oReader.ReadNextSiblingNode(nParentDepth + 1) && L"sqref" == XmlUtils::GetNameNoNS(oReader.GetName()))
						m_formulaRef = oReader.GetText2();
				}
				else if (L"categoryFilterExceptions" == sName)
				{
					m_categoryFilterExceptions = oReader;
				}
			}
		}
		void CSeriesFiltering::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			if (m_dataLabelsRange.IsInit())
			{
				m_dataLabelsRange->toXML(writer);
			}
			if (m_filteredSeriesTitle.IsInit())
			{
				writer.WriteString(L"<c15:filteredSeriesTitle>");
					m_filteredSeriesTitle->toXML(L"c15:tx", writer);
				writer.WriteString(L"</c15:filteredSeriesTitle>");
			}
			if (m_filteredCategoryTitle.IsInit())
			{
				writer.WriteString(L"<c15:filteredCategoryTitle>");
					m_filteredCategoryTitle->toXML(L"c15:cat", writer);
				writer.WriteString(L"</c15:filteredCategoryTitle>");
			}
			if (m_filteredLineSeries.IsInit())
			{
				writer.WriteString(L"<c15:filteredLineSeries>");
				m_filteredLineSeries->toXML(L"c15:ser", writer);
				writer.WriteString(L"</c15:filteredLineSeries>");
			}
			if (m_filteredScatterSeries.IsInit())
			{
				writer.WriteString(L"<c15:filteredScatterSeries>");
				m_filteredScatterSeries->toXML(L"c15:ser", writer);
				writer.WriteString(L"</c15:filteredScatterSeries>");
			}
			if (m_filteredRadarSeries.IsInit())
			{
				writer.WriteString(L"<c15:filteredRadarSeries>");
				m_filteredRadarSeries->toXML(L"c15:ser", writer);
				writer.WriteString(L"</c15:filteredRadarSeries>");
			}
			if (m_filteredBarSeries.IsInit())
			{
				writer.WriteString(L"<c15:filteredBarSeries>");
				m_filteredBarSeries->toXML(L"c15:ser", writer);
				writer.WriteString(L"</c15:filteredBarSeries>");
			}
			if (m_filteredAreaSeries.IsInit())
			{
				writer.WriteString(L"<c15:filteredAreaSeries>");
				m_filteredAreaSeries->toXML(L"c15:ser", writer);
				writer.WriteString(L"</c15:filteredAreaSeries>");
			}
			if (m_filteredBubbleSeries.IsInit())
			{
				writer.WriteString(L"<c15:filteredBubbleSeries>");
				m_filteredBubbleSeries->toXML(L"c15:ser", writer);
				writer.WriteString(L"</c15:filteredBubbleSeries>");
			}
			if (m_filteredSurfaceSeries.IsInit())
			{
				writer.WriteString(L"<c15:filteredSurfaceSeries>");
				m_filteredSurfaceSeries->toXML(L"c15:ser", writer);
				writer.WriteString(L"</c15:filteredSurfaceSeries>");
			}
			if (m_filteredPieSeries.IsInit())
			{
				writer.WriteString(L"<c15:filteredPieSeries>");
				m_filteredPieSeries->toXML(L"c15:ser", writer);
				writer.WriteString(L"</c15:filteredPieSeries>");
			}
			if (m_fullRef.IsInit())
			{
				writer.WriteString(L"<c15:fullRef>");
				writer.WriteString(L"<c15:sqref>" + *m_fullRef + L"</c15:sqref>");
				writer.WriteString(L"</c15:fullRef>");
			}
			if (m_levelRef.IsInit())
			{
				writer.WriteString(L"<c15:levelRef>");
				writer.WriteString(L"<c15:sqref>" + *m_levelRef + L"</c15:sqref>");
				writer.WriteString(L"</c15:levelRef>");
			}
			if (m_formulaRef.IsInit())
			{
				writer.WriteString(L"<c15:formulaRef>");
				writer.WriteString(L"<c15:sqref>" + *m_formulaRef + L"</c15:sqref>");
				writer.WriteString(L"</c15:formulaRef>");
			}
			if (m_categoryFilterExceptions.IsInit())
			{
				m_categoryFilterExceptions->toXML(writer);
			}
		}
		std::wstring CSeriesFiltering::toXML() const
		{
			NSStringUtils::CStringBuilder writer;
			toXML(writer);
			return writer.GetData();
		}
		EElementType CSeriesFiltering::getType() const
		{
			return et_ct_SeriesFiltering;
		}
	}
}