fix bug after testing

.gitignore

@@ -45,3 +45,6 @@ OfficeUtils/win32/OfficeUtilsLib/OfficeUtilsLib/ReadMe.txt
 *.tlb
 *.idb
 **/.hg
+*.zip
+*.tar.gz
+**/*.build/

ASCOfficeDocxFile2/BinReader/DocumentWriter.h

@@ -54,7 +54,22 @@ namespace Writers
 			NSFile::CFileBinary oFile;
 			oFile.CreateFileW(filePath.GetPath());			
                 oFile.WriteStringUTF8( std::wstring(_T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>")));
-                oFile.WriteStringUTF8( std::wstring(_T("<w:document xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" mc:Ignorable=\"w14 wp14\">")));
+                oFile.WriteStringUTF8( std::wstring(_T("<w:document \
+xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" \
+xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" \
+xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" \
+xmlns:v=\"urn:schemas-microsoft-com:vml\" \
+xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" \
+xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" \
+xmlns:w10=\"urn:schemas-microsoft-com:office:word\" \
+xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" \
+xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" \
+xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" \
+xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" \
+xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" \
+xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" \
+xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" \
+mc:Ignorable=\"w14 wp14\">")));
 
                 oFile.WriteStringUTF8(m_oBackground.GetData());
 

ASCOfficeDocxFile2/BinReader/Readers.cpp

@@ -36,26 +36,10 @@ namespace BinDocxRW {
 
 int Binary_VbaProjectTableReader::Read()
 {
-	return ReadTable(&Binary_VbaProjectTableReader::ReadContent, this);
-}
-int Binary_VbaProjectTableReader::ReadContent(BYTE type, long length, void* poResult)
-{
-	int res = c_oSerConstants::ReadOk;
-	if ( c_oSerVbaProjectTypes::Name == type )
-	{
-		std::wstring file_name = m_oBufferedStream.GetString4(length);
+    m_oFileWriter.m_pVbaProject = new OOX::VbaProject();
+    m_oFileWriter.m_pVbaProject->fromPPTY(&m_oBufferedStream);
 
-		OOX::CPath inputPath = m_oBufferedStream.m_strFolder + FILE_SEPARATOR_STR + L"media"  + FILE_SEPARATOR_STR + file_name;
-        OOX::CPath outputPath = m_oFileWriter.m_oDocumentWriter.m_sDir + FILE_SEPARATOR_STR + L"word" + FILE_SEPARATOR_STR + L"vbaProject.bin";
-
-		NSFile::CFileBinary::Copy(inputPath.GetPath(), outputPath.GetPath());
-
-		m_oFileWriter.m_pVbaProject = new OOX::VbaProject();
-		m_oFileWriter.m_pVbaProject->set_filename(outputPath.GetPath());
-	}
-	else
-		res = c_oSerConstants::ReadUnknown;
-	return res;
+    return c_oSerConstants::ReadOk;
 }
 //-------------------------------------------------------------------------------------	
 Binary_HdrFtrTableReader::Binary_HdrFtrTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter, CComments* pComments):Binary_CommonReader(poBufferedStream),m_oFileWriter(oFileWriter),m_oHeaderFooterWriter(oFileWriter.m_oHeaderFooterWriter),m_pComments(pComments)
@@ -134,4 +118,4 @@ int Binary_HdrFtrTableReader::ReadHdrFtrItemContent(BYTE type, long length, void
 	return pBinary_DocumentTableReader->ReadDocumentContent(type, length, NULL);
 }
 
-}
+}

ASCOfficeDocxFile2/BinReader/Readers.h

@@ -285,8 +285,7 @@ public:
 	}
 
     int Read ();
-    int ReadContent	(BYTE type, long length, void* poResult);
-};
+ };
 
 class Binary_HdrFtrTableReader : public Binary_CommonReader<Binary_HdrFtrTableReader>
 {

ASCOfficeDocxFile2/BinWriter/BinWriters.h

@@ -3027,25 +3027,12 @@ namespace BinDocxRW
 			}
             pOfficeDrawingConverter->SetRels(oldRels);
 		}
-		void WriteVbaProjectContent(OOX::VbaProject& oVbaProject)
-		{
-			std::wstring file_name = oVbaProject.filename().GetFilename();
-			
-			m_oBcw.m_oStream.WriteBYTE(c_oSerVbaProjectTypes::Name);
-			m_oBcw.m_oStream.WriteStringW(file_name);
-	
-			//... todooo write parsing vba project
-
-			//write vbaData.... todooo
-			
-			//copy file bin
-			oVbaProject.copy_to(m_oBcw.m_oStream.m_pCommon->m_pImageManager->m_strDstMedia);
-		}
 		void WriteVbaProject(OOX::VbaProject& oVbaProject)
 		{
-			int nStart = m_oBcw.WriteItemWithLengthStart();
-			WriteVbaProjectContent(oVbaProject);
-			m_oBcw.WriteItemWithLengthEnd(nStart);
+            m_oBcw.m_oStream.StartRecord(0);
+            oVbaProject.toPPTY(&m_oBcw.m_oStream);
+            m_oBcw.m_oStream.EndRecord();
+
 		}
 		void Write(std::vector<OOX::WritingElement*>& aElems)
 		{

ASCOfficeDocxFile2/DocWrapper/DocxSerializer.cpp

@@ -93,7 +93,9 @@ bool BinDocxRW::CDocxSerializer::saveToFile(const std::wstring& sSrcFileName, co
 	oDrawingConverter.SetFontDir(m_sFontDir);
 	oDrawingConverter.SetFontPicker(pFontPicker);
 	oDrawingConverter.SetMainDocument(this);
-	oDrawingConverter.SetMediaDstPath(pathMedia.GetPath());
+
+    oDrawingConverter.SetDstPath(pathMain.GetDirectory() + FILE_SEPARATOR_STR + L"word");
+    oDrawingConverter.SetMediaDstPath(pathMedia.GetPath());
 	
 	m_pParamsWriter = new ParamsWriter(&oBufferedStream, &fp, &oDrawingConverter, pEmbeddedFontsManager);
 
@@ -263,8 +265,10 @@ bool BinDocxRW::CDocxSerializer::loadFromFile(const std::wstring& sSrcFileName,
 			
 			if (NULL != pData)
 			{
-				oDrawingConverter.SetMainDocument(this);
-				oDrawingConverter.SetMediaDstPath(sMediaPath);
+				oDrawingConverter.SetMainDocument(this);                
+                oDrawingConverter.SetDstPath(sDstPath + FILE_SEPARATOR_STR + L"word");
+
+                oDrawingConverter.SetMediaDstPath(sMediaPath);
 				oDrawingConverter.SetEmbedDstPath(sEmbedPath);
 				
 				m_pCurFileWriter = new Writers::FileWriter(sDstPath, m_sFontDir, false, nVersion, m_bSaveChartAsImg, &oDrawingConverter, sThemePath);
@@ -273,7 +277,7 @@ bool BinDocxRW::CDocxSerializer::loadFromFile(const std::wstring& sSrcFileName,
 				std::wstring strFileInDir = NSSystemPath::GetDirectoryName(sSrcFileName);
                 std::wstring sFileInDir = strFileInDir.c_str();
 
-                oDrawingConverter.SetSourceFileDir(sFileInDir);
+                oDrawingConverter.SetSrcPath(sFileInDir);
 				
 				BinaryFileReader oBinaryFileReader(sFileInDir, oBufferedStream, *m_pCurFileWriter);
 				oBinaryFileReader.ReadFile();

ASCOfficeDocxFile2/DocWrapper/XlsxSerializer.cpp

@@ -86,15 +86,16 @@ namespace BinXlsxRW{
 	}
     bool CXlsxSerializer::loadFromFile(const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions, const std::wstring& sMediaDir, const std::wstring& sEmbedDir)
 	{
-		NSBinPptxRW::CDrawingConverter oDrawingConverter;
+        std::wstring strFileInDir = NSSystemPath::GetDirectoryName(sSrcFileName);
+
+        NSBinPptxRW::CDrawingConverter oDrawingConverter;
 		
-		oDrawingConverter.SetMediaDstPath(sMediaDir);
+        oDrawingConverter.SetDstPath(sDstPath + FILE_SEPARATOR_STR + L"xl");
+        oDrawingConverter.SetSrcPath(strFileInDir, 2);
+
+        oDrawingConverter.SetMediaDstPath(sMediaDir);
 		oDrawingConverter.SetEmbedDstPath(sEmbedDir);
 
-		std::wstring strFileInDir = NSSystemPath::GetDirectoryName(sSrcFileName);
-
-        oDrawingConverter.SetSourceFileDir(strFileInDir, 2);
-
 		BinXlsxRW::BinaryFileReader oBinaryFileReader;
 		oBinaryFileReader.ReadFile(sSrcFileName, sDstPath, &oDrawingConverter, sXMLOptions);
 		return true;

ASCOfficeOdfFile/formulasconvert/formulasconvert.h

@@ -32,6 +32,7 @@
 #pragma once
 
 #include <string>
+#include <vector>
 #include "../include/cpdoccore/CPScopedPtr.h"
 
 namespace cpdoccore {
@@ -58,6 +59,8 @@ public:
 	
 	//Sheet2.C3:Sheet2.C19 -> Sheet2!C3:C19
     std::wstring convert_chart_distance(std::wstring const & expr);
+
+	void split_distance_by(const std::wstring& expr, const std::wstring& by, std::vector<std::wstring>& out);
     
     std::wstring convert_ref(std::wstring const & expr);
 

ASCOfficeOdfFile/formulasconvert/formulasconvert_odf.cpp

@@ -32,7 +32,6 @@
 #include "formulasconvert.h"
 
 #include <boost/regex.hpp>
-#include <boost/foreach.hpp>
 #include <boost/algorithm/string.hpp>
 
 #include"../../Common/DocxFormat/Source/XML/Utils.h"
@@ -46,6 +45,9 @@ namespace formulasconvert {
 
 		std::wstring convert(const std::wstring& expr);
 		std::wstring convert_chart_distance(const std::wstring& expr);
+
+		void split_distance_by(const std::wstring& expr, const std::wstring& by, std::vector<std::wstring>& out);
+		
 		void replace_cells_range(std::wstring& expr, bool withTableName);
 		bool check_formula(std::wstring& expr);
 		void replace_semicolons(std::wstring& expr);
@@ -189,7 +191,7 @@ namespace formulasconvert {
 
 			if (convert_with_TableName)
 			{
-				return (sheet1 + L"!") + c1 + (c2.empty() ? L"" : (L":" + c3) );
+				return (sheet1 + L"!") + c1 + (c3.empty() ? L"" : (L":" + c3) );
 			}
 			else
 			{
@@ -389,25 +391,24 @@ namespace formulasconvert {
 
 	std::wstring forbidden_formulas[] =
 	{
-		L"NULLFORMULA"
-		/*
-		L"BETADIST",
-		L"CEILING",
-		L"FLOOR",
-		L"RANK",
-		L"ROUND",
-		L"ROUNDDOWN",
-		L"ROUNDUP",
-		L"SUBTOTAL",
-		L"FORMULA",
-		L"ISREF"*/
+		L"NULLFORMULA"		
+		//L"BETADIST",
+		//L"CEILING",
+		//L"FLOOR",
+		//L"RANK",
+		//L"ROUND",
+		//L"ROUNDDOWN",
+		//L"ROUNDUP",
+		//L"SUBTOTAL",
+		//L"FORMULA",
+		//L"ISREF"
 	};
 
 	bool is_forbidden(const std::wstring & formula)
 	{
-		BOOST_FOREACH(const std::wstring & s, forbidden_formulas)
+		for (size_t i = 0; i < 1/*forbidden_formulas.size()*/; i++)
 		{
-			if (boost::algorithm::contains(formula, s))
+			if (boost::algorithm::contains(formula, forbidden_formulas[i]))
 				return true;
 		}
 		return false;
@@ -490,10 +491,30 @@ namespace formulasconvert {
 		return workstr;
 	}
 
+	void odf2oox_converter::Impl::split_distance_by(const std::wstring& expr, const std::wstring& by, std::vector<std::wstring>& out)
+	{
+		std::wstring workstr = expr;
+		boost::wregex complexRef(L"('(?!\\s\\'){0,1}.*?')");// поиск того что в апострофах и замена там
+
+		workstr = boost::regex_replace(
+			expr,
+			complexRef,
+			&replace_point_space,
+			boost::match_default | boost::format_all);
+	    
+		boost::algorithm::split(out, workstr, boost::algorithm::is_any_of(by), boost::algorithm::token_compress_on);
+		
+		for (size_t i = 0; i < out.size(); i++)
+		{
+ 			XmlUtils::replace_all( out[i], L"PROBEL", L" ");
+			XmlUtils::replace_all( out[i], L"TOCHKA", L".");
+		}
+	}
 
 	//Sheet2.C3:Sheet2.C19 Sheet2.L29:Sheet2.L36
 	//в
 	//Sheet2!C3:C19,Sheet2!L27:L34
+
 	std::wstring odf2oox_converter::Impl::convert_chart_distance(const std::wstring& expr)
 	{
 		if (is_forbidden(expr))
@@ -515,25 +536,27 @@ namespace formulasconvert {
 
 		boost::algorithm::split(distance_inp, workstr, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
 
-		BOOST_FOREACH(std::wstring &d,distance_inp)
+		for (size_t i = 0; i < distance_inp.size(); i++)
 		{
 			std::wstring sheet;
 			std::vector<std::wstring> range;
 			std::vector<std::wstring> cells;
 
-			boost::algorithm::split(range,d, boost::algorithm::is_any_of(L":"), boost::algorithm::token_compress_on);
+			boost::algorithm::split(range, distance_inp[i], boost::algorithm::is_any_of(L":"), boost::algorithm::token_compress_on);
 
-			BOOST_FOREACH(std::wstring &c,range)
+			for (size_t j = 0; j < range.size(); j++)
 			{
-				const std::string::size_type colon = c.find('.');
-				cells.push_back(c.substr(colon+1));
-				if (sheet.size()<1)
-					sheet=c.substr(0, colon);
+				const std::string::size_type colon = range[j].find('.');
+				cells.push_back(range[j].substr(colon + 1));
+				if (sheet.size() < 1)
+				{
+					sheet = range[j].substr(0, colon);
+				}
 			}
 			std::wstring cells_out;
-			BOOST_FOREACH(std::wstring &c,cells)
+			for (size_t j = 0; j < cells.size(); j++)
 			{
-				cells_out.append(c);
+				cells_out.append(cells[j]);
 				cells_out.append(L":");
 			}
 			int res1 = sheet.find(L"-");
@@ -544,19 +567,19 @@ namespace formulasconvert {
 				sheet = L"'" + sheet + L"'";
 			}
 
-			distance_out.push_back(sheet+L"!" + cells_out.substr(0, cells_out.size()-1));
+			distance_out.push_back(sheet + L"!" + cells_out.substr(0, cells_out.size()-1));
 		}
 		std::wstring result;
 
-		BOOST_FOREACH(std::wstring &d, distance_out)
+		for (size_t i = 0; i < distance_out.size(); i++)
 		{
-			result.append(d);
+			result.append(distance_out[i]);
 			result.append(L",");
 		}
  		XmlUtils::replace_all( result, L"PROBEL" , L" ");
-		XmlUtils::replace_all( result, L"TOCHKA"	, L".");
+		XmlUtils::replace_all( result, L"TOCHKA", L".");
 		
-		return result.substr(0, result.size()-1);// минус последняя лишняя запятая
+		return result.substr(0, result.size() - 1);// минус последняя лишняя запятая
 	}
 	odf2oox_converter::odf2oox_converter(): impl_(new odf2oox_converter::Impl)
 	{
@@ -579,6 +602,10 @@ namespace formulasconvert {
 	{
 		return impl_->convert_chart_distance(expr);
 	}
+	void odf2oox_converter::split_distance_by(const std::wstring& expr, const std::wstring& by, std::vector<std::wstring>& out)
+	{
+		return impl_->split_distance_by(expr, by, out);
+	}
 	std::wstring odf2oox_converter::convert_named_ref(const std::wstring& expr, bool withTableName, std::wstring separator)
 	{
 		boost::wregex complexRef(L"('(?!\\s\\'){0,1}.*?')");// поиск того что в апострофах и замена там

ASCOfficePPTXFile/ASCOfficeDrawingConverter.cpp

@@ -913,20 +913,29 @@ HRESULT CDrawingConverter::SetMainDocument(BinDocxRW::CDocxSerializer* pDocument
 	return S_OK;
 }
 
-HRESULT CDrawingConverter::SetMediaDstPath(const std::wstring& bsMediaPath)
+void CDrawingConverter::SetSrcPath(const std::wstring& sPath, int nDocType)
 {
-	m_pBinaryWriter->m_pCommon->m_pImageManager->m_strDstMedia = (std::wstring)bsMediaPath;
-	m_pImageManager->SetDstMedia(m_pBinaryWriter->m_pCommon->m_pImageManager->m_strDstMedia);
+    m_pReader->m_pRels->m_pManager  = m_pImageManager;
+    m_pReader->m_strFolder          = sPath;
 
-    NSDirectory::CreateDirectory(bsMediaPath);
-	return S_OK;
+    m_pImageManager->m_nDocumentType = nDocType;
 }
-HRESULT CDrawingConverter::SetEmbedDstPath(const std::wstring& bsEmbedPath)
+void CDrawingConverter::SetDstPath(const std::wstring& sPath)
 {
-	m_pImageManager->SetDstEmbed(bsEmbedPath);
+    m_pImageManager->SetDstFolder(sPath);
+}
+void CDrawingConverter::SetMediaDstPath(const std::wstring& sPath)
+{
+    m_pBinaryWriter->m_pCommon->m_pImageManager->m_strDstMedia = sPath;
+    m_pImageManager->SetDstMedia(sPath);
 
-    NSDirectory::CreateDirectory(bsEmbedPath);
-	return S_OK;
+    NSDirectory::CreateDirectory(sPath);
+}
+void CDrawingConverter::SetEmbedDstPath(const std::wstring& sPath)
+{
+    m_pImageManager->SetDstEmbed(sPath);
+
+    NSDirectory::CreateDirectory(sPath);
 }
 HRESULT CDrawingConverter::AddShapeType(const std::wstring& bsXml)
 {
@@ -5274,14 +5283,6 @@ OOX::CContentTypes* CDrawingConverter::GetContentTypes()
     //return m_pReader->mm_strContentTypes;
 }
 
-void CDrawingConverter::SetSourceFileDir(std::wstring path, int nDocType)
-{
-    m_pReader->m_pRels->m_pManager  = m_pImageManager;
-    m_pReader->m_strFolder          = path;
-
-	m_pImageManager->m_nDocumentType = nDocType;
-}
-
 void CDrawingConverter::Clear()
 {
 	for (std::map<std::wstring, CShape*>::iterator pPair = m_mapShapeTypes.begin(); pPair != m_mapShapeTypes.end(); ++pPair)

ASCOfficePPTXFile/ASCOfficeDrawingConverter.h

@@ -215,8 +215,12 @@ namespace NSBinPptxRW
 		smart_ptr<OOX::IFileContainer>	GetRels();
 		
 		HRESULT SetMainDocument     (BinDocxRW::CDocxSerializer* pDocument);
-        HRESULT SetMediaDstPath     (const std::wstring& sMediaPath);
-        HRESULT SetEmbedDstPath     (const std::wstring& sEmbedPath);
+
+        void SetSrcPath         (const std::wstring& sPath, int nDocType = 1/*XMLWRITER_DOC_TYPE_DOCX*/);
+        void SetDstPath         (const std::wstring& sPath);
+
+        void SetMediaDstPath    (const std::wstring& sMediaPath);
+        void SetEmbedDstPath    (const std::wstring& sEmbedPath);
 
         HRESULT AddShapeType        (const std::wstring& sXml);
         HRESULT AddObject           (const std::wstring& sXml, std::wstring** pMainProps);
@@ -255,8 +259,6 @@ namespace NSBinPptxRW
         void SetDocumentChartsCount (int val);
         int  GetDocumentChartsCount ();
 
-        void SetSourceFileDir       (std::wstring path, int nDocType = 1/*XMLWRITER_DOC_TYPE_DOCX*/);
-
         OOX::CContentTypes* GetContentTypes();
 	protected:
 		nullable<PPTX::Logic::Xfrm> m_oxfrm_override;

ASCOfficePPTXFile/Editor/Drawing/Elements.h

@@ -588,7 +588,7 @@ namespace NSPresentationEditor
 #else
         std::wstring ConvertPPTtoPPTX(CPPTShape* pPPTShape, const NSGuidesVML::CFormParam& pCoef, bool bIsNamespace = false)
 		{
-			if (pPPTShape->m_eType == PPTShapes::sptCRect)
+			if (pPPTShape->m_eType == PPTShapes::sptCRect || pPPTShape->m_eType == PPTShapes::sptCFrame)
 			{
 				if (bIsNamespace)
 				{
@@ -604,7 +604,14 @@ namespace NSPresentationEditor
 				}
 				return _T("<a:prstGeom prst=\"line\"><a:avLst/></a:prstGeom>");
 			}
-						
+			else if (pPPTShape->m_eType == PPTShapes::sptCEllipse)
+			{
+				if (bIsNamespace)
+				{
+					return _T("<a:prstGeom xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" prst=\"line\"><a:avLst/></a:prstGeom>");
+				}
+				return _T("<a:prstGeom prst=\"ellipse\"><a:avLst/></a:prstGeom>");
+			}
             std::wstring strXmlPPTX = bIsNamespace ? _T("<a:custGeom xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">") : _T("<a:custGeom>");
 
 			CFormulaConverter pFormulaConverter;

ASCOfficePPTXFile/PPTXFormat/Logic/CNvGraphicFramePr.h

@@ -121,7 +121,7 @@ namespace PPTX
 				oAttr.Write(_T("noSelect"),			noSelect);
 
 				std::wstring namespaceLocks = L"a";
-				if (m_namespace == L"wp") namespaceLocks = L"wp";
+				//if (m_namespace == L"wp") namespaceLocks = L"wp";
 
 				return XmlUtils::CreateNode(m_namespace + L":cNvGraphicFramePr", oAttr.m_strValue.empty() ? L"" : XmlUtils::CreateNode(namespaceLocks + L":graphicFrameLocks", oAttr));
 			}
@@ -134,7 +134,7 @@ namespace PPTX
 				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = L"xdr";
 				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
 				{
-					namespaceLock_	= L"wp";
+					namespaceLock_	= L"a";
 					namespace_		= L"wp";
 				}
 

ASCOfficePPTXFile/PPTXFormat/Logic/Pic.cpp

@@ -346,8 +346,11 @@ namespace PPTX
 							pReader->m_pRels = new NSBinPptxRW::CRelsGenerator();
 
 							oDrawingConverter.SetMainDocument(&oDocxSerializer);
-							oDrawingConverter.SetSourceFileDir(pReader->m_strFolder, 1);
-							oDrawingConverter.SetMediaDstPath(sMediaPath);
+
+                            oDrawingConverter.SetDstPath(sDstEmbeddedTemp + FILE_SEPARATOR_STR + L"word");
+                            oDrawingConverter.SetSrcPath(pReader->m_strFolder, 1);
+
+                            oDrawingConverter.SetMediaDstPath(sMediaPath);
 							oDrawingConverter.SetEmbedDstPath(sEmbedPath);
 
 							std::wstring sDocxFilename = L"Microsoft_Word_Document" + std::to_wstring( id ) + L".docx";
@@ -434,8 +437,10 @@ namespace PPTX
 							oDrawingConverter.m_pReader = pReader;
 							pReader->m_pRels = new NSBinPptxRW::CRelsGenerator();
 
-							oDrawingConverter.SetSourceFileDir(pReader->m_strFolder, 2);
-							oDrawingConverter.SetMediaDstPath(sMediaPath);
+                            oDrawingConverter.SetDstPath(sDstEmbeddedTemp + FILE_SEPARATOR_STR + L"xl");
+                            oDrawingConverter.SetSrcPath(pReader->m_strFolder, 2);
+
+                            oDrawingConverter.SetMediaDstPath(sMediaPath);
 							oDrawingConverter.SetEmbedDstPath(sEmbedPath);
 
 							std::wstring sXlsxFilename = L"Microsoft_Excel_Worksheet" + std::to_wstring( id ) + L".xlsx";
@@ -900,23 +905,28 @@ namespace PPTX
 				}
 				if (!blipFill.blip->mediaRid.empty())
 				{
-					PPTX::Logic::Ext ext;
+                    PPTX::Logic::Ext ext;
 					ext.link	= OOX::RId(blipFill.blip->mediaRid);
 					nvPicPr.nvPr.extLst.push_back(ext);
 
-					int nRId = -1;
+                    std::wstring strMediaRelsPath;
+                    if (pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX)	strMediaRelsPath = L"media/";
+                    else														strMediaRelsPath = L"../media/";
+
+                    smart_ptr<OOX::Media> mediaFile = blipFill.additionalFile.smart_dynamic_cast<OOX::Media>();
+                    strMediaRelsPath += mediaFile->filename().GetFilename();
+
+                    int nRId = -1;
 					if (blipFill.additionalFile.is<OOX::Audio>())
 					{
 						nvPicPr.nvPr.media.Media = new PPTX::Logic::MediaFile(L"audioFile");
-						nRId = pReader->m_pRels->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio",
-							L"NULL", L"External");
+                        nRId = pReader->m_pRels->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio", strMediaRelsPath, L"");
 
 					}
 					if (blipFill.additionalFile.is<OOX::Video>())
 					{
 						nvPicPr.nvPr.media.Media = new PPTX::Logic::MediaFile(L"videoFile");
-						nRId = pReader->m_pRels->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/video",
-							L"NULL", L"External");
+                        nRId = pReader->m_pRels->WriteRels(L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/video", strMediaRelsPath, L"");
 					}
 
 					if (nvPicPr.nvPr.media.Media.IsInit() && nRId > 0)

ASCOfficePPTXFile/PPTXFormat/Presentation.h

@@ -469,8 +469,8 @@ namespace PPTX
 		bool						m_bMacroEnabled;
 		smart_ptr<OOX::VbaProject>	m_pVbaProject;
 		
-		void SetClrMap(Logic::ClrMap map)				{m_clrMap = map;};
-		void SetClrScheme(nsTheme::ClrScheme scheme)	{m_clrScheme = scheme;};
+        void SetClrMap(Logic::ClrMap map)				{m_clrMap = map;}
+        void SetClrScheme(nsTheme::ClrScheme scheme)	{m_clrScheme = scheme;}
 
 		DWORD GetRGBAFromMap(const std::wstring& str)const
 		{

ASCOfficeRtfFile/RtfFormatLib/source/Reader/OOXDrawingGraphicReader.cpp

@@ -44,13 +44,13 @@ int OOXGraphicReader::Parse( ReaderParameter oParam , RtfShapePtr & pOutput)
 	{
 		if (m_ooxGraphic->element.getType() == OOX::et_p_ShapeTree)
 		{
-			OOXShapeReader shapeReader(m_ooxGraphic->element.GetElem().operator->());
-			return (shapeReader.Parse(oParam, pOutput) ? 1 : 0);
+			OOXShapeGroupReader groupReader(dynamic_cast<PPTX::Logic::SpTree*>(m_ooxGraphic->element.GetElem().operator->()));
+			return (groupReader.Parse(oParam, pOutput) ? 1 : 0);
 		}
 		else
 		{
-			OOXShapeGroupReader groupReader(dynamic_cast<PPTX::Logic::SpTree*>(m_ooxGraphic->element.GetElem().operator->()));
-			return (groupReader.Parse(oParam, pOutput) ? 1 : 0);
+			OOXShapeReader shapeReader(m_ooxGraphic->element.GetElem().operator->());
+			return (shapeReader.Parse(oParam, pOutput) ? 1 : 0);
 		}
 	}
 	if (m_ooxGraphic->olePic.IsInit())

ASCOfficeRtfFile/RtfFormatLib/source/Reader/OOXParagraphElementReaders.cpp

@@ -1003,7 +1003,7 @@ bool OOXRunReader::Parse( ReaderParameter oParam , RtfParagraph& oOutputParagrap
 		oNewProperty = oParam.oRtf->m_oDefaultCharProp; 
 		
 		//применяем внешний стиль
-		//oNewProperty.Merge( oOutputParagraph.m_oProperty.m_oCharProperty );
+		oNewProperty.Merge( oOutputParagraph.m_oProperty.m_oCharProperty );
 		oNewProperty.Merge( m_oCharProperty );
 
 		if( NULL != poStyle && TYPE_RTF_PROPERTY_STYLE_CHAR == poStyle->GetType() )

ASCOfficeRtfFile/RtfFormatLib/source/Reader/OOXPictureAnchorReader.h

@@ -49,6 +49,15 @@ public:
 
 		pOutput->m_eAnchorTypeShape	= RtfShape::st_anchor;
 
+		if ( m_ooxAnchor->m_oDocPr.IsInit() )
+		{
+			pOutput->m_nID			= m_ooxAnchor->m_oDocPr->id + 1025;
+			pOutput->m_sName		= m_ooxAnchor->m_oDocPr->name;
+
+			if (m_ooxAnchor->m_oDocPr->descr.IsInit())
+				pOutput->m_sDescription = m_ooxAnchor->m_oDocPr->descr.get();
+		}
+
 		pOutput->m_bAllowOverlap	= m_ooxAnchor->m_oAllowOverlap.IsInit() ? m_ooxAnchor->m_oAllowOverlap->ToBool()	: false;
 		pOutput->m_nZOrderRelative	= m_ooxAnchor->m_oBehindDoc.IsInit()	? m_ooxAnchor->m_oBehindDoc->ToBool()		: false;
 		pOutput->m_bHidden			= m_ooxAnchor->m_oHidden.IsInit()		? m_ooxAnchor->m_oHidden->ToBool()			: false;

ASCOfficeRtfFile/RtfFormatLib/source/Reader/OOXPictureInlineReader.h

@@ -77,6 +77,15 @@ public:
 				}
 			}
 		}
+
+		if ( m_ooxInline->m_oDocPr.IsInit() )
+		{
+			pOutput->m_nID			= m_ooxInline->m_oDocPr->id + 1025;
+			pOutput->m_sName		= m_ooxInline->m_oDocPr->name;
+
+			if (m_ooxInline->m_oDocPr->descr.IsInit())
+				pOutput->m_sDescription = m_ooxInline->m_oDocPr->descr.get();
+		}
 		
 		OOXGraphicReader oGraphicReader(&m_ooxInline->m_oGraphic);
 			

ASCOfficeRtfFile/RtfFormatLib/source/Reader/OOXShapeReader.cpp

@@ -749,32 +749,44 @@ bool OOXShapeReader::Parse(ReaderParameter oParam, RtfShapePtr& pOutput, PPTX::L
 		if( PROP_DEF != nCropedWidthGoal )
 		{
 			//делаем crop
-			double nCropLeft = XmlUtils::GetInteger( oox_bitmap_fill->srcRect->l.get()) / 100. ;
-			//pOutput->m_oPicture->m_nCropL = nCropLeft * pOutput->m_oPicture->m_nWidthGoal * pOutput->m_oPicture->m_nScaleX / 100;
-			pOutput->m_oPicture->m_nCropL = (int)(nCropLeft * pOutput->m_oPicture->m_nWidthGoal);
-			pOutput->m_nCropFromLeft = (int)(nCropLeft* 65536);
-			nCropedWidthGoal -= pOutput->m_oPicture->m_nCropL;
+			if (oox_bitmap_fill->srcRect->l.IsInit())
+			{
+				double nCropLeft = XmlUtils::GetInteger( oox_bitmap_fill->srcRect->l.get()) / 100. ;
+				//pOutput->m_oPicture->m_nCropL = nCropLeft * pOutput->m_oPicture->m_nWidthGoal * pOutput->m_oPicture->m_nScaleX / 100;
+				pOutput->m_oPicture->m_nCropL = (int)(nCropLeft * pOutput->m_oPicture->m_nWidthGoal);
+				pOutput->m_nCropFromLeft = (int)(nCropLeft* 65536);
+				nCropedWidthGoal -= pOutput->m_oPicture->m_nCropL;
+			}
 
-			double nCropRight = XmlUtils::GetInteger( oox_bitmap_fill->srcRect->r.get()) / 100. ;
-			//pOutput->m_oPicture->m_nCropR = nCropRight * pOutput->m_oPicture->m_nWidthGoal * pOutput->m_oPicture->m_nScaleX / 100;
-			pOutput->m_oPicture->m_nCropR = (int)(nCropRight * pOutput->m_oPicture->m_nWidthGoal);
-			pOutput->m_nCropFromRight = (int)(nCropRight * 65536);
-			nCropedWidthGoal -= pOutput->m_oPicture->m_nCropR;
+			if (oox_bitmap_fill->srcRect->r.IsInit())
+			{
+				double nCropRight = XmlUtils::GetInteger( oox_bitmap_fill->srcRect->r.get()) / 100. ;
+				//pOutput->m_oPicture->m_nCropR = nCropRight * pOutput->m_oPicture->m_nWidthGoal * pOutput->m_oPicture->m_nScaleX / 100;
+				pOutput->m_oPicture->m_nCropR = (int)(nCropRight * pOutput->m_oPicture->m_nWidthGoal);
+				pOutput->m_nCropFromRight = (int)(nCropRight * 65536);
+				nCropedWidthGoal -= pOutput->m_oPicture->m_nCropR;
+			}
 		}
 		int nCropedHeightGoal = pOutput->m_oPicture->m_nHeightGoal;
 		if( PROP_DEF != nCropedHeightGoal )
 		{
-			double nCropTop = XmlUtils::GetInteger( oox_bitmap_fill->srcRect->t.get()) / 100. ;
-			//pOutput->m_oPicture->m_nCropT = nCropTop * pOutput->m_oPicture->m_nHeightGoal * pOutput->m_oPicture->m_dScaleY / 100;
-			pOutput->m_oPicture->m_nCropT = (int)(nCropTop * pOutput->m_oPicture->m_nHeightGoal);
-			pOutput->m_nCropFromTop = (int)(nCropTop * 65536);
-			nCropedHeightGoal -= pOutput->m_oPicture->m_nCropT;
+			if (oox_bitmap_fill->srcRect->t.IsInit())
+			{
+				double nCropTop = XmlUtils::GetInteger( oox_bitmap_fill->srcRect->t.get()) / 100. ;
+				//pOutput->m_oPicture->m_nCropT = nCropTop * pOutput->m_oPicture->m_nHeightGoal * pOutput->m_oPicture->m_dScaleY / 100;
+				pOutput->m_oPicture->m_nCropT = (int)(nCropTop * pOutput->m_oPicture->m_nHeightGoal);
+				pOutput->m_nCropFromTop = (int)(nCropTop * 65536);
+				nCropedHeightGoal -= pOutput->m_oPicture->m_nCropT;
+			}
 
-			double nCropBottom = XmlUtils::GetInteger( oox_bitmap_fill->srcRect->b.get()) / 100. ;
-			//pOutput->m_oPicture->m_nCropT = nCropTop * pOutput->m_oPicture->m_nHeightGoal * pOutput->m_oPicture->m_dScaleY / 100;
-			pOutput->m_oPicture->m_nCropB = (int)(nCropBottom * pOutput->m_oPicture->m_nHeightGoal);
-			pOutput->m_nCropFromBottom = (int)(nCropBottom * 65536);
-			nCropedHeightGoal -= pOutput->m_oPicture->m_nCropB;
+			if (oox_bitmap_fill->srcRect->b.IsInit())
+			{
+				double nCropBottom = XmlUtils::GetInteger( oox_bitmap_fill->srcRect->b.get()) / 100. ;
+				//pOutput->m_oPicture->m_nCropT = nCropTop * pOutput->m_oPicture->m_nHeightGoal * pOutput->m_oPicture->m_dScaleY / 100;
+				pOutput->m_oPicture->m_nCropB = (int)(nCropBottom * pOutput->m_oPicture->m_nHeightGoal);
+				pOutput->m_nCropFromBottom = (int)(nCropBottom * 65536);
+				nCropedHeightGoal -= pOutput->m_oPicture->m_nCropB;
+			}
 		}
 		//устанавливаем scale
 		if( PROP_DEF != pOutput->m_nLeft && PROP_DEF != pOutput->m_nRight && PROP_DEF != nCropedWidthGoal && 0 != nCropedWidthGoal )
@@ -916,7 +928,7 @@ void OOXShapeReader::Parse(ReaderParameter oParam, RtfShapePtr& pOutput, PPTX::L
 	}
 	if (oox_line_prop->w.IsInit())
 	{
-		pOutput->m_nLineWidth = oox_line_prop->w.get() * 12700;
+		pOutput->m_nLineWidth = oox_line_prop->w.get();
 	}
 	if (oox_line_prop->headEnd.IsInit())
 	{
@@ -1006,22 +1018,50 @@ void OOXShapeReader::Parse( ReaderParameter oParam, RtfShapePtr& pOutput, PPTX::
 	//	//Parse(theme->m_oThemeElements.m_oFmtScheme.m_oEffectStyleLst.m_arrEffectStyle[fmt_index].m_oSp3D.GetPointer(), &color);
 	//}
 }
-
-
 //-----------------------------------------------------------------------------------------------------------------------------
-
-bool OOXShapeReader::Parse( ReaderParameter oParam, RtfShapePtr& pOutput)
+void OOXShapeReader::Parse( ReaderParameter oParam, RtfShapePtr& pOutput, PPTX::Logic::Xfrm *xfrm)
 {
-	if (!m_vmlElement && !m_arrElement && !m_ooxShape) return false;
+	if (!xfrm) return;
 	
-	if (m_vmlElement ||  m_arrElement)	return ParseVml(oParam , pOutput);
+	double rot = xfrm->rot.IsInit() ? xfrm->rot.get() / 60000. : 0;
+	if (rot > 0.01)
+		pOutput->m_nRotation = rot * 65535;
 
+	if (xfrm->flipH.get_value_or(false))	pOutput->m_bFlipH = 1;	
+	if (xfrm->flipV.get_value_or(false))	pOutput->m_bFlipV = 1;
+
+	if (pOutput->m_bInGroup)
+	{
+		if (xfrm->offX.IsInit() && xfrm->offY.IsInit())
+		{
+			pOutput->m_nRelLeft	= (int)xfrm->offX.get();
+			pOutput->m_nRelTop	= (int)xfrm->offY.get();
+		}
+		else
+		{
+			pOutput->m_nRelLeft	= 0;
+			pOutput->m_nRelTop	= 0;
+		}
+		if (xfrm->extX.IsInit() && xfrm->extY.IsInit())
+		{
+			pOutput->m_nRelRight	= (int)pOutput->m_nRelLeft + xfrm->offX.get();
+			pOutput->m_nRelBottom	= (int)pOutput->m_nRelTop + xfrm->offY.get();
+		}
+		else
+		{
+			pOutput->m_nRelRight	= 0;
+			pOutput->m_nRelBottom	= 0;
+		}
+		pOutput->m_nRelRotation = pOutput->m_nRotation;
+	}
+}
+
+bool OOXShapeReader::ParseShape( ReaderParameter oParam, RtfShapePtr& pOutput)
+{
 	PPTX::Logic::Shape	* ooxShape	= dynamic_cast<PPTX::Logic::Shape*>	(m_ooxShape);
-	//PPTX::Logic::CxnSp* cxnShape	= dynamic_cast<PPTX::Logic::CxnSp*>	(m_ooxShape);
-	//PPTX::Logic::Pic	* ooxPic	= dynamic_cast<PPTX::Logic::Pic*>	(m_ooxShape);
-
-	if (ooxShape == NULL) return false;
-
+	
+	if (!ooxShape) return false;
+	
 	if (ooxShape->oTextBoxBodyPr.IsInit())
 	{
 		if (ooxShape->oTextBoxBodyPr->fromWordArt.get_value_or(false))
@@ -1051,7 +1091,9 @@ bool OOXShapeReader::Parse( ReaderParameter oParam, RtfShapePtr& pOutput)
 	if (ooxShape->spPr.Geometry.getType() == OOX::et_a_prstGeom)
 	{
 		PPTX::Logic::PrstGeom& geometry = ooxShape->spPr.Geometry.as<PPTX::Logic::PrstGeom>();
-		SimpleTypes::EShapeType type = (SimpleTypes::EShapeType)geometry.prst.GetBYTECode();
+		
+		SimpleTypes::CShapeType<> prst_type(geometry.prst.get());		
+		SimpleTypes::EShapeType type = prst_type.GetValue();
 			
 		pOutput->m_nShapeType = OOX::PrstGeom2VmlShapeType(type);
 		if (pOutput->m_nShapeType == SimpleTypes::Vml::sptNotPrimitive)
@@ -1087,40 +1129,9 @@ bool OOXShapeReader::Parse( ReaderParameter oParam, RtfShapePtr& pOutput)
 		pOutput->m_nGeoRight	= 100000;
 		pOutput->m_nGeoBottom	= 100000;
 	}
-	if (ooxShape->spPr.xfrm.IsInit())
-	{
-		double rot = ooxShape->spPr.xfrm->rot.get() / 60000.;
-		if (rot > 0.01)
-			pOutput->m_nRotation = rot * 65535;
 
-		if (ooxShape->spPr.xfrm->flipH.get_value_or(false))	pOutput->m_bFlipH = 1;	
-		if (ooxShape->spPr.xfrm->flipV.get_value_or(false))	pOutput->m_bFlipV = 1;
+	Parse(oParam, pOutput, ooxShape->spPr.xfrm.GetPointer());
 
-		if (pOutput->m_bInGroup)
-		{
-			if (ooxShape->spPr.xfrm->offX.IsInit() && ooxShape->spPr.xfrm->offY.IsInit())
-			{
-				pOutput->m_nRelLeft	= (int)ooxShape->spPr.xfrm->offX.get();
-				pOutput->m_nRelTop	= (int)ooxShape->spPr.xfrm->offY.get();
-			}
-			else
-			{
-				pOutput->m_nRelLeft	= 0;
-				pOutput->m_nRelTop	= 0;
-			}
-			if (ooxShape->spPr.xfrm->extX.IsInit() && ooxShape->spPr.xfrm->extY.IsInit())
-			{
-				pOutput->m_nRelRight	= (int)pOutput->m_nRelLeft + ooxShape->spPr.xfrm->offX.get();
-				pOutput->m_nRelBottom	= (int)pOutput->m_nRelTop + ooxShape->spPr.xfrm->offY.get();
-			}
-			else
-			{
-				pOutput->m_nRelRight	= 0;
-				pOutput->m_nRelBottom	= 0;
-			}
-			pOutput->m_nRelRotation = pOutput->m_nRotation;
-		}
-	}
 	PPTX::Logic::ShapeStyle* oox_sp_style = ooxShape->style.GetPointer();
 	
 	bool use_fill_from_style = false;
@@ -1132,8 +1143,8 @@ bool OOXShapeReader::Parse( ReaderParameter oParam, RtfShapePtr& pOutput)
 		case PPTX::Logic::UniFill::gradFill:
 		case PPTX::Logic::UniFill::pattFill:
 		case PPTX::Logic::UniFill::solidFill:
-			Parse(oParam, pOutput, &ooxShape->spPr.Fill);
-
+			Parse(oParam, pOutput, &ooxShape->spPr.Fill); 
+			break;
 		case PPTX::Logic::UniFill::noFill:			
 			pOutput->m_bFilled = false;	break;
 		default:
@@ -1185,7 +1196,56 @@ bool OOXShapeReader::Parse( ReaderParameter oParam, RtfShapePtr& pOutput)
 		}
 	}
 
-	return true;			
+	return true;		
+}
+
+bool OOXShapeReader::ParsePic( ReaderParameter oParam, RtfShapePtr& pOutput)
+{
+	PPTX::Logic::Pic * ooxPic	= dynamic_cast<PPTX::Logic::Pic*>(m_ooxShape);
+
+	if (!ooxPic) return false;
+
+	std::wstring strXml;
+	pOutput->m_nShapeType = SimpleTypes::Vml::sptPictureFrame;
+	
+	Parse(oParam, pOutput, ooxPic->spPr.xfrm.GetPointer());
+
+	PPTX::Logic::ShapeStyle* oox_sp_style = ooxPic->style.GetPointer();
+	
+	pOutput->m_bFilled	= true;	
+	
+	Parse(oParam, pOutput, &ooxPic->blipFill);
+
+	if ((oox_sp_style) && (oox_sp_style->lnRef.idx.IsInit()))
+	{
+		Parse(oParam, pOutput, &oox_sp_style->lnRef, 2);
+	}
+	if (ooxPic->spPr.ln.IsInit())
+	{
+		Parse(oParam, pOutput, ooxPic->spPr.ln.GetPointer());	
+	}
+	return true;		
+}
+bool OOXShapeReader::Parse( ReaderParameter oParam, RtfShapePtr& pOutput)
+{
+	if (!m_vmlElement && !m_arrElement && !m_ooxShape) return false;
+	
+	if (OOX::CHdrFtr *pHdrFtr = dynamic_cast<OOX::CHdrFtr *>(oParam.oReader->m_currentContainer))
+		pOutput->m_nHeader = 1;//shape in header/footer
+	else 
+		pOutput->m_nHeader = 0;
+
+	if (m_vmlElement ||  m_arrElement)	return ParseVml(oParam , pOutput);
+
+	PPTX::Logic::Shape	* ooxShape	= dynamic_cast<PPTX::Logic::Shape*>	(m_ooxShape);
+//	PPTX::Logic::CxnSp	* cxnShape	= dynamic_cast<PPTX::Logic::CxnSp*>	(m_ooxShape);
+	PPTX::Logic::Pic	* ooxPic	= dynamic_cast<PPTX::Logic::Pic*>	(m_ooxShape);
+
+	if (ooxShape)	return ParseShape(oParam, pOutput);
+	if (ooxPic)		return ParsePic(oParam, pOutput);
+	//if (cxnShape)	return ParseConnector(oParam, pOutput);
+
+	return false;
 }
 void OOXShapeReader::Parse(ReaderParameter oParam, RtfShapePtr& pOutput, PPTX::Logic::UniFill *oox_fill, std::wstring *change_sheme_color)
 {
@@ -1401,12 +1461,6 @@ bool OOXShapeReader::ParseVml( ReaderParameter oParam , RtfShapePtr& pOutput)
 	}
 
 //---------------------
-
-	if (OOX::CHdrFtr *pHdrFtr = dynamic_cast<OOX::CHdrFtr *>(oParam.oReader->m_currentContainer))
-	{
-		pOutput->m_nHeader = 1;//shape in header/footer
-	}
-
 	return ParseVmlChild(oParam, pOutput);
 }
 bool OOXShapeGroupReader::Parse( ReaderParameter oParam , RtfShapePtr& pOutput)
@@ -1499,11 +1553,6 @@ bool OOXShapeGroupReader::Parse( ReaderParameter oParam , RtfShapePtr& pOutput)
 	}
 	if (m_ooxGroup)
 	{
-		//if( m_ooxGroup->m_sId.IsInit())
-		//{
-		//	pOutput->m_nID = oParam.oReader->m_oOOXIdGenerator.GetId( m_ooxGroup->m_oId.get());
-		//}
-
 		pOutput->m_nZOrderRelative	= 0;
 		
 		pOutput->m_nWrapType		= 3; //def

ASCOfficeRtfFile/RtfFormatLib/source/Reader/OOXShapeReader.h

@@ -67,6 +67,12 @@ public:
 
 	static bool Parse(ReaderParameter oParam, RtfShapePtr& pOutput, PPTX::Logic::BlipFill *oox_bitmap_fill);
 private:
+
+	bool ParseShape( ReaderParameter oParam , RtfShapePtr& oOutput);
+	bool ParsePic( ReaderParameter oParam , RtfShapePtr& oOutput);
+
+	void Parse(ReaderParameter oParam, RtfShapePtr& pOutput, PPTX::Logic::Xfrm *xfrm);
+	
 	void Parse(ReaderParameter oParam, PPTX::Logic::ColorBase	*oox_color,			unsigned int & nColor, _CP_OPT(double) &opacity);
 	void Parse(ReaderParameter oParam, PPTX::Logic::SolidFill	*oox_solid_fill,	unsigned int & nColor, _CP_OPT(double) &opacity);
 	

ASCOfficeRtfFile/RtfFormatLib/source/RtfProperty.cpp

@@ -779,7 +779,7 @@ std::wstring RtfCharProperty::RenderToOOX(RenderParameter oRenderParameter)
 		if( true == poRtfDocument->m_oStyleTable.GetStyle( m_nCharStyle, oStyle ) )
 		{
 			sResult += L"<w:pStyle w:val=\"";
-			sResult += oStyle->m_sName;
+			sResult += L"Style_" + std::to_wstring(m_nCharStyle); //oStyle->m_sName;
 			sResult += L"\"/>";
 		}
 	}
@@ -1179,28 +1179,32 @@ std::wstring RtfStyle::RenderToOOXBegin(RenderParameter oRenderParameter)
 		case stSection :	sType = L"numbering";	break;
 		case stTable :		sType = L"table";		break;
 	}
-    sResult += L"<w:style w:type=\"" + sType + L"\" w:styleId=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\">";
-    sResult += L"<w:name w:val=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\"/>";
+    //sResult += L"<w:style w:type=\"" + sType + L"\" w:styleId=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\">";
+	sResult += L"<w:style w:type=\"" + sType + L"\" w:styleId=\"" + L"Style_" + std::to_wstring(m_nID) + L"\">";
+	sResult += L"<w:name w:val=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\"/>";
 
 	if( PROP_DEF != m_nBasedOn )
 	{
 		RtfStylePtr oBaseStyle;
 		if( true == poDocument->m_oStyleTable.GetStyle( m_nBasedOn, oBaseStyle ) )
-            sResult += L"<w:basedOn w:val=\"" + XmlUtils::EncodeXmlString( oBaseStyle->m_sName ) + L"\"/>";
+		{
+			sResult += L"<w:basedOn w:val=\"Style_" + std::to_wstring(m_nBasedOn) + L"\"/>";
+            //sResult += L"<w:basedOn w:val=\"" + XmlUtils::EncodeXmlString( oBaseStyle->m_sName ) + L"\"/>";
+		}
 	}
 	//if( PROP_DEF != m_nNext )
     //	sResult += L"<w:next w:val=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\"/>", );//Todo
 	//if( PROP_DEF != m_nLink )
     //	sResult += L"<w:link w:val=\"" + XmlUtils::EncodeXmlString( m_sName ) + L"\"/>", );//Todo
-	if( PROP_DEF != m_bHidden )				sResult += L"<w:hidden/>";
-	if( PROP_DEF != m_bLocked )				sResult += L"<w:locked/>";
-	if( PROP_DEF != m_bPersonal )			sResult += L"<w:personal w:val=\"true\" />";
-	if( PROP_DEF != m_bCompose )			sResult += L"<w:personalCompose w:val=\"true\" />";
-	if( PROP_DEF != m_bReply )				sResult += L"<w:personalReply w:val=\"true\" />";
-	if( 1		==	m_nSemiHidden )			sResult += L"<w:semiHidden/>";
-	if( PROP_DEF != m_bQFormat )			sResult += L"<w:qformat/>";
-    if( PROP_DEF != m_nPriority )			sResult += L"<w:uiPriority w:val=\"" + std::to_wstring(m_nPriority) + L"\"/>";
-	if( PROP_DEF != m_bUnhiddenWhenUse )	sResult += L"<w:unhideWhenUsed/>";
+	if( 1 == m_bHidden )			sResult += L"<w:hidden/>";
+	if( 1 == m_bLocked )			sResult += L"<w:locked/>";
+	if( 1 == m_bPersonal )			sResult += L"<w:personal w:val=\"true\" />";
+	if( 1 == m_bCompose )			sResult += L"<w:personalCompose w:val=\"true\" />";
+	if( 1 == m_bReply )				sResult += L"<w:personalReply w:val=\"true\" />";
+	if( 1 == m_nSemiHidden )		sResult += L"<w:semiHidden/>";
+	if( 1 == m_bQFormat )			sResult += L"<w:qFormat/>";
+	if( 1 == m_bUnhiddenWhenUse )	sResult += L"<w:unhideWhenUsed/>";
+    if( PROP_DEF != m_nPriority )	sResult += L"<w:uiPriority w:val=\"" + std::to_wstring(m_nPriority) + L"\"/>";
 
 	return sResult;
 }
@@ -1965,7 +1969,7 @@ std::wstring RtfParagraphProperty::RenderToOOX(RenderParameter oRenderParameter)
 		if( true == poRtfDocument->m_oStyleTable.GetStyle( m_nStyle, oCurStile ) )
 		{
 			sResult += L"<w:pStyle w:val=\"";
-			sResult += oCurStile->m_sName;
+			sResult += L"Style_" + std::to_wstring(m_nStyle);//oCurStile->m_sName;
 			sResult += L"\"/>" ;
 		}
 	}
@@ -2558,7 +2562,7 @@ std::wstring RtfTableProperty::RenderToOOX(RenderParameter oRenderParameter)
 		if( true == poDocument->m_oStyleTable.GetStyle( m_nStyle, oCurStyle) )
 		{
 			sResult += L"<w:tblStyle w:val=\"";
-			sResult += oCurStyle->m_sName;
+			sResult += L"Style_" + std::to_wstring(m_nStyle); //oCurStyle->m_sName;
 			sResult += L"\"/>";
 		}
 	}

ASCOfficeRtfFile/RtfFormatLib/source/RtfShape.cpp

@@ -256,8 +256,6 @@ std::wstring RtfShape::RenderToRtf(RenderParameter oRenderParameter)
 			sResult += L"{\\shp";
 			sResult += L"{\\*\\shpinst";
 			
-			RENDER_RTF_INT( m_nID , sResult, L"shplid" );
-			
 			if (!m_bInGroup)
 			{
 				m_bAllowOverlap		= 1;
@@ -265,8 +263,8 @@ std::wstring RtfShape::RenderToRtf(RenderParameter oRenderParameter)
 				m_nWrapType			= 3;
 				m_nWrapSideType		= 0;
 				m_bLockAnchor		= 0;
-				m_nZOrder			= PROP_DEF;
-				m_nZOrderRelative	= PROP_DEF;
+				//m_nZOrder			= PROP_DEF;
+				m_nZOrderRelative	= 0;
 				m_nLeft				= m_nTop		= 0;
 				m_nRelBottom		= m_nRelRight	= PROP_DEF;
 				m_nPositionV		= m_nPositionH	= PROP_DEF;
@@ -278,26 +276,28 @@ std::wstring RtfShape::RenderToRtf(RenderParameter oRenderParameter)
 				
 				RENDER_RTF_INT	( m_nHeader			, sResult, L"shpfhdr" );
 				
-				//sResult += L"\\shpbxcolumn";
+				sResult += L"\\shpbxcolumn";
 				sResult += L"\\shpbxignore";
-				//sResult += L"\\shpbypara";
+				sResult += L"\\shpbypara";
 				sResult += L"\\shpbyignore";
 				
 				RENDER_RTF_INT	( m_nWrapType		, sResult, L"shpwr" );
 				RENDER_RTF_INT	( m_nWrapSideType	, sResult, L"shpwrk" );
 				
-				//sResult += L"\\shpfblwtxt0";
+				RENDER_RTF_INT( m_nZOrderRelative, sResult, L"shpfblwtxt");
+				RENDER_RTF_INT	( m_nZOrder, sResult, L"shpz" );
 				sResult += L"\\shplockanchor";
-				
-				RENDER_RTF_INT	( m_nZOrder			, sResult, L"shpz" );
+
+				RENDER_RTF_INT( m_nID, sResult, L"shplid" );
 				
 				sResult += L"{\\sp{\\sn fUseShapeAnchor}{\\sv 0}}";
 				sResult += L"{\\sp{\\sn fPseudoInline}{\\sv 1}}";
+				
 			}
 			sResult +=  RenderToRtfShapeProperty( oRenderParameter );
 
-			sResult += L"{\\sp{\\sn fLockPosition}{\\sv 1}}";
-			sResult += L"{\\sp{\\sn fLockRotation}{\\sv 1}}";		
+			//sResult += L"{\\sp{\\sn fLockPosition}{\\sv 1}}";
+			//sResult += L"{\\sp{\\sn fLockRotation}{\\sv 1}}";		
 		
 			//picture
 			if( 0 != m_oPicture && m_nFillType == 1 || m_nFillType == 2 || m_nFillType == 3 || m_nFillType == 9)
@@ -421,11 +421,11 @@ std::wstring RtfShape::RenderToRtfShapeProperty(RenderParameter oRenderParameter
     std::wstring sResult;
 
 //Position absolute
-    RENDER_RTF_SHAPE_PROP(L"posh",		sResult,   	m_nPositionH);
-    RENDER_RTF_SHAPE_PROP(L"posrelh",	sResult,   	m_nPositionHRelative);
-    RENDER_RTF_SHAPE_PROP(L"posv",		sResult,   	m_nPositionV);
+	RENDER_RTF_SHAPE_PROP(L"posh",		sResult,   	m_nPositionH);
+	RENDER_RTF_SHAPE_PROP(L"posrelh",	sResult,   	m_nPositionHRelative);
+	RENDER_RTF_SHAPE_PROP(L"posv",		sResult,   	m_nPositionV);
+	RENDER_RTF_SHAPE_PROP(L"posrelv",	sResult,	m_nPositionVRelative);
 
-    RENDER_RTF_SHAPE_PROP(L"posrelv",		sResult,	m_nPositionVRelative);
     RENDER_RTF_SHAPE_PROP(L"fLayoutInCell",	sResult,	m_bLayoutInCell);
     RENDER_RTF_SHAPE_PROP(L"fAllowOverlap",	sResult,	m_bAllowOverlap);
 
@@ -438,6 +438,17 @@ std::wstring RtfShape::RenderToRtfShapeProperty(RenderParameter oRenderParameter
     RENDER_RTF_SHAPE_PROP(L"sizerelv",		sResult,	m_nPctHeightRelative);
     RENDER_RTF_SHAPE_PROP(L"colStart",		sResult,	m_nColStart);
     RENDER_RTF_SHAPE_PROP(L"colSpan",		sResult,	m_nColSpan);
+
+	if (m_sName.empty() == false)
+	{
+		sResult += L"{\\sp{\\sn wzName}{\\sv ";
+		sResult += m_sName + L"}}";	
+	}
+	if (m_sDescription.empty() == false)
+	{
+		sResult += L"{\\sp{\\sn wzDescription}{\\sv ";
+		sResult += m_sDescription + L"}}";
+	}
 //Rehydration
     //RENDER_RTF_SHAPE_PROP(L"metroBlob",    sResult,   m_sMetroBlob);
 
@@ -449,7 +460,7 @@ std::wstring RtfShape::RenderToRtfShapeProperty(RenderParameter oRenderParameter
     RENDER_RTF_SHAPE_PROP(L"shapeType",		sResult,	m_nShapeType);
     RENDER_RTF_SHAPE_PROP(L"fBehindDocument",sResult,	m_nZOrderRelative);
     RENDER_RTF_SHAPE_PROP(L"fHidden",		sResult,   	m_bHidden);
-	RENDER_RTF_SHAPE_PROP(L"fBackground",	sResult,   	m_bBackground);
+	//RENDER_RTF_SHAPE_PROP(L"fBackground",	sResult,   	m_bBackground);
     //Text
 	//sResult += L"{\\sp{\\sn fLockText}{\\sv 0}}";
 
@@ -586,7 +597,7 @@ std::wstring RtfShape::RenderToRtfShapeProperty(RenderParameter oRenderParameter
 		
 		int nCodePage = -1;
 		
-        if( !m_sGtextFont.empty() )
+        if( m_sGtextFont.empty() == false)
 		{
 			sResult += L"{\\sp{\\sn gtextFont}{\\sv ";
 			sResult += m_sGtextFont + L"}}";
@@ -1487,8 +1498,8 @@ std::wstring RtfShape::GroupRenderToRtf(RenderParameter oRenderParameter)
 			RENDER_RTF_INT( m_nWrapSideType	, sResult, L"shpwrk" );
 			RENDER_RTF_BOOL( m_bLockAnchor	, sResult, L"shplockanchor" );
 						
-			//sResult += L"{\\sp{\\sn fUseShapeAnchor}{\\sv 0}}";
-			//sResult += L"{\\sp{\\sn fPseudoInline}{\\sv 1}}";
+			sResult += L"{\\sp{\\sn fUseShapeAnchor}{\\sv 0}}";
+			sResult += L"{\\sp{\\sn fPseudoInline}{\\sv 1}}";
 		}
 
 		

ASCOfficeRtfFile/RtfFormatTest/RtfFormatTest.vcproj

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="windows-1251"?>
 <VisualStudioProject
 	ProjectType="Visual C++"
-	Version="8.00"
+	Version="8,00"
 	Name="RtfFormatTest"
 	ProjectGUID="{0F49D5D1-A8D3-4F97-8BC1-E2F65BB00C10}"
 	RootNamespace="RtfFormatTest"
@@ -44,7 +44,7 @@
 			<Tool
 				Name="VCCLCompilerTool"
 				Optimization="0"
-				AdditionalIncludeDirectories="..\..\Common\OfficeDrawing;&quot;..\..\DesktopEditor\freetype-2.5.2\include&quot;;..\..\..\..\..\Common\OfficeDrawing\Shapes"
+				AdditionalIncludeDirectories="../../DesktopEditor/xml/libxml2/include;../../DesktopEditor/xml/build/vs2005"
 				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE;_USE_LIBXML2_READER_;LIBXML_READER_ENABLED;USE_LITE_READER;_USE_XMLLITE_READER_;PPTX_DEF;PPT_DEF;ENABLE_PPT_TO_PPTX_CONVERT;AVS_USE_CONVERT_PPTX_TOCUSTOM_VML;DONT_WRITE_EMBEDDED_FONTS"
 				MinimalRebuild="false"
 				BasicRuntimeChecks="3"

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/SXAddl.cpp

@@ -65,60 +65,370 @@ BaseObjectPtr SXAddl::clone()
 
 void SXAddl::readFields(CFRecord& record)
 {
-	m_SXAddlHdr.load(record);
+	record >> frtHeaderOld >> sxc >> sxd;
+	switch(sxc)
+	{
+		case 0x00:	content	= createSxcView		(record);	break;
+		case 0x01:	content	= createSxcField	(record);	break;
+		case 0x02:	content = createSxcHierarchy(record);	break;
+		case 0x03:	content = createSxcCache	(record);	break;
+		case 0x04:	content = createSxcCacheField(record);	break;
+		case 0x05:	content = createSxcQsi		(record);	break;
+		case 0x06:	content = createSxcQuery	(record);	break;
+		case 0x07:	content = createSxcGrpLevel	(record);	break;
+		case 0x08:	content = createSxcGroup	(record);	break;
+		case 0x09:	content = createSxcCacheItem(record);	break;
+		case 0x0C:	content = createSxcSXRule	(record);	break;
+		case 0x0D:	content = createSxcSXFilt	(record);	break;
+		case 0x10:	content = createSxcSXDH		(record);	break;
+		case 0x12:	content = createSxcAutoSort	(record);	break;
+		case 0x13:	content = createSxcSXMgs	(record);	break;
+		case 0x14:	content = createSxcSXMg		(record);	break;
+		case 0x17:	content = createSxcField12	(record);	break;
+		case 0x1A:	content = createSxcSXCondFmts(record);	break;
+		case 0x1B:	content = createSxcSXCondFmt(record);	break;
+		case 0x1C:	content = createSxcSXFilters12(record);	break;
+		case 0x1D:	content = createSxcSXFilter12(record);	break;
+	}
+	if (content)
+		content->load(record);
 
-	Log::error("SXAddl record is not implemented.");
-	record.skipNunBytes(record.getDataSize() - record.getRdPtr());
 }
-//-------------------------------------------------------------------------------------------------------
-BaseObjectPtr SXAddl_SXCCache_SXDId::clone()
+BiffStructurePtr SXAddl::createSxcView(CFRecord& record)
 {
-	return BaseObjectPtr(new SXAddl_SXCCache_SXDId(*this));
-}
-void SXAddl_SXCCache_SXDId::readFields(CFRecord& record)
-{
-	m_SXAddlHdr.load(record);
+	BiffStructurePtr result;
 	
-	short reserved;
-	record >> idCache >> reserved;
+	switch(sxd)
+	{
+		case 0x00: result = BiffStructurePtr(new SXAddl_SXCView_SXDId());				break;
+		case 0x1E: result = BiffStructurePtr(new SXAddl_SXCView_SXDTableStyleClient()); break;
+		case 0xff: result = BiffStructurePtr(new SXAddl_SXCView_SXDEnd());				break;
+	}
+	return result;
+}
+
+BiffStructurePtr SXAddl::createSxcField(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0x00: result = BiffStructurePtr(new SXAddl_SXCField_SXDId());			break;
+		case 0x02: result = BiffStructurePtr(new SXAddl_SXCField_SXDVer10Info());	break;
+		case 0xff: result = BiffStructurePtr(new SXAddl_SXCField_SXDEnd());			break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcHierarchy(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+
+	if (result)
+		result->load(record);
+
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcCache	(CFRecord& record)
+{
+	BiffStructurePtr result;
+	switch(sxd)
+	{
+		case 0x00: result = BiffStructurePtr(new SXAddl_SXCCache_SXDId());				break;
+		case 0x01: result = BiffStructurePtr(new SXAddl_SXCCache_SXDVerUpdInv());		break;
+		case 0x02: result = BiffStructurePtr(new SXAddl_SXCCache_SXDVer10Info());		break;
+		case 0x18: result = BiffStructurePtr(new SXAddl_SXCCache_SXDVerSXMacro());		break;
+		case 0x34: result = BiffStructurePtr(new SXAddl_SXCCache_SXDInvRefreshReal());	break;
+		case 0x41: result = BiffStructurePtr(new SXAddl_SXCCache_SXDInfo12());			break;
+		case 0xff: result = BiffStructurePtr(new SXAddl_SXCCache_SXDEnd());				break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcCacheField(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0x00: result = BiffStructurePtr(new SXAddl_SXCCacheField_SXDId());				break;
+		case 0x05: result = BiffStructurePtr(new SXAddl_SXCCacheField_SXDProperty());		break;
+		case 0x2d: result = BiffStructurePtr(new SXAddl_SXCCacheField_SXDSxrmitmCount());	break;
+		case 0x2f: result = BiffStructurePtr(new SXAddl_SXCCacheField_SXDCaption());		break;
+		case 0x30: result = BiffStructurePtr(new SXAddl_SXCCacheField_SXDIfdbMempropMap());	break;
+		case 0x31: result = BiffStructurePtr(new SXAddl_SXCCacheField_SXDIfdbMpMapCount());	break;
+		case 0x40: result = BiffStructurePtr(new SXAddl_SXCCacheField_SXDPropName());		break;
+		case 0xff: result = BiffStructurePtr(new SXAddl_SXCCacheField_SXDEnd());			break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcQsi(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}	
+BiffStructurePtr SXAddl::createSxcQuery(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcGrpLevel(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcGroup(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcCacheItem(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcSXRule(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcSXFilt(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcSXDH(CFRecord& record)
+{
+	BiffStructurePtr result;
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcAutoSort(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcSXMgs(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcSXMg(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcField12(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcSXCondFmts(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcSXCondFmt(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcSXFilters12(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
+}
+BiffStructurePtr SXAddl::createSxcSXFilter12(CFRecord& record)
+{
+	BiffStructurePtr result;	
+	switch(sxd)
+	{
+		case 0xff: break;
+	}
+	return result;
 }
 //----------------------------------------------------------------------------
-BaseObjectPtr SXAddl_SXCCache_SXDEnd::clone()
+BiffStructurePtr SXAddl_SXCField_SXDId::clone()
 {
-	return BaseObjectPtr(new SXAddl_SXCCache_SXDEnd(*this));
+	return BiffStructurePtr(new SXAddl_SXCField_SXDId(*this));
 }
-void SXAddl_SXCCache_SXDEnd::readFields(CFRecord& record)
-{
-	m_SXAddlHdr.load(record);
 
+void SXAddl_SXCField_SXDId::load(CFRecord& record)
+{
+	record >> stName;
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCView_SXDId::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCView_SXDId(*this));
+}
+
+void SXAddl_SXCView_SXDId::load(CFRecord& record)
+{
+	record >> stName;
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCField_SXDEnd::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCField_SXDEnd(*this));
+}
+
+void SXAddl_SXCField_SXDEnd::load(CFRecord& record)
+{
 	_UINT32	reserved1;
 	short	reserved2;	
 	record >> reserved1 >> reserved2;
 }
 //----------------------------------------------------------------------------
-BaseObjectPtr Continue_SxaddlSxString::clone()
+BiffStructurePtr SXAddl_SXCView_SXDEnd::clone()
 {
-	return BaseObjectPtr(new Continue_SxaddlSxString(*this));
+	return BiffStructurePtr(new SXAddl_SXCView_SXDEnd(*this));
 }
 
-void Continue_SxaddlSxString::readFields(CFRecord& record)
+void SXAddl_SXCView_SXDEnd::load(CFRecord& record)
+{
+	_UINT32	reserved1;
+	short	reserved2;	
+	record >> reserved1 >> reserved2;
+}
+//-------------------------------------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCCacheItem_SXDId::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCacheItem_SXDId(*this));
+}
+
+void SXAddl_SXCCacheItem_SXDId::load(CFRecord& record)
+{
+	short reserved;
+	record >> dwItem >> reserved;
+}
+//-------------------------------------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCCacheField_SXDId::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCacheField_SXDId(*this));
+}
+
+void SXAddl_SXCCacheField_SXDId::load(CFRecord& record)
+{
+	record >> stSourceName;
+}
+//-------------------------------------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCCache_SXDId::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCache_SXDId(*this));
+}
+
+void SXAddl_SXCCache_SXDId::load(CFRecord& record)
+{
+	short reserved;
+	record >> idCache >> reserved;
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCCache_SXDEnd::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCache_SXDEnd(*this));
+}
+
+void SXAddl_SXCCache_SXDEnd::load(CFRecord& record)
+{
+	_UINT32	reserved1;
+	short	reserved2;	
+	record >> reserved1 >> reserved2;
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCField_SXDVer10Info::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCField_SXDVer10Info(*this));
+}
+
+void SXAddl_SXCField_SXDVer10Info::load(CFRecord& record)
+{
+	_UINT32	flags;
+	short	reserved2;	
+	record >> flags >> reserved2;
+
+	fHideDD = GETBIT(flags, 0);
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr Continue_SxaddlSxString::clone()
+{
+	return BiffStructurePtr(new Continue_SxaddlSxString(*this));
+}
+
+void Continue_SxaddlSxString::load(CFRecord& record)
 {
-	m_SXAddlHdr.load(record);
-	
 	int sz = record.getDataSize() - record.getRdPtr();
 
 	if (sz > 0)
 		record >> stContinue;
 }
 //----------------------------------------------------------------------------
-BaseObjectPtr SXAddl_SXCCache_SXDVer10Info::clone()
+BiffStructurePtr SXAddl_SXCCache_SXDVer10Info::clone()
 {
-	return BaseObjectPtr(new SXAddl_SXCCache_SXDVer10Info(*this));
+	return BiffStructurePtr(new SXAddl_SXCCache_SXDVer10Info(*this));
 }
-void SXAddl_SXCCache_SXDVer10Info::readFields(CFRecord& record)
-{
-	m_SXAddlHdr.load(record);
 
+void SXAddl_SXCCache_SXDVer10Info::load(CFRecord& record)
+{
 	_UINT32	reserved1;
 	short	reserved2;	
 	record >> reserved1 >> reserved2;
@@ -131,28 +441,28 @@ void SXAddl_SXCCache_SXDVer10Info::readFields(CFRecord& record)
 	record >> reserved2;
 }
 //----------------------------------------------------------------------------
-BaseObjectPtr SXAddl_SXCCache_SXDVerUpdInv::clone()
-{
-	return BaseObjectPtr(new SXAddl_SXCCache_SXDVerUpdInv(*this));
-}
-void SXAddl_SXCCache_SXDVerUpdInv::readFields(CFRecord& record)
-{
-	m_SXAddlHdr.load(record);
 
+BiffStructurePtr SXAddl_SXCCache_SXDVerUpdInv::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCache_SXDVerUpdInv(*this));
+}
+
+void SXAddl_SXCCache_SXDVerUpdInv::load(CFRecord& record)
+{
 	record >> dwVersionInvalidates;
 
 	record.skipNunBytes(5);
 	
 }
 //----------------------------------------------------------------------------
-BaseObjectPtr SXAddl_SXCCache_SXDInfo12::clone()
-{
-	return BaseObjectPtr(new SXAddl_SXCCache_SXDInfo12(*this));
-}
-void SXAddl_SXCCache_SXDInfo12::readFields(CFRecord& record)
-{
-	m_SXAddlHdr.load(record);
 
+BiffStructurePtr SXAddl_SXCCache_SXDInfo12::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCache_SXDInfo12(*this));
+}
+
+void SXAddl_SXCCache_SXDInfo12::load(CFRecord& record)
+{
 	_UINT32	flags;
 	short	reserved;	
 	
@@ -163,39 +473,27 @@ void SXAddl_SXCCache_SXDInfo12::readFields(CFRecord& record)
 	fSrvSupportSubQuery		= GETBIT(flags, 2);
 }
 //----------------------------------------------------------------------------
-BaseObjectPtr SXAddl_SXCCache_SXDVerSXMacro::clone()
-{
-	return BaseObjectPtr(new SXAddl_SXCCache_SXDVerSXMacro(*this));
-}
-void SXAddl_SXCCache_SXDVerSXMacro::readFields(CFRecord& record)
-{
-	m_SXAddlHdr.load(record);
 
+BiffStructurePtr SXAddl_SXCCache_SXDVerSXMacro::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCache_SXDVerSXMacro(*this));
+}
+
+void SXAddl_SXCCache_SXDVerSXMacro::load(CFRecord& record)
+{
 	unsigned char	reserved1;
 	short			reserved2, reserved3;	
 	
 	record >> dwVer >> reserved1 >> reserved2 >> reserved3;
 }
 //----------------------------------------------------------------------------
-BaseObjectPtr SXAddl_SXCView_SXDId::clone()
+BiffStructurePtr SXAddl_SXCCacheField_SXDIfdbMempropMap::clone()
 {
-	return BaseObjectPtr(new SXAddl_SXCView_SXDId(*this));
+	return BiffStructurePtr(new SXAddl_SXCCacheField_SXDIfdbMempropMap(*this));
 }
-void SXAddl_SXCView_SXDId::readFields(CFRecord& record)
+
+void SXAddl_SXCCacheField_SXDIfdbMempropMap::load(CFRecord& record)
 {
-	m_SXAddlHdr.load(record);
-	
-	record >> stName;
-}
-//----------------------------------------------------------------------------
-BaseObjectPtr SXAddl_SXCCacheField_SXDIfdbMempropMap::clone()
-{
-	return BaseObjectPtr(new SXAddl_SXCCacheField_SXDIfdbMempropMap(*this));
-}
-void SXAddl_SXCCacheField_SXDIfdbMempropMap::readFields(CFRecord& record)
-{
-	m_SXAddlHdr.load(record);
-	
 	record.skipNunBytes(6);
 	
 	int sz = record.getDataSize() - record.getRdPtr();
@@ -208,6 +506,106 @@ void SXAddl_SXCCacheField_SXDIfdbMempropMap::readFields(CFRecord& record)
 		rgMap.push_back(val);
 	}
 }
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCView_SXDTableStyleClient::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCView_SXDTableStyleClient(*this));
+}
 
+void SXAddl_SXCView_SXDTableStyleClient::load(CFRecord& record)
+{
+	record.skipNunBytes(6);
+	
+	unsigned short	flags;
+	
+	record >> flags >> stName;
+
+	fLastColumn		= GETBIT(flags, 1);
+	fRowStrips		= GETBIT(flags, 2);
+	fColumnStrips	= GETBIT(flags, 3);
+	fRowHeaders		= GETBIT(flags, 4);
+	fColumnHeaders	= GETBIT(flags, 5);
+	fDefaultStyle	= GETBIT(flags, 6);
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCCacheField_SXDSxrmitmCount::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCacheField_SXDSxrmitmCount(*this));
+}
+
+void SXAddl_SXCCacheField_SXDSxrmitmCount::load(CFRecord& record)
+{
+	short	reserved2;	
+	record >> citm >> reserved2;
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCCacheField_SXDPropName::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCacheField_SXDPropName(*this));
+}
+
+void SXAddl_SXCCacheField_SXDPropName::load(CFRecord& record)
+{
+	record >> stPropName;
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCCacheField_SXDProperty::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCacheField_SXDProperty(*this));
+}
+
+void SXAddl_SXCCacheField_SXDProperty::load(CFRecord& record)
+{
+	short	reserved2;	
+	record >> ihdb >> reserved2;
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCCacheField_SXDIfdbMpMapCount::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCacheField_SXDIfdbMpMapCount(*this));
+}
+
+void SXAddl_SXCCacheField_SXDIfdbMpMapCount::load(CFRecord& record)
+{
+	short	reserved2;	
+	record >> ifdbMemProp >> reserved2;
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCCacheField_SXDEnd::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCacheField_SXDEnd(*this));
+}
+
+void SXAddl_SXCCacheField_SXDEnd::load(CFRecord& record)
+{
+	_UINT32	reserved1;
+	short	reserved2;	
+	record >> reserved1 >> reserved2;
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCCacheField_SXDCaption::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCacheField_SXDCaption(*this));
+}
+
+void SXAddl_SXCCacheField_SXDCaption::load(CFRecord& record)
+{
+	record >> stCaption;
+}
+//----------------------------------------------------------------------------
+BiffStructurePtr SXAddl_SXCCache_SXDInvRefreshReal::clone()
+{
+	return BiffStructurePtr(new SXAddl_SXCCache_SXDInvRefreshReal(*this));
+}
+
+void SXAddl_SXCCache_SXDInvRefreshReal::load(CFRecord& record)
+{
+	_UINT32	flags;
+	short	reserved2;	
+	record >> flags >> reserved2;
+	
+	fEnableRefresh	= GETBIT(flags, 0);
+	fInvalid		= GETBIT(flags, 1);
+}
 } // namespace XLS
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/SXAddl.h

@@ -60,18 +60,6 @@ class SXAddl: public BiffRecord
 	BIFF_RECORD_DEFINE_TYPE_INFO(SXAddl)
 	BASE_OBJECT_DEFINE_CLASS_NAME(SXAddl)
 public:
-	struct _SXAddlHdr
-	{
-		_UINT32 frtHeaderOld;
-		unsigned char	sxc;
-		unsigned char	sxd;
-
-		void load(CFRecord& record)
-		{
-			record >> frtHeaderOld >> sxc >> sxd;
-		}
-	}m_SXAddlHdr;
-
 	SXAddl();
 	~SXAddl();
 	
@@ -79,57 +67,249 @@ public:
 	virtual void readFields(CFRecord& record);
 
 	static const ElementType	type = typeSXAddl;
-};
 
-class Continue_SxaddlSxString : public SXAddl 
-{
+	_UINT32				frtHeaderOld;
+	unsigned char		sxc;
+	unsigned char		sxd;
+	BiffStructurePtr	content;
+private:
+	BiffStructurePtr createSxcView		(CFRecord& record);
+	BiffStructurePtr createSxcField		(CFRecord& record);
+	BiffStructurePtr createSxcHierarchy	(CFRecord& record);
+	BiffStructurePtr createSxcCache		(CFRecord& record);
+	BiffStructurePtr createSxcCacheField(CFRecord& record);
+	BiffStructurePtr createSxcQsi		(CFRecord& record);	
+	BiffStructurePtr createSxcQuery		(CFRecord& record);
+	BiffStructurePtr createSxcGrpLevel	(CFRecord& record);
+	BiffStructurePtr createSxcGroup		(CFRecord& record);
+	BiffStructurePtr createSxcCacheItem	(CFRecord& record);
+	BiffStructurePtr createSxcSXRule	(CFRecord& record);
+	BiffStructurePtr createSxcSXFilt	(CFRecord& record);
+	BiffStructurePtr createSxcSXDH		(CFRecord& record);
+	BiffStructurePtr createSxcAutoSort	(CFRecord& record);
+	BiffStructurePtr createSxcSXMgs		(CFRecord& record);
+	BiffStructurePtr createSxcSXMg		(CFRecord& record);
+	BiffStructurePtr createSxcField12	(CFRecord& record);
+	BiffStructurePtr createSxcSXCondFmts(CFRecord& record);
+	BiffStructurePtr createSxcSXCondFmt	(CFRecord& record);
+	BiffStructurePtr createSxcSXFilters12(CFRecord& record);
+	BiffStructurePtr createSxcSXFilter12(CFRecord& record);
+};
+class Continue_SxaddlSxString : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(Continue_SxaddlSxString)
 public:
-	virtual void readFields(CFRecord& record);
-	virtual BaseObjectPtr clone();
+	BiffStructurePtr clone();
+
+	Continue_SxaddlSxString(){}
+	~Continue_SxaddlSxString(){}
+
+	static const ElementType	type = typeSXAddl;
+
+	virtual void load(CFRecord& record);
 
 	XLUnicodeStringSegmentedSXADDL stContinue;	
 };
-class SXAddl_SXCAutoSort_SXDEnd : public SXAddl {};
-class SXAddl_SXCAutoSort_SXDId : public SXAddl {};
-class SXAddl_SXCCache_SXDEnd : public SXAddl 
-{
+class SXAddl_SXCField_SXDId	: public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCField_SXDId)
 public:
-	virtual void readFields(CFRecord& record);
-	virtual BaseObjectPtr clone();
+	BiffStructurePtr clone();
+
+	SXAddl_SXCField_SXDId(){}
+	~SXAddl_SXCField_SXDId(){}
+
+	static const ElementType	type = typeSXAddl;
+
+	virtual void load(CFRecord& record);
+
+	XLUnicodeStringSegmentedSXADDL stName;	
+};
+class SXAddl_SXCField_SXDEnd : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCField_SXDEnd)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCField_SXDEnd(){}
+	~SXAddl_SXCField_SXDEnd(){}
+
+	static const ElementType	type = typeSXAddl;
+
+	virtual void load(CFRecord& record);
+};
+class SXAddl_SXCField_SXDVer10Info	: public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCField_SXDVer10Info)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCField_SXDVer10Info(){}
+	~SXAddl_SXCField_SXDVer10Info(){}
+
+	static const ElementType	type = typeSXAddl;
+
+	virtual void load(CFRecord& record);
+
+	bool fHideDD;	
 };
 
