Merge branch hotfix/v6.0.1 into master

Fix typo

.gitignore

@@ -3,6 +3,7 @@ dictionaries/
 LicenceManager/
 Common/boost_1_58_0
 Common/3dParty/boost/boost_1_58_0
+Common/3dParty/boost/boost.data
 Common/3dParty/boost/ios
 Common/3dParty/boost/osx
 Common/3dParty/icu/icu

ASCOfficeDocFile/DocDocxConverter/DocumentMapping.cpp

@@ -1344,7 +1344,7 @@ namespace DocFileFormat
 	{
 		ParagraphPropertyExceptions* backup = _lastValidPapx;
 
-		std::map<short, short> boundaries;
+		std::map<short, short> mapBoundaries;
 		
 		int cp = initialCp;
 		int fc = m_document->FindFileCharPos( cp );
@@ -1388,7 +1388,8 @@ namespace DocFileFormat
 			}
 			if (nestingLevel == iTap_current)
 			{
-				for ( std::list<SinglePropertyModifier>::iterator iter = papx->grpprl->begin(); iter != papx->grpprl->end(); iter++ )
+				bool bPresent = false; //118854.doc
+				for ( std::list<SinglePropertyModifier>::reverse_iterator iter = papx->grpprl->rbegin(); !bPresent && iter != papx->grpprl->rend(); iter++ )
 				{
 					//find the tDef SPRM
 					DWORD code = iter->OpCode;
@@ -1406,19 +1407,27 @@ namespace DocFileFormat
 								boundary1 = FormatUtils::BytesToInt16( iter->Arguments + 1, i * 2 , iter->argumentsSize );
 								boundary2 = FormatUtils::BytesToInt16( iter->Arguments + 1, ( i + 1 ) * 2, iter->argumentsSize );
 
-								AddBoundary(boundary1, boundary2, boundaries);
+								//if (boundary1 < 0) boundary1 = 0;
+								//if (boundary2 < 0) boundary2 = 0;
+
+								mapBoundaries.insert(std::make_pair(boundary1, 0));
+								mapBoundaries.insert(std::make_pair(boundary2, 0));
+								//AddBoundary(boundary1, boundary2, mapBoundaries);
 							}
 							if (max_boundary < boundary2)
 								max_boundary = boundary2;
 
-							AddBoundary(boundary2, max_boundary, boundaries);
+							mapBoundaries.insert(std::make_pair(boundary2, 0));
+							mapBoundaries.insert(std::make_pair(max_boundary, 0));
+							//AddBoundary(boundary2, max_boundary, mapBoundaries);
+							bPresent = true;
 						}break;
 						default:
 							break;
 					}
 				}
 			}
-			if (nestingLevel != iTap_current && fEndNestingLevel && !boundaries.empty())
+			if (nestingLevel != iTap_current && fEndNestingLevel && !mapBoundaries.empty())
 				break;
 			//get the next papx
 			papx = findValidPapx( fcRowEnd );
@@ -1431,11 +1440,16 @@ namespace DocFileFormat
 
 		}
 
-		if ( !boundaries.empty() )
+		if ( !mapBoundaries.empty() )
 		{
-			for ( std::map<short, short>::iterator it = boundaries.begin(); it != boundaries.end(); ++it)
+			std::map<short, short>::iterator it = mapBoundaries.begin(); 
+			std::map<short, short>::iterator it_next = it; it_next++;
+
+			for ( ; it_next != mapBoundaries.end(); ++it_next, ++it)
 			{
-				grid.push_back( it->second );
+				int sz = it_next->first - it->first;
+				if (sz > 2)
+					grid.push_back( it_next->first - it->first );
 			}
 		}
 		_lastValidPapx = backup;

ASCOfficeDocFile/DocDocxConverter/StringTable.h

@@ -77,13 +77,13 @@ namespace DocFileFormat
 		}
 
 		StringTable( VirtualStreamReader *reader, int code_page_ ): 
-                            code_page(code_page_), fExtend(false), cbData(0), cbExtra(0), DataExtra(NULL)
+                            code_page(code_page_), fExtend(false), cbData(0), cbExtra(0)
 		{
             parse( reader, (unsigned int)reader->GetPosition(), 0, false );
 		}
 
 		StringTable( POLE::Stream* tableStream, unsigned int fc, unsigned int lcb, int nWordVersion, bool bReadExta = false) :
-												code_page(1250), fExtend(false), cbData(0), cbExtra(0), DataExtra(NULL)
+												code_page(1250), fExtend(false), cbData(0), cbExtra(0)
 		{
 			if ( lcb > 0 )
 			{

ASCOfficeDocFile/DocDocxConverter/TableCellPropertiesMapping.cpp

@@ -96,94 +96,100 @@ namespace DocFileFormat
 					break;
 			}
 		}
-		std::list<SinglePropertyModifier>::const_reverse_iterator rend = tapx->grpprl->rend();
 
-		for (std::list<SinglePropertyModifier>::const_reverse_iterator iter = tapx->grpprl->rbegin(); iter != rend; ++iter)
+
+		bool bPresentDefTable = false;
+		for (std::list<SinglePropertyModifier>::reverse_iterator iter = tapx->grpprl->rbegin(); iter != tapx->grpprl->rend(); ++iter)
 		{
 			switch (iter->OpCode)
 			{				
 				case sprmOldTDefTable:	
 				case sprmTDefTable:	
 				{
-					SprmTDefTable tdef(iter->Arguments, iter->argumentsSize);
-					int cc = tdef.numberOfColumns;
-
-					_tGrid = tdef.rgdxaCenter;
-                    _tcDef = tdef.rgTc80[(std::min)(_cellIndex,  (int)tdef.rgTc80.size() - 1)];	
-
-                    appendValueElement( _tcPr, L"textDirection", FormatUtils::MapValueToWideString( _tcDef.textFlow, &Global::TextFlowMap[0][0], 6, 6 ), false );
-
-					if ( _tcDef.vertMerge == Global::fvmMerge )
+					if (!bPresentDefTable) //118854.doc
 					{
-                        appendValueElement( _tcPr, L"vMerge", L"continue", false );
-					}
-					else if ( _tcDef.vertMerge == Global::fvmRestart )
-					{
-                        appendValueElement( _tcPr, L"vMerge", L"restart", false );
-					}
+						bPresentDefTable = true;
 
-                    appendValueElement( _tcPr, L"vAlign", FormatUtils::MapValueToWideString( _tcDef.vertAlign, &Global::VerticalAlignMap[0][0], 3, 7 ), false );
+						SprmTDefTable tdef(iter->Arguments, iter->argumentsSize);
+						int cc = tdef.numberOfColumns;
 
-					if ( _tcDef.fFitText )
-					{
-                        appendValueElement( _tcPr, L"tcFitText", L"", false );
-					}
+						_tGrid = tdef.rgdxaCenter;
+						_tcDef = tdef.rgTc80[(std::min)(_cellIndex,  (int)tdef.rgTc80.size() - 1)];	
 
-					if ( _tcDef.fNoWrap )
-					{
-                        appendValueElement( _tcPr, L"noWrap", L"", true );
-					}
-					//int ind = (std::min)(_cellIndex,  (int)tdef.rgTc80.size() - 1);
-					//int ind1 = ind; 
-					//while (ind1 < tdef.rgdxaCenter.size() - 1)
-					//{
-					//	int sz = tdef.rgdxaCenter[ ind1 + 1] - tdef.rgdxaCenter[ ind1 ] ;
-					//	if (sz > 1)
-					//		break;
-					//	ind1++;
-					//}
+						appendValueElement( _tcPr, L"textDirection", FormatUtils::MapValueToWideString( _tcDef.textFlow, &Global::TextFlowMap[0][0], 6, 6 ), false );
 
-					if (tdef.rgTc80[_cellIndex].horzMerge == 1)
-					{
-						for (size_t i = _cellIndex; i < tdef.rgTc80.size(); i++)
+						if ( _tcDef.vertMerge == Global::fvmMerge )
 						{
-							if (tdef.rgTc80[i].horzMerge < 1)
-								break;
-						
-							nComputedCellWidth += tdef.rgdxaCenter[ i + 1] - tdef.rgdxaCenter[ i ] ;
-							_gridSpan++;
+							appendValueElement( _tcPr, L"vMerge", L"continue", false );
+						}
+						else if ( _tcDef.vertMerge == Global::fvmRestart )
+						{
+							appendValueElement( _tcPr, L"vMerge", L"restart", false );
 						}
-					}
-					else if (tdef.rgTc80[_cellIndex].horzMerge == 2)
-					{//skip cover cell
-						_gridSpan = 1;
-						nComputedCellWidth = 0;
-						_bCoverCell = true;
 
-					}
-					else
-					{
-						_gridSpan = 1;
+						appendValueElement( _tcPr, L"vAlign", FormatUtils::MapValueToWideString( _tcDef.vertAlign, &Global::VerticalAlignMap[0][0], 3, 7 ), false );
 
-						nComputedCellWidths +=  (tdef.rgdxaCenter[ _cellIndex + 1] - tdef.rgdxaCenter[ 0 ]);
-						nComputedCellWidth	+= tdef.rgTc80[ _cellIndex].wWidth > 1 ? tdef.rgTc80[ _cellIndex].wWidth : (tdef.rgdxaCenter[ _cellIndex + 1] - tdef.rgdxaCenter[ _cellIndex ]);
-						//Технические_Требования_1_287_ДИТ.DOC
+						if ( _tcDef.fFitText )
+						{
+							appendValueElement( _tcPr, L"tcFitText", L"", false );
+						}
 
-					}
+						if ( _tcDef.fNoWrap )
+						{
+							appendValueElement( _tcPr, L"noWrap", L"", true );
+						}
+						//int ind = (std::min)(_cellIndex,  (int)tdef.rgTc80.size() - 1);
+						//int ind1 = ind; 
+						//while (ind1 < tdef.rgdxaCenter.size() - 1)
+						//{
+						//	int sz = tdef.rgdxaCenter[ ind1 + 1] - tdef.rgdxaCenter[ ind1 ] ;
+						//	if (sz > 1)
+						//		break;
+						//	ind1++;
+						//}
 
-					if (!IsTableBordersDefined(tapx->grpprl))
-					{
-						RELEASEOBJECT(_brcTop);
-						_brcTop = new BorderCode(*_tcDef.brcTop);
+						if (tdef.rgTc80[_cellIndex].horzMerge == 1)
+						{
+							for (size_t i = _cellIndex; i < tdef.rgTc80.size(); i++)
+							{
+								if (tdef.rgTc80[i].horzMerge < 1)
+									break;
+							
+								nComputedCellWidth += tdef.rgdxaCenter[ i + 1] - tdef.rgdxaCenter[ i ] ;
+								_gridSpan++;
+							}
+						}
+						else if (tdef.rgTc80[_cellIndex].horzMerge == 2)
+						{//skip cover cell
+							_gridSpan = 1;
+							nComputedCellWidth = 0;
+							_bCoverCell = true;
 
-						RELEASEOBJECT(_brcLeft);
-						_brcLeft = new BorderCode(*_tcDef.brcLeft);
+						}
+						else
+						{
+							_gridSpan = 1;
 
-						RELEASEOBJECT(_brcRight);
-						_brcRight = new BorderCode(*_tcDef.brcRight);
+							nComputedCellWidths +=  (tdef.rgdxaCenter[ _cellIndex + 1] - tdef.rgdxaCenter[ 0 ]);
+							nComputedCellWidth	+= tdef.rgTc80[ _cellIndex].wWidth > 1 ? tdef.rgTc80[ _cellIndex].wWidth : (tdef.rgdxaCenter[ _cellIndex + 1] - tdef.rgdxaCenter[ _cellIndex ]);
+							//Технические_Требования_1_287_ДИТ.DOC
 
-						RELEASEOBJECT(_brcBottom);
-						_brcBottom = new BorderCode(*_tcDef.brcBottom);
+						}
+
+						if (!IsTableBordersDefined(tapx->grpprl))
+						{
+							RELEASEOBJECT(_brcTop);
+							_brcTop = new BorderCode(*_tcDef.brcTop);
+
+							RELEASEOBJECT(_brcLeft);
+							_brcLeft = new BorderCode(*_tcDef.brcLeft);
+
+							RELEASEOBJECT(_brcRight);
+							_brcRight = new BorderCode(*_tcDef.brcRight);
+
+							RELEASEOBJECT(_brcBottom);
+							_brcBottom = new BorderCode(*_tcDef.brcBottom);
+						}
 					}
 				}
 				break;

ASCOfficeDocFile/DocDocxConverter/TableMapping.cpp

@@ -225,8 +225,11 @@ namespace DocFileFormat
 											documentMapping->m_document->nWordVersion);
 			
 			std::list<CharacterPropertyExceptions*>* chpxs = documentMapping->m_document->GetCharacterPropertyExceptions( fcRowEnd, fcRowEnd + 1 );
-			TableRowPropertiesMapping trpMapping( documentMapping->GetXMLWriter(), *(chpxs->begin()) );
-			tapx.Convert( &trpMapping );
+			if (chpxs)
+			{
+				TableRowPropertiesMapping trpMapping( documentMapping->GetXMLWriter(), *(chpxs->begin()) );
+				tapx.Convert( &trpMapping );
+			}
 
 			documentMapping->_lastValidPapx = papxBackup;
 			documentMapping->_lastValidSepx = sepxBackup;

ASCOfficeDocFile/DocDocxConverter/VMLShapeMapping.cpp

@@ -1116,7 +1116,14 @@ namespace DocFileFormat
 
 			m_context->_doc->Convert(&textboxMapping);
 
-			m_pXmlWriter->WriteString(textboxMapping.getOLEObject());
+			std::wstring sOleXml = textboxMapping.getOLEObject();
+			
+			if (false == sOleXml.empty())
+				m_pXmlWriter->WriteString(sOleXml);
+			else
+			{
+				m_pXmlWriter->WriteString(txtBoxWrapper.GetXmlString());
+			}
 		}
 
 //ShapeType 
@@ -1792,6 +1799,9 @@ namespace DocFileFormat
 				if (dAngle < -360.0)
 					dAngle += 360.0;
 
+				if (dAngle > 360.0)
+					dAngle -= 360.0;
+
 				if ((dAngle >= 45.0 && dAngle <= 135.0) || (dAngle >= 225.0 && dAngle <= 315.0) || (dAngle <= -45.0 && dAngle >= -135.0) || (dAngle <= -225.0 && dAngle >= -315.0))
 					twistDimensions	=	true;
 			}

ASCOfficeDocFile/DocFormatTest/DocFormatTest.vcproj

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="windows-1251"?>
 <VisualStudioProject
 	ProjectType="Visual C++"
-	Version="8,00"
+	Version="8.00"
 	Name="DocFormatTest"
 	ProjectGUID="{0F49D5D1-A8D3-4F97-8BC1-E2F65BB00C10}"
 	RootNamespace="PptFormatTest"
@@ -397,6 +397,10 @@
 					/>
 				</FileConfiguration>
 			</File>
+			<File
+				RelativePath="..\..\ASCOfficeDocxFile2\BinReader\FileWriter.cpp"
+				>
+			</File>
 			<File
 				RelativePath="..\..\ASCOfficeDocxFile2\DocWrapper\FontProcessor.cpp"
 				>

ASCOfficeDocxFile2/BinReader/CommentsWriter.h

@@ -29,10 +29,9 @@
  * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
  *
  */
-#ifndef COMMENTS_WRITER
-#define COMMENTS_WRITER
+#pragma once
 
-#include "../../XlsxSerializerCom/Common/Common.h"
+#include "HeaderFooterWriter.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/FileTypes.h"
 
 namespace Writers
@@ -49,8 +48,9 @@ namespace Writers
 	class CommentsWriter
 	{
         std::wstring	m_sDir;
+		std::wstring	m_sFileName;
 	public:
-        std::wstring	m_sComment;
+		std::wstring	m_sComment;
         std::wstring	m_sCommentExt;
 		std::wstring	m_sCommentsIds;
         std::wstring	m_sPeople;
@@ -73,6 +73,10 @@ namespace Writers
 			m_sDocumentCommentsIds	= sDocumentCommentsIds;
 			m_sDocumentPeople		= sDocumentPeople;
 		}
+		std::wstring getFilename()
+		{
+			return OOX::FileTypes::Comments.DefaultFileName().GetPath();
+		}
 		void Write()
 		{
 			std::wstring sDir = m_sDir + FILE_SEPARATOR_STR + _T("word") + FILE_SEPARATOR_STR;
@@ -156,5 +160,4 @@ namespace Writers
 
 		}
 	};
-}
-#endif	// #ifndef COMMENTS_WRITER
+}

ASCOfficeDocxFile2/BinReader/FileWriter.cpp

@@ -0,0 +1,91 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2019
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at 20A-12 Ernesta Birznieka-Upisha
+ * street, Riga, Latvia, EU, LV-1050.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+
+#include "FileWriter.h"
+
+#include "ReaderClasses.h"
+#include "../../Common/DocxFormat/Source/DocxFormat/Core.h"
+#include "../../Common/DocxFormat/Source/DocxFormat/App.h"
+
+namespace Writers
+{
+
+FileWriter::FileWriter(std::wstring sDirOutput,std::wstring sFontDir, bool bNoFontDir, int nVersion, bool bSaveChartAsImg, NSBinPptxRW::CDrawingConverter* pDrawingConverter, std::wstring sThemePath)
+    :
+      m_oFontTableWriter		(sDirOutput, sFontDir, bNoFontDir),
+      m_oDocumentWriter         (sDirOutput, m_oHeaderFooterWriter),
+      m_oMediaWriter			(sDirOutput),
+      m_oStylesWriter			(sDirOutput, nVersion),
+      m_oNumberingWriter		(sDirOutput),
+      m_oHeaderFooterWriter     (sDirOutput),
+      m_oFootnotesWriter		(sDirOutput),
+      m_oEndnotesWriter         (sDirOutput),
+      m_oSettingWriter          (sDirOutput, m_oHeaderFooterWriter),
+      m_oCommentsWriter         (sDirOutput),
+      m_oChartWriter			(sDirOutput),
+      m_oDocumentRelsWriter     (sDirOutput),
+      m_oWebSettingsWriter      (sDirOutput),
+      m_oCustomXmlWriter		(sDirOutput, pDrawingConverter),
+      m_pDrawingConverter       (pDrawingConverter),
+      m_bSaveChartAsImg         (bSaveChartAsImg),
+      m_sThemePath              (sThemePath),
+      m_nDocPrIndex             (0),
+      m_pComments               (NULL),
+      m_pApp					(NULL),
+      m_pCore					(NULL)
+{
+}
+FileWriter::~FileWriter()
+{
+    RELEASEOBJECT(m_pApp);
+    RELEASEOBJECT(m_pCore);
+}
+void FileWriter::Write()
+{
+    m_oCommentsWriter.Write();
+    m_oChartWriter.Write();
+    m_oStylesWriter.Write();
+    m_oNumberingWriter.Write();
+    m_oFontTableWriter.Write();
+    m_oHeaderFooterWriter.Write();
+    m_oFootnotesWriter.Write();
+    m_oEndnotesWriter.Write();
+    //Setting пишем после HeaderFooter, чтобы заполнить evenAndOddHeaders
+    m_oSettingWriter.Write();
+    m_oWebSettingsWriter.Write();
+    //Document пишем после HeaderFooter, чтобы заполнить sectPr
+    m_oDocumentWriter.Write();
+    //Rels и ContentTypes пишем в конце
+    m_oDocumentRelsWriter.Write();
+}
+}
+

ASCOfficeDocxFile2/BinReader/FileWriter.h

@@ -29,8 +29,7 @@
  * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
  *
  */
-#ifndef FILE_WRITER
-#define FILE_WRITER
+#pragma once
 
 #include "../../DesktopEditor/common/Path.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/Media/VbaProject.h"
@@ -95,57 +94,15 @@ namespace Writers
 		OOX::CApp*						m_pApp;
 		OOX::CCore*						m_pCore;
 
-		FileWriter (std::wstring sDirOutput,std::wstring sFontDir, bool bNoFontDir, int nVersion, bool bSaveChartAsImg, NSBinPptxRW::CDrawingConverter* pDrawingConverter, std::wstring sThemePath)
-									:	m_pDrawingConverter(pDrawingConverter), m_sThemePath(sThemePath), m_bSaveChartAsImg(bSaveChartAsImg),
-										m_oFontTableWriter		(sDirOutput, sFontDir, bNoFontDir),
-										m_oHeaderFooterWriter	(sDirOutput),
-										m_oFootnotesWriter		(sDirOutput),
-										m_oEndnotesWriter		(sDirOutput),
-										m_oMediaWriter			(sDirOutput),
-										m_oStylesWriter			(sDirOutput, nVersion),
-										m_oNumberingWriter		(sDirOutput),
-										m_oDocumentWriter		(sDirOutput, m_oHeaderFooterWriter),
-										m_oSettingWriter		(sDirOutput, m_oHeaderFooterWriter),
-										m_oCommentsWriter		(sDirOutput),
-										m_oChartWriter			(sDirOutput),
-										m_oDocumentRelsWriter	(sDirOutput),
-										m_oWebSettingsWriter	(sDirOutput),
-										m_nDocPrIndex(0),
-										m_pComments(NULL),
-										m_oCustomXmlWriter		(sDirOutput, pDrawingConverter),
-										m_pApp					(NULL),
-										m_pCore					(NULL)
-		{
-		}
-		~FileWriter()
-		{
-			RELEASEOBJECT(m_pApp);
-			RELEASEOBJECT(m_pCore);
-		}
+        FileWriter (std::wstring sDirOutput,std::wstring sFontDir, bool bNoFontDir, int nVersion, bool bSaveChartAsImg, NSBinPptxRW::CDrawingConverter* pDrawingConverter, std::wstring sThemePath);
+
+        ~FileWriter();
 		int getNextDocPr()
 		{
 			m_nDocPrIndex++;
 			return m_nDocPrIndex;
 		}
 
-		void Write()
-		{
-			m_oCommentsWriter.Write();
-			m_oChartWriter.Write();
-			m_oStylesWriter.Write();
-			m_oNumberingWriter.Write();
-			m_oFontTableWriter.Write();
-			m_oHeaderFooterWriter.Write();
-			m_oFootnotesWriter.Write();
-			m_oEndnotesWriter.Write();
-	//Setting пишем после HeaderFooter, чтобы заполнить evenAndOddHeaders
-			m_oSettingWriter.Write();
-			m_oWebSettingsWriter.Write();
-	//Document пишем после HeaderFooter, чтобы заполнить sectPr
-			m_oDocumentWriter.Write();
-	//Rels и ContentTypes пишем в конце
-			m_oDocumentRelsWriter.Write();
-		}
+        void Write();
 	};
 }
-#endif	// #ifndef FILE_WRITER

ASCOfficeDocxFile2/BinReader/HeaderFooterWriter.h

@@ -29,8 +29,7 @@
  * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
  *
  */
-#ifndef HEADER_FOOTER_WRITER
-#define HEADER_FOOTER_WRITER
+#pragma once
 
 #include "../../XlsxSerializerCom/Common/Common.h"
 #include "../../Common/DocxFormat/Source/Common/SimpleTypes_Word.h"
@@ -60,8 +59,8 @@ namespace Writers
         std::wstring			rId;
 		SimpleTypes::EHdrFtr	eType;
 	};
-    static  std::wstring g_string_hdr_Start = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
-<w:hdr xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" \
+static  std::wstring g_string_xml_start = L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>";
+static  std::wstring g_string_xmlns = L"xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" \
 xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
 xmlns:o=\"urn:schemas-microsoft-com:office:office\" \
 xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" \
@@ -78,35 +77,19 @@ xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" \
 xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" \
 xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" \
 xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" \
-mc:Ignorable=\"w14 w15 wp14\">");
-    static  std::wstring g_string_hdr_End = _T("</w:hdr>");
+mc:Ignorable=\"w14 w15 wp14\">";
+   
+	static  std::wstring g_string_hdr_Start = g_string_xml_start + L"<w:hdr " + g_string_xmlns;
+    static  std::wstring g_string_hdr_End = L"</w:hdr>";
 
-    static  std::wstring g_string_ftr_Start = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
-<w:ftr xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" \
-xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" \
-xmlns:o=\"urn:schemas-microsoft-com:office:office\" \
-xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" \
-xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" \
-xmlns:v=\"urn:schemas-microsoft-com:vml\" \
-xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" \
-xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" \
-xmlns:w10=\"urn:schemas-microsoft-com:office:word\" \
-xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" \
-xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" \
-xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" \
-xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" \
-xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" \
-xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" \
-xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" \
-xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" \
-mc:Ignorable=\"w14 w15 wp14\">");
-    static  std::wstring g_string_ftr_End = _T("</w:ftr>");
+    static  std::wstring g_string_ftr_Start = g_string_xml_start + L"<w:ftr " + g_string_xmlns;
+    static  std::wstring g_string_ftr_End = L"</w:ftr>";
 
-	static  std::wstring g_string_footnotes_Start = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><w:footnotes xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" mc:Ignorable=\"w14 w15 wp14\">");
-    static  std::wstring g_string_footnotes_End = _T("</w:footnotes>");
+	static  std::wstring g_string_footnotes_Start = g_string_xml_start + L"<w:footnotes " + g_string_xmlns;
+	static  std::wstring g_string_footnotes_End = L"</w:footnotes>";
 
-	static  std::wstring g_string_endnotes_Start = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><w:endnotes xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" mc:Ignorable=\"w14 w15 wp14\">");
-    static  std::wstring g_string_endnotes_End = _T("</w:endnotes>");
+	static  std::wstring g_string_endnotes_Start = g_string_xml_start + L"<w:endnotes " + g_string_xmlns;
+    static  std::wstring g_string_endnotes_End = L"</w:endnotes>";
 
 	class HeaderFooterWriter 
 	{
@@ -133,17 +116,17 @@ mc:Ignorable=\"w14 w15 wp14\">");
 			for(size_t i = 0, length = m_aHeaders.size(); i < length; ++i)
 			{
 				HdrFtrItem* pHeader = m_aHeaders[i];
-				WriteItem(_T("header"), pHeader->m_sFilename, pHeader->Header, true);
+				WriteItem(L"header", pHeader->m_sFilename, pHeader->Header, true);
 			}
 			for(size_t i = 0, length = m_aFooters.size(); i < length; ++i)
 			{
 				HdrFtrItem* pFooter = m_aFooters[i];
-				WriteItem(_T("footer"), pFooter->m_sFilename, pFooter->Header, false);
+				WriteItem(L"footer", pFooter->m_sFilename, pFooter->Header, false);
 			}
 		}
         void WriteItem( std::wstring sHeader,  std::wstring& sFilename, ContentWriter& m_oWriter, bool bHeader)
 		{
-            OOX::CPath filePath = m_sDir + FILE_SEPARATOR_STR +_T("word") + FILE_SEPARATOR_STR + sFilename;
+            OOX::CPath filePath = m_sDir + FILE_SEPARATOR_STR + L"word" + FILE_SEPARATOR_STR + sFilename;
 
 			NSFile::CFileBinary oFile;
 			oFile.CreateFileW(filePath.GetPath());
@@ -186,7 +169,7 @@ mc:Ignorable=\"w14 w15 wp14\">");
 		}
 		std::wstring getFilename()
 		{
-			return _T("footnotes.xml");
+			return L"footnotes.xml";
 		}
 		bool IsEmpty()
 		{
@@ -208,7 +191,7 @@ mc:Ignorable=\"w14 w15 wp14\">");
 
 			std::wstring sFilename = getFilename();
 
-             std::wstring filePath = m_sDir + FILE_SEPARATOR_STR +_T("word") + FILE_SEPARATOR_STR + sFilename;
+             std::wstring filePath = m_sDir + FILE_SEPARATOR_STR + L"word" + FILE_SEPARATOR_STR + sFilename;
 
 			NSFile::CFileBinary oFile;
 			oFile.CreateFileW(filePath);
@@ -219,7 +202,7 @@ mc:Ignorable=\"w14 w15 wp14\">");
 		}
 		std::wstring getFilename()
 		{
-			return _T("endnotes.xml");
+			return L"endnotes.xml";
 		}
 		bool IsEmpty()
 		{
@@ -227,4 +210,3 @@ mc:Ignorable=\"w14 w15 wp14\">");
 		}
 	};
 }
-#endif	// #ifndef HEADER_FOOTER_WRITER

ASCOfficeDocxFile2/BinReader/ReaderClasses.h

@@ -31,8 +31,7 @@
  */
 #pragma once
 
-#ifndef READER_CLASSES
-#define READER_CLASSES
+#include "HeaderFooterWriter.h"
 
 #include "../../Common/DocxFormat/Source/XML/Utils.h"
 #include "../../Common/DocxFormat/Source/Common/SimpleTypes_Word.h"
@@ -731,12 +730,12 @@ public:
 		{
             pCStringWriter->WriteString(L"<w:sz w:val=\"" + std::to_wstring(FontSize) + L"\"/>");
 		}
