[x2t] Fix CCell::parseRefA; Fix CSV opening

Feature/binary sheet data

ASCOfficeDocxFile2/BinReader/ReaderClasses.h

@@ -1496,14 +1496,25 @@ public:
             std::wstring sFormat;
 			switch(Format)
 			{
-			case numbering_numfmt_None:sFormat = _T("none");break;
-			case numbering_numfmt_Bullet:sFormat = _T("bullet");break;
-			case numbering_numfmt_Decimal:sFormat = _T("decimal");break;
-			case numbering_numfmt_LowerRoman:sFormat = _T("lowerRoman");break;
-			case numbering_numfmt_UpperRoman:sFormat = _T("upperRoman");break;
-			case numbering_numfmt_LowerLetter:sFormat = _T("lowerLetter");break;
-			case numbering_numfmt_UpperLetter:sFormat = _T("upperLetter");break;
-			case numbering_numfmt_DecimalZero:sFormat = _T("decimalZero");break;
+			case numbering_numfmt_None:			sFormat = L"none";			break;
+			case numbering_numfmt_Bullet:		sFormat = L"bullet";		break;
+			case numbering_numfmt_Decimal:		sFormat = L"decimal";		break;
+			case numbering_numfmt_LowerRoman:	sFormat = L"lowerRoman";	break;
+			case numbering_numfmt_UpperRoman:	sFormat = L"upperRoman";	break;
+			case numbering_numfmt_LowerLetter:	sFormat = L"lowerLetter";	break;
+			case numbering_numfmt_UpperLetter:	sFormat = L"upperLetter";	break;
+			case numbering_numfmt_DecimalZero:	sFormat = L"decimalZero";	break;
+			default:
+			{
+				Format -= 0x2008;
+				if (Format >= 0)
+				{
+					SimpleTypes::CNumberFormat<> numFormat;
+					numFormat.SetValue((SimpleTypes::ENumberFormat)Format);
+
+					sFormat = numFormat.ToString();
+				}
+			}break;
 			}
             if(!sFormat.empty())
 			{

ASCOfficeDocxFile2/BinWriter/BinWriters.cpp

@@ -2769,15 +2769,16 @@ void BinaryNumberingTableWriter::WriteLevel(const OOX::Numbering::CLvl& lvl)
 			m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Long);
 			switch(oNumberFormat.GetValue())
 			{
-			case SimpleTypes::numberformatNone: m_oBcw.m_oStream.WriteLONG(numbering_numfmt_None);break;
-			case SimpleTypes::numberformatBullet: m_oBcw.m_oStream.WriteLONG(numbering_numfmt_Bullet);break;
-			case SimpleTypes::numberformatDecimal: m_oBcw.m_oStream.WriteLONG(numbering_numfmt_Decimal);break;
-			case SimpleTypes::numberformatLowerRoman: m_oBcw.m_oStream.WriteLONG(numbering_numfmt_LowerRoman);break;
-			case SimpleTypes::numberformatUpperRoman: m_oBcw.m_oStream.WriteLONG(numbering_numfmt_UpperRoman);break;
-			case SimpleTypes::numberformatLowerLetter: m_oBcw.m_oStream.WriteLONG(numbering_numfmt_LowerLetter);break;
-			case SimpleTypes::numberformatUpperLetter: m_oBcw.m_oStream.WriteLONG(numbering_numfmt_UpperLetter);break;
-			case SimpleTypes::numberformatDecimalZero: m_oBcw.m_oStream.WriteLONG(numbering_numfmt_DecimalZero);break;
-			default: m_oBcw.m_oStream.WriteLONG(numbering_numfmt_Decimal);break;
+			case SimpleTypes::numberformatNone:			m_oBcw.m_oStream.WriteLONG(numbering_numfmt_None);break;
+			case SimpleTypes::numberformatBullet:		m_oBcw.m_oStream.WriteLONG(numbering_numfmt_Bullet);break;
+			case SimpleTypes::numberformatDecimal:		m_oBcw.m_oStream.WriteLONG(numbering_numfmt_Decimal);break;
+			case SimpleTypes::numberformatLowerRoman:	m_oBcw.m_oStream.WriteLONG(numbering_numfmt_LowerRoman);break;
+			case SimpleTypes::numberformatUpperRoman:	m_oBcw.m_oStream.WriteLONG(numbering_numfmt_UpperRoman);break;
+			case SimpleTypes::numberformatLowerLetter:	m_oBcw.m_oStream.WriteLONG(numbering_numfmt_LowerLetter);break;
+			case SimpleTypes::numberformatUpperLetter:	m_oBcw.m_oStream.WriteLONG(numbering_numfmt_UpperLetter);break;
+			case SimpleTypes::numberformatDecimalZero:	m_oBcw.m_oStream.WriteLONG(numbering_numfmt_DecimalZero);break;
+			default: 
+				m_oBcw.m_oStream.WriteLONG(oNumberFormat.GetValue() + 0x2008);break; //max our numbering
 			}
 		}
 	}

ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.cpp

@@ -726,6 +726,17 @@ namespace NSBinPptxRW
 		m_lPosition += UINT16_SIZEOF;
 		m_pStreamCur += UINT16_SIZEOF;
 	}
+	void CBinaryFileWriter::WriteSHORT(const _INT16& lValue)
+	{
+		CheckBufferSize(INT16_SIZEOF);
+#if defined(_IOS) || defined(__ANDROID__)
+		memcpy(m_pStreamCur, &lValue, sizeof(_INT16));
+#else
+		*((_INT16*)m_pStreamCur) = lValue; // EXC_ARM_DA_ALIGN on ios
+#endif
+		m_lPosition += INT16_SIZEOF;
+		m_pStreamCur += INT16_SIZEOF;
+	}
 	void CBinaryFileWriter::WriteULONG(const _UINT32& lValue)
 	{
 		CheckBufferSize(UINT32_SIZEOF);
@@ -1144,6 +1155,84 @@ namespace NSBinPptxRW
 		m_lPosition += lSizeMem;
 		m_pStreamCur += lSizeMem;
 	}
+
+	CStreamBinaryWriter::CStreamBinaryWriter(size_t bufferSize)
+	{
+		m_lSize		= bufferSize;
+		m_pStreamData	= new BYTE[bufferSize];
+
+		m_lPosition = 0;
+		m_pStreamCur = m_pStreamData;
+
+		m_lPositionFlushed = 0;
+	}
+	void CStreamBinaryWriter::CheckBufferSize(_UINT32 lPlus)
+	{
+		if ((m_lPosition + lPlus) > m_lSize)
+		{
+			Flush();
+			if ((m_lPosition + lPlus) > m_lSize)
+			{
+				CBinaryFileWriter::CheckBufferSize(lPlus);
+			}
+		}
+	}
+	_UINT32 CStreamBinaryWriter::GetPosition()
+	{
+		return m_lPosition + m_lPositionFlushed;
+	}
+	void CStreamBinaryWriter::CloseFile()
+	{
+		Flush();
+		CFileBinary::CloseFile();
+	}
+	void CStreamBinaryWriter::Flush()
+	{
+		if (m_lPosition > 0)
+		{
+			CFileBinary::WriteFile(m_pStreamData, m_lPosition);
+		}
+		m_lPositionFlushed += m_lPosition;
+		m_lPosition = 0;
+		m_pStreamCur = m_pStreamData;
+	}
+
+	CXlsbBinaryWriter::CXlsbBinaryWriter(size_t bufferSize) : CStreamBinaryWriter(bufferSize)
+	{
+	}
+	void CXlsbBinaryWriter::XlsbStartRecord(_INT16 lType, _INT32 nLen)
+	{
+		//Type
+		if (lType < 0x80)
+		{
+			WriteBYTE(lType);
+		}
+		else
+		{
+			WriteBYTE((lType & 0x7F) | 0x80);
+			WriteBYTE(lType >> 7);
+		}
+		//Len
+		for (int i = 0; i < 4; ++i)
+		{
+			BYTE nPart = nLen & 0x7F;
+			nLen = nLen >> 7;
+			if(nLen == 0)
+			{
+				WriteBYTE(nPart);
+				break;
+			}
+			else
+			{
+				WriteBYTE(nPart | 0x80);
+			}
+		}
+	}
+	void CXlsbBinaryWriter::XlsbEndRecord()
+	{
+	}
+
+
 	CRelsGenerator::CRelsGenerator(CImageManager2* pManager) : m_lNextRelsID(1), m_mapImages()
 	{
 		m_pManager = pManager;
@@ -1671,6 +1760,20 @@ namespace NSBinPptxRW
 		m_pDataCur += 2;
 		return res;		
 	}
+	_INT16 CBinaryFileReader::GetShort()
+	{
+		if (m_lPos + 1 >= m_lSize)
+			return 0;
+#if defined(_IOS) || defined(__ANDROID__)
+		_INT16 res = 0;
+		memcpy(&res, m_pDataCur, sizeof(_INT16));
+#else
+		_INT16 res = *((_INT16*)m_pDataCur);   // EXC_ARM_DA_ALIGN on ios
+#endif
+		m_lPos += 2;
+		m_pDataCur += 2;
+		return res;
+	}
 
 	// 4 byte
 	_UINT32 CBinaryFileReader::GetULong()
@@ -1869,4 +1972,32 @@ namespace NSBinPptxRW
 		m_pDataCur += nSize;
 		return res;
 	}
+	_UINT16 CBinaryFileReader::XlsbReadRecordType()
+	{
+		_UINT16 nValue = GetUChar();
+		if(0 != (nValue & 0x80))
+		{
+			BYTE nPart = GetUChar();
+			nValue = (nValue & 0x7F) | ((nPart & 0x7F) << 7);
+		}
+		return nValue;
+	}
+	void CBinaryFileReader::XlsbSkipRecord()
+	{
+		Skip(XlsbReadRecordLength());
+	}
+	_UINT32 CBinaryFileReader::XlsbReadRecordLength()
+	{
+		_UINT16 nValue = 0;
+		for (int i = 0; i < 4; ++i)
+		{
+			BYTE nPart = GetUChar();
+			nValue |= (nPart & 0x7F) << (7 * i);
+			if(0 == (nPart & 0x80))
+			{
+				break;
+			}
+		}
+		return nValue;
+	}
 }

ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.h

@@ -36,6 +36,7 @@
 #endif
 
 #include "../../DesktopEditor/common/Types.h"
+#include "../../DesktopEditor/common/File.h"
 #include "../../Common/DocxFormat/Source/Base/Types_32.h"
 
 #include <vector>
@@ -66,6 +67,10 @@ namespace NSStringUtils
 {
 	class CStringBuilder;
 }
+namespace NSFile
+{
+	class CFileBinary;
+}
 namespace PPTX
 {
 	class Theme;
@@ -241,7 +246,7 @@ namespace NSBinPptxRW
 
 		NSCommon::smart_ptr<PPTX::Theme>*			m_pTheme;
 		NSCommon::smart_ptr<PPTX::Logic::ClrMap>*	m_pClrMap;
-	private:
+	protected:
 		BYTE*		m_pStreamData;
 		BYTE*		m_pStreamCur;
 		_UINT32		m_lSize;
@@ -260,7 +265,7 @@ namespace NSBinPptxRW
 		_INT32	m_lYCurShape;
 
 		BYTE*	GetBuffer();
-		_UINT32	GetPosition();
+		virtual _UINT32	GetPosition();
 		void	SetPosition(const _UINT32& lPosition);
 		void	Skip(const _UINT32& lSize);
 
@@ -277,12 +282,13 @@ namespace NSBinPptxRW
 
 		void ClearNoAttack();
 
-		void CheckBufferSize(_UINT32 lPlus);
+		virtual void CheckBufferSize(_UINT32 lPlus);
 		
 		void WriteBYTE	(const BYTE& lValue);
 		void WriteSBYTE	(const signed char& lValue);
 		void WriteBOOL	(const bool& bValue);
 		void WriteUSHORT(const _UINT16& lValue);
+		void WriteSHORT(const _INT16& lValue);
 		
 		void WriteULONG	(const _UINT32& lValue);
 		void WriteLONG	(const _INT32& lValue);
@@ -310,7 +316,7 @@ namespace NSBinPptxRW
 		// --------------------------------------------------------
 
 		CBinaryFileWriter();
-		~CBinaryFileWriter();
+		virtual ~CBinaryFileWriter();
 
 		void StartRecord(_INT32 lType);
 		void EndRecord();
@@ -400,6 +406,29 @@ namespace NSBinPptxRW
 		_INT32	_WriteString(const WCHAR* sBuffer, _UINT32 lCount);
 		void	_WriteStringWithLength(const WCHAR* sBuffer, _UINT32 lCount, bool bByte);
 	};
+
+
+	class CStreamBinaryWriter : public NSFile::CFileBinary, public CBinaryFileWriter
+	{
+	protected:
+		_UINT32 m_lPositionFlushed;
+	public:
+		CStreamBinaryWriter(size_t bufferSize = 16777216);
+
+		void CheckBufferSize(_UINT32 lPlus);
+		_UINT32 GetPosition();
+		void CloseFile();
+		virtual void Flush();
+	};
+	class CXlsbBinaryWriter : public CStreamBinaryWriter
+	{
+	public:
+		CXlsbBinaryWriter(size_t bufferSize = 16777216);
+
+		void XlsbStartRecord(_INT16 lType, _INT32 nLen);
+		void XlsbEndRecord();
+	};
+
 	class CRelsGenerator
 	{
 	private:
@@ -489,6 +518,7 @@ namespace NSBinPptxRW
 
 		// 2 byte
 		_UINT16 GetUShort();
+		_INT16 GetShort();
 
 		// 4 byte
 		_UINT32 GetULong();
@@ -517,5 +547,9 @@ namespace NSBinPptxRW
 
 		BYTE* GetData();
 		BYTE* GetPointer(int nSize);
+
+		_UINT16 XlsbReadRecordType();
+		void XlsbSkipRecord();
+		_UINT32 XlsbReadRecordLength();
 	};
 }

Common/DocxFormat/DocxFormatLib/DocxFormatLib.pro

@@ -78,7 +78,10 @@ SOURCES += \
     ../Source/Common/Wrap.cpp \
     ../Source/Common/ZIndex.cpp \
     ../Source/Common/SimpleTypes_Word.cpp \
-    ../Source/SystemUtility/SystemUtility.cpp
+    ../Source/SystemUtility/SystemUtility.cpp \
+    ../Source/XlsxFormat/Styles/rPr.cpp \
+    ../Source/XlsxFormat/SharedStrings/Si.cpp \
+    ../Source/XlsxFormat/SharedStrings/Text.cpp
 }
 
 

Common/DocxFormat/DocxFormatLib/xlsxformatlib_logic.cpp

@@ -41,3 +41,6 @@
 #include "../Source/XlsxFormat/Worksheets/DataValidation.cpp"
 #include "../Source/XlsxFormat/Table/Tables.cpp"
 #include "../Source/XlsxFormat/Controls/Controls.cpp"
+#include "../Source/XlsxFormat/Styles/rPr.cpp"
+#include "../Source/XlsxFormat/SharedStrings/Si.cpp"
+#include "../Source/XlsxFormat/SharedStrings/Text.cpp"

Common/DocxFormat/Source/Common/SimpleTypes_Shared.h

@@ -564,6 +564,22 @@ namespace SimpleTypes
 
             return this->m_eValue;
 		}
+		virtual EOnOff  FromStringA(const char* sValue)
+		{
+			if		(strcmp("1",		sValue) == 0) this->m_eValue = onoffTrue;
+			else if	(strcmp("0",		sValue) == 0) this->m_eValue = onoffFalse;
+			else if	(strcmp("true",		sValue) == 0) this->m_eValue = onoffTrue;
+			else if	(strcmp("True",		sValue) == 0) this->m_eValue = onoffTrue;
+			else if	(strcmp("t",		sValue) == 0) this->m_eValue = onoffTrue;
+			else if	(strcmp("on",		sValue) == 0) this->m_eValue = onoffTrue;
+			else if	(strcmp("f",		sValue) == 0) this->m_eValue = onoffFalse;
+			else if	(strcmp("false",	sValue) == 0) this->m_eValue = onoffFalse;
+			else if	(strcmp("False",	sValue) == 0) this->m_eValue = onoffFalse;
+			else if	(strcmp("off",		sValue) == 0) this->m_eValue = onoffFalse;
+			else                              this->m_eValue = eDefValue;
+
+			return this->m_eValue;
+		}
 
         virtual std::wstring ToString  () const
 		{

Common/DocxFormat/Source/Common/SimpleTypes_Word.h

@@ -6736,6 +6736,14 @@ namespace SimpleTypes
 
             return this->m_eValue;
 		}
