Merge branch 'develop' of https://github.com/ONLYOFFICE/core into develop

x2t version 2.4.515

ASCOfficeDocFile/DocDocxConverter/ContentTypes.h

@@ -71,7 +71,11 @@ namespace OpenXmlContentTypes
     static const wchar_t* Bmp					=	L"image/bmp";
 	static const wchar_t* Pcz					=	L"image/x-pcz";
 }
-
+namespace DocPrContentTypes
+{
+    static const wchar_t* App			=	L"application/vnd.openxmlformats-officedocument.extended-properties+xml";
+    static const wchar_t* Core			=	L"application/vnd.openxmlformats-package.core-properties+xml";
+}
 namespace WordprocessingMLContentTypes
 {
 	// WordprocessingML content types
@@ -137,7 +141,7 @@ namespace OpenXmlNamespaces
 
 namespace OpenXmlRelationshipTypes
 {
-    static const wchar_t* CoreProperties		=	L"http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
+	static const wchar_t* CoreProperties		=	L"http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
     static const wchar_t* ExtendedProperties	=	L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties";
 
     static const wchar_t* Theme					=	L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";

ASCOfficeDocFile/DocDocxConverter/OpenXmlPackage.cpp

@@ -64,6 +64,8 @@ namespace DocFileFormat
         DocumentContentTypesFile._defaultTypes.insert( make_pair( L"xml", std::wstring( OpenXmlContentTypes::Xml ) ) );
 
         MainRelationshipsFile.Relationships.push_back( Relationship( std::wstring( L"rId1"), OpenXmlRelationshipTypes::OfficeDocument, L"word/document.xml") );
+        MainRelationshipsFile.Relationships.push_back( Relationship( std::wstring( L"rId2"), OpenXmlRelationshipTypes::CoreProperties, L"docProps/core.xml") );
+        MainRelationshipsFile.Relationships.push_back( Relationship( std::wstring( L"rId3"), OpenXmlRelationshipTypes::ExtendedProperties, L"docProps/app.xml") );
 	}
 
 
@@ -195,14 +197,18 @@ namespace DocFileFormat
 		delete storageOut;
 		return S_OK;
 	}
-
-	int OpenXmlPackage::RegisterDocument()
+	void OpenXmlPackage::RegisterDocPr()
 	{
-        return AddPart( L"word", L"document.xml", WordprocessingMLContentTypes::MainDocument, L"");
+        AddPart( L"docProps", L"app.xml", DocPrContentTypes::App, L"");
+        AddPart( L"docProps", L"core.xml", DocPrContentTypes::Core, L"");
 	}
-	int OpenXmlPackage::RegisterDocumentMacros()
+	void OpenXmlPackage::RegisterDocument()
 	{
-        return AddPart( L"word", L"document.xml", WordprocessingMLContentTypes::MainDocumentMacro, L"");
+        AddPart( L"word", L"document.xml", WordprocessingMLContentTypes::MainDocument, L"");
+	}
+	void OpenXmlPackage::RegisterDocumentMacros()
+	{
+        AddPart( L"word", L"document.xml", WordprocessingMLContentTypes::MainDocumentMacro, L"");
 	}
 	int OpenXmlPackage::RegisterVbaProject()
 	{

ASCOfficeDocFile/DocDocxConverter/OpenXmlPackage.h

@@ -165,8 +165,9 @@ namespace DocFileFormat
 		HRESULT SaveOLEObject		( const std::wstring& fileName, const OleObjectFileStructure& oleObjectFileStructure );
 		HRESULT SaveEmbeddedObject	( const std::wstring& fileName, const std::string& data );
 
-		int RegisterDocument();
-		int RegisterDocumentMacros();
+		void RegisterDocPr();
+		void RegisterDocument();
+		void RegisterDocumentMacros();
 		int RegisterFontTable();
 		int RegisterNumbering();
 		int RegisterSettings();

ASCOfficeDocFile/DocDocxConverter/WordprocessingDocument.cpp

@@ -35,6 +35,10 @@
 #include "../../DesktopEditor/raster/BgraFrame.h"
 #include "../../DesktopEditor/common/Directory.h"
 
+#include "../../Common/DocxFormat/Source/DocxFormat/App.h"
+#include "../../Common/DocxFormat/Source/DocxFormat/Core.h"
+#include "../../Common/DocxFormat/Source/DocxFormat/ContentTypes.h"
+
 namespace ImageHelper
 {
     struct __BITMAPINFOHEADER
@@ -211,6 +215,37 @@ namespace DocFileFormat
 		{
 			RegisterDocument();
 		}
+		OOX::CContentTypes oContentTypes;
+		OOX::CPath pathDocProps = m_strOutputPath + FILE_SEPARATOR_STR + _T("docProps");
+		NSDirectory::CreateDirectory(pathDocProps.GetPath());
+		
+		OOX::CPath DocProps = std::wstring(_T("docProps"));
+
+		OOX::CApp* pApp = new OOX::CApp(NULL);
+		if (pApp)
+		{
+			pApp->SetApplication(L"ONLYOFFICE");
+	#if defined(INTVER)
+			pApp->SetAppVersion(VALUE2STR(INTVER));
+	#endif
+			pApp->SetDocSecurity(0);
+			pApp->SetScaleCrop(false);
+			pApp->SetLinksUpToDate(false);
+			pApp->SetSharedDoc(false);
+			pApp->SetHyperlinksChanged(false);
+			
+			pApp->write(pathDocProps + FILE_SEPARATOR_STR + _T("app.xml"), DocProps, oContentTypes);
+			delete pApp;
+		}				
+		OOX::CCore* pCore = new OOX::CCore(NULL);
+		if (pCore)
+		{
+			pCore->SetCreator(_T(""));
+			pCore->SetLastModifiedBy(_T(""));
+			pCore->write(pathDocProps + FILE_SEPARATOR_STR + _T("core.xml"), DocProps, oContentTypes);
+			delete pCore;
+		} 
+		RegisterDocPr();
 
 		WritePackage();
 

ASCOfficeDocFile/DocFormatLib/Linux/DocFormatLib.pro

@@ -21,8 +21,6 @@ include($$PWD/../../../Common/3dParty/boost/boost.pri)
 
 DEFINES +=  UNICODE \
         _UNICODE \
-        _USE_XMLLITE_READER_ \
-         USE_LITE_READER \
         _USE_LIBXML2_READER_ \
         LIBXML_READER_ENABLED \
         DONT_WRITE_EMBEDDED_FONTS \

ASCOfficeDocFile/DocFormatLib/Win32/DocFormatLib.vcproj

@@ -52,6 +52,7 @@
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="4"
+				DisableSpecificWarnings="4005;4311;4312"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"

ASCOfficeDocxFile2/BinReader/ReaderClasses.h

@@ -318,20 +318,29 @@ public:
     docRGB      Color;
 	CThemeColor ThemeColor; 
 
+	bool bValue;
 	bool bColor;
 	bool bThemeColor;
 	Shd()
 	{
-        Value       = shd_Nil;
+		bValue		= false;
         bColor      = false;
 		bThemeColor = false;
 	}
     std::wstring ToString()
 	{
         std::wstring sShd;
-		if(bColor || (bThemeColor && ThemeColor.IsNoEmpty()))
+		if(bValue || bColor || (bThemeColor && ThemeColor.IsNoEmpty()))
 		{
-            sShd += L"<w:shd w:val=\"clear\" w:color=\"auto\"";
+			sShd += L"<w:shd";
+			if(bValue)
+			{
+				if(shd_Nil == Value)
+					sShd += L" w:val=\"nil\"";
+				else
+					sShd += L" w:val=\"clear\"";
+			}
+			sShd += L" w:color=\"auto\"";
 			if(bColor)
                 sShd += L" w:fill=\"" + Color.ToString() + L"\"";
 			if(bThemeColor && ThemeColor.IsNoEmpty())

ASCOfficeDocxFile2/BinReader/Readers.h

@@ -266,7 +266,10 @@ private:
 		Shd* pShd = static_cast<Shd*>(poResult);
 		switch(type)
 		{
-		case c_oSerShdType::Value: pShd->Value = m_oBufferedStream.GetUChar();break;
+		case c_oSerShdType::Value:
+			pShd->bValue = true;
+			pShd->Value = m_oBufferedStream.GetUChar();
+			break;
 		case c_oSerShdType::Color:
 			pShd->bColor = true;
 			pShd->Color = ReadColor();
@@ -451,11 +454,8 @@ public:
 			{
 				Shd oShd;
 				oBinary_CommonReader2.ReadShdOut(length, &oShd);
-				if(shd_Nil != oShd.Value)
-				{
-					orPr->bShd = true;
-					orPr->Shd = oShd.ToString();
-				}
+				orPr->bShd = true;
+				orPr->Shd = oShd.ToString();
 				break;
 			}
 		case c_oSerProp_rPrType::RStyle:
@@ -801,15 +801,7 @@ public:
 			{
 				Shd oShd;
 				oBinary_CommonReader2.ReadShdOut(length, &oShd);
-				if(shd_Nil != oShd.Value)
-				{
-					pCStringWriter->WriteString(oShd.ToString());
-				}
-				else
-				{
-                    std::wstring sShd(L"<w:shd w:val=\"clear\" w:color=\"auto\" w:fill=\"auto\"/>");
-					pCStringWriter->WriteString(sShd);
-				}
+				pCStringWriter->WriteString(oShd.ToString());
 				break;
 			}
 		case c_oSerProp_pPrType::WidowControl:
@@ -1782,11 +1774,8 @@ public:
 		{
 			Shd oShd;
 			oBinary_CommonReader2.ReadShdOut(length, &oShd);
-			if(shd_Nil != oShd.Value)
-			{
-				pWiterTblPr->Shd = oShd.ToString();
-				m_sCurTableShd = pWiterTblPr->Shd;
-			}
+			pWiterTblPr->Shd = oShd.ToString();
+			m_sCurTableShd = pWiterTblPr->Shd;
 		}
 		else if( c_oSerProp_tblPrType::tblpPr == type )
 		{
@@ -2244,10 +2233,7 @@ public:
 			bCellShd = true;
 			Shd oShd;
 			oBinary_CommonReader2.ReadShdOut(length, &oShd);
-			if(shd_Nil != oShd.Value)
-			{
-				pCStringWriter->WriteString(oShd.ToString());
-			}
+			pCStringWriter->WriteString(oShd.ToString());
 		}
 		else if( c_oSerProp_cellPrType::TableCellBorders == type )
 		{
@@ -7449,6 +7435,8 @@ public:
 		{
 			PPTX::Logic::CNvPr pNonVisualDrawingProps(L"wp");
 			res = Read1(length, &Binary_DocumentTableReader::ReadDocPr, this, &pNonVisualDrawingProps);
+			
+			pNonVisualDrawingProps.id = pDrawingProperty->m_nDocPr;
 			pDrawingProperty->sDocPr = pNonVisualDrawingProps.toXML2(L"wp:docPr");
 		}
 		else

ASCOfficeDocxFile2/BinWriter/BinEquationWriter.h

@@ -416,7 +416,7 @@ namespace MathEquation
 
 			virtual void BeginEquation()
 			{
-				int nCurPos = WriteItemStart(BinDocxRW::c_oSerParType::OMath);
+				int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::OMath);
 				m_aEquationStack.push(nCurPos);
 			}
 			virtual void EndEquation()
@@ -618,7 +618,7 @@ namespace MathEquation
                         nRows = m_aRowsCounter.top();
                         m_aRowsCounter.pop();
                     }
-                    int nPos = m_oStream.GetPosition();
+                    int nPos = 0;
                     if (!m_aRowsPosCounter.empty())
                     {
                         nPos = m_aRowsPosCounter.top();

ASCOfficeDocxFile2/BinWriter/BinWriters.cpp

@@ -87,10 +87,14 @@ namespace BinDocxRW
 
 		BinaryDocumentTableWriter oBinaryDocumentTableWriter(m_oParamsWriter, oParamsDocumentWriter, m_mapIgnoreComments, NULL);
 		
-		oBinaryDocumentTableWriter.prepareOfficeDrawingConverter(m_pOfficeDrawingConverter, oParamsDocumentWriter.m_pRels,  pHdrFtr->m_arrShapeTypes);
-		
+		smart_ptr<OOX::IFileContainer> oldRels = m_pOfficeDrawingConverter->GetRels();
+		m_pOfficeDrawingConverter->SetRels(oParamsDocumentWriter.m_pRels);
+		m_pOfficeDrawingConverter->ClearShapeTypes();
+
 		nCurPos = m_oBcw.WriteItemStart(c_oSerHdrFtrTypes::HdrFtr_Content);
 		oBinaryDocumentTableWriter.WriteDocumentContent(pHdrFtr->m_arrItems);
 		m_oBcw.WriteItemEnd(nCurPos);
+
+		m_pOfficeDrawingConverter->SetRels(oldRels);
 	}
 }

ASCOfficeDocxFile2/BinWriter/BinWriters.h

@@ -3016,25 +3016,13 @@ namespace BinDocxRW
 		bool							m_bWriteSectPr;//Записывать ли свойства верхнего уровня в данном экземпляре BinaryOtherTableWriter
 //---------------------------------
 		BinaryDocumentTableWriter(ParamsWriter& oParamsWriter, ParamsDocumentWriter& oParamsDocumentWriter, std::map<int, bool>* mapIgnoreComments, BinaryHeaderFooterTableWriter* oBinaryHeaderFooterTableWriter):
-			m_oParamsWriter(oParamsWriter), m_oParamsDocumentWriter(oParamsDocumentWriter),m_oBcw(oParamsWriter),bpPrs(oParamsWriter, oBinaryHeaderFooterTableWriter),brPrs(oParamsWriter),btblPrs(oParamsWriter),m_oSettings(oParamsWriter.m_oSettings),m_pOfficeDrawingConverter(oParamsWriter.m_pOfficeDrawingConverter),m_mapIgnoreComments(mapIgnoreComments)
+			m_oParamsWriter(oParamsWriter), m_oParamsDocumentWriter(oParamsDocumentWriter), m_oBcw(oParamsWriter),bpPrs(oParamsWriter, oBinaryHeaderFooterTableWriter),brPrs(oParamsWriter),btblPrs(oParamsWriter),m_oSettings(oParamsWriter.m_oSettings),m_pOfficeDrawingConverter(oParamsWriter.m_pOfficeDrawingConverter),m_mapIgnoreComments(mapIgnoreComments)
 		{
 			pBackground		= NULL;
 			pSectPr			= NULL;
 			poDocument		= NULL;
 			m_bWriteSectPr	= false; 
 		}
-		void prepareOfficeDrawingConverter(NSBinPptxRW::CDrawingConverter* pOfficeDrawingConverter, OOX::IFileContainer *rels, std::vector<std::wstring>& aShapeTypes)
-		{
-			smart_ptr<OOX::IFileContainer> oldRels = pOfficeDrawingConverter->GetRels();
-			pOfficeDrawingConverter->SetRels(rels);
-			
-			for(size_t i = 0, length = aShapeTypes.size(); i < length; ++i)
-			{
-                std::wstring& sShapeType = aShapeTypes[i];
-				pOfficeDrawingConverter->AddShapeType(sShapeType);
-			}
-            pOfficeDrawingConverter->SetRels(oldRels);
-		}
 		void WriteVbaProject(OOX::VbaProject& oVbaProject)
 		{
             m_oBcw.m_oStream.StartRecord(0);
@@ -3131,23 +3119,6 @@ namespace BinDocxRW
 					m_oBcw.WriteItemEnd(nCurPos);
 				}
 			}
-	//Write JsaProject
-			if (NULL != poDocument)
-			{
-				smart_ptr<OOX::File> pFile = poDocument->Get(OOX::FileTypes::JsaProject);
-				if (pFile.IsInit() && OOX::FileTypes::JsaProject == pFile->type())
-				{
-					OOX::JsaProject& jsaProject = pFile.as<OOX::JsaProject>();
-					BYTE* pData = NULL;
-					DWORD nBytesCount;
-					if(NSFile::CFileBinary::ReadAllBytes(jsaProject.filename().GetPath(), &pData, nBytesCount))
-					{
-						nCurPos = m_oBcw.WriteItemStart(c_oSerParType::JsaProject);
-						m_oBcw.m_oStream.WriteBYTEArray(pData, nBytesCount);
-						m_oBcw.WriteItemEnd(nCurPos);
-					}
-				}
-			}
 		}
 		void WriteBackground (OOX::Logic::CBackground* pBackground)
 		{
@@ -7741,7 +7712,7 @@ namespace BinDocxRW
 			m_oParamsWriter.m_pCurRels = oParamsDocumentWriter.m_pRels;
 
 			int nStart = m_oBcw.WriteItemWithLengthStart();
-			WriteNotes(oFootnotes.m_arrFootnote, oParamsDocumentWriter, oFootnotes.m_arrShapeTypes);
+			WriteNotes(oFootnotes.m_arrFootnote, oParamsDocumentWriter);
 			m_oBcw.WriteItemWithLengthEnd(nStart);
 		}
 		void WriteEndnotes(OOX::CEndnotes& oEndnotes)
@@ -7750,20 +7721,27 @@ namespace BinDocxRW
 			m_oParamsWriter.m_pCurRels = oParamsDocumentWriter.m_pRels;
 
 			int nStart = m_oBcw.WriteItemWithLengthStart();
-			WriteNotes(oEndnotes.m_arrEndnote, oParamsDocumentWriter, oEndnotes.m_arrShapeTypes);
+			WriteNotes(oEndnotes.m_arrEndnote, oParamsDocumentWriter);
 			m_oBcw.WriteItemWithLengthEnd(nStart);
 		}
-        void WriteNotes(const std::vector<OOX::CFtnEdn*>& arrNotes, ParamsDocumentWriter& oParamsDocumentWriter, std::vector<std::wstring>& arrShapeTypes)
+        void WriteNotes(const std::vector<OOX::CFtnEdn*>& arrNotes, ParamsDocumentWriter& oParamsDocumentWriter)
 		{
+			BinaryDocumentTableWriter oBinaryDocumentTableWriter(m_oParamsWriter, oParamsDocumentWriter, &m_oParamsWriter.m_mapIgnoreComments, NULL);
+			
+			smart_ptr<OOX::IFileContainer> oldRels = m_pOfficeDrawingConverter->GetRels();
+			m_pOfficeDrawingConverter->SetRels(oParamsDocumentWriter.m_pRels);
+			m_pOfficeDrawingConverter->ClearShapeTypes();
+			
 			int nCurPos = 0;
 			for(size_t i = 0 ; i < arrNotes.size(); ++i)
 			{
 				nCurPos = m_oBcw.WriteItemStart(c_oSerNotes::Note);
-				WriteNote(*arrNotes[i], oParamsDocumentWriter, arrShapeTypes);
+				WriteNote(*arrNotes[i], oBinaryDocumentTableWriter);
 				m_oBcw.WriteItemEnd(nCurPos);
 			}
+			m_pOfficeDrawingConverter->SetRels(oldRels);
 		}
-        void WriteNote(const OOX::CFtnEdn& oFtnEdn, ParamsDocumentWriter& oParamsDocumentWriter, std::vector<std::wstring>& arrShapeTypes)
+        void WriteNote(const OOX::CFtnEdn& oFtnEdn, BinaryDocumentTableWriter & oBinaryDocumentTableWriter)
 		{
 			int nCurPos = 0;
 			if(oFtnEdn.m_oType.IsInit())
@@ -7778,10 +7756,6 @@ namespace BinDocxRW
 				m_oBcw.m_oStream.WriteLONG(oFtnEdn.m_oId->GetValue());
 				m_oBcw.WriteItemEnd(nCurPos);
 			}
-
-			BinaryDocumentTableWriter oBinaryDocumentTableWriter(m_oParamsWriter, oParamsDocumentWriter, &m_oParamsWriter.m_mapIgnoreComments, NULL);
-			
-			oBinaryDocumentTableWriter.prepareOfficeDrawingConverter(m_pOfficeDrawingConverter, oParamsDocumentWriter.m_pRels, arrShapeTypes);
 			
 			nCurPos = m_oBcw.WriteItemStart(c_oSerNotes::NoteContent);
 			oBinaryDocumentTableWriter.WriteDocumentContent(oFtnEdn.m_arrItems);
@@ -7864,101 +7838,93 @@ namespace BinDocxRW
 				
 				OOX::CDocx oDocx = OOX::CDocx(OOX::CPath(sDir));
 				
-				m_oParamsWriter.m_poTheme	= oDocx.GetTheme();
-				m_oParamsWriter.m_oSettings = oDocx.GetSettings();
+				m_oParamsWriter.m_poTheme	= oDocx.m_pTheme;
+				m_oParamsWriter.m_oSettings = oDocx.m_pSettings;
 
-				*oBufferedStream.m_pTheme = smart_ptr<PPTX::Theme>(oDocx.GetTheme());
+				*oBufferedStream.m_pTheme = smart_ptr<PPTX::Theme>(oDocx.m_pTheme);
 				oBufferedStream.m_pTheme->AddRef();
 				
-				OOX::CFontTable* pFontTable = oDocx.GetFontTable();
-				
-				if(NULL != pFontTable)
-					m_oParamsWriter.m_pFontProcessor->setFontTable(pFontTable);
+				if(NULL != oDocx.m_pFontTable)
+					m_oParamsWriter.m_pFontProcessor->setFontTable(oDocx.m_pFontTable);
 
 				//ищем первый SectPr и расставляем pageBreak
-				OOX::CDocument* poDocument = oDocx.GetDocument();
 
-                if (poDocument == NULL) return;
-				OOX::Logic::CSectionProperty* pFirstSectPr = poDocument->m_oSectPr.GetPointer();
+                if (oDocx.m_pDocument == NULL) return;
+				OOX::Logic::CSectionProperty* pFirstSectPr = oDocx.m_pDocument->m_oSectPr.GetPointer();
 
 				this->WriteMainTableStart();
 
 				int nCurPos = 0;
 				
 		//Write Settings
-				OOX::CSettings* pSettings = oDocx.GetSettings();
-				if(NULL != pSettings)
+				if(NULL != oDocx.m_pSettings)
 				{
 					BinDocxRW::BinarySettingsTableWriter oBinarySettingsTableWriter(m_oParamsWriter);
 					int nCurPos = this->WriteTableStart(BinDocxRW::c_oSerTableTypes::Settings);
-					oBinarySettingsTableWriter.Write(*pSettings);
+					oBinarySettingsTableWriter.Write(*oDocx.m_pSettings);
 					this->WriteTableEnd(nCurPos);
 				}
 
 		//Write Comments