-class SXAddl_SXCCache_SXDId : public SXAddl
-{
+class SXAddl_SXCView_SXDId	: public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCView_SXDId)
 public:
-	virtual void readFields(CFRecord& record);
-	virtual BaseObjectPtr clone();
+	BiffStructurePtr clone();
+
+	SXAddl_SXCView_SXDId(){}
+	~SXAddl_SXCView_SXDId(){}
+
+	static const ElementType	type = typeSXAddl;
+
+	virtual void load(CFRecord& record);
+
+	XLUnicodeStringSegmentedSXADDL stName;
+};
+class SXAddl_SXCView_SXDEnd	: public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCView_SXDEnd)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCView_SXDEnd(){}
+	~SXAddl_SXCView_SXDEnd(){}
+
+	static const ElementType	type = typeSXAddl;
+
+	virtual void load(CFRecord& record);
+};
+class SXAddl_SXCView_SXDTableStyleClient : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCView_SXDTableStyleClient)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCView_SXDTableStyleClient(){}
+	~SXAddl_SXCView_SXDTableStyleClient(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+
+	bool fLastColumn;
+	bool fRowStrips;
+	bool fColumnStrips;
+	bool fRowHeaders;
+	bool fColumnHeaders;
+	bool fDefaultStyle;
+
+	LPWideString stName;
+};
+class SXAddl_SXCAutoSort_SXDEnd : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCAutoSort_SXDEnd)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCAutoSort_SXDEnd(){}
+	~SXAddl_SXCAutoSort_SXDEnd(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+};
+class SXAddl_SXCAutoSort_SXDId  : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCAutoSort_SXDId)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCAutoSort_SXDId(){}
+	~SXAddl_SXCAutoSort_SXDId(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+
+	bool fAscendSort;
+};
+class SXAddl_SXCCache_SXDEnd  : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCache_SXDEnd)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCache_SXDEnd(){}
+	~SXAddl_SXCCache_SXDEnd(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+	SXAddl_SXCCache_SXDEnd(CFRecord& record);
+};
+
+class SXAddl_SXCCache_SXDId : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCache_SXDId)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCache_SXDId(){}
+	~SXAddl_SXCCache_SXDId(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
 	
 	_UINT32 idCache;
 };
 