+		EXmlSpace FromStringA(const char* pValue)
+		{
+			if       ( strcmp("default", pValue)  == 0 ) this->m_eValue = xmlspaceDefault;
+			else if  ( strcmp("preserve", pValue) == 0 ) this->m_eValue = xmlspacePreserve;
+			else                                  this->m_eValue = eDefValue;
+
+			return this->m_eValue;
+		}
 
         virtual std::wstring   ToString  () const
 		{

Common/DocxFormat/Source/DocxFormat/WritingElement.h

@@ -91,6 +91,15 @@ namespace OOX
     while( !wsName.empty() )\
 	{
 
+#define WritingElement_ReadAttributes_StartChar(Reader) \
+	if ( Reader.GetAttributesCount() <= 0 )\
+		return;\
+	if ( !Reader.MoveToFirstAttribute() )\
+		return;\
+	const char* wsName = Reader.GetNameChar();\
+	while( strlen(wsName) != 0 )\
+	{
+
 #define WritingElement_ReadAttributes_Start_No_NS(Reader) \
 	if ( Reader.GetAttributesCount() <= 0 )\
 		return;\
@@ -106,10 +115,20 @@ namespace OOX
             Value = Reader.GetText();\
         }
 
+#define WritingElement_ReadAttributes_Read_ifChar(Reader, AttrName, Value) \
+		if ( strcmp(AttrName, wsName) == 0 )\
+		{\
+			Value = Reader.GetText();\
+		}
+
 #define WritingElement_ReadAttributes_Read_else_if(Reader, AttrName, Value) \
 		else if ( AttrName == wsName )\
             Value = Reader.GetText();
 
+#define WritingElement_ReadAttributes_Read_else_ifChar(Reader, AttrName, Value) \
+		else if ( strcmp(AttrName, wsName) == 0 )\
+			Value = Reader.GetText();
+
 #define WritingElement_ReadAttributes_ReadSingle(Reader, AttrName, Value) \
 		if ( AttrName == wsName )\
 		{\
@@ -124,6 +143,13 @@ namespace OOX
 	}\
 	Reader.MoveToElement();
 
+#define WritingElement_ReadAttributes_EndChar(Reader) \
+		if ( !Reader.MoveToNextAttribute() ) \
+			break;\
+		wsName = Reader.GetNameChar();\
+	}\
+	Reader.MoveToElement();
+
 #define WritingElement_ReadAttributes_End_No_NS(Reader) \
 		if ( !Reader.MoveToNextAttribute() ) \
 			break;\

Common/DocxFormat/Source/XlsxFormat/ComplexTypes_Spreadsheet.h

@@ -85,6 +85,10 @@ namespace ComplexTypes
 			{
 				m_oVal.FromBool(bVal);
 			}
+			bool ToBool()
+			{
+				return m_oVal.ToBool();
+			}
 			
 		public:
 

Common/DocxFormat/Source/XlsxFormat/SharedStrings/Si.cpp

@@ -0,0 +1,156 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * 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-12 Ernesta Birznieka-Upisha
+ * 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 "Si.h"
+
+#include "../../../../../ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.h"
+
+namespace OOX
+{
+	namespace Spreadsheet
+	{
+
+		void CSi::fromXLSBExt (NSBinPptxRW::CBinaryFileReader& oStream)
+		{
+			_UINT32 nCount = oStream.GetULong();
+			while(nCount-- > 0)
+			{
+				BYTE nTypeRun = oStream.GetUChar();
+				if(0x1 == nTypeRun)
+				{
+					OOX::Spreadsheet::CRun* pRun = new OOX::Spreadsheet::CRun();
+					if(oStream.GetBool())
+					{
+						pRun->m_oRPr.Init();
+						pRun->m_oRPr->fromXLSB(oStream, XLSB::rt_FONT);
+					}
+					_UINT32 nTextCount = oStream.GetULong();
+					while(nTextCount-- > 0)
+					{
+						OOX::Spreadsheet::CText* pText = new OOX::Spreadsheet::CText();
+						pText->m_sText.append(oStream.GetString2());
+						pRun->m_arrItems.push_back(pText);
+					}
+					m_arrItems.push_back(pRun);
+				}
+				else if(0x2 == nTypeRun)
+				{
+					OOX::Spreadsheet::CText* pText = new OOX::Spreadsheet::CText();
+					pText->m_sText.append(oStream.GetString2());
+					m_arrItems.push_back(pText);
+				}
+			}
+		}
+
+		void CSi::toXLSBExt (NSBinPptxRW::CXlsbBinaryWriter& oStream)
+		{
+			//it's not by XLSB format
+			oStream.WriteULONG(m_arrItems.size());
+			for(size_t i = 0; i < m_arrItems.size(); ++i)
+			{
+				OOX::Spreadsheet::WritingElement* we = m_arrItems[i];
+				if(OOX::et_x_r == we->getType())
+				{
+					oStream.WriteBYTE(0x1);
+					OOX::Spreadsheet::CRun* pRun = static_cast<OOX::Spreadsheet::CRun*>(we);
+					oStream.WriteBOOL(pRun->m_oRPr.IsInit());
+					if(pRun->m_oRPr.IsInit())
+					{
+						pRun->m_oRPr->toXLSB(oStream);
+					}
+					oStream.WriteULONG(pRun->m_arrItems.size());
+					for(size_t j = 0, length = pRun->m_arrItems.size(); j < length; ++j)
+					{
+						OOX::Spreadsheet::WritingElement* we = pRun->m_arrItems[j];
+						if(OOX::et_x_t == we->getType())
+						{
+							OOX::Spreadsheet::CText* pText = static_cast<OOX::Spreadsheet::CText*>(we);
+							oStream.WriteString(pText->m_sText);
+						}
+						else
+						{
+							oStream.WriteString(L"");
+						}
+					}
+				}
+				else if(OOX::et_x_t == we->getType())
+				{
+					OOX::Spreadsheet::CText* pText = static_cast<OOX::Spreadsheet::CText*>(we);
+					oStream.WriteBYTE(0x2);
+					oStream.WriteString(pText->m_sText);
+				}
+				else
+				{
+					oStream.WriteBYTE(0);
+				}
+			}
+		}
+		_UINT32 CSi::getXLSBSize() const
+		{
+			_UINT32 nLen = 4;
+			for(size_t i = 0; i < m_arrItems.size(); ++i)
+			{
+				nLen += 1;
+				OOX::Spreadsheet::WritingElement* we = m_arrItems[i];
+				if(OOX::et_x_r == we->getType())
+				{
+					nLen += 1;
+					OOX::Spreadsheet::CRun* pRun = static_cast<OOX::Spreadsheet::CRun*>(we);
+					if(pRun->m_oRPr.IsInit())
+					{
+						nLen += pRun->m_oRPr->getXLSBSize();
+					}
+					nLen += 4;
+					for(size_t j = 0, length = pRun->m_arrItems.size(); j < length; ++j)
+					{
+						OOX::Spreadsheet::WritingElement* we = pRun->m_arrItems[j];
+						if(OOX::et_x_t == we->getType())
+						{
+							OOX::Spreadsheet::CText* pText = static_cast<OOX::Spreadsheet::CText*>(we);
+							nLen += 4 + 2 * pText->m_sText.length();
+						}
+						else
+						{
+							nLen += 4;
+						}
+					}
+				}
+				else if(OOX::et_x_t == we->getType())
+				{
+					OOX::Spreadsheet::CText* pText = static_cast<OOX::Spreadsheet::CText*>(we);
+					nLen += 4 + 2 * pText->m_sText.length();
+				}
+			}
+			return nLen;
+		}
+
+	} //Spreadsheet
+} // OOX

Common/DocxFormat/Source/XlsxFormat/SharedStrings/Si.h

@@ -38,6 +38,12 @@
 #include "PhoneticPr.h"
 #include "Run.h"
 
+namespace NSBinPptxRW
+{
+	class CBinaryFileReader;
+	class CXlsbBinaryWriter;
+}
+
 namespace OOX
 {
 	namespace Spreadsheet
@@ -141,6 +147,10 @@ namespace OOX
 				}
 			}
 
+			void fromXLSBExt (NSBinPptxRW::CBinaryFileReader& oStream);
+			void toXLSBExt (NSBinPptxRW::CXlsbBinaryWriter& oStream);
+			_UINT32 getXLSBSize() const;
+
 			virtual EElementType getType () const
 			{
 				return et_x_Si;

Common/DocxFormat/Source/XlsxFormat/SharedStrings/Text.cpp

@@ -0,0 +1,210 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * 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-12 Ernesta Birznieka-Upisha
+ * 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 "Text.h"
+
+namespace OOX
+{
+	namespace Spreadsheet
+	{
+		void CText::fromXMLToXLSB(XmlUtils::CXmlLiteReader& oReader, SimpleTypes::Spreadsheet::ECellTypeType eType, _UINT16& nType, double& dValue, unsigned int& nValue, BYTE& bValue, std::wstring** psValue, bool& bForceFormula)
+		{
+			SimpleTypes::EXmlSpace eSpace = SimpleTypes::xmlspaceDefault;
+			ReadAttributesToXLSB( oReader, eSpace );
+
+			if ( oReader.IsEmptyNode() )
+				return;
+
+			if(SimpleTypes::Spreadsheet::celltypeStr == eType || SimpleTypes::Spreadsheet::celltypeInlineStr == eType)
+			{
+				std::string sVal = oReader.GetText2A();
+				fromXMLToXLSB(sVal.c_str(), eSpace, eType, nType, dValue, nValue, bValue, psValue, bForceFormula);
+			}
+			else
+			{
+				int nDepth = oReader.GetDepth();
+				XmlUtils::XmlNodeType eNodeType = XmlUtils::XmlNodeType_EndElement;
+				while (oReader.Read(eNodeType) && oReader.GetDepth() >= nDepth && XmlUtils::XmlNodeType_EndElement != eNodeType)
+				{
+					if (eNodeType == XmlUtils::XmlNodeType_Text)
+					{
+						fromXMLToXLSB(oReader.GetTextChar(), eSpace, eType, nType, dValue, nValue, bValue, psValue, bForceFormula);
+					}
+				}
+			}
+		}
+		void CText::fromXMLToXLSB(const char* pVal, SimpleTypes::EXmlSpace eSpace, SimpleTypes::Spreadsheet::ECellTypeType eType, _UINT16& nType, double& dValue, unsigned int& nValue, BYTE& bValue, std::wstring** psValue, bool& bForceFormula)
+		{
+			if(pVal[0] == '\0')
+				return;
+			if(SimpleTypes::Spreadsheet::celltypeNumber == eType)
+			{
+				//todo RkNumber
+				nType = XLSB::rt_CELL_REAL;
+				try
+				{
+					dValue = atof(pVal);
+				}
+				catch(...)
+				{   //1.3912059045063478e-310
+					//Lighting Load Calculation.xls
+				}
+			}
+			else if(SimpleTypes::Spreadsheet::celltypeSharedString == eType)
+			{
+				nType = XLSB::rt_CELL_ISST;
+				try
+				{
+					nValue = atoi(pVal);
+				}
+				catch(...)
+				{
+				}
+			}
+			else if(SimpleTypes::Spreadsheet::celltypeError == eType)
+			{
+				nType = XLSB::rt_CELL_ERROR;
+				if(strcmp("#NULL!", pVal) == 0)
+				{
+					bValue = 0x00;
+				}
+				else if(strcmp("#DIV/0!", pVal) == 0)
+				{
+					bValue = 0x07;
+				}
+				else if(strcmp("#VALUE!", pVal) == 0)
+				{
+					bValue = 0x0F;
+				}
+				else if(strcmp("#REF!", pVal) == 0)
+				{
+					bValue = 0x17;
+				}
+				else if(strcmp("#NAME?", pVal) == 0)
+				{
+					bValue = 0x1D;
+				}
+				else if(strcmp("#NUM!", pVal) == 0)
+				{
+					bValue = 0x24;
+				}
+				else if(strcmp("#N/A", pVal) == 0)
+				{
+					bValue = 0x2A;
+				}
+				else if(strcmp("#GETTING_DATA", pVal) == 0)
+				{
+					bValue = 0x2B;
+				}
+			}
+			else if(SimpleTypes::Spreadsheet::celltypeBool == eType)
+			{
+				nType = XLSB::rt_CELL_BOOL;
+				SimpleTypes::COnOff<> oOnOff;
+				oOnOff.FromStringA(pVal);
+				bValue = oOnOff.ToBool() ? 1 : 0;
+			}
+			else if(SimpleTypes::Spreadsheet::celltypeInlineStr == eType)
+			{
+				nType = XLSB::rt_CELL_ST;
+				if(NULL == (*psValue))
+				{
+					(*psValue) = new std::wstring();
+				}
+				(*psValue)->append(NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pVal, (LONG)strlen(pVal)));
+				trimString(**psValue, eSpace);
+			}
+			else if(SimpleTypes::Spreadsheet::celltypeStr == eType)
+			{
+				bForceFormula = true;
+				nType = XLSB::rt_CELL_ST;
+				if(NULL == (*psValue))
+				{
+					(*psValue) = new std::wstring();
+				}
+				(*psValue)->append(NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pVal, (LONG)strlen(pVal)));
+				trimString(**psValue, eSpace);
+			}
+		}
+		void CText::ReadAttributesToXLSB(XmlUtils::CXmlLiteReader& oReader, SimpleTypes::EXmlSpace& eSpace)
+		{
+			WritingElement_ReadAttributes_StartChar( oReader )
+				if ( strcmp("space", wsName) == 0 )
+				{
+					SimpleTypes::CXmlSpace<> oSpace;
+					oSpace.FromStringA(oReader.GetTextChar());
+					eSpace = oSpace.GetValue();
+					break;
+				}
+
+			WritingElement_ReadAttributes_EndChar( oReader )
+		}
+		void CText::trimString(std::wstring& sVal, SimpleTypes::EXmlSpace eSpace)
+		{
+			NSStringExt::Replace(sVal, L"\t", L"");
+			if(SimpleTypes::xmlspacePreserve == eSpace)
+			{
+				//trim ' ', '\r', '\n'
+				int nLength		= (int)sVal.length();
+				int nStartIndex = 0;
+				int nEndIndex	= nLength - 1;
+
+				for(int i = nStartIndex; i < nLength; ++i)
+				{
+					wchar_t cElem = sVal[i];
+					if(' ' == cElem || '\n' == cElem || '\r' == cElem)
+						nStartIndex++;
+					else
+						break;
+				}
+				for(int i = nEndIndex; i > nStartIndex; --i)
+				{
+					wchar_t cElem = sVal[i];
+					if(' ' == cElem || '\n' == cElem || '\r' == cElem)
+						nEndIndex--;
+					else
+						break;
+				}
+				if(0 != nStartIndex || nLength - 1 != nEndIndex)
+				{
+					if (nStartIndex <= nEndIndex)
+						sVal = sVal.substr(nStartIndex, nEndIndex - nStartIndex + 1);
+					else
+						sVal.clear();
+				}
+			}
+		}
+		SimpleTypes::EXmlSpace CText::GetSpace() const
+		{
+			return m_oSpace.IsInit() ? m_oSpace->GetValue() : SimpleTypes::xmlspaceDefault;
+		}
+	} //Spreadsheet
+} // OOX

Common/DocxFormat/Source/XlsxFormat/SharedStrings/Text.h

@@ -84,43 +84,17 @@ namespace OOX
 					return;
 
 				m_sText = oReader.GetText3();
-				NSStringExt::Replace(m_sText, L"\t", L"");
-				if(!(m_oSpace.IsInit() && SimpleTypes::xmlspacePreserve == m_oSpace->GetValue()))
-				{
-					//trim ' ', '\r', '\n'
-					int nLength		= (int)m_sText.length();
-					int nStartIndex = 0;
-					int nEndIndex	= nLength - 1;
-					
-					for(int i = nStartIndex; i < nLength; ++i)
-					{
-                        wchar_t cElem = m_sText[i];
-						if(' ' == cElem || '\n' == cElem || '\r' == cElem)
-							nStartIndex++;
-						else
-							break;
-					}
-					for(int i = nEndIndex; i > nStartIndex; --i)
-					{
-                        wchar_t cElem = m_sText[i];
-						if(' ' == cElem || '\n' == cElem || '\r' == cElem)
-							nEndIndex--;
-						else
-							break;
-					}
-					if(0 != nStartIndex || nLength - 1 != nEndIndex)
-					{
-						if (nStartIndex <= nEndIndex)
-							m_sText = m_sText.substr(nStartIndex, nEndIndex - nStartIndex + 1);
-						else
-							m_sText.clear();
-					}
-				}
+				trimString(m_sText, GetSpace());
 			}
