.

ASCOfficeDocxFile2/BinReader/DocumentWriter.h

@@ -61,7 +61,7 @@ namespace Writers
                 oFile.WriteStringUTF8( std::wstring(_T("<w:body>")));
                     oFile.WriteStringUTF8(m_oContent.GetData());
 
-                    oFile.WriteStringUTF8( std::wstring(_T("<w:sectPr >")));
+                    oFile.WriteStringUTF8( std::wstring(_T("<w:sectPr>")));
                         oFile.WriteStringUTF8(WriteSectPrHdrFtr());
                         oFile.WriteStringUTF8(m_oSecPr.GetData());
                     oFile.WriteStringUTF8( std::wstring(_T("</w:sectPr>")));

ASCOfficeDocxFile2/BinReader/Readers.h

@@ -6615,8 +6615,10 @@ public:
 				std::wstring sChartsWorksheetRelsName = L"../embeddings/" + sXlsxFilename;
 				long rIdXlsx;
                 std::wstring bstrChartsWorksheetRelType = OOX::FileTypes::MicrosoftOfficeExcelWorksheet.RelationType();
-                m_oFileWriter.m_pDrawingConverter->WriteRels(bstrChartsWorksheetRelType, sChartsWorksheetRelsName, std::wstring(), &rIdXlsx);
-
+                
+				m_oFileWriter.m_pDrawingConverter->WriteRels(bstrChartsWorksheetRelType, sChartsWorksheetRelsName, std::wstring(), &rIdXlsx);
+				m_oFileWriter.m_pDrawingConverter->m_pImageManager->m_pContentTypes->AddDefault(L"xlsx");
+				
 				pChartSpace->m_oChartSpace.m_externalData = new OOX::Spreadsheet::CT_ExternalData();
 				pChartSpace->m_oChartSpace.m_externalData->m_id = new std::wstring();
 				pChartSpace->m_oChartSpace.m_externalData->m_id->append(L"rId");

ASCOfficeDocxFile2/BinWriter/BinWriters.cpp

@@ -81,12 +81,14 @@ namespace BinDocxRW
 	void BinaryHeaderFooterTableWriter::WriteHdrFtrItem(OOX::Logic::CSectionProperty* pSectPr, OOX::CHdrFtr* pHdrFtr, bool bHdr)
 	{
 		int nCurPos = 0;
-		//Content
-		ParamsDocumentWriter oParamsDocumentWriter(pHdrFtr, pHdrFtr->m_oReadPath.GetPath());
+	//Content
+		ParamsDocumentWriter oParamsDocumentWriter(pHdrFtr);
 		m_oParamsWriter.m_pCurRels = oParamsDocumentWriter.m_pRels;
-		m_oParamsWriter.m_sCurDocumentPath = oParamsDocumentWriter.m_sDocumentPath;
+
 		BinaryDocumentTableWriter oBinaryDocumentTableWriter(m_oParamsWriter, oParamsDocumentWriter, m_mapIgnoreComments, NULL);
-		oBinaryDocumentTableWriter.prepareOfficeDrawingConverter(m_pOfficeDrawingConverter, oParamsDocumentWriter.m_sDocumentPath,  pHdrFtr->m_arrShapeTypes);
+		
+		oBinaryDocumentTableWriter.prepareOfficeDrawingConverter(m_pOfficeDrawingConverter, oParamsDocumentWriter.m_pRels,  pHdrFtr->m_arrShapeTypes);
+		
 		nCurPos = m_oBcw.WriteItemStart(c_oSerHdrFtrTypes::HdrFtr_Content);
 		oBinaryDocumentTableWriter.WriteDocumentContent(pHdrFtr->m_arrItems);
 		m_oBcw.WriteItemEnd(nCurPos);

ASCOfficeDocxFile2/BinWriter/BinWriters.h

@@ -57,7 +57,6 @@ namespace BinDocxRW
 		PPTX::Theme*			m_poTheme;
 
 		OOX::IFileContainer*	m_pCurRels;
-        std::wstring			m_sCurDocumentPath;
 		std::map<int, bool>		m_mapIgnoreComments;
 	
 		ParamsWriter(NSBinPptxRW::CBinaryFileWriter* pCBufferedStream, DocWrapper::FontProcessor* pFontProcessor, NSBinPptxRW::CDrawingConverter* pOfficeDrawingConverter, NSFontCutter::CEmbeddedFontsManager* pEmbeddedFontsManager):
@@ -72,9 +71,8 @@ namespace BinDocxRW
 	{
 	public:
 		OOX::IFileContainer*	m_pRels;
-        std::wstring			m_sDocumentPath;
 
-		ParamsDocumentWriter(OOX::IFileContainer* pRels, const std::wstring& sDocumentPath):m_pRels(pRels), m_sDocumentPath(sDocumentPath)
+		ParamsDocumentWriter(OOX::IFileContainer* pRels) : m_pRels(pRels)
 		{
 		}
 	};
@@ -99,6 +97,8 @@ namespace BinDocxRW
 		BinaryCommonWriter(ParamsWriter& oParamsWriter) :	m_oStream(*oParamsWriter.m_pCBufferedStream),
 															m_pEmbeddedFontsManager(oParamsWriter.m_pEmbeddedFontsManager)
 		{
+			*m_oStream.m_pCurrentContainer = oParamsWriter.m_pCurRels;
+			m_oStream.m_pCurrentContainer->AddRef();
 		}
 		int WriteItemStart(BYTE type)
 		{
@@ -2999,15 +2999,17 @@ namespace BinDocxRW
 				RELEASEOBJECT(m_aFldChars[i]);
 			}
 		}
