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

#include "Styles.h"
#include "Docx.h"

#include "Logic/SectionProperty.h"

namespace ComplexTypes
{
	namespace Word
	{
		//--------------------------------------------------------------------------------
		// LsdException 17.7.4.8 (Part 1)
		//--------------------------------------------------------------------------------

		CLsdException::CLsdException()
		{
		}
		CLsdException::~CLsdException()
		{
		}
		void CLsdException::FromXML(XmlUtils::CXmlNode& oNode)
		{
			XmlMacroReadAttributeBase( oNode, L"w:locked",         m_oLocked );
			XmlMacroReadAttributeBase( oNode, L"w:name",           m_sName );
			XmlMacroReadAttributeBase( oNode, L"w:qFormat",        m_oQFormat );
			XmlMacroReadAttributeBase( oNode, L"w:semiHidden",     m_oSemiHidden );
			XmlMacroReadAttributeBase( oNode, L"w:uiPriority",     m_oUiPriority );
			XmlMacroReadAttributeBase( oNode, L"w:unhideWhenUsed", m_oUnhideWhenUsed );
		}
		void CLsdException::FromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes(oReader);

			if ( !oReader.IsEmptyNode() )
				oReader.ReadTillEnd();
		}
		std::wstring CLsdException::ToString() const
		{
			std::wstring sResult;

			ComplexTypes_WriteAttribute( L"w:locked=\"", m_oLocked );

			if ( m_sName.IsInit() )
			{
				sResult += L"w:name=\"";
				sResult += m_sName.get2();
				sResult += L"\" ";
			}

			ComplexTypes_WriteAttribute( L"w:qFormat=\"",        m_oQFormat );
			ComplexTypes_WriteAttribute( L"w:semiHidden=\"",     m_oSemiHidden );
			ComplexTypes_WriteAttribute( L"w:uiPriority=\"",     m_oUiPriority );
			ComplexTypes_WriteAttribute( L"w:unhideWhenUsed=\"", m_oUnhideWhenUsed );

			return sResult;
		}
		void CLsdException::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
			{
				WritingElement_ReadAttributes_Start( oReader )
				WritingElement_ReadAttributes_Read_if     ( oReader, L"w:locked",         m_oLocked )
				WritingElement_ReadAttributes_Read_else_if( oReader, L"w:name",           m_sName )
				WritingElement_ReadAttributes_Read_else_if( oReader, L"w:qFormat",        m_oQFormat )
				WritingElement_ReadAttributes_Read_else_if( oReader, L"w:semiHidden",     m_oSemiHidden )
				WritingElement_ReadAttributes_Read_else_if( oReader, L"w:uiPriority",     m_oUiPriority )
				WritingElement_ReadAttributes_Read_else_if( oReader, L"w:unhideWhenUsed", m_oUnhideWhenUsed )
				WritingElement_ReadAttributes_End( oReader )
			}

	} // Word
} // ComplexTypes

namespace OOX
{
	namespace Logic
	{
		//--------------------------------------------------------------------------------
		// CTableStyleProperties
		//--------------------------------------------------------------------------------

		CTableStyleProperties::CTableStyleProperties()
		{
		}		
		CTableStyleProperties::~CTableStyleProperties()
		{
		}
		const CTableStyleProperties& CTableStyleProperties::operator=(const XmlUtils::CXmlNode &oNode)
		{
			fromXML( (XmlUtils::CXmlNode &)oNode );
			return (*this);
		}
		const CTableStyleProperties& CTableStyleProperties::operator=(const XmlUtils::CXmlLiteReader& oReader)
		{
			fromXML( (XmlUtils::CXmlLiteReader&)oReader );
			return (*this);
		}
		void CTableStyleProperties::fromXML(XmlUtils::CXmlNode& oNode)
		{
			if ( L"w:tblStylePr" != oNode.GetName() )
				return;

			XmlMacroReadAttributeBase( oNode, L"w:type", m_oType );

			XmlUtils::CXmlNode oChild;
			WritingElement_ReadNode( oNode, oChild, L"w:pPr",   m_oParPr );
			WritingElement_ReadNode( oNode, oChild, L"w:rPr",   m_oRunPr );
			WritingElement_ReadNode( oNode, oChild, L"w:tblPr", m_oTblPr );
			WritingElement_ReadNode( oNode, oChild, L"w:tcPr",  m_oTcPr );
			WritingElement_ReadNode( oNode, oChild, L"w:trPr",  m_oTrPr );
		}
		void CTableStyleProperties::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes( oReader );