+			static void fromXMLToXLSB(XmlUtils::CXmlLiteReader& oReader, SimpleTypes::Spreadsheet::ECellTypeType eType, _UINT16& nType, double& dValue, unsigned int& nValue, BYTE& bValue, std::wstring** psValue, bool& bForceFormula);
+			static void fromXMLToXLSB(const char* pVal, SimpleTypes::EXmlSpace eSpace, SimpleTypes::Spreadsheet::ECellTypeType eType, _UINT16& nType, double& dValue, unsigned int& nValue, BYTE& bValue, std::wstring** psValue, bool& bForceFormula);
+
+			static void trimString(std::wstring& sVal, SimpleTypes::EXmlSpace eSpace);
 			std::wstring ToString() const
 			{
 				return m_sText;
 			}
+			SimpleTypes::EXmlSpace GetSpace() const;
 			virtual EElementType getType() const
 			{
 				return et_x_t;
@@ -152,6 +126,7 @@ namespace OOX
 
 				oReader.MoveToElement();
 			}
+			static void ReadAttributesToXLSB(XmlUtils::CXmlLiteReader& oReader, SimpleTypes::EXmlSpace& eSpace);
 
 		public:
 

Common/DocxFormat/Source/XlsxFormat/SimpleTypes_Spreadsheet.h

@@ -1536,6 +1536,26 @@ namespace SimpleTypes
                     this->m_eValue = eDefValue;
                 return this->m_eValue;
 			}
+			ECellTypeType FromStringA(const char* sValue)
+			{
+				if(strcmp("s", sValue) == 0)
+					this->m_eValue = celltypeSharedString;
+				else if(strcmp("str", sValue) == 0)
+					this->m_eValue = celltypeStr;
+				else if(strcmp("n", sValue) == 0)
+					this->m_eValue = celltypeNumber;
+				else if(strcmp("e", sValue) == 0)
+					this->m_eValue = celltypeError;
+				else if(strcmp("b", sValue) == 0)
+					this->m_eValue = celltypeBool;
+				else if(strcmp("inlineStr", sValue) == 0)
+					this->m_eValue = celltypeInlineStr;
+				else if(strcmp("d", sValue) == 0)
+					this->m_eValue = celltypeDate;
+				else
+					this->m_eValue = eDefValue;
+				return this->m_eValue;
+			}
 
 			virtual std::wstring     ToString  () const 
 			{

Common/DocxFormat/Source/XlsxFormat/Styles/rPr.cpp

@@ -0,0 +1,430 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * 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-12 Ernesta Birznieka-Upisha
+ * 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 "rPr.h"
+
+#include "../../../../../ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.h"
+
+namespace OOX
+{
+	namespace Spreadsheet
+	{
+		void CRPr::fromXLSB (NSBinPptxRW::CBinaryFileReader& oStream, _UINT16 nType)
+		{
+			//LONG nEnd = oStream.XlsbReadRecordLength() + oStream.GetPos();
+
+			_UINT16 dyHeight = oStream.GetUShort();
+			if(dyHeight >= 0x0014)
+			{
+				m_oSz.Init();
+				m_oSz->m_oVal.Init();
+				m_oSz->m_oVal->SetValue(dyHeight / 20);
+			}
+			_UINT16 grbit = oStream.GetUShort();
+			if(0 != (grbit & 0x2))
+			{
+				m_oItalic.Init();
+				m_oItalic->FromBool(true);
+			}
+			if(0 != (grbit & 0x8))
+			{
+				m_oStrike.Init();
+				m_oStrike->FromBool(true);
+			}
+			if(0 != (grbit & 0x10))
+			{
+				m_oOutline.Init();
+				m_oOutline->FromBool(true);
+			}
+			if(0 != (grbit & 0x20))
+			{
+				m_oShadow.Init();
+				m_oShadow->FromBool(true);
+			}
+			if(0 != (grbit & 0x40))
+			{
+				m_oCondense.Init();
+				m_oCondense->FromBool(true);
+			}
+			if(0 != (grbit & 0x80))
+			{
+				m_oExtend.Init();
+				m_oExtend->FromBool(true);
+			}
+			_UINT16 bls = oStream.GetUShort();
+			if(0x02BC == bls)
+			{
+				m_oBold.Init();
+				m_oBold->FromBool(true);
+			}
+			_UINT16 sss = oStream.GetUShort();
+			if(sss > 0)
+			{
+				m_oVertAlign.Init();
+				m_oVertAlign->m_oVerticalAlign.Init();
+				switch(sss)
+				{
+					case 0x0001:
+						m_oVertAlign->m_oVerticalAlign->SetValue(SimpleTypes::verticalalignrunSuperscript);
+						break;
+					case 0x0002:
+						m_oVertAlign->m_oVerticalAlign->SetValue(SimpleTypes::verticalalignrunSubscript);
+						break;
+				}
+			}
+			_UINT16 uls = oStream.GetUChar();
+			if(uls > 0)
+			{
+				m_oUnderline.Init();
+				m_oUnderline->m_oUnderline.Init();
+				switch(uls)
+				{
+					case 0x01:
+						m_oUnderline->m_oUnderline->SetValue(SimpleTypes::Spreadsheet::underlineSingle);
+						break;
+					case 0x02:
+						m_oUnderline->m_oUnderline->SetValue(SimpleTypes::Spreadsheet::underlineDouble);
+						break;
+					case 0x21:
+						m_oUnderline->m_oUnderline->SetValue(SimpleTypes::Spreadsheet::underlineSingleAccounting);
+						break;
+					case 0x22:
+						m_oUnderline->m_oUnderline->SetValue(SimpleTypes::Spreadsheet::underlineDoubleAccounting);
+						break;
+				}
+			}
+			_UINT16 bFamily = oStream.GetUChar();
+			if(bFamily > 0)
+			{
+				m_oFamily.Init();
+				m_oFamily->m_oFontFamily.Init();
+				m_oFamily->m_oFontFamily->SetValue((SimpleTypes::Spreadsheet::EFontFamily)bFamily);
+			}
+			_UINT16 bCharSet = oStream.GetUChar();
+			if(bCharSet > 0)
+			{
+				m_oCharset.Init();
+				m_oCharset->m_oCharset.Init();
+				m_oCharset->m_oCharset->SetValue((SimpleTypes::Spreadsheet::EFontCharset)bCharSet);
+			}
+			oStream.Skip(1);
+
+			BYTE xColorType = oStream.GetUChar();
+			BYTE index = oStream.GetUChar();
+			_INT16 nTintAndShade = oStream.GetShort();
+			_UINT32 rgba = oStream.GetULong();
+			m_oColor.Init();
+			if(0 != (xColorType & 0x1))
+			{
+				m_oColor->m_oRgb.Init();
+				m_oColor->m_oRgb->Set_R((unsigned char)(rgba & 0xFF));
+				m_oColor->m_oRgb->Set_G((unsigned char)((rgba & 0xFF00)>>8));
+				m_oColor->m_oRgb->Set_B((unsigned char)((rgba & 0xFF0000)>>16));
+				m_oColor->m_oRgb->Set_A((unsigned char)((rgba & 0xFF000000)>>24));
+			}
+			xColorType &= 0xFE;
+			if(0x2 == xColorType)
+			{
+				m_oColor->m_oIndexed.Init();
+				m_oColor->m_oIndexed->SetValue(index);
+			}
+			else if(0x6 == xColorType)
+			{
+				m_oColor->m_oThemeColor.Init();
+				SimpleTypes::Spreadsheet::EThemeColor eColor = SimpleTypes::Spreadsheet::themecolorDark1;
+				switch(index)
+				{
+					case 0x01:
+						eColor = SimpleTypes::Spreadsheet::themecolorLight1;
+						break;
+					case 0x00:
+						eColor = SimpleTypes::Spreadsheet::themecolorDark1;
+						break;
+					case 0x03:
+						eColor = SimpleTypes::Spreadsheet::themecolorLight2;
+						break;
+					case 0x02:
+						eColor = SimpleTypes::Spreadsheet::themecolorDark2;
+						break;
+					case 0x04:
+						eColor = SimpleTypes::Spreadsheet::themecolorAccent1;
+						break;
+					case 0x05:
+						eColor = SimpleTypes::Spreadsheet::themecolorAccent2;
+						break;
+					case 0x06:
+						eColor = SimpleTypes::Spreadsheet::themecolorAccent3;
+						break;
+					case 0x07:
+						eColor = SimpleTypes::Spreadsheet::themecolorAccent4;
+						break;
+					case 0x08:
+						eColor = SimpleTypes::Spreadsheet::themecolorAccent5;
+						break;
+					case 0x09:
+						eColor = SimpleTypes::Spreadsheet::themecolorAccent6;
+						break;
+					case 0x0A:
+						eColor = SimpleTypes::Spreadsheet::themecolorHyperlink;
+						break;
+					case 0x0B:
+						eColor = SimpleTypes::Spreadsheet::themecolorFollowedHyperlink;
+						break;
+				}
+				m_oColor->m_oThemeColor->SetValue(eColor);
+			}
+			if(0 != nTintAndShade)
+			{
+				m_oColor->m_oTint.Init();
+				m_oColor->m_oTint->SetValue(((double)nTintAndShade) / 0x7FFF);
+			}
+			if(!m_oColor->m_oThemeColor.IsInit() && !m_oColor->m_oRgb.IsInit() && !m_oColor->m_oIndexed.IsInit())
+			{
+				m_oColor->m_oAuto.Init();
+				m_oColor->m_oAuto->FromBool(true);
+			}
+
+			_UINT16 bFontScheme = oStream.GetUChar();
+			if(bFontScheme > 0)
+			{
+				m_oScheme.Init();
+				m_oScheme->m_oFontScheme.Init();
+				switch(bFontScheme)
+				{
+					case 0x01:
+						m_oScheme->m_oFontScheme->SetValue(SimpleTypes::Spreadsheet::fontschemeMajor);
+						break;
+					case 0x02:
+						m_oScheme->m_oFontScheme->SetValue(SimpleTypes::Spreadsheet::fontschemeMinor);
+						break;
+				}
+			}
+			m_oRFont.Init();
+			m_oRFont->m_sVal.Init();
+			m_oRFont->m_sVal->append(oStream.GetString2());
+
+			//oStream.Seek(nEnd);
+		}
+		void CRPr::toXLSB (NSBinPptxRW::CXlsbBinaryWriter& oStream) const
+		{
+			//oStream.XlsbStartRecord();
+
+			_UINT16 dyHeight = 0;
+			if(m_oSz.IsInit() && m_oSz->m_oVal.IsInit())
+			{
+				dyHeight = (_UINT16)((m_oSz->m_oVal->GetValue() * 20)) & 0x1FFF;
+			}
+			oStream.WriteUSHORT(dyHeight);
+			_UINT16 grbit = 0;
+			if(m_oItalic.IsInit() && m_oItalic->ToBool())
+			{
+				grbit |= 0x2;
+			}
+			if(m_oStrike.IsInit() && m_oStrike->ToBool())
+			{
+				grbit |= 0x8;
+			}
+			if(m_oOutline.IsInit() && m_oOutline->ToBool())
+			{
+				grbit |= 0x10;
+			}
+			if(m_oShadow.IsInit() && m_oShadow->ToBool())
+			{
+				grbit |= 0x20;
+			}
+			if(m_oCondense.IsInit() && m_oCondense->ToBool())
+			{
+				grbit |= 0x40;
+			}
+			if(m_oExtend.IsInit() && m_oExtend->ToBool())
+			{
+				grbit |= 0x80;
+			}
+			oStream.WriteUSHORT(grbit);
+			_UINT16 bls = m_oBold.IsInit() && m_oBold->ToBool() ? 0x02BC : 0x0190;
+			oStream.WriteUSHORT(bls);
+			_UINT16 sss = 0;
+			if(m_oVertAlign.IsInit() && m_oVertAlign->m_oVerticalAlign.IsInit())
+			{
+				if(SimpleTypes::verticalalignrunSuperscript == m_oVertAlign->m_oVerticalAlign->GetValue())
+				{
+					sss = 0x0001;
+				}
+				else if(SimpleTypes::verticalalignrunSubscript == m_oVertAlign->m_oVerticalAlign->GetValue())
+				{
+					sss = 0x0002;
+				}
+			}
+			oStream.WriteUSHORT(sss);
+			BYTE uls = 0;
+			if(m_oUnderline.IsInit())
+			{
+				SimpleTypes::Spreadsheet::EUnderline eType = SimpleTypes::Spreadsheet::underlineSingle;
+				if(m_oUnderline->m_oUnderline.IsInit())
+					eType = m_oUnderline->m_oUnderline->GetValue();
+
+				switch(eType)
+				{
+					case SimpleTypes::Spreadsheet::underlineSingle:
+						uls = 0x01;
+						break;
+					case SimpleTypes::Spreadsheet::underlineDouble:
+						uls = 0x02;
+						break;
+					case SimpleTypes::Spreadsheet::underlineSingleAccounting:
+						uls = 0x21;
+						break;
+					case SimpleTypes::Spreadsheet::underlineDoubleAccounting:
+						uls = 0x22;
+						break;
+				}
+			}
+			oStream.WriteBYTE(uls);
+			BYTE bFamily = 0;
+			if(m_oFamily.IsInit() && m_oFamily->m_oFontFamily.IsInit())
+			{
+				bFamily = m_oFamily->m_oFontFamily->GetValue();
+			}
+			oStream.WriteBYTE(bFamily);
+			BYTE bCharSet = 0;
+			if(m_oCharset.IsInit() && m_oCharset->m_oCharset.IsInit())
+			{
+				bCharSet = m_oCharset->m_oCharset->GetValue();
+			}
+			oStream.WriteBYTE(bCharSet);
+			oStream.WriteBYTE(0);
+			BYTE xColorType = 0;
+			_UINT32 rgba = 0;
+			BYTE index = 0;
+			_INT16 nTintAndShade = 0;
+			if(m_oColor.IsInit())
+			{
+				if(m_oColor->m_oRgb.IsInit())
+				{
+					xColorType |= 0x1;
+					xColorType |= 0x4;
+					rgba = m_oColor->m_oRgb->Get_R() | (m_oColor->m_oRgb->Get_G() << 8) | (m_oColor->m_oRgb->Get_B() << 16) | (m_oColor->m_oRgb->Get_A() << 24);
+				}
+				else if(m_oColor->m_oIndexed.IsInit())
+				{
+					BYTE ucA;
+					BYTE ucR;
+					BYTE ucG;
+					BYTE ucB;
+					if(OOX::Spreadsheet::CIndexedColors::GetDefaultRGBAByIndex(m_oColor->m_oIndexed->GetValue(), ucR, ucG, ucB, ucA))
+					{
+						xColorType |= 0x1;
+						xColorType |= 0x4;
+						rgba = ucR | (ucG << 8) | (ucB << 16) | (ucA << 24);
+					}
+				}
+				else if(m_oColor->m_oThemeColor.IsInit())
+				{
+					xColorType |= 0x6;
+					switch(m_oColor->m_oThemeColor->GetValue())
+					{
+						case SimpleTypes::Spreadsheet::themecolorLight1:
+							index = 0x01;
+							break;
+						case SimpleTypes::Spreadsheet::themecolorDark1:
+							index = 0x00;
+							break;
+						case SimpleTypes::Spreadsheet::themecolorLight2:
+							index = 0x03;
+							break;
+						case SimpleTypes::Spreadsheet::themecolorDark2:
+							index = 0x02;
+							break;
+						case SimpleTypes::Spreadsheet::themecolorAccent1:
+							index = 0x04;
+							break;
+						case SimpleTypes::Spreadsheet::themecolorAccent2:
+							index = 0x05;
+							break;
+						case SimpleTypes::Spreadsheet::themecolorAccent3:
+							index = 0x06;
+							break;
+						case SimpleTypes::Spreadsheet::themecolorAccent4:
+							index = 0x07;
+							break;
+						case SimpleTypes::Spreadsheet::themecolorAccent5:
+							index = 0x08;
+							break;
+						case SimpleTypes::Spreadsheet::themecolorAccent6:
+							index = 0x09;
+							break;
+						case SimpleTypes::Spreadsheet::themecolorHyperlink:
+							index = 0x0A;
+							break;
+						case SimpleTypes::Spreadsheet::themecolorFollowedHyperlink:
+							index = 0x0B;
+							break;
+					}
+				}
+				if(m_oColor->m_oTint.IsInit())
+				{
+					nTintAndShade = _INT16(0x7FFF * m_oColor->m_oTint->GetValue());
+				}
+			}
+			oStream.WriteBYTE(xColorType);
+			oStream.WriteBYTE(index);
+			oStream.WriteSHORT(nTintAndShade);
+			oStream.WriteULONG(rgba);
+			BYTE bFontScheme = 0;
+			if(m_oScheme.IsInit() && m_oScheme->m_oFontScheme.IsInit())
+			{
+				switch(m_oScheme->m_oFontScheme->GetValue())
+				{
+					case SimpleTypes::Spreadsheet::fontschemeNone:
+						bFontScheme = 0x00;
+						break;
+					case SimpleTypes::Spreadsheet::fontschemeMajor:
+						bFontScheme = 0x01;
+						break;
+					case SimpleTypes::Spreadsheet::fontschemeMinor:
+						bFontScheme = 0x02;
+						break;
+				}
+			}
+			oStream.WriteBYTE(bFontScheme);
+			oStream.WriteString(m_oRFont.IsInit() && m_oRFont->m_sVal.IsInit() ? m_oRFont->m_sVal.get() : L"");
+
+			//oStream.XlsbEndRecord(XLSB::rt_FONT);
+		}
+		_UINT32 CRPr::getXLSBSize() const
+		{
+			_UINT32 nLen = 2 + 2 + 2 + 2 + 1 + 1 + 1 + 1 + 1 + 1 + 2 + 4 + 1;
+			nLen += 4 + 2 * (m_oRFont.IsInit() && m_oRFont->m_sVal.IsInit() ? m_oRFont->m_sVal->length() : 0);
+			return nLen;
+		}
+
+	} //Spreadsheet
+} // OOX

Common/DocxFormat/Source/XlsxFormat/Styles/rPr.h

@@ -35,6 +35,12 @@
 
 #include "../CommonInclude.h"
 
+namespace NSBinPptxRW
+{
+	class CBinaryFileReader;
+	class CXlsbBinaryWriter;
+}
+
 namespace OOX
 {
 	namespace Spreadsheet
@@ -391,7 +397,7 @@ namespace OOX
 				writer.WriteString(sName);
 				WritingStringNullableAttrBool(L"auto", m_oAuto);
 				WritingStringNullableAttrInt(L"indexed", m_oIndexed, m_oIndexed->GetValue());
-				if(m_oRgb.IsInit())
+				if(m_oRgb.IsInit() && !m_oIndexed.IsInit())
 				{
 					int nIndex = OOX::Spreadsheet::CIndexedColors::GetDefaultIndexByRGBA(m_oRgb->Get_R(), m_oRgb->Get_G(), m_oRgb->Get_B(), m_oRgb->Get_A());
 					if(-1 == nIndex)
@@ -681,12 +687,45 @@ namespace OOX
 					else
 						writer.WriteString(_T("<b val=\"false\"/>"));
 				}
-				if(m_oCharset.IsInit() && m_oCharset->m_oCharset.IsInit())
+				if(m_oItalic.IsInit())
 				{
-					WritingStringValAttrString(L"charset", m_oCharset->m_oCharset->ToString());
+					if(SimpleTypes::onoffTrue == m_oItalic->m_oVal.GetValue())
+						writer.WriteString(_T("<i/>"));
+					else
+						writer.WriteString(_T("<i val=\"false\"/>"));
+				}
+				if(m_oStrike.IsInit())
+				{
+					if(SimpleTypes::onoffTrue == m_oStrike->m_oVal.GetValue())
+						writer.WriteString(_T("<strike/>"));
+					else
+						writer.WriteString(_T("<strike val=\"false\"/>"));
+				}
+				if(m_oUnderline.IsInit() && m_oUnderline->m_oUnderline.IsInit())
+				{
+					if( SimpleTypes::underlineSingle != m_oUnderline->m_oUnderline->GetValue())
+					{
+						WritingStringValAttrString(L"u", m_oUnderline->m_oUnderline->ToString());
+					}
+					else
+					{
+						writer.WriteString(L"<u/>");
+					}
+				}
+				if(m_oOutline.IsInit())
+				{
+					if(SimpleTypes::onoffTrue == m_oOutline->m_oVal.GetValue())
+						writer.WriteString(_T("<outline/>"));
+					else
+						writer.WriteString(_T("<outline val=\"false\"/>"));
+				}
+				if(m_oShadow.IsInit())
+				{
+					if(SimpleTypes::onoffTrue == m_oShadow->m_oVal.GetValue())
+						writer.WriteString(_T("<shadow/>"));
+					else
+						writer.WriteString(_T("<shadow val=\"false\"/>"));
 				}
-				if(m_oColor.IsInit())
-					m_oColor->toXML2(writer, _T("color"));
 				if(m_oCondense.IsInit())
 				{
 					if(SimpleTypes::onoffTrue == m_oCondense->m_oVal.GetValue())
@@ -701,67 +740,35 @@ namespace OOX
 					else
 						writer.WriteString(_T("<extend val=\"false\"/>"));
 				}
-				if(m_oFamily.IsInit() && m_oFamily->m_oFontFamily.IsInit())
+				if(m_oVertAlign.IsInit() && m_oVertAlign->m_oVerticalAlign.IsInit())
 				{
-					WritingStringValAttrString(L"family", m_oFamily->m_oFontFamily->ToString());
-				}
-				if(m_oItalic.IsInit())
-				{
-					if(SimpleTypes::onoffTrue == m_oItalic->m_oVal.GetValue())
-						writer.WriteString(_T("<i/>"));
-					else
-						writer.WriteString(_T("<i val=\"false\"/>"));
-				}
-				if(m_oOutline.IsInit())
-				{
-					if(SimpleTypes::onoffTrue == m_oOutline->m_oVal.GetValue())
-						writer.WriteString(_T("<outline/>"));
-					else
-						writer.WriteString(_T("<outline val=\"false\"/>"));
-				}
-				if(m_oRFont.IsInit() && m_oRFont->m_sVal.IsInit())
-				{
-					WritingStringValAttrEncodeXmlString(L"rFont", m_oRFont->m_sVal.get());
-				}
-				if(m_oScheme.IsInit() && m_oScheme->m_oFontScheme.IsInit())
-				{
-					WritingStringValAttrString(L"scheme", m_oScheme->m_oFontScheme->ToString());
-				}
-				if(m_oShadow.IsInit())
-				{
-					if(SimpleTypes::onoffTrue == m_oShadow->m_oVal.GetValue())
-						writer.WriteString(_T("<shadow/>"));
-					else
-						writer.WriteString(_T("<shadow val=\"false\"/>"));
-				}
-				if(m_oStrike.IsInit())
-				{
-					if(SimpleTypes::onoffTrue == m_oStrike->m_oVal.GetValue())
-						writer.WriteString(_T("<strike/>"));
-					else
-						writer.WriteString(_T("<strike val=\"false\"/>"));
+					std::wstring sVerticalAlign = m_oVertAlign->m_oVerticalAlign->ToString();
+					writer.WriteString(L"<vertAlign val=\"");
+					writer.WriteString(sVerticalAlign);
+					writer.WriteString(L"\"/>");
 				}
 				if(m_oSz.IsInit() && m_oSz->m_oVal.IsInit())
 				{
 					WritingStringValAttrDouble(L"sz", m_oSz->m_oVal->GetValue());
 				}
-				if(m_oUnderline.IsInit() && m_oUnderline->m_oUnderline.IsInit())
+				if(m_oColor.IsInit())
+					m_oColor->toXML2(writer, _T("color"));
+
+				if(m_oRFont.IsInit() && m_oRFont->m_sVal.IsInit())
 				{
-					if( SimpleTypes::underlineSingle != m_oUnderline->m_oUnderline->GetValue())
-					{
-						WritingStringValAttrString(L"u", m_oUnderline->m_oUnderline->ToString());
-					}
-					else
-					{
-						writer.WriteString(L"<u/>");
-					}
+					WritingStringValAttrEncodeXmlString(L"rFont", m_oRFont->m_sVal.get());
 				}
-				if(m_oVertAlign.IsInit() && m_oVertAlign->m_oVerticalAlign.IsInit())
+				if(m_oFamily.IsInit() && m_oFamily->m_oFontFamily.IsInit())
 				{
-                    std::wstring sVerticalAlign = m_oVertAlign->m_oVerticalAlign->ToString();
-					writer.WriteString(L"<vertAlign val=\"");
-                    writer.WriteString(sVerticalAlign);
-					writer.WriteString(L"\"/>");
+					WritingStringValAttrString(L"family", m_oFamily->m_oFontFamily->ToString());
+				}
+				if(m_oCharset.IsInit() && m_oCharset->m_oCharset.IsInit())
+				{
+					WritingStringValAttrString(L"charset", m_oCharset->m_oCharset->ToString());
+				}
+				if(m_oScheme.IsInit() && m_oScheme->m_oFontScheme.IsInit())
+				{
+					WritingStringValAttrString(L"scheme", m_oScheme->m_oFontScheme->ToString());
 				}
 				writer.WriteString(_T("</rPr>"));
 			}
@@ -811,6 +818,10 @@ namespace OOX
 				}
 			}
 