-        void prepareOfficeDrawingConverter(NSBinPptxRW::CDrawingConverter* pOfficeDrawingConverter, std::wstring& sDocumentPath, std::vector<std::wstring>& aShapeTypes)
+		void prepareOfficeDrawingConverter(NSBinPptxRW::CDrawingConverter* pOfficeDrawingConverter, OOX::IFileContainer *rels, std::vector<std::wstring>& aShapeTypes)
 		{
-			pOfficeDrawingConverter->SetRelsPath(sDocumentPath);
+			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 Write(std::vector<OOX::WritingElement*>& aElems)
 		{
@@ -5480,21 +5482,14 @@ namespace BinDocxRW
 			{
 				if (pGraphic->chartRec.IsInit() && pGraphic->chartRec->id_data.IsInit() )
 				{
-					smart_ptr<OOX::File> pFile = m_oParamsDocumentWriter.m_pRels->Find( pGraphic->chartRec->id_data.get());
-					if (pFile.IsInit() && OOX::FileTypes::Chart == pFile->type())
-					{
-						OOX::Spreadsheet::CChartSpace* pChart = static_cast<OOX::Spreadsheet::CChartSpace*>(pFile.operator ->());
+					m_oBcw.m_oStream.WriteBYTE(c_oSerImageType2::Chart2);
+					m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Variable);
 
-						m_oBcw.m_oStream.WriteBYTE(c_oSerImageType2::Chart2);
-						m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Variable);
+					int nCurPos = m_oBcw.WriteItemWithLengthStart();
 
-						int nCurPos = m_oBcw.WriteItemWithLengthStart();
-						
-						BinXlsxRW::BinaryChartWriter oBinaryChartWriter(m_oBcw.m_oStream, m_pOfficeDrawingConverter);	
-						oBinaryChartWriter.WriteCT_ChartSpace(*pChart);
-						
-						m_oBcw.WriteItemWithLengthEnd(nCurPos);
-					}
+					pGraphic->chartRec->toPPTY(&m_oBcw.m_oStream);
+
+					m_oBcw.WriteItemWithLengthEnd(nCurPos);
 				}
 				else
 				{
@@ -7003,9 +6998,8 @@ namespace BinDocxRW
 		}
 		void WriteFootnotes(OOX::CFootnotes& oFootnotes)
 		{
-			ParamsDocumentWriter oParamsDocumentWriter(&oFootnotes, oFootnotes.m_oReadPath.GetPath());
+			ParamsDocumentWriter oParamsDocumentWriter(&oFootnotes);
 			m_oParamsWriter.m_pCurRels = oParamsDocumentWriter.m_pRels;
-			m_oParamsWriter.m_sCurDocumentPath = oParamsDocumentWriter.m_sDocumentPath;
 
 			int nStart = m_oBcw.WriteItemWithLengthStart();
 			WriteNotes(oFootnotes.m_arrFootnote, oParamsDocumentWriter, oFootnotes.m_arrShapeTypes);
@@ -7013,9 +7007,8 @@ namespace BinDocxRW
 		}
 		void WriteEndnotes(OOX::CEndnotes& oEndnotes)
 		{
-			ParamsDocumentWriter oParamsDocumentWriter(&oEndnotes, oEndnotes.m_oReadPath.GetPath());
+			ParamsDocumentWriter oParamsDocumentWriter(&oEndnotes);
 			m_oParamsWriter.m_pCurRels = oParamsDocumentWriter.m_pRels;
-			m_oParamsWriter.m_sCurDocumentPath = oParamsDocumentWriter.m_sDocumentPath;
 
 			int nStart = m_oBcw.WriteItemWithLengthStart();
 			WriteNotes(oEndnotes.m_arrEndnote, oParamsDocumentWriter, oEndnotes.m_arrShapeTypes);
@@ -7048,7 +7041,9 @@ namespace BinDocxRW
 			}
 
 			BinaryDocumentTableWriter oBinaryDocumentTableWriter(m_oParamsWriter, oParamsDocumentWriter, &m_oParamsWriter.m_mapIgnoreComments, NULL);
-			oBinaryDocumentTableWriter.prepareOfficeDrawingConverter(m_pOfficeDrawingConverter, oParamsDocumentWriter.m_sDocumentPath, arrShapeTypes);
+			
+			oBinaryDocumentTableWriter.prepareOfficeDrawingConverter(m_pOfficeDrawingConverter, oParamsDocumentWriter.m_pRels, arrShapeTypes);
+			
 			nCurPos = m_oBcw.WriteItemStart(c_oSerNotes::NoteContent);
 			oBinaryDocumentTableWriter.WriteDocumentContent(oFtnEdn.m_arrItems);
 			m_oBcw.WriteItemEnd(nCurPos);
@@ -7213,14 +7208,13 @@ namespace BinDocxRW
 				BinDocxRW::BinaryHeaderFooterTableWriter oBinaryHeaderFooterTableWriter(m_oParamsWriter, poDocument, &m_oParamsWriter.m_mapIgnoreComments);
 
 		//Write DocumentTable
-				ParamsDocumentWriter oParamsDocumentWriter(poDocument, poDocument->m_oReadPath.GetPath());
+				ParamsDocumentWriter oParamsDocumentWriter(poDocument);
 				m_oParamsWriter.m_pCurRels = oParamsDocumentWriter.m_pRels;
-				m_oParamsWriter.m_sCurDocumentPath = oParamsDocumentWriter.m_sDocumentPath;
 				
 		//DocumentTable всегда пишем последней, чтобы сначала заполнить все вспомогательные структуры, а при заполении документа, вызывать методы типа Style_Add...
 				nCurPos = this->WriteTableStart(BinDocxRW::c_oSerTableTypes::Document);
 				BinDocxRW::BinaryDocumentTableWriter oBinaryDocumentTableWriter(m_oParamsWriter, oParamsDocumentWriter, &m_oParamsWriter.m_mapIgnoreComments, &oBinaryHeaderFooterTableWriter);
-				oBinaryDocumentTableWriter.prepareOfficeDrawingConverter(m_oParamsWriter.m_pOfficeDrawingConverter, oParamsDocumentWriter.m_sDocumentPath, poDocument->m_arrShapeTypes);
+				oBinaryDocumentTableWriter.prepareOfficeDrawingConverter(m_oParamsWriter.m_pOfficeDrawingConverter, oParamsDocumentWriter.m_pRels, poDocument->m_arrShapeTypes);
 				
 				oBinaryDocumentTableWriter.pSectPr			= pFirstSectPr;
 				oBinaryDocumentTableWriter.pBackground		= poDocument->m_oBackground.GetPointer();

ASCOfficeDocxFile2/DocWrapper/DocxSerializer.cpp

@@ -387,7 +387,7 @@ bool BinDocxRW::CDocxSerializer::getBinaryContent(const std::wstring& bsTxConten
 
 	BinDocxRW::BinaryCommonWriter oBinaryCommonWriter(oParamsWriter);
 	int nCurPos = oBinaryCommonWriter.WriteItemWithLengthStart();
-	BinDocxRW::ParamsDocumentWriter oParams(oParamsWriter.m_pCurRels, oParamsWriter.m_sCurDocumentPath);
+	BinDocxRW::ParamsDocumentWriter oParams(oParamsWriter.m_pCurRels);
 	
 	BinDocxRW::BinaryDocumentTableWriter oBinaryDocumentTableWriter(oParamsWriter, oParams, &oParamsWriter.m_mapIgnoreComments, NULL);
 	oBinaryDocumentTableWriter.WriteDocumentContent(oSdtContent.m_arrItems);
@@ -411,7 +411,7 @@ bool BinDocxRW::CDocxSerializer::getBinaryContentElem(OOX::EElementType eElemTyp
 	BinDocxRW::BinaryCommonWriter oBinaryCommonWriter(oParamsWriter);
 	int nCurPos = oBinaryCommonWriter.WriteItemWithLengthStart();
 	
-	BinDocxRW::ParamsDocumentWriter oParams(oParamsWriter.m_pCurRels, oParamsWriter.m_sCurDocumentPath);
+	BinDocxRW::ParamsDocumentWriter oParams(oParamsWriter.m_pCurRels);
 	BinDocxRW::BinaryDocumentTableWriter oBinaryDocumentTableWriter(oParamsWriter, oParams, &oParamsWriter.m_mapIgnoreComments, NULL);
 	if(OOX::et_m_oMathPara == eElemType)
 	{

ASCOfficeDocxFile2/DocWrapper/XlsxSerializer.cpp

@@ -139,31 +139,7 @@ namespace BinXlsxRW{
 		RELEASEOBJECT(pFontPicker);
 		return true;
 	}
-    bool CXlsxSerializer::loadChart(const std::wstring& sChartPath, NSBinPptxRW::CBinaryFileWriter* pWriter, long& lDataSize)
-	{
-		if (NULL == pWriter) return false;
-		if (NULL == m_pExternalDrawingConverter) return false;
-			
-		OOX::CPath						oRootPath;
-		OOX::Spreadsheet::CChartSpace	oChart(oRootPath, sChartPath);
-		
-		long nStartPos = pWriter->GetPosition();
-		BinXlsxRW::BinaryCommonWriter oBcw(*pWriter);
-
-        std::wstring sOldRelsPath = m_pExternalDrawingConverter->GetRelsPath();
-		m_pExternalDrawingConverter->SetRelsPath(sChartPath);
-
-		BinXlsxRW::BinaryChartWriter oBinaryChartWriter(*pWriter, m_pExternalDrawingConverter);	
-		oBinaryChartWriter.WriteCT_ChartSpace(oChart);
-
-		m_pExternalDrawingConverter->SetRelsPath(sOldRelsPath);
-
-		long nEndPos = pWriter->GetPosition();
-		lDataSize = nEndPos - nStartPos;
-
-		return true;
-	}
-	bool CXlsxSerializer::saveChart(NSBinPptxRW::CBinaryFileReader* pReader, long lLength, const std::wstring& sFilepath, const long& lChartNumber)
+ 	bool CXlsxSerializer::saveChart(NSBinPptxRW::CBinaryFileReader* pReader, long lLength, const std::wstring& sFilepath, const long& lChartNumber)
 	{
 		if (NULL == pReader) return false;
 		if (NULL == m_pExternalDrawingConverter) return false;

ASCOfficeDocxFile2/DocWrapper/XlsxSerializer.h

@@ -64,7 +64,6 @@ namespace BinXlsxRW {
         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);
 		
-        bool loadChart          (const std::wstring& sChartPath, NSBinPptxRW::CBinaryFileWriter* pWriter, long& lDataSize);
         bool saveChart          (NSBinPptxRW::CBinaryFileReader* pReader, long lLength, const std::wstring& sFilename, const long& lChartNumber);
 		
         void setFontDir			(const std::wstring& sFontDir);

ASCOfficeOdfFileW/source/Oox2OdfConverter/ConvertDrawing.cpp

@@ -234,7 +234,7 @@ void OoxConverter::convert(PPTX::Logic::SmartArt *oox_smart_art)
 		odf_context()->drawing_context()->get_size (width, height);
 		odf_context()->drawing_context()->get_position (x, y);
 
-		oox_current_child_document = dynamic_cast<OOX::IFileContainer*>(oox_smart_art->m_oCommonRels.operator->());
+		oox_current_child_document = oox_smart_art->m_pFileContainer.operator->();
 
 		odf_context()->drawing_context()->start_group();
 

ASCOfficePPTXFile/ASCOfficeDrawingConverter.cpp

@@ -912,16 +912,7 @@ HRESULT CDrawingConverter::SetMainDocument(BinDocxRW::CDocxSerializer* pDocument
 	m_pImageManager->m_nDocumentType = XMLWRITER_DOC_TYPE_DOCX;
 	return S_OK;
 }
-HRESULT CDrawingConverter::SetRelsPath(const std::wstring& bsRelsPath)
-{
-	// чтобы не переоткрывать рельсы - посмотрим - может у нас уже есть такой??
-	m_strCurrentRelsPath = bsRelsPath;
-	return SetCurrentRelsPath();
-}
-std::wstring CDrawingConverter::GetRelsPath()
-{
-	return m_strCurrentRelsPath;
-}
+
 HRESULT CDrawingConverter::SetMediaDstPath(const std::wstring& bsMediaPath)
 {
 	m_pBinaryWriter->m_pCommon->m_pImageManager->m_strDstMedia = (std::wstring)bsMediaPath;
@@ -1062,9 +1053,7 @@ PPTX::Logic::SpTreeElem CDrawingConverter::ObjectFromXml(const std::wstring& sXm
 							XmlUtils::CXmlNode oNodeContent;
 							oChilds.GetAt(0, oNodeContent);
 
-							std::wstring strCurrentRelsPath = m_strCurrentRelsPath;
-
-                            if (L"dgm:relIds" == oNodeContent.GetName() && m_pBinaryWriter->m_pCommonRels->is_init())
+                            if (L"dgm:relIds" == oNodeContent.GetName() && m_pBinaryWriter->m_pCurrentContainer->is_init())
 							{
 								doc_LoadDiagram(&oElem, oNodeContent, ppMainProps, true);
 							}
@@ -1597,7 +1586,7 @@ void CDrawingConverter::doc_LoadDiagram(PPTX::Logic::SpTreeElem *result, XmlUtil
 	
 	if (id_data.IsInit())
 	{
-		oFileData = (*m_pBinaryWriter->m_pCommonRels)->Find(*id_data);
+		oFileData = (*m_pBinaryWriter->m_pCurrentContainer)->Find(*id_data);
 		
 		if (oFileData.is_init())
 		{
@@ -1616,7 +1605,7 @@ void CDrawingConverter::doc_LoadDiagram(PPTX::Logic::SpTreeElem *result, XmlUtil
 		}
 		if (id_drawing.is_init())
 		{
-			oFileDrawing = (*m_pBinaryWriter->m_pCommonRels)->Find(*id_drawing);
+			oFileDrawing = (*m_pBinaryWriter->m_pCurrentContainer)->Find(*id_drawing);
 			pDiagramDrawing = dynamic_cast<OOX::CDiagramDrawing*>(oFileDrawing.operator->());
 		}
 		if (!pDiagramDrawing && pDiagramData)
@@ -1641,8 +1630,7 @@ void CDrawingConverter::doc_LoadDiagram(PPTX::Logic::SpTreeElem *result, XmlUtil
 	{
 		result->InitElem(new PPTX::Logic::SpTree(*pDiagramDrawing->m_oShapeTree));
 		//to correct write blipFill rId to binary
-		m_strCurrentRelsPath = pDiagramDrawing->GetReadPath().GetPath();
-		SetCurrentRelsPath();
+		SetRels(pDiagramDrawing);
 	}
 	else
 	{//BG-FSC1.docx
@@ -2604,10 +2592,10 @@ void CDrawingConverter::doc_LoadShape(PPTX::Logic::SpTreeElem *elem, XmlUtils::C
 		{
             std::wstring sId = oNodeTextData.GetAttribute(L"id");
 
-			if (sId.length() > 0 && m_pBinaryWriter->m_pCommonRels->IsInit())
+			if (sId.length() > 0 && m_pBinaryWriter->m_pCurrentContainer->IsInit())
 			{
 				OOX::RId rId(sId);
-				smart_ptr<PPTX::LegacyDiagramText> pExt = (*m_pBinaryWriter->m_pCommonRels)->legacyDiagramText(rId);
+				smart_ptr<PPTX::LegacyDiagramText> pExt = (*m_pBinaryWriter->m_pCurrentContainer)->GetLegacyDiagramText(rId);
 
 				if (pExt.IsInit())
 				{
@@ -5275,27 +5263,19 @@ void CDrawingConverter::Clear()
 		RELEASEOBJECT(pMem);
 	}
 	m_mapShapeTypes.clear();
-	m_mapRels.clear();
 }
-
-HRESULT CDrawingConverter::SetCurrentRelsPath()
+void CDrawingConverter::SetRels(smart_ptr<OOX::IFileContainer> container)
 {
-	std::map<std::wstring, smart_ptr<PPTX::CCommonRels>>::iterator pPair = m_mapRels.find(m_strCurrentRelsPath);
-
-	if (m_mapRels.end() == pPair)
-	{
-		smart_ptr<PPTX::CCommonRels> pCR = new PPTX::CCommonRels();
-		m_mapRels.insert(std::pair<std::wstring, NSCommon::smart_ptr<PPTX::CCommonRels>>(m_strCurrentRelsPath, pCR));
-
-		pPair = m_mapRels.find(m_strCurrentRelsPath);
-		
-		OOX::CPath filename = m_strCurrentRelsPath;	
-		pPair->second->_read(filename);
-	}
-
-	*m_pBinaryWriter->m_pCommonRels = pPair->second;
-
-	return S_OK;
+	*m_pBinaryWriter->m_pCurrentContainer = container;
+}
+void CDrawingConverter::SetRels(OOX::IFileContainer *container)
+{
+	*m_pBinaryWriter->m_pCurrentContainer = smart_ptr<OOX::IFileContainer>(container);
+	m_pBinaryWriter->m_pCurrentContainer->AddRef();
+}
+smart_ptr<OOX::IFileContainer> CDrawingConverter::GetRels()
+{
+	return *m_pBinaryWriter->m_pCurrentContainer;
 }
 void CDrawingConverter::SetFontManager(CFontManager* pFontManager)
 {

ASCOfficePPTXFile/ASCOfficeDrawingConverter.h

@@ -63,6 +63,7 @@ namespace BinDocxRW
 namespace OOX
 {
 	class CContentTypes;
+	class IFileContainer;
 }
 namespace NSBinPptxRW
 {
@@ -186,9 +187,7 @@ namespace NSBinPptxRW
 		};
 
 
-        std::map<std::wstring, CShape*>                                 m_mapShapeTypes;
-		std::map<std::wstring, NSCommon::smart_ptr<PPTX::CCommonRels>>	m_mapRels;
-        std::wstring                                                    m_strCurrentRelsPath;
+        std::map<std::wstring, CShape*>						m_mapShapeTypes;
 
         NSBinPptxRW::CBinaryFileWriter*                     m_pBinaryWriter;
         int                                                 m_lNextId;
@@ -211,9 +210,11 @@ namespace NSBinPptxRW
 
 		~CDrawingConverter();
 
-        HRESULT SetMainDocument     (BinDocxRW::CDocxSerializer* pDocument);
-        HRESULT SetRelsPath         (const std::wstring& sRelsPath);
-        std::wstring GetRelsPath    ();
+		void							SetRels(OOX::IFileContainer *container);
+		void							SetRels(smart_ptr<OOX::IFileContainer> container);
+		smart_ptr<OOX::IFileContainer>	GetRels();
+		
+		HRESULT SetMainDocument     (BinDocxRW::CDocxSerializer* pDocument);
         HRESULT SetMediaDstPath     (const std::wstring& sMediaPath);
         HRESULT SetEmbedDstPath     (const std::wstring& sEmbedPath);
 

ASCOfficePPTXFile/Editor/BinReaderWriterDefines.h

@@ -82,7 +82,8 @@ namespace NSBinPptxRW
 
 			FontsEmbedded	= 44,
 			SlideNotesRels	= 45,
-			NotesRels		= 46
+			NotesRels		= 46,
+			NotesMastersRels= 47
 		};
 	}
 }

ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.cpp

@@ -718,11 +718,12 @@ namespace NSBinPptxRW
 	}
 	CBinaryFileWriter::CBinaryFileWriter()
 	{
-		m_pMainDocument = NULL;
-		m_pCommon		= new CCommonWriter();
-		m_pCommonRels	= new NSCommon::smart_ptr<PPTX::CCommonRels>();
-		m_pTheme		= new NSCommon::smart_ptr<PPTX::Theme>();
-		m_pClrMap		= new NSCommon::smart_ptr<PPTX::Logic::ClrMap>();
+		m_pMainDocument		= NULL;
+		m_pCommon			= new CCommonWriter();
+		//m_pCommonRels		= new NSCommon::smart_ptr<PPTX::CCommonRels>();
+		m_pCurrentContainer = new NSCommon::smart_ptr<OOX::IFileContainer>();
+		m_pTheme			= new NSCommon::smart_ptr<PPTX::Theme>();
+		m_pClrMap			= new NSCommon::smart_ptr<PPTX::Logic::ClrMap>();
 		
 		Clear();
 	}
@@ -730,7 +731,8 @@ namespace NSBinPptxRW
 	{
 		RELEASEARRAYOBJECTS	(m_pStreamData);
 		RELEASEOBJECT		(m_pCommon);
-		RELEASEOBJECT		(m_pCommonRels);
+		//RELEASEOBJECT		(m_pCommonRels);
+		RELEASEOBJECT		(m_pCurrentContainer);
 		
 		RELEASEOBJECT		(m_pTheme);
 		RELEASEOBJECT		(m_pClrMap);

ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.h

@@ -51,6 +51,7 @@ namespace OOX
 	class OleObject;
 	class CContentTypes;
 	class WritingElement;
+	class IFileContainer;
 }
 namespace NSCommon
 {
@@ -63,7 +64,6 @@ namespace NSCommon
 }
 namespace PPTX
 {
-	class CCommonRels;
 	class Theme;
 	namespace Logic
 	{
@@ -154,6 +154,7 @@ namespace NSBinPptxRW
         std::vector<LONG>				m_oSlide_Layout_Rels;
 		std::vector<LONG>				m_oSlide_Notes_Rels;
 		std::vector<LONG>				m_oNote_Rels;
+		std::vector<LONG>				m_oNotesMasters_Rels;
 
 		NSShapeImageGen::CImageManager*	m_pImageManager;
 		
@@ -225,7 +226,7 @@ namespace NSBinPptxRW
 		CCommonWriter*								m_pCommon;
 		std::wstring								m_strMainFolder;
 
-		NSCommon::smart_ptr<PPTX::CCommonRels>*		m_pCommonRels;
+		NSCommon::smart_ptr<OOX::IFileContainer>*	m_pCurrentContainer;
 		BinDocxRW::CDocxSerializer *				m_pMainDocument;
 
 		NSCommon::smart_ptr<PPTX::Theme>*			m_pTheme;

ASCOfficePPTXFile/Editor/Converter.h

@@ -147,13 +147,18 @@ namespace PPTX2EditorAdvanced
 
 			// проверяем theme
             size_t pPointerTh = (size_t)(noteMaster->theme_.operator ->());
+			LONG nNotesMastersRelsIndex = -1;
 			std::map<size_t, LONG>::const_iterator pSearchTh = pCommon->themes.find(pPointerTh);
 			if (pSearchTh == pCommon->themes.end())
 			{
 				LONG lCountTh = (LONG)_themes.size();
 				pCommon->themes [pPointerTh] = lCountTh;
                 _themes.push_back(noteMaster->theme_);
+				nNotesMastersRelsIndex = lCountTh;
+			} else {
+				nNotesMastersRelsIndex = pSearchTh->second;
 			}
+			oBinaryWriter.m_pCommon->m_oNotesMasters_Rels.push_back(nNotesMastersRelsIndex);
 		}
 
 		// записываем все слайды
@@ -490,6 +495,21 @@ namespace PPTX2EditorAdvanced
 			oBinaryWriter.EndRecord();
 			// ------------------------------------------------
 
+			// NoteRels --------------------------------------
+			oBinaryWriter.StartMainRecord(NSMainTables::NotesMastersRels);
+			oBinaryWriter.StartRecord(NSMainTables::NotesMastersRels);
+			oBinaryWriter.WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
+
+			_s_rels = oBinaryWriter.m_pCommon->m_oNotesMasters_Rels.size();
+			for (size_t i = 0; i < _s_rels; ++i)
+			{
+				oBinaryWriter.WriteInt1(0, oBinaryWriter.m_pCommon->m_oNotesMasters_Rels[i]);
+			}
+
+			oBinaryWriter.WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
+			oBinaryWriter.EndRecord();
+			// ------------------------------------------------
+
 
 			oBinaryWriter.EndRecord();
 		}

ASCOfficePPTXFile/PPTXFormat/FileContainer.cpp

@@ -34,7 +34,6 @@
 #include "FileContainer.h"
 #include "FileTypes.h"
 
-#include "LegacyDiagramText.h"
 #include "FileFactory.h"
 #include "WrapperFile.h"
 
@@ -241,13 +240,7 @@ namespace PPTX
 			}
 		}
 	}
-	smart_ptr<PPTX::LegacyDiagramText> FileContainer::legacyDiagramText(const OOX::RId& rId) const 
-	{
-        std::map<std::wstring, smart_ptr<OOX::File>>::const_iterator pPair = m_mContainer.find(rId.get());
-        if (pPair == m_mContainer.end ())
-            return smart_ptr<LegacyDiagramText>();
-        return pPair->second.smart_dynamic_cast<LegacyDiagramText>();
-	}
+
 	void FileContainer::read(const OOX::CPath& filename, FileMap& map, IPPTXEvent* Event)
 	{
 		OOX::CRels rels(filename);
@@ -304,25 +297,5 @@ namespace PPTX
 		content.Registration(type().OverrideType(), directory, m_WrittenFileName);
 		m_written = true;
 	}
-//---------------------------------------------------------------------------------------------------------------------------
-	void CCommonRels::_read(const OOX::CRels& rels, const OOX::CPath& path)
-	{
-		size_t nCount = rels.m_arrRelations.size();
-		for (size_t i = 0; i < nCount; ++i)
-		{
-			OOX::Rels::CRelationShip* pRelation = rels.m_arrRelations[i];
 
-			OOX::CPath normPath = CorrectPathRels(path, pRelation);
-
-			smart_ptr<OOX::File> _file = PPTX::FileFactory::CreateFilePPTX_OnlyMedia(normPath, *pRelation);
-			Add(pRelation->rId(), _file);	
-		}
-	}
-
-	void CCommonRels::_read(const OOX::CPath& filename)
-	{
-		OOX::CRels rels(filename);
-		OOX::CPath path = filename.GetDirectory();
-		_read(rels, path);
-	}
 } // namespace PPTX

ASCOfficePPTXFile/PPTXFormat/FileContainer.h

@@ -52,7 +52,6 @@ namespace PPTX
 		virtual ~FileContainer()
 		{
 		}
-		smart_ptr<PPTX::LegacyDiagramText> legacyDiagramText (const OOX::RId& rId) const;
 
 	protected:
 		void read(const OOX::CPath& filename);
@@ -71,16 +70,6 @@ namespace PPTX
 		bool m_bCancelled;
 	};
 
-	class CCommonRels : public PPTX::FileContainer
-	{
-	public:
-		CCommonRels() : PPTX::FileContainer()
-		{
-		}
-	
-		void _read(const OOX::CPath& filename);
-		void _read(const OOX::CRels& rels, const OOX::CPath& path);
-	};
 } // namespace PPTX
 
 #endif // PPTX_IFILE_CONTAINER_INCLUDE_H_

ASCOfficePPTXFile/PPTXFormat/FileFactory.cpp

@@ -143,52 +143,4 @@ namespace PPTX
 		return smart_ptr<OOX::File>(new OOX::UnknowTypeFile());
 	}
 
-	const smart_ptr<OOX::File> FileFactory::CreateFilePPTX_OnlyMedia(const OOX::CPath& norm_filename, OOX::Rels::CRelationShip& relation)
-	{
-		bool bIsDownload = false;
-		std::wstring strFile = relation.Filename().GetPath();
-		
-		int n1 = (int)strFile.find(_T("www"));
-		int n2 = (int)strFile.find(_T("http"));
-		int n3 = (int)strFile.find(_T("ftp"));
-		int n4 = (int)strFile.find(_T("https://"));
-
-        //если nI сранивать не с 0, то будут проблемы
-        //потому что в инсталяции мы кладем файлы в /var/www...
-        if (0 == n1 || 0 == n2 || 0 == n3 || 0 == n4)
-			bIsDownload = true;
-		
-		OOX::CPath filename = norm_filename;
-
-		if (bIsDownload)
-			filename = relation.Filename();
-
-		std::wstring strT = relation.Type();
-
-		if (strT == OOX::FileTypes::Image ||
-			strT == OOX::FileTypes::Chart)
-		{
-			return smart_ptr<OOX::File>(new OOX::Image(filename));
-		}
-		else if(strT == OOX::FileTypes::Data)
-			return smart_ptr<OOX::File>(new OOX::CDiagramData(filename));
-
-		else if(strT == OOX::FileTypes::DiagDrawing)
-			return smart_ptr<OOX::File>(new OOX::CDiagramDrawing(filename));
-			
-		else if(strT == OOX::FileTypes::HyperLink)
-			return smart_ptr<OOX::File>(new OOX::HyperLink(relation.Target()));
-		
-		else if(strT == OOX::FileTypes::LegacyDiagramText)
-			return smart_ptr<OOX::File>(new PPTX::LegacyDiagramText(filename));
-
-		else if(strT == OOX::FileTypes::OleObject)
-			return smart_ptr<OOX::File>(new OOX::OleObject(filename));
-		
-		else if (	strT == OOX::FileTypes::MicrosoftOfficeUnknown) //ms package
-			return smart_ptr<OOX::File>(new OOX::OleObject( filename, true ));
-
-		return smart_ptr<OOX::File>(new OOX::UnknowTypeFile());
-	}
-
 } // namespace PPTX

ASCOfficePPTXFile/PPTXFormat/FileFactory.h

@@ -42,6 +42,5 @@ namespace PPTX
 	{
 	public:
 		static const smart_ptr<OOX::File> CreateFilePPTX(const OOX::CPath& path, OOX::Rels::CRelationShip& relation, FileMap& map);
-		static const smart_ptr<OOX::File> CreateFilePPTX_OnlyMedia(const OOX::CPath& path, OOX::Rels::CRelationShip& relation);
 	};
 } // namespace PPTX

ASCOfficePPTXFile/PPTXFormat/Logic/Controls.cpp

@@ -38,24 +38,23 @@ namespace PPTX
 {
 	namespace Logic
 	{
-		std::wstring Control::GetVmlXmlBySpid(std::wstring spid, std::wstring & rels)  const
+		std::wstring Control::GetVmlXmlBySpid(std::wstring spid, smart_ptr<OOX::IFileContainer> & rels)  const
 		{
 			std::wstring xml;
-			rels = _T("");
 			if(parentFileIs<PPTX::Slide>() && parentFileAs<PPTX::Slide>().Vml.IsInit())
 			{
 				xml		= parentFileAs<PPTX::Slide>().GetVmlXmlBySpid(spid);
-				rels	= parentFileAs<PPTX::Slide>().Vml->GetReadPath().GetPath();
+				rels	= parentFileAs<PPTX::Slide>().Vml.smart_dynamic_cast<OOX::IFileContainer>();
 			}
 			else if(parentFileIs<PPTX::SlideLayout>() && parentFileAs<PPTX::SlideLayout>().Vml.IsInit())
 			{
 				xml= parentFileAs<PPTX::SlideLayout>().GetVmlXmlBySpid(spid);
-				rels	= parentFileAs<PPTX::SlideLayout>().Vml->GetReadPath().GetPath();
+				rels	= parentFileAs<PPTX::SlideLayout>().Vml.smart_dynamic_cast<OOX::IFileContainer>();
 			}
 			else if(parentFileIs<PPTX::SlideMaster>() && parentFileAs<PPTX::SlideMaster>().Vml.IsInit())
 			{
 				xml = parentFileAs<PPTX::SlideMaster>().GetVmlXmlBySpid(spid);
-				rels	= parentFileAs<PPTX::SlideMaster>().Vml->GetReadPath().GetPath();
+				rels	= parentFileAs<PPTX::SlideMaster>().Vml.smart_dynamic_cast<OOX::IFileContainer>();
 			}
 
 			return xml;
@@ -67,7 +66,7 @@ namespace PPTX
 			std::wstring s = *spid;
 			if (s.length() < 8) s = _T("_x0000_s") + s; 
 
-			std::wstring rels;
+			smart_ptr<OOX::IFileContainer> rels;
 			std::wstring xml = GetVmlXmlBySpid(s, rels);
 
 			if (xml.length() > 0)
@@ -82,7 +81,7 @@ namespace PPTX
 				RELEASEOBJECT(oDrawingConverter.m_pBinaryWriter->m_pCommon->m_pImageManager);
 				oDrawingConverter.m_pBinaryWriter->m_pCommon->m_pImageManager = pImageManager;
 
-				oDrawingConverter.SetRelsPath(rels);
+				oDrawingConverter.SetRels(rels);
 
 				std::wstring *main_props = NULL;
 				HRESULT hRes = oDrawingConverter.AddObject(temp, &main_props);
@@ -97,7 +96,7 @@ namespace PPTX
 			std::wstring s = *spid;
 			if (s.length() < 8) s = _T("_x0000_s") + s; 
 
-			std::wstring rels;
+			smart_ptr<OOX::IFileContainer> rels;
 			std::wstring xml = GetVmlXmlBySpid(s, rels);
 
 			if (xml.length() > 0)
@@ -113,7 +112,7 @@ namespace PPTX
 	
 				std::wstring *main_props = NULL;
 
-				oDrawingConverter.SetRelsPath(rels);
+				oDrawingConverter.SetRels(rels);
 
 				HRESULT hRes = oDrawingConverter.AddObject(temp, &main_props);
 				if (hRes == S_OK && oDrawingConverter.m_pBinaryWriter->GetPosition() > 10)

ASCOfficePPTXFile/PPTXFormat/Logic/Controls.h

@@ -50,7 +50,8 @@ namespace PPTX
 
 		public:
 			void AddObjectTo (const std::vector<SpTreeElem> *spTreeElements, NSShapeImageGen::CImageManager* pImageManager) const ;
-			std::wstring GetVmlXmlBySpid(std::wstring spid, std::wstring & rels) const ;
+			
+			std::wstring GetVmlXmlBySpid(std::wstring spid, smart_ptr<OOX::IFileContainer> & rels) const ;
 			
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const ;
 

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/Blip.cpp

@@ -99,7 +99,7 @@ namespace PPTX
 				Effects[i].SetParentPointer(this);
 		}
 
-		std::wstring Blip::GetFullPicName(FileContainer* pRels)const
+		std::wstring Blip::GetFullPicName(OOX::IFileContainer* pRels)const
 		{
 			if(embed.IsInit())
 			{
@@ -141,7 +141,7 @@ namespace PPTX
 			}
 			return _T("");
 		}
-		std::wstring Blip::GetFullOleName(const OOX::RId& oRId, FileContainer* pRels)const
+		std::wstring Blip::GetFullOleName(const OOX::RId& oRId, OOX::IFileContainer* pRels)const
 		{
 			smart_ptr<OOX::OleObject> pOleObject;
 			

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/Blip.h

@@ -135,10 +135,10 @@ namespace PPTX
 				double dW = pWriter->GetShapeWidth(); //mm
 				double dH = pWriter->GetShapeHeight();
 
-				FileContainer* pRels = NULL;
+				OOX::IFileContainer* pRels = NULL;
 				
-				if (pWriter->m_pCommonRels->is_init())
-					pRels = pWriter->m_pCommonRels->operator ->();
+				if (pWriter->m_pCurrentContainer->is_init())
+					pRels = pWriter->m_pCurrentContainer->operator ->();
 
 				std::wstring olePath;
 				if(!oleFilepathBin.empty())
@@ -171,8 +171,8 @@ namespace PPTX
 
 				pWriter->EndRecord();
 			}
-			virtual std::wstring GetFullPicName(FileContainer* pRels = NULL)const;
-			virtual std::wstring GetFullOleName(const OOX::RId& pRId, FileContainer* pRels = NULL)const;
+			virtual std::wstring GetFullPicName(OOX::IFileContainer* pRels = NULL)const;
+			virtual std::wstring GetFullOleName(const OOX::RId& pRId, OOX::IFileContainer* pRels = NULL)const;
 
 			std::vector<UniEffect> Effects;
 

ASCOfficePPTXFile/PPTXFormat/Logic/GraphicFrame.cpp

@@ -375,8 +375,8 @@ namespace PPTX
 				return;
 			}
 
-			std::wstring xml_object_vml;
-			std::wstring xml_object_rels;
+			std::wstring					xml_object_vml;
+			smart_ptr<OOX::IFileContainer>	xml_object_rels;
 
 			if (oleSpid.is_init())
 			{
@@ -452,7 +452,7 @@ namespace PPTX
 	
 				std::wstring *main_props = NULL;
 
-				oDrawingConverter.SetRelsPath(xml_object_rels);
+				oDrawingConverter.SetRels(xml_object_rels);
                 oDrawingConverter.SetAdditionalParam(L"xfrm_override", (BYTE*)xfrm.GetPointer(), sizeof(xfrm));
 
 				HRESULT hRes = oDrawingConverter.AddObject(temp, &main_props);
@@ -613,35 +613,29 @@ namespace PPTX
 		{
 			nvGraphicFramePr.SetParentPointer(this);
            
-			if (xfrm.IsInit())
-				xfrm->SetParentPointer(this);
-			if(table.IsInit())
-                table->SetParentPointer(this);
-			if (smartArt.is_init())
-				smartArt->SetParentPointer(this);
-			if (chartRec.is_init())
-				chartRec->SetParentPointer(this);
-			if (olePic.is_init())
-				olePic->SetParentPointer(this);
+			if (xfrm.IsInit())			xfrm->SetParentPointer(this);
+			if (table.IsInit())			table->SetParentPointer(this);
+			if (smartArt.is_init())		smartArt->SetParentPointer(this);
+			if (chartRec.is_init())		chartRec->SetParentPointer(this);
+			if (olePic.is_init())		olePic->SetParentPointer(this);
 		}
-		std::wstring GraphicFrame::GetVmlXmlBySpid(std::wstring & rels)const
+		std::wstring GraphicFrame::GetVmlXmlBySpid(smart_ptr<OOX::IFileContainer> & rels)const
 		{
             std::wstring xml;
-			rels = L"";
 			if(parentFileIs<PPTX::Slide>() && parentFileAs<PPTX::Slide>().Vml.IsInit())
 			{
 				xml		= parentFileAs<PPTX::Slide>().GetVmlXmlBySpid(oleSpid.get_value_or(L""));
-				rels	= parentFileAs<PPTX::Slide>().Vml->GetReadPath().GetPath();
+				rels	= parentFileAs<PPTX::Slide>().Vml.smart_dynamic_cast<OOX::IFileContainer>();
 			}
 			else if(parentFileIs<PPTX::SlideLayout>() && parentFileAs<PPTX::SlideLayout>().Vml.IsInit())
 			{
-				xml= parentFileAs<PPTX::SlideLayout>().GetVmlXmlBySpid(oleSpid.get_value_or(L""));
-				rels	= parentFileAs<PPTX::SlideLayout>().Vml->GetReadPath().GetPath();
+				xml		= parentFileAs<PPTX::SlideLayout>().GetVmlXmlBySpid(oleSpid.get_value_or(L""));
+				rels	= parentFileAs<PPTX::SlideLayout>().Vml.smart_dynamic_cast<OOX::IFileContainer>();
 			}
 			else if(parentFileIs<PPTX::SlideMaster>() && parentFileAs<PPTX::SlideMaster>().Vml.IsInit())
 			{
-				xml = parentFileAs<PPTX::SlideMaster>().GetVmlXmlBySpid(oleSpid.get_value_or(L""));
-				rels	= parentFileAs<PPTX::SlideMaster>().Vml->GetReadPath().GetPath();
+				xml		= parentFileAs<PPTX::SlideMaster>().GetVmlXmlBySpid(oleSpid.get_value_or(L""));
+				rels	= parentFileAs<PPTX::SlideMaster>().Vml.smart_dynamic_cast<OOX::IFileContainer>();
 			}
 
 			return xml;

ASCOfficePPTXFile/PPTXFormat/Logic/GraphicFrame.h

@@ -98,7 +98,7 @@ namespace PPTX
 
 			SpTreeElem				element;
 
-			std::wstring GetVmlXmlBySpid(std::wstring & rels)	const;
+			std::wstring GetVmlXmlBySpid(smart_ptr<OOX::IFileContainer> & rels)	const;
 		protected:
 			virtual void FillParentPointersForChilds();
 		};

ASCOfficePPTXFile/PPTXFormat/Logic/Hyperlink.cpp

@@ -41,7 +41,7 @@ namespace PPTX
 {
 	namespace Logic
 	{
-		std::wstring Hyperlink::GetFullHyperlinkName(FileContainer* pRels)const
+		std::wstring Hyperlink::GetFullHyperlinkName(OOX::IFileContainer* pRels)const
 		{
 			if(id.IsInit() && *id != _T(""))
 			{

ASCOfficePPTXFile/PPTXFormat/Logic/Hyperlink.h

@@ -113,9 +113,9 @@ namespace PPTX
 
 				if (id.is_init())
 				{
-					FileContainer* pRels = NULL;
-					if (pWriter->m_pCommonRels->is_init())
-						pRels = pWriter->m_pCommonRels->operator ->();
+					OOX::IFileContainer* pRels = NULL;
+					if (pWriter->m_pCurrentContainer->is_init())
+						pRels = pWriter->m_pCurrentContainer->operator ->();
 
 					std::wstring str = GetFullHyperlinkName(pRels);
 					pWriter->WriteString1(0, str);
@@ -256,7 +256,7 @@ namespace PPTX
 					snd->SetParentPointer(this);
 			}
 
-			virtual std::wstring GetFullHyperlinkName(FileContainer* pRels)const;
+			virtual std::wstring GetFullHyperlinkName(OOX::IFileContainer* pRels)const;
 		};
 	} // namespace Logic
 } // namespace PPTX

ASCOfficePPTXFile/PPTXFormat/Logic/Pic.cpp

@@ -112,9 +112,9 @@ namespace PPTX
 			
 			if(m_oId.IsInit() && ole_file.IsInit() == false) 
 			{
-				FileContainer* pRels = NULL;
-				if (pWriter->m_pCommonRels->is_init())
-					pRels = pWriter->m_pCommonRels->operator ->();
+				OOX::IFileContainer* pRels = NULL;
+				if (pWriter->m_pCurrentContainer->is_init())
+					pRels = pWriter->m_pCurrentContainer->operator ->();
 
 				ole_file = GetOleObject(m_oId.get(), pRels);
 			}			
@@ -163,8 +163,8 @@ namespace PPTX
 					DocWrapper::FontProcessor fp;
 					NSBinPptxRW::CDrawingConverter oDrawingConverter; 
 					
-					NSBinPptxRW::CBinaryFileWriter*			old_writer	= oDrawingConverter.m_pBinaryWriter;
-					NSCommon::smart_ptr<PPTX::CCommonRels>  old_rels	= *pWriter->m_pCommonRels;
+					NSBinPptxRW::CBinaryFileWriter*				old_writer	= oDrawingConverter.m_pBinaryWriter;
+					NSCommon::smart_ptr<OOX::IFileContainer>	old_rels	= *pWriter->m_pCurrentContainer;
 					
 					oDrawingConverter.m_pBinaryWriter = pWriter;
 					
@@ -176,7 +176,7 @@ namespace PPTX
 					pWriter->EndRecord();
 
 					oDrawingConverter.m_pBinaryWriter	= old_writer;
-					*pWriter->m_pCommonRels				= old_rels;
+					*pWriter->m_pCurrentContainer		= old_rels;
 				}
 				else if (office_checker.nFileType == AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX)
 				//if ( std::wstring::npos != sProgID.find(L"Excel.Sheet")) //"ET.Xlsx.6" !!!
@@ -189,7 +189,7 @@ namespace PPTX
 					NSBinPptxRW::CDrawingConverter oDrawingConverter;
 					
 					NSBinPptxRW::CBinaryFileWriter*			old_writer	= oDrawingConverter.m_pBinaryWriter;
-					NSCommon::smart_ptr<PPTX::CCommonRels>  old_rels	= *pWriter->m_pCommonRels;
+					NSCommon::smart_ptr<OOX::IFileContainer>	old_rels	= *pWriter->m_pCurrentContainer;
 					
 					oDrawingConverter.m_pBinaryWriter = pWriter;
 
@@ -201,7 +201,7 @@ namespace PPTX
 					pWriter->EndRecord();
 					
 					oDrawingConverter.m_pBinaryWriter	= old_writer;
-					*pWriter->m_pCommonRels				= old_rels;
+					*pWriter->m_pCurrentContainer		= old_rels;
 				}
 				//else if (office_checker.nFileType == AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX)
 				//{
@@ -469,7 +469,7 @@ namespace PPTX
 			return m_sProgId.IsInit() && (m_sData.IsInit() || m_oId.IsInit() || m_OleObjectFile.IsInit());
 		}
 
-		smart_ptr<OOX::OleObject> COLEObject::GetOleObject(const OOX::RId& oRId, FileContainer* pRels) const
+		smart_ptr<OOX::OleObject> COLEObject::GetOleObject(const OOX::RId& oRId, OOX::IFileContainer* pRels) const
 		{
 			smart_ptr<OOX::OleObject> ole_file = m_OleObjectFile;
 			if (ole_file.IsInit() == false)

ASCOfficePPTXFile/PPTXFormat/Logic/Pic.h

@@ -198,7 +198,7 @@ namespace PPTX
 			
 			bool isValid();
 			
-			smart_ptr<OOX::OleObject>	GetOleObject(const OOX::RId& oRId, FileContainer* pRels)const;
+			smart_ptr<OOX::OleObject>	GetOleObject(const OOX::RId& oRId, OOX::IFileContainer* pRels)const;
 			std::wstring				GetOleData	(const std::wstring& sFilePath)const;
 
 			nullable_limit<Limit::OLEDrawAspectType>m_oDrawAspect;

ASCOfficePPTXFile/PPTXFormat/Logic/SmartArt.cpp

@@ -36,6 +36,7 @@
 #include "../SlideMaster.h"
 
 #include "../../ASCOfficeDrawingConverter.h"
+#include "../../../XlsxSerializerCom/Reader/ChartFromToBinary.h"
 #include "../../../ASCOfficeDocxFile2/DocWrapper/XlsxSerializer.h"
 #include "../../../Common/DocxFormat/Source/DocxFormat/Diagram/DiagramData.h"
 #include "../../../Common/DocxFormat/Source/DocxFormat/Diagram/DiagramDrawing.h"
@@ -49,11 +50,11 @@ namespace PPTX
 			if (m_diag.IsInit()) 
 				return ;
 
-			FileContainer* pRels = NULL;
+			OOX::IFileContainer* pRels = NULL;
 			if (pWriter)
 			{
-				if (pWriter->m_pCommonRels->is_init())
-					pRels = pWriter->m_pCommonRels->operator ->();
+				if (pWriter->m_pCurrentContainer->is_init())
+					pRels = pWriter->m_pCurrentContainer->operator ->();
 			}
 
 			smart_ptr<OOX::File>	oFileData;
@@ -65,11 +66,8 @@ namespace PPTX
 
 			if(id_data.IsInit())
 			{
-				if		(parentFileIs<Slide>())			oFileData = parentFileAs<Slide>().Find(*id_data);
-				else if	(parentFileIs<SlideLayout>())	oFileData = parentFileAs<SlideLayout>().Find(*id_data);
-				else if	(parentFileIs<SlideMaster>())	oFileData = parentFileAs<SlideMaster>().Find(*id_data);
-				else if	(parentFileIs<Theme>())			oFileData = parentFileAs<Theme>().Find(*id_data);
-				else if (pRels != NULL)					oFileData = pRels->Find(*id_data);
+				if		(parentFileIs<OOX::IFileContainer>())	oFileData = parentFileAs<OOX::IFileContainer>().Find(*id_data);
+				else if (pRels != NULL)							oFileData = pRels->Find(*id_data);
 			}
 			
 			if (oFileData.IsInit())
@@ -90,11 +88,8 @@ namespace PPTX
 
 				if (id_drawing.IsInit())
 				{
-					if		(parentFileIs<Slide>())			oFileDrawing = parentFileAs<Slide>().Find(*id_drawing);
-					else if	(parentFileIs<SlideLayout>())	oFileDrawing = parentFileAs<SlideLayout>().Find(*id_drawing);
-					else if	(parentFileIs<SlideMaster>())	oFileDrawing = parentFileAs<SlideMaster>().Find(*id_drawing);
-					else if	(parentFileIs<Theme>())			oFileDrawing = parentFileAs<Theme>().Find(*id_drawing);
-					else if (pRels != NULL)					oFileDrawing = pRels->Find(*id_data);
+					if		(parentFileIs<OOX::IFileContainer>())	oFileDrawing = parentFileAs<OOX::IFileContainer>().Find(*id_drawing);
+					else if (pRels != NULL)							oFileDrawing = pRels->Find(*id_data);
 				}
 				else
 				{
@@ -127,8 +122,7 @@ namespace PPTX
 				m_diag = pDiagramDrawing->m_oShapeTree;
 				FillParentPointersForChilds();
 
-				m_oCommonRels	= smart_ptr<PPTX::CCommonRels>( new PPTX::CCommonRels());
-				m_oCommonRels->_read(pDiagramDrawing->m_oReadPath);
+				m_pFileContainer = smart_ptr<OOX::IFileContainer>(pDiagramDrawing);
 
 				if (!m_diag->grpSpPr.xfrm.IsInit())
 					m_diag->grpSpPr.xfrm = new PPTX::Logic::Xfrm;
@@ -141,43 +135,30 @@ namespace PPTX
 
 		void ChartRec::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
 		{
-			FileContainer* pRels = NULL;
-			if (pWriter->m_pCommonRels->is_init())
-				pRels = pWriter->m_pCommonRels->operator ->();
+			OOX::IFileContainer* pRels = NULL;
+			if (pWriter->m_pCurrentContainer->is_init())
+				pRels = pWriter->m_pCurrentContainer->operator ->();
 
-            std::wstring strDataPath = L"";
+			smart_ptr<OOX::File> file;
 			if(id_data.IsInit())
 			{
-				if(parentFileIs<Slide>())
-					strDataPath = parentFileAs<Slide>().GetMediaFullPathNameFromRId(*id_data);
-				else if(parentFileIs<SlideLayout>())
-					strDataPath = parentFileAs<SlideLayout>().GetMediaFullPathNameFromRId(*id_data);
-				else if(parentFileIs<SlideMaster>())
-					strDataPath = parentFileAs<SlideMaster>().GetMediaFullPathNameFromRId(*id_data);
-				else if(parentFileIs<Theme>())
-					strDataPath = parentFileAs<Theme>().GetMediaFullPathNameFromRId(*id_data);
-				else if (pRels != NULL)
-				{
-					smart_ptr<OOX::Image> p = pRels->GetImage(*id_data);
-					if (p.is_init())
-						strDataPath = p->filename().m_strFilename;
-				}
+				if(parentFileIs<OOX::IFileContainer>())	file = parentFileAs<OOX::IFileContainer>().Find(*id_data);
+				else if (pRels != NULL)					file = pRels->Find(*id_data);
 			}
+			smart_ptr<OOX::Spreadsheet::CChartSpace> pChart = file.smart_dynamic_cast<OOX::Spreadsheet::CChartSpace>();
 
-            if (strDataPath.empty())
+            if (pChart.IsInit() == false)
 				return;
 
-			BinXlsxRW::CXlsxSerializer oXlsxSerializer;
 			NSBinPptxRW::CDrawingConverter oDrawingConverter;
 			NSBinPptxRW::CBinaryFileWriter* pOldWriter = oDrawingConverter.m_pBinaryWriter;
+			
 			oDrawingConverter.m_pBinaryWriter = pWriter;
-			NSCommon::smart_ptr<PPTX::CCommonRels> pOldRels = *oDrawingConverter.m_pBinaryWriter->m_pCommonRels;
+			oDrawingConverter.SetRels(pChart.smart_dynamic_cast<OOX::IFileContainer>());
+		
+			BinXlsxRW::BinaryChartWriter oBinaryChartWriter(*pWriter, &oDrawingConverter);	
+			oBinaryChartWriter.WriteCT_ChartSpace(*pChart);
 
-			oXlsxSerializer.setDrawingConverter(&oDrawingConverter);
-
-			long lDataSize = 0;
-			oXlsxSerializer.loadChart(strDataPath, pWriter, lDataSize);
-			*oDrawingConverter.m_pBinaryWriter->m_pCommonRels = pOldRels;
 			oDrawingConverter.m_pBinaryWriter = pOldWriter;
 		}
 		std::wstring ChartRec::toXML() const

ASCOfficePPTXFile/PPTXFormat/Logic/SmartArt.h

@@ -97,10 +97,12 @@ namespace PPTX
 			{
 				if (m_diag.is_init())
 				{
-					smart_ptr<PPTX::CCommonRels> old = *pWriter->m_pCommonRels;
-					*pWriter->m_pCommonRels = m_oCommonRels;
+					smart_ptr<OOX::IFileContainer> old = *pWriter->m_pCurrentContainer;
+					*pWriter->m_pCurrentContainer = m_pFileContainer;
+					
 					m_diag->toPPTY(pWriter);
-					*pWriter->m_pCommonRels = old;
+					
+					*pWriter->m_pCurrentContainer = old;
 				}
 			}
 
@@ -115,7 +117,7 @@ namespace PPTX
 			nullable<OOX::RId>				id_style;
 
 			nullable<PPTX::Logic::SpTree>	m_diag;
-			smart_ptr<PPTX::CCommonRels>	m_oCommonRels;
+			smart_ptr<OOX::IFileContainer>	m_pFileContainer;
 		protected:
 			virtual void FillParentPointersForChilds()
 			{

ASCOfficePPTXFile/PPTXFormat/Logic/SpTreeElem.cpp

@@ -418,6 +418,8 @@ namespace PPTX
 					smart_ptr<PPTX::Logic::SpTree> oSpTree = m_elem.smart_dynamic_cast<PPTX::Logic::SpTree>();
 					if (oSpTree.IsInit()) oSpTree->toXmlWriterVML(pWriter, oTheme, oClrMap);
 				}break;
+				default:
+					break;
 			}
 		}
 

Common/DocxFormat/Source/DocxFormat/IFileContainer.cpp

@@ -35,12 +35,13 @@
 #include "ContentTypes.h"
 
 #include "FileType.h"
+#include "FileTypes.h"
+
 #include "External/External.h"
 #include "External/HyperLink.h"
 #include "Media/Image.h"
 #include "Media/OleObject.h"
-#include "FileTypes.h"
-
+#include "../../../../ASCOfficePPTXFile/PPTXFormat/LegacyDiagramText.h"
 #include "../XlsxFormat/FileFactory_Spreadsheet.h"
 
 namespace OOX
@@ -252,7 +253,13 @@ namespace OOX
 			return smart_ptr<OleObject>();
 		return pPair->second.smart_dynamic_cast<OleObject>();
 	}
-
+	smart_ptr<PPTX::LegacyDiagramText> IFileContainer::GetLegacyDiagramText(const OOX::RId& rId) const 
+	{
+		std::map<std::wstring, smart_ptr<OOX::File>>::const_iterator pPair = m_mContainer.find(rId.get());
+        if (pPair == m_mContainer.end ())
+			return smart_ptr<PPTX::LegacyDiagramText>();
+		return pPair->second.smart_dynamic_cast<PPTX::LegacyDiagramText>();
+	}
 	const bool IFileContainer::IsExist(const FileType& oType) const
 	{
 		for (std::map<std::wstring, smart_ptr<OOX::File>>::const_iterator it = m_mContainer.begin(); it != m_mContainer.end(); ++it)

Common/DocxFormat/Source/DocxFormat/IFileContainer.h

@@ -48,7 +48,12 @@ namespace OOX
 	class Image;
 	class HyperLink;
 	class OleObject;
-} // OOX
+}
+
+namespace PPTX
+{
+	class LegacyDiagramText;
+}
 
 namespace OOX
 {
@@ -76,9 +81,10 @@ namespace OOX
 		void Read (const OOX::CPath& oRootPath, const OOX::CPath& oPath);
 		void ExtractPictures(const OOX::CPath& oPath) const;
 
-		virtual smart_ptr<Image>     GetImage    (const RId& rId) const;
-		virtual smart_ptr<HyperLink> GetHyperlink(const RId& rId) const;
-		virtual smart_ptr<OleObject> GetOleObject(const RId& rId) const;
+		virtual smart_ptr<Image>					GetImage    (const RId& rId) const;
+		virtual smart_ptr<HyperLink>				GetHyperlink(const RId& rId) const;
+		virtual smart_ptr<OleObject>				GetOleObject(const RId& rId) const;
+		virtual smart_ptr<PPTX::LegacyDiagramText>	GetLegacyDiagramText (const OOX::RId& rId) const;
 		
 		OOX::CRels* GetCurRls()
 		{

X2tConverter/test/batch_convert/x2t_test/mainwindow.cpp

@@ -21,6 +21,8 @@
 
 #include "../../../../DesktopEditor/fontengine/application_generate_fonts.h"
 
+#include <QDateTime>
+
 class CDirectoryParse : public NSThreads::CBaseThread
 {
 public:
@@ -155,11 +157,178 @@ public:
     }
 };
 
+class CFormatLogger
+{
+public:
+    std::wstring m_name;
+    bool m_need;
+
+    std::list<std::wstring> m_greenSrc;
+    std::list<std::wstring> m_greenDst;
+
+    std::list<std::wstring> m_yellowSrc;
+    std::list<std::wstring> m_yellowDsc;
+
+    std::list<std::wstring> m_redSrc;
+    std::list<std::wstring> m_redDst;
+
+public:
+    CFormatLogger(const std::wstring& name)
+    {
+        m_name = name;
+        clear();
+    }
+    ~CFormatLogger()
+    {
+    }
+
+    void clear()
+    {
+        m_greenSrc.clear();
+        m_greenDst.clear();
+
+        m_yellowSrc.clear();
+        m_yellowDsc.clear();
+
+        m_redSrc.clear();
+        m_redDst.clear();
+    }
+
+    void Add(const int& code, const std::wstring& src, const std::wstring& dst)
+    {
+        if (0 == code)
+        {
+            m_greenSrc.push_back(src);
+            m_greenDst.push_back(dst);
+        }
+        else if (89 == code || 90 == code || 91 == code)
+        {
+            m_yellowSrc.push_back(src);
+            m_yellowDsc.push_back(dst);
+        }
+        else
+        {
+            m_redSrc.push_back(src);
+            m_redDst.push_back(dst);
+        }
+    }
+
+    std::wstring GetMainHtml()
+    {
+        if (!m_need)
+            return L"";
+
+        int nCountG = m_greenSrc.size();
+        int nCountY = m_yellowSrc.size();
+        int nCountR = m_redSrc.size();
+
+        int nCount = nCountG + nCountY + nCountR;
+
+        if (0 == nCount)
+            return L"";
+
+        int nPercentY = 100 * nCountY / nCount; if (nCountY != 0 && nPercentY == 0) nPercentY = 1;
+        int nPercentR = 100 * nCountR / nCount; if (nCountR != 0 && nPercentR == 0) nPercentR = 1;
+        int nPercentG = 100 - nPercentY - nPercentR;
+
+
+        NSStringUtils::CStringBuilder oBuilder;
+        oBuilder.WriteString(L"<tr style=\"height:30px;\"><td style=\"width:200px;\">");
+
+        oBuilder.WriteString(m_name);
+        oBuilder.WriteString(L" (");
+        oBuilder.AddInt(nPercentG);
+        oBuilder.WriteString(L":");
+        oBuilder.AddInt(nCountG);
+        oBuilder.WriteString(L" | ");
+        oBuilder.AddInt(nPercentY);
+        oBuilder.WriteString(L":");
+        oBuilder.AddInt(nCountY);
+        oBuilder.WriteString(L" | ");
+        oBuilder.AddInt(nPercentR);
+        oBuilder.WriteString(L":");
+        oBuilder.AddInt(nCountR);
+        oBuilder.WriteString(L")</td><td style=\"width:800px;\">");
+
+        oBuilder.WriteString(L"<div style=\"font-size: 0;width:800px;height:20px;margin:0;padding:0;\">");
+
+        oBuilder.WriteString(L"<div style=\"display:inline-block;margin:0;padding:0;width:");
+        oBuilder.AddInt(nPercentG);
+        oBuilder.WriteString(L"%;height:100%;background:#00FF00;\"></div>");
+
+        oBuilder.WriteString(L"<div style=\"display:inline-block;margin:0;padding:0;width:");
+        oBuilder.AddInt(nPercentY);
+        oBuilder.WriteString(L"%;height:100%;background:#FFFF00;\"></div>");
+
+        oBuilder.WriteString(L"<div style=\"display:inline-block;margin:0;padding:0;width:");
+        oBuilder.AddInt(nPercentR);
+        oBuilder.WriteString(L"%;height:100%;background:#FF0000;\"></div>");
+
+        oBuilder.WriteString(L"</div>");
+
+        oBuilder.WriteString(L"</td></tr>");
+
+        return oBuilder.GetData();
+    }
+
+    std::wstring GetHtml()
+    {
+        if (!m_need)
+            return L"";
+
+        int nCountG = m_greenSrc.size();
+        int nCountY = m_yellowSrc.size();
+        int nCountR = m_redSrc.size();
+
+        int nCount = nCountG + nCountY + nCountR;
+
+        if (0 == nCount)
+            return L"";
+
+        NSStringUtils::CStringBuilder oBuilder;
+        oBuilder.WriteString(L"<table border=\"1\"><caption>");
+        oBuilder.WriteString(m_name);
+        oBuilder.WriteString(L"</caption>");
+
+        std::list<std::wstring>::iterator i, j;
+        for (i = m_greenSrc.begin(), j = m_greenDst.begin(); i != m_greenSrc.end(); i++, j++)
+        {
+            oBuilder.WriteString(L"<tr style=\"height:20px;background:#00FF00;\"><td style=\"width:500px;\">");
+            oBuilder.WriteEncodeXmlString(*i);
+            oBuilder.WriteString(L"</td><td style=\"width:500px;\">");
+            oBuilder.WriteEncodeXmlString(*j);
+            oBuilder.WriteString(L"</td></tr>");
+        }
+        for (i = m_yellowSrc.begin(), j = m_yellowDsc.begin(); i != m_yellowSrc.end(); i++, j++)
+        {
+            oBuilder.WriteString(L"<tr style=\"height:20px;background:#FFFF00;\"><td style=\"width:500px;\">");
+            oBuilder.WriteEncodeXmlString(*i);
+            oBuilder.WriteString(L"</td><td style=\"width:500px;\">");
+            oBuilder.WriteEncodeXmlString(*j);
+            oBuilder.WriteString(L"</td></tr>");
+        }
+        for (i = m_redSrc.begin(), j = m_redDst.begin(); i != m_redSrc.end(); i++, j++)
+        {
+            oBuilder.WriteString(L"<tr style=\"height:20px;background:#FF0000;\"><td style=\"width:500px;\">");
+            oBuilder.WriteEncodeXmlString(*i);
+            oBuilder.WriteString(L"</td><td style=\"width:500px;\">");
+            oBuilder.WriteEncodeXmlString(*j);
+            oBuilder.WriteString(L"</td></tr>");
+        }
+
+        oBuilder.WriteString(L"</table>");
+
+        return oBuilder.GetData();
+    }
+};
+
 class CConverter;
 class CInternalWorker
 {
 public:
     std::map<int, bool> m_formats;
+    std::map<int, CFormatLogger> m_logger;
+
     CDirectoryParse* m_pParser;
 
     int m_dst_format;
@@ -194,6 +363,27 @@ public:
         m_formats.insert(std::make_pair<int, bool>(AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_DJVU, true));
         m_formats.insert(std::make_pair<int, bool>(AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS, true));
 
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX, CFormatLogger(L"DOCX")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC, CFormatLogger(L"DOC")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT, CFormatLogger(L"ODT")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_DOCUMENT_RTF, CFormatLogger(L"RTF")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_DOCUMENT_TXT, CFormatLogger(L"TXT")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_DOCUMENT_HTML, CFormatLogger(L"HTML")));
+
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX, CFormatLogger(L"PPTX")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX, CFormatLogger(L"PPSX")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT, CFormatLogger(L"PPT")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP, CFormatLogger(L"ODP")));
+
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX, CFormatLogger(L"XLSX")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS, CFormatLogger(L"XLS")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS, CFormatLogger(L"ODS")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV, CFormatLogger(L"CSV")));
+
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF, CFormatLogger(L"PDF")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_DJVU, CFormatLogger(L"DJVU")));
+        m_logger.insert(std::make_pair<int, CFormatLogger>(AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS, CFormatLogger(L"XPS")));
+
         m_pParser = new CDirectoryParse();
 
         m_dst_format = 0;