-        if(bFontSizeCs)
-        {
-            if(false == bFontSize)
-                pCStringWriter->WriteString(L"<w:sz w:val=\"" + std::to_wstring(FontSizeCs) + L"\"/>");
-            pCStringWriter->WriteString(L"<w:szCs w:val=\"" + std::to_wstring(FontSizeCs) + L"\"/>");
-        }
+		if(bFontSizeCs)
+		{
+			if(false == bFontSize)
+				pCStringWriter->WriteString(L"<w:sz w:val=\"" + std::to_wstring(FontSizeCs) + L"\"/>");
+			pCStringWriter->WriteString(L"<w:szCs w:val=\"" + std::to_wstring(FontSizeCs) + L"\"/>");
+		}
 		if(bHighLight)
 		{
 			docRGB& H = HighLight;
@@ -1772,9 +1771,9 @@ public:
 		if(bGridAfter && nGridAfter > 0)
 		{
             writer.WriteString(L"<w:grid" + sName + L" w:val=\"" + std::to_wstring(nGridAfter) + L"\"/>");
-			if(oAfterWidth.bW)
-				oAfterWidth.Write(writer, _T("w:w") + sName);
 		}
+		if(oAfterWidth.bW)
+			oAfterWidth.Write(writer, _T("w:w") + sName);
 	}
 };
 class WriteHyperlink
@@ -1906,12 +1905,19 @@ public:
 		m_nId += nCount;
 		return nRes;
 	}
+	int getCurrentId()
+	{
+		return m_nId;
+	}
 };
-class CComment{
+class CComment
+{
 private:
 	IdCounter& m_oParaIdCounter;
 	IdCounter& m_oFormatIdCounter;
 public:
+	void *pBinary_DocumentTableReader;
+
 	int IdOpen;
 	int IdFormat;
     std::wstring UserName;
@@ -1923,8 +1929,10 @@ public:
 	bool Solved;
 	unsigned int DurableId;
     std::wstring Text;
-    std::wstring m_sParaId;
-    std::wstring m_sParaIdParent;
+	std::wstring sContent;
+    
+	std::wstring sParaId;
+    std::wstring sParaIdParent;
 	std::vector<CComment*> replies;
 
 	bool bIdOpen;
@@ -1995,8 +2003,8 @@ public:
 
         int nId = pComment->m_oParaIdCounter.getNextId();
 
-		pComment->m_sParaId = XmlUtils::IntToString(nId, L"%08X");
-		sRes += L"<w:p w14:paraId=\"" + pComment->m_sParaId + L"\" w14:textId=\"" + pComment->m_sParaId + L"\">";
+		pComment->sParaId = XmlUtils::IntToString(nId, L"%08X");
+		sRes += L"<w:p w14:paraId=\"" + pComment->sParaId + L"\" w14:textId=\"" + pComment->sParaId + L"\">";
         sRes += L"<w:pPr><w:spacing w:line=\"240\" w:after=\"0\" w:lineRule=\"auto\" w:before=\"0\"/><w:ind w:firstLine=\"0\" w:left=\"0\" w:right=\"0\"/><w:jc w:val=\"left\"/></w:pPr><w:r><w:rPr><w:rFonts w:eastAsia=\"Arial\" w:ascii=\"Arial\" w:hAnsi=\"Arial\" w:cs=\"Arial\"/><w:sz w:val=\"22\"/></w:rPr><w:t xml:space=\"preserve\">";
         sRes += sPart;
         sRes += L"</w:t></w:r></w:p>";
@@ -2038,49 +2046,58 @@ public:
             sRes += L"\"";
 		}
         sRes += L">";
-		std::wstring sText = pComment->Text;
 
-		XmlUtils::replace_all(sText, L"\r", L"");
-
-		int nPrevIndex = 0;
-		for (int i = 0; i < (int)sText.length(); i++)
+		if (false == pComment->sContent.empty())
 		{
-			wchar_t cToken = sText[i];
-			if('\n' == cToken)
-			{
-				writeContentWritePart(pComment, sText, nPrevIndex, i, sRes);
-				nPrevIndex = i + 1;
-			}
+			sRes += pComment->sContent;
 		}
-		writeContentWritePart(pComment, sText, nPrevIndex, (int)sText.length(), sRes);
-        sRes += L"</w:comment>";
+		else
+		{
+	//old comments
+			std::wstring sText = pComment->Text;
+
+			XmlUtils::replace_all(sText, L"\r", L"");
+
+			int nPrevIndex = 0;
+			for (int i = 0; i < (int)sText.length(); i++)
+			{
+				wchar_t cToken = sText[i];
+				if('\n' == cToken)
+				{
+					writeContentWritePart(pComment, sText, nPrevIndex, i, sRes);
+					nPrevIndex = i + 1;
+				}
+			}
+			writeContentWritePart(pComment, sText, nPrevIndex, (int)sText.length(), sRes);
+		}     
+		sRes += L"</w:comment>";
 		return sRes;
 	}
     static std::wstring writeContentExt(CComment* pComment)
 	{
         std::wstring sRes;
-        if(!pComment->m_sParaId.empty())
+        if(false == pComment->sParaId.empty())
 		{
             std::wstring sDone(L"0");
 			if(pComment->bSolved && pComment->Solved)
 				sDone = _T("1");
-            if(!pComment->m_sParaIdParent.empty())
-                sRes += L"<w15:commentEx w15:paraId=\"" + pComment->m_sParaId + L"\" \
-w15:paraIdParent=\"" + pComment->m_sParaIdParent + L"\" w15:done=\"" + sDone + L"\"/>";
+            if(!pComment->sParaIdParent.empty())
+                sRes += L"<w15:commentEx w15:paraId=\"" + pComment->sParaId + L"\" \
+w15:paraIdParent=\"" + pComment->sParaIdParent + L"\" w15:done=\"" + sDone + L"\"/>";
 			else
-                sRes += L"<w15:commentEx w15:paraId=\"" + pComment->m_sParaId + L"\" w15:done=\"" + sDone + L"\"/>";
+                sRes += L"<w15:commentEx w15:paraId=\"" + pComment->sParaId + L"\" w15:done=\"" + sDone + L"\"/>";
 			//расставляем paraIdParent
 			for(size_t i = 0; i < pComment->replies.size(); i++)
-				pComment->replies[i]->m_sParaIdParent = pComment->m_sParaId;
+				pComment->replies[i]->sParaIdParent = pComment->sParaId;
 		}
 		return sRes;
 	}
 	static std::wstring writeContentsIds(CComment* pComment)
 	{
 		std::wstring sRes;
-		if(!pComment->m_sParaId.empty() && pComment->bDurableId)
+		if(!pComment->sParaId.empty() && pComment->bDurableId)
 		{
-			sRes += L"<w16cid:commentId w16cid:paraId=\"" + pComment->m_sParaId + L"\" w16cid:durableId=\"" + XmlUtils::IntToString(pComment->DurableId, L"%08X") + L"\"/>";
+			sRes += L"<w16cid:commentId w16cid:paraId=\"" + pComment->sParaId + L"\" w16cid:durableId=\"" + XmlUtils::IntToString(pComment->DurableId, L"%08X") + L"\"/>";
 		}
 		return sRes;
 	}
@@ -2112,8 +2129,8 @@ class CComments
 public:
 	IdCounter m_oFormatIdCounter;
 	IdCounter m_oParaIdCounter;
-public:
-	CComments():m_oParaIdCounter(1)
+
+	CComments() : m_oParaIdCounter(1)
 	{
 	}
 	~CComments()
@@ -3130,4 +3147,3 @@ public:
 	}
 };
 }
-#endif	// #ifndef READER_CLASSES

ASCOfficeDocxFile2/BinReader/Readers.cpp

@@ -112,7 +112,9 @@ public:
 	long read1defCurPos = 0;\
 		while(read1defCurPos < (long)stLen)\
 	{\
-		BYTE read1defType = m_oBufferedStream.GetUChar();\
+		BYTE read1defType = 0;\
+		if (false == m_oBufferedStream.GetUCharWithResult(&read1defType))\
+			break;\
 		long read1defLength =  m_oBufferedStream.GetLong();\
 		res = fReadFunction(read1defType, read1defLength, arg);\
 		if(res == c_oSerConstants::ReadUnknown)\
@@ -129,7 +131,9 @@ public:
 	long read2defCurPos = 0;\
 		while(read2defCurPos < (long)stLen)\
 	{\
-		BYTE read2defType = m_oBufferedStream.GetUChar();\
+		BYTE read2defType = 0;\
+		if (false == m_oBufferedStream.GetUCharWithResult(&read2defType))\
+			break;\
 		long read2defLenType =  m_oBufferedStream.GetUChar();\
 		int read2defCurPosShift = 2;\
 		int read2defRealLen;\
@@ -1431,8 +1435,7 @@ int Binary_pPrReader::ReadFootnotePr(BYTE type, long length, void* poResult)
 	else if( c_oSerNotes::PrStart == type )
 	{
 		pFtnProps->m_oNumStart.Init();
-		pFtnProps->m_oNumStart->m_oVal.Init();
-		pFtnProps->m_oNumStart->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		pFtnProps->m_oNumStart->m_oVal = m_oBufferedStream.GetLong();
 	}
 	else if( c_oSerNotes::PrFntPos == type )
 	{
@@ -1462,8 +1465,7 @@ int Binary_pPrReader::ReadEndnotePr(BYTE type, long length, void* poResult)
 	else if( c_oSerNotes::PrStart == type )
 	{
 		pEdnProps->m_oNumStart.Init();
-		pEdnProps->m_oNumStart->m_oVal.Init();
-		pEdnProps->m_oNumStart->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		pEdnProps->m_oNumStart->m_oVal = m_oBufferedStream.GetLong();
 	}
 	else if( c_oSerNotes::PrEndPos == type )
 	{
@@ -3294,7 +3296,14 @@ int Binary_OtherTableReader::ReadOtherContent(BYTE type, long length, void* poRe
 	else if(c_oSerOtherTableTypes::DocxTheme == type)
 	{
 		smart_ptr<PPTX::Theme> pTheme = new PPTX::Theme(NULL);
-		pTheme->fromPPTY(&m_oBufferedStream);
+		try
+		{
+			pTheme->fromPPTY(&m_oBufferedStream);
+		}
+		catch(...)
+		{
+			//todooo в отдельный лог
+		}
 		NSBinPptxRW::CXmlWriter xmlWriter;
 		pTheme->toXmlWriter(&xmlWriter);
 		m_oFileWriter.m_oTheme.m_sContent = xmlWriter.GetXmlString();
@@ -3353,22 +3362,40 @@ int Binary_OtherTableReader::ReadImageMapContent(BYTE type, long length, void* p
 }
 
 
-Binary_CommentsTableReader::Binary_CommentsTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter):Binary_CommonReader(poBufferedStream)
+Binary_CommentsTableReader::Binary_CommentsTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter) 
+	: Binary_CommonReader(poBufferedStream), m_oFileWriter(oFileWriter)
 {
 }
 int Binary_CommentsTableReader::Read()
 {
+	m_oFileWriter.m_pDrawingConverter->SetDstContentRels();
+    
+	Writers::ContentWriter oContentWriter;
+	Binary_DocumentTableReader oBinary_DocumentTableReader(m_oBufferedStream, m_oFileWriter, oContentWriter, &m_oComments);
+
+	oBinary_DocumentTableReader.m_bUsedParaIdCounter = true;
+
 	int res = c_oSerConstants::ReadOk;
-	READ_TABLE_DEF(res, this->ReadComments, NULL);
+	READ_TABLE_DEF(res, this->ReadComments, &oBinary_DocumentTableReader);
+
+	OOX::CPath fileRelsPath = m_oFileWriter.m_oDocumentWriter.m_sDir +	FILE_SEPARATOR_STR + L"word" +
+																		FILE_SEPARATOR_STR + L"_rels"+
+																		FILE_SEPARATOR_STR + m_oFileWriter.m_oCommentsWriter.getFilename() + L".rels";
+
+	m_oFileWriter.m_pDrawingConverter->SaveDstContentRels(fileRelsPath.GetPath());
+	
 	return res;
-};
+}
 int Binary_CommentsTableReader::ReadComments(BYTE type, long length, void* poResult)
 {
 	int res = c_oSerConstants::ReadOk;
 	if ( c_oSer_CommentsType::Comment == type )
 	{
 		CComment* pComment = new CComment(m_oComments.m_oParaIdCounter, m_oComments.m_oFormatIdCounter);
+		pComment->pBinary_DocumentTableReader = poResult;
+		
 		READ1_DEF(length, res, this->ReadCommentContent, pComment);
+
 		if(pComment->bIdOpen && NULL == m_oComments.get(pComment->IdOpen))
 			m_oComments.add(pComment);
 		else
@@ -3377,11 +3404,12 @@ int Binary_CommentsTableReader::ReadComments(BYTE type, long length, void* poRes
 	else
 		res = c_oSerConstants::ReadUnknown;
 	return res;
-};
+}
 int Binary_CommentsTableReader::ReadCommentContent(BYTE type, long length, void* poResult)
 {
 	int res = c_oSerConstants::ReadOk;
 	CComment* pComment = static_cast<CComment*>(poResult);
+	
 	if ( c_oSer_CommentsType::Id == type )
 	{
 		pComment->bIdOpen = true;
@@ -3431,28 +3459,55 @@ int Binary_CommentsTableReader::ReadCommentContent(BYTE type, long length, void*
 		pComment->bDurableId = true;
 		pComment->DurableId = m_oBufferedStream.GetULong();
 	}
+	else if ( c_oSer_CommentsType::CommentContent == type )
+	{
+		READ1_DEF(length, res, this->ReadCommentContentExt, pComment->pBinary_DocumentTableReader);
+
+		Binary_DocumentTableReader* doc_reader = (Binary_DocumentTableReader*)pComment->pBinary_DocumentTableReader;
+		
+		pComment->sContent = doc_reader->m_oDocumentWriter.m_oContent.GetData();
+		doc_reader->m_oDocumentWriter.m_oContent.Clear();
+
+		int nId = doc_reader->m_pComments->m_oParaIdCounter.getCurrentId();
+		pComment->sParaId = XmlUtils::IntToString(nId, L"%08X");
+
+	}
 	else if ( c_oSer_CommentsType::Replies == type )
 	{
-		READ1_DEF(length, res, this->ReadReplies, &pComment->replies);
+		READ1_DEF(length, res, this->ReadReplies, pComment);
 	}
 	else
 		res = c_oSerConstants::ReadUnknown;
 	return res;
-};
+}
+int Binary_CommentsTableReader::ReadCommentContentExt(BYTE type, long length, void* poResult)
+{
+	Binary_DocumentTableReader* pBinary_DocumentTableReader = static_cast<Binary_DocumentTableReader*>(poResult);
+
+	if (!pBinary_DocumentTableReader) return c_oSerConstants::ReadOk;
+
+	return pBinary_DocumentTableReader->ReadDocumentContent(type, length, NULL);
+}
 int Binary_CommentsTableReader::ReadReplies(BYTE type, long length, void* poResult)
 {
 	int res = c_oSerConstants::ReadOk;
-	std::vector<CComment*>* paComments = static_cast<std::vector<CComment*>*>(poResult);
+
+	CComment* pCommentParent = static_cast<CComment*>(poResult);
+	
 	if ( c_oSer_CommentsType::Comment == type )
 	{
 		CComment* pNewComment = new CComment(m_oComments.m_oParaIdCounter, m_oComments.m_oFormatIdCounter);
+		pNewComment->pBinary_DocumentTableReader = pCommentParent->pBinary_DocumentTableReader;
+
 		READ1_DEF(length, res, this->ReadCommentContent, pNewComment);
-		paComments->push_back(pNewComment);
+
+		pNewComment->sParaIdParent = pCommentParent->sParaId;
+		pCommentParent->replies.push_back(pNewComment);
 	}
 	else
 		res = c_oSerConstants::ReadUnknown;
 	return res;
-};
+}
 
 
 Binary_SettingsTableReader::Binary_SettingsTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter, OOX::CSettingsCustom& oSettingsCustom):
@@ -3755,8 +3810,7 @@ int Binary_SettingsTableReader::ReadFootnotePr(BYTE type, long length, void* poR
 	else if( c_oSerNotes::PrStart == type )
 	{
 		pFtnProps->m_oNumStart.Init();
-		pFtnProps->m_oNumStart->m_oVal.Init();
-		pFtnProps->m_oNumStart->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		pFtnProps->m_oNumStart->m_oVal = m_oBufferedStream.GetLong();
 	}
 	else if( c_oSerNotes::PrFntPos == type )
 	{
@@ -3794,8 +3848,7 @@ int Binary_SettingsTableReader::ReadEndnotePr(BYTE type, long length, void* poRe
 	else if( c_oSerNotes::PrStart == type )
 	{
 		pEdnProps->m_oNumStart.Init();
-		pEdnProps->m_oNumStart->m_oVal.Init();
-		pEdnProps->m_oNumStart->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		pEdnProps->m_oNumStart->m_oVal = m_oBufferedStream.GetLong();
 	}
 	else if( c_oSerNotes::PrEndPos == type )
 	{
@@ -4204,6 +4257,7 @@ Binary_DocumentTableReader::Binary_DocumentTableReader(NSBinPptxRW::CBinaryFileR
         , m_oMath_rPr(m_oFontTableWriter.m_mapFonts)
         , m_pComments(pComments)
 {
+	m_bUsedParaIdCounter = false;
 	m_byteLastElemType = c_oSerParType::Content;
 	m_pCurWriter = NULL;
 }
@@ -4237,9 +4291,19 @@ int Binary_DocumentTableReader::ReadDocumentContent(BYTE type, long length, void
 		m_byteLastElemType = c_oSerParType::Par;
 		m_oCur_pPr.ClearNoAttack();
 
-        m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("<w:p>")));
+		if (m_bUsedParaIdCounter && m_pComments)
+		{
+			int nId = m_pComments->m_oParaIdCounter.getNextId();
+			std::wstring sParaId = XmlUtils::IntToString(nId, L"%08X");
+
+			m_oDocumentWriter.m_oContent.WriteString(L"<w:p w14:paraId=\"" + sParaId + L"\" w14:textId=\"" + sParaId + L"\">");
+		}
+		else
+		{
+			m_oDocumentWriter.m_oContent.WriteString(std::wstring(L"<w:p>"));
+		}
 		READ1_DEF(length, res, this->ReadParagraph, NULL);
-        m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("</w:p>")));
+        m_oDocumentWriter.m_oContent.WriteString(std::wstring(L"</w:p>"));
 	}
 	else if(c_oSerParType::Table == type)
 	{
@@ -4713,8 +4777,7 @@ int Binary_DocumentTableReader::ReadFFData(BYTE type, long length, void* poResul
 	else if ( c_oSerFFData::Label == type )
 	{
 		pFFData->m_oLabel.Init();
-		pFFData->m_oLabel->m_oVal.Init();
-		pFFData->m_oLabel->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		pFFData->m_oLabel->m_oVal = m_oBufferedStream.GetLong();
 	}
 	else if ( c_oSerFFData::Name == type )
 	{
@@ -4779,20 +4842,18 @@ int Binary_DocumentTableReader::ReadDDList(BYTE type, long length, void* poResul
 	if ( c_oSerFFData::DLDefault == type )
 	{
 		pDDList->m_oDefault.Init();
-		pDDList->m_oDefault->m_oVal.Init();
-		pDDList->m_oDefault->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		pDDList->m_oDefault->m_oVal = m_oBufferedStream.GetLong();
 	}
 	else if ( c_oSerFFData::DLResult == type )
 	{
 		pDDList->m_oResult.Init();
-		pDDList->m_oResult->m_oVal.Init();
-		pDDList->m_oResult->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		pDDList->m_oResult->m_oVal = m_oBufferedStream.GetLong();
 	}
 	else if ( c_oSerFFData::DLListEntry == type )
 	{
 		ComplexTypes::Word::String* pVal = new ComplexTypes::Word::String();
-		pVal->m_sVal.Init();
-		pVal->m_sVal->append(m_oBufferedStream.GetString3(length));
+		pVal->m_sVal = m_oBufferedStream.GetString3(length);
+		
 		pDDList->m_arrListEntry.push_back(pVal);
 	}
 	else
@@ -4844,20 +4905,17 @@ int Binary_DocumentTableReader::ReadTextInput(BYTE type, long length, void* poRe
 	if ( c_oSerFFData::TIDefault == type )
 	{
 		pTextInput->m_oDefault.Init();
-		pTextInput->m_oDefault->m_sVal.Init();
-		pTextInput->m_oDefault->m_sVal->append(m_oBufferedStream.GetString3(length));
+		pTextInput->m_oDefault->m_sVal = m_oBufferedStream.GetString3(length);
 	}
 	else if ( c_oSerFFData::TIFormat == type )
 	{
 		pTextInput->m_oFormat.Init();
-		pTextInput->m_oFormat->m_sVal.Init();
-		pTextInput->m_oFormat->m_sVal->append(m_oBufferedStream.GetString3(length));
+		pTextInput->m_oFormat->m_sVal = m_oBufferedStream.GetString3(length);
 	}
 	else if ( c_oSerFFData::TIMaxLength == type )
 	{
 		pTextInput->m_oMaxLength.Init();
-		pTextInput->m_oMaxLength->m_oVal.Init();
-		pTextInput->m_oMaxLength->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		pTextInput->m_oMaxLength->m_oVal = m_oBufferedStream.GetLong();
 	}
 	else if ( c_oSerFFData::TIType == type )
 	{
@@ -7367,17 +7425,27 @@ int Binary_DocumentTableReader::ReadRunContent(BYTE type, long length, void* poR
 	else if(c_oSerRunType::table == type)
 	{
 		//todo
-        m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("</w:p>")));
-        m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("<w:tbl>")));
+        m_oDocumentWriter.m_oContent.WriteString(std::wstring(L"</w:p>"));
+        m_oDocumentWriter.m_oContent.WriteString(std::wstring(L"<w:tbl>"));
 		READ1_DEF(length, res, this->ReadDocTable, &m_oDocumentWriter.m_oContent);
-        m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("</w:tbl>")));
-        m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("<w:p>")));
+        m_oDocumentWriter.m_oContent.WriteString(std::wstring(L"</w:tbl>"));
 
+		if (m_bUsedParaIdCounter && m_pComments)
+		{
+			int nId = m_pComments->m_oParaIdCounter.getNextId();
+			std::wstring sParaId = XmlUtils::IntToString(nId, L"%08X");
+
+			m_oDocumentWriter.m_oContent.WriteString(L"<w:p w14:paraId=\"" + sParaId + L"\" w14:textId=\"" + sParaId + L"\">");
+		}
+		else
+		{
+			m_oDocumentWriter.m_oContent.WriteString(std::wstring(L"<w:p>"));
+		}
         if(m_oCur_pPr.GetCurSize() > 0)
 		{
-            m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("<w:pPr>")));
+            m_oDocumentWriter.m_oContent.WriteString(std::wstring(L"<w:pPr>"));
 			m_oDocumentWriter.m_oContent.Write(m_oCur_pPr);
-            m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("</w:pPr>")));
+            m_oDocumentWriter.m_oContent.WriteString(std::wstring(L"</w:pPr>"));
 		}
 	}
 	else if(c_oSerRunType::fldstart_deprecated == type)
@@ -7769,7 +7837,7 @@ int Binary_DocumentTableReader::ReadCell(BYTE type, long length, void* poResult)
 		//Потому что если перед </tc> не идет <p>, то документ считается невалидным
 		if(c_oSerParType::Par != oBinary_DocumentTableReader.m_byteLastElemType)
 		{
-            m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("<w:p />")));
+            m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("<w:p/>")));
 		}
 	}
 	else