+			void fromXLSB (NSBinPptxRW::CBinaryFileReader& oStream, _UINT16 nType);
+			void toXLSB (NSBinPptxRW::CXlsbBinaryWriter& oStream) const;
+			_UINT32 getXLSBSize() const;
+
 			virtual EElementType getType () const
 			{
 				return et_x_rPr;

Common/DocxFormat/Source/XlsxFormat/Worksheets/SheetData.h

@@ -37,6 +37,20 @@
 
 #include "../SharedStrings/Si.h"
 
+namespace NSBinPptxRW
+{
+	class CBinaryFileReader;
+	class CXlsbBinaryWriter;
+}
+namespace CSVWriter
+{
+	class CCSVWriter;
+}
+namespace NSFile
+{
+	class CStreamWriter;
+}
+
 namespace OOX
 {
 	namespace Spreadsheet
@@ -58,25 +72,7 @@ namespace OOX
 			{
 				return _T("");
 			}
-			virtual void toXML(NSStringUtils::CStringBuilder& writer) const
-			{
-				writer.WriteString(_T("<f"));
-				WritingStringNullableAttrBool(L"aca", m_oAca);
-				WritingStringNullableAttrBool(L"bx", m_oBx);
-				WritingStringNullableAttrBool(L"ca", m_oCa);
-				WritingStringNullableAttrBool(L"del1", m_oDel1);
-				WritingStringNullableAttrBool(L"del2", m_oDel2);
-				WritingStringNullableAttrBool(L"dt2D", m_oDt2D);
-				WritingStringNullableAttrBool(L"dtr", m_oDtr);
-				WritingStringNullableAttrString(L"r1", m_oR1, m_oR1.get());
-				WritingStringNullableAttrString(L"r2", m_oR2, m_oR2.get());
-				WritingStringNullableAttrString(L"ref", m_oRef, m_oRef.get());
-				WritingStringNullableAttrInt(L"si", m_oSi, m_oSi->GetValue());
-				WritingStringNullableAttrString(L"t", m_oT, m_oT->ToString());
-                writer.WriteString(_T(">"));
-                writer.WriteEncodeXmlString(m_sText);
-				writer.WriteString(_T("</f>"));
-			}
+			virtual void toXML(NSStringUtils::CStringBuilder& writer) const;
 			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
 			{
 				ReadAttributes( oReader );
@@ -86,6 +82,11 @@ namespace OOX
 
 				m_sText = oReader.GetText3();
 			}
+			void fromXLSB (NSBinPptxRW::CBinaryFileReader& oStream);
+			_UINT16 toXLSB (NSBinPptxRW::CXlsbBinaryWriter& oStream);
+			void fromXLSBExt (NSBinPptxRW::CBinaryFileReader& oStream, _UINT16 nFlags);
+			void toXLSBExt (NSBinPptxRW::CXlsbBinaryWriter& oStream);
+			_UINT32 getXLSBSize() const;
 
 			virtual EElementType getType () const
 			{
@@ -96,22 +97,23 @@ namespace OOX
 
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
-				WritingElement_ReadAttributes_Start( oReader )
+				WritingElement_ReadAttributes_StartChar( oReader )
 
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("aca"),		m_oAca )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("bx"),      m_oBx )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("ca"),      m_oCa )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("del1"),	m_oDel1 )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("del2"),	m_oDel2 )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("dt2D"),	m_oDt2D )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("dtr"),		m_oDtr )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("r1"),		m_oR1 )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("r2"),		m_oR2 )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("ref"),		m_oRef )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("si"),		m_oSi )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("t"),		m_oT )
+					WritingElement_ReadAttributes_Read_ifChar		( oReader, "t",		m_oT )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "si",	m_oSi )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "aca",	m_oAca )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "bx",    m_oBx )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "ca",    m_oCa )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "del1",	m_oDel1 )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "del2",	m_oDel2 )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "dt2D",	m_oDt2D )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "dtr",	m_oDtr )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "r1",	m_oR1 )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "r2",	m_oR2 )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "ref",	m_oRef )
+					WritingElement_ReadAttributes_Read_else_ifChar	( oReader, "si",	m_oSi )
 
-					WritingElement_ReadAttributes_End( oReader )
+					WritingElement_ReadAttributes_EndChar( oReader )
 			}
 
 		public:
@@ -149,27 +151,10 @@ namespace OOX
 				return _T("");
 			}
 			virtual void toXML(NSStringUtils::CStringBuilder& writer) const;
-			virtual void 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 ( _T("f") == sName )
-						m_oFormula = oReader;
-					else if ( _T("is") == sName )
-						m_oRichText = oReader;
-					else if ( _T("v") == sName )
-						m_oValue = oReader;
-				}
-				PrepareForBinaryWriter();
-			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			void fromXMLtoXLSB(XmlUtils::CXmlLiteReader& oReader, NSBinPptxRW::CXlsbBinaryWriter& oStream);
+			void fromXLSB (NSBinPptxRW::CBinaryFileReader& oStream, _UINT16 nType, _UINT32 nRow);
+			void toXLSB (NSBinPptxRW::CXlsbBinaryWriter& oStream) const;
 
 			virtual EElementType getType () const
 			{
@@ -184,7 +169,8 @@ namespace OOX
 			{
 				if (m_oRef.IsInit())
 				{
-					return m_oRef.get();
+					const std::string& s = m_oRef.get();
+					return std::wstring(s.begin(), s.end());
 				}
 				else if (m_oRow.IsInit() && m_oCol.IsInit())
 				{
@@ -197,28 +183,27 @@ namespace OOX
 			}
 			void setRef(const std::wstring& sRef) 
 			{
-				m_oRef = sRef;
+				m_oRef = std::string(sRef.begin(), sRef.end());
 			}
 			bool getRowCol(int& nRow, int& nCol) const
 			{
 				bool bRes = false;
 				nRow = 0;
 				nCol = 0;
-				if (m_oRef.IsInit())
+				if (m_oRow.IsInit() && m_oCol.IsInit())
 				{
-					if (parseRef(m_oRef.get(), nRow, nCol))
+					bRes = true;
+					nRow = m_oRow->GetValue();
+					nCol = m_oCol->GetValue();
+				}
+				else if (m_oRef.IsInit())
+				{
+					if (parseRefA(m_oRef->c_str(), nRow, nCol))
 					{
 						bRes = true;
 						nRow--;
 						nCol--;
 					}
-
-				}
-				else if (m_oRow.IsInit() && m_oCol.IsInit())
-				{
-					bRes = true;
-					nRow = m_oRow->GetValue();
-					nCol = m_oCol->GetValue();
 				}
 				return bRes;
 			}
@@ -283,59 +268,17 @@ namespace OOX
 				}
 				return bRes;
 			}