@@ -349,6 +539,71 @@ public:
     void OnConvertFile(CConverter* pConverter, int nCode);
     void Start(int nCores);
     void Cancel();
+
+    void Log()
+    {
+        NSStringUtils::CStringBuilder oBuilder;
+
+        oBuilder.WriteString(L"<!DOCTYPE html>\
+<html style=\"background:#FFFFFF;\">\
+<head></head>\
+<body style=\"width:100%height:100%;\">\
+<table border=\"1\" style=\"height:100%\">\
+<caption>Summary</caption>");
+
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_RTF)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_TXT)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_HTML)->second.GetMainHtml());
+
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP)->second.GetMainHtml());
+
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV)->second.GetMainHtml());
+
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_DJVU)->second.GetMainHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS)->second.GetMainHtml());
+
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_DOCX)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_DOC)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_ODT)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_RTF)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_TXT)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_DOCUMENT_HTML)->second.GetHtml());
+
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPTX)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPSX)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_PRESENTATION_PPT)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_PRESENTATION_ODP)->second.GetHtml());
+
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLSX)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_SPREADSHEET_XLS)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_SPREADSHEET_ODS)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_SPREADSHEET_CSV)->second.GetHtml());
+
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_PDF)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_DJVU)->second.GetHtml());
+        oBuilder.WriteString(m_logger.find(AVS_OFFICESTUDIO_FILE_CROSSPLATFORM_XPS)->second.GetHtml());
+
+        oBuilder.WriteString(L"</table></body></html>");
+
+        std::wstring sTime = QDateTime::currentDateTime().toString().toStdWString();
+        NSCommon::string_replace(sTime, L":", L".");
+
+        std::wstring sDirectory = NSFile::GetProcessDirectory() + L"/report";
+        if (!NSDirectory::Exists(sDirectory))
+            NSDirectory::CreateDirectory(sDirectory);
+
+        NSFile::CFileBinary::SaveToFile(sDirectory + L"/" + sTime + L".html", oBuilder.GetData(), true);
+    }
 };
 
 class CConverter : public NSThreads::CBaseThread