-class SXAddl_SXCCache_SXDInfo12 : public SXAddl 
-{
+class SXAddl_SXCCache_SXDInfo12  : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCache_SXDInfo12)
 public:
+	BiffStructurePtr clone();
 
-	virtual void readFields(CFRecord& record);
-	virtual BaseObjectPtr clone();
+	SXAddl_SXCCache_SXDInfo12(){}
+	~SXAddl_SXCCache_SXDInfo12(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
 
 	bool fSheetData;
 	bool fSrvSupportAttribDrill;
 	bool fSrvSupportSubQuery;
-
 };
 
-class SXAddl_SXCCache_SXDInvRefreshReal : public SXAddl
-{
-};
-
-class SXAddl_SXCCache_SXDVer10Info : public SXAddl 
-{
+class SXAddl_SXCCache_SXDInvRefreshReal : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCache_SXDInvRefreshReal)
 public:
-	
-	virtual void readFields(CFRecord& record);
-	virtual BaseObjectPtr clone();
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCache_SXDInvRefreshReal(){}
+	~SXAddl_SXCCache_SXDInvRefreshReal(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+
+	bool fEnableRefresh;
+	bool fInvalid;
+};
+
+class SXAddl_SXCCache_SXDVer10Info : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCache_SXDVer10Info)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCache_SXDVer10Info(){}
+	~SXAddl_SXCCache_SXDVer10Info(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
 
 	_INT32 citmGhostMax;
 	unsigned char bVerCacheLastRefresh;
@@ -138,155 +318,292 @@ public:
 	unsigned char numDateCopy[8];
 };
 
-class SXAddl_SXCCache_SXDVerSXMacro : public SXAddl 
-{
+class SXAddl_SXCCache_SXDVerSXMacro : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCache_SXDVerSXMacro)
 public:
-	virtual void readFields(CFRecord& record);
-	virtual BaseObjectPtr clone();
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCache_SXDVerSXMacro(){}
+	~SXAddl_SXCCache_SXDVerSXMacro(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
 
 	unsigned char dwVer;
 };
 
-class SXAddl_SXCCache_SXDVerUpdInv : public SXAddl 
-{
+class SXAddl_SXCCache_SXDVerUpdInv : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCache_SXDVerUpdInv)
 public:
-	virtual void readFields(CFRecord& record);
-	virtual BaseObjectPtr clone();
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCache_SXDVerUpdInv(){}
+	~SXAddl_SXCCache_SXDVerUpdInv(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
 
 	unsigned char dwVersionInvalidates;
 };
 