			if ( oReader.IsEmptyNode() )
				return;

			int nParentDepth = oReader.GetDepth();
			while( oReader.ReadNextSiblingNode( nParentDepth ) )
			{
				std::wstring sName = oReader.GetName();
				if      ( L"w:pPr" == sName ) m_oParPr = oReader;
				else if ( L"w:rPr" == sName ) m_oRunPr = oReader;
				else if ( L"w:tblPr" == sName ) m_oTblPr = oReader;
				else if ( L"w:tcPr" == sName ) m_oTcPr = oReader;
				else if ( L"w:trPr" == sName ) m_oTrPr = oReader;
			}
		}
		std::wstring CTableStyleProperties::toXML() const
		{
			std::wstring sResult;

			if ( m_oType.IsInit() )
			{
				sResult = L"<w:tblStylePr w:type=\"";
				sResult += m_oType->ToString();
				sResult += L"\">";
			}
			else
				sResult = L"<w:tblStylePr>";

			WritingElement_WriteNode_2( m_oParPr );
			WritingElement_WriteNode_2( m_oRunPr );
			WritingElement_WriteNode_2( m_oTblPr );
			WritingElement_WriteNode_2( m_oTrPr );
			WritingElement_WriteNode_2( m_oTcPr );

			sResult += L"</w:tblStylePr>";

			return sResult;
		}
		EElementType CTableStyleProperties::getType() const
		{
			return et_w_tblStylePr;
		}
		const CTableStyleProperties CTableStyleProperties::Merge(const CTableStyleProperties& oPrev, const CTableStyleProperties& oCurrent)
		{
			CTableStyleProperties oProperties;
			oProperties.m_oType = Merge( oPrev.m_oType, oCurrent.m_oType );
			oProperties.m_oParPr = Merge( oPrev.m_oParPr, oCurrent.m_oParPr );
			oProperties.m_oRunPr = Merge( oPrev.m_oRunPr, oCurrent.m_oRunPr );
			oProperties.m_oTblPr = Merge( oPrev.m_oTblPr, oCurrent.m_oTblPr );
			oProperties.m_oTcPr = Merge( oPrev.m_oTcPr, oCurrent.m_oTcPr );
			oProperties.m_oTrPr = Merge( oPrev.m_oTrPr, oCurrent.m_oTrPr );

			return oProperties;
		}
		void CTableStyleProperties::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
			{
				WritingElement_ReadAttributes_Start( oReader )
				WritingElement_ReadAttributes_ReadSingle( oReader, L"w:type", m_oType )
				WritingElement_ReadAttributes_End( oReader )
			}
	}
	//--------------------------------------------------------------------------------
	// DocDefaults 17.7.5.1 (Part 1)
	//--------------------------------------------------------------------------------

		CDocDefaults::CDocDefaults()
		{
		}		
		CDocDefaults::~CDocDefaults()
		{
		}
		const CDocDefaults& CDocDefaults::operator=(const XmlUtils::CXmlNode &oNode)
		{
			fromXML( (XmlUtils::CXmlNode &)oNode );
			return *this;
		}
		const CDocDefaults& CDocDefaults::operator=(const XmlUtils::CXmlLiteReader& oReader)
		{
			fromXML( (XmlUtils::CXmlLiteReader&)oReader );
			return *this;
		}
		void CDocDefaults::fromXML(XmlUtils::CXmlNode& oNode)
		{
			if ( L"w:docDefaults" != oNode.GetName() )
				return;

			XmlUtils::CXmlNode oDefault;
			XmlUtils::CXmlNode oPr;

			if ( oNode.GetNode( L"w:pPrDefault", oDefault ) )
			{
				if ( oDefault.GetNode( L"w:pPr", oPr ) )
					m_oParPr = oPr;
			}

			if ( oNode.GetNode( L"w:rPrDefault", oDefault ) )
			{
				if ( oDefault.GetNode( L"w:rPr", oPr ) )
					m_oRunPr = oPr;
			}

		}
		void CDocDefaults::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if ( oReader.IsEmptyNode() )
				return;

			int nParentDepth = oReader.GetDepth();
			while( oReader.ReadNextSiblingNode( nParentDepth ) )
			{
				std::wstring sName = oReader.GetName();
				if ( L"w:pPrDefault" == sName && !oReader.IsEmptyNode() )
				{
					int nParentDepth2 = oReader.GetDepth();
					while( oReader.ReadNextSiblingNode( nParentDepth2 ) )
					{
						sName = oReader.GetName();
						if ( L"w:pPr" == sName )
							m_oParPr = oReader;
					}
				}
				else if ( L"w:rPrDefault" == sName && !oReader.IsEmptyNode() )
				{
					int nParentDepth2 = oReader.GetDepth();
					while( oReader.ReadNextSiblingNode( nParentDepth2 ) )
					{
						sName = oReader.GetName();
						if ( L"w:rPr" == sName )
							m_oRunPr = oReader;
					}
				}
			}
		}
		std::wstring CDocDefaults::toXML() const
		{
			std::wstring sResult = L"<w:docDefaults>";

			if ( m_oParPr.IsInit() )
			{
				sResult += L"<w:pPrDefault>";
				sResult += m_oParPr->toXML();
				sResult += L"</w:pPrDefault>";
			}

			if ( m_oRunPr.IsInit() )
			{
				sResult += L"<w:rPrDefault>";
				sResult += m_oRunPr->toXML();
				sResult += L"</w:rPrDefault>";
			}

			sResult += L"</w:docDefaults>";

			return sResult;
		}
		EElementType CDocDefaults::getType() const
		{
			return et_w_docDefaults;
		}

	//--------------------------------------------------------------------------------
	// LatentStyles 17.7.4.6 (Part 1)
	//--------------------------------------------------------------------------------

		CLatentStyles::CLatentStyles()
		{
		}		
		CLatentStyles::~CLatentStyles()
		{
			for ( unsigned int nIndex = 0; nIndex < m_arrLsdException.size(); nIndex++ )
			{
				if ( m_arrLsdException[nIndex] ) delete m_arrLsdException[nIndex];
				m_arrLsdException[nIndex] = NULL;
			}
			m_arrLsdException.clear();
		}
		const CLatentStyles& CLatentStyles::operator=(const XmlUtils::CXmlNode &oNode)
		{
			fromXML( (XmlUtils::CXmlNode &)oNode );
			return *this;
		}
		const CLatentStyles& CLatentStyles::operator=(const XmlUtils::CXmlLiteReader& oReader)
		{
			fromXML( (XmlUtils::CXmlLiteReader&)oReader );
			return *this;
		}
		void CLatentStyles::fromXML(XmlUtils::CXmlNode& oNode)
		{
			if ( L"w:latentStyles" != oNode.GetName() )
				return;

			XmlMacroReadAttributeBase( oNode, L"w:count",             m_oCount );
			XmlMacroReadAttributeBase( oNode, L"w:defLockedState",    m_oDefLockedState );
			XmlMacroReadAttributeBase( oNode, L"w:defQFormat",        m_oDefQFormat );
			XmlMacroReadAttributeBase( oNode, L"w:defSemiHidden",     m_oDefSemiHidden );
			XmlMacroReadAttributeBase( oNode, L"w:defUIPriority",     m_oDefUiPriority );
			XmlMacroReadAttributeBase( oNode, L"w:defUnhideWhenUsed", m_oDefUnhideWhenUsed );

			std::vector<XmlUtils::CXmlNode> oList;
			if ( oNode.GetNodes( L"w:lsdException", oList ) )
			{
				for ( size_t nIndex = 0; nIndex < oList.size(); nIndex++ )
				{
					XmlUtils::CXmlNode oLsdNode = oList[nIndex];
					if (oLsdNode.IsValid())
					{
						ComplexTypes::Word::CLsdException *oLsdException = new ComplexTypes::Word::CLsdException();
						*oLsdException = oLsdNode;

						if (oLsdException ) m_arrLsdException.push_back( oLsdException );
					}
				}
			}
		}
		void CLatentStyles::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes( oReader );

			if ( oReader.IsEmptyNode() )
				return;

			int nParentDepth = oReader.GetDepth();
			while( oReader.ReadNextSiblingNode( nParentDepth ) )
			{
				std::wstring sName = oReader.GetName();
				if ( L"w:lsdException" == sName )
				{
					ComplexTypes::Word::CLsdException *oLsdException = new ComplexTypes::Word::CLsdException();
					*oLsdException = oReader;

					if (oLsdException) m_arrLsdException.push_back( oLsdException );
				}
			}
		}
		std::wstring CLatentStyles::toXML() const
		{
			std::wstring sResult;
			sResult += L"<w:latentStyles w:count=\"" + std::to_wstring(m_oCount.GetValue())	+ L"\"";
			sResult += L" w:defLockedState=\""		+ m_oDefLockedState.ToString()	+ L"\"";
			sResult += L" w:defQFormat=\""			+ m_oDefQFormat.ToString()		+ L"\"";
			sResult += L" w:defSemiHidden=\""		+ m_oDefSemiHidden.ToString()	+ L"\"";
			sResult += L" w:defUIPriority=\""		+ std::to_wstring(m_oDefUiPriority.GetValue()) + L"\"";
			sResult += L" w:defUnhideWhenUsed=\""	+ m_oDefUnhideWhenUsed.ToString();
			sResult += L"\">";

			for (unsigned int nIndex = 0; nIndex < m_arrLsdException.size(); nIndex++ )
			{
				sResult += L"<w:lsdException ";
				if (m_arrLsdException[nIndex])
					sResult += m_arrLsdException[nIndex]->ToString();
				sResult += L"/>";
			}

			sResult += L"</w:latentStyles>";

			return sResult;
		}
		EElementType CLatentStyles::getType() const
		{
			return et_w_latentStyles;
		}
		void CLatentStyles::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			m_oDefUiPriority.SetValue(99);

			WritingElement_ReadAttributes_Start( oReader )
			WritingElement_ReadAttributes_Read_if     ( oReader, L"w:count",             m_oCount )
			WritingElement_ReadAttributes_Read_else_if( oReader, L"w:defLockedState",    m_oDefLockedState )
			WritingElement_ReadAttributes_Read_else_if( oReader, L"w:defQFormat",        m_oDefQFormat )
			WritingElement_ReadAttributes_Read_else_if( oReader, L"w:defSemiHidden",     m_oDefSemiHidden )
			WritingElement_ReadAttributes_Read_else_if( oReader, L"w:defUIPriority",     m_oDefUiPriority )
			WritingElement_ReadAttributes_Read_else_if(oReader,  L"w:defUnhideWhenUsed", m_oDefUnhideWhenUsed )
			WritingElement_ReadAttributes_End( oReader )
		}

	//--------------------------------------------------------------------------------
	// Style 17.7.4.17 (Part 1)
	//--------------------------------------------------------------------------------

		CStyle::CStyle(OOX::Document *pMain) : WritingElement(pMain)
		{
		}		
		CStyle::~CStyle()
		{
			ClearItems();
		}
		void CStyle::ClearItems()
		{
			for ( unsigned int nIndex = 0; nIndex < m_arrTblStylePr.size(); nIndex++ )
			{
				if ( m_arrTblStylePr[nIndex] ) delete m_arrTblStylePr[nIndex];
				m_arrTblStylePr[nIndex] = NULL;
			}
			m_arrTblStylePr.clear();
		}
		const CStyle& CStyle::operator=(const XmlUtils::CXmlNode &oNode)
		{
			ClearItems();
			fromXML( (XmlUtils::CXmlNode &)oNode );
			return *this;
		}
		const CStyle& CStyle::operator=(const XmlUtils::CXmlLiteReader& oReader)
		{
			ClearItems();
			fromXML( (XmlUtils::CXmlLiteReader&)oReader );
			return *this;
		}
		void CStyle::fromXML(XmlUtils::CXmlNode& oNode)
		{
			if ( L"w:style" != oNode.GetName() )
				return;

			XmlMacroReadAttributeBase( oNode, L"w:customStyle", m_oCustomStyle );
			XmlMacroReadAttributeBase( oNode, L"w:default",     m_oDefault );
			XmlMacroReadAttributeBase( oNode, L"w:styleId",     m_sStyleId );
			XmlMacroReadAttributeBase( oNode, L"w:type",        m_oType );

			XmlUtils::CXmlNode oChild;

			WritingElement_ReadNode( oNode, oChild, L"w:aliases",         m_oAliases );
			WritingElement_ReadNode( oNode, oChild, L"w:autoRedefine",    m_oAutoRedefine );
			WritingElement_ReadNode( oNode, oChild, L"w:basedOn",         m_oBasedOn );
			WritingElement_ReadNode( oNode, oChild, L"w:hidden",          m_oHidden );
			WritingElement_ReadNode( oNode, oChild, L"w:link",            m_oLink );
			WritingElement_ReadNode( oNode, oChild, L"w:locked",          m_oLocked );
			WritingElement_ReadNode( oNode, oChild, L"w:name",            m_oName );
			WritingElement_ReadNode( oNode, oChild, L"w:next",            m_oNext );
			WritingElement_ReadNode( oNode, oChild, L"w:personal",        m_oPersonal );
			WritingElement_ReadNode( oNode, oChild, L"w:personalCompose", m_oPersonalCompose );
			WritingElement_ReadNode( oNode, oChild, L"w:personalReply",   m_oPersonalReply );
			WritingElement_ReadNode( oNode, oChild, L"w:pPr",             m_oParPr );
			WritingElement_ReadNode( oNode, oChild, L"w:qFormat",         m_oQFormat );
			WritingElement_ReadNode( oNode, oChild, L"w:rPr",             m_oRunPr );
			WritingElement_ReadNode( oNode, oChild, L"w:rsid",            m_oRsid );
			WritingElement_ReadNode( oNode, oChild, L"w:semiHidden",      m_oSemiHidden );
			WritingElement_ReadNode( oNode, oChild, L"w:tblPr",           m_oTblPr );

			std::vector<XmlUtils::CXmlNode> oList;
			if ( oNode.GetNodes( L"w:tblStylePr", oList ) )
			{
				for ( size_t nIndex = 0; nIndex < oList.size(); nIndex++ )
				{
					XmlUtils::CXmlNode & oTblStylePrNode = oList[nIndex];
					if (oTblStylePrNode.IsValid())
					{
						OOX::Logic::CTableStyleProperties *oTblStylePr = new OOX::Logic::CTableStyleProperties();
						*oTblStylePr = oTblStylePrNode;

						if (oTblStylePr) m_arrTblStylePr.push_back( oTblStylePr );
					}
				}
			}

			WritingElement_ReadNode( oNode, oChild, L"w:tcPr",            m_oTcPr );
			WritingElement_ReadNode( oNode, oChild, L"w:trPr",            m_oTrPr );
			WritingElement_ReadNode( oNode, oChild, L"w:uiPriority",      m_oUiPriority );
			WritingElement_ReadNode( oNode, oChild, L"w:unhideWhenUsed",  m_oUnhideWhenUsed );
		}
		void CStyle::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes( oReader );

			if ( oReader.IsEmptyNode() )
				return;

			int nParentDepth = oReader.GetDepth();
			while( oReader.ReadNextSiblingNode( nParentDepth ) )
			{
				std::wstring sName = oReader.GetName();

				if      ( L"w:aliases" == sName ) m_oAliases = oReader;
				else if ( L"w:autoRedefine" == sName ) m_oAutoRedefine = oReader;
				else if ( L"w:basedOn" == sName ) m_oBasedOn = oReader;
				else if ( L"w:hidden" == sName ) m_oHidden = oReader;
				else if ( L"w:link" == sName ) m_oLink = oReader;
				else if ( L"w:locked" == sName ) m_oLocked = oReader;
				else if ( L"w:name" == sName ) m_oName = oReader;
				else if ( L"w:next" == sName ) m_oNext = oReader;
				else if ( L"w:personal" == sName ) m_oPersonal = oReader;
				else if ( L"w:personalCompose" == sName ) m_oPersonalCompose = oReader;
				else if ( L"w:personalReply" == sName ) m_oPersonalReply = oReader;
				else if ( L"w:pPr" == sName ) m_oParPr = oReader;
				else if ( L"w:qFormat" == sName ) m_oQFormat = oReader;
				else if ( L"w:rPr" == sName ) m_oRunPr = oReader;
				else if ( L"w:rsid" == sName ) m_oRsid = oReader;
				else if ( L"w:semiHidden" == sName ) m_oSemiHidden = oReader;
				else if ( L"w:tblPr" == sName ) m_oTblPr = oReader;
				else if ( L"w:tblStylePr" == sName )
				{
					OOX::Logic::CTableStyleProperties *oTblStylePr = new OOX::Logic::CTableStyleProperties();
					*oTblStylePr = oReader;

					m_arrTblStylePr.push_back( oTblStylePr );
				}
				else if ( L"w:tcPr" == sName ) m_oTcPr = oReader;
				else if ( L"w:trPr" == sName ) m_oTrPr = oReader;
				else if ( L"w:uiPriority" == sName ) m_oUiPriority = oReader;
				else if ( L"w:unhideWhenUsed" == sName ) m_oUnhideWhenUsed = oReader;
			}
		}
		std::wstring CStyle::toXML() const
		{
			std::wstring sResult = L"<w:style ";

			ComplexTypes_WriteAttribute( L"w:customStyle=\"", m_oCustomStyle );
			ComplexTypes_WriteAttribute( L"w:default=\"",     m_oDefault );
			if ( m_sStyleId.IsInit() )
			{
				sResult += L"w:styleId=\"" + *m_sStyleId + L"\" ";
			}
			ComplexTypes_WriteAttribute( L"w:type=\"", m_oType );

			sResult += L">";

			WritingElement_WriteNode_1( L"<w:name ", m_oName );
			WritingElement_WriteNode_1( L"<w:aliases ", m_oAliases );
			WritingElement_WriteNode_1( L"<w:basedOn ", m_oBasedOn );
			WritingElement_WriteNode_1( L"<w:next ", m_oNext );
			WritingElement_WriteNode_1( L"<w:link ", m_oLink );
			WritingElement_WriteNode_1( L"<w:autoRedefine ", m_oAutoRedefine );
			WritingElement_WriteNode_1( L"<w:hidden ", m_oHidden );
			WritingElement_WriteNode_1( L"<w:uiPriority ", m_oUiPriority );
			WritingElement_WriteNode_1( L"<w:semiHidden ", m_oSemiHidden );
			WritingElement_WriteNode_1( L"<w:unhideWhenUsed ",  m_oUnhideWhenUsed );
			WritingElement_WriteNode_1( L"<w:qFormat ", m_oQFormat );
			WritingElement_WriteNode_1( L"<w:locked ", m_oLocked );
			WritingElement_WriteNode_1( L"<w:personal ", m_oPersonal );
			WritingElement_WriteNode_1( L"<w:personalCompose ", m_oPersonalCompose );
			WritingElement_WriteNode_1( L"<w:personalReply ", m_oPersonalReply );
			WritingElement_WriteNode_1( L"<w:rsid ", m_oRsid );
			WritingElement_WriteNode_2( m_oParPr );
			WritingElement_WriteNode_2( m_oRunPr );
			WritingElement_WriteNode_2( m_oTblPr );
			WritingElement_WriteNode_2( m_oTrPr );
			WritingElement_WriteNode_2( m_oTcPr );

			for ( unsigned int nIndex = 0; nIndex < m_arrTblStylePr.size(); nIndex++ )
			{
				if (m_arrTblStylePr[nIndex])
					sResult += m_arrTblStylePr[nIndex]->toXML();
			}


			sResult += L"</w:style>";

			return sResult;
		}
		EElementType CStyle::getType() const
		{
			return et_w_style;
		}
		void CStyle::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start( oReader )
			WritingElement_ReadAttributes_Read_if     ( oReader, L"w:customStyle", m_oCustomStyle )
			WritingElement_ReadAttributes_Read_else_if( oReader, L"w:default",     m_oDefault )
			WritingElement_ReadAttributes_Read_else_if( oReader, L"w:styleId",     m_sStyleId )
			WritingElement_ReadAttributes_Read_else_if( oReader, L"w:type",        m_oType )
			WritingElement_ReadAttributes_End( oReader )
		}

	//--------------------------------------------------------------------------------
	// Styles 17.7.4.18 (Part 1)
	//--------------------------------------------------------------------------------
		CStyles::CStyles(){}
		CStyles::CStyles(OOX::Document *pMain) : OOX::File(pMain), WritingElement(pMain)
		{
			CDocx* docx = dynamic_cast<CDocx*>(File::m_pMainDocument);
			if (docx)
			{
				if (docx->m_bGlossaryRead)	docx->m_oGlossary.styles = this;
				else						docx->m_oMain.styles = this;
			}
		}
		CStyles::CStyles(OOX::Document *pMain, const CPath& oPath) : OOX::File(pMain), WritingElement(pMain)
		{
			CDocx* docx = dynamic_cast<CDocx*>(File::m_pMainDocument);
			if (docx)
			{
				if (docx->m_bGlossaryRead)	docx->m_oGlossary.styles = this;
				else						docx->m_oMain.styles = this;
			}

			read( oPath );
		}
		CStyles::CStyles(XmlUtils::CXmlNode& oNode) : File(NULL), WritingElement(NULL)
		{
			fromXML( oNode );
		}
		CStyles::CStyles(XmlUtils::CXmlLiteReader& oReader) : File(NULL), WritingElement(NULL)
		{
			fromXML( oReader );
		}
		CStyles::~CStyles()
		{
			for (size_t nIndex = 0; nIndex < m_arrStyle.size(); nIndex++ )
			{
				if ( m_arrStyle[nIndex] )delete m_arrStyle[nIndex];
				m_arrStyle[nIndex] = NULL;
			}
			m_arrStyle.clear();

			m_mapStyleNames.clear();
			m_mapStyleDefaults.clear();
			m_mapEmbeddedStyleNames.clear();
		}
		const CStyles& CStyles::operator =(const XmlUtils::CXmlNode& oNode)
		{
			fromXML( (XmlUtils::CXmlNode&)oNode );
			return *this;
		}
		const CStyles& CStyles::operator =(const XmlUtils::CXmlLiteReader& oReader)
		{
			fromXML( (XmlUtils::CXmlLiteReader&)oReader );
			return *this;
		}
		void CStyles::read(const CPath& oFilePath)
		{
			XmlUtils::CXmlLiteReader oReader;

			if ( !oReader.FromFile( oFilePath.GetPath() ) )
				return;

			if ( !oReader.ReadNextNode() )
				return;

			std::wstring sName = oReader.GetName();
			if ( L"w:styles" == sName)
			{
				fromXML(oReader);
			}
		}
		void CStyles::write(const CPath& oFilePath, const CPath& oDirectory, CContentTypes& oContent) const
		{
			std::wstring sXml = L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
			sXml  += toXML();

			CDirectory::SaveToFile( oFilePath.GetPath(), sXml );

			oContent.Registration(type().OverrideType(), oDirectory, oFilePath.GetFilename());
		}
		const OOX::FileType CStyles::type() const
		{
			return FileTypes::Style;
		}
		const CPath CStyles::DefaultDirectory() const
		{
			return type().DefaultDirectory();
		}
		const CPath CStyles::DefaultFileName() const
		{
			return type().DefaultFileName();
		}
		void CStyles::fromXML(XmlUtils::CXmlNode& oNode)
		{
		}
		void CStyles::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			if ( oReader.IsEmptyNode() )
				return;

			int nStylesDepth = oReader.GetDepth();
			while ( oReader.ReadNextSiblingNode( nStylesDepth ) )
			{
				std::wstring sName = oReader.GetName();

				if ( L"w:style" == sName )
				{
					OOX::CStyle *oStyle = new OOX::CStyle();
					*oStyle = oReader;

					if (oStyle)
					{
						if (oStyle->m_sStyleId.IsInit())
						{
							m_mapStyleNames.insert(std::make_pair(oStyle->m_sStyleId.get(), m_arrStyle.size()));
						}
						if ((oStyle->m_oType.IsInit() && oStyle->m_oDefault.IsInit()) && (oStyle->m_oDefault->ToBool()))
						{
							m_mapStyleDefaults.insert(std::make_pair(oStyle->m_oType->GetValue(), m_arrStyle.size()));
						}
						m_arrStyle.push_back( oStyle );
					}
				}
				else if ( L"w:docDefaults" == sName )
					m_oDocDefaults = oReader;
				else if ( L"w:latentStyles" == sName )
					m_oLatentStyles = oReader;
			}
		}
		std::wstring CStyles::toXML() const
		{
			std::wstring sXml = L"<w:styles xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" mc:Ignorable=\"w14 w15\">";

			if ( m_oDocDefaults.IsInit() )
				sXml += m_oDocDefaults->toXML();

			if ( m_oLatentStyles.IsInit() )
				sXml += m_oLatentStyles->toXML();

			for (size_t nIndex = 0; nIndex < m_arrStyle.size(); nIndex++ )
			{
				if (m_arrStyle[nIndex])
					sXml += m_arrStyle[nIndex]->toXML();
			}
			sXml += L"</w:styles>";
			return sXml;
		}
		EElementType CStyles::getType() const
		{
			return et_w_styles;
		}

} // namespace OOX