@@ -356,6 +611,8 @@ class CConverter : public NSThreads::CBaseThread
 public:
     CInternalWorker* m_pInternal;
     std::wstring m_file;
+    std::wstring m_file_dst;
+    int m_format;
 
 public:
     CConverter(CInternalWorker* pWorker) : NSThreads::CBaseThread()
@@ -377,10 +634,10 @@ public:
             return 0;
         }
 
-        int nFormat = oChecker.nFileType;
+        m_format = oChecker.nFileType;
 
-        std::map<int, bool>::iterator find = m_pInternal->m_formats.find(nFormat);
-        if (find == m_pInternal->m_formats.end())
+        std::map<int, bool>::iterator find = m_pInternal->m_formats.find(m_format);
+        if ((find == m_pInternal->m_formats.end()) || (find->second == false))
         {
             m_bRunThread = FALSE;
             m_pInternal->OnConvertFile(this, -1);
@@ -416,6 +673,8 @@ public:
 
         std::wstring sFileDst = sDirectoryDst + L"/result" + sExt;
 
+        m_file_dst = sFileDst;
+
         oBuilder.WriteEncodeXmlString(sFileDst);
         oBuilder.WriteString(L"</m_sFileTo><m_nFormatTo>");
         oBuilder.WriteString(std::to_wstring(m_pInternal->m_dst_format));
@@ -592,6 +851,13 @@ void CInternalWorker::OnConvertFile(CConverter* pConverter, int nCode)
 {
     CTemporaryCS oCS(&m_oCS);
 
+    if (-1 != nCode)
+    {
+        std::map<int, CFormatLogger>::iterator _logger = m_logger.find(pConverter->m_format);
+        if (_logger != m_logger.end())
+            _logger->second.Add(nCode, pConverter->m_file, pConverter->m_file_dst);
+    }
+
     ++m_nCurrentConvert;
 
     RELEASEOBJECT(pConverter);
@@ -608,6 +874,12 @@ void CInternalWorker::Start(int nCores)
     if (nSizeInit > m_nCount)
         nSizeInit = m_nCount;
 
+    for (std::map<int, CFormatLogger>::iterator i = m_logger.begin(); i != m_logger.end(); i++)
+    {
+        i->second.clear();
+        i->second.m_need = m_formats.find(i->first)->second;
+    }
+
     for (int i = 0; i < nSizeInit; ++i)
         GetNextConverter();
 }
@@ -845,6 +1117,7 @@ void MainWindow::slot_onFileConverted(int nProgress)
 
     if (nProgress == m_pWorker->m_nCount)
     {
+        m_pWorker->Log();
         ui->pushButtonConvert->setText("CONVERT");
         ui->progressBar->setVisible(false);
     }
@@ -1179,6 +1452,6 @@ void MainWindow::stateChanged_DJVU_ALL(bool)
 {
     bool bIsVal = ui->checkBoxDJVU_ALL->isChecked();
     ui->checkBoxPDF->setChecked(bIsVal);
-    ui->checkBoxXLS->setChecked(bIsVal);
+    ui->checkBoxXPS->setChecked(bIsVal);
     ui->checkBoxDJVU->setChecked(bIsVal);
 }

XlsxSerializerCom/Reader/BinaryWriter.h

@@ -1798,16 +1798,14 @@ namespace BinXlsxRW
 				{
 					OOX::Spreadsheet::CDrawing* pDrawing = (OOX::Spreadsheet::CDrawing*)oFile.operator->();
 					
-                    std::wstring sOldRelsPath = m_pOfficeDrawingConverter->GetRelsPath();
-                    std::wstring sDrawingRelsPath = pDrawing->GetReadPath().GetPath();
-					
-					m_pOfficeDrawingConverter->SetRelsPath(sDrawingRelsPath);
+					smart_ptr<OOX::IFileContainer> oldRels = m_pOfficeDrawingConverter->GetRels();
+					m_pOfficeDrawingConverter->SetRels(pDrawing);
 					
 					nCurPos = m_oBcw.WriteItemStart(c_oSerWorksheetsTypes::Drawings);
-					WriteDrawings(oWorksheet, pDrawing, sDrawingRelsPath, currentVmlDrawing);
+					WriteDrawings(oWorksheet, pDrawing, currentVmlDrawing);
 					m_oBcw.WriteItemWithLengthEnd(nCurPos);
 
-					m_pOfficeDrawingConverter->SetRelsPath(sOldRelsPath);
+					m_pOfficeDrawingConverter->SetRels(oldRels);
 				}
 			}
 			//Autofilter