-class SXAddl_SXCCacheField_SXDCaption		: public SXAddl {};
-class SXAddl_SXCCacheField_SXDEnd			: public SXAddl {};
-class SXAddl_SXCCacheField_SXDId			: public SXAddl {};
-class SXAddl_SXCCacheField_SXDIfdbMempropMap: public SXAddl
-{
+class SXAddl_SXCCacheField_SXDCaption : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCacheField_SXDCaption)
 public:
-	virtual void readFields(CFRecord& record);
-	virtual BaseObjectPtr clone();
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCacheField_SXDCaption(){}
+	~SXAddl_SXCCacheField_SXDCaption(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+
+	XLUnicodeStringSegmentedSXADDL stCaption;
+};
+class SXAddl_SXCCacheField_SXDEnd : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCacheField_SXDEnd)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCacheField_SXDEnd(){}
+	~SXAddl_SXCCacheField_SXDEnd(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+};
+
+class SXAddl_SXCCacheField_SXDId : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCacheField_SXDId)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCacheField_SXDId(){}
+	~SXAddl_SXCCacheField_SXDId(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+	
+	XLUnicodeStringSegmentedSXADDL stSourceName;
+};
+
+class SXAddl_SXCCacheField_SXDIfdbMempropMap : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCacheField_SXDIfdbMempropMap)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCacheField_SXDIfdbMempropMap(){}
+	~SXAddl_SXCCacheField_SXDIfdbMempropMap(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
 
 	std::vector<unsigned short>	rgMap;
 };
-class SXAddl_SXCCacheField_SXDIfdbMpMapCount: public SXAddl {};
-class SXAddl_SXCCacheField_SXDProperty		: public SXAddl {};
-class SXAddl_SXCCacheField_SXDPropName		: public SXAddl {};
-class SXAddl_SXCCacheField_SXDSxrmitmCount	: public SXAddl {};
-
-class SXAddl_SXCCacheItem_SXDEnd			: public SXAddl {};
-class SXAddl_SXCCacheItem_SXDId				: public SXAddl {};
-class SXAddl_SXCCacheItem_SXDItmMpMapCount	: public SXAddl {};
-class SXAddl_SXCCacheItem_SXDItmMpropMap	: public SXAddl {};
-class SXAddl_SXCCacheItem_SXDSxrmitmDisp	: public SXAddl {};
-
-class SXAddl_SXCField12_SXDAutoshow			: public SXAddl {};
-class SXAddl_SXCField12_SXDEnd				: public SXAddl {};
-class SXAddl_SXCField12_SXDId				: public SXAddl {};
-class SXAddl_SXCField12_SXDISXTH			: public SXAddl {};
-class SXAddl_SXCField12_SXDMemberCaption	: public SXAddl {};
-class SXAddl_SXCField12_SXDVer12Info		: public SXAddl {};
-class SXAddl_SXCField12_SXDVerUpdInv		: public SXAddl {};
-
-class SXAddl_SXCField_SXDEnd				: public SXAddl {};
-class SXAddl_SXCField_SXDId					: public SXAddl {};
-class SXAddl_SXCField_SXDVer10Info			: public SXAddl {};
-
-class SXAddl_SXCGroup_SXDEnd				: public SXAddl {};
-class SXAddl_SXCGroup_SXDGrpInfo			: public SXAddl {};
-class SXAddl_SXCGroup_SXDId					: public SXAddl {};
-class SXAddl_SXCGroup_SXDMember				: public SXAddl {};
-
-class SXAddl_SXCGrpLevel_SXDEnd				: public SXAddl {};
-class SXAddl_SXCGrpLevel_SXDGrpLevelInfo	: public SXAddl {};
-class SXAddl_SXCGrpLevel_SXDId				: public SXAddl {};
-
-class SXAddl_SXCHierarchy_SXDDisplayFolder	: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDEnd			: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDFilterMember	: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDFilterMember12	: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDIconSet		: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDId				: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDInfo12			: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDKPIGoal		: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDKPIStatus		: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDKPITime		: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDKPITrend		: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDKPIValue		: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDKPIWeight		: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDMeasureGrp		: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDParentKPI		: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDProperty		: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDSXSetParentUnique	: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDUserCaption	: public SXAddl {};
-class SXAddl_SXCHierarchy_SXDVerUpdInv		: public SXAddl {};
-
-class SXAddl_SXCQsi_SXDEnd					: public SXAddl {};
-class SXAddl_SXCQsi_SXDId					: public SXAddl {};
-
-class SXAddl_SXCQuery_SXDEnd				: public SXAddl {};
-class SXAddl_SXCQuery_SXDReconnCond			: public SXAddl {};
-class SXAddl_SXCQuery_SXDSrcConnFile		: public SXAddl {};
-class SXAddl_SXCQuery_SXDSrcDataFile		: public SXAddl {};
-class SXAddl_SXCQuery_SXDXMLSource			: public SXAddl {};
-
-class SXAddl_SXCSXCondFmt_SXDEnd			: public SXAddl {};
-class SXAddl_SXCSXCondFmt_SXDSXCondFmt		: public SXAddl {};
-class SXAddl_SXCSXCondFmts_SXDEnd			: public SXAddl {};
-class SXAddl_SXCSXCondFmts_SXDId			: public SXAddl {};
-class SXAddl_SXCSXDH_SXDEnd					: public SXAddl {};
-class SXAddl_SXCSXDH_SXDId					: public SXAddl {};
-class SXAddl_SXCSXDH_SXDSxdh				: public SXAddl {};
-
-class SXAddl_SXCSXfilt_SXDEnd				: public SXAddl {};
-class SXAddl_SXCSXfilt_SXDId				: public SXAddl {};
-class SXAddl_SXCSXfilt_SXDSXfilt			: public SXAddl {};
-class SXAddl_SXCSXfilt_SXDSXItm				: public SXAddl {};
-
-class SXAddl_SXCSXFilter12_SXDCaption		: public SXAddl {};
-class SXAddl_SXCSXFilter12_SXDEnd			: public SXAddl {};
-class SXAddl_SXCSXFilter12_SXDId			: public SXAddl {};
-class SXAddl_SXCSXFilter12_SXDSXFilter		: public SXAddl {};
-class SXAddl_SXCSXFilter12_SXDSXFilterDesc	: public SXAddl {};
-class SXAddl_SXCSXFilter12_SXDSXFilterValue1: public SXAddl {};
-class SXAddl_SXCSXFilter12_SXDSXFilterValue2: public SXAddl {};
-class SXAddl_SXCSXFilter12_SXDXlsFilter		: public SXAddl {};
-class SXAddl_SXCSXFilter12_SXDXlsFilterValue1: public SXAddl {};
-class SXAddl_SXCSXFilter12_SXDXlsFilterValue2: public SXAddl {};
-class SXAddl_SXCSXFilters12_SXDEnd			: public SXAddl {};
-class SXAddl_SXCSXFilters12_SXDId			: public SXAddl {};
-
-class SXAddl_SXCSXMg_SXDEnd					: public SXAddl {};
-class SXAddl_SXCSXMg_SXDId					: public SXAddl {};
-class SXAddl_SXCSXMg_SXDUserCaption			: public SXAddl {};
-
-class SXAddl_SXCSXMgs_SXDEnd				: public SXAddl {};
-class SXAddl_SXCSXMgs_SXDId					: public SXAddl {};
-class SXAddl_SXCSXMgs_SXDMGrpSXDHMap		: public SXAddl {};
-
-class SXAddl_SXCSXrule_SXDEnd				: public SXAddl {};
-class SXAddl_SXCSXrule_SXDId				: public SXAddl {};
-class SXAddl_SXCSXrule_SXDSXrule			: public SXAddl {};
-
-class SXAddl_SXCView_SXDCalcMember			: public SXAddl {};
-class SXAddl_SXCView_SXDCalcMemString		: public SXAddl {};
-class SXAddl_SXCView_SXDCompactColHdr		: public SXAddl {};
-class SXAddl_SXCView_SXDCompactRwHdr		: public SXAddl {};
-class SXAddl_SXCView_SXDEnd					: public SXAddl {};
-
-class SXAddl_SXCView_SXDId : public SXAddl 
-{
+class SXAddl_SXCCacheField_SXDIfdbMpMapCount : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCacheField_SXDIfdbMpMapCount)
 public:
-	
-	virtual void readFields(CFRecord& record);
-	virtual BaseObjectPtr clone();
+	BiffStructurePtr clone();
 
-	XLUnicodeStringSegmentedSXADDL stName;
+	SXAddl_SXCCacheField_SXDIfdbMpMapCount(){}
+	~SXAddl_SXCCacheField_SXDIfdbMpMapCount(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+
+	_UINT32 ifdbMemProp;
+};
+class SXAddl_SXCCacheField_SXDProperty : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCacheField_SXDProperty)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCacheField_SXDProperty(){}
+	~SXAddl_SXCCacheField_SXDProperty(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+
+	_UINT32 ihdb;
+};
+class SXAddl_SXCCacheField_SXDPropName : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCacheField_SXDPropName)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCacheField_SXDPropName(){}
+	~SXAddl_SXCCacheField_SXDPropName(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+
+	XLUnicodeStringSegmentedSXADDL stPropName;
+};
+class SXAddl_SXCCacheField_SXDSxrmitmCount : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCacheField_SXDSxrmitmCount)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCacheField_SXDSxrmitmCount(){}
+	~SXAddl_SXCCacheField_SXDSxrmitmCount(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+
+	_UINT32 citm;
 };
 
-class SXAddl_SXCView_SXDSXPIIvmb			: public SXAddl {};
-class SXAddl_SXCView_SXDTableStyleClient	: public SXAddl {};
-class SXAddl_SXCView_SXDVer10Info			: public SXAddl {};
-class SXAddl_SXCView_SXDVer12Info			: public SXAddl {};
-class SXAddl_SXCView_SXDVerUpdInv			: public SXAddl {};
+class SXAddl_SXCCacheItem_SXDEnd : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCacheItem_SXDEnd)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCacheItem_SXDEnd(){}
+	~SXAddl_SXCCacheItem_SXDEnd(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+
+};
+
+class SXAddl_SXCCacheItem_SXDId : public BiffStructure
+{	
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(SXAddl_SXCCacheItem_SXDId)
+public:
+	BiffStructurePtr clone();
+
+	SXAddl_SXCCacheItem_SXDId(){}
+	~SXAddl_SXCCacheItem_SXDId(){}
+
+	virtual void load(CFRecord& record);
+
+	static const ElementType	type = typeSXAddl;
+	
+	_UINT32 dwItem;
+};
+
+//class SXAddl_SXCCacheItem_SXDItmMpMapCount	: public SXAddl {};
+//class SXAddl_SXCCacheItem_SXDItmMpropMap	: public SXAddl {};
+//class SXAddl_SXCCacheItem_SXDSxrmitmDisp	: public SXAddl {};
+//
+//class SXAddl_SXCField12_SXDAutoshow			: public SXAddl {};
+//class SXAddl_SXCField12_SXDEnd				: public SXAddl {};
+//class SXAddl_SXCField12_SXDId				: public SXAddl {};
+//class SXAddl_SXCField12_SXDISXTH			: public SXAddl {};
+//class SXAddl_SXCField12_SXDMemberCaption	: public SXAddl {};
+//class SXAddl_SXCField12_SXDVer12Info		: public SXAddl {};
+//class SXAddl_SXCField12_SXDVerUpdInv		: public SXAddl {};
+//
+//
+//class SXAddl_SXCGroup_SXDEnd				: public SXAddl {};
+//class SXAddl_SXCGroup_SXDGrpInfo			: public SXAddl {};
+//class SXAddl_SXCGroup_SXDId					: public SXAddl {};
+//class SXAddl_SXCGroup_SXDMember				: public SXAddl {};
+//
+//class SXAddl_SXCGrpLevel_SXDEnd				: public SXAddl {};
+//class SXAddl_SXCGrpLevel_SXDGrpLevelInfo	: public SXAddl {};
+//class SXAddl_SXCGrpLevel_SXDId				: public SXAddl {};
+//
+//class SXAddl_SXCHierarchy_SXDDisplayFolder	: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDEnd			: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDFilterMember	: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDFilterMember12	: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDIconSet		: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDId				: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDInfo12			: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDKPIGoal		: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDKPIStatus		: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDKPITime		: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDKPITrend		: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDKPIValue		: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDKPIWeight		: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDMeasureGrp		: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDParentKPI		: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDProperty		: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDSXSetParentUnique	: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDUserCaption	: public SXAddl {};
+//class SXAddl_SXCHierarchy_SXDVerUpdInv		: public SXAddl {};
+//
+//class SXAddl_SXCQsi_SXDEnd					: public SXAddl {};
+//class SXAddl_SXCQsi_SXDId					: public SXAddl {};
+//
+//class SXAddl_SXCQuery_SXDEnd				: public SXAddl {};
+//class SXAddl_SXCQuery_SXDReconnCond			: public SXAddl {};
+//class SXAddl_SXCQuery_SXDSrcConnFile		: public SXAddl {};
+//class SXAddl_SXCQuery_SXDSrcDataFile		: public SXAddl {};
+//class SXAddl_SXCQuery_SXDXMLSource			: public SXAddl {};
+//
+//class SXAddl_SXCSXCondFmt_SXDEnd			: public SXAddl {};
+//class SXAddl_SXCSXCondFmt_SXDSXCondFmt		: public SXAddl {};
+//class SXAddl_SXCSXCondFmts_SXDEnd			: public SXAddl {};
+//class SXAddl_SXCSXCondFmts_SXDId			: public SXAddl {};
+//class SXAddl_SXCSXDH_SXDEnd					: public SXAddl {};
+//class SXAddl_SXCSXDH_SXDId					: public SXAddl {};
+//class SXAddl_SXCSXDH_SXDSxdh				: public SXAddl {};
+//
+//class SXAddl_SXCSXfilt_SXDEnd				: public SXAddl {};
+//class SXAddl_SXCSXfilt_SXDId				: public SXAddl {};
+//class SXAddl_SXCSXfilt_SXDSXfilt			: public SXAddl {};
+//class SXAddl_SXCSXfilt_SXDSXItm				: public SXAddl {};
+//
+//class SXAddl_SXCSXFilter12_SXDCaption		: public SXAddl {};
+//class SXAddl_SXCSXFilter12_SXDEnd			: public SXAddl {};
+//class SXAddl_SXCSXFilter12_SXDId			: public SXAddl {};
+//class SXAddl_SXCSXFilter12_SXDSXFilter		: public SXAddl {};
+//class SXAddl_SXCSXFilter12_SXDSXFilterDesc	: public SXAddl {};
+//class SXAddl_SXCSXFilter12_SXDSXFilterValue1: public SXAddl {};
+//class SXAddl_SXCSXFilter12_SXDSXFilterValue2: public SXAddl {};
+//class SXAddl_SXCSXFilter12_SXDXlsFilter		: public SXAddl {};
+//class SXAddl_SXCSXFilter12_SXDXlsFilterValue1: public SXAddl {};
+//class SXAddl_SXCSXFilter12_SXDXlsFilterValue2: public SXAddl {};
+//class SXAddl_SXCSXFilters12_SXDEnd			: public SXAddl {};
+//class SXAddl_SXCSXFilters12_SXDId			: public SXAddl {};
+//
+//class SXAddl_SXCSXMg_SXDEnd					: public SXAddl {};
+//class SXAddl_SXCSXMg_SXDId					: public SXAddl {};
+//class SXAddl_SXCSXMg_SXDUserCaption			: public SXAddl {};
+//
+//class SXAddl_SXCSXMgs_SXDEnd				: public SXAddl {};
+//class SXAddl_SXCSXMgs_SXDId					: public SXAddl {};
+//class SXAddl_SXCSXMgs_SXDMGrpSXDHMap		: public SXAddl {};
+//
+//class SXAddl_SXCSXrule_SXDEnd				: public SXAddl {};
+//class SXAddl_SXCSXrule_SXDId				: public SXAddl {};
+//class SXAddl_SXCSXrule_SXDSXrule			: public SXAddl {};
+//
+//class SXAddl_SXCView_SXDCalcMember			: public SXAddl {};
+//class SXAddl_SXCView_SXDCalcMemString		: public SXAddl {};
+//class SXAddl_SXCView_SXDCompactColHdr		: public SXAddl {};
+//class SXAddl_SXCView_SXDCompactRwHdr		: public SXAddl {};
+
+//class SXAddl_SXCView_SXDSXPIIvmb
+//{
+//	SXAddl_SXCView_SXDSXPIIvmb(CFRecord& record);
+//};
+
+//class SXAddl_SXCView_SXDVer10Info			: public SXAddl {};
+//class SXAddl_SXCView_SXDVer12Info			: public SXAddl {};
+//class SXAddl_SXCView_SXDVerUpdInv			: public SXAddl {};
 
 } // namespace XLS
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/PtgSxName.cpp

@@ -77,7 +77,7 @@ void PtgSxName::assemble(AssemblerStack& ptg_stack, PtgQueue& extra_data, bool f
 			SXPair *pair = dynamic_cast<SXPair*>(global_info->arPivotSxNames[sxIndex].pair[0].get());
 			if (pair)
 			{
-				std::map<int, BaseObjectPtr>::iterator pFind = global_info->mapPivotCache.find(global_info->idPivotCache);
+				std::unordered_map<int, BaseObjectPtr>::iterator pFind = global_info->mapPivotCache.find(global_info->idPivotCache);
 				if (pFind != global_info->mapPivotCache.end())
 				{
 					PIVOTCACHE* pivot_cache = dynamic_cast<PIVOTCACHE*>(pFind->second.get());

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/PIVOTADDL.cpp

@@ -69,109 +69,122 @@ PIVOTADDL = SXAddl_SXCView_SXDId *Continue_SxaddlSxString
 			[SXADDLSXFILTERS12] *SXAddl_SXCView_SXDVerUpdInv *SXAddl_SXCView_SXDSXPIIvmb 
 			[SXAddl_SXCView_SXDVerUpdInv] SXAddl_SXCView_SXDEnd
 */
+
 const bool PIVOTADDL::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCView_SXDId>())
-	{
-		return false;
-	}
-	m_SXAddl_SXCView_SXDId = elements_.back();
-	elements_.pop_back(); 
-	
-	int count = proc.repeated<Continue_SxaddlSxString>(0, 0);
-	
-	if (proc.optional<SXAddl_SXCView_SXDVer10Info>())
-	{
-		m_SXAddl_SXCView_SXDVer10Info = elements_.back();
-		elements_.pop_back(); 
-	}
-	if (proc.optional<SXAddl_SXCView_SXDVer12Info>())
-	{
-		m_SXAddl_SXCView_SXDVer12Info = elements_.back();
-		elements_.pop_back(); 
-	}
-	count = proc.repeated<SXADDLCALCMEMBER>(0, 0);
-	while(count > 0)
-	{
-		m_arSXADDLCALCMEMBER.push_back(elements_.front());
-		elements_.pop_front(); count--;
-	}
+	int count = proc.repeated<SXAddl>(0, 0);
 
-	count = proc.repeated<SXADDLHIERARCHY>(0, 0);
-	while(count > 0)
+	for (std::list<BaseObjectPtr>::iterator it = elements_.begin(); it != elements_.end(); it++)
 	{
-		m_arSXADDLHIERARCHY.push_back(elements_.front());
-		elements_.pop_front(); count--;
-	}	
-	count = proc.repeated<SXADDLFIELD>(0, 0);
-	while(count > 0)
-	{
-		m_arSXADDLFIELD.push_back(elements_.front());
-		elements_.pop_front(); count--;
+		SXAddl* addl = dynamic_cast<SXAddl*>(it->get());
+		if (!addl) continue;
+		SXAddl_SXCView_SXDTableStyleClient* p = dynamic_cast<SXAddl_SXCView_SXDTableStyleClient*>(addl->content.get());
+		if (p)
+		{
+			m_SXAddl_SXCView_SXDTableStyleClient = addl->content;
+		}
 	}
+	//if(!proc.mandatory<SXAddl_SXCView_SXDId>())
+	//{
+	//	return false;
+	//}
+	//m_SXAddl_SXCView_SXDId = elements_.back();
+	//elements_.pop_back(); 
+	//
+	//int count = proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//
+	//if (proc.optional<SXAddl_SXCView_SXDVer10Info>())
+	//{
+	//	m_SXAddl_SXCView_SXDVer10Info = elements_.back();
+	//	elements_.pop_back(); 
+	//}
+	//if (proc.optional<SXAddl_SXCView_SXDVer12Info>())
+	//{
+	//	m_SXAddl_SXCView_SXDVer12Info = elements_.back();
+	//	elements_.pop_back(); 
+	//}
+	//count = proc.repeated<SXADDLCALCMEMBER>(0, 0);
+	//while(count > 0)
+	//{
+	//	m_arSXADDLCALCMEMBER.push_back(elements_.front());
+	//	elements_.pop_front(); count--;
+	//}
 
-	count = proc.repeated<UNKNOWNFRT>(0, 0);
-	
-	if (proc.optional<SXAddl_SXCView_SXDTableStyleClient>())
-	{
-		m_SXAddl_SXCView_SXDTableStyleClient = elements_.back();
-		elements_.pop_back(); 
-	}
+	//count = proc.repeated<SXADDLHIERARCHY>(0, 0);
+	//while(count > 0)
+	//{
+	//	m_arSXADDLHIERARCHY.push_back(elements_.front());
+	//	elements_.pop_front(); count--;
+	//}	
+	//count = proc.repeated<SXADDLFIELD>(0, 0);
+	//while(count > 0)
+	//{
+	//	m_arSXADDLFIELD.push_back(elements_.front());
+	//	elements_.pop_front(); count--;
+	//}
 
-	if(proc.optional<SXAddl_SXCView_SXDCompactRwHdr>())
-	{
-		m_SXAddl_SXCView_SXDCompactRwHdr = elements_.back();
-		elements_.pop_back(); 
+	//count = proc.repeated<UNKNOWNFRT>(0, 0);
+	//
+	//if (proc.optional<SXAddl_SXCView_SXDTableStyleClient>())
+	//{
+	//	m_SXAddl_SXCView_SXDTableStyleClient = elements_.back();
+	//	elements_.pop_back(); 
+	//}
 
-		count = proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCView_SXDCompactColHdr>())
-	{
-		m_SXAddl_SXCView_SXDCompactColHdr = elements_.back();
-		elements_.pop_back(); 
+	//if(proc.optional<SXAddl_SXCView_SXDCompactRwHdr>())
+	//{
+	//	m_SXAddl_SXCView_SXDCompactRwHdr = elements_.back();
+	//	elements_.pop_back(); 
 
-		count = proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
+	//	count = proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCView_SXDCompactColHdr>())
+	//{
+	//	m_SXAddl_SXCView_SXDCompactColHdr = elements_.back();
+	//	elements_.pop_back(); 
 
-	if (proc.optional<SXAddl_SXCView_SXDVerUpdInv>())
-	{
-		m_arSXAddl_SXCView_SXDVerUpdInv.push_back(elements_.back());
-		elements_.pop_back(); 
-	}
-	if (proc.optional<SXADDLCONDFMTS>())
-	{
-		m_SXADDLCONDFMTS = elements_.back();
-		elements_.pop_back(); 
-	}
-	if (proc.optional<SXADDLSXFILTERS12>())
-	{
-		m_SXAddl_SXADDLSXFILTERS12 = elements_.back();
-		elements_.pop_back(); 
-	}
-	count = proc.repeated<SXAddl_SXCView_SXDVerUpdInv>(0, 0);
-	while(count > 0)
-	{
-		m_arSXAddl_SXCView_SXDVerUpdInv.push_back(elements_.front());
-		elements_.pop_front(); count--;
-	}
+	//	count = proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
 
-	count = proc.repeated<SXAddl_SXCView_SXDSXPIIvmb>(0, 0);
-	while(count > 0)
-	{
-		m_arSXAddl_SXCView_SXDSXPIIvmb.push_back(elements_.front());
-		elements_.pop_front(); count--;
-	}
+	//if (proc.optional<SXAddl_SXCView_SXDVerUpdInv>())
+	//{
+	//	m_arSXAddl_SXCView_SXDVerUpdInv.push_back(elements_.back());
+	//	elements_.pop_back(); 
+	//}
+	//if (proc.optional<SXADDLCONDFMTS>())
+	//{
+	//	m_SXADDLCONDFMTS = elements_.back();
+	//	elements_.pop_back(); 
+	//}
+	//if (proc.optional<SXADDLSXFILTERS12>())
+	//{
+	//	m_SXAddl_SXADDLSXFILTERS12 = elements_.back();
+	//	elements_.pop_back(); 
+	//}
+	//count = proc.repeated<SXAddl_SXCView_SXDVerUpdInv>(0, 0);
+	//while(count > 0)
+	//{
+	//	m_arSXAddl_SXCView_SXDVerUpdInv.push_back(elements_.front());
+	//	elements_.pop_front(); count--;
+	//}
 
-	if (proc.optional<SXAddl_SXCView_SXDVerUpdInv>())
-	{
-		m_arSXAddl_SXCView_SXDVerUpdInv.push_back(elements_.front());
-		elements_.pop_front();
-	}
+	//count = proc.repeated<SXAddl_SXCView_SXDSXPIIvmb>(0, 0);
+	//while(count > 0)
+	//{
+	//	m_arSXAddl_SXCView_SXDSXPIIvmb.push_back(elements_.front());
+	//	elements_.pop_front(); count--;
+	//}
 
-	if (proc.optional<SXAddl_SXCView_SXDEnd>())
-	{
-		elements_.pop_back(); 
-	}
+	//if (proc.optional<SXAddl_SXCView_SXDVerUpdInv>())
+	//{
+	//	m_arSXAddl_SXCView_SXDVerUpdInv.push_back(elements_.front());
+	//	elements_.pop_front();
+	//}
+
+	//if (proc.optional<SXAddl_SXCView_SXDEnd>())
+	//{
+	//	elements_.pop_back(); 
+	//}
 	return true;
 }
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/PIVOTADDL.h

@@ -49,21 +49,21 @@ public:
 
 	static const ElementType type = typePIVOTADDL;
 
-	BaseObjectPtr	m_SXAddl_SXCView_SXDId;
-	BaseObjectPtr	m_SXAddl_SXCView_SXDVer10Info;
-	BaseObjectPtr	m_SXAddl_SXCView_SXDVer12Info;
+	BiffStructurePtr	m_SXAddl_SXCView_SXDId;
+	BiffStructurePtr	m_SXAddl_SXCView_SXDVer10Info;
+	BiffStructurePtr	m_SXAddl_SXCView_SXDVer12Info;
 
-	BaseObjectPtr	m_SXAddl_SXCView_SXDCompactRwHdr;
-	BaseObjectPtr	m_SXAddl_SXCView_SXDCompactColHdr;
-	BaseObjectPtr	m_SXAddl_SXADDLSXFILTERS12;
-	BaseObjectPtr	m_SXADDLCONDFMTS;
-	BaseObjectPtr	m_SXAddl_SXCView_SXDTableStyleClient;
+	BiffStructurePtr	m_SXAddl_SXCView_SXDCompactRwHdr;
+	BiffStructurePtr	m_SXAddl_SXCView_SXDCompactColHdr;
+	BiffStructurePtr	m_SXAddl_SXADDLSXFILTERS12;
+	BiffStructurePtr	m_SXADDLCONDFMTS;
+	BiffStructurePtr	m_SXAddl_SXCView_SXDTableStyleClient;
 
-	std::vector<BaseObjectPtr>	m_arSXAddl_SXCView_SXDVerUpdInv;
-	std::vector<BaseObjectPtr>	m_arSXAddl_SXCView_SXDSXPIIvmb;
-	std::vector<BaseObjectPtr>	m_arSXADDLFIELD;
-	std::vector<BaseObjectPtr>	m_arSXADDLHIERARCHY;
-	std::vector<BaseObjectPtr>	m_arSXADDLCALCMEMBER;
+	std::vector<BiffStructurePtr>	m_arSXAddl_SXCView_SXDVerUpdInv;
+	std::vector<BiffStructurePtr>	m_arSXAddl_SXCView_SXDSXPIIvmb;
+	std::vector<BiffStructurePtr>	m_arSXADDLFIELD;
+	std::vector<BiffStructurePtr>	m_arSXADDLHIERARCHY;
+	std::vector<BiffStructurePtr>	m_arSXADDLCALCMEMBER;
 
 };
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/PIVOTCACHEDEFINITION.cpp

@@ -98,7 +98,7 @@ int PIVOTCACHEDEFINITION::serialize_definitions(std::wostream & strm)
 	SXStreamID* streamId = dynamic_cast<SXStreamID*>(m_SXStreamID.get());
 	if (!streamId) return 0;
 
-	std::map<int, BaseObjectPtr>::iterator pFind = global_info_->mapPivotCache.find(streamId->idStm);
+	std::unordered_map<int, BaseObjectPtr>::iterator pFind = global_info_->mapPivotCache.find(streamId->idStm);
 	if (pFind == global_info_->mapPivotCache.end()) return 0;
 
 	global_info_->idPivotCache = streamId->idStm;
@@ -124,13 +124,15 @@ int PIVOTCACHEDEFINITION::serialize_definitions(std::wostream & strm)
 			{
 				CP_XML_ATTR(L"r:id", L"rId1" );
 			}
+			else 
+			{
+				CP_XML_ATTR(L"saveData", 0);
+			}
 			CP_XML_ATTR(L"enableRefresh",	1);
 			CP_XML_ATTR(L"refreshedBy",		db->rgb.value());
 			CP_XML_ATTR(L"refreshedDate",	db_ex->numDate.data.value);
 			CP_XML_ATTR(L"recordCount",		db->crdbdb);
-			//createdVersion="1" 
-			//refreshedVersion="2" 
-			//upgradeOnRefresh="1">
+			//upgradeOnRefresh="1"
 			SXSRC* src = dynamic_cast<SXSRC*>(m_SXSRC.get());
 			if (src)
 			{
@@ -167,7 +169,7 @@ int PIVOTCACHEDEFINITION::serialize_definitions(std::wostream & strm)
 			}
 		}
 	}