-			static bool parseRef(std::wstring sRef, int& nRow, int& nCol)
-			{
-				bool bRes = false;
-
-				nRow = 0;
-				nCol = 0;
-				int nLegnth = (int)sRef.length();
-				if (nLegnth > 0)
-				{
-					int nIndex = 0;
-					NSStringExt::ToUpper(sRef);
-                    wchar_t cCurLetter = sRef[nIndex];
-					while ('A' <= cCurLetter && cCurLetter <= 'Z' && nIndex < nLegnth)
-					{
-						nIndex++;
-						cCurLetter = sRef[nIndex];
-					}
-					if (nIndex > 0)
-					{
-						std::wstring sAdd = sRef.substr(0, nIndex);
-						std::wstring sDig = sRef.substr(nIndex, nLegnth - nIndex);
-						for (size_t i = 0, length = sAdd.length(); i < length; ++i)
-						{
-							nCol = nCol * 26 + sAdd[i] - 'A' + 1;
-						}
-						if (!sDig.empty())
-						{
-							nRow = _wtoi(sDig.c_str());
-							bRes = true;
-						}
-					}
-				}
-				return bRes;
-			}
+			static bool parseRef(std::wstring sRef, int& nRow, int& nCol);
+			static bool parseRefA(const char* sRef, int& nRow, int& nCol);
+			static bool parseRefColA(const char* sRef, int& nCol);
 			static std::wstring combineRef(int nRow, int nCol);
 		private:
 			void PrepareForBinaryWriter();
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+			void ReadAttributesToXLSB(XmlUtils::CXmlLiteReader& oReader, int& nCol, unsigned int& nStyle, SimpleTypes::Spreadsheet::CCellTypeType<>& oType, bool& bShowPhonetic);
+			void toXLSB2 (NSBinPptxRW::CXlsbBinaryWriter& oStream, int nCol, unsigned int nStyle, bool bShowPhonetic, _UINT16 nType, double dValue, unsigned int nValue, BYTE bValue, std::wstring** psValue, bool bForceFormula, const nullable<CFormula>& oFormula, const nullable<CSi>& oRichText) const;
 
-			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
-			{
-				WritingElement_ReadAttributes_Start( oReader )
-
-					WritingElement_ReadAttributes_Read_if ( oReader, _T("cm"), m_oCellMetadata )
-					WritingElement_ReadAttributes_Read_if ( oReader, _T("ph"), m_oShowPhonetic )
-					WritingElement_ReadAttributes_Read_if ( oReader, _T("r"), m_oRef )
-					WritingElement_ReadAttributes_Read_if ( oReader, _T("s"), m_oStyle )
-					WritingElement_ReadAttributes_Read_if ( oReader, _T("t"), m_oType )
-					WritingElement_ReadAttributes_Read_if ( oReader, _T("vm"), m_oValueMetadata )
-
-					WritingElement_ReadAttributes_End( oReader )
-			}
-
-			nullable<std::wstring>								m_oRef;
+			nullable<std::string>								m_oRef;
 			nullable<SimpleTypes::CUnsignedDecimalNumber<>>		m_oRow;
 			nullable<SimpleTypes::CUnsignedDecimalNumber<>>		m_oCol;
 		public:
@@ -383,51 +326,11 @@ namespace OOX
 				
 				toXMLEnd(writer);
 			}
-			virtual void toXMLStart(NSStringUtils::CStringBuilder& writer) const
-			{
-				writer.WriteString(_T("<row"));
-				WritingStringNullableAttrBool(L"collapsed", m_oCollapsed);
-				WritingStringNullableAttrBool(L"customFormat", m_oCustomFormat);
-				WritingStringNullableAttrDouble(L"ht", m_oHt, m_oHt->GetValue());
-				WritingStringNullableAttrBool(L"customHeight", m_oCustomHeight);
-				WritingStringNullableAttrBool(L"hidden", m_oHidden);
-				WritingStringNullableAttrInt(L"outlineLevel", m_oOutlineLevel, m_oOutlineLevel->GetValue());
-				WritingStringNullableAttrBool(L"ph", m_oPh);
-				WritingStringNullableAttrInt(L"r", m_oR, m_oR->GetValue());
-				WritingStringNullableAttrInt(L"s", m_oS, m_oS->GetValue());
-				WritingStringNullableAttrBool(L"thickBot", m_oThickBot);
-				WritingStringNullableAttrBool(L"thickTop", m_oThickTop);
-				writer.WriteString(_T(">"));
-			}
-			virtual void toXMLEnd(NSStringUtils::CStringBuilder& writer) const
-			{
-				writer.WriteString(_T("</row>"));
-			}
-			virtual void 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 ( _T("c") == sName )
-					{
-						CCell *pCell = new CCell();
-						if (pCell)
-						{
-							pCell->m_pMainDocument = m_pMainDocument;
-							pCell->fromXML(oReader);
-							m_arrItems.push_back(pCell);
-						}
-					}
-				}
-			}
-
+			void toXMLStart(NSStringUtils::CStringBuilder& writer) const;
+			void toXMLEnd(NSStringUtils::CStringBuilder& writer) const;
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			void fromXLSB (NSBinPptxRW::CBinaryFileReader& oStream, _UINT16 nType);
+			void toXLSB (NSBinPptxRW::CXlsbBinaryWriter& oStream) const;
 			virtual EElementType getType () const
 			{
 				return et_x_Row;
@@ -435,23 +338,8 @@ namespace OOX
 
 		private:
 
-			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
-			{
-				WritingElement_ReadAttributes_Start( oReader )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("collapsed"),		m_oCollapsed )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("customFormat"),    m_oCustomFormat )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("customHeight"),    m_oCustomHeight )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("hidden"),			m_oHidden )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("ht"),				m_oHt )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("outlineLevel"),    m_oOutlineLevel )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("ph"),				m_oPh )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("r"),				m_oR )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("s"),				m_oS )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("thickBot"),		m_oThickBot )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("thickTop"),		m_oThickTop )
-					WritingElement_ReadAttributes_Read_if     ( oReader, _T("x14ac:dyDescent"),	m_oDyDescent )
-				WritingElement_ReadAttributes_End( oReader )
-			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+			void CheckIndex();
 
 		public:
 			nullable<SimpleTypes::COnOff<>>					m_oCollapsed;
@@ -506,37 +394,20 @@ namespace OOX
 			{
 				writer.WriteString(_T("</sheetData>"));
 			}
-			virtual void 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 ( _T("row") == sName )
-					{
-						CRow *pRow = new CRow();
-						if (pRow)
-						{
-							pRow->m_pMainDocument = m_pMainDocument;
-							pRow->fromXML(oReader);
-							m_arrItems.push_back(pRow);
-						}
-					}
-				}
-			}
-
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			void fromXLSB (NSBinPptxRW::CBinaryFileReader& oStream, _UINT16 nType, CSVWriter::CCSVWriter* pCSVWriter, NSFile::CStreamWriter& oStreamWriter);
+			void toXLSB (NSBinPptxRW::CXlsbBinaryWriter& oStream) const;
 			virtual EElementType getType () const
 			{
 				return et_x_SheetData;
 			}
 		
+			nullable<SimpleTypes::CUnsignedDecimalNumber<>>	m_oXlsbPos;
 		private:
+			void fromXLSBToXmlCell (CCell& pCell, CSVWriter::CCSVWriter* pCSVWriter, NSFile::CStreamWriter& oStreamWriter);
+			void fromXLSBToXmlRowStart (CRow* pRow, CSVWriter::CCSVWriter* pCSVWriter, NSFile::CStreamWriter& oStreamWriter);
+			void fromXLSBToXmlRowEnd (CRow* pRow, CSVWriter::CCSVWriter* pCSVWriter, NSFile::CStreamWriter& oStreamWriter);
+
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
 			}

Common/DocxFormat/Source/XlsxFormat/WritingElement.h

@@ -147,3 +147,783 @@ namespace Spreadsheet
 	};
 }
 }