@@ -2600,7 +2598,7 @@ namespace BinXlsxRW
 			}
 		};
 
-        void WriteDrawings(const OOX::Spreadsheet::CWorksheet& oWorksheet, OOX::Spreadsheet::CDrawing* pDrawing, std::wstring& sDrawingRelsPath, OOX::CVmlDrawing *pVmlDrawing = NULL)
+        void WriteDrawings(const OOX::Spreadsheet::CWorksheet& oWorksheet, OOX::Spreadsheet::CDrawing* pDrawing, OOX::CVmlDrawing *pVmlDrawing = NULL)
 		{
 			for (size_t i = 0, length = pDrawing->m_arrItems.size(); i  < length ; ++i)
 			{
@@ -2611,7 +2609,7 @@ namespace BinXlsxRW
 				if (!pCellAnchor->m_bShapeOle && pCellAnchor->isValid())
 				{
 					int nCurPos = m_oBcw.WriteItemStart(c_oSerWorksheetsTypes::Drawing);
-					WriteDrawing(oWorksheet, pDrawing, pCellAnchor, sDrawingRelsPath, pVmlDrawing);
+					WriteDrawing(oWorksheet, pDrawing, pCellAnchor, pVmlDrawing);
 					m_oBcw.WriteItemEnd(nCurPos);
 				}
 			}
@@ -2727,7 +2725,7 @@ namespace BinXlsxRW
 					if (pCellAnchor)
 					{
 						int nCurPos = m_oBcw.WriteItemStart(c_oSerWorksheetsTypes::Drawing);
-						WriteDrawing(oWorksheet, pDrawing, pCellAnchor, sDrawingRelsPath, pVmlDrawing, pOleObject);
+						WriteDrawing(oWorksheet, pDrawing, pCellAnchor, pVmlDrawing, pOleObject);
 						m_oBcw.WriteItemEnd(nCurPos);
 						
 						delete pCellAnchor;
@@ -2764,7 +2762,7 @@ namespace BinXlsxRW
 										pCellAnchor->m_sSpId->append(it->first);
 
 										int nCurPos = m_oBcw.WriteItemStart(c_oSerWorksheetsTypes::Drawing);
-										WriteDrawing(oWorksheet, pDrawing, pCellAnchor, sDrawingRelsPath, pVmlDrawing, NULL);
+										WriteDrawing(oWorksheet, pDrawing, pCellAnchor, pVmlDrawing, NULL);
 										m_oBcw.WriteItemEnd(nCurPos);
 										
 										delete pCellAnchor;
@@ -2776,7 +2774,7 @@ namespace BinXlsxRW
 				}
 			}
 		}