-	return 0;
+	return global_info_->idPivotCache;
 }
 
 
@@ -176,7 +178,7 @@ int PIVOTCACHEDEFINITION::serialize_records(std::wostream & strm)
 	SXStreamID* streamId = dynamic_cast<SXStreamID*>(m_SXStreamID.get());
 	if (!streamId) return 0;
 
-	std::map<int, BaseObjectPtr>::iterator pFind = global_info_->mapPivotCache.find(streamId->idStm);
+	std::unordered_map<int, BaseObjectPtr>::iterator pFind = global_info_->mapPivotCache.find(streamId->idStm);
 	if (pFind == global_info_->mapPivotCache.end()) return 0;
 
 	PIVOTCACHE* pivot_cache = dynamic_cast<PIVOTCACHE*>(pFind->second.get());

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/PIVOTFRT.cpp

@@ -31,8 +31,8 @@
  */
 
 #include "PIVOTFRT.h"
-#include <Logic/Biff_unions/PIVOTFRT9.h>
-#include <Logic/Biff_unions/PIVOTADDL.h>
+#include "PIVOTFRT9.h"
+#include "PIVOTADDL.h"
 
 namespace XLS
 {

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/PIVOTVD.cpp

@@ -99,7 +99,7 @@ int PIVOTVD::serialize(std::wostream & strm)
 			
 			if (vd_ex->ifmt > 0)	
 			{
-				CP_XML_ATTR(L"numFmtId", vd_ex->ifmt);
+				CP_XML_ATTR(L"numFmtId", vd_ex->ifmt != 44 ? vd_ex->ifmt : 0);
 			}
 
 			if (vd->stName.value().empty() == false)

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/PIVOTVIEW.cpp

@@ -38,16 +38,18 @@
 #include "PIVOTPI.h"
 #include "PIVOTLI.h"
 #include "PIVOTEX.h"
+#include "PIVOTADDL.h"
 
 #include "../Biff_records/SXDI.h"
 #include "../Biff_records/SxView.h"
+#include "../Biff_records/SXAddl.h"
 
 namespace XLS
 {
 
 PIVOTVIEW::PIVOTVIEW()
 {
-	indexCache = -1;
+	index= -1;
 }
 
 PIVOTVIEW::~PIVOTVIEW()
@@ -62,6 +64,8 @@ BaseObjectPtr PIVOTVIEW::clone()
 // PIVOTVIEW = PIVOTCORE [PIVOTFRT]
 const bool PIVOTVIEW::loadContent(BinProcessor& proc)
 {
+	global_info_ = proc.getGlobalWorkbookInfo();
+
 	if(!proc.mandatory<PIVOTCORE>())
 	{
 		return false;
@@ -96,7 +100,14 @@ int PIVOTVIEW::serialize(std::wostream & strm)
 
 	PIVOTFRT* frt = dynamic_cast<PIVOTFRT*>(m_PIVOTFRT.get());
 
-	indexCache = view->iCache;
+	PIVOTADDL* addls = frt ? dynamic_cast<PIVOTADDL*>(frt->m_PIVOTADDL.get()) : NULL;
+
+	std::unordered_map<int, BaseObjectPtr>::iterator pFind = global_info_->mapPivotCache.begin();
+	
+	for (int i = 0; i < view->iCache; i++)
+		pFind++;
+
+	index = pFind->first;
 
 	CP_XML_WRITER(strm)
 	{
@@ -133,7 +144,7 @@ int PIVOTVIEW::serialize(std::wostream & strm)
 				CP_XML_ATTR(L"firstHeaderRow", view->rwFirstHead - view->ref.rowFirst );
 				CP_XML_ATTR(L"firstDataRow", view->rwFirstData - view->ref.rowFirst);
 				CP_XML_ATTR(L"firstDataCol", view->colFirstData - view->ref.columnFirst); 
-				CP_XML_ATTR(L"rowPageCount", 1); 
+				CP_XML_ATTR(L"rowPageCount", view->cDimPg > 0 ? view->cDimPg : 1); 
 				CP_XML_ATTR(L"colPageCount", 1);
 			}
 			CP_XML_NODE(L"pivotFields")
@@ -204,14 +215,23 @@ int PIVOTVIEW::serialize(std::wostream & strm)
 					}
 				}
 			}
-			//CP_XML_NODE(L"pivotTableStyleInfo")
-			//{
-			//	CP_XML_ATTR(L"showRowHeaders", 1); 
-			//	CP_XML_ATTR(L"showColHeaders", 1);
-			//	CP_XML_ATTR(L"showRowStripes", 0);
-			//	CP_XML_ATTR(L"showColStripes", 0);
-			//	CP_XML_ATTR(L"showLastColumn", 1);
-			//}
+
+			
+			if ((addls) && (addls->m_SXAddl_SXCView_SXDTableStyleClient))
+			{
+				SXAddl_SXCView_SXDTableStyleClient* table_style = dynamic_cast<SXAddl_SXCView_SXDTableStyleClient*>(addls->m_SXAddl_SXCView_SXDTableStyleClient.get());
+				CP_XML_NODE(L"pivotTableStyleInfo")
+				{
+					if (!table_style->stName.value().empty())
+						CP_XML_ATTR(L"name", table_style->stName.value()); 
+					
+					CP_XML_ATTR(L"showRowHeaders", table_style->fRowHeaders); 
+					CP_XML_ATTR(L"showColHeaders", table_style->fColumnHeaders);
+					CP_XML_ATTR(L"showRowStripes", table_style->fRowStrips);
+					CP_XML_ATTR(L"showColStripes", table_style->fColumnStrips);
+					CP_XML_ATTR(L"showLastColumn", table_style->fLastColumn);
+				}
+			}
 		}
 	}
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/PIVOTVIEW.h

@@ -54,8 +54,10 @@ public:
 	BaseObjectPtr	m_PIVOTCORE;
 	BaseObjectPtr	m_PIVOTFRT;
 //----------------------------------
-	int				indexCache;
+	int				index;
 	std::wstring	name;
+
+	GlobalWorkbookInfoPtr global_info_;
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLAUTOSORT.cpp

@@ -57,12 +57,12 @@ BaseObjectPtr SXADDLAUTOSORT::clone()
 // SXADDLAUTOSORT = SXAddl_SXCAutoSort_SXDId SXADDLSXRULE SXAddl_SXCAutoSort_SXDEnd
 const bool SXADDLAUTOSORT::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCAutoSort_SXDId>())
-	{
-		return false;
-	}
-	proc.mandatory<SXADDLSXRULE>();
-	proc.mandatory<SXAddl_SXCAutoSort_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCAutoSort_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.mandatory<SXADDLSXRULE>();
+	//proc.mandatory<SXAddl_SXCAutoSort_SXDEnd>();
 	return true;
 }
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLCACHE.cpp

@@ -60,39 +60,39 @@ BaseObjectPtr SXADDLCACHE::clone()
 //[SXADDLCACHE12] [SXADDLDBQUERY] *UNKNOWNFRT SXAddl_SXCCache_SXDEnd
 const bool SXADDLCACHE::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCCache_SXDId>())
-	{
-		return false;
-	}
-	m_SXCCache_SXDId = elements_.back();
-	elements_.pop_back(); 
+	//if(!proc.mandatory<SXAddl_SXCCache_SXDId>())
+	//{
+	//	return false;
+	//}
+	//m_SXCCache_SXDId = elements_.back();
+	//elements_.pop_back(); 
 
-	if (proc.optional<SXAddl_SXCCache_SXDVer10Info>())
-	{
-		m_SXDVer10Info = elements_.back();
-		elements_.pop_back(); 
-	}
-	if (proc.optional<SXAddl_SXCCache_SXDVerSXMacro>())
-	{
-		m_SXDVerSXMacro = elements_.back();
-		elements_.pop_back(); 
-	}
-	if (proc.optional<SXADDLCACHE12>())
-	{
-		m_SXADDLCACHE12 = elements_.back();
-		elements_.pop_back(); 
-	}
-	if (proc.optional<SXADDLDBQUERY>())
-	{
-		m_SXADDLDBQUERY = elements_.back();
-		elements_.pop_back(); 
-	}
-	int count  = proc.repeated<UNKNOWNFRT>(0, 0);
+	//if (proc.optional<SXAddl_SXCCache_SXDVer10Info>())
+	//{
+	//	m_SXDVer10Info = elements_.back();
+	//	elements_.pop_back(); 
+	//}
+	//if (proc.optional<SXAddl_SXCCache_SXDVerSXMacro>())
+	//{
+	//	m_SXDVerSXMacro = elements_.back();
+	//	elements_.pop_back(); 
+	//}
+	//if (proc.optional<SXADDLCACHE12>())
+	//{
+	//	m_SXADDLCACHE12 = elements_.back();
+	//	elements_.pop_back(); 
+	//}
+	//if (proc.optional<SXADDLDBQUERY>())
+	//{
+	//	m_SXADDLDBQUERY = elements_.back();
+	//	elements_.pop_back(); 
+	//}
+	//int count  = proc.repeated<UNKNOWNFRT>(0, 0);
 
-	if (proc.optional<SXAddl_SXCCache_SXDEnd>())
-	{
-		elements_.pop_back(); 
-	}
+	//if (proc.optional<SXAddl_SXCCache_SXDEnd>())
+	//{
+	//	elements_.pop_back(); 
+	//}
 	return true;
 }
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLCACHE12.cpp

@@ -60,45 +60,45 @@ BaseObjectPtr SXADDLCACHE12::clone()
 //   *SXADDLCACHEFIELD [SXADDLSXDH] [SXADDLSXMGS] SXAddl_SXCCache_SXDVerUpdInv
 const bool SXADDLCACHE12::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCCache_SXDVerUpdInv>())
-	{
-		return false;
-	}
-	m_SXAddl_SXCCache_SXDVerUpdInv = elements_.back();
-	elements_.pop_back();
+	//if(!proc.mandatory<SXAddl_SXCCache_SXDVerUpdInv>())
+	//{
+	//	return false;
+	//}
+	//m_SXAddl_SXCCache_SXDVerUpdInv = elements_.back();
+	//elements_.pop_back();
 
-	if (proc.optional<SXAddl_SXCCache_SXDInfo12>())
-	{
-		m_SXAddl_SXCCache_SXDInfo12 = elements_.back();
-		elements_.pop_back();
-	}
-	if (proc.optional<SXAddl_SXCCache_SXDInvRefreshReal>())
-	{
-		m_SXAddl_SXCCache_SXDInvRefreshReal = elements_.back();
-		elements_.pop_back();
-	}
-	
-	int count  =  proc.repeated<SXADDLCACHEFIELD>(0, 0);	
-	while(count > 0)
-	{
-		m_arSXADDLCACHEFIELD.push_back(elements_.front());
-		elements_.pop_front(); count--;
-	}
-	if (proc.optional<SXADDLSXDH>())
-	{
-		m_SXADDLSXDH = elements_.back();
-		elements_.pop_back();
-	}
-	if (proc.optional<SXADDLSXMGS>())
-	{
-		m_SXADDLSXMGS = elements_.back();
-		elements_.pop_back();
-	}
-	if (proc.optional<SXAddl_SXCCache_SXDVerUpdInv>())
-	{
-		m_SXAddl_SXCCache_SXDVerUpdInvS = elements_.back();
-		elements_.pop_back();
-	}
+	//if (proc.optional<SXAddl_SXCCache_SXDInfo12>())
+	//{
+	//	m_SXAddl_SXCCache_SXDInfo12 = elements_.back();
+	//	elements_.pop_back();
+	//}
+	//if (proc.optional<SXAddl_SXCCache_SXDInvRefreshReal>())
+	//{
+	//	m_SXAddl_SXCCache_SXDInvRefreshReal = elements_.back();
+	//	elements_.pop_back();
+	//}
+	//
+	//int count  =  proc.repeated<SXADDLCACHEFIELD>(0, 0);	
+	//while(count > 0)
+	//{
+	//	m_arSXADDLCACHEFIELD.push_back(elements_.front());
+	//	elements_.pop_front(); count--;
+	//}
+	//if (proc.optional<SXADDLSXDH>())
+	//{
+	//	m_SXADDLSXDH = elements_.back();
+	//	elements_.pop_back();
+	//}
+	//if (proc.optional<SXADDLSXMGS>())
+	//{
+	//	m_SXADDLSXMGS = elements_.back();
+	//	elements_.pop_back();
+	//}
+	//if (proc.optional<SXAddl_SXCCache_SXDVerUpdInv>())
+	//{
+	//	m_SXAddl_SXCCache_SXDVerUpdInvS = elements_.back();
+	//	elements_.pop_back();
+	//}
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLCACHEFIELD.cpp

@@ -59,11 +59,11 @@ public:
 
 	const bool loadContent(BinProcessor& proc)
 	{
-		if(!proc.mandatory<SXAddl_SXCCacheField_SXDCaption>())
-		{
-			return false;
-		}
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
+		//if(!proc.mandatory<SXAddl_SXCCacheField_SXDCaption>())
+		//{
+		//	return false;
+		//}
+		//proc.repeated<Continue_SxaddlSxString>(0, 0);
 		return true;
 	};
 };
@@ -81,11 +81,11 @@ public:
 
 	const bool loadContent(BinProcessor& proc)
 	{
-		if(!proc.mandatory<SXAddl_SXCCacheField_SXDPropName>())
-		{
-			return false;
-		}
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
+		//if(!proc.mandatory<SXAddl_SXCCacheField_SXDPropName>())
+		//{
+		//	return false;
+		//}
+		//proc.repeated<Continue_SxaddlSxString>(0, 0);
 		return true;
 	};
 };
@@ -102,11 +102,11 @@ public:
 
 	const bool loadContent(BinProcessor& proc)
 	{
-		if(!proc.mandatory<SXAddl_SXCCacheField_SXDProperty>())
-		{
-			return false;
-		}
-		proc.optional<Parenthesis_SXADDLCACHEFIELD_3>();
+		//if(!proc.mandatory<SXAddl_SXCCacheField_SXDProperty>())
+		//{
+		//	return false;
+		//}
+		//proc.optional<Parenthesis_SXADDLCACHEFIELD_3>();
 		return true;
 	};
 };
@@ -123,11 +123,11 @@ public:
 
 	const bool loadContent(BinProcessor& proc)
 	{
-		if(!proc.mandatory<SXAddl_SXCCacheField_SXDIfdbMpMapCount>())
-		{
-			return false;
-		}
-		proc.mandatory<SXAddl_SXCCacheField_SXDIfdbMempropMap>();
+		//if(!proc.mandatory<SXAddl_SXCCacheField_SXDIfdbMpMapCount>())
+		//{
+		//	return false;
+		//}
+		//proc.mandatory<SXAddl_SXCCacheField_SXDIfdbMempropMap>();
 		return true;
 	};
 };
@@ -144,12 +144,12 @@ public:
 
 	const bool loadContent(BinProcessor& proc)
 	{
-		if(!proc.mandatory<SXAddl_SXCCacheField_SXDSxrmitmCount>())
-		{
-			return false;
-		}
-		proc.repeated<SXADDLCACHEITEM>(0, 0);
-		proc.mandatory<SXAddl_SXCCacheItem_SXDEnd>();
+		//if(!proc.mandatory<SXAddl_SXCCacheField_SXDSxrmitmCount>())
+		//{
+		//	return false;
+		//}
+		//proc.repeated<SXADDLCACHEITEM>(0, 0);
+		//proc.mandatory<SXAddl_SXCCacheItem_SXDEnd>();
 		return true;
 	};
 };
@@ -171,16 +171,16 @@ BaseObjectPtr SXADDLCACHEFIELD::clone()
 //                    SXAddl_SXCCacheField_SXDEnd
 const bool SXADDLCACHEFIELD::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCCacheField_SXDId>())
-	{
-		return false;
-	}
-	proc.repeated<Continue_SxaddlSxString>(0, 0);
-	proc.optional<Parenthesis_SXADDLCACHEFIELD_1>();
-	proc.optional<Parenthesis_SXADDLCACHEFIELD_2>();
-	proc.optional<Parenthesis_SXADDLCACHEFIELD_4>();
-	proc.optional<Parenthesis_SXADDLCACHEFIELD_5>();
-	proc.optional<SXAddl_SXCCacheField_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCCacheField_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//proc.optional<Parenthesis_SXADDLCACHEFIELD_1>();
+	//proc.optional<Parenthesis_SXADDLCACHEFIELD_2>();
+	//proc.optional<Parenthesis_SXADDLCACHEFIELD_4>();
+	//proc.optional<Parenthesis_SXADDLCACHEFIELD_5>();
+	//proc.optional<SXAddl_SXCCacheField_SXDEnd>();
 	return true;
 }
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLCACHEITEM.cpp

@@ -58,11 +58,11 @@ public:
 
 	const bool loadContent(BinProcessor& proc)
 	{
-		if(!proc.mandatory<SXAddl_SXCCacheItem_SXDSxrmitmDisp>())
-		{
-			return false;
-		}
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
+		//if(!proc.mandatory<SXAddl_SXCCacheItem_SXDSxrmitmDisp>())
+		//{
+		//	return false;
+		//}
+		//proc.repeated<Continue_SxaddlSxString>(0, 0);
 		return true;
 	};
 };
@@ -79,11 +79,11 @@ public:
 
 	const bool loadContent(BinProcessor& proc)
 	{
-		if(!proc.mandatory<SXAddl_SXCCacheItem_SXDItmMpMapCount>())
-		{
-			return false;
-		}
-		proc.mandatory<SXAddl_SXCCacheItem_SXDItmMpropMap>();
+		//if(!proc.mandatory<SXAddl_SXCCacheItem_SXDItmMpMapCount>())
+		//{
+		//	return false;
+		//}
+		//proc.mandatory<SXAddl_SXCCacheItem_SXDItmMpropMap>();
 		return true;
 	};
 };
@@ -99,12 +99,12 @@ BaseObjectPtr SXADDLCACHEITEM::clone()
 //                   *(SXAddl_SXCCacheItem_SXDItmMpMapCount SXAddl_SXCCacheItem_SXDItmMpropMap)
 const bool SXADDLCACHEITEM::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCCacheItem_SXDId>())
-	{
-		return false;
-	}
-	proc.optional<Parenthesis_SXADDLCACHEITEM_1>();
-	proc.repeated<Parenthesis_SXADDLCACHEITEM_2>(0, 0);
+	//if(!proc.mandatory<SXAddl_SXCCacheItem_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.optional<Parenthesis_SXADDLCACHEITEM_1>();
+	//proc.repeated<Parenthesis_SXADDLCACHEITEM_2>(0, 0);
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLCALCMEMBER.cpp

@@ -56,14 +56,14 @@ BaseObjectPtr SXADDLCALCMEMBER::clone()
 // SXADDLCALCMEMBER = (SXAddl_SXCView_SXDCalcMember [SXAddl_SXCView_SXDCalcMemString *Continue_SxaddlSxString])
 const bool SXADDLCALCMEMBER::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCView_SXDCalcMember>())
-	{
-		return false;
-	}
-	if(proc.optional<SXAddl_SXCView_SXDCalcMemString>())
-	{
-		int count = proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
+	//if(!proc.mandatory<SXAddl_SXCView_SXDCalcMember>())
+	//{
+	//	return false;
+	//}
+	//if(proc.optional<SXAddl_SXCView_SXDCalcMemString>())
+	//{
+	//	int count = proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLCONDFMT.cpp

@@ -57,12 +57,12 @@ BaseObjectPtr SXADDLCONDFMT::clone()
 // SXADDLCONDFMT = SXAddl_SXCSXCondFmt_SXDSXCondFmt *SXADDLSXRULE SXAddl_SXCSXCondFmt_SXDEnd
 const bool SXADDLCONDFMT::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCSXCondFmt_SXDSXCondFmt>())
-	{
-		return false;
-	}
-	proc.repeated<SXADDLSXRULE>(0, 0);
-	proc.mandatory<SXAddl_SXCSXCondFmt_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCSXCondFmt_SXDSXCondFmt>())
+	//{
+	//	return false;
+	//}
+	//proc.repeated<SXADDLSXRULE>(0, 0);
+	//proc.mandatory<SXAddl_SXCSXCondFmt_SXDEnd>();
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLCONDFMTS.cpp

@@ -57,12 +57,12 @@ BaseObjectPtr SXADDLCONDFMTS::clone()
 // SXADDLCONDFMTS = SXAddl_SXCSXCondFmts_SXDId *SXADDLCONDFMT SXAddl_SXCSXCondFmts_SXDEnd
 const bool SXADDLCONDFMTS::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCSXCondFmts_SXDId>())
-	{
-		return false;
-	}
-	proc.repeated<SXADDLCONDFMT>(0, 0);
-	proc.optional<SXAddl_SXCSXCondFmts_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCSXCondFmts_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.repeated<SXADDLCONDFMT>(0, 0);
+	//proc.optional<SXAddl_SXCSXCondFmts_SXDEnd>();
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLDBQUERY.cpp

@@ -61,39 +61,39 @@ SXADDLDBQUERY = [SXAddl_SXCQuery_SXDXMLSource *Continue_SxaddlSxString]
 */
 const bool SXADDLDBQUERY::loadContent(BinProcessor& proc)
 {
-	int count = 0;
-	
-	if(proc.optional<SXAddl_SXCQuery_SXDXMLSource>())
-	{
-		m_XMLSource = elements_.back();
-		elements_.pop_back();
+	//int count = 0;
+	//
+	//if(proc.optional<SXAddl_SXCQuery_SXDXMLSource>())
+	//{
+	//	m_XMLSource = elements_.back();
+	//	elements_.pop_back();
 
-		count = proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCQuery_SXDSrcDataFile>())
-	{
-		m_SrcDataFile = elements_.back();
-		elements_.pop_back();
+	//	count = proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCQuery_SXDSrcDataFile>())
+	//{
+	//	m_SrcDataFile = elements_.back();
+	//	elements_.pop_back();
 
-		count = proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCQuery_SXDSrcConnFile>())
-	{
-		m_SrcConnFile = elements_.back();
-		elements_.pop_back();
+	//	count = proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCQuery_SXDSrcConnFile>())
+	//{
+	//	m_SrcConnFile = elements_.back();
+	//	elements_.pop_back();
 
-		count = proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCQuery_SXDReconnCond>())
-	{
-		m_ReconnCond = elements_.back();
-		elements_.pop_back();
-	}
+	//	count = proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCQuery_SXDReconnCond>())
+	//{
+	//	m_ReconnCond = elements_.back();
+	//	elements_.pop_back();
+	//}
 
-	if(proc.mandatory<SXAddl_SXCQuery_SXDEnd>())
-	{
-		elements_.pop_back();
-	}
+	//if(proc.mandatory<SXAddl_SXCQuery_SXDEnd>())
+	//{
+	//	elements_.pop_back();
+	//}
 
 	return m_XMLSource || m_SrcConnFile || m_SrcDataFile || m_ReconnCond;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLFIELD.cpp

@@ -60,22 +60,23 @@ SXADDLFIELD = [SXAddl_SXCField_SXDId *Continue_SxaddlSxString SXAddl_SXCField_SX
 */
 const bool SXADDLFIELD::loadContent(BinProcessor& proc)
 {
-	if(proc.optional<SXAddl_SXCField_SXDId>())
-	{
-		int count = proc.repeated<Continue_SxaddlSxString>(0, 0);
-		if (proc.mandatory<SXAddl_SXCField_SXDVer10Info>())
-		{
-		}
-		if (proc.mandatory<SXAddl_SXCField_SXDEnd>())
-		{
-		}
-		if (proc.optional<SXADDLFIELD12>())
-		{
-		}
-		return true;
-	}
+	//if(proc.optional<SXAddl_SXCField_SXDId>())
+	//{
+	//	int count = proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//	if (proc.mandatory<SXAddl_SXCField_SXDVer10Info>())
+	//	{
+	//	}
+	//	if (proc.mandatory<SXAddl_SXCField_SXDEnd>())
+	//	{
+	//	}
+	//	if (proc.optional<SXADDLFIELD12>())
+	//	{
+	//	}
+	//	return true;
+	//}
 
-	return proc.optional<SXADDLFIELD12>();
+	//return proc.optional<SXADDLFIELD12>();
+	return true;
 }
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLFIELD12.cpp

@@ -63,23 +63,23 @@ SXADDLFIELD12 = SXAddl_SXCField12_SXDId *Continue_SxaddlSxString SXAddl_SXCField
 */
 const bool SXADDLFIELD12::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCField12_SXDId>())
-	{
-		return false;
-	}
-	proc.repeated<Continue_SxaddlSxString>(0, 0);
-	proc.mandatory<SXAddl_SXCField12_SXDVer12Info>();
-	proc.mandatory<SXAddl_SXCField12_SXDVerUpdInv>();
-	if(proc.optional<SXAddl_SXCField12_SXDMemberCaption>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	proc.optional<SXAddl_SXCField12_SXDAutoshow>();
-	proc.optional<SXAddl_SXCField12_SXDISXTH>();
-	proc.optional<SXADDLAUTOSORT>();
-	proc.mandatory<SXAddl_SXCField12_SXDVerUpdInv>();
-	proc.repeated<UNKNOWNFRT>(0, 0);
-	proc.mandatory<SXAddl_SXCField12_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCField12_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//proc.mandatory<SXAddl_SXCField12_SXDVer12Info>();
+	//proc.mandatory<SXAddl_SXCField12_SXDVerUpdInv>();
+	//if(proc.optional<SXAddl_SXCField12_SXDMemberCaption>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//proc.optional<SXAddl_SXCField12_SXDAutoshow>();
+	//proc.optional<SXAddl_SXCField12_SXDISXTH>();
+	//proc.optional<SXADDLAUTOSORT>();
+	//proc.mandatory<SXAddl_SXCField12_SXDVerUpdInv>();
+	//proc.repeated<UNKNOWNFRT>(0, 0);
+	//proc.mandatory<SXAddl_SXCField12_SXDEnd>();
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLGROUP.cpp

@@ -60,15 +60,15 @@ SXADDLGROUP = SXAddl_SXCGroup_SXDId *Continue_SxaddlSxString SXAddl_SXCGroup_SXD
 */
 const bool SXADDLGROUP::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCGroup_SXDId>())
-	{
-		return false;
-	}
-	proc.repeated<Continue_SxaddlSxString>(0, 0);
-	proc.mandatory<SXAddl_SXCGroup_SXDGrpInfo>();
-	proc.repeated<SXAddl_SXCGroup_SXDMember>(0, 0);
-	proc.repeated<UNKNOWNFRT>(0, 0);
-	proc.mandatory<SXAddl_SXCGroup_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCGroup_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//proc.mandatory<SXAddl_SXCGroup_SXDGrpInfo>();
+	//proc.repeated<SXAddl_SXCGroup_SXDMember>(0, 0);
+	//proc.repeated<UNKNOWNFRT>(0, 0);
+	//proc.mandatory<SXAddl_SXCGroup_SXDEnd>();
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLGRPLEVEL.cpp

@@ -61,15 +61,15 @@ SXADDLGRPLEVEL = SXAddl_SXCGrpLevel_SXDId *Continue_SxaddlSxString SXAddl_SXCGrp
 */
 const bool SXADDLGRPLEVEL::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCGrpLevel_SXDId>())
-	{
-		return false;
-	}
-	proc.repeated<Continue_SxaddlSxString>(0, 0);
-	proc.mandatory<SXAddl_SXCGrpLevel_SXDGrpLevelInfo>();
-	proc.repeated<SXADDLGROUP>(0, 0);
-	proc.repeated<UNKNOWNFRT>(0, 0);
-	proc.mandatory<SXAddl_SXCGrpLevel_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCGrpLevel_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//proc.mandatory<SXAddl_SXCGrpLevel_SXDGrpLevelInfo>();
+	//proc.repeated<SXADDLGROUP>(0, 0);
+	//proc.repeated<UNKNOWNFRT>(0, 0);
+	//proc.mandatory<SXAddl_SXCGrpLevel_SXDEnd>();
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLHIERARCHY.cpp

@@ -75,67 +75,67 @@ SXADDLHIERARCHY = SXAddl_SXCHierarchy_SXDId *Continue_SxaddlSxString *SXAddl_SXC
 */
 const bool SXADDLHIERARCHY::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCHierarchy_SXDId>())