+namespace XLSB
+{
+	typedef enum CF_RECORD_TYPE
+	{
+		rt_ROW_HDR =								0,
+		rt_CELL_BLANK =								1,
+		rt_CELL_RK =								2,
+		rt_CELL_ERROR =								3,
+		rt_CELL_BOOL =								4,
+		rt_CELL_REAL =								5,
+		rt_CELL_ST =								6,
+		rt_CELL_ISST =								7,
+		rt_FMLA_STRING =							8,
+		rt_FMLA_NUM =								9,
+		rt_FMLA_BOOL =								10,
+		rt_FMLA_ERROR =								11,
+		rt_SST_ITEM =								19,
+		rt_PCDI_MISSING =							20,
+		rt_PCDI_NUMBER =							21,
+		rt_PCDI_BOOLEAN =							22,
+		rt_PCDI_ERROR =								23,
+		rt_PCDI_STRING =							24,
+		rt_PCDI_DATETIME =							25,
+		rt_PCDI_INDEX =								26,
+		rt_PCDIA_MISSING =							27,
+		rt_PCDIA_NUMBER =							28,
+		rt_PCDIA_BOOLEAN =							29,
+		rt_PCDIA_ERROR =							30,
+		rt_PCDIA_STRING =							31,
+		rt_PCDIA_DATETIME =							32,
+		rt_PCR_RECORD =								33,
+		rt_PCR_RECORD_DT =							34,
+		rt_FRT_BEGIN =								35,
+		rt_FRT_END =								36,
+		rt_AC_BEGIN =								37,
+		rt_AC_END =									38,
+		rt_NAME =									39,
+		rt_INDEX_ROW_BLOCK =						40,
+		rt_INDEX_BLOCK =							42,
+		rt_FONT =									43,
+		rt_FMT =									44,
+		rt_FILL =									45,
+		rt_BORDER =									46,
+		rt_XF =										47,
+		rt_STYLE =									48,
+		rt_CELL_META =								49,
+		rt_VALUE_META =								50,
+		rt_MDB =									51,
+		rt_BEGIN_FMD =								52,
+		rt_END_FMD =								53,
+		rt_BEGIN_MDX =								54,
+		rt_END_MDX =								55,
+		rt_BEGIN_MDX_TUPLE =						56,
+		rt_END_MDX_TUPLE =							57,
+		rt_MDX_MBR_ISTR =							58,
+		rt_STR =									59,
+		rt_COL_INFO =								60,
+		rt_CELL_R_STRING =							62,
+		rt_D_VAL =									64,
+		rt_SXVCELL_NUM =							65,
+		rt_SXVCELL_STR =							66,
+		rt_SXVCELL_BOOL =							67,
+		rt_SXVCELL_ERR =							68,
+		rt_SXVCELL_DATE =							69,
+		rt_SXVCELL_NIL =							70,
+		rt_FILE_VERSION =							128,
+		rt_BEGIN_SHEET =							129,
+		rt_END_SHEET =								130,
+		rt_BEGIN_BOOK =								131,
+		rt_END_BOOK =								132,
+		rt_BEGIN_WS_VIEWS =							133,
+		rt_END_WS_VIEWS =							134,
+		rt_BEGIN_BOOK_VIEWS =						135,
+		rt_END_BOOK_VIEWS =							136,
+		rt_BEGIN_WS_VIEW =							137,
+		rt_END_WS_VIEW =							138,
+		rt_BEGIN_CS_VIEWS =							139,
+		rt_END_CS_VIEWS =							140,
+		rt_BEGIN_CS_VIEW =							141,
+		rt_END_CS_VIEW =							142,
+		rt_BEGIN_BUNDLE_SHS =						143,
+		rt_END_BUNDLE_SHS =							144,
+		rt_BEGIN_SHEET_DATA =						145,
+		rt_END_SHEET_DATA =							146,
+		rt_WS_PROP =								147,
+		rt_WS_DIM =									148,
+		rt_PANE =									151,
+		rt_SEL =									152,
+		rt_WB_PROP =								153,
+		rt_WB_FACTOID =								154,
+		rt_FILE_RECOVER =							155,
+		rt_BUNDLE_SH =								156,
+		rt_CALC_PROP =								157,
+		rt_BOOK_VIEW =								158,
+		rt_BEGIN_SST =								159,
+		rt_END_SST =								160,
+		rt_BEGIN_A_FILTER =							161,
+		rt_END_A_FILTER =							162,
+		rt_BEGIN_FILTER_COLUMN =					163,
+		rt_END_FILTER_COLUMN =						164,
+		rt_BEGIN_FILTERS =							165,
+		rt_END_FILTERS =							166,
+		rt_FILTER =									167,
+		rt_COLOR_FILTER =							168,
+		rt_ICON_FILTER =							169,
+		rt_TOP10_FILTER =							170,
+		rt_DYNAMIC_FILTER =							171,
+		rt_BEGIN_CUSTOM_FILTERS =					172,
+		rt_END_CUSTOM_FILTERS =						173,
+		rt_CUSTOM_FILTER =							174,
+		rt_A_FILTER_DATE_GROUP_ITEM =				175,
+		rt_MERGE_CELL =								176,
+		rt_BEGIN_MERGE_CELLS =						177,
+		rt_END_MERGE_CELLS =						178,
+		rt_BEGIN_PIVOT_CACHE_DEF =					179,
+		rt_END_PIVOT_CACHE_DEF =					180,
+		rt_BEGIN_PCD_FIELDS =						181,
+		rt_END_PCD_FIELDS =							182,
+		rt_BEGIN_PCD_FIELD =						183,
+		rt_END_PCD_FIELD =							184,
+		rt_BEGIN_PCD_SOURCE =						185,
+		rt_END_PCD_SOURCE =							186,
+		rt_BEGIN_PCDS_RANGE =						187,
+		rt_END_PCDS_RANGE =							188,
+		rt_BEGIN_PCDF_ATBL =						189,
+		rt_END_PCDF_ATBL =							190,
+		rt_BEGIN_PCDI_RUN =							191,
+		rt_END_PCDI_RUN =							192,
+		rt_END_PIVOT_CACHE_RECORDS =				194,
+		rt_BEGIN_PCD_HIERARCHIES =					195,
+		rt_END_PCD_HIERARCHIES =					196,
+		rt_BEGIN_PCD_HIERARCHY =					197,
+		rt_END_PCD_HIERARCHY =						198,
+		rt_BEGIN_PCDH_FIELDS_USAGE =				199,
+		rt_END_PCDH_FIELDS_USAGE =					200,
+		rt_BEGIN_EXT_CONNECTION =					201,
+		rt_END_EXT_CONNECTION =						202,
+		rt_BEGIN_EC_DB_PROPS =						203,
+		rt_END_EC_DB_PROPS =						204,
+		rt_BEGIN_EC_OLAP_PROPS =					205,
+		rt_END_EC_OLAP_PROPS =						206,
+		rt_BEGIN_PCDS_CONSOL =						207,
+		rt_END_PCDS_CONSOL =						208,
+		rt_BEGIN_PCDSC_PAGES =						209,
+		rt_END_PCDSC_PAGES =						210,
+		rt_BEGIN_PCDSC_PAGE =						211,
+		rt_END_PCDSC_PAGE =							212,
+		rt_BEGIN_PCDSCP_ITEM =						213,
+		rt_END_PCDSCP_ITEM =						214,
+		rt_BEGIN_PCDSC_SETS =						215,
+		rt_END_PCDSC_SETS =							216,
+		rt_BEGIN_PCDSC_SET =						217,
+		rt_END_PCDSC_SET =							218,
+		rt_BEGIN_PCDF_GROUP =						219,
+		rt_END_PCDF_GROUP =							220,
+		rt_BEGIN_PCDFG_ITEMS =						221,
+		rt_END_PCDFG_ITEMS =						222,
+		rt_BEGIN_PCDFG_RANGE =						223,
+		rt_END_PCDFG_RANGE =						224,
+		rt_BEGIN_PCDFG_DISCRETE =					225,
+		rt_END_PCDFG_DISCRETE =						226,
+		rt_END_PCDSD_TUPLE_CACHE =					228,
+		rt_BEGIN_PCDSDTC_ENTRIES =					229,
+		rt_END_PCDSDTC_ENTRIES =					230,
+		rt_END_PCDSDTCE_MEMBER =					234,
+		rt_BEGIN_PCDSDTC_QUERIES =					235,
+		rt_END_PCDSDTC_QUERIES =					236,
+		rt_BEGIN_PCDSDTC_QUERY =					237,
+		rt_END_PCDSDTC_QUERY =						238,
+		rt_BEGIN_PCDSDTC_SETS =						239,
+		rt_END_PCDSDTC_SETS =						240,
+		rt_BEGIN_PCDSDTC_SET =						241,
+		rt_END_PCDSDTC_SET =						242,
+		rt_BEGIN_PCD_CALC_ITEMS =					243,
+		rt_END_PCD_CALC_ITEMS =						244,
+		rt_BEGIN_PCD_CALC_ITEM =					245,
+		rt_END_PCD_CALC_ITEM =						246,
+		rt_BEGIN_P_RULE =							247,
+		rt_END_P_RULE =								248,
+		rt_BEGIN_PR_FILTERS =						249,
+		rt_END_PR_FILTERS =							250,
+		rt_BEGIN_PR_FILTER =						251,
+		rt_END_PR_FILTER =							252,
+		rt_BEGIN_P_NAMES =							253,
+		rt_END_P_NAMES =							254,
+		rt_BEGIN_P_NAME =							255,
+		rt_END_P_NAME =								256,
+		rt_BEGIN_PN_PAIRS =							257,
+		rt_END_PN_PAIRS =							258,
+		rt_BEGIN_PN_PAIR =							259,
+		rt_END_PN_PAIR =							260,
+		rt_BEGIN_EC_WEB_PROPS =						261,
+		rt_END_EC_WEB_PROPS =						262,
+		rt_BEGIN_EC_WP_TABLES =						263,
+		rt_END_ECWP_TABLES =						264,
+		rt_BEGIN_EC_PARAMS =						265,
+		rt_END_EC_PARAMS =							266,
+		rt_BEGIN_EC_PARAM =							267,
+		rt_END_EC_PARAM =							268,
+		rt_BEGIN_PCDKPIS =							269,
+		rt_END_PCDKPIS =							270,
+		rt_BEGIN_PCDKPI =							271,
+		rt_END_PCDKPI =								272,
+		rt_BEGIN_DIMS =								273,
+		rt_END_DIMS =								274,
+		rt_BEGIN_DIM =								275,
+		rt_END_DIM =								276,
+		rt_INDEX_PART_END =							277,
+		rt_BEGIN_STYLE_SHEET =						278,
+		rt_END_STYLE_SHEET =						279,
+		rt_BEGIN_SX_VIEW =							280,
+		rt_END_SXVI =								281,
+		rt_BEGIN_SXVI =								282,
+		rt_BEGIN_SXVIS =							283,
+		rt_END_SXVIS =								284,
+		rt_BEGIN_SXVD =								285,
+		rt_END_SXVD =								286,
+		rt_BEGIN_SXVDS =							287,
+		rt_END_SXVDS =								288,
+		rt_BEGIN_SXPI =								289,
+		rt_END_SXPI =								290,
+		rt_BEGIN_SXPIS =							291,
+		rt_END_SXPIS =								292,
+		rt_BEGIN_SXDI =								293,
+		rt_END_SXDI =								294,
+		rt_BEGIN_SXDIS =							295,
+		rt_END_SXDIS =								296,
+		rt_BEGIN_SXLI =								297,
+		rt_END_SXLI =								298,
+		rt_BEGIN_SXLI_RWS =							299,
+		rt_END_SXLI_RWS =							300,
+		rt_BEGIN_SXLI_COLS =						301,
+		rt_END_SXLI_COLS =							302,
+		rt_BEGIN_SX_FORMAT =						303,
+		rt_END_SX_FORMAT =							304,
+		rt_BEGIN_SX_FORMATS =						305,
+		rt_END_SX_FORMATS =							306,
+		rt_BEGIN_SX_SELECT =						307,
+		rt_END_SX_SELECT =							308,
+		rt_BEGIN_ISXVD_RWS =						309,
+		rt_END_ISXVD_RWS =							310,
+		rt_BEGIN_ISXVD_COLS =						311,
+		rt_END_ISXVD_COLS =							312,
+		rt_END_SX_LOCATION =						313,
+		rt_BEGIN_SX_LOCATION =						314,
+		rt_END_SX_VIEW =							315,
+		rt_BEGIN_SXTHS =							316,
+		rt_END_SXTHS =								317,
+		rt_BEGIN_SXTH =								318,
+		rt_END_SXTH =								319,
+		rt_BEGIN_ISXTH_RWS =						320,
+		rt_END_ISXTH_RWS =							321,
+		rt_BEGIN_ISXTH_COLS =						322,
+		rt_END_ISXTH_COLS =							323,
+		rt_BEGIN_SXTDMPS =							324,
+		rt_END_SXTDMPS =							325,
+		rt_BEGIN_SXTDMP =							326,
+		rt_END_SXTDMP =								327,
+		rt_BEGIN_SXTH_ITEMS =						328,
+		rt_END_SXTH_ITEMS =							329,
+		rt_BEGIN_SXTH_ITEM =						330,
+		rt_END_SXTH_ITEM =							331,
+		rt_BEGIN_METADATA =							332,
+		rt_END_METADATA =							333,
+		rt_BEGIN_ESMDTINFO =						334,
+		rt_MDTINFO =								335,
+		rt_END_ESMDTINFO =							336,
+		rt_BEGIN_ESMDB =							337,
+		rt_END_ESMDB =								338,
+		rt_BEGIN_ESFMD =							339,
+		rt_END_ESFMD =								340,
+		rt_BEGIN_SINGLE_CELLS =						341,
+		rt_END_SINGLE_CELLS =						342,
+		rt_BEGIN_LIST =								343,
+		rt_END_LIST =								344,
+		rt_BEGIN_LIST_COLS =						345,
+		rt_END_LIST_COLS =							346,
+		rt_BEGIN_LIST_COL =							347,
+		rt_END_LIST_COL =							348,
+		rt_BEGIN_LIST_XML_C_PR =					349,
+		rt_END_LIST_XML_C_PR =						350,
+		rt_LIST_CC_FMLA =							351,
+		rt_LIST_TR_FMLA =							352,
+		rt_BEGIN_EXTERNALS =						353,
+		rt_END_EXTERNALS =							354,
+		rt_SUP_BOOK_SRC =							355,
+		rt_SUP_SELF =								357,
+		rt_SUP_SAME =								358,
+		rt_SUP_TABS =								359,
+		rt_BEGIN_SUP_BOOK =							360,
+		rt_PLACEHOLDER_NAME =						361,
+		rt_EXTERN_SHEET =							362,
+		rt_EXTERN_TABLE_START =						363,
+		rt_EXTERN_TABLE_END =						364,
+		rt_EXTERN_ROW_HDR =							366,
+		rt_EXTERN_CELL_BLANK =						367,
+		rt_EXTERN_CELL_REAL =						368,
+		rt_EXTERN_CELL_BOOL =						369,
+		rt_EXTERN_CELL_ERROR =						370,
+		rt_EXTERN_CELL_STRING =						371,
+		rt_BEGIN_ESMDX =							372,
+		rt_END_ESMDX =								373,
+		rt_BEGIN_MDX_SET =							374,
+		rt_END_MDX_SET =							375,
+		rt_BEGIN_MDX_MBR_PROP =						376,
+		rt_END_MDX_MBR_PROP =						377,
+		rt_BEGIN_MDX_KPI =							378,
+		rt_END_MDX_KPI =							379,
+		rt_BEGIN_ESSTR =							380,
+		rt_END_ESSTR =								381,
+		rt_BEGIN_PRF_ITEM =							382,
+		rt_END_PRF_ITEM =							383,
+		rt_BEGIN_PIVOT_CACHE_IDS =					384,
+		rt_END_PIVOT_CACHE_IDS =					385,
+		rt_BEGIN_PIVOT_CACHE_ID =					386,
+		rt_END_PIVOT_CACHE_ID =						387,
+		rt_BEGIN_ISXVIS =							388,
+		rt_END_ISXVIS =								389,
+		rt_BEGIN_COL_INFOS =						390,
+		rt_END_COL_INFOS =							391,
+		rt_BEGIN_RW_BRK =							392,
+		rt_END_RW_BRK =								393,
+		rt_BEGIN_COL_BRK =							394,
+		rt_END_COL_BRK =							395,
+		rt_BRK =									396,
+		rt_USER_BOOK_VIEW =							397,
+		rt_INFO =									398,
+		rt_C_USR =									399,
+		rt_USR =									400,
+		rt_BEGIN_USERS =							401,
+		rt_EOF =									403,
+		rt_UCR =									404,
+		rt_RR_INS_DEL =								405,
+		rt_RR_END_INS_DEL =							406,
+		rt_RR_MOVE =								407,
+		rt_RR_END_MOVE =							408,
+		rt_RR_CHG_CELL =							409,
+		rt_RR_END_CHG_CELL =						410,
+		rt_RR_HEADER =								411,
+		rt_RR_USER_VIEW =							412,
+		rt_RR_REN_SHEET =							413,
+		rt_RR_INSERT_SH =							414,
+		rt_RR_DEF_NAME =							415,
+		rt_RR_NOTE =								416,
+		rt_RR_CONFLICT =							417,
+		rt_RRTQSIF =								418,
+		rt_RR_FORMAT =								419,
+		rt_RR_END_FORMAT =							420,
+		rt_RR_AUTO_FMT =							421,
+		rt_BEGIN_USER_SH_VIEWS =					422,
+		rt_BEGIN_USER_SH_VIEW =						423,
+		rt_END_USER_SH_VIEW =						424,
+		rt_END_USER_SH_VIEWS =						425,
+		rt_ARR_FMLA =								426,
+		rt_SHR_FMLA =								427,
+		rt_TABLE =									428,
+		rt_BEGIN_EXT_CONNECTIONS =					429,
+		rt_END_EXT_CONNECTIONS =					430,
+		rt_BEGIN_PCD_CALC_MEMS =					431,
+		rt_END_PCD_CALC_MEMS =						432,
+		rt_BEGIN_PCD_CALC_MEM =						433,
+		rt_END_PCD_CALC_MEM =						434,
+		rt_BEGIN_PCDHG_LEVELS =						435,
+		rt_END_PCDHG_LEVELS =						436,
+		rt_BEGIN_PCDHG_LEVEL =						437,
+		rt_END_PCDHG_LEVEL =						438,
+		rt_BEGIN_PCDHGL_GROUPS =					439,
+		rt_END_PCDHGL_GROUPS =						440,
+		rt_BEGIN_PCDHGL_GROUP =						441,
+		rt_END_PCDHGL_GROUP =						442,
+		rt_END_PCDHGLG_MEMBERS =					444,
+		rt_BEGIN_PCDHGLG_MEMBER =					445,
+		rt_END_PCDHGLG_MEMBER =						446,
+		rt_BEGIN_QSI =								447,
+		rt_END_QSI =								448,
+		rt_BEGIN_QSIR =								449,
+		rt_END_QSIR =								450,
+		rt_BEGIN_DELETED_NAMES =					451,
+		rt_END_DELETED_NAMES =						452,
+		rt_BEGIN_DELETED_NAME =						453,
+		rt_END_DELETED_NAME =						454,
+		rt_BEGIN_QSIFS =							455,
+		rt_END_QSIFS =								456,
+		rt_BEGIN_QSIF =								457,
+		rt_END_QSIF =								458,
+		rt_BEGIN_AUTO_SORT_SCOPE =					459,
+		rt_END_AUTO_SORT_SCOPE =					460,
+		rt_BEGIN_CF_RULE =							463,
+		rt_END_CF_RULE =							464,
+		rt_BEGIN_ICON_SET =							465,
+		rt_END_ICON_SET =							466,
+		rt_BEGIN_DATABAR =							467,
+		rt_END_DATABAR =							468,
+		rt_BEGIN_COLOR_SCALE =						469,
+		rt_END_COLOR_SCALE =						470,
+		rt_CFVO =									471,
+		rt_EXTERN_VALUE_META =						472,
+		rt_BEGIN_COLOR_PALETTE =					473,
+		rt_END_COLOR_PALETTE =						474,
+		rt_INDEXED_COLOR =							475,
+		rt_MARGINS =								476,
+		rt_PRINT_OPTIONS =							477,
+		rt_PAGE_SETUP =								478,
+		rt_BEGIN_HEADER_FOOTER =					479,
+		rt_END_HEADER_FOOTER =						480,
+		rt_BEGIN_SX_CRT_FORMAT =					481,
+		rt_END_SX_CRT_FORMAT =						482,
+		rt_BEGIN_SX_CRT_FORMATS =					483,
+		rt_END_SX_CRT_FORMATS =						484,
+		rt_WS_FMT_INFO =							485,
+		rt_BEGIN_MGS =								486,
+		rt_END_MGS =								487,
+		rt_BEGIN_MG_MAPS =							488,
+		rt_END_MG_MAPS =							489,
+		rt_BEGIN_MG =								490,
+		rt_END_MG =									491,
+		rt_BEGIN_MAP =								492,
+		rt_END_MAP =								493,
+		rt_H_LINK =									494,
+		rt_BEGIN_D_CON =							495,
+		rt_END_D_CON =								496,
+		rt_BEGIN_D_REFS =							497,
+		rt_END_D_REFS =								498,
+		rt_D_REF =									499,
+		rt_BEGIN_SCEN_MAN =							500,
+		rt_END_SCEN_MAN =							501,
+		rt_BEGIN_SCT =								502,
+		rt_END_SCT =								503,
+		rt_SLC =									504,
+		rt_BEGIN_DXFS =								505,
+		rt_END_DXFS =								506,
+		rt_DXF =									507,
+		rt_BEGIN_TABLE_STYLES =						508,
+		rt_END_TABLE_STYLES =						509,
+		rt_BEGIN_TABLE_STYLE =						510,
+		rt_END_TABLE_STYLE =						511,
+		rt_TABLE_STYLE_ELEMENT =					512,
+		rt_TABLE_STYLE_CLIENT =						513,
+		rt_BEGIN_VOL_DEPS =							514,
+		rt_END_VOL_DEPS =							515,
+		rt_BEGIN_VOL_TYPE =							516,
+		rt_END_VOL_TYPE =							517,
+		rt_BEGIN_VOL_MAIN =							518,
+		rt_END_VOL_MAIN =							519,
+		rt_BEGIN_VOL_TOPIC =						520,
+		rt_END_VOL_TOPIC =							521,
+		rt_VOL_SUBTOPIC =							522,
+		rt_VOL_REF =								523,
+		rt_VOL_NUM =								524,
+		rt_VOL_ERR =								525,
+		rt_VOL_STR =								526,
+		rt_VOL_BOOL =								527,
+		rt_BEGIN_SORT_STATE =						530,
+		rt_END_SORT_STATE =							531,
+		rt_BEGIN_SORT_COND =						532,
+		rt_END_SORT_COND =							533,
+		rt_BOOK_PROTECTION =						534,
+		rt_SHEET_PROTECTION =						535,
+		rt_RANGE_PROTECTION =						536,
+		rt_PHONETIC_INFO =							537,
+		rt_BEGIN_EC_TXT_WIZ =						538,
+		rt_END_EC_TXT_WIZ =							539,
+		rt_BEGIN_ECTW_FLD_INFO_LST =				540,
+		rt_END_ECTW_FLD_INFO_LST =					541,
+		rt_BEGIN_EC_TW_FLD_INFO =					542,
+		rt_FILE_SHARING =							548,
+		rt_OLE_SIZE =								549,
+		rt_DRAWING =								550,
+		rt_LEGACY_DRAWING =							551,
+		rt_LEGACY_DRAWING_HF =						552,
+		rt_WEB_OPT =								553,
+		rt_BEGIN_WEB_PUB_ITEMS =					554,
+		rt_END_WEB_PUB_ITEMS =						555,
+		rt_BEGIN_WEB_PUB_ITEM =						556,
+		rt_END_WEB_PUB_ITEM =						557,
+		rt_BEGIN_SX_COND_FMT =						558,
+		rt_END_SX_COND_FMT =						559,
+		rt_BEGIN_SX_COND_FMTS =						560,
+		rt_END_SX_COND_FMTS =						561,
+		rt_BK_HIM =									562,
+		rt_COLOR =									564,
+		rt_BEGIN_INDEXED_COLORS =					565,
+		rt_END_INDEXED_COLORS =						566,
+		rt_BEGIN_MRU_COLORS =						569,
+		rt_END_MRU_COLORS =							570,
+		rt_MRU_COLOR =								572,
+		rt_BEGIN_D_VALS =							573,
+		rt_END_D_VALS =								574,
+		rt_SUP_NAME_START =							577,
+		rt_SUP_NAME_VALUE_START =					578,
+		rt_SUP_NAME_VALUE_END =						579,
+		rt_SUP_NAME_NUM =							580,
+		rt_SUP_NAME_ERR =							581,
+		rt_SUP_NAME_ST =							582,
+		rt_SUP_NAME_NIL =							583,
+		rt_SUP_NAME_BOOL =							584,
+		rt_SUP_NAME_FMLA =							585,
+		rt_SUP_NAME_BITS =							586,
+		rt_SUP_NAME_END =							587,
+		rt_END_SUP_BOOK =							588,
+		rt_CELL_SMART_TAG_PROPERTY =				589,
+		rt_BEGIN_CELL_SMART_TAG =					590,
+		rt_END_CELL_SMART_TAG =						591,
+		rt_BEGIN_CELL_SMART_TAGS =					592,
+		rt_END_CELL_SMART_TAGS =					593,
+		rt_BEGIN_SMART_TAGS =						594,
+		rt_END_SMART_TAGS =							595,
+		rt_SMART_TAG_TYPE =							596,
+		rt_BEGIN_SMART_TAG_TYPES =					597,
+		rt_END_SMART_TAG_TYPES =					598,
+		rt_BEGIN_SX_FILTERS =						599,
+		rt_END_SX_FILTERS =							600,
+		rt_BEGIN_SXFILTER =							601,
+		rt_END_SX_FILTER =							602,
+		rt_BEGIN_FILLS =							603,
+		rt_END_FILLS =								604,
+		rt_BEGIN_CELL_WATCHES =						605,
+		rt_END_CELL_WATCHES =						606,
+		rt_CELL_WATCH =								607,
+		rt_BEGIN_CR_ERRS =							608,
+		rt_END_CR_ERRS =							609,
+		rt_CRASH_REC_ERR =							610,
+		rt_BEGIN_FONTS =							611,
+		rt_END_FONTS =								612,
+		rt_BEGIN_BORDERS =							613,
+		rt_END_BORDERS =							614,
+		rt_BEGIN_FMTS =								615,
+		rt_END_FMTS =								616,
+		rt_BEGIN_CELL_XFS =							617,
+		rt_END_CELL_XFS =							618,
+		rt_BEGIN_STYLES =							619,
+		rt_END_STYLES =								620,
+		rt_BIG_NAME =								625,
+		rt_BEGIN_CELL_STYLE_XFS =					626,
+		rt_END_CELL_STYLE_XFS =						627,
+		rt_BEGIN_COMMENTS =							628,
+		rt_END_COMMENTS =							629,
+		rt_BEGIN_COMMENT_AUTHORS =					630,
+		rt_END_COMMENT_AUTHORS =					631,
+		rt_COMMENT_AUTHOR =							632,
+		rt_BEGIN_COMMENT_LIST =						633,
+		rt_END_COMMENT_LIST =						634,
+		rt_BEGIN_COMMENT =							635,
+		rt_END_COMMENT =							636,
+		rt_COMMENT_TEXT =							637,
+		rt_BEGIN_OLE_OBJECTS =						638,
+		rt_OLE_OBJECT =								639,
+		rt_END_OLE_OBJECTS =						640,
+		rt_BEGIN_SXRULES =							641,
+		rt_END_SX_RULES =							642,
+		rt_BEGIN_ACTIVE_X_CONTROLS =				643,
+		rt_ACTIVE_X =								644,
+		rt_END_ACTIVE_X_CONTROLS =					645,
+		rt_BEGIN_PCDSDTCE_MEMBERS_SORT_BY =			646,
+		rt_BEGIN_CELL_IGNORE_ECS =					648,
+		rt_CELL_IGNORE_EC =							649,
+		rt_END_CELL_IGNORE_ECS =					650,
+		rt_CS_PROP =								651,
+		rt_CS_PAGE_SETUP =							652,
+		rt_BEGIN_USER_CS_VIEWS =					653,
+		rt_END_USER_CS_VIEWS =						654,
+		rt_BEGIN_USER_CS_VIEW =						655,
+		rt_END_USER_CS_VIEW =						656,
+		rt_BEGIN_PCD_SFCI_ENTRIES =					657,
+		rt_END_PCDSFCI_ENTRIES =					658,
+		rt_PCDSFCI_ENTRY =							659,
+		rt_BEGIN_LIST_PARTS =						660,
+		rt_LIST_PART =								661,
+		rt_END_LIST_PARTS =							662,
+		rt_SHEET_CALC_PROP =						663,
+		rt_BEGIN_FN_GROUP =							664,
+		rt_FN_GROUP =								665,
+		rt_END_FN_GROUP =							666,
+		rt_SUP_ADDIN =								667,
+		rt_SXTDMP_ORDER =							668,
+		rt_CS_PROTECTION =							669,
+		rt_BEGIN_WS_SORT_MAP =						671,
+		rt_END_WS_SORT_MAP =						672,
+		rt_BEGIN_RR_SORT =							673,
+		rt_END_RR_SORT =							674,
+		rt_RR_SORT_ITEM =							675,
+		rt_FILE_SHARING_ISO =						676,
+		rt_BOOK_PROTECTION_ISO =					677,
+		rt_SHEET_PROTECTION_ISO =					678,
+		rt_CS_PROTECTION_ISO =						679,
+		rt_RANGE_PROTECTION_ISO =					680,
+		rt_RW_DESCENT =								1024,
+		rt_KNOWN_FONTS =							1025,
+		rt_BEGIN_SX_TUPLE_SET =						1026,
+		rt_END_SX_TUPLE_SET =						1027,
+		rt_END_SX_TUPLE_SET_HEADER =				1029,
+		rt_BEGIN_SX_TUPLE_SET_DATA =				1031,
+		rt_END_SX_TUPLE_SET_DATA =					1032,
+		rt_BEGIN_SX_TUPLE_SET_ROW =					1033,
+		rt_END_SX_TUPLE_SET_ROW =					1034,
+		rt_SX_TUPLE_SET_ROW_ITEM =					1035,
+		rt_NAME_EXT =								1036,
+		rt_PCDH14 =									1037,
+		rt_BEGIN_PCD_CALC_MEM14 =					1038,
+		rt_END_PCD_CALC_MEM14 =						1039,
+		rt_SXTH14 =									1040,
+		rt_BEGIN_SPARKLINE_GROUP =					1041,
+		rt_END_SPARKLINE_GROUP =					1042,
+		rt_SPARKLINE =								1043,
+		rt_SXDI14 =									1044,
+		rt_WS_FMT_INFO_EX14 =						1045,
+		rt_BEGIN_CF_RULE14 =						1048,
+		rt_END_CF_RULE14 =							1049,
+		rt_CFVO14 =									1050,
+		rt_BEGIN_DATABAR14 =						1051,
+		rt_BEGIN_ICON_SET14 =						1052,
+		rt_D_VAL14 =								1053,
+		rt_BEGIN_D_VALS14 =							1054,
+		rt_COLOR14 =								1055,
+		rt_BEGIN_SPARKLINES =						1056,
+		rt_END_SPARKLINES =							1057,
+		rt_BEGIN_SPARKLINE_GROUPS =					1058,
+		rt_END_SPARKLINE_GROUPS =					1059,
+		rt_SXVD14 =									1061,
+		rt_BEGIN_SX_VIEW14 =						1062,
+		rt_END_SX_VIEW14 =							1063,
+		rt_BEGIN_SX_VIEW16 =						1064,
+		rt_END_SX_VIEW16 =							1065,
+		rt_BEGIN_PCD14 =							1066,
+		rt_END_PCD14 =								1067,
+		rt_BEGIN_EXT_CONN14 =						1068,
+		rt_END_EXT_CONN14 =							1069,
+		rt_BEGIN_SLICER_CACHE_IDS =					1070,
+		rt_END_SLICER_CACHE_IDS =					1071,
+		rt_BEGIN_SLICER_CACHE_ID =					1072,
+		rt_END_SLICER_CACHE_ID =					1073,
+		rt_BEGIN_SLICER_CACHE =						1075,
+		rt_END_SLICER_CACHE =						1076,
+		rt_BEGIN_SLICER_CACHE_DEF =					1077,
+		rt_END_SLICER_CACHE_DEF =					1078,
+		rt_BEGIN_SLICERS_EX =						1079,
+		rt_END_SLICERS_EX =							1080,
+		rt_BEGIN_SLICER_EX =						1081,
+		rt_END_SLICER_EX =							1082,
+		rt_BEGIN_SLICER =							1083,
+		rt_END_SLICER =								1084,
+		rt_SLICER_CACHE_PIVOT_TABLES =				1085,
+		rt_SLICER_CACHE_OLAP_ITEM =					1096,
+		rt_SLICER_CACHE_SELECTION =					1098,
+		rt_END_SLICER_CACHE_NATIVE =				1101,
+		rt_SLICER_CACHE_NATIVE_ITEM =				1102,
+		rt_RANGE_PROTECTION14 =						1103,
+		rt_RANGE_PROTECTION_ISO14 =					1104,
+		rt_CELL_IGNORE_EC14 =						1105,
+		rt_LIST14 =									1111,
+		rt_CF_ICON =								1112,
+		rt_BEGIN_SLICER_CACHES_PIVOT_CACHE_IDS =	1113,
+		rt_BEGIN_SLICERS =							1115,
+		rt_END_SLICERS =							1116,
+		rt_WB_PROP14 =								1117,
+		rt_BEGIN_SX_EDIT =							1118,
+		rt_END_SX_EDIT =							1119,
+		rt_BEGIN_SX_EDITS =							1120,
+		rt_END_SX_EDITS =							1121,
+		rt_BEGIN_SX_CHANGE =						1122,
+		rt_END_SX_CHANGE =							1123,
+		rt_BEGIN_SX_CHANGES =						1124,
+		rt_END_SX_CHANGES =							1125,
+		rt_SX_TUPLE_ITEMS =							1126,
+		rt_BEGIN_SLICER_STYLE =						1128,
+		rt_END_SLICER_STYLE =						1129,
+		rt_SLICER_STYLE_ELEMENT =					1130,
+		rt_BEGIN_STYLE_SHEET_EXT14 =				1131,
+		rt_END_STYLE_SHEET_EXT14 =					1132,
+		rt_BEGIN_SLICER_CACHES_PIVOT_CACHE_ID =		1133,
+		rt_BEGIN_PCD_CALC_MEM_EXT =					1137,
+		rt_END_PCD_CALC_MEM_EXT =					1138,
+		rt_BEGIN_PCD_CALC_MEMS_EXT =				1139,
+		rt_END_PCD_CALC_MEMS_EXT =					1140,
+		rt_PCD_FIELD14 =							1141,
+		rt_BEGIN_SLICER_STYLES =					1142,
+		rt_END_SLICER_STYLES =						1143,
+		rt_CF_RULE_EXT =							1146,
+		rt_BEGIN_SX_COND_FMT14 =					1147,
+		rt_END_SX_COND_FMT14 =						1148,
+		rt_BEGIN_SX_COND_FMTS14 =					1149,
+		rt_END_SX_COND_FMTS14 =						1150,
+		rt_BEGIN_SORT_COND14 =						1152,
+		rt_END_SORT_COND14 =						1153,
+		rt_END_D_VALS14 =							1154,
+		rt_END_ICON_SET14 =							1155,
+		rt_END_DATABAR14 =							1156,
+		rt_BEGIN_COLOR_SCALE14 =					1157,
+		rt_END_COLOR_SCALE14 =						1158,
+		rt_BEGIN_SXRULES14 =						1159,
+		rt_END_SXRULES14 =							1160,
+		rt_BEGIN_P_RULE14 =							1161,
+		rt_END_P_RULE14 =							1162,
+		rt_BEGIN_PR_FILTERS14 =						1163,
+		rt_END_PR_FILTERS14 =						1164,
+		rt_BEGIN_PR_FILTER14 =						1165,
+		rt_END_PR_FILTER14 =						1166,
+		rt_BEGIN_PRF_ITEM14 =						1167,
+		rt_END_PRF_ITEM14 =							1168,
+		rt_BEGIN_CELL_IGNORE_ECS14 =				1169,
+		rt_END_CELL_IGNORE_ECS14 =					1170,
+		rt_DXF14 =									1171,
+		rt_BEGIN_DX_F14S =							1172,
+		rt_END_DXF14S =								1173,
+		rt_FILTER14 =								1177,
+		rt_BEGIN_CUSTOM_FILTERS14 =					1178,
+		rt_CUSTOM_FILTER14 =						1180,
+		rt_ICON_FILTER14 =							1181,
+		rt_BEGIN_PIVOT_TABLE_REFS =					2051,
+		rt_END_PIVOT_TABLE_REFS =					2052,
+		rt_PIVOT_TABLE_REF =						2053,
+		rt_BEGIN_SXVCELLS =							2055,
+		rt_END_SXVCELLS =							2056,
+		rt_BEGIN_SX_ROW =							2057,
+		rt_END_SX_ROW =								2058,
+		rt_PCD_CALC_MEM15 =							2060,
+		rt_QSI15 =									2067,
+		rt_BEGIN_WEB_EXTENSIONS =					2068,
+		rt_END_WEB_EXTENSIONS =						2069,
+		rt_WEB_EXTENSION =							2070,
+		rt_ABS_PATH15 =								2071,
+		rt_TABLE_SLICER_CACHE_IDS =					2075,
+		rt_TABLE_SLICER_CACHE_ID =					2076,
+		rt_BEGIN_TABLE_SLICER_CACHE =				2077,
+		rt_END_TABLE_SLICER_CACHE =					2078,
+		rt_SX_FILTER15 =							2079,
+		rt_BEGIN_TIMELINE_CACHE_PIVOT_CACHE_IDS =	2080,
+		rt_END_TIMELINE_CACHE_PIVOT_CACHE_IDS =		2081,
+		rt_END_TIMELINE_CACHE_IDS =					2084,
+		rt_BEGIN_TIMELINE_CACHE_ID =				2085,
+		rt_END_TIMELINE_CACHE_ID =					2086,
+		rt_BEGIN_TIMELINES_EX =						2087,
+		rt_END_TIMELINES_EX =						2088,
+		rt_BEGIN_TIMELINE_EX =						2089,
+		rt_END_TIMELINE_EX =						2090,
+		rt_WORK_BOOK_PR15 =							2091,
+		rt_PCDH15 =									2092,
+		rt_BEGIN_TIMELINE_STYLE =					2093,
+		rt_END_TIMELINE_STYLE =						2094,
+		rt_TIMELINE_STYLE_ELEMENT =					2095,
+		rt_BEGIN_TIMELINE_STYLES =					2098,
+		rt_END_TIMELINE_STYLES =					2099,
+		rt_DXF15 =									2102,
+		rt_BEGIN_DXFS15 =							2103,
+		rt_END_DXFS15 =								2104,
+		rt_SLICER_CACHE_HIDE_ITEMS_WITH_NO_DATA =	2105,
+		rt_BEGIN_ITEM_UNIQUE_NAMES =				2106,
+		rt_END_ITEM_UNIQUE_NAMES =					2107,
+		rt_ITEM_UNIQUE_NAME =						2108,
+		rt_BEGIN_EXT_CONN15 =						2109,
+		rt_END_EXT_CONN15 =							2110,
+		rt_BEGIN_OLEDB_PR15 =						2111,
+		rt_END_OLEDB_PR15 =							2112,
+		rt_BEGIN_DATA_FEED_PR15 =					2113,
+		rt_END_DATA_FEED_PR15 =						2114,
+		rt_TEXT_PR15 =								2115,
+		rt_RANGE_PR15 =								2116,
+		rt_DB_COMMAND15 =							2117,
+		rt_BEGIN_DB_TABLES15 =						2118,
+		rt_END_DB_TABLES15 =						2119,
+		rt_DB_TABLE15 =								2120,
+		rt_BEGIN_DATA_MODEL =						2121,
+		rt_END_DATA_MODEL =							2122,
+		rt_BEGIN_MODEL_TABLES =						2123,
+		rt_END_MODEL_TABLES =						2124,
+		rt_MODEL_TABLE =							2125,
+		rt_END_MODEL_RELATIONSHIPS =				2127,
+		rt_MODEL_RELATIONSHIP =						2128,
+		rt_BEGIN_EC_TXT_WIZ15 =						2129,
+		rt_END_EC_TXT_WIZ15 =						2130,
+		rt_BEGIN_ECTW_FLD_INFO_LST15 =				2131,
+		rt_END_ECTW_FLD_INFO_LST15 =				2132,
+		rt_BEGIN_ECTW_FLD_INFO15 =					2133,
+		rt_FIELD_LIST_ACTIVE_ITEM =					2134,
+		rt_PIVOT_CACHE_ID_VERSION =					2135,
+		rt_SXDI15 =									2136,
+		rt_REVISION_PTR =							3073,
+		rt_UNKNOWN =								0xFFFF
+	} RecordType;
+}