-        void WriteDrawing(const OOX::Spreadsheet::CWorksheet& oWorksheet, OOX::Spreadsheet::CDrawing* pDrawing, OOX::Spreadsheet::CCellAnchor* pCellAnchor, std::wstring& sDrawingRelsPath, OOX::CVmlDrawing *pVmlDrawing = NULL, OOX::Spreadsheet::COleObject* pOleObject = NULL)
+        void WriteDrawing(const OOX::Spreadsheet::CWorksheet& oWorksheet, OOX::Spreadsheet::CDrawing* pDrawing, OOX::Spreadsheet::CCellAnchor* pCellAnchor, OOX::CVmlDrawing *pVmlDrawing = NULL, OOX::Spreadsheet::COleObject* pOleObject = NULL)
 		{
 			if (!pCellAnchor) return;
 
@@ -2839,17 +2837,19 @@ namespace BinXlsxRW
 					}
 					sVmlXml += L"</v:object>";
 
-                    std::wstring keepRels = m_pOfficeDrawingConverter->GetRelsPath();
-					m_pOfficeDrawingConverter->SetRelsPath(pVmlDrawing->GetReadPath().GetPath());
+                    smart_ptr<OOX::IFileContainer> oldRels = m_pOfficeDrawingConverter->GetRels();
+					m_pOfficeDrawingConverter->SetRels(pVmlDrawing);
 
 					std::wstring* bstrOutputXml = NULL;
 					m_oBcw.m_oStream.WriteBYTE(c_oSer_DrawingType::pptxDrawing);
 					int nCurPos = m_oBcw.WriteItemWithLengthStart();