-	{
-		return false;
-	}
-	proc.repeated<Continue_SxaddlSxString>(0, 0);
-	proc.repeated<SXAddl_SXCHierarchy_SXDProperty>(0, 0);
-	proc.repeated<SXADDLGRPLEVEL>(0, 0);
-	proc.optional<SXAddl_SXCHierarchy_SXDVerUpdInv>();
+	//if(!proc.mandatory<SXAddl_SXCHierarchy_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//proc.repeated<SXAddl_SXCHierarchy_SXDProperty>(0, 0);
+	//proc.repeated<SXADDLGRPLEVEL>(0, 0);
+	//proc.optional<SXAddl_SXCHierarchy_SXDVerUpdInv>();
 
-	if(proc.optional<SXAddl_SXCHierarchy_SXDSXSetParentUnique>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	proc.optional<SXAddl_SXCHierarchy_SXDIconSet>();
-	if(proc.optional<SXAddl_SXCHierarchy_SXDUserCaption>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	proc.repeated<UNKNOWNFRT>(0, 0);
-	proc.optional<SXAddl_SXCHierarchy_SXDVerUpdInv>();
-	proc.repeated<SXAddl_SXCHierarchy_SXDUserCaption>(0, 0);
-	proc.optional<SXAddl_SXCHierarchy_SXDVerUpdInv>();
-	proc.optional<SXAddl_SXCHierarchy_SXDInfo12>();
-	if(proc.optional<SXAddl_SXCHierarchy_SXDDisplayFolder>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCHierarchy_SXDMeasureGrp>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCHierarchy_SXDParentKPI>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCHierarchy_SXDKPIValue>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCHierarchy_SXDKPIGoal>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCHierarchy_SXDKPIStatus>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCHierarchy_SXDKPITrend>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCHierarchy_SXDKPIWeight>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCHierarchy_SXDKPITime>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
+	//if(proc.optional<SXAddl_SXCHierarchy_SXDSXSetParentUnique>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//proc.optional<SXAddl_SXCHierarchy_SXDIconSet>();
+	//if(proc.optional<SXAddl_SXCHierarchy_SXDUserCaption>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//proc.repeated<UNKNOWNFRT>(0, 0);
+	//proc.optional<SXAddl_SXCHierarchy_SXDVerUpdInv>();
+	//proc.repeated<SXAddl_SXCHierarchy_SXDUserCaption>(0, 0);
+	//proc.optional<SXAddl_SXCHierarchy_SXDVerUpdInv>();
+	//proc.optional<SXAddl_SXCHierarchy_SXDInfo12>();
+	//if(proc.optional<SXAddl_SXCHierarchy_SXDDisplayFolder>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCHierarchy_SXDMeasureGrp>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCHierarchy_SXDParentKPI>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCHierarchy_SXDKPIValue>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCHierarchy_SXDKPIGoal>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCHierarchy_SXDKPIStatus>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCHierarchy_SXDKPITrend>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCHierarchy_SXDKPIWeight>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCHierarchy_SXDKPITime>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
 
-	proc.mandatory<SXAddl_SXCHierarchy_SXDEnd>();
+	//proc.mandatory<SXAddl_SXCHierarchy_SXDEnd>();
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLQSI.cpp

@@ -58,13 +58,13 @@ BaseObjectPtr SXADDLQSI::clone()
 // SXADDLQSI = SXAddl_SXCQsi_SXDId SXADDLDBQUERY *UNKNOWNFRT SXAddl_SXCQsi_SXDEnd
 const bool SXADDLQSI::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCQsi_SXDId>())
-	{
-		return false;
-	}
-	proc.mandatory<SXADDLDBQUERY>();
-	proc.repeated<UNKNOWNFRT>(0, 0);
-	proc.mandatory<SXAddl_SXCQsi_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCQsi_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.mandatory<SXADDLDBQUERY>();
+	//proc.repeated<UNKNOWNFRT>(0, 0);
+	//proc.mandatory<SXAddl_SXCQsi_SXDEnd>();
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLSXDH.cpp

@@ -57,12 +57,12 @@ BaseObjectPtr SXADDLSXDH::clone()
 const bool SXADDLSXDH::loadContent(BinProcessor& proc)
 {
 
-	if(!proc.mandatory<SXAddl_SXCSXDH_SXDId>())
-	{
-		return false;
-	}
-	proc.repeated<SXAddl_SXCSXDH_SXDSxdh>(0, 0);
-	proc.mandatory<SXAddl_SXCSXDH_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCSXDH_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.repeated<SXAddl_SXCSXDH_SXDSxdh>(0, 0);
+	//proc.mandatory<SXAddl_SXCSXDH_SXDEnd>();
 	return true;
 }
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLSXFILT.cpp

@@ -56,13 +56,13 @@ BaseObjectPtr SXADDLSXFILT::clone()
 // SXADDLSXFILT = SXAddl_SXCSXfilt_SXDId SXAddl_SXCSXfilt_SXDSXfilt [SXAddl_SXCSXfilt_SXDSXItm] SXAddl_SXCSXfilt_SXDEnd
 const bool SXADDLSXFILT::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCSXfilt_SXDId>())
-	{
-		return false;
-	}
-	proc.mandatory<SXAddl_SXCSXfilt_SXDSXfilt>();
-	proc.optional<SXAddl_SXCSXfilt_SXDSXItm>();
-	proc.mandatory<SXAddl_SXCSXfilt_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCSXfilt_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.mandatory<SXAddl_SXCSXfilt_SXDSXfilt>();
+	//proc.optional<SXAddl_SXCSXfilt_SXDSXItm>();
+	//proc.mandatory<SXAddl_SXCSXfilt_SXDEnd>();
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLSXFILTER12.cpp

@@ -65,38 +65,38 @@ SXADDLSXFILTER12 = SXAddl_SXCSXFilter12_SXDId SXAddl_SXCSXFilter12_SXDSXFilter
 */
 const bool SXADDLSXFILTER12::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCSXFilter12_SXDId>())
-	{
-		return false;
-	}
-	proc.mandatory<SXAddl_SXCSXFilter12_SXDSXFilter>();
+	//if(!proc.mandatory<SXAddl_SXCSXFilter12_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.mandatory<SXAddl_SXCSXFilter12_SXDSXFilter>();
 
-	if(proc.optional<SXAddl_SXCSXFilter12_SXDCaption>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCSXFilter12_SXDSXFilterDesc>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCSXFilter12_SXDSXFilterValue1>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCSXFilter12_SXDSXFilterValue2>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	proc.mandatory<SXAddl_SXCSXFilter12_SXDXlsFilter>();
-	if(proc.optional<SXAddl_SXCSXFilter12_SXDXlsFilterValue1>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	if(proc.optional<SXAddl_SXCSXFilter12_SXDXlsFilterValue2>())
-	{
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
-	}
-	proc.mandatory<SXAddl_SXCSXFilter12_SXDEnd>();
+	//if(proc.optional<SXAddl_SXCSXFilter12_SXDCaption>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCSXFilter12_SXDSXFilterDesc>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCSXFilter12_SXDSXFilterValue1>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCSXFilter12_SXDSXFilterValue2>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//proc.mandatory<SXAddl_SXCSXFilter12_SXDXlsFilter>();
+	//if(proc.optional<SXAddl_SXCSXFilter12_SXDXlsFilterValue1>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//if(proc.optional<SXAddl_SXCSXFilter12_SXDXlsFilterValue2>())
+	//{
+	//	proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//}
+	//proc.mandatory<SXAddl_SXCSXFilter12_SXDEnd>();
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLSXFILTERS12.cpp

@@ -57,12 +57,12 @@ BaseObjectPtr SXADDLSXFILTERS12::clone()
 // SXADDLSXFILTERS12 = SXAddl_SXCSXFilters12_SXDId *SXADDLSXFILTER12 SXAddl_SXCSXFilters12_SXDEnd
 const bool SXADDLSXFILTERS12::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCSXFilters12_SXDId>())
-	{
-		return false;
-	}
-	proc.repeated<SXADDLSXFILTER12>(0, 0);
-	proc.mandatory<SXAddl_SXCSXFilters12_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCSXFilters12_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.repeated<SXADDLSXFILTER12>(0, 0);
+	//proc.mandatory<SXAddl_SXCSXFilters12_SXDEnd>();
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLSXMG.cpp

@@ -59,11 +59,11 @@ public:
 
 	const bool loadContent(BinProcessor& proc)
 	{
-		if(!proc.mandatory<SXAddl_SXCSXMg_SXDUserCaption>())
-		{
-			return false;
-		}
-		proc.repeated<Continue_SxaddlSxString>(0, 0);
+		//if(!proc.mandatory<SXAddl_SXCSXMg_SXDUserCaption>())
+		//{
+		//	return false;
+		//}
+		//proc.repeated<Continue_SxaddlSxString>(0, 0);
 		return true;
 	};
 };
@@ -80,14 +80,14 @@ BaseObjectPtr SXADDLSXMG::clone()
 //              [SXAddl_SXCSXMg_SXDUserCaption *Continue_SxaddlSxString] *UNKNOWNFRT SXAddl_SXCSXMg_SXDEnd
 const bool SXADDLSXMG::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCSXMg_SXDId>())
-	{
-		return false;
-	}
-	proc.repeated<Continue_SxaddlSxString>(0, 0);
-	proc.optional<Parenthesis_SXADDLSXMG_1>();
-	proc.repeated<UNKNOWNFRT>(0, 0);
-	proc.mandatory<SXAddl_SXCSXMg_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCSXMg_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.repeated<Continue_SxaddlSxString>(0, 0);
+	//proc.optional<Parenthesis_SXADDLSXMG_1>();
+	//proc.repeated<UNKNOWNFRT>(0, 0);
+	//proc.mandatory<SXAddl_SXCSXMg_SXDEnd>();
 	return true;
 }
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLSXMGS.cpp

@@ -58,14 +58,14 @@ BaseObjectPtr SXADDLSXMGS::clone()
 // SXADDLSXMGS = SXAddl_SXCSXMgs_SXDId *SXADDLSXMG *SXAddl_SXCSXMgs_SXDMGrpSXDHMap *UNKNOWNFRT SXAddl_SXCSXMgs_SXDEnd
 const bool SXADDLSXMGS::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCSXMgs_SXDId>())
-	{
-		return false;
-	}
-	proc.repeated<SXADDLSXMG>(0, 0);
-	proc.repeated<SXAddl_SXCSXMgs_SXDMGrpSXDHMap>(0, 0);
-	proc.repeated<UNKNOWNFRT>(0, 0);
-	proc.mandatory<SXAddl_SXCSXMgs_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCSXMgs_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.repeated<SXADDLSXMG>(0, 0);
+	//proc.repeated<SXAddl_SXCSXMgs_SXDMGrpSXDHMap>(0, 0);
+	//proc.repeated<UNKNOWNFRT>(0, 0);
+	//proc.mandatory<SXAddl_SXCSXMgs_SXDEnd>();
 	return true;
 }
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_unions/SXADDLSXRULE.cpp

@@ -57,13 +57,13 @@ BaseObjectPtr SXADDLSXRULE::clone()
 // SXADDLSXRULE = SXAddl_SXCSXrule_SXDId SXAddl_SXCSXrule_SXDSXrule *SXADDLSXFILT SXAddl_SXCSXrule_SXDEnd
 const bool SXADDLSXRULE::loadContent(BinProcessor& proc)
 {
-	if(!proc.mandatory<SXAddl_SXCSXrule_SXDId>())
-	{
-		return false;
-	}
-	proc.mandatory<SXAddl_SXCSXrule_SXDSXrule>();
-	proc.repeated<SXADDLSXFILT>(0, 0);
-	proc.mandatory<SXAddl_SXCSXrule_SXDEnd>();
+	//if(!proc.mandatory<SXAddl_SXCSXrule_SXDId>())
+	//{
+	//	return false;
+	//}
+	//proc.mandatory<SXAddl_SXCSXrule_SXDSXrule>();
+	//proc.repeated<SXADDLSXFILT>(0, 0);
+	//proc.mandatory<SXAddl_SXCSXrule_SXDEnd>();
 
 	return true;
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/GlobalWorkbookInfo.h

@@ -35,6 +35,7 @@
 #include <boost/smart_ptr/shared_array.hpp>
 #include <vector>
 #include <map>
+#include <unordered_map>
 
 #include "Biff_structures/BorderFillInfo.h"
 
@@ -106,7 +107,8 @@ public:
 	const static unsigned int					initial_AXES_id = 0x2000000;
 
 	short												idPivotCache;
-	std::map<int, BaseObjectPtr>						mapPivotCache;
+	std::unordered_map<int, BaseObjectPtr>				mapPivotCache;
+
 	std::vector<bool>									arPivotCacheFields;
 	std::vector<bool>									arPivotCacheFieldShortSize;
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/XlsElementsType.h

@@ -310,6 +310,7 @@ enum ElementType
 	typeStringSegmented,
 	typeStringSegmentedSXADDL,
 	typeSXAddl,
+	typeSxaddlSxString,
 	typeSXDI,
 	typeSxDXF,
 	typeSXEx,

ASCOfficeXlsFile2/source/XlsXlsxConverter/XlsConverter.cpp

@@ -1924,7 +1924,8 @@ void XlsConverter::convert(XLS::PIVOTVIEW * pivot_view)
 
 	pivot_view->serialize(strm);
 
-	int index_view = xlsx_context->get_pivots_context().add_view(strm.str(), pivot_view->indexCache);
+
+	int index_view = xlsx_context->get_pivots_context().add_view(strm.str(), pivot_view->index);
 	
 	if (index_view > 0)
 	{
@@ -1940,8 +1941,8 @@ void XlsConverter::convert(XLS::PIVOTCACHEDEFINITION * pivot_cached)
 
 	std::wstringstream strmD, strmR;
 
-	pivot_cached->serialize_definitions(strmD);
+	int index = pivot_cached->serialize_definitions(strmD);
 	pivot_cached->serialize_records(strmR);
 
-	xlsx_context->get_pivots_context().add_cache(strmD.str(), strmR.str());
+	xlsx_context->get_pivots_context().add_cache(strmD.str(), strmR.str(), index);
 }

ASCOfficeXlsFile2/source/XlsXlsxConverter/xlsx_pivots_context.cpp

@@ -34,6 +34,8 @@
 #include <boost/make_shared.hpp>
 #include <simple_xml_writer.h>
 
+#include <map>
+
 namespace oox {
 
 class xlsx_pivots_context::Impl
@@ -55,16 +57,20 @@ public:
 	std::vector<_pivot_cache>	caches_;
 	std::vector<_pivot_view>	views_;
 	std::wstring				connections_;
+
+	std::map<int, int>			mapIndex_;
 };
 
 xlsx_pivots_context::xlsx_pivots_context() : impl_(new xlsx_pivots_context::Impl())
 {
 }
 
-void xlsx_pivots_context::add_cache(std::wstring definitions, std::wstring records)
+void xlsx_pivots_context::add_cache(std::wstring definitions, std::wstring records, int indexCache)
 {
 	Impl::_pivot_cache c = {definitions, records};
 	impl_->caches_.push_back(c);
+
+	impl_->mapIndex_.insert(std::make_pair(indexCache, impl_->caches_.size()));
 }
 
 int xlsx_pivots_context::get_cache_count()
@@ -86,11 +92,11 @@ void xlsx_pivots_context::dump_rels_cache(int index, rels & Rels)
 }
 void xlsx_pivots_context::dump_rels_view(int index, rels & Rels)
 {
-	if (impl_->views_[index].indexCache_ >= 0)
+	if (impl_->views_[index].indexCache_ > 0)
 	{
 		Rels.add(relationship(L"rId1",							
 						L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition",
-						L"../pivotCache/pivotCacheDefinition" + std::to_wstring(impl_->views_[index].indexCache_ + 1) + L".xml", L""));
+						L"../pivotCache/pivotCacheDefinition" + std::to_wstring( impl_->views_[index].indexCache_ ) + L".xml", L""));
 	}
 }
 void xlsx_pivots_context::write_cache_definitions_to(int index, std::wostream & strm)
@@ -122,7 +128,9 @@ int xlsx_pivots_context::add_view(std::wstring table_view, int indexCache)
 {
 	if (table_view.empty()) return 0;
 
-	Impl::_pivot_view v = {table_view, indexCache};
+	std::map<int, int>::iterator pFind = impl_->mapIndex_.find(indexCache);
+
+	Impl::_pivot_view v = {table_view, pFind->second};
 	impl_->views_.push_back(v);
 
 	return (int)impl_->views_.size();

ASCOfficeXlsFile2/source/XlsXlsxConverter/xlsx_pivots_context.h

@@ -46,7 +46,7 @@ public:
 	int add_view(std::wstring table_view, int indexCache);
 	int get_view_count();
 
-	void add_cache(std::wstring definitions, std::wstring records);
+	void add_cache(std::wstring definitions, std::wstring records, int indexCache);
 	int get_cache_count();
 
 	void write_cache_definitions_to	(int index, std::wostream & strm);

Common/DocxFormat/Source/DocxFormat/ContentTypes.h

@@ -324,9 +324,11 @@ namespace OOX
 		{
 			if (sExtension.empty()) return;
 
-			if (m_mapDefaults.find (sExtension) == m_mapDefaults.end())
+			std::wstring sExt = XmlUtils::GetLower(sExtension);
+
+			if (m_mapDefaults.find (sExt) == m_mapDefaults.end())
 			{
-				m_mapDefaults [sExtension] = ContentTypes::CDefault( sExtension );
+				m_mapDefaults [sExt] = ContentTypes::CDefault( sExt );
 			}
 		}
 	private:

Common/DocxFormat/Source/DocxFormat/Drawing/DrawingExt.cpp

@@ -111,16 +111,18 @@ namespace OOX
             std::wstring sResult = _T("<");
             sResult += sNamespace;
             sResult += _T("ext");
-            sResult += m_sAdditionalNamespace;
 
             if ( m_sUri.IsInit() )
 			{
-                sResult += _T(" uri=\"");
-                sResult += m_sUri.get2();
-				sResult += _T("\">");
+                sResult += L" uri=\"" + m_sUri.get2() + L"\"";
 			}
-			else
-				sResult += _T(">");
+
+			if (!m_sAdditionalNamespace.empty())
+			{
+				sResult += L" " + m_sAdditionalNamespace;
+			}
+			
+			sResult += _T(">");
 
 			if(m_oCompatExt.IsInit())
 			{

Common/DocxFormat/Source/XlsxFormat/Workbook/ExternalReferences.h

@@ -110,6 +110,8 @@ namespace OOX
 			}
 			virtual void toXML(NSStringUtils::CStringBuilder& writer) const
 			{
+				if (m_arrItems.empty()) return;
+
 				writer.WriteString(_T("<externalReferences>"));
 				
 				for(size_t i = 0, length = m_arrItems.size(); i < length; ++i)

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

@@ -67,7 +67,7 @@ namespace OOX
 					WritingStringAttrString(L"type", m_oType->ToString());
 					if (m_oGte.IsInit() && false == m_oGte->ToBool())
 						writer.WriteString(L" gte=\"0\"");
-					WritingStringNullableAttrString(L"val", m_oVal, m_oVal.get());
+					WritingStringNullableAttrEncodeXmlString(L"val", m_oVal, m_oVal.get());
 					writer.WriteString(_T("/>"));
 				}
 			}

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

@@ -433,8 +433,8 @@ namespace OOX
 				writer.WriteString(_T("<selection"));
 				WritingStringNullableAttrString(L"activeCell", m_oActiveCell, m_oActiveCell.get());
 				WritingStringNullableAttrInt(L"activeCellId", m_oActiveCellId, m_oActiveCellId->GetValue());
-				WritingStringNullableAttrString(L"sqref", m_oSqref, m_oSqref.get());
 				WritingStringNullableAttrString(L"pane", m_oPane, m_oPane->ToString());
+				WritingStringNullableAttrString(L"sqref", m_oSqref, m_oSqref.get());
 				writer.WriteString(_T("/>"));
 			}
 			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)

Common/OfficeFileFormatChecker2.cpp

@@ -358,26 +358,34 @@ bool COfficeFileFormatChecker::isOOXFormatFile(const std::wstring & fileName)
         std::string::size_type res1 = std::string::npos;
         std::string::size_type res = 0;
         if ((std::string::npos != strContentTypes.find(docxFormatLine)) ||
-            (std::string::npos != strContentTypes.find(dotxFormatLine)) ||
-            (std::string::npos != strContentTypes.find(docmFormatLine)) ||
-            (std::string::npos != strContentTypes.find(dotmFormatLine)))
+            (std::string::npos != strContentTypes.find(docmFormatLine)))
 		{
 			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX;
 		}
-
-        else if ((std::string::npos != strContentTypes.find(xlsxFormatLine)) ||
-                 (std::string::npos != strContentTypes.find(xltxFormatLine)) ||
-                 (std::string::npos != strContentTypes.find(xlsmFormatLine)) ||
-                 (std::string::npos != strContentTypes.find(xltmFormatLine)))
+        else if ((std::string::npos != strContentTypes.find(dotxFormatLine)))
+		{
+			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX;
+		}
+		else if ((std::string::npos != strContentTypes.find(dotmFormatLine)))
+		{
+			nFileType = AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM;
+		}
+		else if ((std::string::npos != strContentTypes.find(xlsxFormatLine)) ||
+                 (std::string::npos != strContentTypes.find(xlsmFormatLine)))
 		{
 			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX;
 		}
-
-        else if ((std::string::npos != strContentTypes.find(pptxFormatLine)) ||
-                 (std::string::npos != strContentTypes.find(potxFormatLine)) ||
+        else if ((std::string::npos != strContentTypes.find(xltxFormatLine)))
+		{
+			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX;
+		}
+		else if ((std::string::npos != strContentTypes.find(xltmFormatLine)))
+		{
+			nFileType = AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM;
+		}
+		else if ((std::string::npos != strContentTypes.find(pptxFormatLine)) ||
                  (std::string::npos != strContentTypes.find(pptmFormatLine)) ||
-                 (std::string::npos != strContentTypes.find(ppsmFormatLine)) ||
-                 (std::string::npos != strContentTypes.find(potmFormatLine)))
+                 (std::string::npos != strContentTypes.find(ppsmFormatLine)))
 		{
 			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX;
 		}
@@ -385,7 +393,14 @@ bool COfficeFileFormatChecker::isOOXFormatFile(const std::wstring & fileName)
 		{
 			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX;
 		}
-
+        else if ((std::string::npos != strContentTypes.find(potxFormatLine)))
+		{
+			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX;
+		}
+        else if ((std::string::npos != strContentTypes.find(potmFormatLine)))
+		{
+			nFileType = AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM;
+		}
 		delete []pBuffer;
 		pBuffer = NULL;
 