-				OOX::CComments* pComments = oDocx.GetComments();
-				OOX::CCommentsExt* pCommentsExt = oDocx.GetCommentsExt();
-				OOX::CPeople* pPeople = oDocx.GetPeople();
-				if(NULL != pComments)
+				if(NULL != oDocx.m_pComments)
 				{
 					BinDocxRW::BinaryCommentsTableWriter oBinaryCommentsTableWriter(m_oParamsWriter);
 					int nCurPos = this->WriteTableStart(BinDocxRW::c_oSerTableTypes::Comments);
-					oBinaryCommentsTableWriter.Write(*pComments, pCommentsExt, pPeople, m_oParamsWriter.m_mapIgnoreComments);
+					oBinaryCommentsTableWriter.Write(*oDocx.m_pComments, oDocx.m_pCommentsExt, oDocx.m_pPeople, m_oParamsWriter.m_mapIgnoreComments);
 					this->WriteTableEnd(nCurPos);
 				}
 
 		//Write StyleTable
-				OOX::CStyles* pStyles = oDocx.GetStyles();
 				BinDocxRW::BinaryStyleTableWriter oBinaryStyleTableWriter(m_oParamsWriter);
-				if(NULL != pStyles)
+				if(NULL != oDocx.m_pStyles)
 				{
 					int nCurPos = this->WriteTableStart(BinDocxRW::c_oSerTableTypes::Style);
-					oBinaryStyleTableWriter.Write(*pStyles);
+					oBinaryStyleTableWriter.Write(*oDocx.m_pStyles);
 					this->WriteTableEnd(nCurPos);
 				}
 		//Write Numbering
-				OOX::CNumbering* pNumbering = oDocx.GetNumbering();
 				BinDocxRW::BinaryNumberingTableWriter oBinaryNumberingTableWriter(m_oParamsWriter);
-				if(NULL != pNumbering)
+				if(NULL != oDocx.m_pNumbering)
 				{
 					nCurPos = this->WriteTableStart(BinDocxRW::c_oSerTableTypes::Numbering);
-					oBinaryNumberingTableWriter.Write(*pNumbering);
+					oBinaryNumberingTableWriter.Write(*oDocx.m_pNumbering);
 					this->WriteTableEnd(nCurPos);
 				}
 
 				BinDocxRW::BinaryNotesTableWriter oBinaryNotesWriter(m_oParamsWriter);
 		//Write Footnotes
-				OOX::CFootnotes* pFootnotes = oDocx.GetFootnotes();
-				if(NULL != pFootnotes)
+				if(NULL != oDocx.m_pFootnotes)
 				{
 					nCurPos = this->WriteTableStart(BinDocxRW::c_oSerTableTypes::Footnotes);
-					oBinaryNotesWriter.WriteFootnotes(*pFootnotes);
+					oBinaryNotesWriter.WriteFootnotes(*oDocx.m_pFootnotes);
 					this->WriteTableEnd(nCurPos);
 				}
 		//Write Endnotes
-				OOX::CEndnotes* pEndnotes = oDocx.GetEndnotes();
-				if(NULL != pEndnotes)
+				if(NULL != oDocx.m_pEndnotes)
 				{
 					nCurPos = this->WriteTableStart(BinDocxRW::c_oSerTableTypes::Endnotes);
-					oBinaryNotesWriter.WriteEndnotes(*pEndnotes);
+					oBinaryNotesWriter.WriteEndnotes(*oDocx.m_pEndnotes);
 					this->WriteTableEnd(nCurPos);
 				}
 
-				BinDocxRW::BinaryHeaderFooterTableWriter oBinaryHeaderFooterTableWriter(m_oParamsWriter, poDocument, &m_oParamsWriter.m_mapIgnoreComments);
+				BinDocxRW::BinaryHeaderFooterTableWriter oBinaryHeaderFooterTableWriter(m_oParamsWriter, oDocx.m_pDocument, &m_oParamsWriter.m_mapIgnoreComments);
 
 		//Write DocumentTable
-				ParamsDocumentWriter oParamsDocumentWriter(poDocument);
+				ParamsDocumentWriter oParamsDocumentWriter(oDocx.m_pDocument);
 				m_oParamsWriter.m_pCurRels = oParamsDocumentWriter.m_pRels;
 		
 		//DocumentTable всегда пишем последней, чтобы сначала заполнить все вспомогательные структуры, а при заполении документа, вызывать методы типа Style_Add...
 				BinDocxRW::BinaryDocumentTableWriter oBinaryDocumentTableWriter(m_oParamsWriter, oParamsDocumentWriter, &m_oParamsWriter.m_mapIgnoreComments, &oBinaryHeaderFooterTableWriter);
-				oBinaryDocumentTableWriter.prepareOfficeDrawingConverter(m_oParamsWriter.m_pOfficeDrawingConverter, oParamsDocumentWriter.m_pRels, poDocument->m_arrShapeTypes);
 				
+				m_oParamsWriter.m_pOfficeDrawingConverter->SetRels(oParamsDocumentWriter.m_pRels);
+				m_oParamsWriter.m_pOfficeDrawingConverter->ClearShapeTypes();
+
 				oBinaryDocumentTableWriter.pSectPr			= pFirstSectPr;
-				oBinaryDocumentTableWriter.pBackground		= poDocument->m_oBackground.GetPointer();
-				oBinaryDocumentTableWriter.poDocument		= poDocument;
+				oBinaryDocumentTableWriter.pBackground		= oDocx.m_pDocument->m_oBackground.GetPointer();
+				oBinaryDocumentTableWriter.poDocument		= oDocx.m_pDocument;
 
 				oBinaryDocumentTableWriter.m_bWriteSectPr	= true;
+				
 		//Write Vba
 				if(NULL != oDocx.m_pVbaProject)
 				{
@@ -7966,9 +7932,22 @@ namespace BinDocxRW
 					oBinaryDocumentTableWriter.WriteVbaProject(*oDocx.m_pVbaProject);
 					this->WriteTableEnd(nCurPos);
 				}
+		//Write JsaProject
+				if (NULL != oDocx.m_pJsaProject)
+				{
+					BYTE* pData = NULL;
+					DWORD nBytesCount;
+					if(NSFile::CFileBinary::ReadAllBytes(oDocx.m_pJsaProject->filename().GetPath(), &pData, nBytesCount))
+					{
+						nCurPos = m_oBcw.WriteItemStart(c_oSerParType::JsaProject);
+						m_oBcw.m_oStream.WriteBYTEArray(pData, nBytesCount);
+						m_oBcw.WriteItemEnd(nCurPos);
+					}
+				}
+
 		// Write content
 				nCurPos = this->WriteTableStart(BinDocxRW::c_oSerTableTypes::Document);
-				oBinaryDocumentTableWriter.Write(poDocument->m_arrItems);
+				oBinaryDocumentTableWriter.Write(oDocx.m_pDocument->m_arrItems);
 				this->WriteTableEnd(nCurPos);
 
 				nCurPos = this->WriteTableStart(BinDocxRW::c_oSerTableTypes::HdrFtr);

ASCOfficeDocxFile2/DocWrapper/DocxSerializer.cpp