Common/DocxFormat/Source/XlsxFormat/Xlsx.h

@@ -99,6 +99,9 @@ namespace OOX
 			OOX::JsaProject*								m_pJsaProject;
             
 			WorkbookComments*								m_pWorkbookComments;
+			NSBinPptxRW::CXlsbBinaryWriter*					m_pXlsbWriter;
+			int												m_nLastReadRow;
+			int												m_nLastReadCol;
 
 			std::vector<CWorksheet*>								m_arWorksheets;	//order as is
 			std::map<std::wstring, OOX::Spreadsheet::CWorksheet*>	m_mapWorksheets; //copy, for fast find - order by rId(name) 
@@ -118,6 +121,9 @@ namespace OOX
 				m_pVbaProject		= NULL;
 				m_pJsaProject		= NULL;
 				m_pWorkbookComments = NULL;
+				m_pXlsbWriter = NULL;
+				m_nLastReadRow = 0;
+				m_nLastReadCol = -1;
 
 				bDeleteWorkbook			= false;
 				bDeleteSharedStrings	= false;

DesktopEditor/xml/include/xmlutils.h

@@ -103,11 +103,13 @@ namespace XmlUtils
 		
 		std::wstring	GetName();
                 std::string     GetNameA();
+                const char*     GetNameChar();
                 int             GetDepth();
                 bool            IsEmptyNode();
 
 		std::wstring	GetText();
                 std::string     GetTextA();