@@ -519,6 +534,9 @@ std::wstring COfficeFileFormatChecker::GetExtensionByType(int type)
     switch (type)
     {
     case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX:		return L".docx";
+    case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM:		return L".docm";
+    case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX:		return L".dotx";
+    case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM:		return L".dotm";
     case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC:		return L".doc";
     case AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT:		return L".odt";
     case AVS_OFFICESTUDIO_FILE_DOCUMENT_RTF:		return L".rtf";
@@ -530,11 +548,17 @@ std::wstring COfficeFileFormatChecker::GetExtensionByType(int type)
     case AVS_OFFICESTUDIO_FILE_DOCUMENT_MOBI:		return L".mobi";
 
     case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX:	return L".pptx";
+    case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTM:	return L".pptm";
     case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT:	return L".ppt";
     case AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP:	return L".odp";
     case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX:	return L".ppsx";
+    case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX:	return L".potx";
+    case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM:	return L".potm";
 
     case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX:	return L".xlsx";
+    case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM:	return L".xlsm";
+    case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX:	return L".xltx";
+    case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM:	return L".xltm";
     case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS:		return L".xls";
     case AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS:		return L".ods";
     case AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV:		return L".csv";
@@ -581,6 +605,12 @@ int COfficeFileFormatChecker::GetFormatByExtension(const std::wstring& ext)
 {
     if (L".docx" == ext)
         return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX;
+    if (L".docm" == ext)
+        return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM;
+    if (L".dotx" == ext)
+        return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX;
+    if (L".dotm" == ext)
+        return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM;
     if (L".doc" == ext)
         return AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC;
     if (L".odt" == ext)
@@ -603,15 +633,27 @@ int COfficeFileFormatChecker::GetFormatByExtension(const std::wstring& ext)
 
     if (L".pptx" == ext)
         return AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX;
+    if (L".pptm" == ext)
+        return AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTM;
     if (L".ppt" == ext)
         return AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT;
     if (L".odp" == ext)
         return AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP;
     if (L".ppsx" == ext)
         return AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX;
+    if (L".potx" == ext)
+        return AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX;
+    if (L".potm" == ext)
+        return AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM;
 
     if (L".xlsx" == ext)
         return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX;
+    if (L".xlsm" == ext)
+        return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM;
+    if (L".xltx" == ext)
+        return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX;
+    if (L".xltm" == ext)
+        return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM;
     if (L".xls" == ext)
         return AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS;
     if (L".ods" == ext)

Common/OfficeFileFormats.h

@@ -44,18 +44,27 @@
 #define AVS_OFFICESTUDIO_FILE_DOCUMENT_EPUB				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0008
 #define AVS_OFFICESTUDIO_FILE_DOCUMENT_FB2				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x0009
 #define AVS_OFFICESTUDIO_FILE_DOCUMENT_MOBI				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x000a
+#define AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x000b
+#define AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x000c
+#define AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM				AVS_OFFICESTUDIO_FILE_DOCUMENT + 0x000d
 
 #define AVS_OFFICESTUDIO_FILE_PRESENTATION				0x0080
 #define AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX			AVS_OFFICESTUDIO_FILE_PRESENTATION + 0x0001
 #define AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT			AVS_OFFICESTUDIO_FILE_PRESENTATION + 0x0002
 #define AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP			AVS_OFFICESTUDIO_FILE_PRESENTATION + 0x0003
 #define AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX			AVS_OFFICESTUDIO_FILE_PRESENTATION + 0x0004
+#define AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTM			AVS_OFFICESTUDIO_FILE_PRESENTATION + 0x0005
+#define AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX			AVS_OFFICESTUDIO_FILE_PRESENTATION + 0x0006
+#define AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM			AVS_OFFICESTUDIO_FILE_PRESENTATION + 0x0007
 
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET				0x0100
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0001
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0002
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0003
 #define AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0004
+#define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0005
+#define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0006
+#define AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM			AVS_OFFICESTUDIO_FILE_SPREADSHEET + 0x0007
 
 #define AVS_OFFICESTUDIO_FILE_CROSSPLATFORM				0x0200
 #define AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF			AVS_OFFICESTUDIO_FILE_CROSSPLATFORM + 0x0001

DesktopEditor/doctrenderer/docbuilder_p.h

@@ -872,6 +872,7 @@ namespace NSDoctRenderer
             oBuilder.WriteString(L"<m_sFontDir>");
             oBuilder.WriteEncodeXmlString(m_sX2tPath + L"/sdkjs/common");
             oBuilder.WriteString(L"</m_sFontDir>");
+            oBuilder.WriteString(L"<m_bIsNoBase64>true</m_bIsNoBase64>");
             oBuilder.WriteString(L"<m_sThemeDir>./sdkjs/slide/themes</m_sThemeDir><m_bDontSaveAdditional>true</m_bDontSaveAdditional>");
             oBuilder.WriteString(params);
             oBuilder.WriteString(L"</TaskQueueDataConvert>");

Makefile

@@ -1,16 +1,29 @@
+PRODUCT_NAME ?= core
+PRODUCT_VERSION ?= 0.0.0
+BUILD_NUMBER ?= 0
+PACKAGE_NAME := $(PRODUCT_NAME)
+
+UNAME_M := $(shell uname -m)
+ifeq ($(UNAME_M),x86_64)
+	ARCHITECTURE := 64
+	ARCH_SUFFIX := x64
+endif
+ifneq ($(filter %86,$(UNAME_M)),)
+	ARCHITECTURE := 32
+	ARCH_SUFFIX := x86
+endif
+
 ifeq ($(OS),Windows_NT)
 	PLATFORM := win
 	EXEC_EXT := .exe
 	SHELL_EXT := .bat
 	SHARED_EXT := .dll
 	LIB_EXT := .lib
+	ARCH_EXT := .zip
 	MAKE := nmake
-	ifeq ($(PROCESSOR_ARCHITECTURE),AMD64)
-		ARCHITECTURE := 64
-	endif
-	ifeq ($(PROCESSOR_ARCHITECTURE),x86)
-		ARCHITECTURE := 32
-	endif
+	AR := 7z a -y
+	PACKAGE_VERSION := $(PRODUCT_VERSION).$(BUILD_NUMBER)
+	ARCH_REPO_DIR := windows
 else
 	UNAME_S := $(shell uname -s)
 	ifeq ($(UNAME_S),Linux)
@@ -19,14 +32,11 @@ else
 		SHELL_EXT := .sh
 		LIB_EXT := .a
 		LIB_PREFIX := lib
+		ARCH_EXT := .tar.gz
 		MAKE := make -j $(shell grep -c ^processor /proc/cpuinfo)
-	endif
-	UNAME_M := $(shell uname -m)
-	ifeq ($(UNAME_M),x86_64)
-		ARCHITECTURE := 64
-	endif
-	ifneq ($(filter %86,$(UNAME_M)),)
-		ARCHITECTURE := 32
+		AR := tar -zcvf
+		PACKAGE_VERSION := $(PRODUCT_VERSION)-$(BUILD_NUMBER)
+		ARCH_REPO_DIR := linux
 	endif
 endif
 
@@ -229,6 +239,18 @@ PDFREADER_DEP += $(HTMLRENDERER)
 
 PDFWRITER_DEP += $(UNICODECONVERTER)
 
+ARCHIVE := ./$(PACKAGE_NAME)$(ARCH_EXT)
+
+ARTIFACTS += build/*
+ARTIFACTS += Common/3dParty/*/$(TARGET)/build/*
+
+
+ifeq ($(OS),Windows_NT)
+ARTIFACTS += Common/3dParty/v8/$(TARGET)/*/*.dll
+else
+ARTIFACTS += Common/3dParty/v8/$(TARGET)/*.S
+endif
+
 #Template for next statment:
 #FOO_MAKE := $(basename $(FOO_PRO)).build/Makefile
 #$(FOO): $(FOO_MAKE)
@@ -241,7 +263,7 @@ $$(value $(1)): $$(value $(1)_MAKE)
 	cd $$(dir $$(value $(1)_MAKE)) && $(MAKE);
 endef
 
-.PHONY : all bin lib clean
+.PHONY : all bin lib clean deploy
 
 all: lib bin 
 
@@ -280,11 +302,24 @@ $(OOXMLSIGNATURE): $(OOXMLSIGNATURE_DEP)
 %.build/Makefile: %.pro
 	mkdir -p $(dir $@) && cd $(dir $@) && qmake -r $<
 
+$(ARCHIVE) : 
+	$(AR) $@ $(ARTIFACTS)
+
 clean:
-	rm -rf $(TARGETS)
+	rm -rf $(TARGETS) $(ARCHIVE)
 	for i in $(PROS); do \
 		if [ -d $$i -a -f $$i/Makefile ]; then \
 			cd $$i && $(MAKE) distclean; \
 		fi \
 done
 
+deploy: $(ARCHIVE)
+	aws s3 cp \
+		$(ARCHIVE) \
+		s3://repo-doc-onlyoffice-com/$(ARCH_REPO_DIR)/$(PACKAGE_NAME)/$(GIT_BRANCH)/$(PACKAGE_VERSION)/$(ARCH_SUFFIX)/ \
+		--acl public-read
+
+	aws s3 sync \
+		s3://repo-doc-onlyoffice-com/$(ARCH_REPO_DIR)/$(PACKAGE_NAME)/$(GIT_BRANCH)/$(PACKAGE_VERSION)/$(ARCH_SUFFIX)/  \
+		s3://repo-doc-onlyoffice-com/$(ARCH_REPO_DIR)/$(PACKAGE_NAME)/$(GIT_BRANCH)/latest/$(ARCH_SUFFIX)/ \
+		--acl public-read --delete

X2tConverter/src/ASCConverters.cpp

@@ -225,7 +225,86 @@ namespace NExtractTools
 
         return doct_bin2docx(sTempDoctFileEditor, sTo, sTemp, bFromChanges, sThemeDir, params);
     }
+	// dotx -> docx
+	int dotx2docx (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params)
+	{
+	   std::wstring sTempUnpackedDOCX = sTemp + FILE_SEPARATOR_STR + _T("docx_unpacked");
+       NSDirectory::CreateDirectory(sTempUnpackedDOCX);
 
+       int nRes = dotx2docx_dir(sFrom, sTempUnpackedDOCX, params);
+       if(SUCCEEDED_X2T(nRes))
+       {
+           COfficeUtils oCOfficeUtils(NULL);
+           if(S_OK == oCOfficeUtils.CompressFileOrDirectory(sTempUnpackedDOCX, sTo, true))
+               return 0;
+       }
+	   return AVS_FILEUTILS_ERROR_CONVERT;
+	}
+	int dotx2docx_dir (const std::wstring &sFrom, const std::wstring &sTo, InputParams& params)
+	{
+       COfficeUtils oCOfficeUtils(NULL);
+       if (S_OK == oCOfficeUtils.ExtractToDirectory(sFrom, sTo, NULL, 0))
+       {
+           std::wstring sContentTypesPath = sTo + FILE_SEPARATOR_STR + _T("[Content_Types].xml");
+           if(NSFile::CFileBinary::Exists(sContentTypesPath))
+           {
+               std::wstring sData;
+               if(NSFile::CFileBinary::ReadAllTextUtf8(sContentTypesPath, sData))
+               {
+                   std::wstring sCTFrom = _T("application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml");
+                   std::wstring sCTTo = _T("application/vnd.ms-word.document.macroEnabled.main+xml");
+
+                   sData = string_replaceAll(sData, sCTFrom, sCTTo);
+
+                   if(NSFile::CFileBinary::SaveToFile(sContentTypesPath, sData, true))
+                   {
+                       return 0;
+                   }
+               }
+           }
+       }
+       return AVS_FILEUTILS_ERROR_CONVERT;
+	}
+	// dotm -> docm
+	int dotm2docm (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params)
+	{
+	   std::wstring sTempUnpackedDOCM = sTemp + FILE_SEPARATOR_STR + _T("docm_unpacked");
+       NSDirectory::CreateDirectory(sTempUnpackedDOCM);
+
+       int nRes = dotm2docm_dir(sFrom, sTempUnpackedDOCM, params);
+       if(SUCCEEDED_X2T(nRes))
+       {
+           COfficeUtils oCOfficeUtils(NULL);
+           if(S_OK == oCOfficeUtils.CompressFileOrDirectory(sTempUnpackedDOCM, sTo, true))
+               return 0;
+       }
+	   return AVS_FILEUTILS_ERROR_CONVERT;
+	}
+	int dotm2docm_dir (const std::wstring &sFrom, const std::wstring &sTo, InputParams& params)
+	{
+       COfficeUtils oCOfficeUtils(NULL);
+       if (S_OK == oCOfficeUtils.ExtractToDirectory(sFrom, sTo, NULL, 0))
+       {
+           std::wstring sContentTypesPath = sTo + FILE_SEPARATOR_STR + _T("[Content_Types].xml");
+           if(NSFile::CFileBinary::Exists(sContentTypesPath))
+           {
+               std::wstring sData;
+               if(NSFile::CFileBinary::ReadAllTextUtf8(sContentTypesPath, sData))
+               {
+                   std::wstring sCTFrom = _T("application/vnd.ms-word.template.macroEnabledTemplate.main+xml");
+                   std::wstring sCTTo = _T("application/vnd.ms-word.document.macroEnabled.main+xml");
+
+                   sData = string_replaceAll(sData, sCTFrom, sCTTo);
+
+                   if(NSFile::CFileBinary::SaveToFile(sContentTypesPath, sData, true))
+                   {
+                       return 0;
+                   }
+               }
+           }
+       }
+       return AVS_FILEUTILS_ERROR_CONVERT;
+	}
     // xslx -> bin
     int xlsx2xlst_bin (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params)
     {
@@ -347,6 +426,86 @@ namespace NExtractTools
 
         return xlst_bin2xlsx(sTempXlstFileEditor, sTo, sTemp, bFromChanges, sThemeDir, params);
     }
+	// xltx -> xlsx
+	int xltx2xlsx (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params)
+	{
+	   std::wstring sTempUnpackedXLSX = sTemp + FILE_SEPARATOR_STR + _T("xlsx_unpacked");
+       NSDirectory::CreateDirectory(sTempUnpackedXLSX);
+
+       int nRes = xltx2xlsx_dir(sFrom, sTempUnpackedXLSX, params);
+       if(SUCCEEDED_X2T(nRes))
+       {
+           COfficeUtils oCOfficeUtils(NULL);
+           if(S_OK == oCOfficeUtils.CompressFileOrDirectory(sTempUnpackedXLSX, sTo, true))
+               return 0;
+       }
+	   return AVS_FILEUTILS_ERROR_CONVERT;
+	}
+	int xltx2xlsx_dir (const std::wstring &sFrom, const std::wstring &sTo, InputParams& params)
+	{
+       COfficeUtils oCOfficeUtils(NULL);
+       if (S_OK == oCOfficeUtils.ExtractToDirectory(sFrom, sTo, NULL, 0))
+       {
+           std::wstring sContentTypesPath = sTo + FILE_SEPARATOR_STR + _T("[Content_Types].xml");
+           if(NSFile::CFileBinary::Exists(sContentTypesPath))
+           {
+               std::wstring sData;
+               if(NSFile::CFileBinary::ReadAllTextUtf8(sContentTypesPath, sData))
+               {
+                   std::wstring sCTFrom = _T("application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml");
+                   std::wstring sCTTo = _T("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml");
+
+                   sData = string_replaceAll(sData, sCTFrom, sCTTo);
+
+                   if(NSFile::CFileBinary::SaveToFile(sContentTypesPath, sData, true))
+                   {
+                       return 0;
+                   }
+               }
+           }
+       }
+       return AVS_FILEUTILS_ERROR_CONVERT;
+	}
+	// xltm -> xlsm
+	int xltm2xlsm (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params)
+	{
+	   std::wstring sTempUnpackedXLSM = sTemp + FILE_SEPARATOR_STR + _T("xlsm_unpacked");
+       NSDirectory::CreateDirectory(sTempUnpackedXLSM);
+
+       int nRes = xltm2xlsm_dir(sFrom, sTempUnpackedXLSM, params);
+       if(SUCCEEDED_X2T(nRes))
+       {
+           COfficeUtils oCOfficeUtils(NULL);
+           if(S_OK == oCOfficeUtils.CompressFileOrDirectory(sTempUnpackedXLSM, sTo, true))
+               return 0;
+       }
+	   return AVS_FILEUTILS_ERROR_CONVERT;
+	}
+	int xltm2xlsm_dir (const std::wstring &sFrom, const std::wstring &sTo, InputParams& params)
+	{
+       COfficeUtils oCOfficeUtils(NULL);
+       if (S_OK == oCOfficeUtils.ExtractToDirectory(sFrom, sTo, NULL, 0))
+       {
+           std::wstring sContentTypesPath = sTo + FILE_SEPARATOR_STR + _T("[Content_Types].xml");
+           if(NSFile::CFileBinary::Exists(sContentTypesPath))
+           {
+               std::wstring sData;
+               if(NSFile::CFileBinary::ReadAllTextUtf8(sContentTypesPath, sData))
+               {
+                   std::wstring sCTFrom = _T("application/vnd.ms-excel.sheet.macroEnabled.main+xml");
+                   std::wstring sCTTo = _T("application/vnd.ms-excel.template.macroEnabled.main+xml");
+
+                   sData = string_replaceAll(sData, sCTFrom, sCTTo);
+
+                   if(NSFile::CFileBinary::SaveToFile(sContentTypesPath, sData, true))
+                   {
+                       return 0;
+                   }
+               }
+           }
+       }
+       return AVS_FILEUTILS_ERROR_CONVERT;
+	}
     // pptx -> bin
     int pptx2pptt_bin (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params)
     {
@@ -833,21 +992,21 @@ namespace NExtractTools
 
 	// ppsx -> pptx
 	int ppsx2pptx (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params)
-   {
-	   std::wstring sTempUnpackedPPSX = sTemp + FILE_SEPARATOR_STR + _T("ppsx_unpacked");
-       NSDirectory::CreateDirectory(sTempUnpackedPPSX);
+	{
+	   std::wstring sTempUnpackedPPTX = sTemp + FILE_SEPARATOR_STR + _T("pptx_unpacked");
+       NSDirectory::CreateDirectory(sTempUnpackedPPTX);
 
-       int nRes = ppsx2pptx_dir(sFrom, sTempUnpackedPPSX, params);
+       int nRes = ppsx2pptx_dir(sFrom, sTempUnpackedPPTX, params);
        if(SUCCEEDED_X2T(nRes))
        {
            COfficeUtils oCOfficeUtils(NULL);
-           if(S_OK == oCOfficeUtils.CompressFileOrDirectory(sTempUnpackedPPSX, sTo, true))
+           if(S_OK == oCOfficeUtils.CompressFileOrDirectory(sTempUnpackedPPTX, sTo, true))
                return 0;
        }
 	   return AVS_FILEUTILS_ERROR_CONVERT;
-   }
+	}
 	int ppsx2pptx_dir (const std::wstring &sFrom, const std::wstring &sTo, InputParams& params)
-   {
+	{
        COfficeUtils oCOfficeUtils(NULL);
        if (S_OK == oCOfficeUtils.ExtractToDirectory(sFrom, sTo, NULL, 0))
        {
@@ -871,7 +1030,86 @@ namespace NExtractTools
        }
        return AVS_FILEUTILS_ERROR_CONVERT;
    }
+	// potx -> pptx
+	int potx2pptx (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params)
+	{
+	   std::wstring sTempUnpackedPPTX = sTemp + FILE_SEPARATOR_STR + _T("pptx_unpacked");
+       NSDirectory::CreateDirectory(sTempUnpackedPPTX);
 
+       int nRes = potx2pptx_dir(sFrom, sTempUnpackedPPTX, params);
+       if(SUCCEEDED_X2T(nRes))
+       {
+           COfficeUtils oCOfficeUtils(NULL);
+           if(S_OK == oCOfficeUtils.CompressFileOrDirectory(sTempUnpackedPPTX, sTo, true))
+               return 0;
+       }
+	   return AVS_FILEUTILS_ERROR_CONVERT;
+	}
+	int potx2pptx_dir (const std::wstring &sFrom, const std::wstring &sTo, InputParams& params)
+	{
+       COfficeUtils oCOfficeUtils(NULL);
+       if (S_OK == oCOfficeUtils.ExtractToDirectory(sFrom, sTo, NULL, 0))
+       {
+           std::wstring sContentTypesPath = sTo + FILE_SEPARATOR_STR + _T("[Content_Types].xml");
+           if(NSFile::CFileBinary::Exists(sContentTypesPath))
+           {
+               std::wstring sData;
+               if(NSFile::CFileBinary::ReadAllTextUtf8(sContentTypesPath, sData))
+               {
+                   std::wstring sCTFrom = _T("application/vnd.openxmlformats-officedocument.presentationml.template.main+xml");
+                   std::wstring sCTTo = _T("application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml");
+
+                   sData = string_replaceAll(sData, sCTFrom, sCTTo);
+
+                   if(NSFile::CFileBinary::SaveToFile(sContentTypesPath, sData, true))
+                   {
+                       return 0;
+                   }
+               }
+           }
+       }
+       return AVS_FILEUTILS_ERROR_CONVERT;
+	}
+	// potm -> pptm
+	int potm2pptm (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params)
+	{
+	   std::wstring sTempUnpackedPPTM = sTemp + FILE_SEPARATOR_STR + _T("pptm_unpacked");
+       NSDirectory::CreateDirectory(sTempUnpackedPPTM);
+
+       int nRes = potm2pptm_dir(sFrom, sTempUnpackedPPTM, params);
+       if(SUCCEEDED_X2T(nRes))
+       {
+           COfficeUtils oCOfficeUtils(NULL);
+           if(S_OK == oCOfficeUtils.CompressFileOrDirectory(sTempUnpackedPPTM, sTo, true))
+               return 0;
+       }
+	   return AVS_FILEUTILS_ERROR_CONVERT;
+	}
+	int potm2pptm_dir (const std::wstring &sFrom, const std::wstring &sTo, InputParams& params)
+	{
+       COfficeUtils oCOfficeUtils(NULL);
+       if (S_OK == oCOfficeUtils.ExtractToDirectory(sFrom, sTo, NULL, 0))
+       {
+           std::wstring sContentTypesPath = sTo + FILE_SEPARATOR_STR + _T("[Content_Types].xml");
+           if(NSFile::CFileBinary::Exists(sContentTypesPath))
+           {
+               std::wstring sData;
+               if(NSFile::CFileBinary::ReadAllTextUtf8(sContentTypesPath, sData))
+               {
+                   std::wstring sCTFrom = _T("application/vnd.ms-powerpoint.template.macroEnabled.main+xml");
+                   std::wstring sCTTo = _T("application/vnd.ms-powerpoint.presentation.macroEnabled.main+xml");
+
+                   sData = string_replaceAll(sData, sCTFrom, sCTTo);
+
+                   if(NSFile::CFileBinary::SaveToFile(sContentTypesPath, sData, true))
+                   {
+                       return 0;
+                   }
+               }
+           }
+       }
+       return AVS_FILEUTILS_ERROR_CONVERT;
+	}
 	// ppt -> pptx
 	int ppt2pptx (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params)
    {
@@ -1558,16 +1796,25 @@ namespace NExtractTools
             switch (OfficeFileFormatChecker.nFileType)
 			{
 				case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX:
+				case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM:
+				case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX:
+				case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM:
 				{
 					return docx2doct_bin(sResultDecryptFile, sTo, sTemp, params);
 				}break;
 				case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX:
+				case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM:
+				case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX:
+				case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM:
 				{
 					const std::wstring & sXmlOptions = params.getXmlOptions();
 					return xlsx2xlst_bin(sResultDecryptFile, sTo, sTemp, params);
                 }break;
 				case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX:
+				case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTM:
 				case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX:
+				case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX:
+                case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM:
 				{
 					return pptx2pptt_bin(sResultDecryptFile, sTo, sTemp,params);
 				}break;
@@ -1615,16 +1862,25 @@ namespace NExtractTools
                 switch (OfficeFileFormatChecker.nFileType)
                 {
                 case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX:
-                {
+                case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM:
+				case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX:
+                case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM:
+				{
                     return fromDocument(sResultDecryptFile, AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX, sTemp, params);
                 }break;
                 case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX:
+                case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM:
+                case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX:
+                case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM:
                 {
                     return fromSpreadsheet(sResultDecryptFile, AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX, sTemp, params);
                 }break;
                 case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX:
+                case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTM:
                 case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX:
-                {
+				case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX:
+                case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM:
+				{
                     return fromPresentation(sResultDecryptFile, AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX, sTemp, params);
                 }break;
                 }
@@ -2140,11 +2396,20 @@ namespace NExtractTools
        {
            std::wstring sDocxDir = sTemp + FILE_SEPARATOR_STR + _T("docx_unpacked");
            NSDirectory::CreateDirectory(sDocxDir);
-           if(AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX == nFormatFrom)
+           if (AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX == nFormatFrom ||
+			   AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM == nFormatFrom)
            {
                nRes = zip2dir(sFrom, sDocxDir);
            }
-           else if(AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC == nFormatFrom)
+           else if(AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX == nFormatFrom)
+           {
+               nRes = dotx2docx_dir(sFrom, sDocxDir, params);
+           }
+           else if(AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM == nFormatFrom)
+           {
+               nRes = dotm2docm_dir(sFrom, sDocxDir, params);
+           }
+		   else if(AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC == nFormatFrom)
            {
                nRes = doc2docx_dir(sFrom, sDocxDir, sTemp, params);
            }
@@ -2308,7 +2573,8 @@ namespace NExtractTools
            std::wstring sXlsxDir = sTemp + FILE_SEPARATOR_STR + _T("xlsx_unpacked");
            NSDirectory::CreateDirectory(sXlsxDir);
 		   bool isSavedXFile = false;
-           if(AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX == nFormatFrom)
+           if (AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX == nFormatFrom || 
+			   AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM == nFormatFrom)
            {
                nRes = zip2dir(sFrom, sXlsxDir);
 			   if (SUCCEEDED_X2T(nRes) && params.getSaveXFile())
@@ -2317,7 +2583,15 @@ namespace NExtractTools
 				   isSavedXFile = true;
 			   }
            }
-           else if(AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS == nFormatFrom)
+		   else if(AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX == nFormatFrom)
+		   {
+               nRes = xltx2xlsx_dir(sFrom, sXlsxDir, params);
+		   }
+		   else if(AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM == nFormatFrom)
+		   {
+               nRes = xltm2xlsm_dir(sFrom, sXlsxDir, params);
+		   }
+		   else if(AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS == nFormatFrom)
            {
                nRes = xls2xlsx_dir(sFrom, sXlsxDir, sTemp, params);
            }
@@ -2436,11 +2710,12 @@ namespace NExtractTools
        int nRes = 0;
        std::wstring sPptxDir = sTemp + FILE_SEPARATOR_STR + _T("pptx_unpacked");
        NSDirectory::CreateDirectory(sPptxDir);
-       if(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX == nFormatFrom)
+       if (AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX == nFormatFrom ||
+		   AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTM == nFormatFrom)
        {
            nRes = zip2dir(sFrom, sPptxDir);
        }
-       else if(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT == nFormatFrom)
+	   else if(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT == nFormatFrom)
        {
            nRes = ppt2pptx_dir(sFrom, sPptxDir, sTemp, params);
        }
@@ -2452,7 +2727,15 @@ namespace NExtractTools
        {
            nRes = ppsx2pptx_dir(sFrom, sPptxDir, params);
        }
-       else
+       else if(AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX == nFormatFrom)
+       {
+           nRes = potx2pptx_dir(sFrom, sPptxDir, params);
+       }
+       else if(AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM == nFormatFrom)
+       {
+           nRes = potm2pptm_dir(sFrom, sPptxDir, params);
+       }
+	   else
            nRes = AVS_FILEUTILS_ERROR_CONVERT;
        if(SUCCEEDED_X2T(nRes))
        {
@@ -2776,6 +3059,34 @@ namespace NExtractTools
 			case TCD_PPTT2PPTX:
 			{
 				result =  pptt2pptx (sFileFrom, sFileTo, sTempDir, bFromChanges, sThemeDir, oInputParams);
+			}break;		
+			case TCD_DOTX2DOCX:
+			{
+				result =  dotx2docx (sFileFrom, sFileTo, sTempDir, oInputParams);
+			}break;
+			case TCD_DOTM2DOCM:
+			{
+				result =  dotm2docm (sFileFrom, sFileTo, sTempDir, oInputParams);
+			}break;
+			case TCD_XLTX2XLSX:
+			{
+				result =  xltx2xlsx (sFileFrom, sFileTo, sTempDir, oInputParams);
+			}break;
+			case TCD_XLTM2XLSM:
+			{
+				result =  xltm2xlsm (sFileFrom, sFileTo, sTempDir, oInputParams);
+			}break;
+			case TCD_PPSX2PPTX:
+			{
+				result =  ppsx2pptx (sFileFrom, sFileTo, sTempDir, oInputParams);
+			}break;
+			case TCD_POTX2PPTX:
+			{
+				result =  potx2pptx (sFileFrom, sFileTo, sTempDir, oInputParams);
+			}break;
+			case TCD_POTM2PPTM:
+			{
+				result =  potm2pptm (sFileFrom, sFileTo, sTempDir, oInputParams);
 			}break;
 			case TCD_ZIPDIR:
 			{
@@ -2837,10 +3148,6 @@ namespace NExtractTools
 			{
                 result =  zip2dir (sFileFrom, NSDirectory::GetFolderPath(sFileTo));
 			}break;
-			case TCD_PPSX2PPTX:
-			{
-				result =  ppsx2pptx (sFileFrom, sFileTo, sTempDir, oInputParams);
-			}break;
 			case TCD_PPT2PPTX:
 			{
 				result =  ppt2pptx (sFileFrom, sFileTo, sTempDir, oInputParams);

X2tConverter/src/ASCConverters.h

@@ -55,12 +55,22 @@ namespace NExtractTools
     int doct_bin2docx_dir	(const std::wstring &sFrom, const std::wstring &sToResult, const std::wstring &sTo, bool bFromChanges, const std::wstring &sThemeDir, InputParams& params);
 	int doct2docx			(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, bool bFromChanges, const std::wstring &sThemeDir, InputParams& params);
 
-    int xlsx2xlst_bin		(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
+	int dotx2docx			(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
+    int dotx2docx_dir		(const std::wstring &sFrom, const std::wstring &sTo, InputParams& params);
+    int dotm2docm			(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
+    int dotm2docm_dir		(const std::wstring &sFrom, const std::wstring &sTo, InputParams& params);
+
+	int xlsx2xlst_bin		(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
 	int xlsx_dir2xlst_bin	(const std::wstring &sFrom, const std::wstring &sTo, InputParams& params, bool bXmlOptions);
     int xlsx2xlst			(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
 	int xlst_bin2xlsx		(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, bool bFromChanges, const std::wstring &sThemeDir, InputParams& params);
     int xlst_bin2xlsx_dir	(const std::wstring &sFrom, const std::wstring &sToResult, const std::wstring &sTo, bool bFromChanges, const std::wstring &sThemeDir, InputParams& params);
 	int xlst2xlsx			(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, bool bFromChanges, const std::wstring &sThemeDir, InputParams& params);
+   
+	int xltx2xlsx			(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
+    int xltx2xlsx_dir		(const std::wstring &sFrom, const std::wstring &sTo, InputParams& params);
+    int xltm2xlsm			(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
+    int xltm2xlsm_dir		(const std::wstring &sFrom, const std::wstring &sTo, InputParams& params);
 
     int pptx2pptt_bin		(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
     int pptx_dir2pptt_bin	(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
@@ -80,6 +90,10 @@ namespace NExtractTools
 
     int ppsx2pptx		(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
     int ppsx2pptx_dir   (const std::wstring &sFrom, const std::wstring &sTo, InputParams& params);
+    int potx2pptx		(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
+    int potx2pptx_dir   (const std::wstring &sFrom, const std::wstring &sTo, InputParams& params);
+    int potm2pptm		(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
+    int potm2pptm_dir   (const std::wstring &sFrom, const std::wstring &sTo, InputParams& params);
 
     int ppt2pptx		(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);
     int ppt2pptx_dir    (const std::wstring &sFrom, const std::wstring &sTo, const std::wstring &sTemp, InputParams& params);

X2tConverter/src/cextracttools.cpp

@@ -109,25 +109,45 @@ namespace NExtractTools
                 switch (OfficeFileFormatChecker.nFileType)
 				{
 				case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX:
+				case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCM:
+				case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTX:
+				case AVS_OFFICESTUDIO_FILE_DOCUMENT_DOTM:
 					{
 							 if (0 == sExt2.compare(_T(".doct")))		res = TCD_DOCX2DOCT;
 						else if (0 == sExt2.compare(_T(".bin")))		res = TCD_DOCX2DOCT_BIN;
 						else if (0 == sExt2.compare(_T(".rtf")))		res = TCD_DOCX2RTF;
                         else if (0 == sExt2.compare(_T(".odt")))		res = TCD_DOCX2ODT;
+                        else if (0 == sExt2.compare(_T(".docx")))		res = TCD_DOTX2DOCX;
+                        else if (0 == sExt2.compare(_T(".docm")))		res = TCD_DOTM2DOCM;
                     }break;
 				case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX:
+				case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSM:
+				case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTX:
+				case AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLTM:
 					{
 							 if (0 == sExt2.compare(_T(".xlst")))		res = TCD_XLSX2XLST;
 						else if (0 == sExt2.compare(_T(".bin")))		res = TCD_XLSX2XLST_BIN;
 						else if (0 == sExt2.compare(_T(".csv")))		res = TCD_XLSX2CSV;
                         else if (0 == sExt2.compare(_T(".ods")))		res = TCD_XLSX2ODS;
+                        else if (0 == sExt2.compare(_T(".xlsx")))		res = TCD_XLTX2XLSX;
+                        else if (0 == sExt2.compare(_T(".xlsm")))		res = TCD_XLTM2XLSM;
                     }break;
                 case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX:
+                case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTM:
 				case AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX:
+                case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX:
+                case AVS_OFFICESTUDIO_FILE_PRESENTATION_POTM:
 					{
 							 if (0 == sExt2.compare(_T(".bin")))		res = TCD_PPTX2PPTT_BIN;
 						else if (0 == sExt2.compare(_T(".pptt")))		res = TCD_PPTX2PPTT;
-						else if (0 == sExt2.compare(_T(".pptx")))		res = TCD_PPSX2PPTX;
+						else if (0 == sExt2.compare(_T(".pptx")))
+						{
+							if (OfficeFileFormatChecker.nFileType == AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX)
+								res = TCD_PPSX2PPTX;
+							if (OfficeFileFormatChecker.nFileType == AVS_OFFICESTUDIO_FILE_PRESENTATION_POTX)
+								res = TCD_POTX2PPTX;
+						}
+						else if (0 == sExt2.compare(_T(".pptm")))		res = TCD_POTM2PPTM;
                         else if (0 == sExt2.compare(_T(".odp")))		res = TCD_PPTX2ODP;
 					}break;
 				case AVS_OFFICESTUDIO_FILE_TEAMLAB_DOCY:

X2tConverter/src/cextracttools.h

@@ -62,16 +62,23 @@ namespace NExtractTools
         TCD_DOCT2DOCX,
         TCD_DOCX2DOCT_BIN,
         TCD_DOCT_BIN2DOCX,
+        TCD_DOTX2DOCX,
+        TCD_DOTM2DOCM,
 
         TCD_XLSX2XLST,
         TCD_XLST2XLSX,
         TCD_XLSX2XLST_BIN,
         TCD_XLST_BIN2XLSX,
+        TCD_XLTX2XLSX,
+        TCD_XLTM2XLSM,
 
         TCD_PPTX2PPTT,
         TCD_PPTT2PPTX,
         TCD_PPTX2PPTT_BIN,
         TCD_PPTT_BIN2PPTX,
+        TCD_PPSX2PPTX,
+		TCD_POTX2PPTX,
+		TCD_POTM2PPTM,
 
         TCD_ZIPDIR,
         TCD_UNZIPDIR,
@@ -89,7 +96,6 @@ namespace NExtractTools
         TCD_T2BIN,
         TCD_BIN2T,
 
-        TCD_PPSX2PPTX,
 //ppt 2
         TCD_PPT2PPTX,
         TCD_PPT2PPTT,
@@ -136,7 +142,7 @@ namespace NExtractTools
         TCD_PPTT2ODP,
         TCD_PPTX_BIN2ODP,
 		
-	TCD_XML2DOCX,
+		TCD_XML2DOCX,
         TCD_DOCX2XML,
 //
 		TCD_MSCRYPT2,
@@ -718,7 +724,7 @@ namespace NExtractTools
 
                 int nDelimitersCount = 6;
                 int aDelimiters[6] = { 0, 0, 0, 0, 0, 0 };
-                for(int i = 0; i < dwBytesRead; ++i)
+                for (DWORD i = 0; i < dwBytesRead; ++i)
                 {
                     char cCurChar = pBuffer[i];
                     if ('\n' == cCurChar)
@@ -900,7 +906,25 @@ namespace NExtractTools
         else if (0 == sArg3.compare(_T("ppsx2pptx"))) {
             res = TCD_PPSX2PPTX;
         }
-        else if (0 == sArg3.compare(_T("ppt2pptx"))) {
+        else if (0 == sArg3.compare(_T("potx2pptx"))) {
+            res = TCD_POTX2PPTX;
+        }
+        else if (0 == sArg3.compare(_T("potm2pptm"))) {
+            res = TCD_POTM2PPTM;
+        }
+        else if (0 == sArg3.compare(_T("xltx2xlsx"))) {
+            res = TCD_XLTX2XLSX;
+        }
+        else if (0 == sArg3.compare(_T("xltm2xlsm"))) {
+            res = TCD_XLTM2XLSM;
+        }
+        else if (0 == sArg3.compare(_T("dotx2docx"))) {
+            res = TCD_DOTX2DOCX;
+        }
+        else if (0 == sArg3.compare(_T("dotm2docm"))) {
+            res = TCD_DOTM2DOCM;
+        }
+		else if (0 == sArg3.compare(_T("ppt2pptx"))) {
             res = TCD_PPT2PPTX;
         }
         else if (0 == sArg3.compare(_T("doc2docx"))) {

XlsxSerializerCom/Reader/BinaryWriter.h

@@ -67,7 +67,7 @@ namespace BinXlsxRW
 			int nCurPos = 0;
 			for(size_t i = 0, length = oTableParts.m_arrItems.size(); i < length; ++i)
 				WriteTablePart(oWorksheet, *oTableParts.m_arrItems[i]);
-		};
+        }
 		void WriteTablePart(const OOX::Spreadsheet::CWorksheet& oWorksheet, const OOX::Spreadsheet::CTablePart& oTablePart)
 		{
 			int nCurPos = 0;
@@ -578,13 +578,13 @@ namespace BinXlsxRW
 	public:
 		BinaryStyleTableWriter(NSBinPptxRW::CBinaryFileWriter &oCBufferedStream, NSFontCutter::CEmbeddedFontsManager* pEmbeddedFontsManager):m_oBcw(oCBufferedStream),m_pEmbeddedFontsManager(pEmbeddedFontsManager)
 		{
-		};
+        }
 		void Write(OOX::Spreadsheet::CStyles& styles, PPTX::Theme* pTheme, DocWrapper::FontProcessor& oFontProcessor)
 		{
 			int nStart = m_oBcw.WriteItemWithLengthStart();
 			WriteStylesContent(styles, pTheme, oFontProcessor);
 			m_oBcw.WriteItemWithLengthEnd(nStart);
-		};
+        }
 		void WriteStylesContent(OOX::Spreadsheet::CStyles& styles, PPTX::Theme* pTheme, DocWrapper::FontProcessor& oFontProcessor)
 		{
 			int nCurPos;
@@ -656,7 +656,7 @@ namespace BinXlsxRW
 				WriteTableStyles(styles.m_oTableStyles.get());
 				m_oBcw.WriteItemEnd(nCurPos);
 			}
-		};
+        }
 		void WriteBorders(const OOX::Spreadsheet::CBorders& borders, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* pTheme)
 		{
 			int nCurPos = 0;
@@ -667,7 +667,7 @@ namespace BinXlsxRW
 				WriteBorder(*pBorder, pIndexedColors, pTheme);
 				m_oBcw.WriteItemEnd(nCurPos);
 			}
-		};
+        }
 		void WriteBorder(const OOX::Spreadsheet::CBorder& border, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* pTheme)
 		{
 			int nCurPos = 0;
@@ -741,7 +741,7 @@ namespace BinXlsxRW
 				m_oBcw.m_oStream.WriteBOOL(border.m_oOutline->ToBool());
 				m_oBcw.WriteItemEnd(nCurPos);
 			}
-		};
+        }
 		void WriteBorderProp(const OOX::Spreadsheet::CBorderProp& borderProp, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* pTheme)
 		{
 			int nCurPos = 0;
@@ -761,7 +761,7 @@ namespace BinXlsxRW
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
 				m_oBcw.m_oStream.WriteBYTE((BYTE)borderProp.m_oStyle->GetValue());
 			}
-		};
+        }
 		void WriteCellStyleXfs(const OOX::Spreadsheet::CCellStyleXfs& cellStyleXfs)
 		{
 			int nCurPos = 0;
@@ -791,7 +791,7 @@ namespace BinXlsxRW
 					m_oBcw.WriteItemEnd(nCurPos);
 				}
 			}
-		};
+        }
 		void WriteXfs(const OOX::Spreadsheet::CXfs& xfs)
 		{
 			int nCurPos = 0;
@@ -888,7 +888,7 @@ namespace BinXlsxRW
 				WriteAligment(xfs.m_oAligment.get());
 				m_oBcw.WriteItemWithLengthEnd(nCurPos);
 			}
-		};
+        }
 		void WriteAligment(const OOX::Spreadsheet::CAligment& aligment)
 		{
 			int nCurPos = 0;
@@ -952,7 +952,7 @@ namespace BinXlsxRW
 					WriteFill(*pFill, pIndexedColors, pTheme, false);
 					m_oBcw.WriteItemEnd(nCurPos);
 			}
-		};
+        }
 		void WriteFill(const OOX::Spreadsheet::CFill& fill, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* pTheme, bool bPriorityBg = false)
 		{
 			int nCurPos = 0;
@@ -1002,7 +1002,7 @@ namespace BinXlsxRW
 				m_oBcw.WriteItemEnd(nCurPos2);
 				m_oBcw.WriteItemEnd(nCurPos);
 			}
-		};
+        }
 		void WriteFonts(const OOX::Spreadsheet::CFonts& fonts, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* pTheme, DocWrapper::FontProcessor& oFontProcessor)
 		{
 			int nCurPos = 0;
@@ -1013,7 +1013,7 @@ namespace BinXlsxRW
 				WriteFont(*pFont, pIndexedColors, pTheme, oFontProcessor);
 				m_oBcw.WriteItemEnd(nCurPos);
 			}
-		};
+        }
 		void WriteFont(const OOX::Spreadsheet::CFont& font, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* theme, DocWrapper::FontProcessor& oFontProcessor)
 		{
 			int nCurPos = 0;
@@ -1092,7 +1092,7 @@ namespace BinXlsxRW
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
 				m_oBcw.m_oStream.WriteBYTE(font.m_oVertAlign->m_oVerticalAlign->GetValue());
 			}
-		};
+        }
 		void WriteNumFmts(const OOX::Spreadsheet::CNumFmts& numFmts)
 		{
 			int nCurPos = 0;
@@ -1103,7 +1103,7 @@ namespace BinXlsxRW
 				WriteNumFmt(*pNumFmt);
 				m_oBcw.WriteItemEnd(nCurPos);
 			}
-		};
+        }
 		void WriteNumFmt(const OOX::Spreadsheet::CNumFmt& numFmt)
 		{
 			int nCurPos = 0;
@@ -1125,7 +1125,7 @@ namespace BinXlsxRW
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Long);
 				m_oBcw.m_oStream.WriteLONG(numFmt.m_oNumFmtId->GetValue());
 			}
-		};
+        }
 		void WriteCellStyles(const OOX::Spreadsheet::CCellStyles& oCellStyles)
 		{
 			int nCurPos = 0;
@@ -1190,7 +1190,7 @@ namespace BinXlsxRW
 				WriteDxf(*pDxf, pIndexedColors, pTheme, oFontProcessor);
 				m_oBcw.WriteItemEnd(nCurPos);
 			}
-		};
+        }
 		void WriteDxf(const OOX::Spreadsheet::CDxf& oDxf, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* pTheme, DocWrapper::FontProcessor& oFontProcessor)
 		{
 			int nCurPos = 0;
@@ -1328,13 +1328,13 @@ namespace BinXlsxRW
 	public:
 		BinarySharedStringTableWriter(NSBinPptxRW::CBinaryFileWriter &oCBufferedStream, NSFontCutter::CEmbeddedFontsManager* pEmbeddedFontsManager):m_oBcw(oCBufferedStream),m_pEmbeddedFontsManager(pEmbeddedFontsManager)
 		{
-		};
+        }
 		void Write(OOX::Spreadsheet::CSharedStrings& sharedString, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* pTheme, DocWrapper::FontProcessor& oFontProcessor)
 		{
 			int nStart = m_oBcw.WriteItemWithLengthStart();
 			WriteSharedStrings(sharedString, pIndexedColors, pTheme, oFontProcessor);
 			m_oBcw.WriteItemWithLengthEnd(nStart);
-		};
+        }
 		void WriteSharedStrings(OOX::Spreadsheet::CSharedStrings& sharedString, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* pTheme, DocWrapper::FontProcessor& oFontProcessor)
 		{
 			int nCurPos;
@@ -1349,7 +1349,7 @@ namespace BinXlsxRW
 					m_oBcw.WriteItemWithLengthEnd(nCurPos);
 				}
 			}
-		};
+        }
 		void WriteSharedString(OOX::Spreadsheet::CSi& si, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* pTheme, DocWrapper::FontProcessor& oFontProcessor)
 		{
 			int nCurPos;
@@ -1373,7 +1373,7 @@ namespace BinXlsxRW
 						m_pEmbeddedFontsManager->CheckString(pText->m_sText);
 				}
 			}
-		};
+        }
 		void WriteRun(OOX::Spreadsheet::CRun& run, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* pTheme, DocWrapper::FontProcessor& oFontProcessor)
 		{
 			int nCurPos;
@@ -1397,7 +1397,7 @@ namespace BinXlsxRW
 						m_pEmbeddedFontsManager->CheckString(pText->m_sText);
 				}
 			}
-		};
+        }
 		void WriteRPr(const OOX::Spreadsheet::CRPr& rPr, OOX::Spreadsheet::CIndexedColors* pIndexedColors, PPTX::Theme* pTheme, DocWrapper::FontProcessor& oFontProcessor)
 		{
 			int nCurPos = 0;
@@ -1475,7 +1475,7 @@ namespace BinXlsxRW
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
 				m_oBcw.m_oStream.WriteBYTE(rPr.m_oVertAlign->m_oVerticalAlign->GetValue());
 			}
-		};
+        }
 
 	};
 	class BinaryWorkbookTableWriter
@@ -1528,11 +1528,15 @@ namespace BinXlsxRW
 			{
 				nCurPos = m_oBcw.WriteItemStart(c_oSerWorkbookTypes::VbaProject);
 
-				smart_ptr<OOX::VbaProject> vbaProject = fileVbaProject.smart_dynamic_cast<OOX::VbaProject>();
-				WriteVbaProject (vbaProject);
-				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+                smart_ptr<OOX::VbaProject> vbaProject = fileVbaProject.smart_dynamic_cast<OOX::VbaProject>();
+
+                m_oBcw.m_oStream.StartRecord(0);
+                vbaProject->toPPTY(&m_oBcw.m_oStream);
+                m_oBcw.m_oStream.EndRecord();
+
+                m_oBcw.WriteItemWithLengthEnd(nCurPos);
 			}
-		};
+        }
 		void WriteWorkbookPr(const OOX::Spreadsheet::CWorkbookPr& workbookPr)
 		{
 			//Date1904
@@ -1549,7 +1553,7 @@ namespace BinXlsxRW
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
 				m_oBcw.m_oStream.WriteBOOL(workbookPr.m_oDateCompatibility->ToBool());
 			}
-		};
+        }
 		void WriteBookViews(const OOX::Spreadsheet::CBookViews& bookViews)
 		{
 			int nCurPos;
@@ -1561,7 +1565,7 @@ namespace BinXlsxRW
 				WriteWorkbookView(*pWorkbookView);
 				m_oBcw.WriteItemWithLengthEnd(nCurPos);
 			}
-		};
+        }
 		void WriteWorkbookView(const OOX::Spreadsheet::CWorkbookView& workbookView)
 		{
 			//ActiveTab
@@ -1571,7 +1575,7 @@ namespace BinXlsxRW
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Long);
 				m_oBcw.m_oStream.WriteLONG(workbookView.m_oActiveTab->GetValue());
 			}
-		};
+        }
 		void WriteDefinedNames(const OOX::Spreadsheet::CDefinedNames& definedNames)
 		{
 			int nCurPos;
@@ -1583,7 +1587,7 @@ namespace BinXlsxRW
 				WriteDefinedName(*pDefinedName);
 				m_oBcw.WriteItemWithLengthEnd(nCurPos);
 			}
-		};
+        }
 		void WriteExternalReferences(const OOX::Spreadsheet::CExternalReferences& externalReferences, OOX::Spreadsheet::CWorkbook& workbook)
 		{
 			int nCurPos;
@@ -1649,7 +1653,7 @@ namespace BinXlsxRW
 					}
 				}
 			}
-		};
+        }
 		void WriteExternalBook(const OOX::Spreadsheet::CExternalBook& externalBook, const std::wstring& sLink)
 		{
 			int nCurPos = 0;
@@ -1972,18 +1976,6 @@ namespace BinXlsxRW
 				m_oBcw.m_oStream.WriteStringW(definedName.m_oComment.get2());
 			}
 		}
-		void WriteVbaProject(smart_ptr<OOX::VbaProject> & fileVbaProject)
-		{
-			std::wstring file_name = fileVbaProject->filename().GetFilename();
-			
-			m_oBcw.m_oStream.WriteBYTE(c_oSerWorkbookVbaProjectTypes::Name);
-			m_oBcw.m_oStream.WriteStringW(file_name);
-	
-			//... todooo write parsing vba project
-			
-			//copy file bin
-			fileVbaProject->copy_to(m_oBcw.m_oStream.m_pCommon->m_pImageManager->m_strDstMedia);
-		}
 	};
 	class BinaryWorksheetTableWriter
 	{
@@ -4129,13 +4121,13 @@ namespace BinXlsxRW
 	public:
 		BinaryCalcChainTableWriter(NSBinPptxRW::CBinaryFileWriter &oCBufferedStream) : m_oBcw(oCBufferedStream)
 		{
-		};
+        }
 		void Write(OOX::Spreadsheet::CCalcChain& pCalcChain)
 		{
 			int nStart = m_oBcw.WriteItemWithLengthStart();
 			WriteCalcChainTableContent(pCalcChain);
 			m_oBcw.WriteItemWithLengthEnd(nStart);
-		};
+        }
 		void WriteCalcChainTableContent(OOX::Spreadsheet::CCalcChain& pCalcChain)
 		{
 			int nCurPos;
@@ -4146,7 +4138,7 @@ namespace BinXlsxRW
 				WriteCalcChain(*pCalcChain.m_arrItems[i]);
 				m_oBcw.WriteItemWithLengthEnd(nCurPos);
 			}
-		};
+        }
 		void WriteCalcChain(OOX::Spreadsheet::CCalcCell& oCalcCell)
 		{
 			//Array
@@ -4191,7 +4183,7 @@ namespace BinXlsxRW
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
 				m_oBcw.m_oStream.WriteBOOL(oCalcCell.m_oNewThread->ToBool());
 			}
-		};
+        }
 	};
 	class BinaryOtherTableWriter
 	{
@@ -4225,13 +4217,13 @@ namespace BinXlsxRW
 				m_pTheme				(pTheme),
 				m_pOfficeDrawingConverter(pOfficeDrawingConverter)
 		{
-		};
+        }
 		void Write()
 		{
 			int nStart = m_oBcw.WriteItemWithLengthStart();
 			WriteOtherTableContent();
 			m_oBcw.WriteItemWithLengthEnd(nStart);
-		};
+        }
 		void WriteOtherTableContent()
 		{
 			int nCurPos;
@@ -4252,7 +4244,7 @@ namespace BinXlsxRW
 					m_pTheme->toPPTY(&m_oBcw.m_oStream);
 				m_oBcw.WriteItemWithLengthEnd(nCurPos);
 			}
-		};
+        }
 	};
 	class BinaryFileWriter {
 	private:
@@ -4279,7 +4271,8 @@ namespace BinXlsxRW
             std::wstring mediaDir = path.GetDirectory() + L"media";
 			NSDirectory::CreateDirectory(mediaDir);
 
-			pOfficeDrawingConverter->SetMediaDstPath(mediaDir);
+            pOfficeDrawingConverter->SetDstPath(path.GetDirectory() + FILE_SEPARATOR_STR + L"word");
+            pOfficeDrawingConverter->SetMediaDstPath(mediaDir);
 
 			long nGrowSize = 1 * 1024 * 1024;//1мб
 			NSBinPptxRW::CBinaryFileWriter& oBufferedStream = *pOfficeDrawingConverter->m_pBinaryWriter;

XlsxSerializerCom/Writer/BinaryReader.h

@@ -56,8 +56,8 @@ namespace BinXlsxRW {
         std::wstring sPath;
 		int nIndex;
         std::map<OOX::Spreadsheet::CDrawing*, std::wstring> mapDrawings;
-	public:
-		ImageObject()
+
+        ImageObject()
 		{
 		}
         ImageObject(std::wstring& _sPath, int _nIndex)
@@ -75,8 +75,8 @@ namespace BinXlsxRW {
 		OOX::Spreadsheet::CPivotCacheRecords* pRecords;
 		long nCacheId;
 		OOX::Spreadsheet::CPivotTable* pTable;
-	public:
-		PivotCachesTemp()
+
+        PivotCachesTemp()
 		{
 			nId = -1;
 			pDefinitionData = NULL;
@@ -212,7 +212,7 @@ namespace BinXlsxRW {
 
 				pOfficeArtExtension->m_sUri.Init();
 				pOfficeArtExtension->m_sUri->append(_T("{504A1905-F514-4f6f-8877-14C23A59335A}"));
-				pOfficeArtExtension->m_sAdditionalNamespace = _T(" xmlns:x14=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/main\"");
+				pOfficeArtExtension->m_sAdditionalNamespace = _T("xmlns:x14=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/main\"");
 				pTable->m_oExtLst.Init();
 				pTable->m_oExtLst->m_arrExt.push_back(pOfficeArtExtension);
 			}
@@ -1515,7 +1515,7 @@ namespace BinXlsxRW {
 		int Read()
 		{
 			return ReadTable(&BinaryWorkbookTableReader::ReadWorkbookTableContent, this);
-		};
+        }
 		int ReadWorkbookTableContent(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -1548,12 +1548,19 @@ namespace BinXlsxRW {
 			}
 			else if(c_oSerWorkbookTypes::VbaProject == type)
 			{
-				res = Read1(length, &BinaryWorkbookTableReader::ReadVbaProject, this, poResult);
-			}
+                smart_ptr<OOX::VbaProject> oFileVbaProject(new OOX::VbaProject());
+
+                oFileVbaProject->fromPPTY(&m_oBufferedStream);
+
+                smart_ptr<OOX::File> oFile = oFileVbaProject.smart_dynamic_cast<OOX::File>();
+                const OOX::RId oRId = m_oWorkbook.Add(oFile);
+
+                m_oWorkbook.m_bMacroEnabled = true;
+            }
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadWorkbookPr(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -1570,7 +1577,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadBookViews(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -1660,7 +1667,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadDefinedNames(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -1673,7 +1680,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadDefinedName(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CDefinedName* pDefinedName = static_cast<OOX::Spreadsheet::CDefinedName*>(poResult);
@@ -1706,7 +1713,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadExternalBook(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CExternalLink* extLink = static_cast<OOX::Spreadsheet::CExternalLink*>(poResult);
@@ -1741,7 +1748,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadExternalSheetNames(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CExternalSheetNames* pSheetNames = static_cast<OOX::Spreadsheet::CExternalSheetNames*>(poResult);
@@ -1756,7 +1763,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadExternalDefinedNames(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CExternalDefinedNames* pDefinedNames = static_cast<OOX::Spreadsheet::CExternalDefinedNames*>(poResult);
@@ -1770,7 +1777,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadExternalDefinedName(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CExternalDefinedName* pDefinedName = static_cast<OOX::Spreadsheet::CExternalDefinedName*>(poResult);
@@ -1793,7 +1800,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadExternalSheetDataSet(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CExternalSheetDataSet* pSheetDataSet = static_cast<OOX::Spreadsheet::CExternalSheetDataSet*>(poResult);
@@ -1807,7 +1814,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadExternalSheetData(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CExternalSheetData* pSheetData = static_cast<OOX::Spreadsheet::CExternalSheetData*>(poResult);
@@ -1831,7 +1838,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadExternalRow(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CExternalRow* pRow = static_cast<OOX::Spreadsheet::CExternalRow*>(poResult);
@@ -1850,7 +1857,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadExternalCell(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CExternalCell* pCell = static_cast<OOX::Spreadsheet::CExternalCell*>(poResult);
@@ -1873,7 +1880,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadOleLink(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CExternalLink* extLink = static_cast<OOX::Spreadsheet::CExternalLink*>(poResult);
@@ -1908,7 +1915,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadOleItem(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::COleItem* pOleItem = static_cast<OOX::Spreadsheet::COleItem*>(poResult);
@@ -1936,7 +1943,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadDdeLink(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CDdeLink* ddeLink = static_cast<OOX::Spreadsheet::CDdeLink*>(poResult);
@@ -1964,7 +1971,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadDdeItem(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CDdeItem* pDdeItem = static_cast<OOX::Spreadsheet::CDdeItem*>(poResult);
@@ -1997,7 +2004,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadDdeValues(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CDdeValues* pDdeValues = static_cast<OOX::Spreadsheet::CDdeValues*>(poResult);
@@ -2021,7 +2028,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadDdeValue(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CDdeValue* pDdeValue = static_cast<OOX::Spreadsheet::CDdeValue*>(poResult);
@@ -2040,7 +2047,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadPivotCaches(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -2099,31 +2106,6 @@ namespace BinXlsxRW {
 				res = c_oSerConstants::ReadUnknown;
 			return res;
 		}
-		int ReadVbaProject(BYTE type, long length, void* poResult)
-		{
-			int res = c_oSerConstants::ReadOk;
-			if(c_oSerWorkbookVbaProjectTypes::Name == type)
-			{
-				std::wstring file_name = m_oBufferedStream.GetString4(length);
-
-				OOX::CPath inputPath = m_oBufferedStream.m_strFolder + FILE_SEPARATOR_STR + _T("media")  + FILE_SEPARATOR_STR + file_name;
-                OOX::CPath outputPath = m_sDestinationDir + FILE_SEPARATOR_STR + _T("xl")  + FILE_SEPARATOR_STR + _T("vbaProject.bin");
-
-				NSFile::CFileBinary::Copy(inputPath.GetPath(), outputPath.GetPath());
-
-				smart_ptr<OOX::VbaProject> oFileVbaProject(new OOX::VbaProject());
-				oFileVbaProject->set_filename(outputPath.GetPath());
-				
-				smart_ptr<OOX::File> oFile = oFileVbaProject.smart_dynamic_cast<OOX::File>();
-				const OOX::RId oRId = m_oWorkbook.Add(oFile);
-
-				m_oWorkbook.m_bMacroEnabled = true;
-				return res;
-
-			}
-			else
-				res = c_oSerConstants::ReadUnknown;
-		}
 	};
 	class BinaryCommentReader : public Binary_CommonReader<BinaryCommentReader>
 	{
@@ -2174,7 +2156,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadComment(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -2258,7 +2240,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadCommentDatas(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -2388,7 +2370,7 @@ namespace BinXlsxRW {
 		{
 			m_oWorkbook.m_oSheets.Init();
 			return ReadTable(&BinaryWorksheetsTableReader::ReadWorksheetsTableContent, this);
-		};
+        }
 		int ReadWorksheetsTableContent(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -2426,7 +2408,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadWorksheet(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -2598,7 +2580,7 @@ namespace BinXlsxRW {
 
                 pOfficeArtExtension->m_sUri.Init();
                 pOfficeArtExtension->m_sUri->append(_T("{05C60535-1F16-4fd2-B633-F4F36F0B64E0}"));
-                pOfficeArtExtension->m_sAdditionalNamespace = _T(" xmlns:x14=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/main\"");
+                pOfficeArtExtension->m_sAdditionalNamespace = _T("xmlns:x14=\"http://schemas.microsoft.com/office/spreadsheetml/2009/9/main\"");
                 m_pCurWorksheet->m_oExtLst.Init();
                 m_pCurWorksheet->m_oExtLst->m_arrExt.push_back(pOfficeArtExtension);
             }
@@ -3012,7 +2994,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadPageMargins(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CPageMargins* pPageMargins = static_cast<OOX::Spreadsheet::CPageMargins*>(poResult);
@@ -3050,7 +3032,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadPageSetup(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CPageSetup* pPageSetup = static_cast<OOX::Spreadsheet::CPageSetup*>(poResult);
@@ -3068,7 +3050,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadPrintOptions(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CPrintOptions* pPrintOptions = static_cast<OOX::Spreadsheet::CPrintOptions*>(poResult);
@@ -3089,7 +3071,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadHyperlinks(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -3102,7 +3084,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadHyperlink(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CHyperlink* pHyperlink = static_cast<OOX::Spreadsheet::CHyperlink*>(poResult);
@@ -3137,7 +3119,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadMergeCells(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -3299,7 +3281,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadDrawing(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CCellAnchor* pCellAnchor = static_cast<OOX::Spreadsheet::CCellAnchor*>(poResult);
@@ -3347,7 +3329,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadFromTo(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CFromTo* pFromTo = static_cast<OOX::Spreadsheet::CFromTo*>(poResult);
@@ -3377,7 +3359,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadExt(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CExt* pExt = static_cast<OOX::Spreadsheet::CExt*>(poResult);
@@ -3397,7 +3379,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadPos(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CPos* pPos = static_cast<OOX::Spreadsheet::CPos*>(poResult);
@@ -3417,7 +3399,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadSheetData(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -3430,7 +3412,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadRow(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CRow* pRow = static_cast<OOX::Spreadsheet::CRow*>(poResult);
@@ -3638,7 +3620,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadConditionalFormatting(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CConditionalFormatting* pConditionalFormatting = static_cast<OOX::Spreadsheet::CConditionalFormatting*>(poResult);
@@ -3662,7 +3644,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadConditionalFormattingRule(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CConditionalFormattingRule* pConditionalFormattingRule = static_cast<OOX::Spreadsheet::CConditionalFormattingRule*>(poResult);
@@ -3779,7 +3761,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadDataBar(BYTE type, long length, void* poResult)
 		{
 			OOX::Spreadsheet::CDataBar* pDataBar = static_cast<OOX::Spreadsheet::CDataBar*>(poResult);
@@ -4027,7 +4009,7 @@ namespace BinXlsxRW {
             else
                 res = c_oSerConstants::ReadUnknown;
             return res;
-        };
+        }
         int ReadSparklines(BYTE type, long length, void* poResult)
         {
             OOX::Spreadsheet::CSparklines* pSparklines = static_cast<OOX::Spreadsheet::CSparklines*>(poResult);
@@ -4041,7 +4023,7 @@ namespace BinXlsxRW {
             else
                 res = c_oSerConstants::ReadUnknown;
             return res;
-        };
+        }
         int ReadSparkline(BYTE type, long length, void* poResult)
         {
             OOX::Spreadsheet::CSparkline* pSparkline = static_cast<OOX::Spreadsheet::CSparkline*>(poResult);
@@ -4105,7 +4087,7 @@ namespace BinXlsxRW {
 		int Read()
 		{
 			return ReadTable(&BinaryOtherTableReader::ReadOtherTableContent, this);
-		};
+        }
 		int ReadOtherTableContent(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;
@@ -4139,7 +4121,7 @@ namespace BinXlsxRW {
 			else
 				res = c_oSerConstants::ReadUnknown;
 			return res;
-		};
+        }
 		int ReadMediaItem(BYTE type, long length, void* poResult)
 		{
 			int res = c_oSerConstants::ReadOk;