@@ -298,7 +298,7 @@ bool BinDocxRW::CDocxSerializer::loadFromFile(const std::wstring& sSrcFileName,
 				OOX::CApp* pApp = new OOX::CApp(NULL);
 				if (pApp)
 				{
-					pApp->SetApplication(L"OnlyOffice");
+					pApp->SetApplication(L"ONLYOFFICE");
 #if defined(INTVER)
                     pApp->SetAppVersion(VALUE2STR(INTVER));
 #endif

ASCOfficeDocxFile2/DocWrapper/XlsxSerializer.cpp

@@ -85,7 +85,7 @@ namespace BinXlsxRW{
 		sMediaPath = pathMediaDir.GetPath();
 		sEmbedPath = pathEmbedDir.GetPath();
 	}
-    bool CXlsxSerializer::loadFromFile(const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions, const std::wstring& sMediaDir, const std::wstring& sEmbedDir)
+    int CXlsxSerializer::loadFromFile(const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions, const std::wstring& sMediaDir, const std::wstring& sEmbedDir)
 	{
         std::wstring strFileInDir = NSSystemPath::GetDirectoryName(sSrcFileName);
 
@@ -97,11 +97,10 @@ namespace BinXlsxRW{
 		oDrawingConverter.SetMediaDstPath(sMediaDir);
 		oDrawingConverter.SetEmbedDstPath(sEmbedDir);
 
-		BinXlsxRW::BinaryFileReader oBinaryFileReader;
-		oBinaryFileReader.ReadFile(sSrcFileName, sDstPath, &oDrawingConverter, sXMLOptions);
-		return true;
+		BinXlsxRW::BinaryFileReader oBinaryFileReader;		
+		return oBinaryFileReader.ReadFile(sSrcFileName, sDstPath, &oDrawingConverter, sXMLOptions);
 	}
-    bool CXlsxSerializer::saveToFile(const std::wstring& sDstFileName, const std::wstring& sSrcPath, const std::wstring& sXMLOptions)
+    int CXlsxSerializer::saveToFile(const std::wstring& sDstFileName, const std::wstring& sSrcPath, const std::wstring& sXMLOptions)
 	{
 		COfficeFontPicker* pFontPicker = new COfficeFontPicker();
 		pFontPicker->Init(m_sFontDir);
@@ -137,10 +136,10 @@ namespace BinXlsxRW{
 		oOfficeDrawingConverter.SetFontPicker(pFontPicker);
 
 		BinXlsxRW::BinaryFileWriter oBinaryFileWriter(fp);
-		oBinaryFileWriter.Open(sSrcPath, sDstFileName, pEmbeddedFontsManager, &oOfficeDrawingConverter, sXMLOptions, m_bIsNoBase64);
+		int result = oBinaryFileWriter.Open(sSrcPath, sDstFileName, pEmbeddedFontsManager, &oOfficeDrawingConverter, sXMLOptions, m_bIsNoBase64);
 
 		RELEASEOBJECT(pFontPicker);
-		return true;
+		return result;
 	}
  	bool CXlsxSerializer::saveChart(NSBinPptxRW::CBinaryFileReader* pReader, long lLength, const std::wstring& sFilepath, const long& lChartNumber)
 	{

ASCOfficeDocxFile2/DocWrapper/XlsxSerializer.h

@@ -62,8 +62,8 @@ namespace BinXlsxRW {
 		
         static void CreateXlsxFolders  (const std::wstring& sXmlOptions, const std::wstring& sDstPath, std::wstring& sMediaPath, std::wstring& sEmbedPath);
 
-        bool loadFromFile       (const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions, const std::wstring& sMediaDir, const std::wstring& sEmbedPath);
-        bool saveToFile         (const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions);
+        int loadFromFile		(const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions, const std::wstring& sMediaDir, const std::wstring& sEmbedPath);
+        int saveToFile			(const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions);
 		
         bool saveChart          (NSBinPptxRW::CBinaryFileReader* pReader, long lLength, const std::wstring& sFilename, const long& lChartNumber);
 		

ASCOfficeDocxFile2/Linux/ASCOfficeDocxFile2Lib.pro

@@ -16,8 +16,6 @@ include($$PWD/../../Common/3dParty/boost/boost.pri)
 
 DEFINES += UNICODE \
 	_UNICODE \
-	_USE_XMLLITE_READER_ \
-	USE_LITE_READER \
 	USE_AVSOFFICESTUDIO_XMLUTILS \
 	SOLUTION_ASCOFFICEDOCXFILE2 \
         #DISABLE_FILE_DOWNLOADER \

ASCOfficeOdfFile/linux/OdfFileReaderLib.pro

@@ -22,8 +22,6 @@ include($$PWD/../../Common/3dParty/boost/boost.pri)
 DEFINES +=  UNICODE \
             _UNICODE \
             _USE_LIBXML2_READER_ \
-            _USE_XMLLITE_READER_ \
-            USE_LITE_READER \
             LIBXML_READER_ENABLED \
             DONT_WRITE_EMBEDDED_FONTS
 
@@ -288,6 +286,7 @@ SOURCES += \
     ../src/docx/xlsx_table_state.cpp \
     ../src/docx/xlsx_textcontext.cpp \
     ../src/docx/xlsx_pivots_context.cpp \
+    ../src/docx/xlsx_data_validation.cpp \
     ../src/docx/xlsx_utils.cpp \
     ../src/docx/xlsx_xf.cpp
 }
@@ -551,6 +550,7 @@ HEADERS += \
     ../src/docx/xlsx_table_position.h \
     ../src/docx/xlsx_table_state.h \
     ../src/docx/xlsx_textcontext.h \
+    ../src/docx/xlsx_data_validation.h \
     ../src/docx/xlsx_utils.h \
     ../src/docx/xlsx_xf.h \
     ../include/logging.h \

ASCOfficeOdfFile/linux/odffilereaderlib_oox.cpp

@@ -101,3 +101,4 @@
 #include "../src/docx/xlsx_utils.cpp"
 #include "../src/docx/xlsx_xf.cpp"
 #include "../src/docx/xlsx_pivots_context.cpp"
+#include "../src/docx/xlsx_data_validation.cpp""

ASCOfficeOdfFile/src/docx/docx_conversion_context.cpp

@@ -777,7 +777,8 @@ void docx_conversion_context::process_section(std::wostream & strm, odf_reader::
 		{
 			double page_width = 0;
 			const odf_reader::page_layout_instance * pp = root()->odf_context().pageLayoutContainer().page_layout_first();
-			if (pp)
+			
+			if ((pp) && (pp->properties()))
 			{
 				odf_reader::style_page_layout_properties_attlist & attr_page = pp->properties()->attlist_;
 				if (attr_page.fo_page_width_)
@@ -1169,7 +1170,7 @@ void docx_conversion_context::docx_convert_delayed()
     {
         odf_reader::office_element * elm = delayed_elements_.front();
         elm->docx_convert(*this);
-		delayed_elements_.pop_front();
+		delayed_elements_.erase(delayed_elements_.begin(), delayed_elements_.begin() + 1);
     }
 	delayed_converting_=false;
 }

ASCOfficeOdfFile/src/docx/docx_conversion_context.h

@@ -763,7 +763,7 @@ private:
     std::wstring			automatic_parent_style_; 
     std::wstring			current_master_page_name_;
 	std::wstring			text_list_style_name_;
-    std::list<std::wstring> list_style_stack_;
+    std::vector<std::wstring> list_style_stack_;
     bool					first_element_list_item_;
     
 	bool page_break_after_;
@@ -781,9 +781,9 @@ private:
  
     int										new_list_style_number_;	// счетчик для нумерации имен созданных в процессе конвертации стилей
 	NoteType								process_note_;
-    std::list<odf_reader::office_element *> delayed_elements_;
+    std::vector<odf_reader::office_element*> delayed_elements_;
 
-    std::list< const odf_reader::style_text_properties * >	text_properties_stack_;
+    std::vector< const odf_reader::style_text_properties*>	text_properties_stack_;
 	std::map<std::wstring, text_tracked_context::_state>	map_current_changes_;    
     boost::unordered_map<std::wstring, std::wstring>		list_style_renames_;// цепочки переименований нумераций
 };

ASCOfficeOdfFile/src/docx/docx_table_context.h

@@ -73,7 +73,7 @@ public:
 private:
     docx_conversion_context	&	context_;    
     std::wstring				table_style_;
-    std::list<std::wstring>		table_row_style_stack_;
+    std::vector<std::wstring>	table_row_style_stack_;
     std::wstring				default_row_cell_style_name_;
     int							current_table_column_;
     unsigned int				columns_spanned_num_;
@@ -188,7 +188,7 @@ public:
 
 private:
     docx_conversion_context & context_;
-    std::list<docx_table_state> table_states_;
+    std::vector<docx_table_state> table_states_;
 };
 
 

ASCOfficeOdfFile/src/docx/oox_package.cpp

@@ -40,6 +40,7 @@
 #include "../../DesktopEditor/common/File.h"
 #include "../../DesktopEditor/raster/Metafile/MetaFile.h"
 #include "../../DesktopEditor/raster/ImageFileFormatChecker.h"
+#include "../../Common/DocxFormat/Source/Base/Base.h"
 
 namespace cpdoccore { 
 namespace oox {
@@ -284,8 +285,8 @@ void core_file::write(const std::wstring & RootPath)
     L"xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:dcmitype=\"http://purl.org/dc/dcmitype/\" "
     L"xmlns:dcterms=\"http://purl.org/dc/terms/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" >";
 
-	//resStream << L"<dc:creator>ONLYOFFICE Online Editor</dc:creator>";
-	//resStream << L"<cp:lastModifiedBy>ONLYOFFICE Online Editor</cp:lastModifiedBy>";
+	//resStream << L"<dc:creator>ONLYOFFICE</dc:creator>";
+	//resStream << L"<cp:lastModifiedBy>ONLYOFFICE</cp:lastModifiedBy>";
 	resStream << L"<cp:revision>1</cp:revision>";
     resStream << L"</cp:coreProperties>";
 
@@ -300,8 +301,12 @@ void app_file::write(const std::wstring & RootPath)
     resStream << L"<Properties xmlns=\"http://schemas.openxmlformats.org/officeDocument/2006/extended-properties\" "
         L"xmlns:vt=\"http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes\" >";
    
-	resStream << L"<Application>OnlyOffice</Application>"; 
-    resStream << L"</Properties>";
+	resStream << L"<Application>ONLYOFFICE"; 
+#if defined(INTVER)
+	std::string s = VALUE2STR(INTVER);
+	resStream << L"/" << std::wstring(s.begin(), s.end()) ;
+#endif	
+	resStream << L"</Application></Properties>";
     
     simple_element elm(L"app.xml", resStream.str());
     elm.write(RootPath);

ASCOfficeOdfFile/src/docx/pptx_table_context.h

@@ -82,7 +82,7 @@ private:
    
 	std::wstring table_style_;
 
-    std::list<std::wstring> table_row_style_stack_;
+    std::vector<std::wstring> table_row_style_stack_;
     
 	std::wstring default_row_cell_style_name_;
     int current_table_column_;
@@ -214,7 +214,7 @@ public:
 private:
 	std::wstringstream			output_stream_;
     pptx_conversion_context &	context_;
-    std::list<pptx_table_state> table_states_;
+    std::vector<pptx_table_state> table_states_;
 };
 
 void oox_serialize_tcPr(std::wostream & strm, std::vector<const odf_reader::style_instance *> & style_inst, oox::pptx_conversion_context & Context);

ASCOfficeOdfFile/src/docx/pptx_text_context.cpp

@@ -126,13 +126,13 @@ private:
 
 	std::wstring					base_style_name_;
 	odf_types::style_family::type	base_style_family_;//Presentation Or SpreadSheet
-/////////////lists////////////
-    std::list<std::wstring> list_style_stack_;
+//-------------------------------------------------------------------------------
+    std::vector<std::wstring> list_style_stack_;
     bool first_element_list_item_;
-    // счетчик для нумерации имен созданных в процессе конвертации стилей
-    int new_list_style_number_;
-    // цепочки переименований нумераций
-    boost::unordered_map<std::wstring, std::wstring> list_style_renames_;
+    
+    int new_list_style_number_;	// счетчик для нумерации имен созданных в процессе конвертации стилей
+   
+    boost::unordered_map<std::wstring, std::wstring> list_style_renames_; // цепочки переименований нумераций
    
 	void write_list_styles(std::wostream & strm);
 	//void write_list_properties(std::wostream & strm);

ASCOfficeOdfFile/src/docx/xlsx_conditionalFormatting.cpp

@@ -116,7 +116,7 @@ public:
 			int priority = 1;
             CP_XML_WRITER(_Wostream)
             {
-				for (int i = 0 ; i < conditionalFormattings_.size(); i++)
+				for (size_t i = 0 ; i < conditionalFormattings_.size(); i++)
                 {
 					conditionalFormatting & c = conditionalFormattings_[i];
 					
@@ -126,7 +126,7 @@ public:
                     {
  						CP_XML_ATTR(L"sqref", c.ref);
 
-						for (int j = 0 ; j < c.rules.size(); j++)
+						for (size_t j = 0 ; j < c.rules.size(); j++)
 						{
 							if (c.rules[j].type < 1 || c.rules[j].type > 5) continue;
 
@@ -171,7 +171,7 @@ public:
 										if (c.rules[j].minLength)	CP_XML_ATTR(L"minLength", *c.rules[j].minLength);
 										if (c.rules[j].maxLength)	CP_XML_ATTR(L"maxLength", *c.rules[j].maxLength);
 
-										for (int k = 0; k < c.rules[j].cfvo.size(); k++)
+										for (size_t k = 0; k < c.rules[j].cfvo.size(); k++)
 										{
 											c.rules[j].cfvo[k].serialize(CP_XML_STREAM());
 										}
@@ -189,11 +189,11 @@ public:
 									CP_XML_ATTR(L"type", L"colorScale");
 									CP_XML_NODE(L"colorScale")
 									{
-										for (int k = 0; k < c.rules[j].cfvo.size(); k++)
+										for (size_t k = 0; k < c.rules[j].cfvo.size(); k++)
 										{
 											c.rules[j].cfvo[k].serialize(CP_XML_STREAM());
 										}	
-										for (int k = 0; k < c.rules[j].color.size(); k++)
+										for (size_t k = 0; k < c.rules[j].color.size(); k++)
 										{
 											CP_XML_NODE(L"color")
 											{
@@ -209,7 +209,7 @@ public:
 									{
 										if (c.rules[j].showValue)	CP_XML_ATTR(L"showValue", *c.rules[j].showValue);
 										
-										for (int k = 0; k < c.rules[j].cfvo.size(); k++)
+										for (size_t k = 0; k < c.rules[j].cfvo.size(); k++)
 										{
 											c.rules[j].cfvo[k].serialize(CP_XML_STREAM());
 										}										

ASCOfficeOdfFile/src/docx/xlsx_data_validation.cpp

@@ -0,0 +1,212 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2017
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
+ * EU, LV-1021.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+
+#include "xlsx_data_validation.h"
+#include "xlsx_utils.h"
+
+#include <vector>
+#include <map>
+
+#include <cpdoccore/xml/simple_xml_writer.h>
+#include <cpdoccore/CPSharedPtr.h>
+
+#include "../formulasconvert/formulasconvert.h"
+#include "../../../Common/DocxFormat/Source/XML/Utils.h"
+
+namespace cpdoccore {
+namespace oox {
+
+class xlsx_dataValidation
+{
+public:
+	xlsx_dataValidation() : showErrorMessage(false), showInputMessage(false), showDropDown(false), allowBlank(false) {}
+
+	std::wstring ref;
+	std::wstring activate_ref;
+	std::wstring type;
+	std::wstring formula1;			
+	std::wstring formula2;
+	std::wstring operator_;
+	bool showErrorMessage;
+	bool showInputMessage;
+	bool showDropDown;
+	bool allowBlank;
+};
+typedef shared_ptr<xlsx_dataValidation>::Type xlsx_dataValidation_ptr;
+
+class xlsx_dataValidations_context::Impl
+{
+public:
+
+    void serialize(std::wostream & _Wostream)
+    {
+        if (mapActivateDataValidations.empty()) return;
+ 		
+        CP_XML_WRITER(_Wostream)
+        {
+			CP_XML_NODE(L"dataValidations")
+			{      
+				CP_XML_ATTR(L"count", mapActivateDataValidations.size());
+
+				for (std::map<std::wstring, xlsx_dataValidation_ptr>::iterator it = mapActivateDataValidations.begin();
+					it != mapActivateDataValidations.end(); ++it)
+                {
+					CP_XML_NODE(L"dataValidation")
+                    {
+ 						CP_XML_ATTR(L"sqref", it->second->activate_ref);
+ 						CP_XML_ATTR(L"allowBlank", it->second->allowBlank);
+ 						CP_XML_ATTR(L"operator", it->second->operator_);
+ 						CP_XML_ATTR(L"showDropDown", it->second->showDropDown);
+ 						CP_XML_ATTR(L"showErrorMessage", it->second->showErrorMessage);
+ 						CP_XML_ATTR(L"showInputMessage", it->second->showInputMessage);
+ 						CP_XML_ATTR(L"type", it->second->type);
+
+						if (!it->second->formula1.empty())
+						{
+							CP_XML_NODE(L"formula1")
+							{
+								CP_XML_STREAM() << it->second->formula1;
+							}
+						}
+
+						if (!it->second->formula2.empty())
+						{
+							CP_XML_NODE(L"formula2")
+							{
+								CP_XML_STREAM() << it->second->formula2;
+							}
+						}
+					}
+                }        
+            }
+        }
+
+		mapActivateDataValidations.clear();
+    }
+
+	std::map<std::wstring, xlsx_dataValidation_ptr>		mapDataValidations;			//for all tables
+	std::map<std::wstring, xlsx_dataValidation_ptr>		mapActivateDataValidations; //in current table
+};
+
+xlsx_dataValidations_context::xlsx_dataValidations_context() :
+			impl_(new xlsx_dataValidations_context::Impl())
+{}
+
+xlsx_dataValidations_context::~xlsx_dataValidations_context()
+{
+}
+void xlsx_dataValidations_context::serialize(std::wostream & _Wostream)
+{
+    return impl_->serialize(_Wostream);
+}
+void xlsx_dataValidations_context::activate(const std::wstring & name, const std::wstring & ref)
+{
+	std::map<std::wstring, xlsx_dataValidation_ptr>::iterator pFindActivate = impl_->mapActivateDataValidations.find(name);
+
+	if (pFindActivate != impl_->mapActivateDataValidations.end())
+	{
+		pFindActivate->second->activate_ref += L" " + ref;
+	}
+	else
+	{
+		std::map<std::wstring, xlsx_dataValidation_ptr>::iterator pFind = impl_->mapDataValidations.find(name);
+
+		if (pFind != impl_->mapDataValidations.end())
+		{
+			pFind->second->activate_ref = ref;
+			impl_->mapActivateDataValidations.insert(std::make_pair(name, pFind->second));
+		}
+	}
+}
+void xlsx_dataValidations_context::add_help_msg(const std::wstring & name, bool val)
+{
+	std::map<std::wstring, xlsx_dataValidation_ptr>::iterator pFind = impl_->mapDataValidations.find(name);
+
+	if (pFind == impl_->mapDataValidations.end()) return;
+	
+	pFind->second->showInputMessage = val;
+}
+
+void xlsx_dataValidations_context::add_error_msg(const std::wstring & name, bool val)
+{
+	std::map<std::wstring, xlsx_dataValidation_ptr>::iterator pFind = impl_->mapDataValidations.find(name);
+
+	if (pFind == impl_->mapDataValidations.end()) return;
+	
+	pFind->second->showErrorMessage = val;
+}
+
+void xlsx_dataValidations_context::add(const std::wstring & name, const std::wstring &ref)
+{
+	xlsx_dataValidation_ptr _new = xlsx_dataValidation_ptr(new xlsx_dataValidation());
+
+	formulasconvert::odf2oox_converter converter;
+	_new->ref = converter.convert_named_ref(ref, false, L";");
+
+	impl_->mapDataValidations.insert(std::make_pair(name, _new));
+}
+
+void xlsx_dataValidations_context::add_formula(const std::wstring & name, const std::wstring & f) // todooo пооптимальней
+{
+	std::map<std::wstring, xlsx_dataValidation_ptr>::iterator pFind = impl_->mapDataValidations.find(name);
+
+	if (pFind == impl_->mapDataValidations.end()) return;
+
+	formulasconvert::odf2oox_converter converter;
+	int pos = -1;
+	std::wstring val;
+	
+	if ( 0 <= (pos = f.find(L"cell-content-is-in-list"))) //oooc: , of:
+	{
+		pFind->second->type = L"list";
+		val = f.substr(24 + pos, f.size() - 25 - pos);
+		
+		if ( val.substr(0, 1) == L"\"") 
+		{
+			XmlUtils::replace_all(val, L"\"", L"");
+		
+			pFind->second->formula1 = converter.convert(val);
+
+			if ( std::wstring::npos != val.find(L";") )//convert formula replacing ; on ,
+			{
+				pFind->second->formula1 = L"\"" + pFind->second->formula1 + L"\"";
+			}
+		}
+		else
+		{
+			pFind->second->formula1 = converter.convert(val);
+		}
+	}
+}
+
+}
+}

ASCOfficeOdfFile/src/docx/xlsx_data_validation.h

@@ -1,44 +1,61 @@
-/*
- * (c) Copyright Ascensio System SIA 2010-2017
- *
- * This program is a free software product. You can redistribute it and/or
- * modify it under the terms of the GNU Affero General Public License (AGPL)
- * version 3 as published by the Free Software Foundation. In accordance with
- * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
- * that Ascensio System SIA expressly excludes the warranty of non-infringement
- * of any third-party rights.
- *
- * This program is distributed WITHOUT ANY WARRANTY; without even the implied
- * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
- * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
- *
- * You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
- * EU, LV-1021.
- *
- * The  interactive user interfaces in modified source and object code versions
- * of the Program must display Appropriate Legal Notices, as required under
- * Section 5 of the GNU AGPL version 3.
- *
- * Pursuant to Section 7(b) of the License you must retain the original Product
- * logo when distributing the program. Pursuant to Section 7(e) we decline to
- * grant you any rights under trademark law for use of our trademarks.
- *
- * All the Product's GUI elements, including illustrations and icon sets, as
- * well as technical writing content are licensed under the terms of the
- * Creative Commons Attribution-ShareAlike 4.0 International. See the License
- * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
- *
- */
-#pragma once
-#ifndef COMMON_UTILS_INCLUDE_H_
-#define COMMON_UTILS_INCLUDE_H_
-
-#include "../SystemUtility/SystemUtility.h"
-#include <vector>
-
-namespace Common
-{
-void readAllShapeTypes(const OOX::CPath& oPath, std::vector<std::wstring>& aShapetypes);
-} // namespace Common
-
-#endif // COMMON_UTILS_INCLUDE_H_
+/*
+ * (c) Copyright Ascensio System SIA 2010-2017
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
+ * EU, LV-1021.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+#pragma once
+
+#include <cpdoccore/CPOptional.h>
+#include <cpdoccore/CPScopedPtr.h>
+#include <string>
+
+namespace cpdoccore {
+namespace oox {
+
+class xlsx_dataValidations_context
+{
+public:
+    xlsx_dataValidations_context();
+    ~xlsx_dataValidations_context();
+
+	void add(const std::wstring & name, const std::wstring & ref);
+	void add_formula(const std::wstring & name, const std::wstring & f);
+	void add_help_msg(const std::wstring & name, bool val);
+	void add_error_msg(const std::wstring & name, bool val);
+
+	void activate(const std::wstring & name, const std::wstring & ref);
+
+    void serialize(std::wostream & _Wostream);
+private:
+    class Impl;
+    _CP_SCOPED_PTR(Impl) impl_;
+};
+
+}
+}

ASCOfficeOdfFile/src/docx/xlsx_output_xml.cpp

@@ -54,6 +54,8 @@ public:
     std::wstringstream	sort_;
     std::wstringstream	autofilter_;
 	std::wstringstream	conditionalFormatting_;
+	std::wstringstream  picture_background_;
+	std::wstringstream  dataValidations_;
 	std::wstringstream	ole_objects_;
 	std::wstringstream	page_props_;
 
@@ -138,7 +140,14 @@ std::wostream & xlsx_xml_worksheet::page_properties()
 {
     return impl_->page_props_;
 }
-
+std::wostream & xlsx_xml_worksheet::picture_background()
+{
+    return impl_->picture_background_;
+}
+std::wostream & xlsx_xml_worksheet::dataValidations()
+{
+    return impl_->dataValidations_;
+}
 //---------------------------------------------------------------------------------------
 rels & xlsx_xml_worksheet::sheet_rels()
 {
@@ -178,6 +187,7 @@ void xlsx_xml_worksheet::write_to(std::wostream & strm)
 
 			CP_XML_STREAM() << impl_->conditionalFormatting_.str();
 
+			CP_XML_STREAM() << impl_->dataValidations_.str();
 			if (!impl_->hyperlinks_.str().empty())
             {
                 CP_XML_NODE(L"hyperlinks")
@@ -207,6 +217,7 @@ void xlsx_xml_worksheet::write_to(std::wostream & strm)
 					CP_XML_STREAM() << impl_->ole_objects_.str();
                 }
             }
+			CP_XML_STREAM() << impl_->picture_background_.str();
 
 			//CP_XML_NODE(L"headerFooter){}
 

ASCOfficeOdfFile/src/docx/xlsx_output_xml.h

@@ -61,6 +61,8 @@ public:
     std::wostream & comments();
 	std::wostream & autofilter();
 	std::wostream & conditionalFormatting();
+	std::wostream & picture_background();
+	std::wostream & dataValidations();
 	std::wostream & sort();
 	std::wostream & ole_objects();
 	std::wostream & page_properties();

ASCOfficeOdfFile/src/docx/xlsx_table_state.h

@@ -120,7 +120,7 @@ public:
     xlsx_table_metrics					& get_table_metrics()					{ return xlsx_table_metrics_; }
     xlsx_drawing_context				& get_drawing_context()					{ return xlsx_drawing_context_; }
     xlsx_comments_context				& get_comments_context()				{ return xlsx_comments_context_; }
-	xlsx_conditionalFormatting_context	& get_conditionalFormatting_context()	{return xlsx_conditionalFormatting_context_;}
+	xlsx_conditionalFormatting_context	& get_conditionalFormatting_context()	{ return xlsx_conditionalFormatting_context_;}
 
     void	table_column_last_width(double w) { table_column_last_width_ = w; }
     double	table_column_last_width() const { return table_column_last_width_; };

ASCOfficeOdfFile/src/docx/xlsx_tablecontext.cpp

@@ -324,6 +324,10 @@ void xlsx_table_context::serialize_background(std::wostream & _Wostream)
 {
     return state()->serialize_background(_Wostream);
 }
+void xlsx_table_context::serialize_data_validation(std::wostream & _Wostream)
+{
+    return xlsx_conversion_context_->get_dataValidations_context().serialize(_Wostream);
+}
 void xlsx_table_context::serialize_hyperlinks(std::wostream & _Wostream)
 {
     return state()->serialize_hyperlinks(_Wostream);

ASCOfficeOdfFile/src/docx/xlsx_tablecontext.h

@@ -91,6 +91,7 @@ public:
 	void serialize_ole_objects			(std::wostream & _Wostream);
 	void serialize_page_properties		(std::wostream & _Wostream);
 	void serialize_background			(std::wostream & _Wostream);
+	void serialize_data_validation		(std::wostream & _Wostream);
 
 	xlsx_table_metrics & get_table_metrics();
   

ASCOfficeOdfFile/src/docx/xlsx_textcontext.cpp

@@ -49,13 +49,6 @@
 namespace cpdoccore {
 namespace oox {
 
-void removeCharsFromString( std::wstring &str, std::wstring charsToRemove ) 
-{
-   for ( unsigned int i = 0; i < charsToRemove.length(); ++i ) 
-   {
-	   str.erase( std::remove(str.begin(), str.end(), charsToRemove[i]), str.end() );
-   }
-}
 
 class xlsx_text_context::Impl: boost::noncopyable
 {

ASCOfficeOdfFile/src/docx/xlsxconversioncontext.cpp

@@ -437,6 +437,7 @@ void xlsx_conversion_context::end_table()
     get_table_context().serialize_autofilter			(current_sheet().autofilter());
     get_table_context().serialize_sort					(current_sheet().sort());
     get_table_context().serialize_merge_cells			(current_sheet().mergeCells());
+	get_table_context().serialize_data_validation		(current_sheet().dataValidations());
     
 	get_drawing_context().set_odf_packet_path			(root()->get_folder());
     get_drawing_context().process_objects				(get_table_metrics());

ASCOfficeOdfFile/src/docx/xlsxconversioncontext.h

@@ -49,6 +49,7 @@
 #include "xlsx_defined_names.h"
 #include "xlsx_table_metrics.h"
 #include "xlsx_pivots_context.h"
+#include "xlsx_data_validation.h"
 #include "oox_chart_context.h"
 
 #include "mediaitems.h"
@@ -179,6 +180,7 @@ public:
     xlsx_drawing_context_handle & get_drawing_context_handle();	
     xlsx_comments_context       & get_comments_context();
 	xlsx_comments_context_handle & get_comments_context_handle();
+	xlsx_dataValidations_context& get_dataValidations_context()	{ return xlsx_dataValidations_context_;}
 
     mediaitems & get_mediaitems() { return mediaitems_; }
 
@@ -212,6 +214,7 @@ private:
 	xlsx_pivots_context				xlsx_pivots_context_;
     xlsx_drawing_context_handle     xlsx_drawing_context_handle_;
     xlsx_comments_context_handle    xlsx_comments_context_handle_;
+	xlsx_dataValidations_context	xlsx_dataValidations_context_;
 };
 
 }

ASCOfficeOdfFile/src/odf/chart_build_oox.cpp

@@ -233,8 +233,9 @@ void object_odf_context::docx_convert(oox::docx_conversion_context & Context)
 		Context.set_paragraph_state	(false);		
 		Context.set_run_state		(false);
 
+		Context.get_math_context().base_font_size_ = baseFontHeight_;	
+		
 		Context.start_math_formula();
-			Context.get_math_context().base_font_size_ = baseFontHeight_;	
 			office_math_->oox_convert(Context.get_math_context());
 		Context.end_math_formula();
 

ASCOfficeOdfFile/src/odf/datatypes/chartdatalabelnumber.cpp

@@ -41,9 +41,10 @@ std::wostream & operator << (std::wostream & _Wostream, const chart_data_label_n
 {
 	switch(_Val.get_type())
 	{
-	case   chart_data_label_number::none: _Wostream <<  L"none"; break;
-	case   chart_data_label_number::value: _Wostream <<  L"value"; break;
-	case   chart_data_label_number::percentage : _Wostream <<  L"percentage"; break;
+	case chart_data_label_number::none:					_Wostream <<  L"none"; break;
+	case chart_data_label_number::value:				_Wostream <<  L"value"; break;
+	case chart_data_label_number::percentage :			_Wostream <<  L"percentage"; break;
+	case chart_data_label_number::value_and_percentage:	_Wostream <<  L"value-and-percentage"; break;
 	}
     return _Wostream;    
 }
@@ -59,9 +60,10 @@ chart_data_label_number chart_data_label_number::parse(const std::wstring & Str)
         return chart_data_label_number( value );
     else if (tmp == L"percentage")
         return chart_data_label_number( percentage );
-    else
+	else if (tmp == L"value-and-percentage")
+		return chart_data_label_number( value_and_percentage );
+	else
     {
-        BOOST_THROW_EXCEPTION( errors::invalid_attribute() );        
         return chart_data_label_number( none );
     }
 }

ASCOfficeOdfFile/src/odf/datatypes/chartdatalabelnumber.h

@@ -45,7 +45,8 @@ public:
     {
         none,
         value,
-        percentage
+        percentage,
+		value_and_percentage
     };
 
     chart_data_label_number() {}

ASCOfficeOdfFile/src/odf/documentcontext.cpp

@@ -61,6 +61,7 @@ private:
 
 document_context::document_context() : impl_( new document_context::Impl() )
 {            
+	level = 0;
 }
 
 document_context::~document_context()

ASCOfficeOdfFile/src/odf/documentcontext.h

@@ -45,10 +45,11 @@ class document_context
 public:
     document_context();
     virtual ~document_context();
-
-public:
+				
     void set_last_paragraph(text::paragraph * Paragraph);
     text::paragraph * get_last_paragraph();
+
+	int level;
     
 private:
     class Impl;

ASCOfficeOdfFile/src/odf/office_body.cpp

@@ -151,6 +151,8 @@ void office_body::docx_convert(oox::docx_conversion_context & Context)
 	{
 		if (page_layout_instance * lastPageLayout = Context.root()->odf_context().pageLayoutContainer().page_layout_by_name(Context.get_page_properties()))
 		{
+			Context.next_dump_page_properties(true);
+			
 			lastPageLayout->docx_serialize(Context.output_stream(), Context);
 			//Context.remove_page_properties();
 		}

ASCOfficeOdfFile/src/odf/office_chart.cpp

@@ -80,7 +80,16 @@ void chart_chart::add_attributes( const xml::attributes_wc_ptr & Attributes )
 
 void chart_chart::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
 {
-	CP_CREATE_ELEMENT(content_);
+	if CP_CHECK_NAME(L"text", L"tracked-changes") 
+	{
+		CP_CREATE_ELEMENT(tracked_changes_);
+	}
+	else if CP_CHECK_NAME(L"table", L"content-validations")
+	{
+		CP_CREATE_ELEMENT(content_validations_);
+	}
+	else
+		CP_CREATE_ELEMENT(content_);
 }
 void chart_title_attlist::add_attributes( const xml::attributes_wc_ptr & Attributes )
 {

ASCOfficeOdfFile/src/odf/office_chart.h

@@ -60,7 +60,10 @@ private:
     virtual void add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name);
 
 public:
-    office_element_ptr_array content_;
+	office_element_ptr			tracked_changes_;
+	office_element_ptr			content_validations_;
+    
+	office_element_ptr_array	content_;
 
 };
 
@@ -105,6 +108,10 @@ private:
 
 public:
     chart_chart_attlist			attlist_;
+	
+	office_element_ptr			tracked_changes_;
+	office_element_ptr			content_validations_;
+	
 	office_element_ptr_array	content_;
 };
 

ASCOfficeOdfFile/src/odf/office_elements_type.h

@@ -233,6 +233,14 @@ enum ElementType
 	typeTableDatabaseRange,
 	typeTableSort,
 	typeTableSortBy,
+	typeTableCalculationSettings,
+    typeTableNullDate,
+    typeTableShapes,
+	typeTableContentValidation,
+	typeTableContentValidations,
+	typeTableHelpMassage,
+	typeTableErrorMassage,
+	typeTableErrorMacro,
 
 	typeTableFilter,
 	typeTableFilterAnd,
@@ -411,9 +419,6 @@ enum ElementType
 
 	typeScriptEventListener,
 
-	typeTableCalculationSettings,
-    typeTableNullDate,
-
     typeNumberNumberStyle,
     typeNumberDataStyle,
     typeNumberText,
@@ -436,7 +441,6 @@ enum ElementType
     typeNumberMinutes,
     typeNumberSeconds,
     typeNumberAmPm,
-    typeTableShapes,
 
     typeChartChart,
     typeChartTitle,

ASCOfficeOdfFile/src/odf/office_presentation.cpp

@@ -54,11 +54,25 @@ const wchar_t * office_presentation::name = L"presentation";
 void office_presentation::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
 {
 	if	CP_CHECK_NAME(L"draw", L"page") 
+	{
 		CP_CREATE_ELEMENT(pages_);
+	}
+	else if CP_CHECK_NAME(L"table", L"tracked-changes")
+	{
+		CP_CREATE_ELEMENT(tracked_changes_);
+	}
+	else if CP_CHECK_NAME(L"table", L"content-validations")
+	{
+		CP_CREATE_ELEMENT(content_validations_);
+	}
 	else if CP_CHECK_NAME(L"presentation", L"footer-decl") 
+	{
 		CP_CREATE_ELEMENT(footer_decls_);
+	}
 	else if CP_CHECK_NAME(L"presentation", L"date-time-decl") 
+	{
 		CP_CREATE_ELEMENT(date_time_decls_);
+	}
 
 }
 

ASCOfficeOdfFile/src/odf/office_presentation.h

@@ -62,10 +62,13 @@ private:
 
 public:
 
-    office_element_ptr_array date_time_decls_;
-    office_element_ptr_array footer_decls_;
+	office_element_ptr			tracked_changes_;
+	office_element_ptr			content_validations_;
+    
+    office_element_ptr_array	date_time_decls_;
+    office_element_ptr_array	footer_decls_;
   
-	office_element_ptr_array pages_;
+	office_element_ptr_array	pages_;
 
 };
 

ASCOfficeOdfFile/src/odf/office_spreadsheet.cpp

@@ -63,6 +63,10 @@ void office_spreadsheet::add_child_element( xml::sax * Reader, const std::wstrin
 	{
 		CP_CREATE_ELEMENT(tracked_changes_);
 	}
+	else if CP_CHECK_NAME(L"table", L"content-validations")
+	{
+		CP_CREATE_ELEMENT(content_validations_);
+	}
 	else
 		CP_CREATE_ELEMENT(content_);
 }
@@ -88,6 +92,9 @@ void office_spreadsheet::xlsx_convert(oox::xlsx_conversion_context & Context)
 	if (database_ranges_)
 		database_ranges_->xlsx_convert(Context);
 
+	if (content_validations_)
+		content_validations_->xlsx_convert(Context);
+
 	if (data_pilot_tables_)
 		data_pilot_tables_->xlsx_convert(Context);
 	

ASCOfficeOdfFile/src/odf/office_spreadsheet.h

@@ -62,12 +62,12 @@ public:
 	office_element_ptr			database_ranges_; 
 	office_element_ptr			data_pilot_tables_;
 	office_element_ptr			tracked_changes_;
-
+	office_element_ptr			content_validations_;
+	
 	office_element_ptr_array	content_;
  	
 	// table:calculation-settings
 	// table:consolidation
-	// table:content-validations
 	// table:dde-links
 	// table:label-ranges
 	

ASCOfficeOdfFile/src/odf/office_text.cpp

@@ -101,6 +101,10 @@ void office_text::add_child_element( xml::sax * Reader, const std::wstring & Ns,
 	{
 		CP_CREATE_ELEMENT(tracked_changes_);
 	}
+	else if CP_CHECK_NAME(L"table", L"content-validations")
+	{
+		CP_CREATE_ELEMENT(content_validations_);
+	}
 	else if (is_text_content(Ns, Name))
     {
         CP_CREATE_ELEMENT(content_);

ASCOfficeOdfFile/src/odf/office_text.h

@@ -67,7 +67,9 @@ private:
     //  TODO: table-decls
 
 	office_element_ptr			tracked_changes_;
-    office_element_ptr_array	content_;
+	office_element_ptr			content_validations_;
+    
+	office_element_ptr_array	content_;
     // TODO: text-page-sequence
     // TODO: office-text-content-epilogue:
     // TODO: table-functions

ASCOfficeOdfFile/src/odf/style_table_properties.cpp

@@ -213,7 +213,7 @@ void style_table_column_properties::docx_convert(oox::docx_conversion_context &
 		double kf_max_width_ms =1.;
 
 		const page_layout_instance * pp = Context.root()->odf_context().pageLayoutContainer().page_layout_first();//
-		if (pp)
+		if ((pp) && (pp->properties()))
 		{
 			style_page_layout_properties_attlist & attr_page = pp->properties()->attlist_;
 			if (attr_page.fo_page_width_)

ASCOfficeOdfFile/src/odf/style_text_properties.cpp

@@ -53,7 +53,7 @@ namespace odf_reader {
 
 void removeCharsFromString( std::wstring &str, std::wstring charsToRemove ) 
 {
-   for ( unsigned int i = 0; i < charsToRemove.length(); ++i ) 
+   for ( size_t i = 0; i < charsToRemove.length(); ++i ) 
    {
 	   str.erase( std::remove(str.begin(), str.end(), charsToRemove[i]), str.end() );
    }
@@ -292,14 +292,14 @@ void text_format_properties_content::pptx_convert_as_list(oox::pptx_conversion_c
 					w_font = font->name();
 
 				//'Arial' глючит
-				removeCharsFromString(w_font, _T("'"));
+				removeCharsFromString(w_font, L"'");
 			}
 
 			if (w_font.length()>0)
 			{				
 				CP_XML_NODE(L"a:buFont")
 				{			
-					removeCharsFromString(w_font, _T("'"));
+					removeCharsFromString(w_font, L"'");
 					CP_XML_ATTR(L"typeface", w_font);
 					if ((style_font_charset_))
 					{		

ASCOfficeOdfFile/src/odf/table.cpp

@@ -728,7 +728,61 @@ void table_shapes::add_child_element( xml::sax * Reader, const std::wstring & Ns
     CP_CREATE_ELEMENT(content_);
 }
 
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// table:content-validations
+const wchar_t * table_content_validations::ns = L"table";
+const wchar_t * table_content_validations::name = L"content-validations";
 
+void table_content_validations::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
+{
+    CP_CREATE_ELEMENT(content_);
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// table:content-validation
+const wchar_t * table_content_validation::ns = L"table";
+const wchar_t * table_content_validation::name = L"content-validation";
 
+void table_content_validation::add_attributes(xml::attributes_wc_ptr const & Attributes)
+{
+    CP_APPLY_ATTR(L"table:name",				table_name_);
+    CP_APPLY_ATTR(L"table:condition",			table_condition_);
+	CP_APPLY_ATTR(L"table:display-list",		table_display_list_);
+	CP_APPLY_ATTR(L"table:allowempty-cell",		table_allowempty_cell_);
+	CP_APPLY_ATTR(L"table:base-cell-address",	table_base_cell_address_);
+}
+void table_content_validation::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
+{
+    CP_CREATE_ELEMENT(content_);
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// table:content-validation
+const wchar_t * table_error_message::ns = L"table";
+const wchar_t * table_error_message::name = L"error-message";
+
+void table_error_message::add_attributes(xml::attributes_wc_ptr const & Attributes)
+{
+    CP_APPLY_ATTR(L"table:title",			table_title_);
+    CP_APPLY_ATTR(L"table:message-type",	table_message_type_);
+	CP_APPLY_ATTR(L"table:display",			table_display_);
+}
+void table_error_message::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
+{
+    CP_CREATE_ELEMENT(content_);
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////
+// table:content-validation
+const wchar_t * table_help_message::ns = L"table";
+const wchar_t * table_help_message::name = L"help-message";
+
+void table_help_message::add_attributes(xml::attributes_wc_ptr const & Attributes)
+{
+    CP_APPLY_ATTR(L"table:title",			table_title_);
+    CP_APPLY_ATTR(L"table:message-type",	table_message_type_);
+	CP_APPLY_ATTR(L"table:display",			table_display_);
+}
+void table_help_message::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
+{
+    CP_CREATE_ELEMENT(content_);
+}
 }
 }

ASCOfficeOdfFile/src/odf/table.h

@@ -653,6 +653,7 @@ public:
 };
 CP_REGISTER_OFFICE_ELEMENT2(table_table);
 
+//table:content-shapes
 class table_shapes : public office_element_impl<table_shapes>
 {
 public:
@@ -676,5 +677,105 @@ private:
 };
 CP_REGISTER_OFFICE_ELEMENT2(table_shapes);
 
+//table:content-validations
+class table_content_validations : public office_element_impl<table_content_validations>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeTableContentValidations;
+
+    CPDOCCORE_DEFINE_VISITABLE();
+
+    virtual void xlsx_convert(oox::xlsx_conversion_context & Context) ;
+
+private:
+	virtual void add_attributes( const xml::attributes_wc_ptr & Attributes ){}
+    virtual void add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name);
+
+    office_element_ptr_array content_;
+
+};
+CP_REGISTER_OFFICE_ELEMENT2(table_content_validations);
+
+//table:content-validation
+class table_content_validation : public office_element_impl<table_content_validation>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeTableContentValidation;
+
+    CPDOCCORE_DEFINE_VISITABLE();
+
+    virtual void xlsx_convert(oox::xlsx_conversion_context & Context) ;
+
+private:
+	virtual void add_attributes( const xml::attributes_wc_ptr & Attributes );
+    virtual void add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name);
+
+    _CP_OPT(std::wstring)		table_name_;
+	_CP_OPT(odf_types::Bool)	table_allowempty_cell_;
+	_CP_OPT(std::wstring)		table_display_list_;
+    _CP_OPT(std::wstring)		table_condition_;
+    _CP_OPT(std::wstring)		table_base_cell_address_;
+
+    office_element_ptr_array	content_;
+};
+CP_REGISTER_OFFICE_ELEMENT2(table_content_validation);
+
+//table:error-message
+class table_error_message : public office_element_impl<table_error_message>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeTableErrorMassage;
+
+    CPDOCCORE_DEFINE_VISITABLE();
+
+    virtual void xlsx_convert(oox::xlsx_conversion_context & Context) ;
+
+private:
+	virtual void add_attributes( const xml::attributes_wc_ptr & Attributes );
+    virtual void add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name);
+
+    _CP_OPT(std::wstring)		table_title_;
+	_CP_OPT(odf_types::Bool)	table_display_;
+    _CP_OPT(std::wstring)		table_message_type_;
+
+    office_element_ptr_array	content_;
+};
+CP_REGISTER_OFFICE_ELEMENT2(table_error_message);
+
+//table:help-message
+class table_help_message : public office_element_impl<table_help_message>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeTableHelpMassage;
+
+    CPDOCCORE_DEFINE_VISITABLE();
+
+    virtual void xlsx_convert(oox::xlsx_conversion_context & Context) ;
+
+private:
+	virtual void add_attributes( const xml::attributes_wc_ptr & Attributes );
+    virtual void add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name);
+
+    _CP_OPT(std::wstring)		table_title_;
+	_CP_OPT(odf_types::Bool)	table_display_;
+    _CP_OPT(std::wstring)		table_message_type_;
+
+    office_element_ptr_array	content_;
+};
+CP_REGISTER_OFFICE_ELEMENT2(table_help_message);
+
+//table:error-macro
 }
 }

ASCOfficeOdfFile/src/odf/table_xlsx.cpp

@@ -803,11 +803,13 @@ void table_table_cell::xlsx_convert(oox::xlsx_conversion_context & Context)
     
 	is_style_visible = (!cellStyleName.empty() || defaultColumnCellStyle) ? true : false;
 
-	if ( content_.elements_.size() > 0	|| 
-		!formula.empty()	||
+	if ( content_.elements_.size() > 0	|| attlist_.table_content_validation_name_ || !formula.empty()	||
 		(	t_val == oox::XlsxCellType::n										&& !number_val.empty()) || 
 		(	t_val == oox::XlsxCellType::b										&& bool_val) ||
-		((	t_val == oox::XlsxCellType::str || oox::XlsxCellType::inlineStr)	&& str_val))	is_data_visible = true;
+		((	t_val == oox::XlsxCellType::str || oox::XlsxCellType::inlineStr)	&& str_val))	
+	{
+		is_data_visible = true;
+	}
 
 	if (attlist_.table_number_columns_repeated_ < 199 && last_cell_)	last_cell_ = false;
 	
@@ -837,15 +839,20 @@ void table_table_cell::xlsx_convert(oox::xlsx_conversion_context & Context)
 			t_val = oox::XlsxCellType::s;//в случае текста, если он есть берем кэшированное значение
 			
 		if (skip_next_cell)break;
-
-        // пустые ячейки пропускаем.
+	
+	// пустые ячейки пропускаем.
         if ( is_data_visible || ((cellStyle || defaultColumnCellStyle) && is_style_visible))
         {
-            CP_XML_WRITER(strm)
+			std::wstring ref = oox::getCellAddress(Context.current_table_column(), Context.current_table_row());
+			if (attlist_.table_content_validation_name_)
+			{
+				Context.get_dataValidations_context().activate(*attlist_.table_content_validation_name_, ref);
+			}   
+			CP_XML_WRITER(strm)
             {
                 CP_XML_NODE(L"c")
                 {
-                    CP_XML_ATTR(L"r", oox::getCellAddress(Context.current_table_column(), Context.current_table_row()));
+                    CP_XML_ATTR(L"r", ref);
                     CP_XML_ATTR(L"t", oox::cellType2Str(t_val));
                     CP_XML_ATTR(L"s", xfId_last_set);
 
@@ -887,6 +894,7 @@ void table_table_cell::xlsx_convert(oox::xlsx_conversion_context & Context)
                     {
                         CP_XML_NODE(L"v")   { CP_XML_CONTENT((int)(bool_val.get())); }
                     }
+
                 }
 				if ( is_data_visible || (cellStyle && is_style_visible && !last_cell_))
 				{
@@ -1179,5 +1187,38 @@ void table_covered_table_cell::xlsx_convert(oox::xlsx_conversion_context & Conte
     }
 }
 
+void table_content_validations::xlsx_convert(oox::xlsx_conversion_context & Context) 
+{
+	for (size_t i = 0 ; i < content_.size(); i++)
+	{
+		content_[i]->xlsx_convert(Context);
+    }
+}
+void table_content_validation::xlsx_convert(oox::xlsx_conversion_context & Context) 
+{
+	std::wstring name = table_name_.get_value_or(L"");
+	
+	Context.get_dataValidations_context().add(name, table_base_cell_address_.get_value_or(L""));
+	Context.get_dataValidations_context().add_formula(name, table_condition_.get_value_or(L""));
+	
+	for (size_t i = 0 ; i < content_.size(); i++)
+	{
+		if (content_[i]->get_type() == typeTableErrorMassage)
+		{
+			Context.get_dataValidations_context().add_error_msg(name, true);
+		}
+		else if (content_[i]->get_type() == typeTableErrorMassage)
+		{
+			Context.get_dataValidations_context().add_help_msg(name, true);
+		}
+		content_[i]->xlsx_convert(Context);
+    }
+}
+void table_error_message::xlsx_convert(oox::xlsx_conversion_context & Context) 
+{
+}
+void table_help_message::xlsx_convert(oox::xlsx_conversion_context & Context) 
+{
+}
 }
 }

ASCOfficeOdfFile/src/odf/text_elements.cpp

@@ -312,14 +312,29 @@ void paragraph::afterCreate(document_context * Context)
     // вызывается сразу после создания объекта
     if (Context)
     {
-        // выставляем у предыдущего параграфа указатель на следующий (т.е. на вновь созданный)
-        if (paragraph * prevPar = Context->get_last_paragraph())
-            prevPar->set_next(this);
-        
-        // запоминаем в контексте вновь созданный параграф
-        Context->set_last_paragraph(this);
+		Context->level++;
+		// выставляем у предыдущего параграфа указатель на следующий (т.е. на вновь созданный)
+
+		if (Context->level == 1)
+		{
+			if (paragraph * prevPar = Context->get_last_paragraph())
+			{
+				prevPar->set_next(this);
+			}
+	        
+			// запоминаем в контексте вновь созданный параграф
+			Context->set_last_paragraph(this);
+		}
     }
 }
+void paragraph::afterReadContent(document_context * Context)
+{
+    if (Context)
+    {
+		Context->level--;
+    }
+}
+
 const wchar_t * emptyParagraphContent = L"<w:pPr></w:pPr><w:r><w:rPr></w:rPr></w:r>";
 
 const wchar_t * emptyParagraphDrawing = L"<w:p><w:pPr></w:pPr></w:p>";
@@ -435,27 +450,6 @@ void paragraph::docx_convert(oox::docx_conversion_context & Context)
 	
 	std::wostream & _Wostream = Context.output_stream();
 
-    if (next_par_)
-    {
-        // проверяем не сменит ли следующий параграф свойства страницы.
-        // если да — устанавливаем контексту флаг на то что необходимо в конце текущего параграфа 
-        // распечатать свойства раздела
-		//проверить ... не она ли текущая - может быть прописан дубляж - и тогда разрыв нарисуется ненужный
-        const std::wstring & next_styleName				= next_par_->attrs_.text_style_name_;
-        const _CP_OPT(std::wstring) next_masterPageName	= Context.root()->odf_context().styleContainer().master_page_name_by_name(next_styleName);
-
-        if ((next_masterPageName)  && (Context.get_master_page_name() != *next_masterPageName))
-        {
-            Context.next_dump_page_properties(true);
-			is_empty = false;
-        }
-    } 
-	if (next_section_ || next_end_section_)
-	{
-		Context.get_section_context().get().is_dump_ = true;
-		is_empty = false;
-	}
-
     const _CP_OPT(std::wstring) masterPageName	= Context.root()->odf_context().styleContainer().master_page_name_by_name(styleName);
    
 	if (masterPageName)
@@ -469,6 +463,27 @@ void paragraph::docx_convert(oox::docx_conversion_context & Context)
 
 		is_empty = false;
     }    
+
+    if (next_par_)
+    {
+        // проверяем не сменит ли следующий параграф свойства страницы.
+        // если да — устанавливаем контексту флаг на то что необходимо в текущем параграфе
+        // распечатать свойства раздела/секции
+		//проверить ... не она ли текущая - может быть прописан дубляж - и тогда разрыв нарисуется ненужный
+        const std::wstring & next_styleName				= next_par_->attrs_.text_style_name_;
+        const _CP_OPT(std::wstring) next_masterPageName	= Context.root()->odf_context().styleContainer().master_page_name_by_name(next_styleName);
+
+        if ((next_masterPageName)  && (Context.get_master_page_name() != *next_masterPageName))
+        {
+            Context.next_dump_page_properties(true);
+			is_empty = false;
+        }
+    } 
+	if (next_section_/* || next_end_section_*/)
+	{
+		Context.get_section_context().get().is_dump_ = true;
+		is_empty = false;
+	}
 	std::wstringstream strm;
 	if (Context.process_page_properties(strm))
 	{
@@ -604,7 +619,10 @@ void h::afterCreate()
 {
     paragraph_.afterCreate( getContext() );
 }
-
+void h::afterReadContent()
+{
+    paragraph_.afterReadContent( getContext() );
+}
 void h::docx_convert(oox::docx_conversion_context & Context) 
 {
     paragraph_.docx_convert(Context);
@@ -627,7 +645,10 @@ void p::afterCreate()
 {
     paragraph_.afterCreate( getContext() );
 }
-
+void p::afterReadContent()
+{
+    paragraph_.afterReadContent( getContext() );
+}
 std::wostream & p::text_to_stream(std::wostream & _Wostream) const
 {
     return paragraph_.text_to_stream(_Wostream);

ASCOfficeOdfFile/src/odf/text_elements.h

@@ -73,7 +73,8 @@ public:
     }
 
     void afterCreate(document_context * ctx);
-   
+ 	void afterReadContent(document_context * ctx);
+  
 	void docx_convert (oox::docx_conversion_context & Context) ;
     void xlsx_convert (oox::xlsx_conversion_context & Context) ;
     void pptx_convert (oox::pptx_conversion_context & Context) ;
@@ -114,7 +115,9 @@ public:
     void pptx_convert(oox::pptx_conversion_context & Context) ;
 
     virtual void afterCreate();
-    virtual std::wostream & text_to_stream(std::wostream & _Wostream) const;
+    virtual void afterReadContent();
+    
+	virtual std::wostream & text_to_stream(std::wostream & _Wostream) const;
 
     paragraph paragraph_;
 
@@ -151,8 +154,9 @@ public:
 	void pptx_convert(oox::pptx_conversion_context & Context) ;
 
 	virtual void afterCreate();
-
-    virtual std::wostream & text_to_stream(std::wostream & _Wostream) const;
+	virtual void afterReadContent();
+    
+	virtual std::wostream & text_to_stream(std::wostream & _Wostream) const;
 
     p(){};
 	paragraph paragraph_;
@@ -245,7 +249,8 @@ public:
     void docx_convert(oox::docx_conversion_context & Context);
 
     virtual std::wostream & text_to_stream(std::wostream & _Wostream) const;
-    virtual void afterCreate();
+    
+	virtual void afterCreate();
     virtual void afterReadContent();
 
 private:

ASCOfficeOdfFile/win32/cpcommon.vcproj

@@ -53,7 +53,7 @@
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="4"
-				DisableSpecificWarnings="4311;4267;4996;4172"
+				DisableSpecificWarnings="4005;4311;4312"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"

ASCOfficeOdfFile/win32/cpodf.vcproj

@@ -53,7 +53,7 @@
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="false"
 				DebugInformationFormat="4"
-				DisableSpecificWarnings="4311;4267;4996;4172"
+				DisableSpecificWarnings="4005;4311;4312"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"
@@ -642,6 +642,14 @@
 					RelativePath="..\src\docx\xlsx_conditionalFormatting.h"
 					>
 				</File>
+				<File
+					RelativePath="..\src\docx\xlsx_data_validation.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\src\docx\xlsx_data_validation.h"
+					>
+				</File>
 				<File
 					RelativePath="..\src\docx\xlsx_defined_names.cpp"
 					>

ASCOfficeOdfFile/win32/cpxml.vcproj

@@ -53,7 +53,7 @@
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="4"
-				DisableSpecificWarnings="4311;4267;4996;4172"
+				DisableSpecificWarnings="4005;4311;4312"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"

ASCOfficeOdfFile/win32/formulasconvert.vcproj

@@ -49,7 +49,7 @@
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="4"
-				DisableSpecificWarnings="4311;4267;4996;4172"
+				DisableSpecificWarnings="4005;4311;4312"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"

ASCOfficeOdfFileW/linux/OdfFileWriterLib.pro

@@ -22,8 +22,6 @@ include($$PWD/../../Common/3dParty/boost/boost.pri)
 DEFINES +=  UNICODE \
             _UNICODE \
             _USE_LIBXML2_READER_ \
-            _USE_XMLLITE_READER_ \
-            USE_LITE_READER \
             LIBXML_READER_ENABLED \
             DONT_WRITE_EMBEDDED_FONTS
 

ASCOfficeOdfFileW/source/OdfFormat/object_package.cpp

@@ -151,13 +151,17 @@ namespace odf_writer
 					CP_XML_ATTR(L"xmlns:smil", L"urn:oasis:names:tc:opendocument:xmlns:smil-compatible:1.0");
 					CP_XML_ATTR(L"xmlns:anim", L"urn:oasis:names:tc:opendocument:xmlns:animation:1.0");
 					CP_XML_ATTR(L"xmlns:chartooo", L"http://openoffice.org/2010/chart");
-					CP_XML_ATTR(L"office:version",		L"1.2");		
+					CP_XML_ATTR(L"office:version", L"1.2");		
 		
 					CP_XML_NODE(L"office:meta")
 					{  
 						CP_XML_NODE(L"meta:generator")
 						{
-							CP_XML_STREAM() << L"ONLYOFFICE Online Editor";
+							CP_XML_STREAM() << L"ONLYOFFICE";
+#if defined(INTVER)
+							std::string s = VALUE2STR(INTVER);
+							CP_XML_STREAM() << L"/" << std::wstring (s.begin(), s.end() );
+#endif					
 						}
 						CP_XML_NODE(L"meta:initial-creator");
 						CP_XML_NODE(L"meta:creation-date");

ASCOfficeOdfFileW/source/OdfFormat/odf_chart_context.cpp

@@ -1624,9 +1624,9 @@ void odf_chart_context::set_cash(std::wstring format, std::vector<std::wstring>
 		ref1 = std::wstring(L"local-table.") + utils::getColAddress(start_col) + boost::lexical_cast<std::wstring>(start_row);
 		//
 		if (by_row)
-			ref2 = std::wstring(L"local-table.") + utils::getColAddress(start_col) + boost::lexical_cast<std::wstring>(start_row + count_cash_values);
+			ref2 = std::wstring(L"local-table.") + utils::getColAddress(start_col) + std::to_wstring(start_row + count_cash_values);
 		else
-			ref2 = std::wstring(L"local-table.") + utils::getColAddress(start_col + count_cash_values) + boost::lexical_cast<std::wstring>(start_row);
+			ref2 = std::wstring(L"local-table.") + utils::getColAddress(start_col + count_cash_values) + std::to_wstring(start_row);
 	
 		ref = ref1 + L":" + ref2;
 	}

ASCOfficeOdfFileW/source/OdfFormat/odf_number_styles_context.cpp

@@ -540,6 +540,7 @@ void odf_number_styles_context::create_date_style(number_format_state & state, o
 	boost::algorithm::to_lower(s);
 	
 	boost::wregex re(L"([a-zA-Z]+)(\\W+)");//(L"(\\w+)");
+	
 	std::list<std::wstring> result;
 	bool b = boost::regex_split(std::back_inserter(result),s, re);
 	result.push_back(s);//последний ..выносится - так уж работает boost.regex_split
@@ -627,12 +628,12 @@ void odf_number_styles_context::create_time_style(number_format_state & state, o
 
 	int res;
 	int sz=0;
-	for (std::list<std::wstring>::iterator i=result.begin(); i!=result.end(); ++i)
+	for (std::list<std::wstring>::iterator it = result.begin(); it != result.end(); ++it)
 	{
 		office_element_ptr elm;
-		s = *i;
+		s = *it;
 		sz = s.length();
-		if ((res=s.find(L"h")) >=0) 
+		if ((res=s.find(L"h")) >= 0) 
 		{
 			create_element(L"number", L"hours", elm, odf_context_);
 			number_hours* number_hours_ = dynamic_cast<number_hours*>(elm.get());		

ASCOfficeOdfFileW/source/OdfFormat/odp_slide_context.h

@@ -31,7 +31,7 @@
  */
 #pragma once
 
-#include <list>
+#include <vector>
 #include "odp_page_state.h"
 
 #include "odf_table_context.h"
@@ -83,7 +83,7 @@ private:
 	odf_table_context			table_context_;
 	odf_comment_context			comment_context_;
 	
-	std::list<odp_page_state>	page_state_list_;
+	std::vector<odp_page_state>	page_state_list_;
 	int							count_slides_;
 
 	friend class odp_conversion_context;

ASCOfficeOdfFileW/source/OdfFormat/ods_conversion_context.cpp

@@ -115,6 +115,10 @@ void ods_conversion_context::set_table_part_autofilter(bool val)
 {
 	table_context_.set_table_part_autofilter(val);
 }
+void ods_conversion_context::add_table_part_column(std::wstring name)
+{
+	table_context_.add_table_part_column(name);
+}
 void ods_conversion_context::end_table_part()
 {
 	table_context_.end_table_part();

ASCOfficeOdfFileW/source/OdfFormat/ods_conversion_context.h

@@ -110,6 +110,7 @@ public:
 	void start_table_part	(std::wstring name, std::wstring ref);
 	void end_table_part		();
 	void set_table_part_autofilter(bool val);
+	void add_table_part_column(std::wstring name);
 
 	void start_conditional_formats();
 	void end_conditional_formats(){}

ASCOfficeOdfFileW/source/OdfFormat/ods_table_context.cpp

@@ -78,8 +78,36 @@ void ods_table_context::start_table_part(std::wstring name, std::wstring ref)
 
 	table_database_ranges_.root->add_child_element(elm);
 	table_database_ranges_.elements.push_back(elm);
+
+	table_part_state part_state;
+	part_state.name = name;
+	part_state.ref = ref;
+
+	int r = ref.rfind(L":");
+	if (r < 0) return;//тута однозначно .. по правилам оох
+
+	utils::parsing_ref (ref.substr(0, r), part_state.col_start, part_state.row_start);
+	utils::parsing_ref (ref.substr(r + 1, ref.size() - r), part_state.col_end, part_state.row_end);
+
+	state().table_parts_.push_back(part_state);
 }
 
+void ods_table_context::add_table_part_column(std::wstring name)
+{
+	if (state().table_parts_.empty()) return;
+
+	size_t column = state().table_parts_.back().columns.size();
+
+	std::wstring sCol = utils::getColAddress(state().table_parts_.back().col_start + column - 1);
+
+	std::wstring ref;//table name ????
+
+	ref += sCol + std::to_wstring(state().table_parts_.back().row_start);
+	ref += L":";
+	ref += sCol + std::to_wstring(state().table_parts_.back().row_end);
+
+	state().table_parts_.back().columns.push_back(std::make_pair(name, ref));
+}
 void ods_table_context::set_table_part_autofilter(bool val)
 {
 	if (!val) return;
@@ -152,15 +180,13 @@ void ods_table_context::add_defined_range(const std::wstring & name, const std::
 	
 	if (sheet_id >=0)
 	{
-		int i=0;
-		for (std::list<ods_table_state>::iterator iter = table_state_list_.begin(); iter != table_state_list_.end(); iter++)
+		for (size_t i = 0; i < table_state_list_.size(); ++i)
 		{
 			if (i == sheet_id)
 			{
-				iter->add_definded_expression(elm);
+				table_state_list_[i].add_definded_expression(elm);
 				break;
 			}
-			i++;
 		}
 	}
 	else
@@ -187,31 +213,23 @@ void ods_table_context::add_defined_expression(const std::wstring & name, const
 	named_expression->table_name_		= name;
 	named_expression->table_expression_ = odf_value;
 	
-	if (sheet_id >=0)
+	if (sheet_id >=0 && sheet_id < table_state_list_.size())
 	{
-		int i=0;
-		for (std::list<ods_table_state>::iterator iter = table_state_list_.begin(); iter != table_state_list_.end(); iter++)
+		odf_base_cell = table_state_list_[sheet_id].office_table_name_ + L".$A$1";
+		table_state_list_[sheet_id].add_definded_expression(elm);
+		
+		if ( printable)
 		{
-			if (i == sheet_id)
-			{
-				odf_base_cell = iter->office_table_name_ + L".$A$1";
-				iter->add_definded_expression(elm);
-				if ( printable)
-				{
-					XmlUtils::replace_all( odf_value, L"[", L"");
-					XmlUtils::replace_all( odf_value, L"]", L"");
-					XmlUtils::replace_all( odf_value, L";", L" ");
+			XmlUtils::replace_all( odf_value, L"[", L"");
+			XmlUtils::replace_all( odf_value, L"]", L"");
+			XmlUtils::replace_all( odf_value, L";", L" ");
 
-					iter->set_print_range(odf_value);
-				}
-				break;
-			}
-			i++;
+			table_state_list_[sheet_id].set_print_range(odf_value);
 		}
 	}
 	else
 	{
-		if (!table_defined_expressions_.root)create_element(L"table", L"named-expressions",table_defined_expressions_.root,&context_);
+		if (!table_defined_expressions_.root)create_element(L"table", L"named-expressions", table_defined_expressions_.root,&context_);
 		table_defined_expressions_.root->add_child_element(elm);
 	}
 

ASCOfficeOdfFileW/source/OdfFormat/ods_table_context.h

@@ -52,8 +52,6 @@ struct table_additional_elements_state
 	std::vector<office_element_ptr> elements;
 };
 
-
-/// \class ods_table_context
 class ods_table_context
 {
 public:
@@ -76,13 +74,14 @@ public:
 	
 	void start_table_part(std::wstring name, std::wstring ref);
 		void set_table_part_autofilter(bool val);
+		void add_table_part_column(std::wstring name);
 	void end_table_part();
 
 private:
 
     ods_conversion_context & context_;
 
-	std::list<ods_table_state>		table_state_list_;
+	std::vector<ods_table_state>	table_state_list_;
 	
 	table_additional_elements_state	table_defined_expressions_;
 	table_additional_elements_state	table_database_ranges_;

ASCOfficeOdfFileW/source/OdfFormat/ods_table_state.cpp

@@ -634,15 +634,15 @@ void ods_table_state::set_merge_cells(int start_col, int start_row, int end_col,
 
 	if (spanned_cols > 10000)spanned_cols = 1024;
 
-	for (std::list<ods_cell_state>::iterator cell = cells_.begin(); cell != cells_.end(); cell++)
+	for (size_t i = 0; i < cells_.size(); ++i)
 	{
-		if (cell->row > end_row) break;
+		if (cells_[i].row > end_row) break;
 
-		if (cell->row >= start_row)
+		if (cells_[i].row >= start_row)
 		{
-			if (cell->col >= start_col)
+			if (cells_[i].col >= start_col)
 			{
-				table_table_cell* cell_elm = dynamic_cast<table_table_cell*>(cell->elm.get());
+				table_table_cell* cell_elm = dynamic_cast<table_table_cell*>(cells_[i].elm.get());
 				if (cell_elm == NULL)return;
 
 				cell_elm->table_table_cell_attlist_extra_.table_number_columns_spanned_ = spanned_cols;
@@ -668,6 +668,24 @@ void ods_table_state::set_cell_formula(std::wstring & formula)
 	}
 
 	std::wstring odfFormula = formulas_converter_table.convert_formula(formula);
+
+	if (std::wstring::npos != odfFormula.find(L"["))
+	{
+		for (size_t i = 0; i < table_parts_.size(); i++)
+		{
+			if (table_parts_[i].in_ref(current_table_column_, current_table_row_))
+			{
+				for (size_t j = 0; j < table_parts_[i].columns.size(); j ++)
+				{
+					std::wstring name = table_parts_[i].name + L"[" + table_parts_[i].columns[j].first + L"]";
+					//Таблица1[ Сумма за кв. 3 ]
+
+					XmlUtils::replace_all(odfFormula, name, table_parts_[i].columns[j].second);
+				}
+				break;
+			}
+		}
+	}
 	
 	table_table_cell* cell = dynamic_cast<table_table_cell*>(cells_.back().elm.get());
 	if (cell == NULL)return;
@@ -684,7 +702,7 @@ std::wstring ods_table_state::replace_cell_row(boost::wsmatch const & what)
         int col_formula=0, row_formula=0;
 		utils::parsing_ref(ref_formula, col_formula, row_formula);col_formula--;//инче отсчет с 1
 	
-		ref_formula = utils::getColAddress(col_formula)+boost::lexical_cast<std::wstring>(row_formula+current_table_row_ -tmp_row_);
+		ref_formula = utils::getColAddress(col_formula) + std::to_wstring(row_formula +current_table_row_ - tmp_row_);
 
 
 		return ref_formula;

ASCOfficeOdfFileW/source/OdfFormat/ods_table_state.h

@@ -69,7 +69,8 @@ class odf_text_context;
 class table_table;
 class style;
 
-namespace utils {
+namespace utils 
+{
 	static std::wstring getColAddress(size_t col)
 	{
 		static const size_t r = (L'Z' - L'A' + 1);
@@ -78,8 +79,8 @@ namespace utils {
 
 		if (r0 > 0)
 		{
-			const std::wstring rest = getColAddress(col - r*r0);
-			const std::wstring res = getColAddress(r0-1) + rest;
+			const std::wstring rest = getColAddress(col - r * r0);
+			const std::wstring res = getColAddress(r0 - 1) + rest;
 			return res;
 		}
 		else
@@ -210,6 +211,24 @@ struct ods_shared_formula_state
     int moving_type; //1 - col, 2 - row
 };
 
+struct table_part_state
+{
+	std::wstring name;
+	std::wstring ref;
+
+	int col_start = 0;
+	int row_start = 0;
+
+	int col_end = 0;
+	int row_end = 0;
+
+	bool in_ref(int col, int row)
+	{
+		return (col >= col_start && col <= col_end && row >= row_start && row <= row_end);
+	}
+
+	std::vector<std::pair<std::wstring, std::wstring>> columns; //name, odf_ref
+};
 struct ods_array_formula_state
 {
 	std::wstring formula;
@@ -341,12 +360,14 @@ private:
 	
 	std::vector<office_element_ptr> current_level_;//постоянно меняющийся список уровней ("0-й элемент - сама таблица)
 	
-	std::list<ods_cell_state>	cells_;
+	std::vector<ods_cell_state>	cells_;
 	long						cells_size_;
 	
 	std::vector<ods_hyperlink_state>		hyperlinks_;
 	std::vector<ods_shared_formula_state>	shared_formulas_;
 
+	std::vector<table_part_state>			table_parts_;
+
 	odf_drawing_context		drawing_context_;	
 
 	friend class ods_table_context;

ASCOfficeOdfFileW/source/Oox2OdfConverter/DocxConverter.cpp

@@ -141,7 +141,7 @@ odf_writer::odf_conversion_context* DocxConverter::odf_context()
 PPTX::Theme* DocxConverter::oox_theme()
 {
 	if (docx_document)
-		return docx_document->GetTheme();
+		return docx_document->m_pTheme;
 	else
 		return NULL;
 }
@@ -151,22 +151,17 @@ OOX::IFileContainer* DocxConverter::current_document()
 		return oox_current_child_document;
 	else
 	{
-		OOX::CDocument  *oox_doc = docx_document->GetDocument();
-		return dynamic_cast<OOX::IFileContainer*>(oox_doc);
+		return dynamic_cast<OOX::IFileContainer*>(docx_document->m_pDocument);
 	}
 }
 NSCommon::smart_ptr<OOX::File> DocxConverter::find_file_by_id(std::wstring sId)
 {
-	OOX::CDocument  *oox_doc = docx_document->GetDocument();
-
 	smart_ptr<OOX::File> oFile;
-	if (oox_doc)
-	{
-		if (oox_current_child_document)
-			oFile = oox_current_child_document->Find(sId);
-		else
-			oFile = oox_doc->Find(sId);
-	}
+
+	if (oox_current_child_document)
+		oFile = oox_current_child_document->Find(sId);
+	else if (docx_document->m_pDocument)
+		oFile = docx_document->m_pDocument->Find(sId);
 		
 	return oFile;
 }
@@ -185,10 +180,9 @@ std::wstring DocxConverter::find_link_by_id (std::wstring sId, int type)
 	}
 	if (!ref.empty()) return ref;
 
-	OOX::CDocument  *oox_doc = docx_document->GetDocument();
-	if (oox_doc == NULL) return L"";
+	if (docx_document->m_pDocument == NULL) return L"";
 	
-	oFile	= oox_doc->Find(sId);
+	oFile	= docx_document->m_pDocument->Find(sId);
 	ref		= OoxConverter::find_link_by(oFile, type);
 
 	return ref;
@@ -221,8 +215,7 @@ void DocxConverter::convertDocument()
 
 void DocxConverter::convert_document()
 {
-	const OOX::CDocument* document = docx_document->GetDocument();
-	if (!document)return;
+	if (!docx_document->m_pDocument)return;
 
 	std::vector<_section> sections;
 //----------------------------------------------------------------------------------------------------------
@@ -231,13 +224,13 @@ void DocxConverter::convert_document()
 
 	OOX::Logic::CSectionProperty* prev = NULL;
 
-    for (size_t i = 0; i < document->m_arrItems.size(); ++i)
+    for (size_t i = 0; i < docx_document->m_pDocument->m_arrItems.size(); ++i)
 	{
-		if ((document->m_arrItems[i]) == NULL) continue;
+		if ((docx_document->m_pDocument->m_arrItems[i]) == NULL) continue;
 
-		if (document->m_arrItems[i]->getType() == OOX::et_w_p)
+		if (docx_document->m_pDocument->m_arrItems[i]->getType() == OOX::et_w_p)
 		{
-			OOX::Logic::CParagraph * para = dynamic_cast<OOX::Logic::CParagraph *>(document->m_arrItems[i]);
+			OOX::Logic::CParagraph * para = dynamic_cast<OOX::Logic::CParagraph *>(docx_document->m_pDocument->m_arrItems[i]);
 			
 			if ((para) && (para->m_oParagraphProperty))
 			{
@@ -260,15 +253,17 @@ void DocxConverter::convert_document()
 	}
 	_section section;
 	
-	section.props		= document->m_oSectPr.GetPointer();
+	section.props		= docx_document->m_pDocument->m_oSectPr.GetPointer();
 	section.start_para	= last_section_start;
-	section.end_para	= document->m_arrItems.size(); 
+	section.end_para	= docx_document->m_pDocument->m_arrItems.size(); 
 	section.bContinue	= compare (prev, section.props);
 
 	sections.push_back(section);
 					
 //----------------------------------------------------------------------------------------------------------
 
+	convert(docx_document->m_pDocument->m_oSectPr.GetPointer(), false, L"Standard");
+	
 	odt_context->text_context()->clear_params();
 
 	for (size_t sect = 0; sect < sections.size(); sect++)
@@ -277,7 +272,7 @@ void DocxConverter::convert_document()
 
         for (size_t i = sections[sect].start_para; i < sections[sect].end_para; ++i)
 		{
-			convert(document->m_arrItems[i]);
+			convert(docx_document->m_pDocument->m_arrItems[i]);
 		}
 	}
 }
@@ -1419,7 +1414,7 @@ void DocxConverter::apply_HF_from(OOX::Logic::CSectionProperty *props, OOX::Logi
 		}
 	}
 }
-void DocxConverter::convert(OOX::Logic::CSectionProperty *oox_section_pr, bool bSection)
+void DocxConverter::convert(OOX::Logic::CSectionProperty *oox_section_pr, bool bSection, const std::wstring & master_name)
 {
 	if (oox_section_pr == NULL) return;
 	current_section_properties = NULL;
@@ -1444,18 +1439,24 @@ void DocxConverter::convert(OOX::Logic::CSectionProperty *oox_section_pr, bool b
 		}
 	}
  ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-   if (!last_section_properties && (!bSection || continuous == false || oox_section_pr->m_oTitlePg.IsInit()))
-	{	
-		last_section_properties = oox_section_pr;
-	}
-	else if (!bSection || continuous == false)
+
+	bool bDefault = (master_name == L"Standard");
+	
+	if (!bDefault)
 	{
-        apply_HF_from(last_section_properties, oox_section_pr);
+		if (!last_section_properties && (!bSection || continuous == false || oox_section_pr->m_oTitlePg.IsInit()))
+		{	
+			last_section_properties = oox_section_pr;
+		}
+		else if (!bSection || continuous == false)
+		{
+			apply_HF_from(last_section_properties, oox_section_pr);
+		}
 	}
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 	if (!bSection || continuous == false)
 	{
-		odt_context->page_layout_context()->add_master_page(bSection ? L"" : L"Standard");
+		odt_context->page_layout_context()->add_master_page(master_name);
 	}
 	
 	bool present_header		= false;
@@ -1572,7 +1573,7 @@ void DocxConverter::convert(OOX::Logic::CSectionProperty *oox_section_pr, bool b
 
 		//nullable<SimpleTypes::CDecimalNumber<>   > m_oCode;
 	}
-	convert(docx_document->GetDocument()->m_oBackground.GetPointer(), 1);//подложка - вот в таком она месте :(, причём одна на все разделы, не как в оо
+	convert(docx_document->m_pDocument->m_oBackground.GetPointer(), 1);//подложка - вот в таком она месте :(, причём одна на все разделы, не как в оо
 			//nullable<ComplexTypes::Word::CTextDirection                  > m_oTextDirection;
 			//nullable<ComplexTypes::Word::COnOff2<SimpleTypes::onoffTrue> > m_oRtlGutter;
 			//nullable<ComplexTypes::Word::CVerticalJc                     > m_oVAlign;
@@ -1592,7 +1593,7 @@ void DocxConverter::convert(OOX::Logic::CSectionProperty *oox_section_pr, bool b
 	
 	if (continuous == false || oox_section_pr->m_oTitlePg.IsInit())
 	{
-		OOX::Logic::CSectionProperty*	s = last_section_properties; 
+		OOX::Logic::CSectionProperty*	s = last_section_properties ? last_section_properties : oox_section_pr; 
 		
 		bool present_title_page			= s->m_oTitlePg.IsInit() ? true : false;
 		bool present_odd_even_pages		= odt_context->page_layout_context()->even_and_left_headers_;
@@ -1621,7 +1622,7 @@ void DocxConverter::convert(OOX::Logic::CSectionProperty *oox_section_pr, bool b
 				if (s->m_arrHeaderReference[i]->m_oId.IsInit())
 				{
 					convert_hdr_ftr(s->m_arrHeaderReference[i]->m_oId->GetValue());
-					convert(docx_document->GetDocument()->m_oBackground.GetPointer(), 2);
+					convert(docx_document->m_pDocument->m_oBackground.GetPointer(), 2);
 				}
 
 				odt_context->end_header_footer();
@@ -1649,7 +1650,7 @@ void DocxConverter::convert(OOX::Logic::CSectionProperty *oox_section_pr, bool b
 				if (s->m_arrFooterReference[i]->m_oId.IsInit())
 				{
 					convert_hdr_ftr(s->m_arrFooterReference[i]->m_oId->GetValue());
-					convert(docx_document->GetDocument()->m_oBackground.GetPointer(), 3);
+					convert(docx_document->m_pDocument->m_oBackground.GetPointer(), 3);
 				}
 
 				odt_context->end_header_footer();	
@@ -1659,7 +1660,8 @@ void DocxConverter::convert(OOX::Logic::CSectionProperty *oox_section_pr, bool b
 		if (!add_odd_even_pages_footer	&& present_odd_even_pages)							odt_context->add_empty_footer(1);
 		if (!add_default_footer			&& (present_odd_even_pages || present_title_page))	odt_context->add_empty_footer(0);
 
-		odt_context->is_paragraph_in_current_section_ = true;
+		if (!bDefault)
+			odt_context->is_paragraph_in_current_section_ = true;
 
 		//odt_context->set_master_page_name(odt_context->page_layout_context()->last_master() ?
 		//									  odt_context->page_layout_context()->last_master()->get_name() : L"");
@@ -1701,24 +1703,27 @@ void DocxConverter::convert(OOX::Logic::CSectionProperty *oox_section_pr, bool b
 		odt_context->add_section_columns(num_columns, 
 			oox_section_pr->m_oCols->m_arrColumns.size() > 0 ? -1 : default_space_pt , separator );
 
-		std::vector<std::pair<double,double>> width_space;
-		
-		for (size_t i = 0; i< oox_section_pr->m_oCols->m_arrColumns.size(); i++)
+		if (num_columns > 1) //
 		{
-			if (oox_section_pr->m_oCols->m_arrColumns[i] == NULL) continue;
+			std::vector<std::pair<double,double>> width_space;
 			
-			double space = default_space_pt;
-			if (oox_section_pr->m_oCols->m_arrColumns[i]->m_oSpace.IsInit())
-				space = oox_section_pr->m_oCols->m_arrColumns[i]->m_oSpace->ToPoints();
-		
-			double w = -1; 
-			if (oox_section_pr->m_oCols->m_arrColumns[i]->m_oW.IsInit())
-				w = oox_section_pr->m_oCols->m_arrColumns[i]->m_oW->ToPoints();
+			for (size_t i = 0; i < oox_section_pr->m_oCols->m_arrColumns.size(); i++)
+			{
+				if (oox_section_pr->m_oCols->m_arrColumns[i] == NULL) continue;
+				
+				double space = default_space_pt;
+				if (oox_section_pr->m_oCols->m_arrColumns[i]->m_oSpace.IsInit())
+					space = oox_section_pr->m_oCols->m_arrColumns[i]->m_oSpace->ToPoints();
 			
-			width_space.push_back(std::pair<double,double>(w, space));
-		}
+				double w = -1; 
+				if (oox_section_pr->m_oCols->m_arrColumns[i]->m_oW.IsInit())
+					w = oox_section_pr->m_oCols->m_arrColumns[i]->m_oW->ToPoints();
+				
+				width_space.push_back(std::pair<double,double>(w, space));
+			}
 
-		odt_context->add_section_column(width_space);
+			odt_context->add_section_column(width_space);
+		}
 	}
 }
 void DocxConverter::convert(OOX::Logic::CBackground *oox_background, int type)
@@ -2335,8 +2340,7 @@ void DocxConverter::convert(SimpleTypes::CTheme<>* oox_font_theme, _CP_OPT(std::
 {
 	if (oox_font_theme == NULL) return;
 
-	PPTX::Theme * docx_theme= docx_document->GetTheme();
-	if (docx_theme == NULL) return;
+	if (docx_document->m_pTheme == NULL) return;
 
 	std::wstring font;
 
@@ -2344,23 +2348,23 @@ void DocxConverter::convert(SimpleTypes::CTheme<>* oox_font_theme, _CP_OPT(std::
 	{
 	case SimpleTypes::themeMajorAscii:
 	case SimpleTypes::themeMajorHAnsi :
-		font = docx_theme->themeElements.fontScheme.majorFont.latin.typeface;
+		font = docx_document->m_pTheme->themeElements.fontScheme.majorFont.latin.typeface;
 		break;
 	case SimpleTypes::themeMajorBidi:
-		font = docx_theme->themeElements.fontScheme.majorFont.cs.typeface;
+		font = docx_document->m_pTheme->themeElements.fontScheme.majorFont.cs.typeface;
 		break;
 	case SimpleTypes::themeMajorEastAsia:
-		font = docx_theme->themeElements.fontScheme.majorFont.ea.typeface;
+		font = docx_document->m_pTheme->themeElements.fontScheme.majorFont.ea.typeface;
 		break;
 	case SimpleTypes::themeMinorAscii:
 	case SimpleTypes::themeMinorHAnsi:
-		font = docx_theme->themeElements.fontScheme.minorFont.latin.typeface;
+		font = docx_document->m_pTheme->themeElements.fontScheme.minorFont.latin.typeface;
 		break;
 	case SimpleTypes::themeMinorBidi:
-		font = docx_theme->themeElements.fontScheme.minorFont.cs.typeface;
+		font = docx_document->m_pTheme->themeElements.fontScheme.minorFont.cs.typeface;
 		break;
 	case SimpleTypes::themeMinorEastAsia:
-		font = docx_theme->themeElements.fontScheme.minorFont.ea.typeface;
+		font = docx_document->m_pTheme->themeElements.fontScheme.minorFont.ea.typeface;
 		break;
 	}
 	if (!font.empty()) odf_font_name = font;
@@ -2867,11 +2871,9 @@ void DocxConverter::convert(SimpleTypes::CHexColor<>		*color,
 	}
 	if(theme_color && result == false)
 	{
-		PPTX::Theme * docx_theme= docx_document->GetTheme();
-		
-		std::map<std::wstring, PPTX::Logic::UniColor>::iterator pFind = docx_theme->themeElements.clrScheme.Scheme.find(theme_color->ToString());
+		std::map<std::wstring, PPTX::Logic::UniColor>::iterator pFind = docx_document->m_pTheme->themeElements.clrScheme.Scheme.find(theme_color->ToString());
 
-		if (pFind != docx_theme->themeElements.clrScheme.Scheme.end())
+		if (pFind != docx_document->m_pTheme->themeElements.clrScheme.Scheme.end())
 		{
 			PPTX::Logic::UniColor & color = pFind->second;
 			
@@ -2890,38 +2892,36 @@ void DocxConverter::convert(ComplexTypes::Word::CColor *color, _CP_OPT(odf_types
 PPTX::Logic::ClrMap* DocxConverter::oox_clrMap()
 {
 	//return current_clrMap; todoooo
-	OOX::CSettings * docx_settings = docx_document->GetSettings();
-	if (!docx_settings) return NULL;
+	if (!docx_document->m_pSettings) return NULL;
 	
-	return docx_settings->m_oClrSchemeMapping.GetPointer();
+	return docx_document->m_pSettings->m_oClrSchemeMapping.GetPointer();
 }
 void DocxConverter::convert_settings()
 {
 	if (!odt_context) return;
 
-	OOX::CSettings * docx_settings = docx_document->GetSettings();
-	if (!docx_settings) return;
+	if (!docx_document->m_pSettings) return;
 
-	if (docx_settings->m_oZoom.IsInit())
+	if (docx_document->m_pSettings->m_oZoom.IsInit())
 	{
 	}
-	if (docx_settings->m_oMirrorMargins.IsInit())
+	if (docx_document->m_pSettings->m_oMirrorMargins.IsInit())
 	{
 		odt_context->page_layout_context()->set_pages_mirrored(true);
 	}
 
-	odt_context->page_layout_context()->even_and_left_headers_ = docx_settings->m_oEvenAndOddHeaders.IsInit();
+	odt_context->page_layout_context()->even_and_left_headers_ = docx_document->m_pSettings->m_oEvenAndOddHeaders.IsInit();
 
-	if (docx_settings->m_oPrintTwoOnOne.IsInit())
+	if (docx_document->m_pSettings->m_oPrintTwoOnOne.IsInit())
 	{
-		if (docx_settings->m_oGutterAtTop.IsInit()){} //portrait
+		if (docx_document->m_pSettings->m_oGutterAtTop.IsInit()){} //portrait
 		else {}//landscape
 	}
 
-	if (docx_settings->m_oDefaultTabStop.IsInit())
+	if (docx_document->m_pSettings->m_oDefaultTabStop.IsInit())
 	{
 		_CP_OPT(odf_types::length) length;
-		convert(docx_settings->m_oDefaultTabStop->m_oVal.GetPointer(), length);
+		convert(docx_document->m_pSettings->m_oDefaultTabStop->m_oVal.GetPointer(), length);
 		
 		odf_writer::odf_style_state_ptr state;
 		if (odt_context->styles_context()->find_odf_default_style_state(odf_types::style_family::Paragraph, state) && state)
@@ -2941,7 +2941,7 @@ void DocxConverter::convert_lists_styles()
 {
 	if (!odt_context) return;
 
-	OOX::CNumbering * lists_styles = docx_document->GetNumbering();
+	OOX::CNumbering * lists_styles = docx_document->m_pNumbering;
 	
 	if (!lists_styles)return;
 
@@ -2979,27 +2979,25 @@ void DocxConverter::convert_lists_styles()
 void DocxConverter::convert_styles()
 {
 	if (!odt_context) return;
-
-	OOX::CStyles * docx_styles = docx_document->GetStyles();
 	
-	if (!docx_styles)return;
+	if (!docx_document->m_pStyles)return;
 
 	//nullable<OOX::CLatentStyles > m_oLatentStyles;
 
-	convert(docx_styles->m_oDocDefaults.GetPointer());
+	convert(docx_document->m_pStyles->m_oDocDefaults.GetPointer());
 
-	for (size_t i=0; i< docx_styles->m_arrStyle.size(); i++)
+	for (size_t i=0; i< docx_document->m_pStyles->m_arrStyle.size(); i++)
 	{
-		if (docx_styles->m_arrStyle[i] == NULL) continue;
+		if (docx_document->m_pStyles->m_arrStyle[i] == NULL) continue;
 		
 		if (!current_font_size.empty())
 		{
 			current_font_size.erase(current_font_size.begin() + 1, current_font_size.end());
 		}
 
-		convert(docx_styles->m_arrStyle[i]);
+		convert(docx_document->m_pStyles->m_arrStyle[i]);
 	
-		if (i == 0 && docx_styles->m_arrStyle[i]->m_oDefault.IsInit() && docx_styles->m_arrStyle[i]->m_oDefault->ToBool())
+		if (i == 0 && docx_document->m_pStyles->m_arrStyle[i]->m_oDefault.IsInit() && docx_document->m_pStyles->m_arrStyle[i]->m_oDefault->ToBool())
 		{
 			//NADIE_COMO_TU.docx тут дефолтовый стиль не прописан явно, берем тот что Normal
 			odf_writer::odf_style_state_ptr def_style_state;
@@ -3285,7 +3283,7 @@ void DocxConverter::convert(OOX::Numbering::CLvl* oox_num_lvl)
 	if (oox_num_lvl->m_oLvlPicBulletId.IsInit() && oox_num_lvl->m_oLvlPicBulletId->m_oVal.IsInit())
 	{
 		int id = oox_num_lvl->m_oLvlPicBulletId->m_oVal->GetValue();
-		OOX::CNumbering * lists_styles = docx_document->GetNumbering();
+		OOX::CNumbering * lists_styles = docx_document->m_pNumbering;
 
 		for (size_t i = 0; (lists_styles) && (i < lists_styles->m_arrNumPicBullet.size()); i++)
 		{
@@ -3582,12 +3580,11 @@ void DocxConverter::convert(OOX::Logic::CEndnoteReference* oox_ref)
 }
 void DocxConverter::convert_comment(int oox_comm_id)
 {
-	OOX::CComments * docx_comments = docx_document->GetComments();
-	if (!docx_comments)return;
+	if (!docx_document->m_pComments)return;
 
-	for (size_t comm = 0 ; comm < docx_comments->m_arrComments.size(); comm++)
+	for (size_t comm = 0 ; comm < docx_document->m_pComments->m_arrComments.size(); comm++)
 	{
-		OOX::CComment* oox_comment = docx_comments->m_arrComments[comm];
+		OOX::CComment* oox_comment = docx_document->m_pComments->m_arrComments[comm];
 		
 		if (oox_comment == NULL)					continue;
 		if (oox_comment->m_oId.IsInit() == false)	continue;
@@ -3611,14 +3608,13 @@ void DocxConverter::convert_comment(int oox_comm_id)
 }
 void DocxConverter::convert_footnote(int oox_ref_id)
 {
-	OOX::CFootnotes * footnotes = docx_document->GetFootnotes();
-	if (!footnotes)return;
+	if (!docx_document->m_pFootnotes)return;
 
 	odt_context->start_note(oox_ref_id, 1);
 
-	for (size_t n = 0 ; n < footnotes->m_arrFootnote.size(); n++)
+	for (size_t n = 0 ; n < docx_document->m_pFootnotes->m_arrFootnote.size(); n++)
 	{
-		OOX::CFtnEdn* oox_note = footnotes->m_arrFootnote[n];
+		OOX::CFtnEdn* oox_note = docx_document->m_pFootnotes->m_arrFootnote[n];
 		
 		if (oox_note == NULL)					continue;
 		if (oox_note->m_oId.IsInit() == false)	continue;
@@ -3639,14 +3635,13 @@ void DocxConverter::convert_footnote(int oox_ref_id)
 }
 void DocxConverter::convert_endnote(int oox_ref_id)
 {
-	OOX::CEndnotes * endnotes = docx_document->GetEndnotes();
-	if (!endnotes)return;
+	if (!docx_document->m_pEndnotes)return;
 
 	odt_context->start_note(oox_ref_id, 2);
 
-	for (size_t n = 0 ; n < endnotes->m_arrEndnote.size(); n++)
+	for (size_t n = 0 ; n < docx_document->m_pEndnotes->m_arrEndnote.size(); n++)
 	{
-		OOX::CFtnEdn* oox_note = endnotes->m_arrEndnote[n];
+		OOX::CFtnEdn* oox_note = docx_document->m_pEndnotes->m_arrEndnote[n];
 		
 		if (oox_note == NULL)					continue;
 		if (oox_note->m_oId.IsInit() == false)	continue;

ASCOfficeOdfFileW/source/Oox2OdfConverter/DocxConverter.h

@@ -184,7 +184,7 @@ namespace Oox2Odf
 
 		void convert(OOX::Logic::CBackground			*oox_background, int type);
 		void convert(OOX::Logic::CSdt					*oox_sdt);
-		void convert(OOX::Logic::CSectionProperty		*oox_section_pr, bool bSection);
+		void convert(OOX::Logic::CSectionProperty		*oox_section_pr, bool bSection, const std::wstring & master_name = L"");
 		void convert(OOX::Logic::CParagraph				*oox_paragraph);
 		void convert(OOX::Logic::CRun					*oox_run);
 		void convert(OOX::Logic::CParagraphProperty		*oox_para_prop,	odf_writer::style_paragraph_properties	*paragraph_properties);

ASCOfficeOdfFileW/source/Oox2OdfConverter/XlsxConverter.cpp

@@ -32,9 +32,10 @@
 #include "XlsxConverter.h"
 #include "../../../Common/DocxFormat/Source/XlsxFormat/Xlsx.h"
 #include "../../../Common/DocxFormat/Source/XlsxFormat/Workbook/Workbook.h"
+#include "../../../Common/DocxFormat/Source/XlsxFormat/Worksheets/Worksheet.h"
+#include "../../../Common/DocxFormat/Source/XlsxFormat/Comments/Comments.h"
 #include "../../../Common/DocxFormat/Source/XlsxFormat/SharedStrings/SharedStrings.h"
 #include "../../../Common/DocxFormat/Source/XlsxFormat/Styles/Styles.h"
-#include "../../../Common/DocxFormat/Source/XlsxFormat/Worksheets/Worksheet.h"
 #include "../../../Common/DocxFormat/Source/XlsxFormat/CalcChain/CalcChain.h"
 #include "../../../Common/DocxFormat/Source/XlsxFormat/ExternalLinks/ExternalLinks.h"
 #include "../../../Common/DocxFormat/Source/XlsxFormat/ExternalLinks/ExternalLinkPath.h"
@@ -267,6 +268,30 @@ void XlsxConverter::convert(OOX::Spreadsheet::CWorksheet *oox_sheet)
 		pos++;
 	}
 	//todooo для оптимизации - перенести мержи в начало
+
+	//выносные части таблицы
+	if (oox_sheet->m_oTableParts.IsInit())
+	{
+		for (size_t i=0 ; i < oox_sheet->m_oTableParts->m_arrItems.size(); i++)
+		{
+			OOX::Spreadsheet::CTablePart *oox_table_part = oox_sheet->m_oTableParts->m_arrItems[i];
+			if (!oox_table_part)continue;
+			if (!oox_table_part->m_oRId.IsInit())continue;
+
+			smart_ptr<OOX::File> oFile = oox_sheet->Find(oox_table_part->m_oRId->GetValue());
+			if (oFile.IsInit() && OOX::Spreadsheet::FileTypes::Table == oFile->type())
+			{
+				OOX::Spreadsheet::CTableFile* pTableFile = (OOX::Spreadsheet::CTableFile*)oFile.operator->();
+						
+				if ((pTableFile) && (pTableFile->m_oTable.IsInit()))
+				{				
+					oox_current_child_document = dynamic_cast<OOX::IFileContainer*>(pTableFile);					
+						convert(pTableFile->m_oTable.GetPointer());				
+					oox_current_child_document = NULL;
+				}
+			}
+		}
+	}
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////	
 	//колонки
 		ods_context->start_columns();
@@ -327,29 +352,7 @@ void XlsxConverter::convert(OOX::Spreadsheet::CWorksheet *oox_sheet)
 		}
 		ods_context->end_conditional_formats();
 	}
-	//выносные части таблицы
-	if (oox_sheet->m_oTableParts.IsInit())
-	{
-		for (size_t i=0 ; i < oox_sheet->m_oTableParts->m_arrItems.size(); i++)
-		{
-			OOX::Spreadsheet::CTablePart *oox_table_part = oox_sheet->m_oTableParts->m_arrItems[i];
-			if (!oox_table_part)continue;
-			if (!oox_table_part->m_oRId.IsInit())continue;
 
-			smart_ptr<OOX::File> oFile = oox_sheet->Find(oox_table_part->m_oRId->GetValue());
-			if (oFile.IsInit() && OOX::Spreadsheet::FileTypes::Table == oFile->type())
-			{
-				OOX::Spreadsheet::CTableFile* pTableFile = (OOX::Spreadsheet::CTableFile*)oFile.operator->();
-						
-				if ((pTableFile) && (pTableFile->m_oTable.IsInit()))
-				{				
-					oox_current_child_document = dynamic_cast<OOX::IFileContainer*>(pTableFile);					
-						convert(pTableFile->m_oTable.GetPointer());				
-					oox_current_child_document = NULL;
-				}
-			}
-		}
-	}
 /////////////////////////////////////////////////////////////////////////
 	convert(oox_sheet->m_oSheetViews.GetPointer());
 	convert(oox_sheet->m_oHeaderFooter.GetPointer());
@@ -417,11 +420,27 @@ void XlsxConverter::convert(OOX::Spreadsheet::CTable *oox_table_part)
 	if (oox_table_part->m_oAutoFilter.IsInit())
 		ods_context->set_table_part_autofilter(true);
 
+	convert(oox_table_part->m_oTableColumns.GetPointer());
 	OoxConverter::convert(oox_table_part->m_oExtLst.GetPointer());
 	
 	ods_context->end_table_part();
 }
 
+void XlsxConverter::convert(OOX::Spreadsheet::CTableColumns *oox_table_part_columns)
+{
+	if (!oox_table_part_columns) return;
+
+	for (size_t i = 0; i < oox_table_part_columns->m_arrItems.size(); i++)
+	{
+		std::wstring name;
+		if (oox_table_part_columns->m_arrItems[i]->m_oName.IsInit())
+			name = oox_table_part_columns->m_arrItems[i]->m_oName.get2();
+		
+		ods_context->add_table_part_column(name);
+	}
+}
+
+
 void XlsxConverter::convert(OOX::Spreadsheet::CCommentItem * oox_comment)
 {
 	if (!oox_comment) return;

ASCOfficeOdfFileW/source/Oox2OdfConverter/XlsxConverter.h

@@ -48,6 +48,7 @@ namespace OOX
 
 		class CWorksheet;
 		class CTable;
+		class CTableColumns;
 		class CCol;
 		class CRow;
 		class CCell;
@@ -157,6 +158,7 @@ namespace Oox2Odf
 		void convert(OOX::Spreadsheet::CWorksheet			*oox_sheet);
 		void convert(OOX::Spreadsheet::CDefinedName			*oox_defined);
 		void convert(OOX::Spreadsheet::CTable				*oox_table_part);
+		void convert(OOX::Spreadsheet::CTableColumns		*oox_table_part_columns);
 		void convert(OOX::Spreadsheet::CPictureWorksheet	*oox_background);
 		void convert(OOX::Spreadsheet::CHeaderFooter		*oox_header_footer);
 

ASCOfficeOdfFileW/source/win32/OdfFormat.vcproj

@@ -53,7 +53,7 @@
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="4"
-				DisableSpecificWarnings="4996"
+				DisableSpecificWarnings="4005;4311;4312"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"

ASCOfficeOdfFileW/source/win32/Oox2OdfConverter.vcproj

@@ -52,6 +52,7 @@
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="4"
+				DisableSpecificWarnings="4005;4311;4312"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"

ASCOfficePPTFile/PPTFormatLib/Linux/PPTFormatLib.pro

@@ -23,8 +23,6 @@ DEFINES +=  UNICODE \
         _UNICODE \
         _USE_LIBXML2_READER_ \
         LIBXML_READER_ENABLED \
-        USE_LITE_READER \
-        _USE_XMLLITE_READER_ \
         _PRESENTATION_WRITER_ \
         _SVG_CONVERT_TO_IMAGE_  \
         DONT_WRITE_EMBEDDED_FONTS

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/Converter.cpp

@@ -37,6 +37,7 @@
 #include "../../../ASCOfficePPTXFile/Editor/DefaultNotesTheme.h"
 
 #include "../../../Common/DocxFormat/Source/SystemUtility/SystemUtility.h"
+#include "../../../ASCOfficeXlsFile2/source/Common/simple_xml_writer.h"
 #include "../../../DesktopEditor/common/Directory.h"
 
 #include "../Reader/PPTDocumentInfo.h"
@@ -60,8 +61,6 @@ namespace NSPresentationEditor
         static std::wstring g_string_core = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
 <cp:coreProperties xmlns:cp=\"http://schemas.openxmlformats.org/package/2006/metadata/core-properties\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:dcterms=\"http://purl.org/dc/terms/\" xmlns:dcmitype=\"http://purl.org/dc/dcmitype/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\
 <dc:title>Slide 1</dc:title>\
-<dc:creator>OnlyOffice</dc:creator>\
-<cp:lastModifiedBy>OnlyOffice</cp:lastModifiedBy>\
 <cp:revision>1</cp:revision>\
 </cp:coreProperties>");
 	}
@@ -188,12 +187,12 @@ void NSPresentationEditor::CPPTXWriter::WriteContentTypes()
 {
     std::wstring strContentTypes = L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
 <Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">\
-<Default Extension=\"bmp\" ContentType=\"image/bmp\" />\
-<Default Extension=\"png\" ContentType=\"image/png\" />\
-<Default Extension=\"jpeg\" ContentType=\"image/jpeg\" />\
-<Default Extension=\"wmf\" ContentType=\"image/x-wmf\" />\
-<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\" />\
-<Default Extension=\"xml\" ContentType=\"application/xml\" />\
+<Default Extension=\"bmp\" ContentType=\"image/bmp\"/>\
+<Default Extension=\"png\" ContentType=\"image/png\"/>\
+<Default Extension=\"jpeg\" ContentType=\"image/jpeg\"/>\
+<Default Extension=\"wmf\" ContentType=\"image/x-wmf\"/>\
+<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>\
+<Default Extension=\"xml\" ContentType=\"application/xml\"/>\
 <Default Extension=\"gif\" ContentType=\"image/gif\"/>\
 <Default Extension=\"emf\" ContentType=\"image/x-emf\"/>\
 <Default Extension=\"wav\" ContentType=\"audio/wav\"/>\
@@ -208,7 +207,7 @@ void NSPresentationEditor::CPPTXWriter::WriteContentTypes()
 <Default Extension=\"xls\" ContentType=\"application/vnd.ms-excel\"/>\
 <Default Extension=\"xlsx\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\"/>\
 <Default Extension=\"bin\" ContentType=\"application/vnd.openxmlformats-officedocument.oleObject\" />\
-<Default Extension=\"jpg\" ContentType=\"application/octet-stream\"/>";
+<Default Extension=\"jpg\" ContentType=\"image/jpeg\"/>";
 
 	if (m_pDocument->m_bMacros)
 	{
@@ -278,60 +277,127 @@ void NSPresentationEditor::CPPTXWriter::WriteContentTypes()
 
 void NSPresentationEditor::CPPTXWriter::WriteApp(CFile& oFile)
 {
-    std::wstring str1 = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
-<Properties xmlns=\"http://schemas.openxmlformats.org/officeDocument/2006/extended-properties\" xmlns:vt=\"http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes\">\
-<TotalTime>0</TotalTime>\
-<Words>0</Words>\
-<Application>OnlyOffice</Application>\
-<PresentationFormat>On-screen Show (4:3)</PresentationFormat>\
-<Paragraphs>0</Paragraphs>");
+	std::wstringstream strm;
 
-	oFile.WriteStringUTF8(str1);
-
-    oFile.WriteStringUTF8(L"<Slides>" + std::to_wstring(m_pDocument->m_arSlides.size()) + L"</Slides>");
-    oFile.WriteStringUTF8(L"<Notes>" + std::to_wstring(m_pDocument->m_arNotes.size()) + L"</Notes>");
-
-    oFile.WriteStringUTF8(L"<HiddenSlides>0</HiddenSlides>\
-                          <MMClips>2</MMClips>\
-                          <ScaleCrop>false</ScaleCrop>\
-                          <HeadingPairs>\
-                          <vt:vector size=\"4\" baseType=\"variant\">");
-
-	int nCountThemes = (int)m_pDocument->m_arThemes.size();
-	int nCountSlides = (int)m_pDocument->m_arSlides.size();
-
-    std::wstring strThemes = L"<vt:variant><vt:lpstr>Theme</vt:lpstr></vt:variant><vt:variant><vt:i4>" +std::to_wstring(nCountThemes) +
-            L"</vt:i4></vt:variant>";
-
-    std::wstring strSlides = L"<vt:variant><vt:lpstr>Slide Titles</vt:lpstr></vt:variant><vt:variant><vt:i4>" +
-            std::to_wstring(nCountSlides) + L"</vt:i4></vt:variant></vt:vector></HeadingPairs>";
-
-    std::wstring strTitles = L"<TitlesOfParts><vt:vector size=\"" + std::to_wstring(nCountSlides + nCountThemes) + L"\" baseType=\"lpstr\">";
-
-    oFile.WriteStringUTF8(strThemes + strSlides + strTitles);
-
-    std::wstring strMemory = _T("");
-	for (int i = 1; i <= nCountThemes; ++i)
+ 	CP_XML_WRITER(strm)
 	{
-        strMemory += L"<vt:lpstr>Theme " + std::to_wstring(i) + L"</vt:lpstr>";
+		CP_XML_NODE(L"Properties")
+		{
+			CP_XML_ATTR(L"xmlns", L"http://schemas.openxmlformats.org/officeDocument/2006/extended-properties");
+			CP_XML_ATTR(L"xmlns:vt", L"http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypess");
+		}
+		CP_XML_NODE(L"Application")
+		{
+			CP_XML_STREAM() << 0;
+		}
+#if defined(INTVER)
+		CP_XML_NODE(L"AppVersion")
+		{
+			std::string s = VALUE2STR(INTVER);
+			CP_XML_STREAM() << std::wstring(s.begin(), s.end());
+		}
+#endif	
+		CP_XML_NODE(L"TotalTime")
+		{
+			CP_XML_STREAM() << 0;
+		}
+		CP_XML_NODE(L"Words")
+		{
+			CP_XML_STREAM() << 0;
+		}
+		CP_XML_NODE(L"PresentationFormat")
+		{
+			CP_XML_STREAM() << L"On-screen Show (4:3)";
+		}
+		CP_XML_NODE(L"Paragraphs")
+		{
+			CP_XML_STREAM() << 0;
+		}
+		CP_XML_NODE(L"Slides")
+		{
+			CP_XML_STREAM() << m_pDocument->m_arSlides.size();
+		}
+		CP_XML_NODE(L"Notes")
+		{
+			CP_XML_STREAM() << m_pDocument->m_arNotes.size();
+		}
+		CP_XML_NODE(L"HiddenSlides")
+		{
+			CP_XML_STREAM() << 0;
+		}
+		CP_XML_NODE(L"MMClips")
+		{
+			CP_XML_STREAM() << 2;
+		}
+		CP_XML_NODE(L"ScaleCrop")
+		{
+			CP_XML_STREAM() << L"false";
+		}
+		CP_XML_NODE(L"HeadingPairs")
+		{
+			CP_XML_NODE(L"vt:vector")
+			{
+				CP_XML_ATTR(L"size", 4);
+				CP_XML_ATTR(L"baseType", L"variant");
+				
+				CP_XML_NODE(L"vt:variant")
+				{
+					CP_XML_ATTR(L"vt:lpstr", L"Theme");
+				}
+				CP_XML_NODE(L"vt:variant")
+				{
+					CP_XML_ATTR(L"vt:i4", m_pDocument->m_arThemes.size());
+				}
+				CP_XML_NODE(L"vt:variant")
+				{
+					CP_XML_ATTR(L"vt:lpstr", L"Slide Titles");
+				}
+				CP_XML_NODE(L"vt:variant")
+				{
+					CP_XML_ATTR(L"vt:i4", m_pDocument->m_arSlides.size());
+				}
+			}
+		}
+		CP_XML_NODE(L"TitlesOfParts")
+		{
+			CP_XML_NODE(L"vt:vector")
+			{
+				CP_XML_ATTR(L"size", m_pDocument->m_arSlides.size() + m_pDocument->m_arThemes.size());
+				CP_XML_ATTR(L"baseType", L"lpstr");
+
+				for (size_t i = 1; i <= m_pDocument->m_arThemes.size(); ++i)
+				{
+					CP_XML_NODE(L"vt:lpstr")
+					{
+						CP_XML_STREAM() <<  L"Theme " << i;
+					}	
+				}
+				for (size_t i = 1; i <= m_pDocument->m_arSlides.size(); ++i)
+				{
+					CP_XML_NODE(L"vt:lpstr")
+					{
+						CP_XML_STREAM() <<  L"Slide " << i;
+					}
+				}
+			}
+		}
+
+		CP_XML_NODE(L"Company");
+		CP_XML_NODE(L"LinksUpToDate")
+		{
+			CP_XML_STREAM() <<  L"false";
+		}
+		CP_XML_NODE(L"SharedDoc")
+		{
+			CP_XML_STREAM() <<  L"false";
+		}
+		CP_XML_NODE(L"HyperlinksChanged")
+		{
+			CP_XML_STREAM() <<  L"false";
+		}
 	}
-	for (int i = 1; i <= nCountSlides; ++i)
-	{
-        strMemory += L"<vt:lpstr>Slide " + std::to_wstring(i) + L"</vt:lpstr>";
-	}
-
-    std::wstring str5 = _T("</vt:vector>\
-</TitlesOfParts>\
-<Company></Company>\
-<LinksUpToDate>false</LinksUpToDate>\
-<SharedDoc>false</SharedDoc>\
-<HyperlinksChanged>false</HyperlinksChanged>\
-<AppVersion>4.4000</AppVersion>\
-</Properties>");
-
-	strMemory += str5;
-
-	oFile.WriteStringUTF8(strMemory);
+	oFile.WriteStringUTF8(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>");
+	oFile.WriteStringUTF8(strm.str());
 }
 
 void NSPresentationEditor::CPPTXWriter::WritePresInfo()

ASCOfficePPTFile/PPTFormatLib/Records/Drawing/ShapeContainer.h

@@ -959,7 +959,7 @@ public:
 		case NSOfficeDrawing::adjust10Value:
 			{
 				LONG lIndexAdj = pProperty->m_ePID - NSOfficeDrawing::adjustValue;
-				if (lIndexAdj >= 0 && lIndexAdj < pShape->m_arAdjustments.size())
+				if (lIndexAdj >= 0 && lIndexAdj < (LONG)pShape->m_arAdjustments.size())
 				{
 					pShape->m_oCustomVML.LoadAdjusts(lIndexAdj, (LONG)pProperty->m_lValue);
 				}
@@ -1639,7 +1639,7 @@ public:
 			}
 
 //------ shape properties ----------------------------------------------------------------------------------------
-			for (int nIndexProp = 0; nIndexProp < oArrayOptions.size(); ++nIndexProp)
+			for (size_t nIndexProp = 0; nIndexProp < oArrayOptions.size(); ++nIndexProp)
 			{
 				CPPTElement oElement;
 				oElement.SetUpProperties(pElement, pTheme, pSlideWrapper, pSlide, &oArrayOptions[nIndexProp]->m_oProperties);
@@ -1756,7 +1756,7 @@ public:
 		}
 		else
 		{//image, audio, video ....
-			for (int nIndexProp = 0; nIndexProp < oArrayOptions.size(); ++nIndexProp)
+			for (size_t nIndexProp = 0; nIndexProp < oArrayOptions.size(); ++nIndexProp)
 			{
 				CPPTElement oElement;
 				oElement.SetUpProperties(pElement, pTheme, pSlideWrapper, pSlide, &oArrayOptions[nIndexProp]->m_oProperties);

ASCOfficePPTFile/PPTFormatLib/Records/TextSpecInfoAtom.h

@@ -70,7 +70,7 @@ public:
 
 			int sz = pStream->tell() - m_lOffsetInStream;
 
-			if (sz >= m_oHeader.RecLen)
+			if (sz >= (int)m_oHeader.RecLen)
 				break;
 		}
 
@@ -85,7 +85,7 @@ public:
 		if (m_arrSIs.size() < 1) return;
 
 		int pos_text = 0, pos_si = 0;
-		int ind = 0;
+		size_t ind = 0;
 		
 		for (size_t i = 0; i < pText->m_arParagraphs.size(); i++)
 		{

ASCOfficePPTFile/PPTFormatLib/Win32/PPTFormatLib.vcproj

@@ -65,6 +65,7 @@
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="false"
 				DebugInformationFormat="4"
+				DisableSpecificWarnings="4005;4311;4312"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"

ASCOfficePPTXFile/ASCOfficeDrawingConverter.cpp

@@ -937,6 +937,12 @@ void CDrawingConverter::SetEmbedDstPath(const std::wstring& sPath)
 
     NSDirectory::CreateDirectory(sPath);
 }
+
+void CDrawingConverter::ClearShapeTypes()
+{
+	m_mapShapeTypes.clear();
+}
+
 HRESULT CDrawingConverter::AddShapeType(const std::wstring& bsXml)
 {
     std::wstring strXml = L"<main ";
@@ -974,20 +980,24 @@ HRESULT CDrawingConverter::AddShapeType(const std::wstring& bsXml)
 
 	if (oNode.IsValid())
 	{
-        CPPTShape* pShape = new CPPTShape();
-		pShape->m_bIsShapeType = true;
-
         XmlUtils::CXmlNode oNodeST = oNode.ReadNodeNoNS(L"shapetype");
 
         std::wstring strId = oNodeST.GetAttribute(L"id");
-		pShape->LoadFromXMLShapeType(oNodeST);
 
-		CShapePtr pS = CShapePtr(new CShape(NSBaseShape::unknown, 0));
-		pS->setBaseShape(CBaseShapePtr(pShape));
-		
-		LoadCoordSize(oNodeST, pS);
+		//if (m_mapShapeTypes.find(strId) == m_mapShapeTypes.end())//?? с затиранием ???
+		{
+			CPPTShape* pShape = new CPPTShape();
+			pShape->m_bIsShapeType = true;
+			
+			pShape->LoadFromXMLShapeType(oNodeST);
 
-		m_mapShapeTypes.insert(std::pair<std::wstring, CShapePtr>(strId, pS));			
+			CShapePtr pS = CShapePtr(new CShape(NSBaseShape::unknown, 0));
+			pS->setBaseShape(CBaseShapePtr(pShape));
+			
+			LoadCoordSize(oNodeST, pS);
+
+			m_mapShapeTypes.insert(std::make_pair(strId, pS));			
+		}
     }
 
 	return S_OK;
@@ -1094,6 +1104,12 @@ PPTX::Logic::SpTreeElem CDrawingConverter::ObjectFromXml(const std::wstring& sXm
              }
             else if (strName == L"pict" || strName == L"object")
 			{
+				//сначала shape type
+				XmlUtils::CXmlNode oNodeST;
+				if (oParseNode.GetNode(L"v:shapetype", oNodeST))
+				{
+					AddShapeType(oNodeST.GetXml());
+				}
 				XmlUtils::CXmlNodes oChilds;
                 if (oParseNode.GetNodes(L"*", oChilds))
 				{
@@ -1148,10 +1164,6 @@ PPTX::Logic::SpTreeElem CDrawingConverter::ObjectFromXml(const std::wstring& sXm
 #endif
 							}
 						}
-                        else if (L"shapetype" == strNameP)
-						{
-							AddShapeType(oNodeP.GetXml());
-						}
 						else
 						{
 							continue;
@@ -1447,6 +1459,13 @@ bool CDrawingConverter::ParceObject(const std::wstring& strXml, std::wstring** p
 			}
             else if (strName == L"pict" || strName == L"object")
 			{
+				//сначала shape type
+				XmlUtils::CXmlNode oNodeST;
+				if (oParseNode.GetNode(L"v:shapetype", oNodeST))
+				{
+					AddShapeType(oNodeST.GetXml());
+				}
+
 				XmlUtils::CXmlNodes oChilds;
                 if (oParseNode.GetNodes(L"*", oChilds))
 				{
@@ -1487,10 +1506,6 @@ bool CDrawingConverter::ParceObject(const std::wstring& strXml, std::wstring** p
 								doc_LoadGroup(pElem, oNodeP, pMainProps, true);
 							}
 						}
-                        else if (L"shapetype" == strNameP)
-						{
-							AddShapeType(oNodeP.GetXml());
-						}
 						else
 						{
 							continue;
@@ -2817,6 +2832,13 @@ void CDrawingConverter::doc_LoadGroup(PPTX::Logic::SpTreeElem *result, XmlUtils:
     if (bIsTop) pTree->m_lGroupIndex = 0;
     else        pTree->m_lGroupIndex = 1;
 
+	//сначала shape type
+	XmlUtils::CXmlNode oNodeST;
+	if (oNode.GetNode(L"v:shapetype", oNodeST))
+	{
+		AddShapeType(oNodeST.GetXml());
+	}
+
 	XmlUtils::CXmlNodes oNodes;
     if (oNode.GetNodes(L"*", oNodes))
 	{
@@ -2828,30 +2850,7 @@ void CDrawingConverter::doc_LoadGroup(PPTX::Logic::SpTreeElem *result, XmlUtils:
 
 			std::wstring strNameP = XmlUtils::GetNameNoNS(oNodeT.GetName());
 
-            if (L"shapetype" == strNameP)
-			{
-				//AddShapeType(oNodeT.GetXml()); 
-                std::wstring strId = oNodeT.GetAttribute(L"id");
-
-				if (strId.length() > 0)
-				{
-					if (m_mapShapeTypes.find(strId) == m_mapShapeTypes.end())
-					{
-						CPPTShape* pShape = new CPPTShape();
-						pShape->m_bIsShapeType = true;
-
-						pShape->LoadFromXMLShapeType(oNodeT);
-
-						CShapePtr pS = CShapePtr(new CShape(NSBaseShape::unknown, 0));
-						pS->setBaseShape(CBaseShapePtr(pShape));
-						
-						LoadCoordSize(oNodeT, pS);
-
-						m_mapShapeTypes.insert(std::pair<std::wstring, CShapePtr>(strId, pS));	
-					}
-				}
-			}
-            else if (L"shape"       == strNameP ||
+				if (L"shape"       == strNameP ||
                     L"rect"         == strNameP ||
                     L"oval"         == strNameP ||
                     L"line"         == strNameP ||
@@ -2873,6 +2872,8 @@ void CDrawingConverter::doc_LoadGroup(PPTX::Logic::SpTreeElem *result, XmlUtils:
 				if (_el.is_init())
 					pTree->SpTreeElems.push_back(_el);
 			}
+			else
+				continue;
 		}
 	}
 
@@ -3985,8 +3986,19 @@ void CDrawingConverter::CheckBrushShape(PPTX::Logic::SpTreeElem* oElem, XmlUtils
 		nullable_string sRid;
 		oNodeFill.ReadAttributeBase(L"r:id", sRid);
 		if (sRid.is_init())
-		{			
-			PPTX::Logic::BlipFill* pBlipFill = new PPTX::Logic::BlipFill();
+		{		
+			PPTX::Logic::BlipFill* pBlipFill = NULL;
+			if (pPicture)
+			{
+				pBlipFill = &pPicture->blipFill;
+			}
+			else
+			{
+				pBlipFill = new PPTX::Logic::BlipFill();
+				
+				pSpPr->Fill.m_type = PPTX::Logic::UniFill::blipFill;
+				pSpPr->Fill.Fill = pBlipFill;
+			}
             pBlipFill->m_namespace = L"a";
 			pBlipFill->blip = new PPTX::Logic::Blip();
 			pBlipFill->blip->embed = new OOX::RId(*sRid);
@@ -3999,9 +4011,6 @@ void CDrawingConverter::CheckBrushShape(PPTX::Logic::SpTreeElem* oElem, XmlUtils
 			{
 				pBlipFill->stretch = new PPTX::Logic::Stretch();				
 			}
-
-			pSpPr->Fill.m_type = PPTX::Logic::UniFill::blipFill;
-			pSpPr->Fill.Fill = pBlipFill;
 		}		
 		nullable_string sRotate;
 		oNodeFill.ReadAttributeBase(L"rotate", sRotate);
@@ -4128,7 +4137,19 @@ void CDrawingConverter::CheckBrushShape(PPTX::Logic::SpTreeElem* oElem, XmlUtils
 				nullable_string sType;
 				oNodeFillID.ReadAttributeBase(L"type", sType);
 
-				PPTX::Logic::BlipFill* pBlipFill = new PPTX::Logic::BlipFill();
+				PPTX::Logic::BlipFill* pBlipFill = NULL;
+				
+				if (pPicture)
+				{
+					pBlipFill = &pPicture->blipFill;
+				}
+				else
+				{
+					pBlipFill = new PPTX::Logic::BlipFill();
+					
+					pSpPr->Fill.m_type = PPTX::Logic::UniFill::blipFill;
+					pSpPr->Fill.Fill = pBlipFill;
+				}
                 pBlipFill->m_namespace = L"a";
 				pBlipFill->blip = new PPTX::Logic::Blip();
 
@@ -4180,51 +4201,50 @@ void CDrawingConverter::CheckBrushShape(PPTX::Logic::SpTreeElem* oElem, XmlUtils
 					else
 						pBlipFill->srcRect->b = str0;
 				}
-
-				if (pShape)
-				{
-					pSpPr->Fill.m_type = PPTX::Logic::UniFill::blipFill;
-					pSpPr->Fill.Fill = pBlipFill;
-				}
-				if (pPicture)
-				{
-					pSpPr->Fill.m_type = PPTX::Logic::UniFill::notInit;
-					pPicture->blipFill = *pBlipFill;
-				}
-
 			}
 		}
 	}
-
-	// default params
-	if (!pSpPr->Fill.Fill.is_init())
+	if (pPicture)
 	{
-		if (pPPTShape->IsWordArt())
-		{
-			PPTX::Logic::NoFill* pNoFill = new PPTX::Logic::NoFill();
-            pNoFill->m_namespace = L"a";
+		pSpPr->Fill.m_type = PPTX::Logic::UniFill::notInit;
 
-			pSpPr->Fill.m_type = PPTX::Logic::UniFill::noFill;
-			pSpPr->Fill.Fill = pNoFill;
+		if (false == pPicture->blipFill.blip.is_init())
+		{//MSF_Lec3-4.docx
+			oElem->InitElem(NULL);
 		}
-		else
+	}
+	else
+	{
+		// default params for fill shape
+		if (!pSpPr->Fill.Fill.is_init())
 		{
-			PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
-            pSolid->m_namespace = L"a";
-			pSolid->Color.Color = new PPTX::Logic::SrgbClr();
-			pSolid->Color.Color->SetRGB(0xFF, 0xFF, 0xFF);
-
-			pSpPr->Fill.m_type = PPTX::Logic::UniFill::solidFill;
-			pSpPr->Fill.Fill = pSolid;
-
-			if (sOpacity.is_init())
+			if (pPPTShape->IsWordArt())
 			{
-				BYTE lAlpha = NS_DWC_Common::getOpacityFromString(*sOpacity);
-				PPTX::Logic::ColorModifier oMod;
-                oMod.name = L"alpha";
-				int nA = (int)(lAlpha * 100000.0 / 255.0);
-				oMod.val = nA;
-				pSolid->Color.Color->Modifiers.push_back(oMod);
+				PPTX::Logic::NoFill* pNoFill = new PPTX::Logic::NoFill();
+				pNoFill->m_namespace = L"a";
+
+				pSpPr->Fill.m_type = PPTX::Logic::UniFill::noFill;
+				pSpPr->Fill.Fill = pNoFill;
+			}
+			else
+			{
+				PPTX::Logic::SolidFill* pSolid = new PPTX::Logic::SolidFill();
+				pSolid->m_namespace = L"a";
+				pSolid->Color.Color = new PPTX::Logic::SrgbClr();
+				pSolid->Color.Color->SetRGB(0xFF, 0xFF, 0xFF);
+
+				pSpPr->Fill.m_type = PPTX::Logic::UniFill::solidFill;
+				pSpPr->Fill.Fill = pSolid;
+
+				if (sOpacity.is_init())
+				{
+					BYTE lAlpha = NS_DWC_Common::getOpacityFromString(*sOpacity);
+					PPTX::Logic::ColorModifier oMod;
+					oMod.name = L"alpha";
+					int nA = (int)(lAlpha * 100000.0 / 255.0);
+					oMod.val = nA;
+					pSolid->Color.Color->Modifiers.push_back(oMod);
+				}
 			}
 		}
 	}

ASCOfficePPTXFile/ASCOfficeDrawingConverter.h

@@ -225,7 +225,8 @@ namespace NSBinPptxRW
         void SetMediaDstPath    (const std::wstring& sMediaPath);
         void SetEmbedDstPath    (const std::wstring& sEmbedPath);
 
-        HRESULT AddShapeType        (const std::wstring& sXml);
+		void ClearShapeTypes	();
+
         HRESULT AddObject           (const std::wstring& sXml, std::wstring** pMainProps);
 
         HRESULT SaveObject          (long lStart, long lLength, const std::wstring& sMainProps, std::wstring & sXml);
@@ -293,6 +294,7 @@ namespace NSBinPptxRW
 
         void    Clear();
 		HRESULT SetCurrentRelsPath();
+        HRESULT AddShapeType        (const std::wstring& sXml);
 	};
 }
 #endif //OOX_IFILE_CONTAINER_INCLUDE_H_

ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.cpp

@@ -1280,6 +1280,14 @@ namespace NSBinPptxRW
 
 		m_pWriter->WriteString(strRels);
 	}
+	void CRelsGenerator::WritePresentationComments(int nComment)
+	{
+		std::wstring strRels = L"<Relationship Id=\"rId" + std::to_wstring( m_lNextRelsID++ ) +
+			L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments\" Target=\"comments/comment" +
+			std::to_wstring(nComment) + L".xml\"/>";
+
+		m_pWriter->WriteString(strRels);
+	}
 	void CRelsGenerator::EndPresentationRels(bool bIsCommentsAuthors, bool bIsNotesMaster, bool bIsVbaProject, bool bIsJsaProject)
 	{
  		if (bIsNotesMaster)

ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.h

@@ -424,6 +424,7 @@ namespace NSBinPptxRW
 		void WriteThemes (int nCount);
 		void WriteSlides (int nCount);
 		void WriteSlideComments	(int nComment);
+		void WritePresentationComments	(int nComment);
 		int WriteChart (int nChartNumber, _INT32 lDocType);
 		int WriteRels (const std::wstring& bsType, const std::wstring& bsTarget, const std::wstring& bsTargetMode);
 		int WriteHyperlink	(const std::wstring& strLink, const bool& bIsActionInit);		

ASCOfficePPTXFile/Editor/PPTXWriter.h

@@ -32,7 +32,6 @@
 #pragma once
 #include "Converter.h"
 #include "../../DesktopEditor/common/Directory.h"
-#include "../../Common/DocxFormat/Source/DocxFormat/App.h"
 
 #include "DefaultNotesMaster.h"
 #include "DefaultNotesTheme.h"
@@ -823,6 +822,24 @@ namespace NSBinPptxRW
 					m_oPresentation.notesMasterIdLst[0].rid = (size_t)nCurrentRels;
 					++nCurrentRels;
 				}
+				if (m_oPresentation.comments.is_init())
+				{
+					m_oReader.m_pRels->WritePresentationComments(nComment);
+					OOX::CPath pathFolderCommentDir = m_strDstFolder + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("comments");
+					if (1 == nComment)
+					{
+						NSDirectory::CreateDirectory (pathFolderCommentDir.GetPath());
+					}
+					std::wstring strCommentFile = L"comment" + std::to_wstring(nComment) + L".xml";
+
+					oXmlWriter.ClearNoAttack();
+					m_oPresentation.comments->toXmlWriter(&oXmlWriter);
+
+					OOX::CPath pathComment = pathFolderCommentDir + FILE_SEPARATOR_STR  + strCommentFile;
+					oXmlWriter.SaveToFile(pathComment.GetPath());
+
+					++nComment;
+				}
 
 				m_oReader.m_pRels->EndPresentationRels(m_oPresentation.commentAuthors.is_init(), bNotesMasterPresent, m_oPresentation.m_pVbaProject.is_init(), m_oPresentation.m_pJsaProject.is_init());
 				m_oReader.m_pRels->CloseRels();
@@ -1012,11 +1029,12 @@ namespace NSBinPptxRW
 		{
 			m_oApp.TotalTime = 0;
 			m_oApp.Words = 0;
-			m_oApp.Application = L"OnlyOffice";
+			std::wstring sApplication = L"ONLYOFFICE";
 #if defined(INTVER)
             std::string s = VALUE2STR(INTVER);
-            m_oApp.AppVersion = std::wstring(s.begin(), s.end());
+            sApplication += L"/" + std::wstring(s.begin(), s.end());
 #endif
+			m_oApp.Application = sApplication;
 			m_oApp.PresentationFormat = L"On-screen Show (4:3)";
 			m_oApp.Paragraphs = 0;
 			m_oApp.Slides = (int)m_arSlides.size();
@@ -1058,7 +1076,6 @@ namespace NSBinPptxRW
 			m_oApp.LinksUpToDate = false;
 			m_oApp.SharedDoc = false;
 			m_oApp.HyperlinksChanged = false;
-			m_oApp.AppVersion = _T("3.0000");			
 		}
 		void CreateDefaultCore()
 		{

ASCOfficePPTXFile/PPTXFormat/FileContainer.cpp

@@ -40,10 +40,12 @@
 #include "../../Common/DocxFormat/Source/DocxFormat/Rels.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/ContentTypes.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/External/HyperLink.h"
-#include "../../Common/DocxFormat/Source/DocxFormat/Media/Media.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/FileTypes.h"
 #include "../../DesktopEditor/common/Directory.h"
 
+#include "../../Common/DocxFormat/Source/DocxFormat/Media/Image.h"
+#include "../../Common/DocxFormat/Source/DocxFormat/Media/OleObject.h"
+
 #include <boost/unordered_map.hpp>
 
 namespace PPTX
@@ -87,12 +89,71 @@ namespace PPTX
 
 	void FileContainer::read(const OOX::CPath& filename)
 	{
-		//OOX::IFileContainer::read(filename);
 	}
 
 	void FileContainer::read(const OOX::CRels& rels, const OOX::CPath& path)
 	{
 	}
+	const bool FileContainer::IsExist(const OOX::FileType& oType) const
+	{
+		for (size_t i = 0; i < m_arContainer.size(); ++i)
+		{
+			smart_ptr<OOX::File> pFile	= m_arContainer[i];
+
+			if (oType == pFile->type())
+				return true;
+		}
+
+		return false;
+	}
+	smart_ptr<OOX::File> FileContainer::Get(const OOX::FileType& oType)
+	{
+		for (size_t i = 0; i < m_arContainer.size(); ++i)
+		{
+			smart_ptr<OOX::File> &pFile	= m_arContainer[i];
+			if (oType == pFile->type())
+				return pFile;
+		}
+
+		return smart_ptr<OOX::File>(new OOX::UnknowTypeFile( m_oUnknown ));
+	}
+
+	void FileContainer::Get(const OOX::FileType& oType, std::vector<smart_ptr<OOX::File>> & files)
+	{
+		for (size_t i = 0; i < m_arContainer.size(); ++i)
+		{
+			smart_ptr<OOX::File> &pFile	= m_arContainer[i];
+			
+			if ( oType == pFile->type() )
+				files.push_back(pFile);
+		}
+	}
+	std::wstring FileContainer::GetImagePathNameFromRId(const OOX::RId& rid)const
+	{
+		smart_ptr<OOX::Image> p = IFileContainer::Get<OOX::Image>(rid);
+		if (!p.is_init())
+			return _T("");
+		return p->filename().m_strFilename;
+	}
+	std::wstring FileContainer::GetLinkFromRId(const OOX::RId& rid)const
+	{
+		smart_ptr<OOX::External> pExt = Find(rid).smart_dynamic_cast<OOX::External>();
+		if (pExt.IsInit())
+			return pExt->Uri().m_strFilename;
+
+		smart_ptr<OOX::Media> pMedia = Find(rid).smart_dynamic_cast<OOX::Media>();
+		if (pMedia.IsInit())
+			return pMedia->filename().m_strFilename;
+
+		return _T("");
+	}
+	std::wstring FileContainer::GetOleFromRId(const OOX::RId& rid)const
+	{
+		smart_ptr<OOX::OleObject> p = IFileContainer::Get<OOX::OleObject>(rid);
+		if (!p.is_init())
+			return _T("");
+		return p->filename().m_strFilename;
+	}
 	void FileContainer::read(const OOX::CRels& rels, const OOX::CPath& path, FileMap& map, IPPTXEvent* Event)
 	{
 		bool bIsSlide = false;
@@ -178,9 +239,11 @@ namespace PPTX
 	void FileContainer::write(OOX::CRels& rels, const OOX::CPath& curdir, const OOX::CPath& directory, OOX::CContentTypes& content) const
 	{
 		std::map<std::wstring, size_t> mNamePair;
-        for (std::map<std::wstring, smart_ptr<OOX::File>>::const_iterator pPair = m_mContainer.begin(); pPair != m_mContainer.end(); ++pPair)
+       
+        for (boost::unordered_map<std::wstring, smart_ptr<OOX::File>>::const_iterator pPair = m_mapContainer.begin(); pPair != m_mapContainer.end(); ++pPair)
 		{
-			smart_ptr<OOX::File>		pFile	= pPair->second;
+			smart_ptr<OOX::File>		pFile = pPair->second;
+
 			smart_ptr<OOX::External>	pExt	= pFile.smart_dynamic_cast<OOX::External>();
 			smart_ptr<OOX::Media>		pMedia  = pFile.smart_dynamic_cast<OOX::Media>();
 
@@ -217,6 +280,7 @@ namespace PPTX
 
 					OOX::CSystemUtility::CreateDirectories(directory / defdir);
 					pFile->write(directory / defdir / name, directory, content);
+					
 					rels.Registration(pPair->first, pFile->type(), defdir / name);
 				}
 			}
@@ -229,9 +293,9 @@ namespace PPTX
 
 	void FileContainer::WrittenSetFalse()
 	{
-        for (std::map<std::wstring, smart_ptr<OOX::File>>::const_iterator pPair = m_mContainer.begin(); pPair != m_mContainer.end(); ++pPair)
+		for (size_t i = 0; i < m_arContainer.size(); i++)
 		{
-			smart_ptr<OOX::File> pFile = pPair->second;
+			smart_ptr<OOX::File> &pFile = m_arContainer[i];
 
 			smart_ptr<PPTX::WrapperFile>	pWrapFile = pFile.smart_dynamic_cast<PPTX::WrapperFile>();
 			smart_ptr<PPTX::FileContainer>	pWrapCont = pFile.smart_dynamic_cast<PPTX::FileContainer>();

ASCOfficePPTXFile/PPTXFormat/FileContainer.h

@@ -55,32 +55,14 @@ namespace PPTX
 		virtual ~FileContainer()
 		{
 		}
-		virtual std::wstring GetImagePathNameFromRId(const OOX::RId& rid)const
-		{
-			smart_ptr<OOX::Image> p = Get<OOX::Image>(rid);
-			if (!p.is_init())
-				return _T("");
-			return p->filename().m_strFilename;
-		}
-		virtual std::wstring GetLinkFromRId(const OOX::RId& rid)const
-		{
-			smart_ptr<OOX::External> pExt = Find(rid).smart_dynamic_cast<OOX::External>();
-			if (pExt.IsInit())
-				return pExt->Uri().m_strFilename;
+		const bool IsExist(const OOX::FileType& oType) const;
 
-			smart_ptr<OOX::Media> pMedia = Find(rid).smart_dynamic_cast<OOX::Media>();
-			if (pMedia.IsInit())
-				return pMedia->filename().m_strFilename;
-
-			return _T("");
-		}
-		virtual std::wstring GetOleFromRId(const OOX::RId& rid)const
-		{
-			smart_ptr<OOX::OleObject> p = Get<OOX::OleObject>(rid);
-			if (!p.is_init())
-				return _T("");
-			return p->filename().m_strFilename;
-		}
+		smart_ptr<OOX::File>	Get(const OOX::FileType& oType);
+		void					Get(const OOX::FileType& oType, std::vector<smart_ptr<OOX::File>> & files);
+		
+		virtual std::wstring GetImagePathNameFromRId(const OOX::RId& rid)const;
+		virtual std::wstring GetLinkFromRId			(const OOX::RId& rid)const;
+		virtual std::wstring GetOleFromRId			(const OOX::RId& rid)const;
 	protected:
 		void read(const OOX::CPath& filename);
 		void read(const OOX::CRels& rels, const OOX::CPath& path);

ASCOfficePPTXFile/PPTXFormat/Folder.cpp

@@ -79,12 +79,13 @@ namespace PPTX
 			if (_presentation->IsExist(OOX::FileTypes::VbaProject))
 			{
 				_presentation->m_bMacroEnabled	= true;
-				_presentation->m_pVbaProject	= _presentation->Get(OOX::FileTypes::VbaProject).smart_dynamic_cast<OOX::VbaProject>();
+				_presentation->m_pVbaProject = _presentation->Get(OOX::FileTypes::VbaProject).smart_dynamic_cast<OOX::VbaProject>();
 			}
 			if (_presentation->IsExist(OOX::FileTypes::JsaProject))
 			{
-				_presentation->m_pJsaProject	= _presentation->Get(OOX::FileTypes::JsaProject).smart_dynamic_cast<OOX::JsaProject>();
+				_presentation->m_pJsaProject = _presentation->Get(OOX::FileTypes::JsaProject).smart_dynamic_cast<OOX::JsaProject>();
 			}
+			_presentation->comments = _presentation->Get(OOX::Presentation::FileTypes::SlideComments).smart_dynamic_cast<PPTX::Comments>();
 		}
 
         for (std::map<std::wstring, smart_ptr<OOX::File>>::const_iterator pPair = map.m_map.begin(); pPair != map.m_map.end(); ++pPair)
@@ -190,17 +191,17 @@ namespace PPTX
 		return true;//FileContainer::exist(OOX::Presentation::FileTypes::Presentation);
 	}
 
-	void Document::extractPictures(const OOX::CPath& path)
-	{
-		OOX::CSystemUtility::CreateDirectories(path);
-		FileContainer::ExtractPictures(path);
-	}
+	//void Document::extractPictures(const OOX::CPath& path)
+	//{
+	//	OOX::CSystemUtility::CreateDirectories(path);
+	//	FileContainer::ExtractPictures(path);
+	//}
 
-	void Document::extractPictures(const OOX::CPath& source, const OOX::CPath& path)
-	{
-		//read(source);
-		extractPictures(path);
-	}
+	//void Document::extractPictures(const OOX::CPath& source, const OOX::CPath& path)
+	//{
+	//	//read(source);
+	//	extractPictures(path);
+	//}
 
 	long Document::CountFiles(const OOX::CPath& path)
 	{

ASCOfficePPTXFile/PPTXFormat/Folder.h

@@ -50,8 +50,8 @@ namespace PPTX
 
 		const bool isValid(const OOX::CPath& path) const;
 
-		void extractPictures(const OOX::CPath& path);
-		void extractPictures(const OOX::CPath& source, const OOX::CPath& path);
+		//void extractPictures(const OOX::CPath& path);
+		//void extractPictures(const OOX::CPath& source, const OOX::CPath& path);
 	private:
 		long CountFiles(const OOX::CPath& path);
 	};

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/Blip.cpp

@@ -135,8 +135,14 @@ namespace PPTX
 		{
 			smart_ptr<OOX::OleObject> pOleObject;
 			
-			if (pRels != NULL)						pOleObject = pRels->Get<OOX::OleObject>(oRId);
-			else if(parentFileIs<FileContainer>())	pOleObject = parentFileAs<FileContainer>().Get<OOX::OleObject>(oRId);
+			if (pRels != NULL)
+				pOleObject = pRels->Get<OOX::OleObject>(oRId);
+			else
+			{
+				OOX::IFileContainer* pContainer = dynamic_cast<OOX::IFileContainer*>(const_cast<PPTX::WrapperFile*>(parentFile));
+				if (pContainer)
+					pOleObject = pContainer->Get<OOX::OleObject>(oRId);
+			}
 			
 			if (pOleObject.IsInit())
 				return pOleObject->filename().m_strFilename;

ASCOfficePPTXFile/PPTXFormat/Logic/Pic.cpp

@@ -288,7 +288,7 @@ namespace PPTX
 				}
 				else if (7 == _at)//OleObject Binary FileName (bin, xls, doc, ... other stream file)
 				{
-					m_OleObjectFile = new OOX::OleObject(false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
+					m_OleObjectFile = new OOX::OleObject(NULL, false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
 					std::wstring strOlePath = pReader->GetString2();
 					m_OleObjectFile->set_filename(strOlePath, false); //temp !!! for ImageManager original file name
 				}
@@ -297,8 +297,9 @@ namespace PPTX
 			}
 
 			if (m_sData.IsInit() && m_OleObjectFile.IsInit() == false)
-				m_OleObjectFile = new OOX::OleObject(false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
-
+			{
+				m_OleObjectFile = new OOX::OleObject(NULL, false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
+			}
 
 			BYTE embedded_type = 0;
 
@@ -335,6 +336,17 @@ namespace PPTX
 							std::wstring strOlePath = pReader->GetString(_embed_data_size);
 							m_OleObjectFile->set_filename(strOlePath, false); //temp !!! for ImageManager original file name
 						}
+						else if (embedded_type == 4)
+						{
+							pReader->Seek(pReader->GetPos() - 4); //roll back to size record
+							std::wstring sXmlContent;
+							pReader->m_pMainDocument->getXmlContentElem(OOX::et_m_oMathPara, *pReader, sXmlContent);
+
+							if (!sXmlContent.empty())
+							{
+								m_sAlternateContenteXml = sXmlContent;
+							}
+						}
 						else if (embedded_type == 1)
 						{
 							m_OleObjectFile = new OOX::OleObject(NULL, true, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
@@ -385,7 +397,7 @@ namespace PPTX
 							OOX::CApp* pApp = new OOX::CApp(NULL);
 							if (pApp)
 							{
-								pApp->SetApplication(L"OnlyOffice");
+								pApp->SetApplication(L"ONLYOFFICE");
 #if defined(INTVER)
                                 pApp->SetAppVersion(VALUE2STR(INTVER));
 #endif
@@ -440,9 +452,10 @@ namespace PPTX
 							std::wstring sXmlOptions, sMediaPath, sEmbedPath;
 							BinXlsxRW::CXlsxSerializer::CreateXlsxFolders (sXmlOptions, sDstEmbeddedTemp, sMediaPath, sEmbedPath);
 							
-							std::map<std::wstring, size_t>	old_enum_map	= oXlsx.m_mapEnumeratedGlobal;
-                            NSBinPptxRW::CBinaryFileReader*	old_reader		= oDrawingConverter.m_pReader;
-                            NSBinPptxRW::CRelsGenerator*	old_rels		= pReader->m_pRels;
+							boost::unordered_map<std::wstring, size_t>	old_enum_map = oXlsx.m_mapEnumeratedGlobal;
+                           
+							NSBinPptxRW::CBinaryFileReader*	old_reader	= oDrawingConverter.m_pReader;
+                            NSBinPptxRW::CRelsGenerator*	old_rels	= pReader->m_pRels;
 							
 							oXlsx.m_mapEnumeratedGlobal.clear();
 
@@ -502,12 +515,14 @@ namespace PPTX
 			smart_ptr<OOX::OleObject> ole_file = m_OleObjectFile;
 			if (ole_file.IsInit() == false)
 			{
-				if (pRels != NULL)						ole_file = pRels->Get<OOX::OleObject>(oRId);
-
-				else if(parentFileIs<Slide>())			ole_file = parentFileAs<Slide>().Get<OOX::OleObject>(oRId);
-				else if(parentFileIs<SlideLayout>())	ole_file = parentFileAs<SlideLayout>().Get<OOX::OleObject>(oRId);
-				else if(parentFileIs<SlideMaster>())	ole_file = parentFileAs<SlideMaster>().Get<OOX::OleObject>(oRId);
-				else if(parentFileIs<Theme>())			ole_file = parentFileAs<Theme>().Get<OOX::OleObject>(oRId);
+				if (pRels != NULL)
+					ole_file = pRels->Get<OOX::OleObject>(oRId);
+				else
+				{
+					OOX::IFileContainer* pContainer = dynamic_cast<OOX::IFileContainer*>(const_cast<PPTX::WrapperFile*>(parentFile));
+					if (pContainer)
+						ole_file = pContainer->Get<OOX::OleObject>(oRId);
+				}
 			}
 			return ole_file;
 		}
@@ -860,7 +875,7 @@ namespace PPTX
 						if(oleObject.IsInit() && blipFill.blip.IsInit())
 						{
 							if (oleObject->m_OleObjectFile.IsInit() == false)
-								oleObject->m_OleObjectFile = new OOX::OleObject(false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
+								oleObject->m_OleObjectFile = new OOX::OleObject(NULL, false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
 							
 							oleObject->m_OleObjectFile->set_filename_cache (blipFill.blip->oleFilepathImage);
 
@@ -944,7 +959,7 @@ namespace PPTX
 
 					if (oleObject->m_OleObjectFile.IsInit() == false)
 					{
-						oleObject->m_OleObjectFile = new OOX::OleObject(false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
+						oleObject->m_OleObjectFile = new OOX::OleObject(NULL, false, pReader->m_nDocumentType == XMLWRITER_DOC_TYPE_DOCX);
 						
 						oleObject->m_OleObjectFile->set_filename		(blipFill.blip->oleFilepathBin, false);
 						oleObject->m_OleObjectFile->set_filename_cache	(blipFill.blip->oleFilepathImage);

ASCOfficePPTXFile/PPTXFormat/Logic/Pic.h

@@ -221,6 +221,8 @@ namespace PPTX
 		
 			nullable_int						m_oDxaOrig;
 			nullable_int						m_oDyaOrig;
+
+			nullable_string						m_sAlternateContenteXml;
 		};
 
 		class Pic : public WrapperWritingElement

ASCOfficePPTXFile/PPTXFormat/Presentation.h

@@ -49,6 +49,7 @@
 #include "Logic/ClrMap.h"
 #include "Logic/ExtP.h"
 #include "Theme/ClrScheme.h"
+#include "Comments.h"
 
 #include "../../Common/DocxFormat/Source/DocxFormat/Media/VbaProject.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/Media/JsaProject.h"
@@ -72,8 +73,6 @@ namespace PPTX
 		}
 		virtual void read(const OOX::CPath& filename, FileMap& map)
 		{
-			//FileContainer::read(filename, map);
-
 			XmlUtils::CXmlNode oNode;
 			oNode.FromXmlFile(filename.m_strFilename);
 
@@ -235,6 +234,7 @@ namespace PPTX
 				pWriter->EndRecord();
 			}
 			pWriter->WriteRecord2(9, m_pJsaProject);
+			pWriter->WriteRecord2(10, comments);
 
 			pWriter->EndRecord();
 		}
@@ -362,6 +362,11 @@ namespace PPTX
 						smart_ptr<OOX::File> file = m_pJsaProject.smart_dynamic_cast<OOX::File>();
 						FileContainer::Add(file);
 					}break;
+					case 10:
+					{
+						comments = new PPTX::Comments(OOX::File::m_pMainDocument);
+						comments->fromPPTY(pReader);
+					}break;
 					default:
 					{
 						pReader->SkipRecord();
@@ -479,6 +484,7 @@ namespace PPTX
 		bool						m_bMacroEnabled;
 		smart_ptr<OOX::VbaProject>	m_pVbaProject;
 		smart_ptr<OOX::JsaProject>	m_pJsaProject;
+		smart_ptr<PPTX::Comments>	comments;
 		
         void SetClrMap(Logic::ClrMap map)				{m_clrMap = map;}
         void SetClrScheme(nsTheme::ClrScheme scheme)	{m_clrScheme = scheme;}

ASCOfficePPTXFile/PPTXLib/Linux/PPTXFormatLib/PPTXFormatLib.pro

@@ -26,8 +26,6 @@ include($$PWD/../../../../Common/3dParty/boost/boost.pri)
 DEFINES += UNICODE \
     _UNICODE \
     _USE_LIBXML2_READER_ \
-    _USE_XMLLITE_READER_ \
-    USE_LITE_READER \
     AVS_USE_CONVERT_PPTX_TOCUSTOM_VML \
     #DISABLE_FILE_DOWNLOADER \
     CXIMAGE_DONT_DECLARE_TCHAR \

ASCOfficePPTXFile/PPTXLib/PPTXFormat.vcproj

@@ -54,6 +54,7 @@
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="4"
+				DisableSpecificWarnings="4005;4311;4312"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"

ASCOfficeRtfFile/RtfFormatLib/Linux/RtfFormatLib.pro

@@ -21,8 +21,6 @@ include($$PWD/../../../Common/3dParty/boost/boost.pri)
 
 DEFINES += UNICODE _UNICODE \
          _USE_LIBXML2_READER_ \
-        _USE_XMLLITE_READER_ \
-        USE_LITE_READER \
         LIBXML_READER_ENABLED \
         DONT_WRITE_EMBEDDED_FONTS \
         AVS_USE_CONVERT_PPTX_TOCUSTOM_VML

ASCOfficeRtfFile/RtfFormatLib/Win32/RtfFormatLib.vcproj

@@ -51,6 +51,7 @@
 				WarningLevel="3"
 				Detect64BitPortabilityProblems="true"
 				DebugInformationFormat="4"
+				DisableSpecificWarnings="4005;4311;4312"
 			/>
 			<Tool
 				Name="VCManagedResourceCompilerTool"

ASCOfficeRtfFile/RtfFormatLib/source/Reader/OOXHeaderReader.cpp

@@ -52,7 +52,7 @@ bool OOXHeaderReader::Parse( ReaderParameter oParam, std::wstring sRID, TextItem
 		oOOXTextItemReader.Parse(*it, oParam );
 	}
 	
-	oParam.oReader->m_currentContainer = dynamic_cast<OOX::IFileContainer*>(oParam.oDocx->GetDocument());
+	oParam.oReader->m_currentContainer = dynamic_cast<OOX::IFileContainer*>(oParam.oDocx->m_pDocument);
 	
 	return true;
 }