+                const char*		GetTextChar();
 
 		std::wstring	GetText2();
                 std::string     GetText2A();

DesktopEditor/xml/src/xmllight.cpp

@@ -126,6 +126,10 @@ namespace XmlUtils
 	{
 		return m_pInternal->GetNameA();
 	}
+	const char* CXmlLiteReader::GetNameChar()
+	{
+		return m_pInternal->GetNameChar();
+	}
 	int CXmlLiteReader::GetDepth()
 	{
 		return m_pInternal->GetDepth();
@@ -143,6 +147,10 @@ namespace XmlUtils
 	{
 		return m_pInternal->GetTextA();
 	}
+	const char* CXmlLiteReader::GetTextChar()
+	{
+		return m_pInternal->GetTextChar();
+	}
 
 	std::wstring CXmlLiteReader::GetText2()
 	{

DesktopEditor/xml/src/xmllight_private.h

@@ -266,12 +266,11 @@ namespace XmlUtils
             if (!IsValid())
                 return L"";
 
-            xmlChar* pName = xmlTextReaderName(reader);
+            const xmlChar* pName = xmlTextReaderConstName(reader);
             if (NULL == pName)
                 return L"";
 
             std::wstring sRet = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pName, (LONG)strlen((const char*)pName));
-            free(pName);
             return sRet;
         }
         std::string GetNameA()
@@ -279,14 +278,25 @@ namespace XmlUtils
             if (!IsValid())
                 return "";
 
-            xmlChar* pName = xmlTextReaderName(reader);
+            const xmlChar* pName = xmlTextReaderConstName(reader);
             if (NULL == pName)
                 return "";
 
             std::string sRet((char*)pName);
-            free(pName);
             return sRet;
         }
+        const char* GetNameChar()
+        {
+            if (!IsValid())
+                return "";
+
+            const xmlChar* pName = xmlTextReaderConstName(reader);
+            if (NULL == pName)
+                return "";
+
+            return (const char*)pName;
+        }
+
         inline int GetDepth()
         {
             if (!IsValid())
@@ -310,12 +320,11 @@ namespace XmlUtils
             if (!IsValid())
                 return NULL;
 
-            xmlChar* pValue = xmlTextReaderValue(reader);
+            const xmlChar* pValue = xmlTextReaderConstValue(reader);
             if (NULL == pValue)
                 return L"";
 
             std::wstring sTemp = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pValue, (LONG)strlen((const char*)pValue));
-            free(pValue);
             return sTemp;
         }
         inline std::string GetTextA()
@@ -323,14 +332,24 @@ namespace XmlUtils
             if (!IsValid())
                 return NULL;
 
-            xmlChar* pValue = xmlTextReaderValue(reader);
+            const xmlChar* pValue = xmlTextReaderConstValue(reader);
             if (NULL == pValue)
                 return "";
 
             std::string sTemp((const char*)pValue);
-            free(pValue);
             return sTemp;
         }
+        inline const char* GetTextChar()
+        {
+            if (!IsValid())
+                return "";
+
+            const xmlChar* pValue = xmlTextReaderConstValue(reader);
+            if (NULL == pValue)
+                return "";
+
+            return (const char*)pValue;
+        }
 
         std::wstring GetText2()
         {
@@ -440,12 +459,11 @@ namespace XmlUtils
 
         std::wstring GetNamespacePrefix()
         {
-            xmlChar* pName = xmlTextReaderPrefix(reader);
+            const xmlChar* pName = xmlTextReaderConstPrefix(reader);
             if (NULL == pName)
                 return L"";
 
             std::wstring sTemp = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pName, (LONG)strlen((const char*)pName));
-            free(pName);
             return sTemp;
         }
         XmlNodeType GetNodeType()

XlsxSerializerCom/Common/BinReaderWriterDefines.h

@@ -369,7 +369,8 @@ namespace BinXlsxRW
 		ColBreaks = 31,
 		DataValidations = 32,
 		QueryTable = 33,
-		Controls = 34
+		Controls = 34,
+		XlsbPos = 35
 	};}
 	namespace c_oSerWorksheetPropTypes{enum c_oSerWorksheetPropTypes
 	{

XlsxSerializerCom/Reader/BinaryWriter.cpp

@@ -29,6 +29,8 @@
  * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
  *
  */
+
+#include <stdio.h>
 #include "BinaryWriter.h"
 #include "../Writer/BinaryReader.h"
 
@@ -3809,13 +3811,22 @@ void BinaryWorksheetTableWriter::WriteMergeCells(const OOX::Spreadsheet::CMergeC
 void BinaryWorksheetTableWriter::WriteSheetData(const OOX::Spreadsheet::CSheetData& oSheetData)
 {
 	int nCurPos;
-	for(size_t i = 0, length = oSheetData.m_arrItems.size(); i < length; ++i)
+	if(oSheetData.m_oXlsbPos.IsInit())
 	{
-		OOX::Spreadsheet::CRow* pRow = oSheetData.m_arrItems[i];
-		nCurPos = m_oBcw.WriteItemStart(c_oSerWorksheetsTypes::Row);
-		WriteRow(*pRow);
+		nCurPos = m_oBcw.WriteItemStart(c_oSerWorksheetsTypes::XlsbPos);
+		m_oBcw.m_oStream.WriteLONG(oSheetData.m_oXlsbPos->GetValue());
 		m_oBcw.WriteItemEnd(nCurPos);
 	}
+	else
+	{
+		for(size_t i = 0, length = oSheetData.m_arrItems.size(); i < length; ++i)
+		{
+			OOX::Spreadsheet::CRow* pRow = oSheetData.m_arrItems[i];
+			nCurPos = m_oBcw.WriteItemStart(c_oSerWorksheetsTypes::Row);
+			WriteRow(*pRow);
+			m_oBcw.WriteItemEnd(nCurPos);
+		}
+	}
 }
 void BinaryWorksheetTableWriter::WriteRow(const OOX::Spreadsheet::CRow& oRows)
 {
@@ -6300,6 +6311,7 @@ void BinaryOtherTableWriter::WriteOtherTableContent()
 BinaryFileWriter::BinaryFileWriter(DocWrapper::FontProcessor& oFontProcessor) : m_oBcw(NULL), m_oFontProcessor(oFontProcessor)
 {
 	m_nLastFilePos = 0;
+	m_nLastFilePosOffset = 0;
 	m_nRealTableCount = 0;
 }
 BinaryFileWriter::~BinaryFileWriter()
@@ -6319,7 +6331,6 @@ _UINT32 BinaryFileWriter::Open(const std::wstring& sInputDir, const std::wstring
     pOfficeDrawingConverter->SetDstPath(path.GetDirectory() + FILE_SEPARATOR_STR + L"word");
     pOfficeDrawingConverter->SetMediaDstPath(mediaDir);
 
-	long nGrowSize = 1 * 1024 * 1024;//1мб
 	NSBinPptxRW::CBinaryFileWriter& oBufferedStream = *pOfficeDrawingConverter->m_pBinaryWriter;
 
 	m_oBcw = new BinaryCommonWriter(oBufferedStream);
@@ -6331,6 +6342,7 @@ _UINT32 BinaryFileWriter::Open(const std::wstring& sInputDir, const std::wstring
 	BYTE saveFileType;
 	SerializeCommon::ReadFileType(sXMLOptions, fileType, nCodePage, sDelimiter, saveFileType);
 
+	m_nLastFilePosOffset = 0;
 	OOX::Spreadsheet::CXlsx *pXlsx = NULL;
 	switch(fileType)
 	{
@@ -6342,7 +6354,28 @@ _UINT32 BinaryFileWriter::Open(const std::wstring& sInputDir, const std::wstring
 		case BinXlsxRW::c_oFileTypes::XLSX:
 		default:
 		{
-			pXlsx = new OOX::Spreadsheet::CXlsx(OOX::CPath(sInputDir));
+			if (bIsNoBase64)
+			{
+				pXlsx = new OOX::Spreadsheet::CXlsx();
+
+				NSBinPptxRW::CXlsbBinaryWriter oXlsbWriter;
+				oXlsbWriter.CreateFileW(sFileDst);
+				//write dummy header and main table
+				oXlsbWriter.WriteStringUtf8(WriteFileHeader(0, g_nFormatVersionNoBase64));
+				oXlsbWriter.WriteReserved(GetMainTableSize());
+				int nDataStartPos = oXlsbWriter.GetPosition();
+				pXlsx->m_pXlsbWriter = &oXlsbWriter;
+				//parse
+				pXlsx->Read(OOX::CPath(sInputDir));
+
+				pXlsx->m_pXlsbWriter = NULL;
+				oXlsbWriter.CloseFile();
+				m_nLastFilePosOffset = oXlsbWriter.GetPosition() - nDataStartPos;
+			}
+			else
+			{
+				pXlsx = new OOX::Spreadsheet::CXlsx(OOX::CPath(sInputDir));
+			}
 		}break;
 	}		
 	if (0 != result)
@@ -6370,15 +6403,29 @@ _UINT32 BinaryFileWriter::Open(const std::wstring& sInputDir, const std::wstring
 		{
 			oBufferedStream.WriteStringUtf8(WriteFileHeader(0, g_nFormatVersionNoBase64));
 		}
+		int nHeaderLen = oBufferedStream.GetPosition();
 		intoBindoc(*pXlsx, oBufferedStream, pEmbeddedFontsManager, pOfficeDrawingConverter);
 
 		BYTE* pbBinBuffer = oBufferedStream.GetBuffer();
 		int nBinBufferLen = oBufferedStream.GetPosition();
 		if (bIsNoBase64)
 		{
+			int nMidPoint = nHeaderLen + GetMainTableSize();
 			NSFile::CFileBinary oFile;
-			oFile.CreateFileW(sFileDst);
-			oFile.WriteFile(pbBinBuffer, nBinBufferLen);
+			if(0 != m_nLastFilePosOffset)
+			{
+				oFile.OpenFile(sFileDst, true);
+			}
+			else
+			{
+				oFile.CreateFileW(sFileDst);
+			}
+			//write header and main table
+			oFile.WriteFile(pbBinBuffer, nMidPoint);
+			//skip xlsb records written on xml reading
+			oFile.SeekFile(0, SEEK_END);
+			//write other records
+			oFile.WriteFile(pbBinBuffer + nMidPoint, nBinBufferLen - nMidPoint);
 			oFile.CloseFile();
 		}
 		else
@@ -6486,15 +6533,17 @@ std::wstring BinaryFileWriter::WriteFileHeader(int nDataSize, int version)
 }
 void BinaryFileWriter::WriteMainTableStart()
 {
-	int nTableCount = 128;//Специально ставим большое число, чтобы не увеличивать его при добавлении очередной таблицы.
 	m_nRealTableCount = 0;
 	m_nMainTableStart = m_oBcw->m_oStream.GetPosition();
 	//вычисляем с какой позиции можно писать таблицы
-	int nmtItemSize = 5;//5 byte
-	m_nLastFilePos = m_nMainTableStart + nTableCount * nmtItemSize;
-	//Write mtLen 
+	m_nLastFilePos = m_nMainTableStart + GetMainTableSize();
+	//Write mtLen
 	m_oBcw->m_oStream.WriteBYTE(0);
 }
+int BinaryFileWriter::GetMainTableSize()
+{
+	return 128 * 5;//128 items of 5 bytes
+}
 void BinaryFileWriter::WriteMainTableEnd()
 {
 //Количество таблиц
@@ -6511,7 +6560,7 @@ int BinaryFileWriter::WriteTableStart(BYTE type, int nStartPos)
 	//Write mtiType
 	m_oBcw->m_oStream.WriteBYTE(type);
 	//Write mtiOffBits
-	m_oBcw->m_oStream.WriteLONG(m_nLastFilePos);
+	m_oBcw->m_oStream.WriteLONG(m_nLastFilePos + m_nLastFilePosOffset);
 
 	//Write table
 	//Запоминаем позицию в MainTable

XlsxSerializerCom/Reader/BinaryWriter.h

@@ -294,6 +294,7 @@ namespace BinXlsxRW
 	private:
 		BinaryCommonWriter* m_oBcw;
 		int m_nLastFilePos;
+		int m_nLastFilePosOffset;
 		int m_nRealTableCount;
 		int m_nMainTableStart;
 		DocWrapper::FontProcessor& m_oFontProcessor;
@@ -307,6 +308,7 @@ namespace BinXlsxRW
        std::wstring WriteFileHeader(int nDataSize, int version);
 		void WriteMainTableStart();
 		void WriteMainTableEnd();
+		int GetMainTableSize();
 		int WriteTableStart(BYTE type, int nStartPos = -1);
 		void WriteTableEnd(int nCurPos);
 	};

XlsxSerializerCom/Writer/BinaryReader.cpp

@@ -3367,9 +3367,9 @@ int BinaryWorksheetsTableReader::ReadWorksheet(boost::unordered_map<BYTE, std::v
 	SEEK_TO_POS_END(oCols);
 //-------------------------------------------------------------------------------------------------------------
 	SEEK_TO_POS_START(c_oSerWorksheetsTypes::SheetData);
-		OOX::Spreadsheet::CSheetData oSheetData;
 		if (NULL == m_oSaveParams.pCSVWriter)
 		{
+			OOX::Spreadsheet::CSheetData oSheetData;
 			oSheetData.toXMLStart(oStreamWriter);
 			READ1_DEF(length, res, this->ReadSheetData, NULL);
 			oSheetData.toXMLEnd(oStreamWriter);
@@ -4647,10 +4647,12 @@ int BinaryWorksheetsTableReader::ReadDrawing(BYTE type, long length, void* poRes
 	
 	int res = ReadCellAnchor(type, length, poResult);
 
-	if (res == c_oSerConstants::ReadOk) return res;	
+	if (res != c_oSerConstants::ReadUnknown) return res;	
+	res = c_oSerConstants::ReadOk;
 
 	if(c_oSer_DrawingType::pptxDrawing == type)
 	{
+		LONG nOldPos = m_oBufferedStream.GetPos();
 		pCellAnchor->m_oElement.Init();
 
 		BYTE typeRec1   = m_oBufferedStream.GetUChar();    // must be 0;
@@ -4661,7 +4663,10 @@ int BinaryWorksheetsTableReader::ReadDrawing(BYTE type, long length, void* poRes
 		pCellAnchor->m_oElement->fromPPTY(&m_oBufferedStream);
 
 		if (!pCellAnchor->m_oElement->is_init())
+		{
+			m_oBufferedStream.Seek(nOldPos);
 			res = c_oSerConstants::ReadUnknown;
+		}
 	}
 	else
 		res = c_oSerConstants::ReadUnknown;
@@ -4908,7 +4913,18 @@ int BinaryWorksheetsTableReader::ReadPos(BYTE type, long length, void* poResult)
 int BinaryWorksheetsTableReader::ReadSheetData(BYTE type, long length, void* poResult)
 {
 	int res = c_oSerConstants::ReadOk;
-	if(c_oSerWorksheetsTypes::Row == type)
+	if(c_oSerWorksheetsTypes::XlsbPos == type)
+	{
+		int nOldPos = m_oBufferedStream.GetPos();
+		m_oBufferedStream.Seek(m_oBufferedStream.GetULong());
+
+		OOX::Spreadsheet::CSheetData oSheetData;
+		oSheetData.fromXLSB(m_oBufferedStream, m_oBufferedStream.XlsbReadRecordType(), m_oSaveParams.pCSVWriter, *m_pCurStreamWriter);
+
+		m_oBufferedStream.Seek(nOldPos);
+		res = c_oSerConstants::ReadUnknown;
+	}
+	else if(c_oSerWorksheetsTypes::Row == type)
 	{
 		OOX::Spreadsheet::CRow oRow;
 		READ2_DEF_SPREADSHEET(length, res, this->ReadRow, &oRow);

XlsxSerializerCom/Writer/BinaryReader.h

@@ -238,7 +238,7 @@ namespace BinXlsxRW
 	class BinaryWorksheetsTableReader : public Binary_CommonReader
 	{
 		Binary_CommonReader2				m_oBcr2;
-		NSFile::CStreamWriter*				m_pCurStreamWriter;
+		NSFile::CStreamWriter*		m_pCurStreamWriter;
 		NSBinPptxRW::CDrawingConverter*		m_pOfficeDrawingConverter;
 
         OOX::Spreadsheet::CWorkbook&					m_oWorkbook;