-					m_pOfficeDrawingConverter->AddObject(sVmlXml, &bstrOutputXml);
-					m_oBcw.WriteItemWithLengthEnd(nCurPos);
 					
+					m_pOfficeDrawingConverter->AddObject(sVmlXml, &bstrOutputXml);
+					
+					m_pOfficeDrawingConverter->SetRels(oldRels);
+
+					m_oBcw.WriteItemWithLengthEnd(nCurPos);					
 					RELEASEOBJECT(bstrOutputXml);
-					m_pOfficeDrawingConverter->SetRelsPath(keepRels);
 				}
 			}
 			else if (pCellAnchor->m_oElement.IsInit())
@@ -2857,10 +2857,16 @@ namespace BinXlsxRW
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_DrawingType::pptxDrawing);
 				int nCurPos = m_oBcw.WriteItemWithLengthStart();
 
+				smart_ptr<OOX::IFileContainer> oldRels = *m_oBcw.m_oStream.m_pCurrentContainer;
+				*m_oBcw.m_oStream.m_pCurrentContainer = pDrawing;
+				m_oBcw.m_oStream.m_pCurrentContainer->AddRef();
+
 				m_oBcw.m_oStream.StartRecord(0);
 				m_oBcw.m_oStream.WriteRecord2(1, pCellAnchor->m_oElement->GetElem());
 				m_oBcw.m_oStream.EndRecord();
 
+				*m_oBcw.m_oStream.m_pCurrentContainer = oldRels;
+
 				m_oBcw.WriteItemWithLengthEnd(nCurPos);
 			}
 		}
@@ -3419,6 +3425,8 @@ namespace BinXlsxRW
 					WriteIconSet(*pIconSet);
 					m_oBcw.WriteItemEnd(nCurPos);
 					break;
+				default:
+					break;
 				}
 			}
 		}