@@ -8614,8 +8682,7 @@ int Binary_DocumentTableReader::ReadSdtPr(BYTE type, long length, void* poResult
 	else if (c_oSerSdt::Alias == type)
 	{
 		pSdtPr->m_oAlias.Init();
-		pSdtPr->m_oAlias->m_sVal.Init();
-		pSdtPr->m_oAlias->m_sVal->append(m_oBufferedStream.GetString3(length));
+		pSdtPr->m_oAlias->m_sVal = m_oBufferedStream.GetString3(length);
 	}
 	else if (c_oSerSdt::Appearance == type)
 	{
@@ -8663,14 +8730,12 @@ int Binary_DocumentTableReader::ReadSdtPr(BYTE type, long length, void* poResult
 	else if (c_oSerSdt::Id == type)
 	{
 		pSdtPr->m_oId.Init();
-		pSdtPr->m_oId->m_oVal.Init();
-		pSdtPr->m_oId->m_oVal->SetValue(m_oBufferedStream.GetULong());
+		pSdtPr->m_oId->m_oVal = m_oBufferedStream.GetULong();
 	}
 	else if (c_oSerSdt::Label == type)
 	{
 		pSdtPr->m_oLabel.Init();
-		pSdtPr->m_oLabel->m_oVal.Init();
-		pSdtPr->m_oLabel->m_oVal->SetValue(m_oBufferedStream.GetULong());
+		pSdtPr->m_oLabel->m_oVal = m_oBufferedStream.GetULong();
 	}
 	else if (c_oSerSdt::Lock == type)
 	{
@@ -8681,8 +8746,7 @@ int Binary_DocumentTableReader::ReadSdtPr(BYTE type, long length, void* poResult
 	{
 		pSdtPr->m_oPlaceHolder.Init();
 		pSdtPr->m_oPlaceHolder->m_oDocPart.Init();
-		pSdtPr->m_oPlaceHolder->m_oDocPart->m_sVal.Init();
-		pSdtPr->m_oPlaceHolder->m_oDocPart->m_sVal->append(m_oBufferedStream.GetString3(length));
+		pSdtPr->m_oPlaceHolder->m_oDocPart->m_sVal = m_oBufferedStream.GetString3(length);
 	}
 	else if (c_oSerSdt::RPr == type)
 	{
@@ -8703,8 +8767,7 @@ int Binary_DocumentTableReader::ReadSdtPr(BYTE type, long length, void* poResult
 	else if (c_oSerSdt::Tag == type)
 	{
 		pSdtPr->m_oTag.Init();
-		pSdtPr->m_oTag->m_sVal.Init();
-		pSdtPr->m_oTag->m_sVal->append(m_oBufferedStream.GetString3(length));
+		pSdtPr->m_oTag->m_sVal = m_oBufferedStream.GetString3(length);
 	}
 	else if (c_oSerSdt::Temporary == type)
 	{
@@ -8843,8 +8906,7 @@ int Binary_DocumentTableReader::ReadSdtPrDate(BYTE type, long length, void* poRe
 	else if (c_oSerSdt::DateFormat == type)
 	{
 		pDate->m_oDateFormat.Init();
-		pDate->m_oDateFormat->m_sVal.Init();
-		pDate->m_oDateFormat->m_sVal->append(m_oBufferedStream.GetString3(length));
+		pDate->m_oDateFormat->m_sVal = m_oBufferedStream.GetString3(length);
 	}
 	else if (c_oSerSdt::Lid == type)
 	{
@@ -8869,14 +8931,12 @@ int Binary_DocumentTableReader::ReadDocPartList(BYTE type, long length, void* po
 	if (c_oSerSdt::DocPartCategory == type)
 	{
 		pDocPart->m_oDocPartCategory.Init();
-		pDocPart->m_oDocPartCategory->m_sVal.Init();
-		pDocPart->m_oDocPartCategory->m_sVal->append(m_oBufferedStream.GetString3(length));
+		pDocPart->m_oDocPartCategory->m_sVal = m_oBufferedStream.GetString3(length);
 	}
 	else if (c_oSerSdt::DocPartGallery == type)
 	{
 		pDocPart->m_oDocPartGallery.Init();
-		pDocPart->m_oDocPartGallery->m_sVal.Init();
-		pDocPart->m_oDocPartGallery->m_sVal->append(m_oBufferedStream.GetString3(length));
+		pDocPart->m_oDocPartGallery->m_sVal = m_oBufferedStream.GetString3(length);
 	}
 	else if (c_oSerSdt::DocPartUnique == type)
 	{
@@ -8907,14 +8967,15 @@ int Binary_DocumentTableReader::ReadDropDownList(BYTE type, long length, void* p
 }
 
 
-Binary_NotesTableReader::Binary_NotesTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter, CComments* pComments, bool bIsFootnote):
-	Binary_CommonReader(poBufferedStream),m_oFileWriter(oFileWriter),m_pComments(pComments),m_bIsFootnote(bIsFootnote)
+Binary_NotesTableReader::Binary_NotesTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter, CComments* pComments, bool bIsFootnote)
+	: Binary_CommonReader(poBufferedStream), m_oFileWriter(oFileWriter), m_pComments(pComments), m_bIsFootnote(bIsFootnote)
 {
 }
 int Binary_NotesTableReader::Read()
 {
 	m_oFileWriter.m_pDrawingConverter->SetDstContentRels();
-    std::wstring sFilename;
+    
+	std::wstring sFilename;
 	Writers::ContentWriter* pContentWriter = NULL;
 	if(m_bIsFootnote)
 	{
@@ -9016,7 +9077,18 @@ BinaryFileReader::BinaryFileReader(std::wstring& sFileInDir, NSBinPptxRW::CBinar
 }
 int BinaryFileReader::ReadFile()
 {
-	return ReadMainTable();
+	long res = c_oSerConstants::ReadOk;
+
+	try
+	{
+		res = ReadMainTable();
+	}
+	catch(...)
+	{
+		res = c_oSerConstants::ErrorStream;
+	}
+
+	return res;
 }
 int BinaryFileReader::ReadMainTable()
 {

ASCOfficeDocxFile2/BinReader/Readers.h

@@ -226,12 +226,14 @@ public:
 class Binary_CommentsTableReader : public Binary_CommonReader
 {
 public:
-	CComments m_oComments;
-public:
+	CComments				m_oComments;
+	Writers::FileWriter&	m_oFileWriter;
+
 	Binary_CommentsTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter);
 	int Read();
 	int ReadComments(BYTE type, long length, void* poResult);
 	int ReadCommentContent(BYTE type, long length, void* poResult);
+	int ReadCommentContentExt(BYTE type, long length, void* poResult);
 	int ReadReplies(BYTE type, long length, void* poResult);
 };
 class Binary_SettingsTableReader : public Binary_CommonReader
@@ -279,18 +281,21 @@ private:
     Binary_pPrReader                oBinary_pPrReader;
     Binary_rPrReader                oBinary_rPrReader;
     Binary_tblPrReader              oBinary_tblPrReader;
-	NSStringUtils::CStringBuilder*        m_pCurWriter;
+	NSStringUtils::CStringBuilder*	m_pCurWriter;
     rPr                             m_oCur_rPr;
     rPr                             m_oMath_rPr;
-	NSStringUtils::CStringBuilder         m_oCur_pPr;
+	NSStringUtils::CStringBuilder	m_oCur_pPr;
     BYTE                            m_byteLastElemType;
-    CComments*                      m_pComments;
 public:
+    CComments*                      m_pComments;
     Writers::ContentWriter&         m_oDocumentWriter;
     Writers::MediaWriter&           m_oMediaWriter;
 
+	bool							m_bUsedParaIdCounter;
+
     Binary_DocumentTableReader(NSBinPptxRW::CBinaryFileReader& poBufferedStream, Writers::FileWriter& oFileWriter, Writers::ContentWriter& oDocumentWriter, CComments* pComments);
 	~Binary_DocumentTableReader();
+	
 	int Read();
 	NSStringUtils::CStringBuilder& GetRunStringWriter();
 	int ReadDocumentContentOut(long length);

ASCOfficeDocxFile2/BinWriter/BinReaderWriterDefines.h

@@ -805,7 +805,8 @@ extern int g_nCurFormatVersion;
 		Replies = 9,
 		OOData = 10,
 		DurableId = 11,
-		ProviderId = 12
+		ProviderId = 12,
+		CommentContent = 13
 	};}
 	namespace c_oSer_SettingsType{enum c_oSer_SettingsType
 	{

ASCOfficeDocxFile2/BinWriter/BinWriters.h

@@ -35,16 +35,14 @@
 
 #include "BinReaderWriterDefines.h"
 
+#include "../../Common/DocxFormat/Source/DocxFormat/DocxFlat.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/Docx.h"
 #include "../../Common/DocxFormat/Source/MathEquation/MathEquation.h"
 
 #include "../../Common/DocxFormat/Source/DocxFormat/Document.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/FontTable.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/Numbering.h"
-#include "../../Common/DocxFormat/Source/DocxFormat/Comments.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/Styles.h"
-#include "../../Common/DocxFormat/Source/DocxFormat/Footnote.h"
-#include "../../Common/DocxFormat/Source/DocxFormat/Endnote.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/Settings/Settings.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/External/HyperLink.h"
 #include "../../Common/DocxFormat/Source/DocxFormat/Media/VbaProject.h"
@@ -76,24 +74,42 @@ namespace BinDocxRW
 		NSBinPptxRW::CDrawingConverter*			m_pOfficeDrawingConverter;
 		NSFontCutter::CEmbeddedFontsManager*	m_pEmbeddedFontsManager;
 
-		OOX::CSettings*			m_oSettings;
-		PPTX::Theme*			m_poTheme;
+		OOX::Document*			m_pMain;
+		OOX::CSettings*			m_pSettings;
+		PPTX::Theme*			m_pTheme;
+		
+		OOX::CStyles*			m_pStyles;
+		OOX::CNumbering*		m_pNumbering;
+
+		bool m_bLocalStyles;
+		bool m_bLocalNumbering;
+
+		OOX::CStyles*			m_pEmbeddedStyles;
+		OOX::CNumbering*		m_pEmbeddedNumbering;
 
 		OOX::IFileContainer*	m_pCurRels;
 		std::map<int, bool>		m_mapIgnoreComments;
 
 		ParamsWriter(NSBinPptxRW::CBinaryFileWriter* pCBufferedStream, DocWrapper::FontProcessor* pFontProcessor, NSBinPptxRW::CDrawingConverter* pOfficeDrawingConverter, NSFontCutter::CEmbeddedFontsManager* pEmbeddedFontsManager):
-				m_pCBufferedStream(pCBufferedStream),m_pFontProcessor(pFontProcessor),m_pOfficeDrawingConverter(pOfficeDrawingConverter),m_pEmbeddedFontsManager(pEmbeddedFontsManager)
+				m_pCBufferedStream(pCBufferedStream), m_pFontProcessor(pFontProcessor), m_pOfficeDrawingConverter(pOfficeDrawingConverter), m_pEmbeddedFontsManager(pEmbeddedFontsManager)
 		{
-			m_oSettings = NULL;
-			m_poTheme	= NULL;
+			m_pMain		= NULL;
+			m_pSettings = NULL;
+			m_pTheme	= NULL;
 			m_pCurRels	= NULL;
+			m_pStyles	= NULL;
+			m_pNumbering = NULL;
+
+			m_pEmbeddedStyles = NULL;
+			m_pEmbeddedNumbering = NULL;
+
+			m_bLocalStyles = m_bLocalNumbering = false;
 		}
 	};
 	class ParamsDocumentWriter
 	{
 	public:
-		OOX::IFileContainer*	m_pRels;
+		OOX::IFileContainer* m_pRels;
 
 		ParamsDocumentWriter(OOX::IFileContainer* pRels) : m_pRels(pRels)
 		{
@@ -129,22 +145,20 @@ namespace BinDocxRW
 	class BinaryHeaderFooterTableWriter
 	{
 		BinaryCommonWriter				m_oBcw;
-		ParamsWriter&					m_oParamsWriter;
-		OOX::CSettings*					m_oSettings;
 
-		PPTX::Theme*					m_poTheme;
-		DocWrapper::FontProcessor&		m_oFontProcessor;
 		NSBinPptxRW::CDrawingConverter* m_pOfficeDrawingConverter;
 		std::map<int, bool>*			m_mapIgnoreComments;
 	public:
-		OOX::IFileContainer* m_oDocumentRels;
-		std::vector<OOX::CHdrFtr*> m_aHeaders;
-		std::vector<SimpleTypes::EHdrFtr> m_aHeaderTypes;
-		std::vector<OOX::Logic::CSectionProperty*> m_aHeaderSectPrs;
-		std::vector<OOX::CHdrFtr*> m_aFooters;
-		std::vector<SimpleTypes::EHdrFtr> m_aFooterTypes;
-		std::vector<OOX::Logic::CSectionProperty*> m_aFooterSectPrs;
-	public:
+		ParamsWriter&								m_oParamsWriter;
+		OOX::IFileContainer*						m_oDocumentRels;
+
+		std::vector<OOX::CHdrFtr*>					m_aHeaders;
+		std::vector<SimpleTypes::EHdrFtr>			m_aHeaderTypes;
+		std::vector<OOX::Logic::CSectionProperty*>	m_aHeaderSectPrs;
+		std::vector<OOX::CHdrFtr*>					m_aFooters;
+		std::vector<SimpleTypes::EHdrFtr>			m_aFooterTypes;
+		std::vector<OOX::Logic::CSectionProperty*>	m_aFooterSectPrs;
+
 		BinaryHeaderFooterTableWriter(ParamsWriter& oParamsWriter, OOX::IFileContainer* oDocumentRel, std::map<int, bool>* mapIgnoreComments);
 		void Write();
 		void WriteHdrFtrContent(std::vector<OOX::CHdrFtr*>& aHdrFtrs, std::vector<SimpleTypes::EHdrFtr>& aHdrFtrTypes, std::vector<OOX::Logic::CSectionProperty*>& aHdrSectPrs, bool bHdr);
@@ -161,7 +175,7 @@ namespace BinDocxRW
 	{
 		BinaryCommonWriter m_oBcw;
 	public:
-		PPTX::Theme*					m_poTheme;
+		PPTX::Theme*					m_pTheme;
 		NSBinPptxRW::CDrawingConverter* m_pOfficeDrawingConverter;
 		DocWrapper::FontProcessor&		m_oFontProcessor;
 
@@ -173,7 +187,8 @@ namespace BinDocxRW
 	{
 		BinaryCommonWriter m_oBcw;
 		Binary_rPrWriter brPrs;
-		OOX::CSettings* m_oSettings;
+		
+		ParamsWriter& m_oParamsWriter;
 	public:
 		BinaryHeaderFooterTableWriter* m_oBinaryHeaderFooterTableWriter;
 
@@ -201,6 +216,9 @@ namespace BinDocxRW
 							 const nullable<ComplexTypes::Word::CDecimalNumber>& numStart, nullable<ComplexTypes::Word::CFtnPos>* ftnPos,
 							 nullable<ComplexTypes::Word::CEdnPos>* endPos, std::vector<OOX::CFtnEdnSepRef*>* refs);
 		void WriteNumFmt(const ComplexTypes::Word::CNumFmt& oNumFmt);
+
+	private:
+		std::wstring AddEmbeddedStyle(const std::wstring & styleId);
 	};
 	class Binary_tblPrWriter
 	{
@@ -291,19 +309,19 @@ namespace BinDocxRW
 	{
 	private:
 		ParamsWriter&			m_oParamsWriter;
+		
 		ParamsDocumentWriter&	m_oParamsDocumentWriter;
 		BinaryCommonWriter		m_oBcw;
 		Binary_pPrWriter		bpPrs;
 		Binary_rPrWriter		brPrs;
 		std::wstring			m_sCurParStyle;
-		OOX::CSettings*			m_oSettings;
 
 		NSBinPptxRW::CDrawingConverter* m_pOfficeDrawingConverter;
 		std::map<int, bool>*			m_mapIgnoreComments;
 	public:
 		Binary_tblPrWriter				btblPrs;
 		OOX::Logic::CSectionProperty*	pSectPr;
-		OOX::Logic::CBackground *		pBackground;
+		OOX::WritingElement*			pBackground;
 		OOX::CDocument*					poDocument;
 		OOX::JsaProject*				pJsaProject;
 
@@ -315,7 +333,7 @@ namespace BinDocxRW
 		void WriteVbaProject(OOX::VbaProject& oVbaProject);
 		void Write(std::vector<OOX::WritingElement*> & aElems);
 		void WriteDocumentContent(const std::vector<OOX::WritingElement*> & aElems);
-		void WriteBackground (OOX::Logic::CBackground* pBackground);
+		void WriteBackground (OOX::WritingElement* pBackground);
 		void WriteParapraph(OOX::Logic::CParagraph& par, OOX::Logic::CParagraphProperty* pPr);
 		void WriteParagraphContent(const std::vector<OOX::WritingElement*> & content, bool bHyperlink = false);
 		void WriteDel(const OOX::Logic::CDel& oDel);
@@ -439,7 +457,7 @@ namespace BinDocxRW
 		void WriteRunContent(std::vector<OOX::WritingElement*>::iterator &start, std::vector<OOX::WritingElement*>::iterator &end, bool bHyperlink = false);
 		void WriteNoteRef(const nullable<SimpleTypes::COnOff<>>& oCustomMarkFollows, const nullable<SimpleTypes::CDecimalNumber<>>& oId);
 		void WriteText(const std::wstring& text, BYTE type);
-		void WriteDrawingPptx(OOX::WritingElement* item);
+		bool WriteDrawingPptx(OOX::WritingElement* item);
 		void WriteDrawing(std::wstring* pXml, OOX::Logic::CDrawing* pDrawing, PPTX::Logic::GraphicFrame *pGraphic);
 		void WriteNvGraphicFramePr(const PPTX::Logic::NvGraphicFramePr& oGraphicFramePr);
 		void WriteDocPr(const PPTX::Logic::CNvPr& oDocPr);
@@ -489,12 +507,14 @@ namespace BinDocxRW
 			std::vector<CCommentWriteTemp*> aReplies;
 		};
 		BinaryCommonWriter m_oBcw;
+		ParamsWriter& m_oParamsWriter;
+		NSBinPptxRW::CDrawingConverter* m_pOfficeDrawingConverter;
 	public:
 		BinaryCommentsTableWriter(ParamsWriter& oParamsWriter);
 		void Write(OOX::CComments& oComments, OOX::CCommentsExt* pCommentsExt, OOX::CPeople* pPeople, OOX::CCommentsIds* pCommentsIds, std::map<int, bool>& mapIgnoreComments);
-		void WriteCommentsContent(OOX::CComments& oComments, OOX::CCommentsExt* pCommentsExt, OOX::CPeople* pPeople, OOX::CCommentsIds* pCommentsIds, std::map<int, bool>& mapIgnoreComments);
-		void WriteComment(CCommentWriteTemp& oComment);
-		void WriteReplies(std::vector<CCommentWriteTemp*>& aCommentWriteTemp);
+		void WriteCommentsContent(OOX::CComments& oComments, OOX::CCommentsExt* pCommentsExt, OOX::CPeople* pPeople, OOX::CCommentsIds* pCommentsIds, std::map<int, bool>& mapIgnoreComments, ParamsDocumentWriter& oParamsDocumentWriter);
+		void WriteComment(CCommentWriteTemp& oComment, BinaryDocumentTableWriter & oBinaryDocumentTableWriter);
+		void WriteReplies(std::vector<CCommentWriteTemp*>& aCommentWriteTemp, BinaryDocumentTableWriter & oBinaryDocumentTableWriter);
 	};
 	class BinarySettingsTableWriter
 	{

ASCOfficeDocxFile2/DocWrapper/ChartWriter.cpp

@@ -163,8 +163,7 @@ namespace BinXlsxRW{
 			toXlsxSheetdata(pWorksheet, *it->second, aSharedStrings);
 			
 			OOX::Spreadsheet::CSheet* pSheet = new OOX::Spreadsheet::CSheet();
-			pSheet->m_oName.Init();
-			pSheet->m_oName->append(sSheetName);
+			pSheet->m_oName = sSheetName;
 			pSheet->m_oSheetId.Init();
 			pSheet->m_oSheetId->SetValue(nSheetId++);
 			
@@ -212,8 +211,7 @@ namespace BinXlsxRW{
         for (boost::unordered_map<std::wstring, int>::iterator it = m_mapFormats.begin(); it != m_mapFormats.end(); ++it)
 		{
 			OOX::Spreadsheet::CNumFmt* pNumFmt = new OOX::Spreadsheet::CNumFmt();
-			pNumFmt->m_oFormatCode.Init();
-			pNumFmt->m_oFormatCode->append(it->first);
+			pNumFmt->m_oFormatCode = (it->first);
 			pNumFmt->m_oNumFmtId.Init();
 			pNumFmt->m_oNumFmtId->SetValue(NUMID_START + it->second);
 			oXlsx.m_pStyles->m_oNumFmts->m_arrItems.push_back(pNumFmt);

ASCOfficeDocxFile2/DocWrapper/DocxSerializer.cpp

@@ -64,7 +64,7 @@ BinDocxRW::CDocxSerializer::~CDocxSerializer()
 	RELEASEOBJECT(m_pParamsWriter);
 	RELEASEOBJECT(m_pCurFileWriter);
 }
-bool BinDocxRW::CDocxSerializer::saveToFile(const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions)
+bool BinDocxRW::CDocxSerializer::saveToFile(const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions, const std::wstring& sTempPath)
 {
 	OOX::CPath pathMain(sSrcFileName);
     
@@ -105,6 +105,7 @@ bool BinDocxRW::CDocxSerializer::saveToFile(const std::wstring& sSrcFileName, co
 
     oDrawingConverter.SetDstPath(pathMain.GetDirectory() + FILE_SEPARATOR_STR + L"word");
 	oDrawingConverter.SetMediaDstPath(pathMedia.GetPath());
+	oDrawingConverter.SetTempPath(sTempPath);
 	
 	m_pParamsWriter = new ParamsWriter(&oBufferedStream, &fp, &oDrawingConverter, pEmbeddedFontsManager);
 
@@ -201,7 +202,8 @@ bool BinDocxRW::CDocxSerializer::loadFromFile(const std::wstring& sSrcFileName,
 		bool bValidFormat = false;
         std::wstring sSignature(g_sFormatSignature);
         int nSigLength = (int)sSignature.length();
-		if((int)nBase64DataSize > nSigLength)
+		
+		if ((int)nBase64DataSize > nSigLength)
 		{
             std::string sCurSig((char*)pBase64Data, nSigLength);
             if(sSignature == std::wstring(sCurSig.begin(), sCurSig.end()))
@@ -216,7 +218,8 @@ bool BinDocxRW::CDocxSerializer::loadFromFile(const std::wstring& sSrcFileName,
 			int nType = 0;
             std::string version = "";
             std::string dst_len = "";
-			while (true)
+			
+			while (nIndex < nBase64DataSize)
 			{
 				nIndex++;
 				BYTE _c = pBase64Data[nIndex];

ASCOfficeDocxFile2/DocWrapper/DocxSerializer.h

@@ -63,7 +63,7 @@ namespace BinDocxRW
 		virtual ~CDocxSerializer();
 
         bool loadFromFile   (const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions, const std::wstring& sThemePath, const std::wstring& sMediaPath, const std::wstring& sEmbedPath);
-        bool saveToFile     (const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions);
+        bool saveToFile     (const std::wstring& sSrcFileName, const std::wstring& sDstPath, const std::wstring& sXMLOptions, const std::wstring& sTempPath);
 
         bool CreateDocxFolders(std::wstring strDirectory, std::wstring& sThemePath, std::wstring& sMediaPath, std::wstring& sEmbedPath);
 		

ASCOfficeDocxFile2/DocWrapper/XlsxSerializer.cpp

@@ -174,8 +174,15 @@ namespace BinXlsxRW{
 		BinXlsxRW::SaveParams			oSaveParams(sDrawingsPath, sThemePath, m_pExternalDrawingConverter->GetContentTypes());
 		OOX::Spreadsheet::CChartSpace	oChartSpace(NULL);
 		BinXlsxRW::BinaryChartReader	oBinaryChartReader(*pReader, oSaveParams, m_pExternalDrawingConverter);
-		
-		oBinaryChartReader.ReadCT_ChartSpace(lLength, &oChartSpace);
+	
+		try
+		{
+			oBinaryChartReader.ReadCT_ChartSpace(lLength, &oChartSpace);
+		}
+		catch(...)
+		{
+			//todooo
+		}
 
 		if(oChartSpace.isValid())
 		{

ASCOfficeDocxFile2/Linux/ASCOfficeDocxFile2Lib.pro

@@ -38,7 +38,8 @@ SOURCES += \
     ../../OfficeCryptReader/source/ECMACryptFile.cpp \
     ../../OfficeCryptReader/source/CryptTransform.cpp \
     ../BinReader/Readers.cpp \
-    ../BinReader/CustormXmlWriter.cpp
+    ../BinReader/CustormXmlWriter.cpp \
+    ../BinReader/FileWriter.cpp
 
 HEADERS += ../DocWrapper/DocxSerializer.h \
     ../DocWrapper/FontProcessor.h \

ASCOfficeOdfFile/formulasconvert/formulasconvert_odf.cpp

@@ -615,10 +615,8 @@ namespace formulasconvert {
 				cells_out.append(cells[j]);
 				cells_out.append(L":");
 			}
-			size_t res1 = sheet.find(L"-");
-			size_t res2 = sheet.find(L"'");
 			
-			if (res1 != std::wstring::npos && res2 != std::wstring::npos && !(res2 == 0))
+			if (sheet.find(L"-") != std::wstring::npos && sheet.find(L"'") == std::wstring::npos && sheet.find(L"\"") == std::wstring::npos)
 			{
 				sheet = L"'" + sheet + L"'";
 			}

ASCOfficeOdfFile/formulasconvert/formulasconvert_oox.cpp

@@ -148,7 +148,7 @@ public:
 			{
 				case 'M':
 				{
-					if ((pos + 5 < size) && (expr.substr(pos, 5) == L"MINYS"))
+					if ((pos + 5 <= size) && (expr.substr(pos, 5) == L"MINYS"))
 					{
 						result += L"-"; pos += 5;
 					}
@@ -159,7 +159,7 @@ public:
 				}break;
 				case 'T':
 				{	
-					if ((pos + 6 < size) && (expr.substr(pos, 6) == L"ТОСHKA"))
+					if ((pos + 6 <= size) && (expr.substr(pos, 6) == L"ТОСHKA"))
 					{
 						result += L"."; pos += 6;
 					}
@@ -170,7 +170,7 @@ public:
 				}break;
 				case 'V':
 				{
-					if ((pos + 5 < size) && (expr.substr(pos, 5) == L"VOSKL"))
+					if ((pos + 5 <= size) && (expr.substr(pos, 5) == L"VOSKL"))
 					{
 						result += L"!"; pos += 5;
 					}
@@ -181,11 +181,11 @@ public:
 				}break;
 				case 'S':
 				{
-					if ((pos + 8 < size) && (expr.substr(pos, 8) == L"SCOBCAIN"))
+					if ((pos + 8 <= size) && (expr.substr(pos, 8) == L"SCOBCAIN"))
 					{
 						result += L"("; pos += 8;
 					}
-					else if ((pos + 9 < size) && (expr.substr(pos, 9) == L"SCOBCAOUT"))
+					else if ((pos + 9 <= size) && (expr.substr(pos, 9) == L"SCOBCAOUT"))
 					{
 						result += L")"; pos += 9;
 					}
@@ -196,15 +196,15 @@ public:
 				}break;
 				case 'K':
 				{
-					if ((pos + 9 < size) && (expr.substr(pos, 9) == L"KVADRATIN"))
+					if ((pos + 9 <= size) && (expr.substr(pos, 9) == L"KVADRATIN"))
 					{
 						result += L"["; pos += 9;
 					}
-					else if ((pos + 10 < size) && (expr.substr(pos, 10) == L"KVADRATOUT"))
+					else if ((pos + 10 <= size) && (expr.substr(pos, 10) == L"KVADRATOUT"))
 					{
 						result += L"]"; pos += 10;
 					}
-					else if ((pos + 8 < size) && (expr.substr(pos, 8) == L"KAVYCHKA"))
+					else if ((pos + 8 <= size) && (expr.substr(pos, 8) == L"KAVYCHKA"))
 					{
 						result += L"\""; pos += 8;
 					}
@@ -215,7 +215,7 @@ public:
 				}break;
 				case 'P':
 				{
-					if ((pos + 6 < size) && (expr.substr(pos, 6) == L"PROBEL"))
+					if ((pos + 6 <= size) && (expr.substr(pos, 6) == L"PROBEL"))
 					{
 						result += L" "; pos += 6;
 					}
@@ -226,7 +226,7 @@ public:
 				}break;
 				case 'A':
 				{
-					if ((pos + 8 < size) && (expr.substr(pos, 8) == L"APOSTROF"))
+					if ((pos + 8 <= size) && (expr.substr(pos, 8) == L"APOSTROF"))
 					{
 						result += L"'"; pos += 8;
 					}

ASCOfficeOdfFile/include/odf/odf_elements_type.h

@@ -260,6 +260,9 @@ enum ElementType
     typeStyleFooterLeft,
     typeStyleFootnoteSep,
 
+	typeLoextHeaderFirst,
+	typeLoextFooterFirst,
+
     typeStyleSectionProperties,
     typeStyleHeaderStyle,
     typeStyleFooterStyle,
@@ -598,6 +601,7 @@ enum ElementType
     typeChartStockRangeLine,
 	typeChartRegressionCurve,
 	typeChartEquation,
+	typeChartDateScale,
 
 	typeStyleChartProperties,
 

ASCOfficeOdfFile/linux/OdfFileReaderLib.pro

@@ -217,6 +217,7 @@ SOURCES += \
     ../src/odf/datatypes/bibliography.cpp \
     ../src/odf/datatypes/commandtype.cpp \
     ../src/odf/datatypes/styleprint.cpp \
+    ../src/odf/datatypes/charttimeunit.cpp \
     ../src/docx/xlsx_conditionalFormatting.cpp \
     ../src/docx/xlsx_dxfs.cpp \
     ../src/docx/docx_content_type.cpp \
@@ -478,6 +479,7 @@ HEADERS += \
     ../src/odf/datatypes/chartlabelposition.h \
     ../src/odf/datatypes/grandtotal.h \
     ../src/odf/datatypes/styleprint.h \
+    ../src/odf/datatypes/charttimeunit.h \
     ../src/docx/docx_content_type.h \
     ../src/docx/docx_conversion_context.h \
     ../src/docx/docx_conversion_state.h \

ASCOfficeOdfFile/linux/odffilereaderlib_odf_datatypes.cpp

@@ -131,3 +131,4 @@
 #include "../src/odf/datatypes/stylenumformat.cpp"
 #include "../src/odf/datatypes/bibliography.cpp"
 #include "../src/odf/datatypes/styleprint.cpp"
+#include "../src/odf/datatypes/charttimeunit.cpp"

ASCOfficeOdfFile/src/docx/docx_conversion_context.cpp

@@ -646,23 +646,30 @@ void docx_conversion_context::add_new_run(std::wstring parentStyleId)
 
 std::wstring docx_conversion_context::add_hyperlink(const std::wstring & href, bool draw)
 {
-	hyperlinks::_type_place type = hyperlinks::document_place;
-	
-		 if (current_process_comment_ == true)												type = hyperlinks::comment_place;
-	else if	(current_process_note_ == footNote	|| current_process_note_ == footNoteRefSet)	type = hyperlinks::footnote_place;
-	else if	(current_process_note_ == endNote	|| current_process_note_ == endNoteRefSet )	type = hyperlinks::endnote_place;
-	
+	oox::_rels_type_place type_place = get_type_place();
+		
 	std::wstring href_correct = xml::utils::replace_text_to_xml(href);
     XmlUtils::replace_all( href_correct, L" .", L".");//1 (130).odt
 	
-	return hyperlinks_.add(href_correct, type, draw);
+	return hyperlinks_.add(href_correct, type_place, draw);
 }
 hyperlinks::_ref  docx_conversion_context::last_hyperlink()
 {
 	return hyperlinks_.last();
 }
+_rels_type_place docx_conversion_context::get_type_place()
+{
+	if (current_process_comment_)					return oox::comment_place;
+	if (current_process_note_ == footNote || 
+		current_process_note_ == footNoteRefSet)	return oox::footnote_place;
+	if (current_process_note_ == endNote ||
+		current_process_note_ == endNoteRefSet )	return oox::endnote_place;
+	
+	if (process_headers_footers_)					return oox::header_footer_place;
 
-void docx_conversion_context::dump_hyperlinks(rels & Rels, hyperlinks::_type_place type)
+	return oox::document_place;
+}
+void docx_conversion_context::dump_hyperlinks(rels & Rels, _rels_type_place type)
 {
     hyperlinks_.dump_rels(Rels, type);
 }
@@ -728,9 +735,12 @@ void docx_conversion_context::end_document()
 
 ////////////////////////////////////////////////////////////////////////////
 	dump_bibliography();
-	dump_hyperlinks (notes_context_.footnotesRels(), hyperlinks::footnote_place);
-	dump_hyperlinks (notes_context_.endnotesRels(), hyperlinks::endnote_place);
-   
+	dump_hyperlinks (notes_context_.footnotesRels(), oox::footnote_place);
+	dump_hyperlinks (notes_context_.endnotesRels(), oox::endnote_place);
+
+	get_mediaitems()->dump_rels(notes_context_.footnotesRels(), oox::footnote_place);
+ 	get_mediaitems()->dump_rels(notes_context_.endnotesRels(), oox::endnote_place);
+  
 	output_document_->get_word_files().set_notes(notes_context_);
 ////////////////////////	
 	for (size_t i = 0; i < charts_.size(); i++)
@@ -898,21 +908,25 @@ namespace
         }
     }
 
-    std::wstring StyleDisplayName(const std::wstring & Name, const std::wstring & DisplayName, odf_types::style_family::type Type)
+    std::wstring StyleDisplayName(const std::wstring & Name, const std::wstring & DisplayName, odf_types::style_family::type Type, bool &bDisplayed)
     {
-        if (!DisplayName.empty())
+		bDisplayed = true;
+        if (false == DisplayName.empty())
             return DisplayName;
 
-		if (!Name.empty())
+		if (false == Name.empty())
+		{
+			bDisplayed = false;
             return Name;
+		}
         else
         {
             switch(Type)
             {
             case odf_types::style_family::Paragraph:
                 return L"Normal";
-                break;
             default:
+				bDisplayed = false;
                 return std::wstring(L"DStyle_") + boost::lexical_cast<std::wstring>(odf_types::style_family( Type) );
             }
         }
@@ -1113,11 +1127,9 @@ void docx_conversion_context::process_styles()
 
 		for (size_t i = 0; i < arStyles.size(); i++)
 		{
-            if (!arStyles[i]->is_automatic() && 
-					(
-					arStyles[i]->type() == odf_types::style_family::Paragraph ||
-					arStyles[i]->type() == odf_types::style_family::Text
-					))
+            if (false == arStyles[i]->is_automatic() && 
+					(arStyles[i]->type() == odf_types::style_family::Paragraph ||
+					 arStyles[i]->type() == odf_types::style_family::Text))
             {
                 const std::wstring id = styles_map_.get(arStyles[i]->name(), arStyles[i]->type());
                 _Wostream << L"<w:style w:styleId=\"" << id << L"\" w:type=\"" << StyleTypeOdf2Docx(arStyles[i]->type()) << L"\""; 
@@ -1127,7 +1139,8 @@ void docx_conversion_context::process_styles()
 				}
 				_Wostream << L">";
 
-                const std::wstring displayName = StyleDisplayName(arStyles[i]->name(), arStyles[i]->display_name(), arStyles[i]->type());
+				bool bDisplayed = (arStyles[i]->type() == odf_types::style_family::Paragraph);
+                const std::wstring displayName = StyleDisplayName(arStyles[i]->name(), arStyles[i]->display_name(), arStyles[i]->type(), bDisplayed);
 
 				_Wostream << L"<w:name w:val=\"" << XmlUtils::EncodeXmlString(displayName) << L"\"/>";
 
@@ -1136,12 +1149,13 @@ void docx_conversion_context::process_styles()
                     const std::wstring basedOnId = styles_map_.get(baseOn->name(), baseOn->type());
                     _Wostream << L"<w:basedOn w:val=\"" << basedOnId << "\"/>";
                 }
-                else if (!arStyles[i]->is_default() && styles_map_.check(L"", arStyles[i]->type()))
+                else if (false == arStyles[i]->is_default() && styles_map_.check(L"", arStyles[i]->type()))
                 {
+					bDisplayed = false;
                     const std::wstring basedOnId = styles_map_.get(L"", arStyles[i]->type());
                     _Wostream << L"<w:basedOn w:val=\"" << basedOnId << "\"/>";
                 }
-				else
+				if (bDisplayed)
 				{
 					_Wostream << L"<w:qFormat/>";
 				}
@@ -1187,7 +1201,7 @@ void docx_conversion_context::process_section(std::wostream & strm, odf_reader::
 	int count_columns = 1;
 	bool sep_columns = false;
 
-	oox::section_context::_section & section = get_section_context().get();
+	oox::section_context::_section & section = get_section_context().get_last();
 
 	if (!columns)
 	{
@@ -1285,7 +1299,7 @@ void docx_conversion_context::process_section(std::wostream & strm, odf_reader::
 }
 bool docx_conversion_context::process_page_properties(std::wostream & strm)
 {
-    if (is_next_dump_page_properties() || get_section_context().get().is_dump_)
+    if (is_next_dump_page_properties() || get_section_context().get_last().is_dump_)
     {
         std::wstring pageProperties = get_page_properties();
 		odf_reader::page_layout_instance * page_layout_instance_ = root()->odf_context().pageLayoutContainer().page_layout_by_name(pageProperties);
@@ -1463,14 +1477,14 @@ bool docx_conversion_context::get_page_break_before()
 
 void docx_conversion_context::add_page_properties(const std::wstring & StyleName)
 {
-	section_context::_section & s = section_context_.get();
+	section_context::_section & s = section_context_.get_last();
 	
 	s.page_properties_.push_back( StyleName);
 }
 
 std::wstring docx_conversion_context::get_page_properties()
 {
-	section_context::_section & s = section_context_.get();
+	section_context::_section & s = section_context_.get_last();
 
 	if (s.page_properties_.size() > 1)			return s.page_properties_[1];
 	else if (s.page_properties_.size() == 1)	return s.page_properties_[0];
@@ -1478,7 +1492,7 @@ std::wstring docx_conversion_context::get_page_properties()
 }
 void docx_conversion_context::remove_page_properties()
 {
-	section_context::_section & s = section_context_.get();
+	section_context::_section & s = section_context_.get_last();
 
 	if (s.page_properties_.size() > 1)
 	{
@@ -1974,7 +1988,34 @@ void section_context::add_section(const std::wstring & SectionName, const std::w
     _section newSec(SectionName, Style, PageProperties );
     sections_.push_back(newSec);
 }
+section_context::_section & section_context::get_first()		
+{ 
+	if (sections_.empty())
+		return main_section_;
+	else
+		return sections_[0]; 
+}
+section_context::_section & section_context::get_last()		
+{ 
+	if (sections_.empty())
+		return main_section_;
+	else
+		return sections_.back();
+}
+void section_context::remove_section()	
+{
+	if (sections_.empty()) return;
 
+	sections_.pop_back();
+	//sections_.erase(sections_.begin(), sections_.begin() + 1);
+	if (sections_.empty())
+	{
+		//после оканчания разметки секциями и начале (возобновлении) основного раздела нужен разрыв (хотя настройки страницы могут и не поменяться)
+		//щас разрыв на текущей странице
+		//todooo проверить - может типо если следующий будет заголовок - разорвать
+		main_section_.is_dump_ = false;
+	}
+}
 namespace 
 {
     // обработка Header/Footer
@@ -1993,8 +2034,8 @@ namespace
 		//слить если есть mediaitems, добавить релсы и обнулить их для основного документа.
 		rels internal_rels;
 
-		Context.get_mediaitems()->dump_rels(internal_rels);
-		Context.dump_hyperlinks(internal_rels, hyperlinks::document_place);
+		Context.get_mediaitems()->dump_rels(internal_rels, oox::header_footer_place);
+		Context.dump_hyperlinks(internal_rels, oox::header_footer_place);
 
 		Context.get_headers_footers().add(styleName, dbgStr, type, internal_rels);
 	}

ASCOfficeOdfFile/src/docx/docx_conversion_context.h

@@ -324,11 +324,10 @@ public:
     
 	struct _section 
 	{
-		_section() {is_dump_ = false;}
+		_section() : is_dump_(false){}
 		
-		_section(const std::wstring & SectionName, const std::wstring & Style, const std::wstring & PageProperties) 
+		_section(const std::wstring & SectionName, const std::wstring & Style, const std::wstring & PageProperties) : is_dump_(false)
 		{ 
-			is_dump_		= false;
 			name_			= SectionName;
 			style_			= Style;
 			page_properties_.push_back(PageProperties);
@@ -340,7 +339,7 @@ public:
 		
 		std::vector<std::wstring>	page_properties_;
 
-		bool						is_dump_;
+		bool						is_dump_ = false;
 	};
   
 	void add_section(const std::wstring & SectionName, const std::wstring & Style, const std::wstring & PageProperties);
@@ -349,27 +348,12 @@ public:
 	{ 
 		return sections_.empty(); 
 	}
-    _section & get()		
-	{ 
-		if (sections_.empty())
-			return main_section_;
-		else
-			return sections_[0]; 
-	}
-	void remove_section()	
-	{
-		if (sections_.empty()) return;
+    _section & get_first();
+    _section & get_last();
 
-		sections_.erase(sections_.begin(), sections_.begin() + 1);
-		if (sections_.empty())
-		{
-			//после оканчания разметки секциями и начале (возобновлении) основного раздела нужен разрыв (хотя настройки страницы могут и не поменяться)
-			//щас разрыв на текущей странице
-			//todooo проверить - может типо если следующий будет заголовок - разорвать
-			main_section_.is_dump_ = false;
-		}
-	}
-	std::wstring			dump_;
+	void remove_section();
+
+	std::wstring dump_;
   
 private:    
 	_section				main_section_;
@@ -798,10 +782,12 @@ public:
 
 	std::wstring		add_hyperlink	(const std::wstring & href, bool drawing);
     hyperlinks::_ref	last_hyperlink	();
-    void				dump_hyperlinks	(rels & Rels, hyperlinks::_type_place type);
+    void				dump_hyperlinks	(rels & Rels, _rels_type_place type);
 
     void dump_headers_footers	(rels & Rels) const;
     void dump_notes				(rels & Rels) const;
+
+	_rels_type_place get_type_place();
 	
 	void dump_bibliography();
 	std::wstring  dump_settings_document();

ASCOfficeOdfFile/src/docx/docx_drawing.cpp

@@ -195,6 +195,86 @@ void _docx_drawing::serialize_text(std::wostream & strm)
 	serialize_bodyPr(strm, L"wps");
 }
 
+//--------------------------------------------------------------------
+void docx_serialize_media_child(std::wostream & strm, _docx_drawing & val)
+{
+    CP_XML_WRITER(strm)    
+    {
+		CP_XML_NODE(L"pic:pic")
+		{
+			CP_XML_ATTR(L"xmlns:pic",L"http://schemas.openxmlformats.org/drawingml/2006/picture");
+			{
+				CP_XML_NODE(L"pic:nvPicPr")
+				{
+					CP_XML_NODE(L"pic:cNvPr")
+					{
+						CP_XML_ATTR(L"id", val.id + 1);
+						CP_XML_ATTR(L"name", val.name);
+					
+						//oox_serialize_action(CP_XML_STREAM(), val.action);
+					}
+					CP_XML_NODE(L"pic:cNvPicPr")
+					{
+						CP_XML_NODE(L"a:picLocks") CP_XML_ATTR(L"noChangeAspect",1);
+					}
+					CP_XML_NODE(L"pic:nvPr")
+					{
+						std::wstring strNode; 
+						
+						if		(val.type == typeVideo)	strNode = L"a:videoFile"; 
+						else if (val.type == typeAudio) strNode = L"a:audioFile"; 
+
+						if (false == strNode.empty())
+						{
+							CP_XML_NODE(strNode)
+							{
+								CP_XML_ATTR(L"r:link",	val.objectId);
+							}
+						}
+						if (false == val.extId.empty())
+						{
+							CP_XML_NODE(L"a:extLst")
+							{
+								CP_XML_NODE(L"a:ext")
+								{
+									CP_XML_ATTR(L"uri",	L"{DAA4B4D4-6D71-4841-9C94-3DE7FCFB9230}");
+									CP_XML_NODE(L"wp15:media")
+									{	
+										CP_XML_ATTR(L"xmlns:wp15", L"http://schemas.microsoft.com/office/word/2012/wordprocessingDrawing");
+										if (val.extExternal)
+										{
+											CP_XML_ATTR(L"r:link",	val.extId);
+										}
+										else
+										{
+											CP_XML_ATTR(L"r:embed",	val.extId);
+										}
+									}
+								}
+							}
+						}
+					}
+				}    
+			}
+			val.fill.bitmap->name_space = L"pic";
+			oox_serialize_fill(CP_XML_STREAM(), val.fill);
+
+			CP_XML_NODE(L"pic:spPr")
+			{
+				val.serialize_xfrm(CP_XML_STREAM());
+
+				CP_XML_NODE(L"a:prstGeom")
+				{
+					CP_XML_ATTR(L"prst", L"rect");
+					CP_XML_NODE(L"a:avLst");
+				}
+
+				oox_serialize_ln(CP_XML_STREAM(), val.additional);
+				oox_serialize_effects(CP_XML_STREAM(), val.additional);
+			}
+		}
+	}
+}
 //--------------------------------------------------------------------
 void docx_serialize_image_child(std::wostream & strm, _docx_drawing & val)
 {
@@ -211,6 +291,8 @@ void docx_serialize_image_child(std::wostream & strm, _docx_drawing & val)
 						//CP_XML_ATTR(L"desc text",L"");
 						CP_XML_ATTR(L"id", val.id + 1);
 						CP_XML_ATTR(L"name", val.name);
+					
+						//oox_serialize_action(CP_XML_STREAM(), val.action);
 					}
 					CP_XML_NODE(L"pic:cNvPicPr")
 					{
@@ -346,6 +428,11 @@ void docx_serialize_common(std::wostream & strm, _docx_drawing & val)
 					CP_XML_ATTR(L"uri", L"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup");
 					docx_serialize_group_child(CP_XML_STREAM(), val);
 				}				
+				else if (val.type == typeAudio || val.type == typeVideo || val.type == typeMedia)
+				{
+					CP_XML_ATTR(L"uri",L"http://schemas.openxmlformats.org/drawingml/2006/picture");
+					docx_serialize_media_child(CP_XML_STREAM(), val);
+				}
 				else if (val.type == typeImage)
 				{
 					CP_XML_ATTR(L"uri",L"http://schemas.openxmlformats.org/drawingml/2006/picture");

ASCOfficeOdfFile/src/docx/docx_package.cpp

@@ -144,9 +144,9 @@ void word_files::write(const std::wstring & RootPath)
 
 void word_files::update_rels(docx_conversion_context & Context)
 {
-    Context.get_mediaitems()->dump_rels(rels_files_.get_rel_file()->get_rels());
+	Context.get_mediaitems()->dump_rels(rels_files_.get_rel_file()->get_rels(), oox::document_place);
 	
-	Context.dump_hyperlinks		(rels_files_.get_rel_file()->get_rels(), hyperlinks::document_place);
+	Context.dump_hyperlinks		(rels_files_.get_rel_file()->get_rels(), oox::document_place);
     Context.dump_headers_footers(rels_files_.get_rel_file()->get_rels());
     Context.dump_notes			(rels_files_.get_rel_file()->get_rels());
 }

ASCOfficeOdfFile/src/docx/drawing_object_description.h

@@ -51,7 +51,7 @@ struct drawing_object_description
 {
 	bool									bNotes_;
 
-	oox::RelsType							type_;
+	oox::_rels_type							type_;
 
 	std::wstring							name_;	
 	std::wstring							descriptor_;	

ASCOfficeOdfFile/src/docx/hyperlinks.cpp

@@ -31,7 +31,6 @@
  */
 
 #include "hyperlinks.h"
-#include "oox_rels.h"
 
 #include <xml/utils.h>
 
@@ -48,7 +47,7 @@ hyperlinks::_ref  hyperlinks::last()
 	return r;
 }
 
-std::wstring hyperlinks::add(const std::wstring & href, _type_place type_place, bool drawing)
+std::wstring hyperlinks::add(const std::wstring & href, _rels_type_place type_place, bool drawing)
 {
 	std::wstring id = std::wstring(L"rHpId") + std::to_wstring(hrefs_.size() + 1);
 	
@@ -60,14 +59,14 @@ std::wstring hyperlinks::add(const std::wstring & href, _type_place type_place,
 }
 
 
-void hyperlinks::dump_rels(rels & Rels, _type_place type)
+void hyperlinks::dump_rels(rels & Rels, _rels_type_place type_place)
 {
     size_t i = 0;
     for (size_t i = 0; i < hrefs_.size(); i++)
     {
  		if (hrefs_[i].used_rels)continue; // уже использовали этот релс
 
-		if (hrefs_[i].type_place == type)
+		if (hrefs_[i].type_place == type_place)
 		{
 			Rels.add( relationship(hrefs_[i].id, L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", hrefs_[i].href, L"External" ) );
 			hrefs_[i].used_rels = true;

ASCOfficeOdfFile/src/docx/hyperlinks.h

@@ -31,40 +31,29 @@
  */
 #pragma once
 
-#include <vector>
-#include <string>
+#include "oox_rels.h"
 
 namespace cpdoccore { 
 namespace oox {
 
-class rels;
-
 class hyperlinks
 {
 public:
-	enum _type_place
-	{
-		document_place,
-		endnote_place,
-		footnote_place,
-		comment_place
-
-	};
 
 	struct _ref
 	{
-		std::wstring	href;
-		_type_place		type_place;
-		bool			drawing;
-		std::wstring	id;
-		bool			used_rels;
+		std::wstring		href;
+		_rels_type_place	type_place;
+		bool				drawing;
+		std::wstring		id;
+		bool				used_rels;
 	};
 
-    std::wstring add(const std::wstring & href, _type_place type_place, bool drawing);
+    std::wstring add(const std::wstring & href, _rels_type_place type_place, bool drawing);
 
 	_ref  last();
     
-	void dump_rels(rels & Rels, _type_place type);
+	void dump_rels(rels & Rels, _rels_type_place type_place);
 
 
 private:

ASCOfficeOdfFile/src/docx/measuredigits.cpp

@@ -34,47 +34,38 @@
 #include <boost/lexical_cast.hpp>
 #include <logging.h>
 
-#include <float.h>
-
 #include "../../../DesktopEditor/graphics/pro/Fonts.h"
 
 namespace cpdoccore {
 namespace utils {
 
-namespace 
+std::pair<double, double> GetMaxDigitSizePixelsImpl(const std::wstring & fontName, double fontSize, double dpi, long fontStyle, NSFonts::IFontManager *pFontManager)
 {
-    class Error : public std::exception {};    
-    class LoadFontError : public Error {};
-    class MeasureError : public Error {};
-}
+    if (pFontManager == NULL) return std::pair<double, double>(7., 8.);
 
-std::pair<float, float> GetMaxDigitSizePixelsImpl(const std::wstring & fontName, double fontSize, double dpi, long fontStyle, NSFonts::IFontManager *pFontManager)
-{
-    if (pFontManager == NULL) return std::pair<float, float>(7,8);
-
-   int hr = FALSE;
+	int hr = FALSE;
 
     if (FALSE == (hr = pFontManager->LoadFontByName(fontName, fontSize, fontStyle, dpi, dpi )))
 	{
         if (FALSE == (hr = pFontManager->LoadFontByName(L"Arial", fontSize, fontStyle, dpi, dpi )))
 		{
-            return std::pair<float, float>(7, 8);
+            return std::pair<double, double>(7, 8);
 		}
 	}
 
-    float maxWidth = 0;
-    float maxHeight = 0;
+    double maxWidth = 0;
+    double maxHeight = 0;
 
-	float minWidth = 0xffff;
-	float minHeight = 0xffff;
+	double minWidth = 0xffffffff;
+	double minHeight = 0xfffffff;
 
    // for (int i = 0; i <= 9; ++i)
     {
 		//if (FALSE == (hr = pFontManager->LoadString2( std::to_wstring(i), 0, 0)))
 		//	return std::pair<float, float>(7,8);
 
-		if (FALSE == (hr = pFontManager->LoadString2( L"0123456789abcdefghijklmnopqrstuvwxyz" , 0, 0)))
-			return std::pair<float, float>(7,8);
+		if (FALSE == (hr = pFontManager->LoadString2( L"0123456789abcdefghijklmnopqrstuvwxyz" , 0, 0)))//
+			return std::pair<double, double>(7., 8.);
 
 		TBBox box;
 		try
@@ -82,12 +73,12 @@ std::pair<float, float> GetMaxDigitSizePixelsImpl(const std::wstring & fontName,
            box = pFontManager->MeasureString();
 		}catch(...)
 		{
-            return std::pair<float, float>(7,8);
+            return std::pair<double, double>(7.,8.);
 		}
 
 		if (box.fMaxX < -0xffff+1 || box.fMaxY < -0xffff+1 ||
 			box.fMinX > 0xffff-1 || box.fMinY > 0xffff-1)		
-				return std::pair<float, float>(7,8);
+				return std::pair<double, double>(7., 8. );
           
         if (box.fMaxX - box.fMinX > maxWidth)   maxWidth = box.fMaxX - box.fMinX;
         if (box.fMaxY - box.fMinY > maxHeight)  maxHeight = box.fMaxY - box.fMinY;
@@ -96,12 +87,13 @@ std::pair<float, float> GetMaxDigitSizePixelsImpl(const std::wstring & fontName,
         if (box.fMaxY - box.fMinY < minHeight)  minHeight = box.fMaxY - box.fMinY;
     }
 
-	double width = (minWidth + 2 * maxWidth) /36. /3.;
-	return std::pair<float, float>(width, maxHeight);
+    double width = (minWidth + 2 * maxWidth) /36. /3.;
+	//double width = (minWidth + 2 * maxWidth) / 5./*/36.*/ /3.;
+	return std::pair<double, double>(width, maxHeight);
 }
 
 
-std::pair<float, float> GetMaxDigitSizePixels(const std::wstring & fontName, double fontSize, double dpi, long fontStyle, NSFonts::IApplicationFonts *appFonts)
+std::pair<double, double> GetMaxDigitSizePixels(const std::wstring & fontName, double fontSize, double dpi, long fontStyle, NSFonts::IApplicationFonts *appFonts)
 {
     try 
     {
@@ -111,7 +103,7 @@ std::pair<float, float> GetMaxDigitSizePixels(const std::wstring & fontName, dou
         {
             NSFonts::IFontManager *pFontManager = appFonts->GenerateFontManager();
 
-            std::pair<float, float> val = GetMaxDigitSizePixelsImpl(fontName, fontSize, dpi, fontStyle, pFontManager);
+            std::pair<double, double> val = GetMaxDigitSizePixelsImpl(fontName, fontSize, dpi, fontStyle, pFontManager);
 
             if (pFontManager)
             {                
@@ -126,7 +118,7 @@ std::pair<float, float> GetMaxDigitSizePixels(const std::wstring & fontName, dou
     {
         // TODO: default value!
     }    
-	return std::pair<float, float>(7, 8);
+	return std::pair<double, double>(7., 8.);
 }
 
 }

ASCOfficeOdfFile/src/docx/measuredigits.h

@@ -42,7 +42,7 @@ namespace NSFonts
 namespace cpdoccore {
 namespace utils {
 
-    std::pair<float, float> GetMaxDigitSizePixels(const std::wstring & fontName, double fontSize, double dpi, long fontStyle, NSFonts::IApplicationFonts *appFonts);
+    std::pair<double, double> GetMaxDigitSizePixels(const std::wstring & fontName, double fontSize, double dpi, long fontStyle, NSFonts::IApplicationFonts *appFonts);
 
 }
 }

ASCOfficeOdfFile/src/docx/mediaitems.cpp

@@ -59,18 +59,10 @@ bool is_internal(const std::wstring & uri, const std::wstring & packetRoot)
 	return NSFile::CFileBinary::Exists(resultPath) || NSDirectory::Exists(mediaPath);
 }
 
-mediaitems::item::item(	std::wstring const & _href,
-                       RelsType _type,
-                       std::wstring const & _outputName,
-						bool _mediaInternal,
-						std::wstring const & _Id
-					   )
-           : href(_href),
-           type(_type),
-           outputName(_outputName),
-           mediaInternal(_mediaInternal),
-		   Id(_Id),
-           valid(true) //вообще говоря даже если файл покоцанный то мы все равно обязаны перенести "объект"
+mediaitems::item::item(std::wstring const & _href,_rels_type _type, std::wstring const & _outputName,
+						bool _mediaInternal, std::wstring const & _Id, _rels_type_place type_place_)
+           : href(_href), type(_type), outputName(_outputName), mediaInternal(_mediaInternal), Id(_Id), valid(true), type_place(type_place_)
+		   //вообще говоря даже если файл покоцанный то мы все равно обязаны перенести "объект"
 {    
 	count_add = 1;
 	count_used = 0;
@@ -102,13 +94,13 @@ void mediaitems::set_font_directory(std::wstring pathFonts)
         applicationFonts_->InitializeFromFolder(pathFonts);
 }
 
-std::wstring mediaitems::add_or_find(const std::wstring & href, RelsType type, bool & isInternal)
+std::wstring mediaitems::add_or_find(const std::wstring & href, _rels_type type, bool & isInternal, _rels_type_place type_place)
 {
     std::wstring ref;
-    return add_or_find(href, type, isInternal, ref);
+    return add_or_find(href, type, isInternal, ref, type_place);
 }
 
-std::wstring static get_default_file_name(RelsType type)
+std::wstring static get_default_file_name(_rels_type type)
 {
     switch (type)
     {
@@ -136,7 +128,7 @@ std::wstring static get_default_file_name(RelsType type)
         return L"";
     }
 }
-std::wstring mediaitems::create_file_name(const std::wstring & uri, RelsType type, bool & isInternal, size_t Num)
+std::wstring mediaitems::create_file_name(const std::wstring & uri, _rels_type type, bool & isInternal, size_t Num)
 {
 	if (uri.empty()) return L"";
 
@@ -206,7 +198,7 @@ std::wstring mediaitems::detectImageFileExtension(const std::wstring &fileName)
 	return XmlUtils::GetLower(sExt);
 }
 
-std::wstring mediaitems::add_or_find(const std::wstring & href, RelsType type, bool & isInternal, std::wstring & ref)
+std::wstring mediaitems::add_or_find(const std::wstring & href, _rels_type type, bool & isInternal, std::wstring & ref, _rels_type_place type_place)
 {
 	bool isMediaInternal = true;
 	std::wstring sub_path = L"media/";
@@ -254,6 +246,8 @@ std::wstring mediaitems::add_or_find(const std::wstring & href, RelsType type, b
 	std::wstring id;
     for (size_t i = 0 ; i < items_.size(); i++)
     {
+		if (items_[i].type_place != type_place) continue;
+
 		if ((items_[i].href == inputPath && !inputPath.empty()) || (items_[i].type == type && inputPath.empty()))
 		{
 			id			= items_[i].Id;
@@ -313,13 +307,18 @@ std::wstring mediaitems::add_or_find(const std::wstring & href, RelsType type, b
 			count_shape++;
 		}
 		
-		items_.push_back( item(inputPath, type, xml::utils::replace_text_to_xml(outputPath), isMediaInternal, id) );
+		items_.push_back( item(inputPath, type, xml::utils::replace_text_to_xml(outputPath), isMediaInternal, id, type_place) );
 	}
 
   	ref = outputPath;
     isInternal = isMediaInternal;
 	return id;
 }
+void mediaitems::add_rels(bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type, _rels_type_place type_place)
+{
+	items_.push_back( item(L"", type, ref, isInternal, rid, type_place) );
+}
+
 std::wstring mediaitems::add_control_props(std::wstring & oox_target)
 {
     const bool isMediaInternal = true;
@@ -330,10 +329,10 @@ std::wstring mediaitems::add_control_props(std::wstring & oox_target)
 
 	oox_target = std::wstring(L"ctrlProp") + std::to_wstring(count_control) + L".xml";
 		
-	items_.push_back( item(L"", typeControlProps, oox_target, isMediaInternal, rId) );
+	items_.push_back( item(L"", typeControlProps, oox_target, isMediaInternal, rId, oox::document_place) );
     return rId;
 }
-void mediaitems::dump_rels(rels & Rels)
+void mediaitems::dump_rels(rels & Rels, _rels_type_place type_place)
 {
     for (size_t i = 0; i < items_.size(); i++)
     {
@@ -341,8 +340,10 @@ void mediaitems::dump_rels(rels & Rels)
 		if ( items_[i].type == typeShape ) continue; 
 		if ( items_[i].type == typeGroupShape ) continue; 
 
+		if (items_[i].type_place != type_place) continue;
+		
 		if (items_[i].count_used >= items_[i].count_add) continue; // уже использовали этот релс выше(колонтитул ....)
-        
+
 		Rels.add( relationship(
                 items_[i].Id, 
                 get_rel_type (items_[i].type), 

ASCOfficeOdfFile/src/docx/mediaitems.h

@@ -46,25 +46,28 @@ namespace oox {
 class mediaitems
 {
 public:
+
     mediaitems(const std::wstring & odfPacket);
 	virtual ~mediaitems();
 
     struct item 
     {
-        item(	std::wstring const &	_href,
-				RelsType				_type,
-				std::wstring const &	_outputName,
-				bool					_mediaInternal,
-				std::wstring const &	_Id);
+        item(	std::wstring const &	href,
+				_rels_type				type,
+				std::wstring const &	outputName,
+				bool					mediaInternal,
+				std::wstring const &	Id,
+				_rels_type_place		type_place);
 
-        std::wstring	href;
-        RelsType		type;
-        std::wstring	outputName;
-        bool			mediaInternal;
-        bool			valid;
-		std::wstring	Id;
-		int				count_used;
-		int				count_add;
+        std::wstring		href;
+        _rels_type			type;
+		_rels_type_place	type_place;
+        std::wstring		outputName;
+        bool				mediaInternal;
+        bool				valid;
+		std::wstring		Id;
+		int					count_used;
+		int					count_add;
     };
     typedef std::vector< item > items_array;
 	
@@ -83,15 +86,17 @@ public:
 	void set_font_directory(std::wstring pathFonts);
 	NSFonts::IApplicationFonts *applicationFonts() {return applicationFonts_;}
 
-    std::wstring add_or_find(const std::wstring & href, RelsType type, bool & isInternal);//возможны ссылки на один и тот же объект
-    std::wstring add_or_find(const std::wstring & href, RelsType type, bool & isInternal, std::wstring & ref);
+    std::wstring add_or_find(const std::wstring & href, _rels_type type, bool & isInternal, _rels_type_place type_place);//возможны ссылки на один и тот же объект
+    std::wstring add_or_find(const std::wstring & href, _rels_type type, bool & isInternal, std::wstring & ref, _rels_type_place type_place);
     
+	void add_rels(bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type, _rels_type_place type_place);
 	std::wstring add_control_props	(std::wstring & oox_target);
 
-	void dump_rels(rels & Rels);
-    items_array & items() { return items_; }
+	void dump_rels(rels & Rels, _rels_type_place type);
+    
+	items_array & items() { return items_; }
 
-	static std::wstring get_rel_type(RelsType type)
+	static std::wstring get_rel_type(_rels_type type)
 	{
 		switch (type)
 		{
@@ -111,7 +116,7 @@ public:
 				return L"";
 		}
 	}
-	static RelsType detectMediaType(const std::wstring & fileName)
+	static _rels_type detectMediaType(const std::wstring & fileName)
 	{
 		size_t pos = fileName.rfind(L".");
 
@@ -139,7 +144,7 @@ public:
 	}
 
 private:
-	std::wstring create_file_name			(const std::wstring & uri, RelsType type, bool & isInternal, size_t Num);
+	std::wstring create_file_name			(const std::wstring & uri, _rels_type type, bool & isInternal, size_t Num);
 	std::wstring detectImageFileExtension	(const std::wstring &fileName);
    
 	items_array		items_;

ASCOfficeOdfFile/src/docx/oox_chart_axis.cpp

@@ -137,7 +137,7 @@ void oox_axis_content::oox_serialize_content(std::wostream & _Wostream)
 		{
 			CP_XML_NODE(L"c:orientation")
 			{
-				odf_reader::GetProperty(content_.properties_,L"reverse-direction",boolVal);
+				odf_reader::GetProperty(content_.properties_, L"reverse-direction",boolVal);
 				if ((boolVal == true) && (boolVal.get()==true))
 				{
 					CP_XML_ATTR(L"val", "maxMin");
@@ -147,7 +147,7 @@ void oox_axis_content::oox_serialize_content(std::wostream & _Wostream)
 					CP_XML_ATTR(L"val", "minMax");//default
 				}
 			}
-			odf_reader::GetProperty(content_.properties_,L"maximum", doubleVal);
+			odf_reader::GetProperty(content_.properties_, L"maximum", doubleVal);
 			if (doubleVal)
 			{
 				CP_XML_NODE(L"c:max")
@@ -189,16 +189,31 @@ void oox_axis_content::oox_serialize_content(std::wostream & _Wostream)
 				CP_XML_ATTR(L"val",L"l");//  "b" | "l" |  "r" |  "t"// == bottom left right top
 		}
 		//oox_serialize_ln(_Wostream, content_.graphic_properties_);
+		_CP_OPT(std::wstring) strNumFormat, strPercentFormat;
+		_CP_OPT(bool) bLinkData;
+		_CP_OPT(int) nTypeFormat;
 
-		odf_reader::GetProperty(content_.properties_, L"num_format", strVal);
-		odf_reader::GetProperty(content_.properties_, L"link-data-style-to-source", boolVal);
+		odf_reader::GetProperty(content_.properties_, L"num_format", strNumFormat);
+		odf_reader::GetProperty(content_.properties_, L"percentage_num_format", strPercentFormat);
+		odf_reader::GetProperty(content_.properties_, L"data-label-number", nTypeFormat);
+		odf_reader::GetProperty(content_.properties_, L"link-data-style-to-source", bLinkData);
 
-		if ((strVal) && (strVal->length() > 1))
+		std::wstring formatCode;
+		if ((nTypeFormat) && (*nTypeFormat == 2) && strPercentFormat)
+		{
+			formatCode = *strPercentFormat;
+		}
+		else if ((strNumFormat) && (strNumFormat->length() > 1))
+		{
+			formatCode = *strNumFormat;
+		}
+
+		if (formatCode.length() > 1)
 		{
 			CP_XML_NODE(L"c:numFmt")
 			{
-				CP_XML_ATTR(L"formatCode", *strVal);
-				CP_XML_ATTR(L"sourceLinked", boolVal.get_value_or(true));
+				CP_XML_ATTR(L"formatCode", formatCode);
+				CP_XML_ATTR(L"sourceLinked", bLinkData.get_value_or(true));
 			}
 		}
 
@@ -228,7 +243,7 @@ void oox_axis_content::oox_serialize_content(std::wostream & _Wostream)
 				{
 					shape.oox_serialize(CP_XML_STREAM());
 				}
-				odf_reader::GetProperty(content_.properties_,L"display_label",boolVal);
+				odf_reader::GetProperty(content_.properties_, L"display_label",boolVal);
 				if ((boolVal == true) && (boolVal.get()==true))
 				{
 					CP_XML_NODE(L"c:minorTickMark")
@@ -241,7 +256,7 @@ void oox_axis_content::oox_serialize_content(std::wostream & _Wostream)
 		
 		title.oox_serialize(_Wostream);
 		
-		odf_reader::GetProperty(content_.properties_,L"display_label", boolVal);
+		odf_reader::GetProperty(content_.properties_, L"display_label", boolVal);
 		if ((boolVal == true) && (boolVal.get()==true))
 		{
 			CP_XML_NODE(L"c:tickLblPos")
@@ -250,7 +265,7 @@ void oox_axis_content::oox_serialize_content(std::wostream & _Wostream)
 			}
 		}		
 		
-		shape.set(content_.graphic_properties_,content_.fill_) ;
+		shape.set(content_.graphic_properties_, content_.fill_) ;
 		shape.oox_serialize(_Wostream);
 
 		oox_serialize_default_text(_Wostream, content_.text_properties_);

ASCOfficeOdfFile/src/docx/oox_chart_context.cpp

@@ -41,22 +41,8 @@
 namespace cpdoccore {
 namespace oox {
 
-class oox_chart_context::Impl
+oox_chart_context::oox_chart_context(mediaitems_ptr & m, std::wstring name) : mediaitems_(m), no_used_local_tables_(false)
 {
-public:
-    Impl(std::wstring name){}
-    std::wstring name_;
-
-    std::wstringstream  chartData_;
-
-    std::wstring drawingName_;
-    std::wstring drawingId_;
-};
-
-oox_chart_context::oox_chart_context(mediaitems_ptr & m, std::wstring name) :
-		impl_(new oox_chart_context::Impl( name)), mediaitems_(m)
-{
-	
 }
 
 void oox_chart_context::reset_fill(oox::_oox_fill &f)
@@ -65,7 +51,7 @@ void oox_chart_context::reset_fill(oox::_oox_fill &f)
 	{
 		bool isInternal = true;
 		std::wstring ref;
-		f.bitmap->rId = mediaitems_->add_or_find(f.bitmap->xlink_href_, typeImage, isInternal, ref); 
+		f.bitmap->rId = mediaitems_->add_or_find(f.bitmap->xlink_href_, typeImage, isInternal, ref, oox::chart_place); 
 
 		rels_.push_back(_rel(isInternal, f.bitmap->rId, ref, typeImage));
 	}
@@ -75,7 +61,7 @@ void oox_chart_context::set_externalData(const std::wstring & href)
 	bool isInternal = true;
 	std::wstring href_out;
 	
-	externalDataId_ = mediaitems_->add_or_find(href, typeMsObject, isInternal, href_out);
+	externalDataId_ = mediaitems_->add_or_find(href, typeMsObject, isInternal, href_out, oox::chart_place);
 	rels_.push_back(_rel(isInternal, externalDataId_, href_out, typeMsObject));
 }
 void oox_chart_context::set_userShapes(std::pair<std::wstring, std::wstring> &link)
@@ -84,10 +70,6 @@ void oox_chart_context::set_userShapes(std::pair<std::wstring, std::wstring> &li
 	userShapesId_ = link.second;
 	rels_.push_back(_rel(isInternal, userShapesId_, link.first, typeChartUserShapes));
 }
-std::wostream & oox_chart_context::chartData()
-{
-    return impl_->chartData_;
-}
 
 void oox_chart_context::dump_rels(rels & Rels)
 {
@@ -146,9 +128,12 @@ void oox_chart_context::serialize(std::wostream & strm)
 		
 			CP_XML_NODE(L"c:lang")
 			{
-				CP_XML_ATTR(L"val",L"en-US");
+				CP_XML_ATTR(L"val", L"en-US");
+			}
+			CP_XML_NODE(L"c:roundedCorners")
+			{
+				CP_XML_ATTR(L"val", 0);
 			}
-
 			if (pivot_source_.empty() == false)
 			{
 				set_cache_only(true);

ASCOfficeOdfFile/src/docx/oox_chart_context.h

@@ -45,7 +45,6 @@
 namespace cpdoccore { 
 namespace oox {
 
-
 class oox_chart_context;
 typedef _CP_PTR(oox_chart_context) oox_chart_context_ptr;
 
@@ -56,8 +55,6 @@ public:
     oox_chart_context(mediaitems_ptr & mediaitems_, std::wstring name);
     ~oox_chart_context();
 
-	std::wostream & chartData();
-
 	void reset_fill(oox::_oox_fill &fill_);
 
 	void serialize(std::wostream & strm);
@@ -67,9 +64,10 @@ public:
 	{
 		pivot_source_ = source;
 	}
-	void set_title(odf_reader::chart::title & t)
+	void set_title(odf_reader::chart::title & t, odf_reader::chart::title & sub)
 	{
 		title_.set_content(t);
+		title_.set_sub_content(sub);
 	}
 	void add_axis(int type, odf_reader::chart::axis & content)
 	{
@@ -125,12 +123,10 @@ public:
 		plot_area_.properties_3d_	= prop_3d; 
 		plot_area_.fill_			= fill; 
 	}
+	bool no_used_local_tables_;
 
 	void set_cache_only	(bool val);
 private:
-    class Impl;
-    _CP_SCOPED_PTR(Impl) impl_;
-	
 	mediaitems_ptr						mediaitems_;
 	std::vector<_rel>					rels_;
 	
@@ -145,18 +141,6 @@ private:
 	std::vector<odf_reader::_property>	graphic_properties_;
 	_oox_fill							fill_;
 };
-//autoTitleDeleted (Auto Title Is Deleted) §21.2.2.7
-//backWall (Back Wall) §21.2.2.11
-//dispBlanksAs (Display Blanks As) §21.2.2.42
-//extLst (Chart Extensibility) §21.2.2.64
-//floor (Floor) §21.2.2.69
-//legend (Legend) §21.2.2.93
-//pivotFmts (Pivot Formats) §21.2.2.143
-//plotArea (Plot Area) §21.2.2.145
-//plotVisOnly (Plot Visible Only) §21.2.2.146
-//showDLblsOverMax (Show Data Labels over Maximum) §21.2.2.180
-//sideWall (Side Wall) §21.2.2.191
-//title (Title) §21.2.2.210
-//view3D (View In 3D)
+
 }
 }

ASCOfficeOdfFile/src/docx/oox_chart_legend.h

@@ -40,7 +40,7 @@
 namespace cpdoccore {
 namespace oox {
 
-class oox_chart_legend: boost::noncopyable
+class oox_chart_legend : boost::noncopyable
 {
 public:
 	oox_chart_legend(){}

ASCOfficeOdfFile/src/docx/oox_chart_series.cpp

@@ -55,9 +55,9 @@ oox_chart_series::oox_chart_series()
 	values_[3].type	= L"c:yVal";
 	values_[4].type	= L"c:bubbleSize";//заместо оси х!!!!
 
-	iSymbolMarkerType_	= 0;
-	bLocalTable_		= false;
-	labelPosEnabled_	= true;
+	iSymbolMarkerType_		= 0;
+	bCacheOnly_				= false;
+	labelPosEnabled_		= true;
 }
 void oox_chart_series::setName(const std::wstring &value)
 {
@@ -93,7 +93,7 @@ void oox_chart_series::setFormula(int ind, const std::wstring &value, const std:
 
 void oox_chart_series::set_cache_only (bool val)
 {
-	bLocalTable_ = val;
+	bCacheOnly_ = val;
 }
 
 void oox_chart_series::parse_properties()
@@ -127,14 +127,32 @@ void oox_chart_series::parse_properties()
 		
 		data_labels_->set_showCatName(*boolVal); 
 	}
-	odf_reader::GetProperty(content_.properties_, L"data-label-number", intVal);
+	_CP_OPT(std::wstring) strNumFormat, strPercentFormat;
+	_CP_OPT(bool) bLinkData;
+	_CP_OPT(int) nTypeFormat;
 
-	if (intVal)
+	odf_reader::GetProperty(content_.properties_, L"num_format", strNumFormat);
+	odf_reader::GetProperty(content_.properties_, L"percentage_num_format", strPercentFormat);
+	odf_reader::GetProperty(content_.properties_, L"data-label-number", nTypeFormat);
+	odf_reader::GetProperty(content_.properties_, L"link-data-style-to-source", bLinkData);
+
+	std::wstring formatCode = strNumFormat.get_value_or(L"");
+	if (nTypeFormat)
 	{
 		if (!data_labels_)	data_labels_ = oox_data_labels();
 		
-		if (*intVal == 1)	data_labels_->set_showVal(true); 
-		if (*intVal == 2)	data_labels_->set_showPercent(true); 		
+		if (*nTypeFormat == 1)	data_labels_->set_showVal(true); 
+		if (*nTypeFormat == 2)
+		{
+			data_labels_->set_showPercent(true); 		
+			if (strPercentFormat)
+				formatCode = *strPercentFormat;
+		}
+	}
+	if (false == formatCode.empty())
+	{
+		if (!data_labels_)	data_labels_ = oox_data_labels();
+		data_labels_->set_formatCode(formatCode, bLinkData.get_value_or(true));
 	}
 	odf_reader::GetProperty(content_.properties_, L"label-position", intVal);
 	if (intVal && labelPosEnabled_)
@@ -149,8 +167,14 @@ void oox_chart_series::setValues(int ind, std::vector<std::wstring> & values)
 {
 	values_[ind].present = true;
 
-	if (ind == 0)	values_[ind].strRef_.present = true;
-	else			values_[ind].numRef_.present = true;
+	if (ind == 0)
+	{
+		values_[ind].strRef_.present = true;
+	}
+	else
+	{
+		values_[ind].numRef_.present = true;
+	}
 
 	for (size_t i = 0; i < values.size(); i++)
 	{
@@ -227,37 +251,45 @@ void oox_chart_series::oox_serialize_common(std::wostream & _Wostream)
 		{
 			CP_XML_NODE(L"c:tx")
 			{
-				CP_XML_NODE(L"c:strRef")
+				if (false == label_.formula.empty())
 				{
-					if (!label_.formula.empty())
+					CP_XML_NODE(L"c:strRef")
 					{
 						CP_XML_NODE(L"c:f")
 						{
 							CP_XML_STREAM() << label_.formula;
 						}
-					}
-					if (false == label_.str_cache.empty())
-					{
-						CP_XML_NODE(L"c:strCache")
+						if (false == label_.str_cache.empty())
 						{
-							CP_XML_NODE(L"c:ptCount")
+							CP_XML_NODE(L"c:strCache")
 							{
-								CP_XML_ATTR(L"val", label_.str_cache.size());
-							}
-							for (size_t i = 0; i < label_.str_cache.size(); i++)
-							{
-								CP_XML_NODE(L"c:pt")
+								CP_XML_NODE(L"c:ptCount")
 								{
-									CP_XML_ATTR(L"idx", i);
-									CP_XML_NODE(L"c:v")
+									CP_XML_ATTR(L"val", label_.str_cache.size());
+								}
+								for (size_t i = 0; i < label_.str_cache.size(); i++)
+								{
+									CP_XML_NODE(L"c:pt")
 									{
-										CP_XML_STREAM() <<  label_.str_cache[i];
+										CP_XML_ATTR(L"idx", i);
+										CP_XML_NODE(L"c:v")
+										{
+											CP_XML_STREAM() <<  label_.str_cache[i];
+										}
 									}
 								}
 							}
 						}
 					}
 				}
+				else if (false == label_.str_cache.empty())
+				{
+					CP_XML_NODE(L"c:v")
+					{
+						CP_XML_STREAM() <<  label_.str_cache[0];
+					}
+				}
+
 			}
 		}
 
@@ -265,7 +297,7 @@ void oox_chart_series::oox_serialize_common(std::wostream & _Wostream)
 		{
 			if (values_[i].present)
 			{
-				if (bLocalTable_)
+				if (bCacheOnly_)
 				{
 					if (values_[i].numRef_.present && values_[i].numRef_.num_cache_count == 0)
 					{
@@ -279,16 +311,13 @@ void oox_chart_series::oox_serialize_common(std::wostream & _Wostream)
 				CP_XML_NODE(values_[i].type)
 				{
 
-					if (values_[i].numRef_.present && !bLocalTable_)
+					if (values_[i].numRef_.present && false == values_[i].numRef_.formula.empty())
 					{
 						CP_XML_NODE(L"c:numRef")
 						{
 							CP_XML_NODE(L"c:f")
 							{
-								if (values_[i].numRef_.formula.empty())
-									CP_XML_CONTENT(L"label");
-								else
-									CP_XML_CONTENT(values_[i].numRef_.formula);
+								CP_XML_CONTENT(values_[i].numRef_.formula);
 							}
 						
 							if (values_[i].numRef_.num_cache_count > 0)
@@ -364,16 +393,13 @@ void oox_chart_series::oox_serialize_common(std::wostream & _Wostream)
 							}
 						}
 					}
-					else if (values_[i].strRef_.present && !bLocalTable_)
+					else if (values_[i].strRef_.present && false == values_[i].strRef_.formula.empty())
 					{
 						CP_XML_NODE(L"c:strRef")
 						{
 							CP_XML_NODE(L"c:f")
 							{
-								if (values_[i].strRef_.formula.empty())
-									CP_XML_CONTENT(L"label");
-								else
-									CP_XML_CONTENT(values_[i].strRef_.formula);
+								CP_XML_CONTENT(values_[i].strRef_.formula);
 							}
 							CP_XML_NODE(L"c:strCache")
 							{
@@ -466,7 +492,7 @@ void oox_chart_series::oox_serialize_common(std::wostream & _Wostream)
 
 			}
 		}
-		if (!content_.text_properties_.empty())
+		if (!content_.text_properties_)
 		{
 			if (!data_labels_) data_labels_ = oox_data_labels();
 
@@ -500,7 +526,7 @@ void oox_chart_series::oox_serialize_common(std::wostream & _Wostream)
 						shape.oox_serialize(CP_XML_STREAM());
 					}
 
-					if (!content_.points_[i].text_properties_.empty())
+					if (!content_.points_[i].text_properties_)
 					{
 						if (!data_labels_) data_labels_ = oox_data_labels();
 

ASCOfficeOdfFile/src/docx/oox_chart_series.h

@@ -62,7 +62,9 @@ public:
 	int							id_;
 	std::wstring				name_;	
 	int							iSymbolMarkerType_;
-	bool						bLocalTable_;
+
+	bool						bCacheOnly_; // used embedded or only cache values
+
 	_CP_OPT(oox_data_labels)	data_labels_;
 	
 	void setName(const std::wstring &value);

ASCOfficeOdfFile/src/docx/oox_chart_shape.cpp

@@ -36,11 +36,16 @@
 #include "oox_chart_shape.h"
 #include "oox_drawing.h"
 
+#include "../odf/odfcontext.h"
+#include "../odf/style_text_properties.h"
+
 namespace cpdoccore {
 namespace oox {
 
 void oox_chart_shape::oox_serialize(std::wostream & _Wostream)
 {
+	if (!bEnabled) return;
+
 	CP_XML_WRITER(_Wostream)
     {
 		CP_XML_NODE(L"c:spPr")
@@ -52,15 +57,16 @@ void oox_chart_shape::oox_serialize(std::wostream & _Wostream)
 
 }
 
-void oox_chart_shape::set(std::vector<odf_reader::_property> & prop,_oox_fill & fill)
+void oox_chart_shape::set(std::vector<odf_reader::_property> & prop, _oox_fill & fill)
 {
+	bEnabled = true;
 	content_ = prop;
 	fill_ = fill;
 }
 
-void oox_serialize_default_text(std::wostream & _Wostream, std::vector<odf_reader::_property>& properties)
+void oox_serialize_default_text(std::wostream & _Wostream, odf_reader::text_format_properties_content_ptr properties)
 {
-	if (properties.size() < 1)return;
+	if (!properties) return;
 
 	CP_XML_WRITER(_Wostream)
     {
@@ -72,27 +78,8 @@ void oox_serialize_default_text(std::wostream & _Wostream, std::vector<odf_reade
 			{
 				CP_XML_NODE(L"a:pPr")
 				{
-					CP_XML_NODE(L"a:defRPr")
-					{							
-						_CP_OPT(double) dVal;
-						_CP_OPT(int) iVal;	
-						_CP_OPT(std::wstring) sVal;
-
-						if (odf_reader::GetProperty(properties, L"font-size",dVal))
-							CP_XML_ATTR(L"sz", (int)(dVal.get()*100));
-						
-						if ((odf_reader::GetProperty(properties, L"font-style",iVal)) && (*iVal >0))
-							CP_XML_ATTR(L"i", "true");
-						
-						if ((odf_reader::GetProperty(properties, L"font-weight",iVal)) && (*iVal >0))
-							CP_XML_ATTR(L"b", "true");		
-				
-						if (odf_reader::GetProperty(properties, L"font-color",sVal))
-							CP_XML_NODE(L"a:solidFill")	
-							{
-								CP_XML_NODE(L"a:srgbClr"){CP_XML_ATTR(L"val", sVal.get());}
-							}
-					}
+					odf_reader::fonts_container fonts;
+					properties->oox_serialize(CP_XML_STREAM(), true, fonts, true);
 
 				}
 			}

ASCOfficeOdfFile/src/docx/oox_chart_shape.h

@@ -39,19 +39,27 @@
 #include "oox_drawing_fills.h"
             
 namespace cpdoccore {
+
+namespace odf_reader {
+
+	class text_format_properties_content;
+	typedef boost::shared_ptr<text_format_properties_content> text_format_properties_content_ptr;
+}
+
 namespace oox {
 
-void oox_serialize_default_text(std::wostream & _Wostream, std::vector<odf_reader::_property>& properties);
+void oox_serialize_default_text(std::wostream & _Wostream, odf_reader::text_format_properties_content_ptr properties);
 
 class oox_chart_shape : boost::noncopyable
 {
 public:
-	oox_chart_shape(){}
+	oox_chart_shape() : bEnabled ( false) {}
 	~oox_chart_shape(){}
 
 	void set(std::vector<odf_reader::_property> & prop,_oox_fill & fill); 
     void oox_serialize(std::wostream & _Wostream);
 			
+	bool bEnabled;
 private:
 	std::vector<odf_reader::_property>	content_;
 	_oox_fill							fill_;

ASCOfficeOdfFile/src/docx/oox_data_labels.cpp

@@ -49,18 +49,19 @@ oox_data_labels::oox_data_labels()//подписи на значениях
 	showPercent_		= false;
 	showSerName_		= false;
 	showVal_			= false;
+	linkData_			= true;
 
 	position_			= -1; //not set
 }
 
-void oox_data_labels::set_common_dLbl ( std::vector<odf_reader::_property> & text_properties)
+void oox_data_labels::set_common_dLbl ( odf_reader::text_format_properties_content_ptr text_properties)
 {
 	textPr_ = text_properties;
 }
 
-void oox_data_labels::add_dLbl(int ind, std::vector<odf_reader::_property> & text_properties)
+void oox_data_labels::add_dLbl(int ind, odf_reader::text_format_properties_content_ptr text_properties)
 {
-	dLbls_.insert(std::pair<int, std::vector<odf_reader::_property>>(ind, text_properties));
+	dLbls_.insert(std::make_pair(ind, text_properties));
 }
 
 void oox_data_labels::oox_serialize(std::wostream & _Wostream)
@@ -69,9 +70,17 @@ void oox_data_labels::oox_serialize(std::wostream & _Wostream)
     {
 		CP_XML_NODE(L"c:dLbls")
         {
+			if (false == formatCode_.empty())
+			{
+				CP_XML_NODE(L"c:numFmt")
+				{
+					CP_XML_ATTR(L"formatCode", formatCode_);
+					CP_XML_ATTR(L"sourceLinked", linkData_);
+				}
+			}
 			oox_serialize_default_text(CP_XML_STREAM(), textPr_);
 	
-			for (std::map<int, std::vector<odf_reader::_property>>::iterator it = dLbls_.begin(); it != dLbls_.end(); ++it)
+			for (std::map<int, odf_reader::text_format_properties_content_ptr>::iterator it = dLbls_.begin(); it != dLbls_.end(); ++it)
 			{
 				CP_XML_NODE(L"c:dLbl")
 				{

ASCOfficeOdfFile/src/docx/oox_data_labels.h

@@ -41,6 +41,13 @@
 #include <xml/attributes.h>
             
 namespace cpdoccore {
+
+namespace odf_reader {
+
+	class text_format_properties_content;
+	typedef boost::shared_ptr<text_format_properties_content> text_format_properties_content_ptr;
+}
+
 namespace oox {
 
 class oox_data_labels
@@ -58,14 +65,22 @@ public:
 	void set_showPercent	(bool Val){showPercent_		= Val;}
 	void set_showSerName	(bool Val){showSerName_		= Val;}
 	void set_showVal		(bool Val){showVal_			= Val;}
+	
+	void set_formatCode		(std::wstring & formatCode, bool linkData)
+	{
+		formatCode_ = formatCode;
+		linkData_ = linkData;
+	}
 
 	void set_position		(int Val){position_	= Val;}
 
-	void add_dLbl			(int ind, std::vector<odf_reader::_property> & text_properties);
-	void set_common_dLbl	( std::vector<odf_reader::_property> & text_properties);
+	void add_dLbl			(int ind, odf_reader::text_format_properties_content_ptr text_properties);
+	void set_common_dLbl	( odf_reader::text_format_properties_content_ptr text_properties);
    
 private:
 
+	std::wstring formatCode_;
+	bool linkData_;
 	bool showBubbleSize_;		// (Show Bubble Size) §21.2.2.178
 	bool showCatName_;			// (Show Category Name) §21.2.2.179
 	bool showLeaderLines_;		// (Show Leader Lines) §21.2.2.183
@@ -76,8 +91,8 @@ private:
 
 	int position_;
 
-	std::vector<odf_reader::_property>					textPr_;
-	std::map<int, std::vector<odf_reader::_property>>	dLbls_;
+	odf_reader::text_format_properties_content_ptr					textPr_;
+	std::map<int, odf_reader::text_format_properties_content_ptr>	dLbls_;
 
 
 //delete (Delete) §21.2.2.40

ASCOfficeOdfFile/src/docx/oox_drawing.cpp

@@ -170,7 +170,8 @@ void oox_serialize_effects(std::wostream & strm, const std::vector<odf_reader::_
 					double offsetY = dShadowOffsetY.get_value_or(0);
 
 					double dist = sqrt(offsetX * offsetX + offsetY * offsetY);
-					double dir = (offsetX > 0 ? atan(offsetY / offsetX) : 0) * 180. / 3.1415926;
+					double dir = atan(offsetY / offsetX) * 180. / 3.1415926; 
+					if (dir < 0) dir += 360;
 
 					CP_XML_ATTR(L"dist", (int)(dist)); 
 					CP_XML_ATTR(L"dir", (int)(dir * 60000)); 

ASCOfficeOdfFile/src/docx/oox_drawing.h

@@ -77,7 +77,7 @@ namespace oox {
 		std::wstring	hId;
         std::wstring	hRef;
 
-		RelsType		typeRels;
+		_rels_type		typeRels;
 		bool			highlightClick;
     };
 	class _oox_drawing
@@ -86,7 +86,7 @@ namespace oox {
         _oox_drawing() : type(typeUnknown), id(0), x(0), y(0), cx(0), cy(0), sub_type(0), hidden(false), inGroup(false), lined(false), connector(false), name(L"object"), extExternal(false)
         {
         }
-        RelsType		type;
+        _rels_type		type;
 
  		bool			inGroup;
 		size_t			id;

ASCOfficeOdfFile/src/docx/oox_drawing_fills.h

@@ -125,7 +125,7 @@ namespace oox {
 //////////////////////////////////////////////////////////////////////////////
 	struct _oox_fill
 	{
-		_oox_fill() : type(-1){}
+		int type = -1;
 
 		oox_gradient_fill_ptr	gradient;
 		oox_hatch_fill_ptr		hatch;
@@ -133,11 +133,10 @@ namespace oox {
 		oox_solid_fill_ptr		solid;
 
 		_CP_OPT(double) opacity;
-		int				type;
 
 		void clear()
 		{
-			type=-1;
+			type = -1;
 			opacity = boost::none;
 
 			gradient.reset();

ASCOfficeOdfFile/src/docx/oox_layout.h

@@ -36,13 +36,6 @@
 #include <CPScopedPtr.h>
 
 #include "../odf/chart_objects.h"
-
-namespace cpdoccore {
-namespace odf_reader 
-{
-	//class style_table_cell_properties_attlist;
-}
-}
                     
 namespace cpdoccore {
 namespace oox {
@@ -58,8 +51,6 @@ public:
     //size_t borderId(const odf_reader::style_table_cell_properties_attlist * cellProp, bool & is_default);
 
     void oox_serialize(std::wostream & _Wostream);/* const;*/
-    
-
 };
 
 }

ASCOfficeOdfFile/src/docx/oox_package.cpp

@@ -389,16 +389,18 @@ void media::write(const std::wstring & RootPath)
 															items[i].type == typeAudio ||
 															items[i].type == typeVideo ))
         {
-			std::wstring & file_name	= items[i].href;
+			std::wstring &file_name	= items[i].href;
 			std::wstring file_name_out	= RootPath + FILE_SEPARATOR_STR + items[i].outputName;
 			
+			if (file_name.empty()) continue;
+
 			CImageFileFormatChecker svmFileChecker;
 			if (svmFileChecker.isSvmFile(file_name))
 			{
 				ConvertSvmToImage(file_name, file_name_out, appFonts_);
 			}
 			else
-				NSFile::CFileBinary::Copy(items[i].href, file_name_out);
+				NSFile::CFileBinary::Copy(file_name, file_name_out);
         }
     }
 

ASCOfficeOdfFile/src/docx/oox_plot_area.cpp

@@ -96,7 +96,10 @@ void oox_plot_area::add_axis(int type, odf_reader::chart::axis & content)
 
 	axis_.push_back(ax);
 }
-
+void oox_plot_area::set_no_local_table	(bool val)
+{
+	no_used_local_tables_ = val;
+} 
 void oox_plot_area::reset_cross_axis()//обязательно после всех добавлений
 {
 	for (size_t i = 0; i < axis_.size(); i++)

ASCOfficeOdfFile/src/docx/oox_plot_area.h

@@ -45,7 +45,7 @@ namespace oox {
 class oox_plot_area: boost::noncopyable
 {
 public:
-	oox_plot_area(){}
+	oox_plot_area() : no_used_local_tables_(false) {}
 	~oox_plot_area(){}
  
     std::vector<oox_chart_ptr>			charts_;
@@ -65,22 +65,12 @@ public:
 	void add_chart	(int type);
 	void add_axis	(int type,	odf_reader::chart::axis & content);
 
- 	//void set_content_series	(odf_reader::chart::series & content);
+	void set_no_local_table (bool val); //whithout embedded tables
+	//void set_content_series	(odf_reader::chart::series & content);
 
 private:
-	void reset_cross_axis();//обязательно после всех добавлений
-
-
-//variable charts 
-//catAx (Category Axis Data) §21.2.2.25
-//dateAx (Date Axis) §21.2.2.39
-//serAx (Series Axis) §21.2.2.175
-//valAx (Value Axis) §21.2.2.226
-
-//extLst (Chart Extensibility) §21.2.2.64
-//layout (Layout) §21.2.2.88
-//spPr (Shape Properties) §21.2.2.197
-//dTable (Data Table) §21.2.2.54
+	void reset_cross_axis(); //обязательно после всех добавлений
+ 	bool no_used_local_tables_;
 
 };
 

ASCOfficeOdfFile/src/docx/oox_rels.h

@@ -40,7 +40,7 @@
 namespace cpdoccore { 
 namespace oox {
 
-enum RelsType 
+enum _rels_type 
 {
 	typeUnknown = 0, 
 	typeDefault,
@@ -63,10 +63,18 @@ enum RelsType
 	typeControlProps,
 	typeChartUserShapes
 };
-
+enum _rels_type_place
+{
+	document_place,
+	endnote_place,
+	footnote_place,
+	comment_place,
+	header_footer_place,
+	chart_place
+};
 struct _rel
 { 
-    _rel(bool is_internal_, std::wstring const & rid_, std::wstring const & ref_,  RelsType const & type_) :
+    _rel(bool is_internal_, std::wstring const & rid_, std::wstring const & ref_,  _rels_type const & type_) :
 			is_internal(is_internal_),
 			rid(rid_),
 			ref(ref_),
@@ -76,7 +84,7 @@ struct _rel
     bool			is_internal;
     std::wstring	rid;
     std::wstring	ref;
-    RelsType		type;
+    _rels_type		type;
 };
 
 class relationship : public xml::element_impl<relationship>

ASCOfficeOdfFile/src/docx/oox_title.cpp

@@ -34,63 +34,81 @@
 #include <boost/functional.hpp>
 #include <CPOptional.h>
 #include <xml/simple_xml_writer.h>
+#include "../odf/odfcontext.h"
 #include "../odf/style_text_properties.h"
 
 namespace cpdoccore {
 namespace oox {
 
+void oox_title::oox_content_serialize(std::wostream & _Wostream, odf_reader::chart::title & content)
+{
+	if (content_.content_.empty()) return;
+
+	CP_XML_WRITER(_Wostream)
+    {
+		CP_XML_NODE(L"a:p")
+		{
+			CP_XML_NODE(L"a:pPr")
+			{
+				CP_XML_NODE(L"a:defRPr"){}
+			}
+			CP_XML_NODE(L"a:r")
+			{
+				//odf_reader::fonts_container & fonts = context.fontContainer();
+				odf_reader::fonts_container fonts;
+				if (content.text_properties_)
+					content.text_properties_->oox_serialize(CP_XML_STREAM(), true, fonts);
+
+				CP_XML_NODE(L"a:t")
+				{
+					CP_XML_CONTENT(content.content_);
+				}
+			}
+		}
+	}
+}
+
 void oox_title::oox_serialize(std::wostream & _Wostream)
 {
-	if (content_.content_.length() < 1)
-	{
-		//возможен шаблон txPr
-		return;
-	}
-    
+	if (!content_.bEnabled && !sub_.bEnabled) return;
+	
 	CP_XML_WRITER(_Wostream)
     {
 		CP_XML_NODE(L"c:title")
         {
-			CP_XML_NODE(L"c:tx")
+			if (false == content_.content_.empty() || false == sub_.content_.empty())
 			{
-				CP_XML_NODE(L"c:rich")
+				CP_XML_NODE(L"c:tx")
+				{
+					CP_XML_NODE(L"c:rich")
+					{
+						CP_XML_NODE(L"a:bodyPr"){}
+						CP_XML_NODE(L"a:lstStyle"){}
+						
+						oox_content_serialize(CP_XML_STREAM(), content_);
+						oox_content_serialize(CP_XML_STREAM(), sub_);				
+					}
+				}
+			}
+			else if (content_.text_properties_)
+			{
+				CP_XML_NODE(L"c:txPr")
 				{
 					CP_XML_NODE(L"a:bodyPr"){}
 					CP_XML_NODE(L"a:lstStyle"){}
+					
 					CP_XML_NODE(L"a:p")
 					{
 						CP_XML_NODE(L"a:pPr")
 						{
-							CP_XML_NODE(L"a:defRPr"){}
-						}
-						CP_XML_NODE(L"a:r")
-						{
-							CP_XML_NODE(L"a:rPr")
+							CP_XML_NODE(L"a:defRPr")
 							{
-								_CP_OPT(double) dVal;
-								_CP_OPT(std::wstring) sVal;
-								_CP_OPT(int) iVal;	
-
-								if (odf_reader::GetProperty(content_.text_properties_,L"font-size",dVal))
-									CP_XML_ATTR(L"sz", (int)(dVal.get()*100));
-								
-								if ((odf_reader::GetProperty(content_.text_properties_,L"font-style",iVal)) && (*iVal >0))
-									CP_XML_ATTR(L"i", "true");
-								if ((odf_reader::GetProperty(content_.text_properties_,L"font-weight",iVal)) && (*iVal >0))
-									CP_XML_ATTR(L"b", "true");		
-								if (odf_reader::GetProperty(content_.text_properties_,L"font-color",sVal))
-									CP_XML_NODE(L"a:solidFill")	
-									{
-										CP_XML_NODE(L"a:srgbClr"){CP_XML_ATTR(L"val", sVal.get());}
-									}
-							}
-							CP_XML_NODE(L"a:t")
-							{
-								CP_XML_CONTENT(content_.content_);
+								//odf_reader::fonts_container & fonts = context.fontContainer();
+								odf_reader::fonts_container fonts;
+								content_.text_properties_->oox_serialize(CP_XML_STREAM(), true, fonts);
 							}
 						}
-					}
-				
+					}			
 				}
 			}
             layout_.oox_serialize(CP_XML_STREAM());
@@ -98,8 +116,13 @@ void oox_title::oox_serialize(std::wostream & _Wostream)
 			{
 				CP_XML_ATTR(L"val", 0);
 			}
+			
+			oox_chart_shape shape;
+			shape.set(content_.graphic_properties_, content_.fill_);
+			shape.oox_serialize(CP_XML_STREAM());
 		}
     }
+
 }
 }
 }

ASCOfficeOdfFile/src/docx/oox_title.h

@@ -55,9 +55,17 @@ public:
 	{
 		content_ = t;
 	}
+	void set_sub_content(odf_reader::chart::title &  t)
+	{
+		sub_ = t;
+	}
 private:
+    void oox_content_serialize(std::wostream & _Wostream, odf_reader::chart::title & content);
+	
 	cpdoccore::oox::oox_layout layout_;
+	
 	odf_reader::chart::title content_;
+	odf_reader::chart::title sub_;
 
 //extLst (Chart Extensibility) §21.2.2.64
 //layout (Layout) §21.2.2.88

ASCOfficeOdfFile/src/docx/oox_types_chart.cpp

@@ -32,7 +32,6 @@
 
 #include <xml/simple_xml_writer.h>
 #include "oox_types_chart.h"
-#include "oox_chart_shape.h"
 
 namespace cpdoccore {
 namespace oox {
@@ -59,8 +58,9 @@ void oox_chart::set_name(const std::wstring& val)
 }
 void oox_chart::set_content_series(odf_reader::chart::series & content)
 {
-	series_.back()->content_=content;
+	series_.back()->content_= content;
 }
+
 void oox_chart::set_values_series(int ind, std::vector<std::wstring> & val)
 {
 	if (val.empty())return;
@@ -467,7 +467,21 @@ void oox_stock_chart::set_properties(std::vector<odf_reader::_property> g)
 	
 	oox_chart::set_properties(g);
 
-	odf_reader::GetProperty(g, L"japanese-candle-stick",bCandleStick);
+	odf_reader::GetProperty(g, L"japanese-candle-stick", bCandleStick);
+}
+void oox_stock_chart::set_stock_gain_marke(odf_reader::chart::simple & obj)
+{
+	if (!obj.bEnabled) return;
+}
+void oox_stock_chart::set_stock_loss_marker(odf_reader::chart::simple & obj)
+{
+	if (!obj.bEnabled) return;
+}
+void oox_stock_chart::set_stock_range_line(odf_reader::chart::simple & obj)
+{
+	if (!obj.bEnabled) return;
+
+	range_line.set(obj.graphic_properties_, obj.fill_);
 }
 void oox_stock_chart::oox_serialize(std::wostream & _Wostream)
 {
@@ -480,10 +494,13 @@ void oox_stock_chart::oox_serialize(std::wostream & _Wostream)
         {
 			oox_serialize_common(CP_XML_STREAM());
 			
-			//CP_XML_NODE(L"c:hiLowLines")//hiLowLines (High Low Lines) §21.2.2.80
-			//{
-			//	//shape.oox_serialize(CP_XML_STREAM());
-			//}
+			if (range_line.bEnabled)
+			{
+				CP_XML_NODE(L"c:hiLowLines")
+				{
+					range_line.oox_serialize(CP_XML_STREAM());
+				}
+			}
 			CP_XML_NODE(L"c:upDownBars")
 			{
 				CP_XML_NODE(L"c:gapWidth")

ASCOfficeOdfFile/src/docx/oox_types_chart.h

@@ -31,11 +31,9 @@
  */
 #pragma once 
 
-#include <iosfwd>
 #include <boost/noncopyable.hpp>
 
-#include <CPScopedPtr.h>
-#include <CPSharedPtr.h>
+#include "oox_chart_shape.h"
 
 #include "xlsx_color.h"
 #include "oox_chart_series.h"
@@ -84,6 +82,9 @@ public:
 	void set_name			(const std::wstring& val);
 	void set_content_series	(odf_reader::chart::series & content);
 	
+	virtual void set_stock_gain_marke(odf_reader::chart::simple & obj){}
+	virtual void set_stock_loss_marker(odf_reader::chart::simple & obj){}
+	virtual void set_stock_range_line(odf_reader::chart::simple & obj){}
 	//void set_showBubbleSize(bool Val){data_labels_.set_showBubbleSize(Val);}
 	//void set_showCatName(bool Val){data_labels_.set_showCatName(Val);}
 	//void set_showLeaderLines(bool Val){data_labels_.set_showLeaderLines(Val);}
@@ -349,6 +350,9 @@ class oox_stock_chart: public oox_chart
 
 	static _CP_PTR(oox_chart) create();
 
+	virtual void set_stock_gain_marke(odf_reader::chart::simple & obj);
+	virtual void set_stock_loss_marker(odf_reader::chart::simple & obj);
+	virtual void set_stock_range_line(odf_reader::chart::simple & obj);
 
 	_CP_OPT(bool) bCandleStick;
 	
@@ -357,6 +361,7 @@ class oox_stock_chart: public oox_chart
 
 	_oox_fill					fill_;
 
+	oox_chart_shape range_line;
 	//dropLines (Drop Lines) §21.2.2.53
 	//hiLowLines (High Low Lines) §21.2.2.80
 	//ser (Line Chart Series) §21.2.2.171

ASCOfficeOdfFile/src/docx/pptx_conversion_context.cpp

@@ -208,7 +208,7 @@ void pptx_conversion_context::start_document()
 	instances.push_back(odfContext.styleContainer().style_default_by_type(odf_types::style_family::Presentation));
 	instances.push_back(odfContext.styleContainer().style_by_name(L"Default",odf_types::style_family::Presentation,false));
 
-    odf_reader::text_format_properties_content			textFormatProperties	= calc_text_properties_content(instances);
+    odf_reader::text_format_properties_content_ptr	textFormatProperties	= calc_text_properties_content(instances);
     odf_reader::paragraph_format_properties			parFormatProperties		= calc_paragraph_properties_content(instances);
 
 	process_masters_ = false;

ASCOfficeOdfFile/src/docx/pptx_drawings.cpp

@@ -50,7 +50,7 @@ public:
         bool isInternal,
         std::wstring const & rid,
         std::wstring const & ref,
-		RelsType type)
+		_rels_type type)
     {
         pptx_drawings_.push_back(d);
 		
@@ -79,7 +79,7 @@ public:
         bool isInternal,
         std::wstring const & rid,
         std::wstring const & ref,
-		RelsType type)
+		_rels_type type)
     {
 	
 		bool present = false;
@@ -153,7 +153,7 @@ void pptx_drawings::add(_pptx_drawing const & d,
         bool isInternal,
         std::wstring const & rid,
         std::wstring const & ref,
-        RelsType type)
+        _rels_type type)
 {
     impl_->add(d, isInternal, rid, ref, type);
 }
@@ -161,7 +161,7 @@ void pptx_drawings::add(/**/
         bool isInternal,
         std::wstring const & rid,
         std::wstring const & ref,
-        RelsType type)
+        _rels_type type)
 {
     impl_->add(isInternal, rid, ref, type);
 }

ASCOfficeOdfFile/src/docx/pptx_drawings.h

@@ -56,13 +56,13 @@ public:
         bool isInternal,
         std::wstring const & rid,
         std::wstring const & ref,
-		RelsType type
+		_rels_type type
         );
     void add(/**/
         bool isInternal,
         std::wstring const & rid,
         std::wstring const & ref,
-		RelsType type
+		_rels_type type
         );
     bool empty() const;
 

ASCOfficeOdfFile/src/docx/pptx_slide_context.cpp

@@ -82,11 +82,11 @@ public:
 
 	bool header, footer, date_time, slideNum;
 
-    void add_drawing(_pptx_drawing const & d, bool isInternal, std::wstring const & rid, std::wstring const & ref, RelsType type)
+    void add_drawing(_pptx_drawing const & d, bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type)
     {
         pptx_drawings_->add(d, isInternal, rid, ref, type);
     }
-	void add_additional_rels (bool isInternal, std::wstring const & rid, std::wstring const & ref, RelsType type)
+	void add_additional_rels (bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type)
     {
         pptx_drawings_->add(isInternal, rid, ref, type);
     }
@@ -359,7 +359,7 @@ void pptx_slide_context::add_background(_oox_fill & fill)
 		bool isMediaInternal = false;
 		std::wstring ref;
 		
-		fill.bitmap->rId = get_mediaitems()->add_or_find(fill.bitmap->xlink_href_, typeImage, isMediaInternal, ref);
+		fill.bitmap->rId = get_mediaitems()->add_or_find(fill.bitmap->xlink_href_, typeImage, isMediaInternal, ref, oox::document_place);
 		add_rels(isMediaInternal, fill.bitmap->rId, ref, typeImage);
 	}	
 	impl_->background_fill_ = fill;
@@ -413,7 +413,7 @@ void pptx_slide_context::start_action(std::wstring action)
 		impl_->object_description_.action_.highlightClick = true;
 	}
 }
-void pptx_slide_context::set_link(std::wstring link, RelsType typeRels)
+void pptx_slide_context::set_link(std::wstring link, _rels_type typeRels)
 {
 	++hlinks_size_;
 	
@@ -423,7 +423,7 @@ void pptx_slide_context::set_link(std::wstring link, RelsType typeRels)
 	{
 		bool isMediaInternal = true;
 		
-		impl_->object_description_.action_.hSoundId = get_mediaitems()->add_or_find(link, typeAudio, isMediaInternal, impl_->object_description_.action_.hSoundRef);		
+		impl_->object_description_.action_.hSoundId = get_mediaitems()->add_or_find(link, typeAudio, isMediaInternal, impl_->object_description_.action_.hSoundRef, oox::document_place);		
 		impl_->add_additional_rels(isMediaInternal, impl_->object_description_.action_.hSoundId, impl_->object_description_.action_.hSoundRef, typeAudio);
 	}
 	else
@@ -578,7 +578,7 @@ void pptx_slide_context::Impl::process_image(drawing_object_description& obj, _p
 	std::wstring ref;/// это ссылка на выходной внешний объект
 	bool isMediaInternal = false;
 	
-	drawing.fill.bitmap->rId		= get_mediaitems()->add_or_find(obj.xlink_href_, typeImage, isMediaInternal, ref);
+	drawing.fill.bitmap->rId		= get_mediaitems()->add_or_find(obj.xlink_href_, typeImage, isMediaInternal, ref, oox::document_place);
 	drawing.fill.bitmap->isInternal	= isMediaInternal;
 
 	if (drawing.type == typeShape)
@@ -586,7 +586,7 @@ void pptx_slide_context::Impl::process_image(drawing_object_description& obj, _p
 		add_additional_rels(isMediaInternal, drawing.fill.bitmap->rId, ref, typeImage);//собственно это не объект, а доп рел и ref объекта
 	
 		isMediaInternal	= true;
-		std::wstring rId = get_mediaitems()->add_or_find(L"", typeShape, isMediaInternal, ref);
+		std::wstring rId = get_mediaitems()->add_or_find(L"", typeShape, isMediaInternal, ref, oox::document_place);
 		
 		add_drawing(drawing, isMediaInternal, rId, ref, typeShape);//объект
 
@@ -601,7 +601,7 @@ void pptx_slide_context::Impl::process_chart(drawing_object_description & obj, _
     std::wstring ref;
     bool isMediaInternal = true;
    
-	drawing.objectId = get_mediaitems()->add_or_find(obj.xlink_href_, obj.type_, isMediaInternal, ref);  
+	drawing.objectId = get_mediaitems()->add_or_find(obj.xlink_href_, obj.type_, isMediaInternal, ref, oox::document_place);  
 	
 	add_drawing(drawing, isMediaInternal, drawing.objectId, ref, drawing.type);
 }
@@ -610,7 +610,7 @@ void pptx_slide_context::Impl::process_table(drawing_object_description & obj, _
 {
     std::wstring ref;
     bool isMediaInternal = true;
-	std::wstring rId = get_mediaitems()->add_or_find(L"", obj.type_, isMediaInternal, ref);        
+	std::wstring rId = get_mediaitems()->add_or_find(L"", obj.type_, isMediaInternal, ref, oox::document_place);        
    
 	add_drawing(drawing, isMediaInternal, rId, ref, drawing.type);
 
@@ -625,12 +625,12 @@ void pptx_slide_context::Impl::process_shape(drawing_object_description & obj, _
 	
 	if (drawing.fill.bitmap)
 	{
-		drawing.fill.bitmap->rId = get_mediaitems()->add_or_find(drawing.fill.bitmap->xlink_href_, typeImage, isMediaInternal, ref);
+		drawing.fill.bitmap->rId = get_mediaitems()->add_or_find(drawing.fill.bitmap->xlink_href_, typeImage, isMediaInternal, ref, oox::document_place);
 		
 		add_additional_rels(isMediaInternal, drawing.fill.bitmap->rId, ref, typeImage);
 	}
 		
-	std::wstring rId = get_mediaitems()->add_or_find(L"", typeShape, isMediaInternal, ref);
+	std::wstring rId = get_mediaitems()->add_or_find(L"", typeShape, isMediaInternal, ref, oox::document_place);
    
 ////////////////////////////////////////////////////////////////
 	_CP_OPT(std::wstring) sPlaceHolderType;
@@ -653,7 +653,7 @@ void pptx_slide_context::Impl::process_object(drawing_object_description& obj, _
     std::wstring ref, ref_image;
     bool isMediaInternal = true, isMediaInternal_image = true;
    
-	drawing.objectId		= get_mediaitems()->add_or_find(obj.xlink_href_, obj.type_, isMediaInternal, ref);      
+	drawing.objectId		= get_mediaitems()->add_or_find(obj.xlink_href_, obj.type_, isMediaInternal, ref, oox::document_place);      
 	drawing.objectProgId	= obj.descriptor_;
 
 	if (!drawing.fill.bitmap)
@@ -664,7 +664,7 @@ void pptx_slide_context::Impl::process_object(drawing_object_description& obj, _
 		_image_file_::GenerateZeroImage(odfPacket_ + FILE_SEPARATOR_STR + L"zero.png");
 	}
 	
-	drawing.fill.bitmap->rId = get_mediaitems()->add_or_find(drawing.fill.bitmap->xlink_href_, typeImage, isMediaInternal_image, ref_image);
+	drawing.fill.bitmap->rId = get_mediaitems()->add_or_find(drawing.fill.bitmap->xlink_href_, typeImage, isMediaInternal_image, ref_image, oox::document_place);
 	add_additional_rels(isMediaInternal_image, drawing.fill.bitmap->rId, ref_image, typeImage);
 
 	add_drawing(drawing, isMediaInternal, drawing.objectId, ref, drawing.type);	
@@ -676,7 +676,7 @@ void pptx_slide_context::Impl::process_media(drawing_object_description& obj, _p
 
 	drawing.type = mediaitems::detectMediaType(obj.xlink_href_); //reset from Media to Audio, Video, ... QuickTime? AudioCD? ...   
 	
-	drawing.objectId	= get_mediaitems()->add_or_find(obj.xlink_href_, drawing.type, isMediaInternal, ref);    
+	drawing.objectId	= get_mediaitems()->add_or_find(obj.xlink_href_, drawing.type, isMediaInternal, ref, oox::document_place);    
 	drawing.extId		= L"ext" + drawing.objectId;
 	drawing.extExternal	= !isMediaInternal;
 	
@@ -687,7 +687,7 @@ void pptx_slide_context::Impl::process_media(drawing_object_description& obj, _p
 		
 		_image_file_::GenerateZeroImage(odfPacket_ + FILE_SEPARATOR_STR + L"zero.png");
 	}
-	drawing.fill.bitmap->rId = get_mediaitems()->add_or_find(drawing.fill.bitmap->xlink_href_, typeImage, isMediaInternal_image, ref_image);		
+	drawing.fill.bitmap->rId = get_mediaitems()->add_or_find(drawing.fill.bitmap->xlink_href_, typeImage, isMediaInternal_image, ref_image, oox::document_place);		
 	add_additional_rels(isMediaInternal_image, drawing.fill.bitmap->rId, ref_image, typeImage);
 	
 	add_drawing(drawing, false, drawing.objectId, L"NULL", drawing.type);
@@ -725,7 +725,7 @@ mediaitems_ptr & pptx_slide_context::get_mediaitems()
 	return impl_->get_mediaitems(); 
 }
 
-void pptx_slide_context::add_rels( bool isInternal, std::wstring const & rid, std::wstring const & ref, RelsType type)
+void pptx_slide_context::add_rels( bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type)
 {
 	impl_->add_additional_rels(isInternal, rid, ref, type);
 }

ASCOfficeOdfFile/src/docx/pptx_slide_context.h

@@ -91,7 +91,7 @@ public:
 	void end_frame();
 
 	void start_action	(std::wstring action);
-		void set_link	(std::wstring link, RelsType typeRels = typeHyperlink); 
+		void set_link	(std::wstring link, _rels_type typeRels = typeHyperlink); 
 	void end_action		();
 
  	void start_table();
@@ -123,7 +123,7 @@ public:
 	void add_rels( bool isInternal,
         std::wstring const & rid,
         std::wstring const & ref,
-        RelsType type);
+        _rels_type type);
 
 	void set_footer();
 	void set_header();

ASCOfficeOdfFile/src/docx/pptx_table_context.cpp

@@ -390,7 +390,7 @@ void oox_serialize_tcPr(std::wostream & strm, std::vector<const odf_reader::styl
 				{
 					bool isMediaInternal = true;
 					std::wstring ref;
-					fill.bitmap->rId = Context.get_slide_context().get_mediaitems()->add_or_find(fill.bitmap->xlink_href_, oox::typeImage, isMediaInternal, ref);
+					fill.bitmap->rId = Context.get_slide_context().get_mediaitems()->add_or_find(fill.bitmap->xlink_href_, oox::typeImage, isMediaInternal, ref, oox::document_place);
 					Context.get_slide_context().add_rels(isMediaInternal, fill.bitmap->rId, ref, oox::typeImage);
 				}
 				oox::oox_serialize_fill(CP_XML_STREAM(), fill);				

ASCOfficeOdfFile/src/docx/pptx_text_context.cpp

@@ -42,9 +42,9 @@
 #include <xml/utils.h>
 
 #include "../odf/odfcontext.h"
-#include "../odf/style_text_properties.h"
 #include "../odf/calcs_styles.h"
 
+#include "../odf/style_text_properties.h"
 
 namespace cpdoccore {
 namespace oox {
@@ -269,7 +269,11 @@ void pptx_text_context::Impl::ApplyTextProperties(std::wstring style_name, std::
 	else if (para_style)	get_styles_context().start_process_style(para_style);
 	else					get_styles_context().start_process_style(baseStyle);
 
-	propertiesOut.apply_from(calc_text_properties_content(instances));
+	odf_reader::text_format_properties_content_ptr text_props = calc_text_properties_content(instances);
+	if (text_props)
+	{
+		propertiesOut.apply_from(*text_props.get());
+	}
 }
 
 void pptx_text_context::Impl::ApplyListProperties(odf_reader::paragraph_format_properties & propertiesOut, int Level)

ASCOfficeOdfFile/src/docx/xlsx_alignment.cpp

@@ -88,7 +88,7 @@ bool is_default(const xlsx_alignment & rVal)
 }
 
 xlsx_alignment OdfProperties2XlsxAlignment(	xlsx_conversion_context									* context,
-											const odf_reader::text_format_properties_content		* textProp, 
+											const odf_reader::text_format_properties_content_ptr	textProp, 
 											const odf_reader::paragraph_format_properties			* parProp,
 											const odf_reader::style_table_cell_properties_attlist	* cellProp)
 {

ASCOfficeOdfFile/src/docx/xlsx_alignment.h

@@ -39,9 +39,10 @@ namespace cpdoccore {
 namespace odf_reader {
 
 	class text_format_properties_content;
+	typedef boost::shared_ptr<text_format_properties_content> text_format_properties_content_ptr;
+
 	class paragraph_format_properties;
 	class style_table_cell_properties_attlist;
-
 }
 }
 
@@ -71,7 +72,7 @@ struct xlsx_alignment
 };
 
 xlsx_alignment OdfProperties2XlsxAlignment( xlsx_conversion_context									* context,
-											const odf_reader::text_format_properties_content		* textProp, 
+											const odf_reader::text_format_properties_content_ptr	textProp, 
 											const odf_reader::paragraph_format_properties			* parProp,
 											const odf_reader::style_table_cell_properties_attlist	* cellProp);
 

ASCOfficeOdfFile/src/docx/xlsx_cell_format.h

@@ -36,7 +36,7 @@ namespace oox {
 
 struct XlsxCellType
 {
-    enum type { null, b, n, e, s, str, inlineStr };    
+    enum type { null, b, n, e, s, str, inlineStr, d };    
 };
 
 int odf_string_to_build_in(const int value_type);

ASCOfficeOdfFile/src/docx/xlsx_drawing.cpp

@@ -107,22 +107,26 @@ void xlsx_drawing_position::serialize(std::wostream & strm, const std::wstring &
     {
 		CP_XML_NODE( ns_title + (ns_title.empty() ? L"" : L":") + (type == xlsx_drawing_position::from ? L"from" : L"to") )
         {
-            CP_XML_NODE(ns + (ns.empty() ? L"" : L":") + L"col")
-            {
+            //CP_XML_NODE(ns + (ns.empty() ? L"" : L":") + L"col")
+			CP_XML_NODE(L"xdr:col")
+			{
                 CP_XML_CONTENT(position.col);
             }
             
-            CP_XML_NODE(ns + (ns.empty() ? L"" : L":") + L"colOff")
+            //CP_XML_NODE(ns + (ns.empty() ? L"" : L":") + L"colOff")
+			CP_XML_NODE(L"xdr:colOff")
             {
                 CP_XML_CONTENT(static_cast<size_t>(position.colOff));
             }
 
-            CP_XML_NODE(ns + (ns.empty() ? L"" : L":") + L"row")
+            //CP_XML_NODE(ns + (ns.empty() ? L"" : L":") + L"row")
+			CP_XML_NODE(L"xdr:row")
             {
                 CP_XML_CONTENT(position.row);
             }
 
-            CP_XML_NODE(ns + (ns.empty() ? L"" : L":") + L"rowOff")
+			//CP_XML_NODE(ns + (ns.empty() ? L"" : L":") + L"rowOff")
+			CP_XML_NODE(L"xdr:rowOff")
             {
                 CP_XML_CONTENT(static_cast<size_t>(position.rowOff));
             }  

ASCOfficeOdfFile/src/docx/xlsx_drawing_context.cpp

@@ -70,7 +70,7 @@ public:
 		return std::pair<std::wstring, std::wstring>(fileName, rId);
     }
 
-    std::pair<std::wstring, std::wstring> add_drawing_xml(std::wstring const & content, xlsx_drawings_ptr drawings, RelsType const & type_)
+    std::pair<std::wstring, std::wstring> add_drawing_xml(std::wstring const & content, xlsx_drawings_ptr drawings, _rels_type const & type_)
     {
         const std::wstring id = std::to_wstring(next_drawing_id_++);
         const std::wstring fileName = std::wstring(L"drawing") + id + L".xml";
@@ -108,7 +108,7 @@ xlsx_drawing_context_handle::~xlsx_drawing_context_handle()
 {
 }
 
-std::pair<std::wstring, std::wstring> xlsx_drawing_context_handle::add_drawing_xml(std::wstring const & content, xlsx_drawings_ptr drawings, RelsType const & type_)
+std::pair<std::wstring, std::wstring> xlsx_drawing_context_handle::add_drawing_xml(std::wstring const & content, xlsx_drawings_ptr drawings, _rels_type const & type_)
 {
     return impl_->add_drawing_xml(content, drawings, type_);
 }
@@ -626,14 +626,14 @@ void xlsx_drawing_context::process_image(drawing_object_description & obj, _xlsx
 	std::wstring ref;/// это ссылка на выходной внешний объект
 	bool isMediaInternal = false;
 
-	drawing.fill.bitmap->rId = impl_->get_mediaitems()->add_or_find(obj.xlink_href_, typeImage, isMediaInternal, ref);		
+	drawing.fill.bitmap->rId = impl_->get_mediaitems()->add_or_find(obj.xlink_href_, typeImage, isMediaInternal, ref, oox::document_place);		
 
 	if (drawing.type == typeShape)
 	{
 		impl_->get_drawings()->add(isMediaInternal, drawing.fill.bitmap->rId, ref, typeImage, false, false);//собственно это не объект, а доп рел и ref объекта
 	
 		isMediaInternal=true;
-		std::wstring rId = impl_->get_mediaitems()->add_or_find(L"", typeShape, isMediaInternal, ref);
+		std::wstring rId = impl_->get_mediaitems()->add_or_find(L"", typeShape, isMediaInternal, ref, oox::document_place);
 		
 		xlsx_drawings_->add(drawing, isMediaInternal, rId, ref, typeShape);//объект
 
@@ -651,7 +651,7 @@ void xlsx_drawing_context::process_chart(drawing_object_description & obj,_xlsx_
 	std::wstring ref;
     bool isMediaInternal = true;
 	
-	drawing.objectId = impl_->get_mediaitems()->add_or_find(obj.xlink_href_, obj.type_, isMediaInternal, ref);
+	drawing.objectId = impl_->get_mediaitems()->add_or_find(obj.xlink_href_, obj.type_, isMediaInternal, ref, oox::document_place);
     xlsx_drawings_->add(drawing, isMediaInternal, drawing.objectId, ref, obj.type_);
 	
 	if (drawing.inGroup)
@@ -691,7 +691,7 @@ void xlsx_drawing_context::process_object(drawing_object_description & obj, xlsx
 	}
 	else
 	{
-		drawing.objectId		= impl_->get_mediaitems()->add_or_find(obj.xlink_href_, obj.type_, isMediaInternal, ref);
+		drawing.objectId		= impl_->get_mediaitems()->add_or_find(obj.xlink_href_, obj.type_, isMediaInternal, ref, oox::document_place);
 		drawing.objectProgId	= obj.descriptor_;
 		
 		xlsx_drawings_->add(drawing, isMediaInternal, drawing.objectId, ref, obj.type_, true);
@@ -705,7 +705,7 @@ void xlsx_drawing_context::process_shape(drawing_object_description & obj,_xlsx_
 	std::wstring ref;
     bool isMediaInternal = true;
 
-	std::wstring rId = impl_->get_mediaitems()->add_or_find(L"", obj.type_, isMediaInternal, ref);
+	std::wstring rId = impl_->get_mediaitems()->add_or_find(L"", obj.type_, isMediaInternal, ref, oox::document_place);
 	xlsx_drawings_->add(drawing, isMediaInternal, rId, ref, obj.type_);
 }
 
@@ -725,7 +725,7 @@ void xlsx_drawing_context::process_group(drawing_object_description & obj, xlsx_
 	std::wstring ref;
     bool isMediaInternal = true;
 
-	std::wstring rId	= impl_->get_mediaitems()->add_or_find(L"", obj.type_, isMediaInternal, ref);
+	std::wstring rId	= impl_->get_mediaitems()->add_or_find(L"", obj.type_, isMediaInternal, ref, oox::document_place);
 	xlsx_drawings_->add(drawing, isMediaInternal, rId, ref, obj.type_);
 
 }
@@ -756,7 +756,7 @@ void xlsx_drawing_context::process_group_objects(std::vector<drawing_object_desc
 			std::wstring ref;
 			bool isMediaInternal = true;
 			
-			drawing.fill.bitmap->rId = impl_->get_mediaitems()->add_or_find(drawing.fill.bitmap->xlink_href_, typeImage, isMediaInternal, ref);
+			drawing.fill.bitmap->rId = impl_->get_mediaitems()->add_or_find(drawing.fill.bitmap->xlink_href_, typeImage, isMediaInternal, ref, oox::document_place);
 			
 			bool in_sheet = (obj.type_== typeOleObject || obj.type_== typeMsObject) ? true : false;
 			impl_->get_drawings()->add(isMediaInternal, drawing.fill.bitmap->rId, ref, typeImage, in_sheet, false);//собственно это не объект, а доп рел и ref объекта
@@ -798,7 +798,7 @@ void xlsx_drawing_context::start_action(std::wstring action)
 	impl_->object_description_.action_.enabled	= true;
 }
 
-void xlsx_drawing_context::set_link(std::wstring link, RelsType typeRels)
+void xlsx_drawing_context::set_link(std::wstring link, _rels_type typeRels)
 {//hyprelinks only
 	++hlinks_size_;
 	std::wstring hId = L"hId" + std::to_wstring(hlinks_size_);

ASCOfficeOdfFile/src/docx/xlsx_drawing_context.h

@@ -62,7 +62,7 @@ public:
     xlsx_drawing_context_handle(mediaitems_ptr & items);
     ~xlsx_drawing_context_handle();
     
-    std::pair<std::wstring, std::wstring>	add_drawing_xml(std::wstring const & content, xlsx_drawings_ptr drawings, RelsType const & type_ = typeDefault);
+    std::pair<std::wstring, std::wstring>	add_drawing_xml(std::wstring const & content, xlsx_drawings_ptr drawings, _rels_type const & type_ = typeDefault);
  	std::pair<std::wstring, std::wstring>	add_drawing_vml(std::wstring const & content, xlsx_drawings_ptr drawings);
    
 	const std::vector<drawing_elm> & content()		const;
@@ -152,7 +152,7 @@ public:
 	void process_objects(xlsx_table_metrics & table_metrics);
 
 	void start_action(std::wstring action);
-		void set_link(std::wstring link, RelsType typeRels = typeHyperlink); 
+		void set_link(std::wstring link, _rels_type typeRels = typeHyperlink); 
 	void end_action();
 
 private:

ASCOfficeOdfFile/src/docx/xlsx_drawings.cpp

@@ -44,7 +44,7 @@ namespace oox {
 class xlsx_drawings::Impl
 {
 public:
-    void add(_xlsx_drawing & d, bool isInternal, std::wstring const & rid, std::wstring const & ref, RelsType type, bool sheet_rel )//объект
+    void add(_xlsx_drawing & d, bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type, bool sheet_rel )//объект
     {
 		if ( type == typeControlProps || type == typeComment)
 		{
@@ -72,7 +72,7 @@ public:
  				drawing_rels_.push_back(_rel(false, d.action.hId, d.action.hRef, d.action.typeRels));	
 		}
     }
-    void add( bool isInternal, std::wstring const & rid, std::wstring const & ref, RelsType type, bool sheet_rel, bool vml_rel) //не объект
+    void add( bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type, bool sheet_rel, bool vml_rel) //не объект
     {
 		bool present = false;
 		
@@ -305,12 +305,12 @@ xlsx_drawings::~xlsx_drawings()
 }
 
 void xlsx_drawings::add(_xlsx_drawing & d, bool isInternal, std::wstring const & rid,
-															std::wstring const & ref, RelsType type, bool sheet_rel)
+															std::wstring const & ref, _rels_type type, bool sheet_rel)
 {
     impl_->add(d, isInternal, rid, ref, type, sheet_rel);
 }
 
-void xlsx_drawings::add( bool isInternal, std::wstring const & rid, std::wstring const & ref, RelsType type, bool sheet_rel, bool vml_rel)
+void xlsx_drawings::add( bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type, bool sheet_rel, bool vml_rel)
 {
     impl_->add(isInternal, rid, ref, type, sheet_rel, vml_rel);
 }

ASCOfficeOdfFile/src/docx/xlsx_drawings.h

@@ -46,14 +46,14 @@ typedef _CP_PTR(xlsx_drawings) xlsx_drawings_ptr;
 
 struct drawing_elm
 {
-    drawing_elm(std::wstring const & _filename, std::wstring const & _content, xlsx_drawings_ptr _drawings, RelsType const & _type)
+    drawing_elm(std::wstring const & _filename, std::wstring const & _content, xlsx_drawings_ptr _drawings, _rels_type const & _type)
         : filename(_filename), content(_content), drawings(_drawings), type(_type)
     {}
     
     std::wstring		filename;
     std::wstring		content;
     xlsx_drawings_ptr	drawings;
-	RelsType			type;
+	_rels_type			type;
 };
 
 class _xlsx_drawing;
@@ -65,8 +65,8 @@ public:
     ~xlsx_drawings	();
     static xlsx_drawings_ptr create(bool inGroup);
 
-    void add ( _xlsx_drawing & d,	bool isInternal, std::wstring const & rid, std::wstring const & ref, RelsType type, bool sheet_rel = false );
-    void add (						bool isInternal, std::wstring const & rid, std::wstring const & ref, RelsType type, bool sheet_rel, bool vml_rel);
+    void add ( _xlsx_drawing & d,	bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type, bool sheet_rel = false );
+    void add (						bool isInternal, std::wstring const & rid, std::wstring const & ref, _rels_type type, bool sheet_rel, bool vml_rel);
     
 	bool empty() const;
 	bool vml_empty() const;

ASCOfficeOdfFile/src/docx/xlsx_dxfs.cpp

@@ -65,7 +65,7 @@ xlsx_dxfs::~xlsx_dxfs()
 {
 }
 
-size_t xlsx_dxfs::dxfId(	const odf_reader::text_format_properties_content		* textProp,
+size_t xlsx_dxfs::dxfId(	const odf_reader::text_format_properties_content_ptr	textProp,
 							const odf_reader::graphic_format_properties				* graphProp,
 							const odf_reader::style_table_cell_properties_attlist	* cellProp)
 {

ASCOfficeOdfFile/src/docx/xlsx_dxfs.h

@@ -35,11 +35,14 @@
 #include <string>
 
 #include <CPScopedPtr.h>
+#include <boost/shared_ptr.hpp>
 
 namespace cpdoccore {
 	namespace odf_reader {
 
 	class text_format_properties_content;
+	typedef boost::shared_ptr<text_format_properties_content> text_format_properties_content_ptr;
+
 	class graphic_format_properties;
 	class paragraph_format_properties;
 	class style_table_cell_properties_attlist;
@@ -53,7 +56,7 @@ namespace oox {
 		xlsx_dxfs();
 		~xlsx_dxfs();
 
-		size_t dxfId(	const odf_reader::text_format_properties_content		* textProp,
+		size_t dxfId(	const odf_reader::text_format_properties_content_ptr	textProp,
 						const odf_reader::graphic_format_properties				* graphProp,
 						const odf_reader::style_table_cell_properties_attlist	* cellProp);
 		

ASCOfficeOdfFile/src/docx/xlsx_fills.cpp

@@ -32,6 +32,10 @@
 #include "xlsx_fill.h"
 #include "xlsx_fills.h"
 
+#include "../odf/style_text_properties.h"
+#include "../odf/style_table_properties.h"
+#include "../odf/style_paragraph_properties.h"
+
 #include <xml/simple_xml_writer.h>
 
 #include <boost/functional.hpp>
@@ -87,7 +91,7 @@ size_t xlsx_fills::size() const
     return impl_->fills_.size();
 }
 
-size_t xlsx_fills::fillId(	const odf_reader::text_format_properties_content		* textProp,
+size_t xlsx_fills::fillId(	const odf_reader::text_format_properties_content_ptr	textProp,
 							const odf_reader::paragraph_format_properties			* parProp,
 							const odf_reader::style_table_cell_properties_attlist	* cellProp, bool default_set)
 {
@@ -95,7 +99,7 @@ size_t xlsx_fills::fillId(	const odf_reader::text_format_properties_content		* t
     return fillId(textProp, parProp, cellProp,default_set, is_default);
 }
 
-size_t xlsx_fills::fillId(	const odf_reader::text_format_properties_content		* textProp,
+size_t xlsx_fills::fillId(	const odf_reader::text_format_properties_content_ptr	textProp,
 							const odf_reader::paragraph_format_properties			* parProp,
 							const odf_reader::style_table_cell_properties_attlist	* cellProp, 
 							bool default_set, bool & is_default)

ASCOfficeOdfFile/src/docx/xlsx_fills.h

@@ -40,7 +40,9 @@
 namespace cpdoccore { 
 namespace odf_reader {
 
-    class text_format_properties_content;
+	class text_format_properties_content;
+	typedef boost::shared_ptr<text_format_properties_content> text_format_properties_content_ptr;
+
     class paragraph_format_properties;
     class style_table_cell_properties_attlist;
 }
@@ -57,11 +59,11 @@ namespace oox {
     public:
         size_t size() const;
        
-		size_t fillId(	const odf_reader::text_format_properties_content		* textProp,
+		size_t fillId(	const odf_reader::text_format_properties_content_ptr	textProp,
 						const odf_reader::paragraph_format_properties			* parProp,
 						const odf_reader::style_table_cell_properties_attlist	* cellProp, bool  default_set);
 
-        size_t fillId(	const odf_reader::text_format_properties_content		* textProp,
+        size_t fillId(	const odf_reader::text_format_properties_content_ptr	textProp,
 						const odf_reader::paragraph_format_properties			* parProp,
 						const odf_reader::style_table_cell_properties_attlist	* cellProp, bool default_set,bool & is_default);
 

ASCOfficeOdfFile/src/docx/xlsx_font.cpp

@@ -263,19 +263,19 @@ std::size_t hash_value(xlsx_font const & val)
 
 //----------------------------------------------------------------------------------
 
-XlsxFontCharset GetXlsxFontCharset(const odf_reader::text_format_properties_content * textProp)
+XlsxFontCharset GetXlsxFontCharset(const odf_reader::text_format_properties_content_ptr textProp)
 {
     // TODO
     return XCHARSET_EMPTY;    
 }
 
-XlsxFontFamily GetXlsxFontFamily(const odf_reader::text_format_properties_content * textProp)
+XlsxFontFamily GetXlsxFontFamily(const odf_reader::text_format_properties_content_ptr textProp)
 {
     // TODO
     return XFAMILY_EMPTY;
 }
 
-xlsx_font::xlsx_font (	const odf_reader::text_format_properties_content		* textProp,
+xlsx_font::xlsx_font (	const odf_reader::text_format_properties_content_ptr	textProp,
 						const odf_reader::paragraph_format_properties			* parProp,
 						const odf_reader::style_table_cell_properties_attlist	* cellProp)
 {

ASCOfficeOdfFile/src/docx/xlsx_font.h

@@ -41,8 +41,10 @@
 namespace cpdoccore { 
 namespace odf_reader {
 
-    class text_format_properties_content;
-    class paragraph_format_properties;
+	class text_format_properties_content;
+	typedef boost::shared_ptr<text_format_properties_content> text_format_properties_content_ptr;
+
+	class paragraph_format_properties;
     class style_table_cell_properties_attlist;
 }
 }
@@ -104,7 +106,7 @@ namespace oox {
     struct xlsx_font
     {
 		xlsx_font () {};
-		xlsx_font (	const odf_reader::text_format_properties_content		* textProp,
+		xlsx_font (	const odf_reader::text_format_properties_content_ptr	textProp,
 					const odf_reader::paragraph_format_properties			* parProp,
 					const odf_reader::style_table_cell_properties_attlist	* cellProp);
 

ASCOfficeOdfFile/src/docx/xlsx_fonts.cpp

@@ -48,7 +48,7 @@ public:
 
 
     size_t size() const;
-    size_t fontId(	const odf_reader::text_format_properties_content		* textProp,
+    size_t fontId(	const odf_reader::text_format_properties_content_ptr	textProp,
 					const odf_reader::paragraph_format_properties			* parProp,
 					const odf_reader::style_table_cell_properties_attlist	* cellProp);
 
@@ -99,7 +99,7 @@ void xlsx_fonts::Impl::serialize(std::wostream & _Wostream) const
 	}
 }
 
-size_t xlsx_fonts::Impl::fontId(const odf_reader::text_format_properties_content		* textProp,
+size_t xlsx_fonts::Impl::fontId(const odf_reader::text_format_properties_content_ptr	textProp,
 								const odf_reader::paragraph_format_properties			* parProp,
 								const odf_reader::style_table_cell_properties_attlist	* cellProp)
 {
@@ -123,7 +123,7 @@ size_t xlsx_fonts::Impl::fontId(const odf_reader::text_format_properties_content
 //}
 
 /*
-int xlsx_fonts::Impl::getIndex(const odf_reader::text_format_properties_content * textProp,
+int xlsx_fonts::Impl::getIndex(const odf_reader::text_format_properties_content_ptr textProp,
                          const odf_reader::paragraph_format_properties * parProp,
                          const odf_reader::style_table_cell_properties_attlist * cellProp) const
 {
@@ -160,7 +160,7 @@ void xlsx_fonts::serialize(std::wostream & _Wostream) const
     return impl_->serialize(_Wostream);
 }
 
-size_t xlsx_fonts::fontId(const odf_reader::text_format_properties_content * textProp,
+size_t xlsx_fonts::fontId(const odf_reader::text_format_properties_content_ptr textProp,
     const odf_reader::paragraph_format_properties * parProp,
     const odf_reader::style_table_cell_properties_attlist * cellProp)
 {

ASCOfficeOdfFile/src/docx/xlsx_fonts.h

@@ -33,12 +33,15 @@
 
 #include <iosfwd>
 #include <CPScopedPtr.h>
+#include <boost/shared_ptr.hpp>
 
 namespace cpdoccore { 
 namespace odf_reader {
 
     class text_format_properties_content;
-    class paragraph_format_properties;
+	typedef boost::shared_ptr<text_format_properties_content> text_format_properties_content_ptr;
+
+	class paragraph_format_properties;
     class style_table_cell_properties_attlist;
 }
 }
@@ -57,7 +60,7 @@ namespace oox {
     public:
         size_t size() const;
         
-		size_t fontId(	const odf_reader::text_format_properties_content		* textProp,
+		size_t fontId(	const odf_reader::text_format_properties_content_ptr	textProp,
 						const odf_reader::paragraph_format_properties			* parProp,
 						const odf_reader::style_table_cell_properties_attlist	* cellProp);
 		const xlsx_font & getFont(size_t id) const;

ASCOfficeOdfFile/src/docx/xlsx_numFmts.cpp

@@ -30,62 +30,160 @@
  *
  */
 #include <vector>
+#include <map>
 #include <xml/utils.h>
+#include <xml/simple_xml_writer.h>
 
 #include "xlsx_numFmts.h"
+#include "../odf/datatypes/officevaluetype.h"
 
 namespace cpdoccore {
 namespace oox {
 
-struct xlsx_num_fmts::Impl
+class xlsx_num_fmts::Impl
 {
-    std::vector<std::wstring> formats_;
+private:
+	struct _desc
+	{
+		std::wstring code;
+		unsigned int id;
+	};
+    std::vector<_desc> arrFormats;
+	std::map<unsigned int, size_t> mapIdsFormat;
+	std::map<std::wstring, size_t> mapFormatsCode;
 
-    static size_t transform_id(size_t id)
-    {
-        return id + 164;
-    }
+	unsigned int last_custom_id = 164;
 
-    size_t num_format_id(const std::wstring & format_code);
+	unsigned int add(const std::wstring & format_code, unsigned int id);
+public:   
+	unsigned int add_or_find(const std::wstring & format_code, char type);
+	void serialize(std::wostream & _Wostream) const;
 };
-
-size_t xlsx_num_fmts::Impl::num_format_id(const std::wstring & format_code)
+unsigned int xlsx_num_fmts::Impl::add(const std::wstring & format_code, unsigned int id)
 {
-    for (size_t i = 0; i < formats_.size(); ++i)
-    {
-        if (formats_[i] == format_code)
-            return transform_id(i);
-    }
+	std::map<unsigned int, size_t>::iterator pFind = mapIdsFormat.find(id);
 
-    formats_.push_back(format_code);
-    return transform_id(formats_.size() - 1);            
+	if (pFind == mapIdsFormat.end())
+	{
+		mapIdsFormat.insert(std::make_pair(id, arrFormats.size()));
+		mapFormatsCode.insert(std::make_pair(format_code, arrFormats.size()));
+
+		_desc desc = {format_code, id};
+		arrFormats.push_back(desc);
+
+	}
+	else
+	{
+		//занято id для format_code -> следующий если есть берем
+		id = add(format_code, ++id);
+	}
+	return id;
+}
+unsigned int xlsx_num_fmts::Impl::add_or_find(const std::wstring & format_code, char format_code_type)
+{
+	if (format_code.empty()) return 0;
+
+	std::map<std::wstring, size_t>::iterator pFind = mapFormatsCode.find(format_code);
+
+	if (pFind != mapFormatsCode.end())
+	{
+		return arrFormats[pFind->second].id;
+	}
+	else
+	{ 
+		unsigned int id = 0;
+		if (format_code_type == odf_types::office_value_type::Currency)
+		{
+			if (std::wstring::npos != format_code.find(L"#,##0.00"))
+			{
+				if (std::wstring::npos != format_code.find(L"[Red]"))			id = 8; // "€"#,##0.00;[Red]\-"€"#,##0.00
+				else															id = 7; // "€"#,##0.00;\-"€"#,##0.00
+			}
+			else
+				id = last_custom_id++;
+		}
+		else if (format_code_type == odf_types::office_value_type::Date)
+		{
+			if (std::wstring::npos != format_code.find(L"mm-dd-yy"))			id = 14; 
+			else if (std::wstring::npos != format_code.find(L"d-mmm-yy"))		id = 15; 
+			else if (std::wstring::npos != format_code.find(L"d-mmm"))			id = 16; 
+			else if (std::wstring::npos != format_code.find(L"mmm-yy"))			id = 17; 
+			else if (std::wstring::npos != format_code.find(L"m/d/yy h:mm"))	id = 22; 
+			else
+				id = last_custom_id++;
+		}
+		else if (format_code_type == odf_types::office_value_type::Time)
+		{
+			if (std::wstring::npos != format_code.find(L"h:mm AM/PM"))			id = 18; 
+			else if (std::wstring::npos != format_code.find(L"h:mm:ss AM/PM"))	id = 19; 
+			else if (std::wstring::npos != format_code.find(L"h:mm"))			id = 20; 
+			else if (std::wstring::npos != format_code.find(L"h:mm:ss"))		id = 21; 
+			else if (std::wstring::npos != format_code.find(L"m/d/yy h:mm"))	id = 22; 
+			else
+				id = last_custom_id++;
+		}
+		else if (format_code_type == odf_types::office_value_type::Scientific)
+		{
+			if (std::wstring::npos != format_code.find(L"0.00E+00"))			id = 11;
+			else
+				id = last_custom_id++;
+		}
+		else if (format_code_type == odf_types::office_value_type::Fraction)
+		{
+			if (std::wstring::npos != format_code.find(L"??/??"))				id = 13;
+			else if (std::wstring::npos != format_code.find(L"?/?"))			id = 12; 
+			else
+				id = last_custom_id++;
+		}
+		else if (format_code_type == odf_types::office_value_type::Percentage)
+		{
+			if (std::wstring::npos != format_code.find(L"0.00%"))				id = 10;
+			else if (std::wstring::npos != format_code.find(L"0%"))				id = 9;
+			else
+				id = last_custom_id++;
+		}
+		else
+		{
+			id = last_custom_id++;
+		}
+		return add(format_code, id);
+	}
+}
+void xlsx_num_fmts::Impl::serialize(std::wostream & strm) const
+{
+    CP_XML_WRITER(strm)
+    {
+        CP_XML_NODE (L"numFmts")
+        {
+            CP_XML_ATTR (L"formatCode", arrFormats.size());
+			
+			for (size_t i = 0; i < arrFormats.size(); ++i)
+			{
+				CP_XML_NODE(L"numFmt")
+				{	
+					CP_XML_ATTR (L"numFmtId", arrFormats[i].id);
+					CP_XML_ATTR (L"formatCode", arrFormats[i].code);
+				}
+			}
+		}
+	}
 }
 
+//-----------------------------------------------------------------------------------------------------------------
 xlsx_num_fmts::xlsx_num_fmts() : impl_(new xlsx_num_fmts::Impl())
 {
 }
-
 xlsx_num_fmts::~xlsx_num_fmts()
-{}
-
-size_t xlsx_num_fmts::num_format_id(const std::wstring & format_code)
 {
-    return impl_->num_format_id(format_code);
 }
-
-void xlsx_num_fmts::serialize(std::wostream & _Wostream) const
+unsigned int xlsx_num_fmts::add_or_find(const std::wstring & format_code, char format_code_type)
 {
-    _Wostream << L"<numFmts count=\"" << impl_->formats_.size() << L"\">";
-    for (size_t i = 0; i < impl_->formats_.size(); ++i)
-    {
-        _Wostream << L"<numFmt formatCode=\"" << xml::utils::replace_text_to_xml(impl_->formats_[i]) <<
-            L"\" numFmtId=\"" << impl_->transform_id(i) << "\" />";
-    }
-        
-    _Wostream << L"</numFmts>";
+    return impl_->add_or_find(format_code, format_code_type);
+}
+void xlsx_num_fmts::serialize(std::wostream & strm) const
+{
+	impl_->serialize(strm);
 }
-
-
    
 }
 }

ASCOfficeOdfFile/src/docx/xlsx_numFmts.h

@@ -46,12 +46,12 @@ namespace oox {
     public:
         xlsx_num_fmts();
         ~xlsx_num_fmts();
-    public:
-        size_t num_format_id(const std::wstring & format_code);
-        void serialize(std::wostream & _Wostream) const;
+
+        unsigned int add_or_find(const std::wstring & format_code, char format_code_type);
+        void serialize(std::wostream & strm) const;
 
     private:
-        struct Impl;
+        class Impl;
         _CP_SCOPED_PTR(Impl) impl_;
     };
 }

ASCOfficeOdfFile/src/docx/xlsx_num_format_context.cpp

@@ -55,7 +55,6 @@ public:
     Impl(): in_convert_style_(false)
     {}
 
-public:
     std::wstring current_style_name_;
     std::wstringstream stream_;
 
@@ -64,9 +63,14 @@ public:
         current_style_name_ = L"";
         stream_.str(std::wstring());  
         in_convert_style_ = false;
+		type_ = odf_types::office_value_type::Custom;
     }
 
     std::wstring last_format_;
+	std::wstring last_date_format_ = L"yyyy.mmmm.dd";
+	std::wstring last_time_format_ = L"hh:mm:ss";
+
+	odf_types::office_value_type type_ = odf_types::office_value_type::Custom;
 
     bool in_convert_style_;
 };
@@ -81,7 +85,7 @@ num_format_context::~num_format_context()
 
 void num_format_context::start_format(const std::wstring & style_name)
 {
-    impl_->reset_current();
+	impl_->reset_current();
     impl_->current_style_name_ = style_name;
     impl_->in_convert_style_ = true;
 }
@@ -94,19 +98,38 @@ std::wostream & num_format_context::output()
 void num_format_context::end_format()
 {    
     impl_->last_format_ = impl_->stream_.str();
-    impl_->reset_current();
+
+	if (impl_->type_ == odf_types::office_value_type::Date)
+		impl_->last_date_format_ = impl_->last_format_;
+	
+	if (impl_->type_ == odf_types::office_value_type::Time)
+		impl_->last_time_format_ = impl_->last_format_;
 }
 
 std::wstring num_format_context::get_last_format() const
 {
     return impl_->last_format_;
 }
-
+std::wstring num_format_context::get_last_date_format() const
+{
+    return impl_->last_date_format_;
+}
+std::wstring num_format_context::get_last_time_format() const
+{
+    return impl_->last_time_format_;
+}
 void num_format_context::start_complex_format()
 {
     impl2_->complex_number_format_.reset();
 }
-
+odf_types::office_value_type::type num_format_context::type() const
+{
+    return impl_->type_.get_type();
+}
+void num_format_context::type(odf_types::office_value_type::type t)
+{
+    impl_->type_ = t;
+}
 void num_format_context::add_format(std::wstring const & cond, std::wstring const & format)
 {
     impl2_->complex_number_format_.add_format(cond, format);

ASCOfficeOdfFile/src/docx/xlsx_num_format_context.h

@@ -36,6 +36,8 @@
 #include <boost/noncopyable.hpp>
 #include <CPScopedPtr.h>
 
+#include "../odf/datatypes/officevaluetype.h"
+
 namespace cpdoccore {
 	namespace odf_reader
 	{
@@ -55,6 +57,11 @@ public:
     void end_format();
 
     std::wstring get_last_format() const;
+	std::wstring get_last_date_format() const;
+	std::wstring get_last_time_format() const;
+
+	odf_types::office_value_type::type type() const;
+	void type(odf_types::office_value_type::type t);
 
     void start_complex_format();
     void add_format(std::wstring const & cond, std::wstring const & format);
@@ -62,6 +69,8 @@ public:
 
 	//std::wstring default_data_style(int type);
 	odf_reader::odf_read_context & odf_context_;
+
+
 private:
     class Impl;
     _CP_SCOPED_PTR(Impl) impl_;

ASCOfficeOdfFile/src/docx/xlsx_output_xml.cpp

@@ -227,6 +227,8 @@ void xlsx_xml_worksheet::write_to(std::wostream & strm)
 
 			CP_XML_STREAM() << impl_->header_footer_.str();
 			
+			CP_XML_STREAM() << impl_->breaks_.str();
+			
 			if (false == impl_->drawingId_.empty())
 			{
 				CP_XML_NODE(L"drawing")
@@ -263,10 +265,6 @@ void xlsx_xml_worksheet::write_to(std::wostream & strm)
 				}
 			}
 			CP_XML_STREAM() << impl_->picture_background_.str();
-
-			//или тут ??? headerFooter
-
-			CP_XML_STREAM() << impl_->breaks_.str();
 		}
     }
 }

ASCOfficeOdfFile/src/docx/xlsx_pivots_context.cpp

@@ -1513,12 +1513,15 @@ void xlsx_pivots_context::add_field_cache(int index, std::wstring value, bool sh
 			//XmlUtils::replace_all(value, L" ", L"");
 			//XmlUtils::replace_all(value, L"\x00A0", L"");		
 		}
-		if (oox::IsNumber(value))
+		std::wstring strNumber = oox::GetNumberFromString(value);
+		if (false == strNumber.empty())
 		{
 			try
 			{	
-				XmlUtils::replace_all(value, L",", L".");
-				dVal = boost::lexical_cast<double>(value);
+				XmlUtils::replace_all(strNumber, L" ", L"");
+				XmlUtils::replace_all(strNumber, L",", L".");
+				
+				dVal = boost::lexical_cast<double>(strNumber);
 			}
 			catch(...)
 			{
@@ -1529,7 +1532,7 @@ void xlsx_pivots_context::add_field_cache(int index, std::wstring value, bool sh
 			node_name = L"n";
 
 			_INT64 iVal = *dVal;
-			if (abs(iVal - *dVal) > 0.00001)
+			if ( *dVal - iVal > 0.00001)
 			{
 				value = std::to_wstring(*dVal);
 				impl_->current_.fields.back().bNumber = true;

ASCOfficeOdfFile/src/docx/xlsx_styles.cpp

@@ -29,10 +29,6 @@
  * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
  *
  */
-
-#include "../odf/style_text_properties.h"
-#include "../odf/style_paragraph_properties.h"
-
 #include "xlsxconversioncontext.h"
 #include "xlsx_fonts.h"
 #include "xlsx_xf.h"
@@ -43,6 +39,9 @@
 #include "xlsx_cell_styles.h"
 #include "xlsx_numFmts.h"
 
+#include "../odf/style_text_properties.h"
+#include "../odf/style_paragraph_properties.h"
+
 #include <boost/unordered_set.hpp>
 #include <boost/functional.hpp>
 
@@ -58,13 +57,13 @@ public:
    
 	size_t size() const;
    
-	size_t xfId(	const odf_reader::text_format_properties_content		* textProp,
+	size_t xfId(	const odf_reader::text_format_properties_content_ptr	textProp,
 					const odf_reader::paragraph_format_properties			* parProp,
 					const odf_reader::style_table_cell_properties_attlist	* cellProp,
 					const xlsx_cell_format * xlxsCellFormat,
-					const std::wstring &num_format, bool  default_set, bool & is_visible);
+					const std::wstring &num_format, odf_types::office_value_type::type num_format_type, bool  default_set, bool & is_visible);
 	
-	size_t dxfId(	const odf_reader::text_format_properties_content		* textProp,
+	size_t dxfId(	const odf_reader::text_format_properties_content_ptr	textProp,
 					const odf_reader::graphic_format_properties				* graphProp,
 					const odf_reader::style_table_cell_properties_attlist	* cellProp);
 
@@ -110,19 +109,21 @@ size_t xlsx_style_manager::Impl::size() const
     return cellXfs_.size();
 }
 
-size_t xlsx_style_manager::Impl::dxfId(	const odf_reader::text_format_properties_content	* textProp,
-										const odf_reader::graphic_format_properties			* graphProp,
+size_t xlsx_style_manager::Impl::dxfId(	const odf_reader::text_format_properties_content_ptr	textProp,
+										const odf_reader::graphic_format_properties				* graphProp,
 										const odf_reader::style_table_cell_properties_attlist	* cellProp)
 {
 	return dxfs_.dxfId(textProp, graphProp, cellProp);
 }
 
-size_t xlsx_style_manager::Impl::xfId(const odf_reader::text_format_properties_content		* textProp,
+size_t xlsx_style_manager::Impl::xfId(const odf_reader::text_format_properties_content_ptr	textProp,
                                       const odf_reader::paragraph_format_properties			* parProp,
                                       const odf_reader::style_table_cell_properties_attlist * cellProp,
                                       const xlsx_cell_format								* xlxsCellFormat,
 
-                                      const std::wstring &num_format, bool  default_set, bool & is_visible )
+                                      const std::wstring &num_format, odf_types::office_value_type::type num_format_type, 
+									  
+									  bool  default_set, bool & is_visible )
 {
 	bool is_visible_set = is_visible;
     const size_t fontId = fonts_.fontId(textProp, parProp, cellProp);
@@ -147,7 +148,7 @@ size_t xlsx_style_manager::Impl::xfId(const odf_reader::text_format_properties_c
     xfRecord.applyBorder = true;
     xfRecord.borderId = borderId;
 
-    xfRecord.applyFill = true; // TODO
+    xfRecord.applyFill = true;
     xfRecord.fillId = fillId;
     
     xfRecord.applyFont = true;
@@ -155,10 +156,10 @@ size_t xlsx_style_manager::Impl::xfId(const odf_reader::text_format_properties_c
     
     xfRecord.applyProtection = false; // TODO
 
-    if (!num_format.empty())
+    if (false == num_format.empty())
     {
         xfRecord.applyNumberForm = true;
-        xfRecord.numFmtId = numFmts_.num_format_id(num_format);
+        xfRecord.numFmtId = numFmts_.add_or_find(num_format, num_format_type);
     }
     else
 		if (xlxsCellFormat && 
@@ -248,25 +249,25 @@ size_t xlsx_style_manager::size() const
     return impl_->size();
 }
 
-size_t xlsx_style_manager::xfId(const odf_reader::text_format_properties_content		* textProp,
+size_t xlsx_style_manager::xfId(const odf_reader::text_format_properties_content_ptr	textProp,
                                 const odf_reader::paragraph_format_properties			* parProp,
                                 const odf_reader::style_table_cell_properties_attlist	* cellProp,
                                 const xlsx_cell_format * xlxsCellFormat,
-                                const std::wstring &num_format, bool  default_set)
+                                const std::wstring &num_format, char num_format_type, bool  default_set)
 {
     bool is_visible;
-    return impl_->xfId(textProp, parProp, cellProp, xlxsCellFormat, num_format, default_set, is_visible);
+    return impl_->xfId(textProp, parProp, cellProp, xlxsCellFormat, num_format, (odf_types::office_value_type::type) num_format_type, default_set, is_visible);
 }
 
-size_t xlsx_style_manager::xfId(const odf_reader::text_format_properties_content		* textProp,
+size_t xlsx_style_manager::xfId(const odf_reader::text_format_properties_content_ptr	textProp,
                                 const odf_reader::paragraph_format_properties			* parProp,
                                 const odf_reader::style_table_cell_properties_attlist	* cellProp,
                                 const xlsx_cell_format * xlxsCellFormat,
-                                const std::wstring &num_format, bool  default_set, bool & is_visible)
+                                const std::wstring &num_format, char num_format_type, bool  default_set, bool & is_visible)
 {
-    return impl_->xfId(textProp, parProp, cellProp, xlxsCellFormat, num_format, default_set,is_visible);
+    return impl_->xfId(textProp, parProp, cellProp, xlxsCellFormat, num_format, (odf_types::office_value_type::type)num_format_type, default_set,is_visible);
 }
-size_t xlsx_style_manager::dxfId(const odf_reader::text_format_properties_content		* textProp,
+size_t xlsx_style_manager::dxfId(const odf_reader::text_format_properties_content_ptr	textProp,
 								 const odf_reader::graphic_format_properties			* graphProp,
 								 const odf_reader::style_table_cell_properties_attlist	* cellProp)
 {

ASCOfficeOdfFile/src/docx/xlsx_styles.h

@@ -38,10 +38,12 @@
 namespace cpdoccore {
 namespace odf_reader {
 
-	class text_format_properties_content;
 	class graphic_format_properties;
 	class paragraph_format_properties;
 	class style_table_cell_properties_attlist;
+	
+	class text_format_properties_content;
+	typedef boost::shared_ptr<text_format_properties_content> text_format_properties_content_ptr;
 }
 
 namespace oox {
@@ -55,19 +57,19 @@ public:
     xlsx_style_manager(xlsx_conversion_context *context);
     size_t size() const;
     
-	size_t xfId(const odf_reader::text_format_properties_content		* textProp,
+	size_t xfId(const odf_reader::text_format_properties_content_ptr	textProp,
 				const odf_reader::paragraph_format_properties			* parProp,
 				const odf_reader::style_table_cell_properties_attlist	* cellProp,
 				const xlsx_cell_format * xlxsCellFormat,
-				const std::wstring &num_format,  bool  default_set,bool & is_visible);
+				const std::wstring &num_format, char num_format_type, bool  default_set, bool & is_visible);
 
-    size_t xfId(const odf_reader::text_format_properties_content		* textProp,
+    size_t xfId(const odf_reader::text_format_properties_content_ptr	textProp,
 				const odf_reader::paragraph_format_properties			* parProp,
 				const odf_reader::style_table_cell_properties_attlist	* cellProp,
 				const xlsx_cell_format * xlxsCellFormat,
-				const std::wstring &num_format, bool  default_set);
+				const std::wstring &num_format, char num_format_type, bool  default_set);
 
-    size_t dxfId(const odf_reader::text_format_properties_content		* textProp,
+    size_t dxfId(const odf_reader::text_format_properties_content_ptr	textProp,
 				 const odf_reader::graphic_format_properties			* graphProp,
 				 const odf_reader::style_table_cell_properties_attlist	* cellProp);
 

ASCOfficeOdfFile/src/docx/xlsx_tablecontext.cpp

@@ -137,7 +137,7 @@ void xlsx_table_context::end_database_range()
 
 void xlsx_table_context::set_database_range_value(int index, const std::wstring& value)
 {
-	if (index < 0 || index > xlsx_data_ranges_.size()) return;
+	if (index < 0 || index > (int)xlsx_data_ranges_.size()) return;
 
 	size_t col = state()->current_column();
 	size_t row = state()->current_row();

ASCOfficeOdfFile/src/docx/xlsx_textcontext.cpp

@@ -41,15 +41,14 @@
 #include <xml/utils.h>
 
 #include "../odf/odfcontext.h"
-#include "../odf/style_text_properties.h"
-#include "../odf/style_paragraph_properties.h"
 #include "../odf/calcs_styles.h"
 
+#include "../odf/style_paragraph_properties.h"
+#include "../odf/style_text_properties.h"
 
 namespace cpdoccore {
 namespace oox {
 
-
 class xlsx_text_context::Impl: boost::noncopyable
 {
 public:
@@ -65,7 +64,7 @@ public:
     std::wstring	end_span2();
 
     void			start_cell_content();
-	void			set_cell_text_properties( odf_reader::text_format_properties_content * text_properties);
+	void			set_cell_text_properties( odf_reader::text_format_properties_content_ptr text_properties);
     int				end_cell_content();
 
 	void			start_comment_content();
@@ -100,10 +99,11 @@ private:
 	bool only_text;
 
 	odf_reader::styles_container				& styles_;
-	odf_reader::text_format_properties_content	* text_properties_cell_;
 	odf_reader::styles_container				* local_styles_ptr_;
 
-    std::wstring	dump_paragraph();
+	odf_reader::text_format_properties_content_ptr text_properties_cell_;
+   
+	std::wstring	dump_paragraph();
 	std::wstring	dump_run();
 
     void write_rPr(std::wostream & strm);
@@ -281,10 +281,14 @@ void xlsx_text_context::Impl::ApplyTextProperties(std::wstring style, std::wstri
 	if (paraStyle)		instances.push_back(paraStyle);
 	if (textStyle)		instances.push_back(textStyle);
 
-	propertiesOut.apply_from(calc_text_properties_content(instances));
+	odf_reader::text_format_properties_content_ptr text_props = calc_text_properties_content(instances);
+	if (text_props)
+	{
+		propertiesOut.apply_from(*text_props.get());
+	}
 }
 
-void xlsx_text_context::Impl::set_cell_text_properties(odf_reader::text_format_properties_content * text_properties)
+void xlsx_text_context::Impl::set_cell_text_properties(odf_reader::text_format_properties_content_ptr text_properties)
 {
 	text_properties_cell_ = text_properties;
 }
@@ -324,11 +328,24 @@ void xlsx_text_context::Impl::write_rPr(std::wostream & strm)
 		{
 			CP_XML_NODE(L"rPr")
 			{
-				if (text_properties_.fo_font_family_)
+				if (text_properties_.fo_font_weight_)
 				{
-					CP_XML_NODE(L"rFont")	
+					CP_XML_NODE(L"b")		
 					{
-						CP_XML_ATTR(L"val", text_properties_.fo_font_family_.get());
+						if (text_properties_.fo_font_weight_->get_type() > 0)
+							CP_XML_ATTR(L"val", "true");
+						else
+							CP_XML_ATTR(L"val", "false");
+					}
+				}
+				if (text_properties_.fo_font_style_)
+				{
+					CP_XML_NODE(L"i")		
+					{
+						if (text_properties_.fo_font_style_->get_type() > 0)
+							CP_XML_ATTR(L"val", "true");
+						else 
+							CP_XML_ATTR(L"val", "false");
 					}
 				}
 				if (text_properties_.fo_font_size_)
@@ -345,24 +362,11 @@ void xlsx_text_context::Impl::write_rPr(std::wostream & strm)
 						CP_XML_ATTR(L"rgb", text_properties_.fo_color_->get_hex_value());
 					}
 				}
-				if (text_properties_.fo_font_style_)
+				if (text_properties_.fo_font_family_)
 				{
-					CP_XML_NODE(L"i")		
+					CP_XML_NODE(L"rFont")	
 					{
-						if (text_properties_.fo_font_style_->get_type() > 0)
-							CP_XML_ATTR(L"val", "true");
-						else 
-							CP_XML_ATTR(L"val", "false");
-					}
-				}
-				if (text_properties_.fo_font_weight_)
-				{
-					CP_XML_NODE(L"b")		
-					{
-						if (text_properties_.fo_font_weight_->get_type() > 0)
-							CP_XML_ATTR(L"val", "true");
-						else
-							CP_XML_ATTR(L"val", "false");
+						CP_XML_ATTR(L"val", text_properties_.fo_font_family_.get());
 					}
 				}
 			}
@@ -582,7 +586,7 @@ void xlsx_text_context::set_local_styles_container(odf_reader::styles_container*
 	return impl_->set_local_styles_container(local_styles_);
 }
 
-void xlsx_text_context::set_cell_text_properties(odf_reader::text_format_properties_content *text_properties)
+void xlsx_text_context::set_cell_text_properties(odf_reader::text_format_properties_content_ptr text_properties)
 {
 	return impl_->set_cell_text_properties(text_properties);
 }

ASCOfficeOdfFile/src/docx/xlsx_textcontext.h

@@ -46,6 +46,7 @@ namespace odf_reader
 	typedef boost::shared_ptr<styles_container> styles_container_ptr;
 	
 	class text_format_properties_content;
+	typedef boost::shared_ptr<text_format_properties_content> text_format_properties_content_ptr;
 };
 namespace oox {
 	
@@ -58,7 +59,7 @@ public:
     ~xlsx_text_context	();
 
 	void set_local_styles_container	(odf_reader::styles_container *local_styles_);
-	void set_cell_text_properties	(odf_reader::text_format_properties_content *text_properties);    
+	void set_cell_text_properties	(odf_reader::text_format_properties_content_ptr text_properties);    
     
     void			start_paragraph(const std::wstring & styleName);
     void			end_paragraph();

ASCOfficeOdfFile/src/docx/xlsx_utils.cpp

@@ -51,7 +51,18 @@ bool IsNumber(const std::wstring &value)
 
 	return boost::regex_search(value/*.begin(), value.end(), results*/, rule);
 }
+std::wstring GetNumberFromString(const std::wstring &value)
+{
+	boost::wregex rule(L"^\\s*\\-{0,1}[0-9]*[.,]{0,1}[0-9]*\\s*$");
+	boost::match_results<std::wstring::const_iterator> results;
 
+    if (boost::regex_match(value, results, rule))
+    {
+        return (results[0].str());
+	}
+	else
+		return L"";
+}
 std::wstring getColAddress(size_t col)
 {
     static const size_t r = (L'Z' - L'A' + 1);
@@ -165,17 +176,20 @@ bool parseBoolVal(const std::wstring & str)
 {
     std::wstring s = str;
     boost::algorithm::to_lower(s);
-    if (L"true" == str || L"1" == str)
-        return true;
-    else
+    
+	if (L"false" == str || L"0" == str)
         return false;
+    else
+        return true;
 }
 
 std::wstring cellType2Str(XlsxCellType::type type)
 {
     switch(type)
     {
-    case XlsxCellType::b:
+	case XlsxCellType::d:
+        return L"d";
+	case XlsxCellType::b:
         return L"b";
     case XlsxCellType::n:
         return L"n";

ASCOfficeOdfFile/src/docx/xlsx_utils.h

@@ -41,6 +41,7 @@ namespace cpdoccore {
 namespace oox {
 
 bool IsNumber(const std::wstring &value);
+std::wstring GetNumberFromString(const std::wstring &value);
 
 std::wstring getColAddress(size_t col);
 std::wstring getRowAddress(size_t row);

ASCOfficeOdfFile/src/docx/xlsxconversioncontext.cpp

@@ -122,7 +122,7 @@ void xlsx_conversion_context::start_document()
 	instances.push_back(odfContext.styleContainer().style_default_by_type(odf_types::style_family::TableCell));
 	instances.push_back(odfContext.styleContainer().style_by_name(L"Default", odf_types::style_family::TableCell, false));
 
-    odf_reader::text_format_properties_content		textFormatProperties	= calc_text_properties_content(instances);
+    odf_reader::text_format_properties_content_ptr	textFormatProperties	= calc_text_properties_content(instances);
     odf_reader::paragraph_format_properties			parFormatProperties		= calc_paragraph_properties_content(instances);
     odf_reader::style_table_cell_properties_attlist	cellFormatProperties	= calc_table_cell_properties(instances);
 
@@ -131,7 +131,7 @@ void xlsx_conversion_context::start_document()
 	cellFormat.set_cell_type(XlsxCellType::s);
     cellFormat.set_num_format(oox::odf_string_to_build_in(0));
 
-    default_style_ = get_style_manager().xfId(&textFormatProperties, &parFormatProperties, &cellFormatProperties, &cellFormat, L"", true);
+    default_style_ = get_style_manager().xfId(textFormatProperties, &parFormatProperties, &cellFormatProperties, &cellFormat, L"", 0, true);
 
 }
 
@@ -665,12 +665,12 @@ int xlsx_conversion_context::get_current_cell_style_id()
     return get_table_context().get_current_cell_style_id();
 }
 
-std::pair<float,float> xlsx_conversion_context::getMaxDigitSize()
+std::pair<double, double> xlsx_conversion_context::getMaxDigitSize()
 {
     if (maxDigitSize_.first <= 0.1)
     {
 		std::wstring font_name;
-		int font_size;
+		int font_size = 10;
 
 		std::vector<const odf_reader::style_instance *> instances;
 		
@@ -687,31 +687,32 @@ std::pair<float,float> xlsx_conversion_context::getMaxDigitSize()
 			if (inst) instances.push_back(inst);
 		}
 
-		odf_reader::text_format_properties_content textFormatProperties	= calc_text_properties_content(instances);
+		odf_reader::text_format_properties_content_ptr textFormatProperties	= calc_text_properties_content(instances);
 
-		if (textFormatProperties.fo_font_family_)
-			font_name = textFormatProperties.fo_font_family_.get();
-		else
+		if (textFormatProperties)
 		{
-			std::wstring style_font_name;
-			if (textFormatProperties.style_font_name_)				style_font_name = textFormatProperties.style_font_name_.get();
-			else if (textFormatProperties.style_font_name_complex_)	style_font_name = textFormatProperties.style_font_name_complex_.get();
-			else if (textFormatProperties.style_font_name_asian_)	style_font_name = textFormatProperties.style_font_name_asian_.get();
-			
-			odf_reader::fonts_container & fonts = odf_document_->odf_context().fontContainer();
-			odf_reader::font_instance * font = fonts.font_by_style_name(style_font_name);
-			if (font)
+			if (textFormatProperties->fo_font_family_)
+				font_name = textFormatProperties->fo_font_family_.get();
+			else
 			{
-				font_name = font->name();
+				std::wstring style_font_name;
+				
+				if (textFormatProperties->style_font_name_)					style_font_name = textFormatProperties->style_font_name_.get();
+				else if (textFormatProperties->style_font_name_complex_)	style_font_name = textFormatProperties->style_font_name_complex_.get();
+				else if (textFormatProperties->style_font_name_asian_)		style_font_name = textFormatProperties->style_font_name_asian_.get();
+				
+				odf_reader::fonts_container & fonts = odf_document_->odf_context().fontContainer();
+				odf_reader::font_instance * font = fonts.font_by_style_name(style_font_name);
+				if (font)
+				{
+					font_name = font->name();
+				}
 			}
+			if ((textFormatProperties->fo_font_size_) && (textFormatProperties->fo_font_size_->get_type() == odf_types::font_size::Length))
+				font_size = (int)(0.5 + textFormatProperties->fo_font_size_->get_length().get_value_unit(odf_types::length::pt));
 		}
 		if (font_name.empty()) font_name = L"Arial";
-
-		if ((textFormatProperties.fo_font_size_) && (textFormatProperties.fo_font_size_->get_type() == odf_types::font_size::Length))
-			font_size = (int)(0.5 + textFormatProperties.fo_font_size_->get_length().get_value_unit(odf_types::length::pt));
-		else
-			font_size =10;
-		
+	
         maxDigitSize_ = utils::GetMaxDigitSizePixels(font_name.c_str(), font_size, 96., 0, mediaitems_->applicationFonts());
     }    
     return maxDigitSize_;

ASCOfficeOdfFile/src/docx/xlsxconversioncontext.h

@@ -163,7 +163,7 @@ public:
         return odf_document_;
     }
 
-    std::pair<float,float> getMaxDigitSize();
+    std::pair<double, double> getMaxDigitSize();
 
     void process_styles();
 
@@ -207,7 +207,7 @@ private:
 	std::vector<std::wstring>			table_parts_;
  
     std::wstringstream                  defaultOutput_;
-    std::pair<float,float>              maxDigitSize_;
+    std::pair<double, double>              maxDigitSize_;
     num_format_context                  num_format_context_;
     size_t                              default_style_;
     mediaitems_ptr						mediaitems_;

ASCOfficeOdfFile/src/odf/calcext_elements.cpp

@@ -276,11 +276,11 @@ void calcext_condition::xlsx_convert(oox::xlsx_conversion_context & Context)
 		instStyle = Context.root()->odf_context().styleContainer().style_by_display_name(style_name, style_family::TableCell, false);
 	if (instStyle)
 	{
-		text_format_properties_content		textFormats		= calc_text_properties_content		(instStyle);
+		text_format_properties_content_ptr	textFormats		= calc_text_properties_content		(instStyle);
 		graphic_format_properties			graphicFormats	= calc_graphic_properties_content	(instStyle);
 		style_table_cell_properties_attlist	cellFormats		= calc_table_cell_properties		(instStyle);
 	
-		int dxfId = Context.get_style_manager().dxfId(&textFormats, &graphicFormats, &cellFormats);
+		int dxfId = Context.get_style_manager().dxfId(textFormats, &graphicFormats, &cellFormats);
 		Context.set_conditional_format_dxf(dxfId);
 	}
 	Context.end_conditional_format_rule();

ASCOfficeOdfFile/src/odf/calcs_styles.cpp

@@ -39,18 +39,21 @@ namespace cpdoccore {
 
 namespace odf_reader {
 
-text_format_properties_content calc_text_properties_content(const std::vector<const style_text_properties*> & textProps)
+text_format_properties_content_ptr calc_text_properties_content(const std::vector<const style_text_properties*> & textProps)
 {
-    text_format_properties_content result;
- 	for (size_t i = 0; i < textProps.size(); i++)
+	if (textProps.empty()) return text_format_properties_content_ptr();
+
+	text_format_properties_content_ptr result = boost::make_shared<text_format_properties_content>();
+ 	
+	for (size_t i = 0; i < textProps.size(); i++)
     {
         if (textProps[i])
-            result.apply_from(textProps[i]->content());
+            result->apply_from(textProps[i]->content());
     }
     return result;
 }
 
-text_format_properties_content calc_text_properties_content(const style_instance * styleInstance)
+text_format_properties_content_ptr calc_text_properties_content(const style_instance * styleInstance)
 {
     std::vector<const style_text_properties*> textProps;
 
@@ -67,12 +70,19 @@ text_format_properties_content calc_text_properties_content(const style_instance
     return calc_text_properties_content(textProps);
 }
 
-text_format_properties_content calc_text_properties_content(const std::vector<const style_instance *> & styleInstances)
+text_format_properties_content_ptr calc_text_properties_content(const std::vector<const style_instance *> & styleInstances)
 {
-    text_format_properties_content result;
+	if (styleInstances.empty()) return text_format_properties_content_ptr();
+
+	text_format_properties_content_ptr result = boost::make_shared<text_format_properties_content>();
+
  	for (size_t i = 0; i < styleInstances.size(); i++)
     {
-        result.apply_from(calc_text_properties_content(styleInstances[i]));
+		text_format_properties_content_ptr props = calc_text_properties_content(styleInstances[i]);
+		if (props)
+		{
+			result->apply_from(*props.get());
+		}
     }
     return result;
 }