/*
 * (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 "Fills.h"

#include "../../Common/SimpleTypes_Shared.h"
#include "../../Common/SimpleTypes_Spreadsheet.h"

#include "../../XlsbFormat/Biff12_records/Fill.h"
#include "../../XlsbFormat/Biff12_records/BeginFills.h"
#include "../../../MsBinaryFile/XlsFile/Format/Logic/Biff_structures/BiffStructure.h"

#include "../../XlsbFormat/Biff12_unions/FILLS.h"

namespace OOX
{
	namespace Spreadsheet
	{
		CPatternFill::CPatternFill()
		{
		}
		CPatternFill::~CPatternFill()
		{
		}
		void CPatternFill::fromXML(XmlUtils::CXmlNode& node)
		{
		}
		std::wstring CPatternFill::toXML() const
		{
			return L"";
		}
		void CPatternFill::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			toXMLWithNS(writer, L"", L"patternFill", L"");
		}
		void CPatternFill::toXMLWithNS(NSStringUtils::CStringBuilder& writer, const std::wstring &node_ns, const std::wstring &node_name, const std::wstring &child_ns) const
		{
			writer.StartNodeWithNS(node_ns, node_name);
			writer.StartAttributes();
			WritingStringNullableAttrString(L"patternType", m_oPatternType, m_oPatternType->ToString());
			if(m_oBgColor.IsInit() || m_oFgColor.IsInit())
			{
				writer.EndAttributes();
				if(m_oBgColor.IsInit() && m_oFgColor.IsInit())
				{
					m_oFgColor->toXMLWithNS(writer, child_ns, L"fgColor", child_ns);
					m_oBgColor->toXMLWithNS(writer, child_ns, L"bgColor", child_ns);
				}
				else if(m_oFgColor.IsInit())
				{
					m_oFgColor->toXMLWithNS(writer, child_ns, L"fgColor", child_ns);
				}
				else if(m_oBgColor.IsInit())
				{
					m_oBgColor->toXMLWithNS(writer, child_ns, L"bgColor", child_ns);
				}

				writer.EndNodeWithNS(node_ns, node_name);
			}
			else
				writer.EndAttributesAndNode();
		}
		void CPatternFill::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes( oReader );

			if ( oReader.IsEmptyNode() )
				return;

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

				if ( L"bgColor" == sName )
					m_oBgColor = oReader;
				else if ( L"fgColor" == sName )
					m_oFgColor = oReader;
			}
		}
		void CPatternFill::fromBin(XLS::BaseObjectPtr& obj)
		{
			ReadAttributes(obj);
		}
		void CPatternFill::toBin(XLS::BaseObjectPtr obj)
		{
			auto ptr = static_cast<XLSB::Fill*>(obj.get());
			if(m_oPatternType.IsInit())
			{
				if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeNone)
					ptr->fls = 0x00;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeSolid)
					ptr->fls = 0x01;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeMediumGray)
					ptr->fls = 0x02;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkGray)
					ptr->fls = 0x03;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeLightGray)
					ptr->fls = 0x04;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkHorizontal)
					ptr->fls = 0x05;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkVertical)
					ptr->fls = 0x06;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkDown)
					ptr->fls = 0x07;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkUp)
					ptr->fls = 0x08;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkGrid)
					ptr->fls = 0x09;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkTrellis)
					ptr->fls = 0x0A;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeLightHorizontal)
					ptr->fls = 0x0B;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeLightVertical)
					ptr->fls = 0x0C;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeLightDown)
					ptr->fls = 0x0D;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeLightUp)
					ptr->fls = 0x0E;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeLightGrid)
					ptr->fls = 0x0F;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeLightTrellis)
					ptr->fls = 0x10;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeGray125)
					ptr->fls = 0x11;
				else if (m_oPatternType == SimpleTypes::Spreadsheet::EPatternType::patterntypeGray0625)
					ptr->fls = 0x12;
				else
					ptr->fls = 0x00;
			}
			else
					ptr->fls = 0x00;

			if(m_oBgColor.IsInit())
				ptr->brtColorBack = m_oBgColor->toColor();
            else
            {   m_oBgColor.Init();
                ptr->brtColorBack = m_oBgColor->GetDefaultColor();
            }
			if(m_oFgColor.IsInit())
				ptr->brtColorFore = m_oFgColor->toColor();
            else
            {
                m_oFgColor.Init();
                ptr->brtColorFore = m_oFgColor->GetDefaultColor();
            }
		}
		EElementType CPatternFill::getType () const
		{
			return et_x_PatternFill;
		}
		void CPatternFill::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start( oReader )
				WritingElement_ReadAttributes_Read_if ( oReader, L"patternType", m_oPatternType )
			WritingElement_ReadAttributes_End( oReader )
		}
		void CPatternFill::ReadAttributes(XLS::BaseObjectPtr& obj)
			{
				auto ptr = static_cast<XLSB::Fill*>(obj.get());
				if(ptr != nullptr)
				{
					switch(ptr->fls)
					{
						case 0x00:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeNone; break;
						case 0x01:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeSolid; break;
						case 0x02:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeMediumGray; break;
						case 0x03:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkGray; break;
						case 0x04:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeLightGray; break;
						case 0x05:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkHorizontal; break;
						case 0x06:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkVertical; break;
						case 0x07:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkDown; break;
						case 0x08:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkUp; break;
						case 0x09:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkGrid; break;
						case 0x0A:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeDarkTrellis; break;
						case 0x0B:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeLightHorizontal; break;
						case 0x0C:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeLightVertical; break;
						case 0x0D:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeLightDown; break;
						case 0x0E:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeLightUp; break;
						case 0x0F:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeLightGrid; break;
						case 0x10:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeLightTrellis; break;
						case 0x11:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeGray125; break;
						case 0x12:
							m_oPatternType = SimpleTypes::Spreadsheet::EPatternType::patterntypeGray0625; break;
					}

					m_oBgColor.Init();
					m_oBgColor->fromBin(dynamic_cast<XLS::BaseObject*>(&ptr->brtColorBack));

					m_oFgColor.Init();
					m_oFgColor->fromBin(dynamic_cast<XLS::BaseObject*>(&ptr->brtColorFore));
				}
			}

		CGradientStop::CGradientStop()
		{
		}
		CGradientStop::~CGradientStop()
		{
		}
		void CGradientStop::fromXML(XmlUtils::CXmlNode& node)
		{
		}
		std::wstring CGradientStop::toXML() const
		{
			return L"";
		}
		void CGradientStop::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			toXMLWithNS(writer, L"", L"stop", L"");
		}
		void CGradientStop::toXMLWithNS(NSStringUtils::CStringBuilder& writer, const std::wstring &node_ns, const std::wstring &node_name, const std::wstring &child_ns) const
		{
			writer.StartNodeWithNS(node_ns, node_name);
			writer.StartAttributes();
			WritingStringNullableAttrDouble(L"position", m_oPosition, m_oPosition->GetValue());
			writer.EndAttributes();
			if (m_oColor.IsInit())
			{
				m_oColor->toXMLWithNS(writer, child_ns, L"color", child_ns);
			}
			writer.EndNodeWithNS(node_ns, node_name);
		}
		void CGradientStop::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes( oReader );

			if ( oReader.IsEmptyNode() )
				return;

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

				if ( L"color" == sName )
					m_oColor = oReader;
			}
		}
		void CGradientStop::fromBin(XLS::BiffStructure* obj)
		{
			auto ptr = static_cast<XLSB::GradientStop*>(obj);
			if(ptr != nullptr)
			{
				m_oPosition = ptr->xnumPosition.data.value;
				m_oColor.Init();
				m_oColor->fromBin(dynamic_cast<XLS::BaseObject*>(&ptr->brtColor));
			}
		}
		void CGradientStop::toBin(XLS::BaseObjectPtr obj)
		{
			auto ptr = static_cast<XLSB::Fill*>(obj.get());
			XLSB::GradientStop stop;
			if(m_oPosition.IsInit())
				stop.xnumPosition.data.value = m_oPosition->GetValue();
			else
				stop.xnumPosition.data.value = 0;
			if(m_oColor.IsInit())
			{
				stop.brtColor = m_oColor->toColor();
			}
			ptr->xfillGradientStop.push_back(stop);
		}

		EElementType CGradientStop::getType () const
		{
			return et_x_GradientStop;
		}
		void CGradientStop::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
			{
				WritingElement_ReadAttributes_Start( oReader )
					WritingElement_ReadAttributes_Read_if ( oReader, L"position", m_oPosition )
				WritingElement_ReadAttributes_End( oReader )
			}

		CGradientFill::CGradientFill()
		{
		}
		CGradientFill::~CGradientFill()
		{
		}
		void CGradientFill::fromXML(XmlUtils::CXmlNode& node)
		{
		}
		std::wstring CGradientFill::toXML() const
		{
			return L"";
		}
		void CGradientFill::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			toXMLWithNS(writer, L"", L"gradientFill", L"");
		}
		void CGradientFill::toXMLWithNS(NSStringUtils::CStringBuilder& writer, const std::wstring &node_ns, const std::wstring &node_name, const std::wstring &child_ns) const
		{
			writer.StartNodeWithNS(node_ns, node_name);
			writer.StartAttributes();
			WritingStringNullableAttrString(L"type", m_oType, m_oType->ToString());
			WritingStringNullableAttrDouble(L"left", m_oLeft, m_oLeft->GetValue());
			WritingStringNullableAttrDouble(L"right", m_oRight, m_oRight->GetValue());
			WritingStringNullableAttrDouble(L"top", m_oTop, m_oTop->GetValue());
			WritingStringNullableAttrDouble(L"bottom", m_oBottom, m_oBottom->GetValue());
			WritingStringNullableAttrDouble(L"degree", m_oDegree, m_oDegree->GetValue());
			writer.EndAttributes();
			for(size_t i = 0; i < m_arrItems.size(); ++i)
			{
				m_arrItems[i]->toXMLWithNS(writer, child_ns, L"stop", child_ns);
			}
			writer.EndNodeWithNS(node_ns, node_name);
		}
		void CGradientFill::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes( oReader );

			if ( oReader.IsEmptyNode() )
				return;

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

				if ( L"stop" == sName )
				{
					CGradientStop* pGradientStop = new CGradientStop();
					*pGradientStop = oReader;
					m_arrItems.push_back(pGradientStop);
				}
			}
		}
		void CGradientFill::fromBin(XLS::BaseObjectPtr& obj)
		{
			ReadAttributes(obj);

			auto ptr = static_cast<XLSB::Fill*>(obj.get());
			if(ptr != nullptr)
			{
				for(auto &gradStop : ptr->xfillGradientStop)
				{
					auto ptrGradStop = new CGradientStop();
					auto ptrBiffStruct = dynamic_cast<XLS::BiffStructure*>(&gradStop);
					ptrGradStop->fromBin(ptrBiffStruct);
					m_arrItems.push_back(ptrGradStop);
				}
			}
		}
		void CGradientFill::toBin(XLS::BaseObjectPtr obj)
		{
			auto ptr = static_cast<XLSB::Fill*>(obj.get());

			if(m_oType.IsInit())
				ptr->iGradientType = m_oType->GetValue();
			else
				ptr->iGradientType = 0;
			if(m_oDegree.IsInit())
				ptr->xnumDegree.data.value = m_oDegree->GetValue();
			else
				ptr->xnumDegree.data.value = 0;
			if(m_oLeft.IsInit())
				ptr->xnumFillToLeft.data.value = m_oLeft->GetValue();
			else
				ptr->xnumFillToLeft.data.value = 0;
			if(m_oRight.IsInit())
				ptr->xnumFillToRight.data.value = m_oRight->GetValue();
			else
				ptr->xnumFillToRight.data.value = 0;
			if(m_oTop .IsInit())
				ptr->xnumFillToTop.data.value = m_oTop->GetValue();
			else
				ptr->xnumFillToTop.data.value = 0;
			if(m_oBottom.IsInit())
				ptr->xnumFillToBottom.data.value = m_oBottom->GetValue();
			else
				ptr->xnumFillToBottom.data.value = 0;

			for(auto i:m_arrItems)
			{
				i->toBin(obj);
			}


		}
		EElementType CGradientFill::getType () const
		{
			return et_x_GradientFill;
		}
		void CGradientFill::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start( oReader )
				WritingElement_ReadAttributes_Read_if     ( oReader, L"bottom",	m_oBottom )
				WritingElement_ReadAttributes_Read_if     ( oReader, L"degree",	m_oDegree )
				WritingElement_ReadAttributes_Read_if     ( oReader, L"left",	m_oLeft )
				WritingElement_ReadAttributes_Read_if     ( oReader, L"right",	m_oRight )
				WritingElement_ReadAttributes_Read_if     ( oReader, L"top",	m_oTop )
				WritingElement_ReadAttributes_Read_if     ( oReader, L"type",	m_oType )
			WritingElement_ReadAttributes_End( oReader )
		}
		void CGradientFill::ReadAttributes(XLS::BaseObjectPtr& obj)
			{
				auto ptr = static_cast<XLSB::Fill*>(obj.get());
				if(ptr != nullptr && ptr->fls == 0x28)
				{
					m_oType         = (SimpleTypes::Spreadsheet::EGradientType)ptr->iGradientType;

					m_oDegree       = ptr->xnumDegree.data.value;
					m_oLeft         = ptr->xnumFillToLeft.data.value;
					m_oRight        = ptr->xnumFillToRight.data.value;
					m_oTop          = ptr->xnumFillToTop.data.value;
					m_oBottom       = ptr->xnumFillToBottom.data.value;
				}
			}

		CFill::CFill()
		{
		}
		CFill::~CFill()
		{
		}
		void CFill::fromXML(XmlUtils::CXmlNode& node)
		{
		}
		std::wstring CFill::toXML() const
		{
			return L"";
		}
		void CFill::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			toXMLWithNS(writer, L"", L"fill", L"");
		}
		void CFill::toXMLWithNS(NSStringUtils::CStringBuilder& writer, const std::wstring &node_ns, const std::wstring &node_name, const std::wstring &child_ns) const
		{
			writer.StartNodeWithNS(node_ns, node_name);
			writer.StartAttributes();
			writer.EndAttributes();
			if (m_oPatternFill.IsInit())
				m_oPatternFill->toXMLWithNS(writer, child_ns, L"patternFill", child_ns);
			if (m_oGradientFill.IsInit())
				m_oGradientFill->toXMLWithNS(writer, child_ns, L"gradientFill", child_ns);
			writer.EndNodeWithNS(node_ns, node_name);
		}
		void CFill::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes( oReader );

			if ( oReader.IsEmptyNode() )
				return;

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

				if ( L"gradientFill" == sName )
					m_oGradientFill = oReader;
				else if ( L"patternFill" == sName )
					m_oPatternFill = oReader;
			}
		}
		void CFill::fromBin(XLS::BaseObjectPtr& obj)
		{
			m_oPatternFill  = obj;
			m_oGradientFill = obj;

			if ((m_oGradientFill.IsInit()) && (false == m_oGradientFill->m_oType.IsInit()))
				m_oGradientFill.reset();
		}
		XLS::BaseObjectPtr CFill::toBin()
		{
			auto ptr(new XLSB::Fill);
			XLS::BaseObjectPtr objectPtr(ptr);

			if(m_oPatternFill.IsInit())
			{
				m_oPatternFill->toBin(objectPtr);
			}
            else
            {
                CColor color;
                ptr->fls = 0;
                ptr->brtColorBack = color.GetDefaultColor();
                ptr->brtColorFore = color.GetDefaultColor();
            }

			if(m_oGradientFill.IsInit())
			{
				m_oGradientFill->toBin(objectPtr);
			}
            else
            {
                ptr->iGradientType = 0;
            }
            ptr->cNumStop = 0;
			return objectPtr;
		}
		EElementType CFill::getType () const
		{
			return et_x_Fill;
		}
		void CFill::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
			{
				if ( oReader.GetAttributesCount() <= 0) return;

				nullable_string sColor, sPatternColor, sPattern;

				WritingElement_ReadAttributes_Start( oReader )
					WritingElement_ReadAttributes_Read_if     ( oReader, _T("ss:PatternColor"), sPatternColor )
					WritingElement_ReadAttributes_Read_else_if( oReader, _T("ss:Pattern"), sPattern )
					WritingElement_ReadAttributes_Read_else_if( oReader, _T("ss:Color"), sColor )
				WritingElement_ReadAttributes_End( oReader )

				if (sColor.IsInit() == false && sPattern.IsInit() == false && sPatternColor.IsInit() == false) return;

				m_oPatternFill.Init();
				if (sColor.IsInit())
				{
					m_oPatternFill->m_oFgColor.Init(); m_oPatternFill->m_oFgColor->m_oRgb.Init();
					m_oPatternFill->m_oFgColor->m_oRgb->FromString(*sColor);
				}
				if (sPatternColor.IsInit())
				{
					m_oPatternFill->m_oBgColor.Init(); m_oPatternFill->m_oBgColor->m_oRgb.Init();
					m_oPatternFill->m_oBgColor->m_oRgb->FromString(*sPatternColor);
				}
				m_oPatternFill->m_oPatternType.Init();
				if (sPattern.IsInit())
				{
					m_oPatternFill->m_oPatternType->FromString(*sPattern);
				}
				else m_oPatternFill->m_oPatternType->FromString(L"Solid");
			}

		CFills::CFills()
		{
		}
		CFills::~CFills()
		{
		}
		void CFills::fromXML(XmlUtils::CXmlNode& node)
		{
		}
		std::wstring CFills::toXML() const
		{
			return L"";
		}
		void CFills::toXML(NSStringUtils::CStringBuilder& writer) const
		{
			writer.WriteString(L"<fills");
			WritingStringNullableAttrInt(L"count", m_oCount, m_oCount->GetValue());
			writer.WriteString(L">");

			for ( size_t i = 0; i < m_arrItems.size(); ++i)
			{
				if (  m_arrItems[i] )
				{
					m_arrItems[i]->toXML(writer);
				}
			}

			writer.WriteString(L"</fills>");
		}
		void CFills::fromXML(XmlUtils::CXmlLiteReader& oReader)
		{
			ReadAttributes( oReader );

			if ( oReader.IsEmptyNode() )
				return;

			int index = 0;

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

				if ( L"fill" == sName )
				{
					CFill* pFill = new CFill();
					*pFill = oReader;

					m_arrItems.push_back( pFill );
					m_mapFills.insert(std::make_pair(index++, pFill));
				}
			}
		}
		void CFills::fromBin(std::vector<XLS::BaseObjectPtr>& obj)
		{
			ReadAttributes(obj);

			int index = 0;

			for(auto &fill : obj)
			{
				CFill *pFill = new CFill(fill);
				m_arrItems.push_back(pFill);
				m_mapFills.insert(std::make_pair(index++, pFill));
			}
		}
		XLS::BaseObjectPtr CFills::toBin()
		{
			auto ptr(new XLSB::FILLS);
			auto ptr1(new XLSB::BeginFills);
			ptr->m_BrtBeginFills = XLS::BaseObjectPtr{ptr1};

			XLS::BaseObjectPtr objectPtr(ptr);
			for(auto i : m_arrItems)
				ptr->m_arBrtFill.push_back(i->toBin());
			ptr1->cfills = ptr->m_arBrtFill.size();
			return objectPtr;

		}
		EElementType CFills::getType () const
		{
			return et_x_Fills;
		}
		void CFills::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
		{
			WritingElement_ReadAttributes_Start( oReader )
				WritingElement_ReadAttributes_Read_if ( oReader, L"count", m_oCount )
			WritingElement_ReadAttributes_End( oReader )
		}
		void CFills::ReadAttributes(std::vector<XLS::BaseObjectPtr>& obj)
			{
				m_oCount = (_UINT32)obj.size();
			}

	} //Spreadsheet
} // namespace OOX