.

Before:
```
real    3m6,793s
user    0m28,249s
sys     0m5,641s
```

After:
```
real    0m13,834s
user    0m2,169s
sys     0m0,838s
```

ASCOfficeDocFile/DocDocxConverter/DocumentMapping.cpp

@@ -800,8 +800,9 @@ namespace DocFileFormat
 					}
 				}
 				XMLTools::XMLElement elem(L"w:br");
-                elem.AppendAttribute(L"w:type", L"textWrapping");
-                elem.AppendAttribute(L"w:clear", L"all");
+				//СЗ в МРФ Техноград о предоставлении ТП 1 квартал 2019_MO_Q31.doc
+                //elem.AppendAttribute(L"w:type", L"textWrapping");
+                //elem.AppendAttribute(L"w:clear", L"all");
 
 				m_pXmlWriter->WriteString(elem.GetXMLString());
 			}

ASCOfficeDocxFile2/BinReader/Readers.cpp

@@ -4236,15 +4236,15 @@ int Binary_DocumentTableReader::ReadParagraphContent(BYTE type, long length, voi
 	}
 	else if ( c_oSerParType::OMathPara == type )
 	{
-        m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("<m:oMathPara>")));
+        GetRunStringWriter().WriteString(std::wstring(_T("<m:oMathPara>")));
 		READ1_DEF(length, res, this->ReadMathOMathPara, poResult);
-        m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("</m:oMathPara>")));
+        GetRunStringWriter().WriteString(std::wstring(_T("</m:oMathPara>")));
 	}
 	else if ( c_oSerParType::OMath == type )
 	{
-        m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("<m:oMath>")));
+        GetRunStringWriter().WriteString(std::wstring(_T("<m:oMath>")));
 		READ1_DEF(length, res, this->ReadMathArg, poResult);
-        m_oDocumentWriter.m_oContent.WriteString(std::wstring(_T("</m:oMath>")));
+        GetRunStringWriter().WriteString(std::wstring(_T("</m:oMath>")));
 	}
 	else if ( c_oSerParType::MRun == type )
 	{

ASCOfficeOdfFile/formulasconvert/formulasconvert_odf.cpp

@@ -122,27 +122,64 @@ namespace formulasconvert {
 			XmlUtils::replace_all( expr, L"SCOBCAIN", L"(");
 			XmlUtils::replace_all( expr, L"SCOBCAOUT", L")");
 
-			XmlUtils::replace_all( expr, L"KVADRATIN", L"[");
-			XmlUtils::replace_all( expr, L"KVADRATOUT", L"]");
+			//XmlUtils::replace_all( expr, L"KVADRATIN", L"[");
+			//XmlUtils::replace_all( expr, L"KVADRATOUT", L"]");
 			
 			XmlUtils::replace_all( expr, L"PROBEL", L" ");
-			XmlUtils::replace_all( expr, L"APOSTROF", L"'");	
-			XmlUtils::replace_all( expr, L"KAVYCHKA", L"\"");
+			//XmlUtils::replace_all( expr, L"APOSTROF", L"'");	
+			//XmlUtils::replace_all( expr, L"KAVYCHKA", L"\"");
 		}
 		static void replace_tmp(std::wstring &expr)
 		{
-			XmlUtils::replace_all( expr, L".", L"ТОСHKA");
-			XmlUtils::replace_all( expr, L"!", L"VOSKL");
+		//	XmlUtils::replace_all( expr, L".", L"ТОСHKA");
+		//	XmlUtils::replace_all( expr, L"!", L"VOSKL");
 
-			XmlUtils::replace_all( expr, L"(", L"SCOBCAIN");
-			XmlUtils::replace_all( expr, L")", L"SCOBCAOUT");
+		//	XmlUtils::replace_all( expr, L"(", L"SCOBCAIN");
+		//	XmlUtils::replace_all( expr, L")", L"SCOBCAOUT");
 
-			//XmlUtils::replace_all( expr, L"[", L"KVADRATIN");
-			//XmlUtils::replace_all( expr, L"]", L"KVADRATOUT");
-			
-			XmlUtils::replace_all( expr, L" ", L"PROBEL");
-		//	XmlUtils::replace_all( expr, L"'", L"APOSTROF");	
-		//	XmlUtils::replace_all( expr, L"\"", L"KAVYCHKA");
+		//	//XmlUtils::replace_all( expr, L"[", L"KVADRATIN");
+		//	//XmlUtils::replace_all( expr, L"]", L"KVADRATOUT");
+		//	
+		//	XmlUtils::replace_all( expr, L" ", L"PROBEL");
+		////	XmlUtils::replace_all( expr, L"'", L"APOSTROF");	
+		////	XmlUtils::replace_all( expr, L"\"", L"KAVYCHKA");
+
+			std::wstring result;
+
+			size_t pos = 0, size = expr.length();
+
+			while(pos < size)
+			{
+				switch(expr[pos])
+				{
+					case '.':
+					{	
+						result += L"ТОСHKA";
+					}break;
+					case '!':
+					{
+						result += L"VOSKL";
+					}break;
+					case '(':
+					{
+						result += L"SCOBCAIN";
+					}break;
+					case ')':
+					{
+						result += L"SCOBCAOUT";
+					}break;
+					case ' ':
+					{
+						result += L"PROBEL";
+					}break;
+					default:
+					{
+						result += expr[pos];
+					}break;
+				}
+				pos++;
+			}
+		expr = result;
 		}
 		static std::wstring convert_scobci(boost::wsmatch const & what)
 		{

ASCOfficeOdfFile/formulasconvert/formulasconvert_oox.cpp

@@ -133,36 +133,202 @@ public:
 	}
 	static void oox_replace_tmp_back(std::wstring &expr)
 	{
-		XmlUtils::replace_all( expr, L"MINYS", L"-");
-		XmlUtils::replace_all( expr, L"ТОСHKA", L".");
-		XmlUtils::replace_all( expr, L"VOSKL", L"!");
+		std::wstring result;
 
-		XmlUtils::replace_all( expr, L"SCOBCAIN", L"(");
-		XmlUtils::replace_all( expr, L"SCOBCAOUT", L")");
+		size_t pos = 0, size = expr.length();
 
-		XmlUtils::replace_all( expr, L"KVADRATIN", L"[");
-		XmlUtils::replace_all( expr, L"KVADRATOUT", L"]");
-		
-		XmlUtils::replace_all( expr, L"PROBEL", L" ");
-		XmlUtils::replace_all( expr, L"APOSTROF", L"'");	
-		XmlUtils::replace_all( expr, L"KAVYCHKA", L"\"");
+		while(pos < size)
+		{
+			if (pos + 5 >= size)
+			{
+				result += expr[pos++];
+				continue;
+			}
+			switch(expr[pos])
+			{
+				case 'M':
+				{
+					if ((pos + 5 < size) && (expr.substr(pos, 5) == L"MINYS"))
+					{
+						result += L"-"; pos += 5;
+					}
+					else
+					{
+						result += expr[pos++];
+					}
+				}break;
+				case 'T':
+				{	
+					if ((pos + 6 < size) && (expr.substr(pos, 6) == L"ТОСHKA"))
+					{
+						result += L"."; pos += 6;
+					}
+					else
+					{
+						result += expr[pos++];
+					}
+				}break;
+				case 'V':
+				{
+					if ((pos + 5 < size) && (expr.substr(pos, 5) == L"VOSKL"))
+					{
+						result += L"!"; pos += 5;
+					}
+					else
+					{
+						result += expr[pos++];
+					}
+				}break;
+				case 'S':
+				{
+					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"))
+					{
+						result += L")"; pos += 9;
+					}
+					else
+					{
+						result += expr[pos++];
+					}
+				}break;
+				case 'K':
+				{
+					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"))
+					{
+						result += L"]"; pos += 10;
+					}
+					else if ((pos + 8 < size) && (expr.substr(pos, 8) == L"KAVYCHKA"))
+					{
+						result += L"\""; pos += 8;
+					}
+					else
+					{
+						result += expr[pos++];
+					}
+				}break;
+				case 'P':
+				{
+					if ((pos + 6 < size) && (expr.substr(pos, 6) == L"PROBEL"))
+					{
+						result += L" "; pos += 6;
+					}
+					else
+					{
+						result += expr[pos++];
+					}
+				}break;
+				case 'A':
+				{
+					if ((pos + 8 < size) && (expr.substr(pos, 8) == L"APOSTROF"))
+					{
+						result += L"'"; pos += 8;
+					}
+					else
+					{
+						result += expr[pos++];
+					}
+				}break;
+				default:
+				{
+					result += expr[pos++];
+				}break;
+			}
+		}
+		expr = result;
+		//XmlUtils::replace_all( expr, L"MINYS", L"-");
+		//XmlUtils::replace_all( expr, L"ТОСHKA", L".");
+		//XmlUtils::replace_all( expr, L"VOSKL", L"!");
+
+		//XmlUtils::replace_all( expr, L"SCOBCAIN", L"(");
+		//XmlUtils::replace_all( expr, L"SCOBCAOUT", L")");
+
+		//XmlUtils::replace_all( expr, L"KVADRATIN", L"[");
+		//XmlUtils::replace_all( expr, L"KVADRATOUT", L"]");
+		//
+		//XmlUtils::replace_all( expr, L"PROBEL", L" ");
+		//XmlUtils::replace_all( expr, L"APOSTROF", L"'");	
+		//XmlUtils::replace_all( expr, L"KAVYCHKA", L"\"");
 	}
 
 	static void oox_replace_tmp(std::wstring &expr)
 	{
-		XmlUtils::replace_all( expr, L"-", L"MINYS");
-		XmlUtils::replace_all( expr, L".", L"ТОСHKA");
-		XmlUtils::replace_all( expr, L"!", L"VOSKL");
+		std::wstring result;
 
-		XmlUtils::replace_all( expr, L"(", L"SCOBCAIN");
-		XmlUtils::replace_all( expr, L")", L"SCOBCAOUT");
+		size_t pos = 0, size = expr.length();
 
-		XmlUtils::replace_all( expr, L"[", L"KVADRATIN");
-		XmlUtils::replace_all( expr, L"]", L"KVADRATOUT");
-		
-		XmlUtils::replace_all( expr, L" ", L"PROBEL");
-		XmlUtils::replace_all( expr, L"'", L"APOSTROF");	
-		XmlUtils::replace_all( expr, L"\"", L"KAVYCHKA");
+		while(pos < size)
+		{
+			switch(expr[pos])
+			{
+				case '-':
+				{
+					result += L"MINYS";
+				}break;
+				case '.':
+				{	
+					result += L"ТОСHKA";
+				}break;
+				case '!':
+				{
+					result += L"VOSKL";
+				}break;
+				case '(':
+				{
+					result += L"SCOBCAIN";
+				}break;
+				case ')':
+				{
+					result += L"SCOBCAOUT";
+				}break;
+				case '[':
+				{
+					result += L"KVADRATIN";
+				}break;
+				case ']':
+				{
+					result += L"KVADRATOUT";
+				}break;
+				case ' ':
+				{
+					result += L"PROBEL";
+				}break;
+				case '\'':
+				{
+					result += L"APOSTROF";
+				}break;
+				case '\"':
+				{
+					result += L"KAVYCHKA";
+				}break;
+				default:
+				{
+					result += expr[pos];
+				}break;
+			}
+			pos++;
+		}
+		expr = result;
+
+		//XmlUtils::replace_all( expr, L"-", L"MINYS");
+		//XmlUtils::replace_all( expr, L".", L"ТОСHKA");
+		//XmlUtils::replace_all( expr, L"!", L"VOSKL");
+
+		//XmlUtils::replace_all( expr, L"(", L"SCOBCAIN");
+		//XmlUtils::replace_all( expr, L")", L"SCOBCAOUT");
+
+		//XmlUtils::replace_all( expr, L"[", L"KVADRATIN");
+		//XmlUtils::replace_all( expr, L"]", L"KVADRATOUT");
+		//
+		//XmlUtils::replace_all( expr, L" ", L"PROBEL");
+		//XmlUtils::replace_all( expr, L"'", L"APOSTROF");	
+		//XmlUtils::replace_all( expr, L"\"", L"KAVYCHKA");
 	}
 
 	static bool is_forbidden1(const std::wstring & formula)

ASCOfficeOdfFileW/source/OdfFormat/ods_table_state.cpp

@@ -968,7 +968,7 @@ void ods_table_state::set_cell_formula(std::wstring & formula)
 
 	XmlUtils::replace_all(odfFormula, L"EXTERNALREF", L"file://");//снятие экранирования
 
-	if (std::wstring::npos != odfFormula.find(L"["))
+	if ((false == table_parts_.empty()) && (std::wstring::npos != odfFormula.find(L"[")))
 	{
 		for (size_t i = 0; i < table_parts_.size(); i++)
 		{
@@ -1049,58 +1049,57 @@ void ods_table_state::add_or_find_cell_shared_formula(std::wstring & formula, st
 		int moving_type = 0;
 		
 		std::vector<std::wstring> distance;
-		boost::algorithm::split(distance, ref,boost::algorithm::is_any_of(L":"), boost::algorithm::token_compress_on);
+		boost::algorithm::split(distance, ref, boost::algorithm::is_any_of(L":"), boost::algorithm::token_compress_on);
 		if (distance.size() > 1)
 		{
             int col1, row1, col2, row2;
-			utils::parsing_ref(distance[0],col1,row1);
-			utils::parsing_ref(distance[1],col2,row2);
+			utils::parsing_ref(distance[0], col1, row1);
+			utils::parsing_ref(distance[1], col2, row2);
 
 			if (row2 - row1 > 0) moving_type = 2;
 			if (col2 - col1 > 0)moving_type = 1;
 		}
 		ods_shared_formula_state state = {(unsigned int)ind, odf_formula,ref, current_table_column_,current_table_row_, moving_type};
-		shared_formulas_.push_back(state);
+		shared_formulas_.insert(std::make_pair((unsigned int)ind, state));
 		
 		cell->attlist_.table_formula_ = odf_formula;
 		cells_.back().empty = false;
 	}
 	else
 	{
-        for (size_t i = 0; i < shared_formulas_.size() ;i++)
+		std::map<unsigned int, ods_shared_formula_state>::iterator pFind = shared_formulas_.find(ind);
+		
+		if (pFind != shared_formulas_.end())
 		{
-			if (shared_formulas_[i].index == ind)
-			{
-				odf_formula = shared_formulas_[i].formula;
+			odf_formula = pFind->second.formula;
 
-				//поменять по ref формулу !!!
-				if (shared_formulas_[i].moving_type == 1)
-				{
-					tmp_column_ = shared_formulas_[i].base_column;
-					tmp_row_	= shared_formulas_[i].base_row;
-					
-					const std::wstring res = boost::regex_replace(
-						odf_formula,
-						boost::wregex(L"([a-zA-Z]{1,3}[0-9]{1,3})|(?='.*?')|(?=\".*?\")"),
-						&ods_table_state::replace_cell_column,
-						boost::match_default | boost::format_all);
-					odf_formula = res;
-				}
-				if (shared_formulas_[i].moving_type == 2)
-				{
-					tmp_column_ = shared_formulas_[i].base_column;
-					tmp_row_	= shared_formulas_[i].base_row;
-					
-					const std::wstring res = boost::regex_replace(
-						odf_formula,
-						boost::wregex(L"([a-zA-Z]{1,3}[0-9]{1,3})|(?='.*?')|(?=\".*?\")"),
-						&ods_table_state::replace_cell_row,
-						boost::match_default | boost::format_all);
-					odf_formula = res;
-				}
-				cell->attlist_.table_formula_ = odf_formula;				
-				cells_.back().empty = false;
+			//поменять по ref формулу !!!
+			if (pFind->second.moving_type == 1)
+			{
+				tmp_column_ = pFind->second.base_column;
+				tmp_row_	= pFind->second.base_row;
+				
+				const std::wstring res = boost::regex_replace(
+					odf_formula,
+					boost::wregex(L"([a-zA-Z]{1,3}[0-9]{1,3})|(?='.*?')|(?=\".*?\")"),
+					&ods_table_state::replace_cell_column,
+					boost::match_default | boost::format_all);
+				odf_formula = res;
 			}
+			else if (pFind->second.moving_type == 2)
+			{
+				tmp_column_ = pFind->second.base_column;
+				tmp_row_	= pFind->second.base_row;
+				
+				const std::wstring res = boost::regex_replace(
+					odf_formula,
+					boost::wregex(L"([a-zA-Z]{1,3}[0-9]{1,3})|(?='.*?')|(?=\".*?\")"),
+					&ods_table_state::replace_cell_row,
+					boost::match_default | boost::format_all);
+				odf_formula = res;
+			}
+			cell->attlist_.table_formula_ = odf_formula;				
+			cells_.back().empty = false;
 		}
 	}
 }

ASCOfficeOdfFileW/source/OdfFormat/ods_table_state.h

@@ -453,12 +453,12 @@ private:
 	std::vector<ods_cell_state>	cells_;
 	long						cells_size_;
 	
-	std::vector<ods_hyperlink_state>		hyperlinks_;
-	std::vector<ods_shared_formula_state>	shared_formulas_;
+	std::vector<ods_hyperlink_state> hyperlinks_;
+	std::map<unsigned int, ods_shared_formula_state> shared_formulas_;
 
-	std::vector<table_part_state>			table_parts_;
+	std::vector<table_part_state> table_parts_;
 
-	std::vector<data_validation_state>		data_validations_;
+	std::vector<data_validation_state> data_validations_;
 
 	odf_drawing_context		drawing_context_;	
 	odf_controls_context	controls_context_;	

ASCOfficeOdfFileW/source/Oox2OdfConverter/DocxConverter.cpp

@@ -1417,7 +1417,12 @@ void DocxConverter::convert(OOX::Logic::CParagraphProperty	*oox_paragraph_pr, cp
 void DocxConverter::convert( ComplexTypes::Word::CShading* shading, _CP_OPT(odf_types::color)& odf_color)
 {	
 	if (!shading) return;	
-		
+	
+	if ((shading->m_oVal.IsInit()) && ( shading->m_oVal->GetValue() == SimpleTypes::shdClear || 
+										shading->m_oVal->GetValue() == SimpleTypes::shdNil))
+	{
+		return;
+	}
 	convert(shading->m_oFill.GetPointer(), shading->m_oThemeFill.GetPointer(),
 		shading->m_oThemeFillTint.GetPointer(), shading->m_oThemeShade.GetPointer(), odf_color);
 		

ASCOfficeOdfFileW/source/Oox2OdfConverter/DocxConverter.h

@@ -191,7 +191,6 @@ namespace Oox2Odf
 		void convert(OOX::Logic::CParagraphProperty		*oox_para_prop,	odf_writer::style_paragraph_properties	*paragraph_properties);
 		void convert(ComplexTypes::Word::CFramePr		*oox_frame_pr,	odf_writer::style_paragraph_properties	*paragraph_properties);
 		void convert(OOX::Logic::CRunProperty			*oox_run_prop,	odf_writer::style_text_properties		*text_properties, bool is_list_styles = false);
-		void convert(ComplexTypes::Word::CShading		*oox_shading,	odf_writer::style_text_properties		*text_properties );
 		void convert(OOX::Logic::CFldSimple				*oox_fld);
 		void convert(OOX::Logic::CFldChar				*oox_fld);
 		void convert(OOX::Logic::CInstrText				*oox_instrText);

ASCOfficePPTXFile/ASCOfficeDrawingConverter.cpp

@@ -3042,8 +3042,19 @@ void CDrawingConverter::doc_LoadGroup(PPTX::Logic::SpTreeElem *result, XmlUtils:
 			{
 				AddShapeType(oNodeT);
 			}
-			else if (
-				L"shape"		== strNameP ||
+		}
+	}
+    if (oNode.GetNodes(L"*", oNodes))
+	{
+		int nCount = oNodes.GetCount();
+		for (int i = 0; i < nCount; ++i)
+		{
+			XmlUtils::CXmlNode oNodeT;
+			oNodes.GetAt(i, oNodeT);
+
+			std::wstring strNameP = XmlUtils::GetNameNoNS(oNodeT.GetName());
+
+			if (L"shape"		== strNameP ||
                 L"rect"         == strNameP ||
                 L"oval"         == strNameP ||
                 L"line"         == strNameP ||

ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.cpp

@@ -966,6 +966,11 @@ namespace NSBinPptxRW
         _WriteStringWithLength(s->c_str(), (_UINT32)s->length(), false);
 	}
 
+	void CBinaryFileWriter::WriteStringData(const WCHAR* pData, _UINT32 len)
+	{
+		_WriteStringWithLength(pData, len, false);
+	}
+
 	void CBinaryFileWriter::WriteString1Data(int type, const WCHAR* pData, _UINT32 len)
 	{
 		BYTE bType = (BYTE)type;
@@ -1129,7 +1134,6 @@ namespace NSBinPptxRW
 	}
 	void CBinaryFileWriter::_WriteStringWithLength(const WCHAR* sBuffer, _UINT32 lCount, bool bByte)
 	{
-		//CheckBufferSize at first to prevent negative m_lPosition after Flush in CStreamBinaryWriter
 		if (sizeof(wchar_t) == 4)
 		{
 			_INT32 lSizeMemMax = 4 * lCount + 2;//2 - for null terminator
@@ -1187,7 +1191,7 @@ namespace NSBinPptxRW
 			}
 		}
 	}
-	_UINT32 CStreamBinaryWriter::GetPosition()
+	_UINT32 CStreamBinaryWriter::GetPositionAbsolute()
 	{
 		return m_lPosition + m_lPositionFlushed;
 	}

ASCOfficePPTXFile/Editor/BinaryFileReaderWriter.h

@@ -329,6 +329,7 @@ namespace NSBinPptxRW
 		void WriteString1	(int type, const std::wstring& val);
 		void WriteString2	(int type, const NSCommon::nullable_string& val);
 		void WriteString	(const std::wstring& val);
+		void WriteStringData(const WCHAR* pData, _UINT32 len);
 
 		void WriteString1Data(int type, const WCHAR* pData, _UINT32 len);
 
@@ -416,7 +417,7 @@ namespace NSBinPptxRW
 		CStreamBinaryWriter(size_t bufferSize = 16777216);
 
 		void CheckBufferSize(_UINT32 lPlus);
-		_UINT32 GetPosition();
+		_UINT32 GetPositionAbsolute();
 		void CloseFile();
 		virtual void Flush();
 	};

ASCOfficePPTXFile/Editor/Drawing/Shapes/BaseShape/BaseShape.h

@@ -70,7 +70,8 @@ namespace ODRAW
     class CBaseShape
     {
     public:
-        std::vector<long>					m_arAdjustments;
+		std::vector<long>					m_arAbsMaxAdjustments;
+		std::vector<long>					m_arAdjustments;
         std::vector<double>					m_arGuides;
         LONG								m_eJoin;
         bool								m_bConcentricFill;
@@ -139,6 +140,10 @@ namespace ODRAW
             m_strPath	= Shape->m_strPath;
             m_strRect	= Shape->m_strRect;
 
+			m_arAbsMaxAdjustments.clear();
+			for(size_t i = 0; i < Shape->m_arAbsMaxAdjustments.size(); i++)
+                m_arAbsMaxAdjustments.push_back(Shape->m_arAbsMaxAdjustments[i]);
+
             m_arAdjustments.clear();           
 			for(size_t i = 0; i < Shape->m_arAdjustments.size(); i++)
                 m_arAdjustments.push_back(Shape->m_arAdjustments[i]);
@@ -181,6 +186,10 @@ namespace ODRAW
             Shape->m_strPath	= m_strPath;
             Shape->m_strRect	= m_strRect;
 
+            Shape->m_arAbsMaxAdjustments.clear();
+            for(size_t i = 0; i < m_arAbsMaxAdjustments.size(); i++)
+                Shape->m_arAbsMaxAdjustments.push_back(m_arAbsMaxAdjustments[i]);
+
             Shape->m_arAdjustments.clear();
             for(size_t i = 0; i < m_arAdjustments.size(); i++)
                 Shape->m_arAdjustments.push_back(m_arAdjustments[i]);

ASCOfficePPTXFile/Editor/Drawing/Shapes/BaseShape/PPTShape/PPTAutoShapes/BentConnector.h

@@ -49,6 +49,8 @@ public:
 		AddGuide(_T("val #0"));
 		m_arAdjustments.push_back(10800);
 
+		m_arAbsMaxAdjustments.push_back(82000);
+
 		LoadConnectorsList(_T("0,0;21600,21600"));
     }
 };

ASCOfficePPTXFile/Editor/Drawing/Shapes/BaseShape/PPTShape/PptShape.h

@@ -192,7 +192,13 @@ public:
             }
             else
             {
-                m_arAdjustments.push_back((LONG)XmlUtils::GetInteger(arAdj[nIndex]));
+				long val = (long)XmlUtils::GetInteger(arAdj[nIndex]);
+				if (nIndex < m_arAbsMaxAdjustments.size())
+				{
+					if (abs(val) > m_arAbsMaxAdjustments[nIndex])
+						val = 0;
+				}
+                m_arAdjustments.push_back(val);
             }
         }
 

ASCOfficePPTXFile/PPTXFormat/Logic/GrpSpPr.h

@@ -236,7 +236,7 @@ namespace PPTX
 						}
 						case 2:
 						{
-							pReader->SkipRecord();
+							EffectList.fromPPTY(pReader);
 							break;
 						}
 						case 3:

ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.cpp

@@ -240,7 +240,7 @@ namespace PPTX
 					}
 					case 4:
 					{
-						pReader->SkipRecord();
+						EffectList.fromPPTY(pReader);
 						break;
 					}
 					case 5:

ASCOfficeRtfFile/RtfFormatLib/source/DestinationCommand.h

@@ -2246,7 +2246,9 @@ public:
                     COMMAND_RTF_INT( "levelnorestart", m_oListLevelProp.m_nNoRestart, sCommand, hasParameter, parameter )
                     COMMAND_RTF_INT( "levellegal", m_oListLevelProp.m_nLegal, sCommand, hasParameter, parameter )
                     COMMAND_RTF_INT( "levelpicture", m_oListLevelProp.m_nPictureIndex, sCommand, hasParameter, parameter )
-                    COMMAND_RTF_INT( "li", m_oListLevelProp.m_nIndent, sCommand, hasParameter, parameter )
+					COMMAND_RTF_INT( "levelspace", m_oListLevelProp.m_nSpace, sCommand, hasParameter, parameter )
+					COMMAND_RTF_INT( "levelindent", m_oListLevelProp.m_nIndent, sCommand, hasParameter, parameter )
+					COMMAND_RTF_INT( "li", m_oListLevelProp.m_nIndent, sCommand, hasParameter, parameter )
                     COMMAND_RTF_INT( "lin", m_oListLevelProp.m_nIndentStart, sCommand, hasParameter, parameter )
                     COMMAND_RTF_INT( "fi", m_oListLevelProp.m_nFirstIndent, sCommand, hasParameter, parameter )
                     else if( "tx" == sCommand  )
@@ -2305,7 +2307,13 @@ public:
 			{
 				RtfListLevelProperty oListLevelProp;
 				ListLevelReader oListLevelReader( oListLevelProp );
+
+				oReader.m_oState->m_oCharProp.m_bListLevel = true;
+				oReader.m_oState->m_oCharProp.SetDefaultRtf();
+				
 				bool bResult = StartSubReader( oListLevelReader, oDocument, oReader );
+				
+				oReader.m_oState->m_oCharProp.m_bListLevel = false;
 				if( true == bResult )
 				{
 					oListLevelProp.m_nLevel = m_oListProp.GetCount();
@@ -2356,8 +2364,15 @@ public:
         else if( "list" == sCommand )
 		{
 			RtfListProperty oListProp;
+			
 			ListReader oListReader(oListProp);
+
+			oReader.m_oState->m_oCharProp.m_bListLevel = true;
+			
 			bool bResult = StartSubReader( oListReader, oDocument, oReader );
+			
+			oReader.m_oState->m_oCharProp.m_bListLevel = false;
+			
 			if( true == bResult )
 			{
 				oDocument.m_oListTable.AddItem( oListProp );

ASCOfficeRtfFile/RtfFormatLib/source/Reader/OOXShapeReader.cpp

@@ -136,8 +136,8 @@ bool OOXShapeReader::ParseVmlStyle(RtfShapePtr pShape, SimpleTypes::Vml::CCssPro
 				{
 				case SimpleTypes::Vml::cssmsoposhorrelMargin:	pShape->m_eXAnchor = RtfShape::ax_margin; break;
 				case SimpleTypes::Vml::cssmsoposhorrelPage:		pShape->m_eXAnchor = RtfShape::ax_page; break;
-				case SimpleTypes::Vml::cssmsoposhorrelText:
-				case SimpleTypes::Vml::cssmsoposhorrelChar:		break;//inline	
+				case SimpleTypes::Vml::cssmsoposhorrelText:		break; //???
+				case SimpleTypes::Vml::cssmsoposhorrelChar:		pShape->m_eAnchorTypeShape = RtfShape::st_inline; break;//inline	
 				}
 			}break;
 		case SimpleTypes::Vml::cssptMsoPositionVertical: 
@@ -194,7 +194,10 @@ bool OOXShapeReader::ParseVmlStyle(RtfShapePtr pShape, SimpleTypes::Vml::CCssPro
 			break;
 		case SimpleTypes::Vml::cssptZIndex : 
 			{
-				pShape->m_eAnchorTypeShape	= RtfShape::st_anchor;
+				if (pShape->m_eAnchorTypeShape == RtfShape::st_none)
+				{
+					pShape->m_eAnchorTypeShape = RtfShape::st_anchor;
+				}
 
 				int nValue = prop->get_Value().oZIndex.nOrder;
 				pShape->m_nZOrder = nValue;

ASCOfficeRtfFile/RtfFormatLib/source/RtfProperty.cpp

@@ -579,52 +579,63 @@ std::wstring RtfBorder::RenderToOOX(RenderParameter oRenderParameter)
 {
 	RtfDocument* poRtfDocument = static_cast<RtfDocument*>(oRenderParameter.poDocument);
     std::wstring  sResult;
-	if( PROP_DEF != m_nColor )
-	{
-		RtfColor oColor;
-		RenderParameter oNewParam = oRenderParameter;
-		oNewParam.nType = RENDER_TO_OOX_PARAM_COLOR_VALUE;
-		if( true == poRtfDocument->m_oColorTable.GetColor( m_nColor, oColor ) )
-            sResult += L" w:color=\"" + oColor.RenderToOOX(oNewParam) + L"\"";
-	}
-	if( PROP_DEF != m_nWidth ) //w:sz  1/8 twips (equivalent to 1/576th of an inch)
-        sResult += L" w:sz=\"" + std::to_wstring(2 * m_nWidth / 5 ) + L"\"";
-	if( PROP_DEF != m_nSpace )
-        sResult += L" w:space=\"" + std::to_wstring((int)RtfUtility::Twip2pt( m_nSpace )) + L"\"";
 
 	switch( m_eType )
 	{
-		case bt_brdrs:			sResult += L" w:val=\"single\"";					break;
+		case bt_brdrs:			sResult += L" w:val=\"single\"";				break;
 		case bt_brdrth:			sResult += L" w:val=\"thick\"";					break;
 		case bt_brdrsh:			sResult += L" w:val=\"\"thin";					break;
-		case bt_brdrdb:			sResult += L" w:val=\"double\"";					break;
-		case bt_brdrdot:		sResult += L" w:val=\"dotted\"";					break;
-		case bt_brdrdash:		sResult += L" w:val=\"dashed\"";					break;
+		case bt_brdrdb:			sResult += L" w:val=\"double\"";				break;
+		case bt_brdrdot:		sResult += L" w:val=\"dotted\"";				break;
+		case bt_brdrdash:		sResult += L" w:val=\"dashed\"";				break;
 		case bt_brdrhair:		sResult += L" w:val=\"hair\"";					break;
 		case bt_brdrdashsm:		sResult += L" w:val=\"dashSmallGap\"";			break;
 		case bt_brdrdashd:		sResult += L" w:val=\"dotDash\"";				break;
-		case bt_brdrdashdd:		sResult += L" w:val=\"dotDotDash\"";				break;
+		case bt_brdrdashdd:		sResult += L" w:val=\"dotDotDash\"";			break;
 		case bt_brdrinset:		sResult += L" w:val=\"inset\"";					break;
-		case bt_brdrnone:		sResult += L" w:val=\"nil\"";					break;
-		case bt_brdroutset:		sResult += L" w:val=\"outset\"";					break;
-		case bt_brdrtriple:		sResult += L" w:val=\"triple\"";					break;
+		case bt_brdrnone:		sResult += L" w:val=\"none\"";					break;
+		case bt_brdroutset:		sResult += L" w:val=\"outset\"";				break;
+		case bt_brdrtriple:		sResult += L" w:val=\"triple\"";				break;
 		case bt_brdrtnthsg:		sResult += L" w:val=\"thinThickSmallGap\"";		break;
 		case bt_brdrthtnsg:		sResult += L" w:val=\"thickThinSmallGap\"";		break;
-		case bt_brdrtnthtnsg:	sResult += L" w:val=\"thinThickThinSmallGap\""; 	break;
-		case bt_brdrtnthtnmg:	sResult += L" w:val=\"thinThickThinMediumGap\"";	break;
-		case bt_brdrtnthmg:		sResult += L" w:val=\"thinThickMediumGap\"";		break;
-		case bt_brdrthtnmg:		sResult += L" w:val=\"thickThinMediumGap\"";		break;
+		case bt_brdrtnthtnsg:	sResult += L" w:val=\"thinThickThinSmallGap\""; break;
+		case bt_brdrtnthtnmg:	sResult += L" w:val=\"thinThickThinMediumGap\"";break;
+		case bt_brdrtnthmg:		sResult += L" w:val=\"thinThickMediumGap\"";	break;
+		case bt_brdrthtnmg:		sResult += L" w:val=\"thickThinMediumGap\"";	break;
 		case bt_brdrtnthlg:		sResult += L" w:val=\"thinThickLargeGap\"";		break;
 		case bt_brdrthtnlg:		sResult += L" w:val=\"thickThinLargeGap\"";		break;
 		case bt_brdrtnthtnlg:	sResult += L" w:val=\"thinThickThinLargeGap\"";	break;
 		case bt_brdrwavy:		sResult += L" w:val=\"wave\"";					break;
-		case bt_brdrwavydb:		sResult += L" w:val=\"doubleWave\"";				break;
-		case bt_brdrdashdotstr: sResult += L" w:val=\"dashDotStroked\"";			break;
+		case bt_brdrwavydb:		sResult += L" w:val=\"doubleWave\"";			break;
+		case bt_brdrdashdotstr: sResult += L" w:val=\"dashDotStroked\"";		break;
 		case bt_brdremboss:		sResult += L" w:val=\"threeDEmboss\"";			break;
 		case bt_brdrengrave:	sResult += L" w:val=\"threeDEngrave\"";			break;
 		default:
 			break;
 	}
+	if( PROP_DEF != m_nColor )
+	{
+		RtfColor oColor;
+		RenderParameter oNewParam = oRenderParameter;
+		oNewParam.nType = RENDER_TO_OOX_PARAM_COLOR_VALUE;
+		
+		if (m_nColor == -1)
+		{
+			oColor.m_bAuto = true;
+            sResult += L" w:color=\"auto\"";
+		}
+		else if( true == poRtfDocument->m_oColorTable.GetColor( m_nColor, oColor ) )
+            sResult += L" w:color=\"" + oColor.RenderToOOX(oNewParam) + L"\"";
+	}
+	if( PROP_DEF != m_nWidth ) //w:sz  1/8 twips (equivalent to 1/576th of an inch)
+	{
+        sResult += L" w:sz=\"" + std::to_wstring(2 * m_nWidth / 5 ) + L"\"";
+	}
+	if( PROP_DEF != m_nSpace )
+	{
+        sResult += L" w:space=\"" + std::to_wstring((int)RtfUtility::Twip2pt( m_nSpace )) + L"\"";
+	}
+
     if( false == sResult.empty() )
 	{
 		if( RENDER_TO_OOX_PARAM_BORDER_ATTRIBUTE == oRenderParameter.nType )

ASCOfficeRtfFile/RtfFormatLib/source/RtfProperty.h

@@ -848,7 +848,7 @@ public:
 		m_eType		= bt_brdrnone;
 		m_nWidth	= 0;
 		m_nSpace	= 0;
-		m_nColor	= PROP_DEF;
+		m_nColor	= -1; //auto
 	}
 	void Merge( RtfBorder& oBorPr )
 	{
@@ -987,6 +987,8 @@ typedef boost::shared_ptr<RtfCharProperty> RtfCharPropertyPtr;
 class RtfCharProperty: public IRenderableProperty
 {
 public: 
+	bool m_bListLevel;
+
 	enum _UnderlineStyle {uls_none, uls_Single, uls_Dotted,uls_Dashed ,uls_Dash_dotted,uls_Dash_dot_dotted,uls_Double,uls_Heavy_wave,uls_Long_dashe,uls_Stops_all,uls_Thick,uls_Thick_dotted,uls_Thick_dashed,uls_Thick_dash_dotted,uls_Thick_dash_dot_dotted,uls_Thick_long_dashed,uls_Double_wave,uls_Word,uls_Wave};
 
 	int m_nAnimated;		//animtextN	Animated text properties (note: Word 2007 ignores this control word):
@@ -1060,6 +1062,7 @@ public:
 
 	RtfCharProperty()
 	{
+		m_bListLevel = false;
 		SetDefault();
 	}
 	int GetType()
@@ -1073,7 +1076,8 @@ public:
 		m_poShading.SetDefaultRtf();
 		m_poBorder.SetDefaultRtf();
 		
-		m_nFontSize = 24;
+		if (false == m_bListLevel)
+			m_nFontSize = 24;
 	}
 	void SetDefaultOOX()
 	{
@@ -1082,7 +1086,8 @@ public:
 		m_poShading.SetDefaultOOX();
 		m_poBorder.SetDefaultOOX();
 		
-		m_nFontSize = 20;
+		if (false == m_bListLevel)
+			m_nFontSize = 20;
 	}
 	void SetDefault()
 	{
@@ -1214,11 +1219,14 @@ public:
 	int		m_nFirstIndent;
 	int		m_nIndent;
 	int		m_nIndentStart;
+	int		m_nSpace;
 	
 	RtfCharProperty m_oCharProp; //Char
 
 	RtfListLevelProperty()
 	{
+		m_oCharProp.m_bListLevel = true;
+
 		SetDefault();
 	}
 	bool IsValid()
@@ -1250,6 +1258,7 @@ public:
 	 }
 	void SetDefault()
 	{
+		DEFAULT_PROPERTY	( m_nSpace )
 		DEFAULT_PROPERTY	( m_nLevel )
 		DEFAULT_PROPERTY	( m_nNumberType )
 		DEFAULT_PROPERTY	( m_bTentative )
@@ -2416,18 +2425,18 @@ public:
 	void SetDefaultOOX()
 	{
 		SetDefault();
-	}
-	void SetDefault()
-	{
-		RtfTableProperty::SetDefault();
 //не SetEmpty() !!!		
 		m_oBorderLeft.SetDefault();
 		m_oBorderRight.SetDefault();
 		m_oBorderTop.SetDefault();
 		m_oBorderBottom.SetDefault();
 		m_oBorderVert.SetDefault();
-		m_oBorderHor.SetDefault();
-
+		m_oBorderHor.SetDefault();	
+	}
+	//5.5 Доверенность_MO_Q139.rtf
+	void SetDefault()
+	{
+		RtfTableProperty::SetDefault();
 		DEFAULT_PROPERTY( m_nIndex )
 		DEFAULT_PROPERTY( m_nBandIndex )
 		DEFAULT_PROPERTY( m_bLastRow )
@@ -2649,6 +2658,10 @@ public:
 	void SetDefaultRtf()
 	{
 		SetDefault();
+		
+		//4.1 Наряд_R7_M133.rtf
+		m_nSpaceAfter = 0;
+		m_nSpaceBetween = 240;
 	}
 	void SetDefaultOOX()
 	{
@@ -2701,7 +2714,7 @@ public:
 		m_oBorderTop.SetDefault();
 		m_oBorderLeft.SetDefault();
 		m_oBorderBottom.SetDefault();
-		m_oBorderRight.SetDefault();
+		m_oBorderRight.SetDefault(); 
 		m_oBorderBox.SetDefault();
 		m_oBorderBar.SetDefault();
 

Common/3dParty/openssl/fetch.sh

@@ -4,5 +4,5 @@ SCRIPTPATH="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 cd "$SCRIPTPATH"
 
 if [ ! -d openssl ]; then
-  git clone https://github.com/openssl/openssl.git
+  git clone --depth=1 https://github.com/openssl/openssl.git
 fi

Common/DocxFormat/Projects/DocxFormat2005.vcproj

@@ -1596,10 +1596,18 @@
 					RelativePath="..\Source\XlsxFormat\SharedStrings\SharedStrings.h"
 					>
 				</File>
+				<File
+					RelativePath="..\Source\XlsxFormat\SharedStrings\Si.cpp"
+					>
+				</File>
 				<File
 					RelativePath="..\Source\XlsxFormat\SharedStrings\Si.h"
 					>
 				</File>
+				<File
+					RelativePath="..\Source\XlsxFormat\SharedStrings\Text.cpp"
+					>
+				</File>
 				<File
 					RelativePath="..\Source\XlsxFormat\SharedStrings\Text.h"
 					>
@@ -1636,6 +1644,10 @@
 					RelativePath="..\Source\XlsxFormat\Styles\NumFmts.h"
 					>
 				</File>
+				<File
+					RelativePath="..\Source\XlsxFormat\Styles\rPr.cpp"
+					>
+				</File>
 				<File
 					RelativePath="..\Source\XlsxFormat\Styles\rPr.h"
 					>

Common/DocxFormat/Source/Common/ComplexTypes.h

@@ -333,7 +333,6 @@ namespace ComplexTypes
 
 				return sResult;
 			}
-		private:
 
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
@@ -693,8 +692,6 @@ namespace ComplexTypes
 
 				return sResult;
 			}
-		private:
-
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
 				// Читаем атрибуты

Common/DocxFormat/Source/DocxFormat/Logic/Run.h

@@ -42,6 +42,7 @@
 #include "Pict.h"
 #include "Annotations.h"
 #include "AlternateContent.h"
+#include "../../../../../DesktopEditor/common/StringExt.h"
 
 namespace OOX
 {
@@ -215,100 +216,158 @@ namespace OOX
 				if ( oReader.IsEmptyNode() )
 					return;
 
+				fromXMLElems(oReader);
+			}
+			void fromXMLElems(XmlUtils::CXmlLiteReader& oReader)
+			{
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				WritingElement *pItem = NULL;
 				int nParentDepth = oReader.GetDepth();
 				while( oReader.ReadNextSiblingNode( nParentDepth ) )
 				{
-					std::wstring sName = oReader.GetName();
-					WritingElement *pItem = NULL;
-
-					if ( _T("mc:AlternateContent") == sName )
-						pItem = new CAlternateContent( oReader );
-					else if ( _T("w:annotationRef") == sName )
-						pItem = new CAnnotationRef( oReader );
-					else if ( _T("w:br") == sName )
-						pItem = new CBr( oReader );
-					else if ( _T("w:commentReference") == sName )
-						pItem = new CCommentReference( oReader );
-					else if ( _T("w:contentPart") == sName )
-						pItem = new CContentPart( oReader );
-					else if ( _T("w:continuationSeparator") == sName )
-						pItem = new CContinuationSeparator( oReader );
-					else if ( _T("w:cr") == sName )
-						pItem = new CCr( oReader );
-					else if ( _T("w:dayLong") == sName )
-						pItem = new CDayLong( oReader );
-					else if ( _T("w:dayShort") == sName )
-						pItem = new CDayShort( oReader );
-					else if ( _T("w:delInstrText") == sName )
-						pItem = new CDelInstrText( oReader );
-					else if ( _T("w:delText") == sName )
-						pItem = new CDelText( oReader );
-					else if ( _T("w:drawing") == sName ) 
-						pItem = new CDrawing( oReader );
-					else if ( _T("w:endnoteRef") == sName )
-						pItem = new CEndnoteRef( oReader );
-					else if ( _T("w:endnoteReference") == sName )
-						pItem = new CEndnoteReference( oReader );
-					else if ( _T("w:fldChar") == sName )
-						pItem = new CFldChar( oReader );
-					else if ( _T("w:footnoteRef") == sName )
-						pItem = new CFootnoteRef( oReader );
-					else if ( _T("w:footnoteReference") == sName )
-						pItem = new CFootnoteReference( oReader );
-					else if ( _T("w:instrText") == sName )
-						pItem = new CInstrText( oReader );
-					else if ( _T("w:lastRenderedPageBreak") == sName )
-						pItem = new CLastRenderedPageBreak( oReader );
-					else if ( _T("w:monthLong") == sName )
-						pItem = new CMonthLong( oReader );
-					else if ( _T("w:monthShort") == sName )
-						pItem = new CMonthShort( oReader );
-					else if ( _T("w:noBreakHyphen") == sName )
-						pItem = new CNoBreakHyphen( oReader );
-					else if ( _T("w:object") == sName )
-						pItem = new CObject( oReader );
-					else if ( _T("w:pgNum") == sName )
-						pItem = new CPgNum( oReader );
-					else if ( _T("w:pict") == sName )
-						pItem = new CPicture( oReader );
-					else if ( _T("w:ptab") == sName )
-						pItem = new CPTab( oReader );
-					else if ( _T("w:rPr") == sName )
-					{
-						if (m_oRunProperty)
-						{
-							CRunProperty prop2(oReader);
-							CRunProperty newProp = CRunProperty::Merge(*m_oRunProperty, prop2);
-
-							pItem = m_oRunProperty = new CRunProperty(newProp);
-						}
-						else
-						{
-							pItem = m_oRunProperty = new CRunProperty( oReader );
-						}
-					}
-					else if ( _T("w:ruby") == sName )
-						pItem = new CRuby( oReader );
-					else if ( _T("w:separator") == sName )
-						pItem = new CSeparator( oReader );
-					else if ( _T("w:softHyphen") == sName )
-						pItem = new CSoftHyphen( oReader );
-					else if ( _T("w:sym") == sName )
-						pItem = new CSym( oReader );
-					else if ( _T("w:t") == sName )
-						pItem = new CText( oReader );
-					else if ( _T("w:tab") == sName )
-						pItem = new CTab( oReader );
-					else if ( _T("w:yearLong") == sName )
-						pItem = new CYearLong( oReader );
-
+					pItem = fromXMLElem(oReader);
 					if ( pItem )
 						m_arrItems.push_back( pItem );
 				}
-				if ((m_oRunProperty) && (m_oRunProperty->m_pText))
+			}
+
+			WritingElement* fromXMLElem(XmlUtils::CXmlLiteReader& oReader)
+			{
+				std::wstring sName = oReader.GetName();
+				WritingElement *pItem = NULL;
+
+				if ( _T("mc:AlternateContent") == sName )
+					pItem = new CAlternateContent( oReader );
+				else if ( _T("w:annotationRef") == sName )
+					pItem = new CAnnotationRef( oReader );
+				else if ( _T("w:br") == sName )
+					pItem = new CBr( oReader );
+				else if ( _T("w:commentReference") == sName )
+					pItem = new CCommentReference( oReader );
+				else if ( _T("w:contentPart") == sName )
+					pItem = new CContentPart( oReader );
+				else if ( _T("w:continuationSeparator") == sName )
+					pItem = new CContinuationSeparator( oReader );
+				else if ( _T("w:cr") == sName )
+					pItem = new CCr( oReader );
+				else if ( _T("w:dayLong") == sName )
+					pItem = new CDayLong( oReader );
+				else if ( _T("w:dayShort") == sName )
+					pItem = new CDayShort( oReader );
+				else if ( _T("w:delInstrText") == sName )
+					pItem = new CDelInstrText( oReader );
+				else if ( _T("w:delText") == sName )
+					pItem = new CDelText( oReader );
+				else if ( _T("w:drawing") == sName ) 
+					pItem = new CDrawing( oReader );
+				else if ( _T("w:endnoteRef") == sName )
+					pItem = new CEndnoteRef( oReader );
+				else if ( _T("w:endnoteReference") == sName )
+					pItem = new CEndnoteReference( oReader );
+				else if ( _T("w:fldChar") == sName )
+					pItem = new CFldChar( oReader );
+				else if ( _T("w:footnoteRef") == sName )
+					pItem = new CFootnoteRef( oReader );
+				else if ( _T("w:footnoteReference") == sName )
+					pItem = new CFootnoteReference( oReader );
+				else if ( _T("w:instrText") == sName )
+					pItem = new CInstrText( oReader );
+				else if ( _T("w:lastRenderedPageBreak") == sName )
+					pItem = new CLastRenderedPageBreak( oReader );
+				else if ( _T("w:monthLong") == sName )
+					pItem = new CMonthLong( oReader );
+				else if ( _T("w:monthShort") == sName )
+					pItem = new CMonthShort( oReader );
+				else if ( _T("w:noBreakHyphen") == sName )
+					pItem = new CNoBreakHyphen( oReader );
+				else if ( _T("w:object") == sName )
+					pItem = new CObject( oReader );
+				else if ( _T("w:pgNum") == sName )
+					pItem = new CPgNum( oReader );
+				else if ( _T("w:pict") == sName )
+					pItem = new CPicture( oReader );
+				else if ( _T("w:ptab") == sName )
+					pItem = new CPTab( oReader );
+				else if ( _T("w:rPr") == sName )
 				{
-					m_arrItems.push_back( m_oRunProperty->m_pText);
-					m_oRunProperty->m_pText = NULL;
+					if (m_oRunProperty)
+					{
+						CRunProperty prop2;
+						prop2.fromXML(oReader, this);
+						CRunProperty newProp = CRunProperty::Merge(*m_oRunProperty, prop2);
+
+						pItem = m_oRunProperty = new CRunProperty(newProp);
+					}
+					else
+					{
+						pItem = m_oRunProperty = new CRunProperty();
+						m_oRunProperty->fromXML(oReader, this);
+					}
+				}
+				else if ( _T("w:ruby") == sName )
+					pItem = new CRuby( oReader );
+				else if ( _T("w:separator") == sName )
+					pItem = new CSeparator( oReader );
+				else if ( _T("w:softHyphen") == sName )
+					pItem = new CSoftHyphen( oReader );
+				else if ( _T("w:sym") == sName )
+					pItem = new CSym( oReader );
+				else if ( _T("w:t") == sName )
+				{
+					fromXMLText(oReader);
+				}
+				else if ( _T("w:tab") == sName )
+					pItem = new CTab( oReader );
+				else if ( _T("w:yearLong") == sName )
+					pItem = new CYearLong( oReader );
+
+				return pItem;
+			}
+			void fromXMLText(XmlUtils::CXmlLiteReader& oReader)
+			{
+				//for <w:t>6<w:cr/>6</w:t>
+				nullable<SimpleTypes::CXmlSpace<> > oSpace;
+				CText::ReadAttributes(oReader, oSpace);
+
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				bool bTrimLeft, bTrimRight;
+				bTrimLeft = bTrimRight = !(oSpace.IsInit() && SimpleTypes::xmlspacePreserve == oSpace->GetValue());
+				CText* pTextLast = NULL;
+				int nDepth = oReader.GetDepth();
+				XmlUtils::XmlNodeType eNodeType = XmlUtils::XmlNodeType_EndElement;
+				while (oReader.Read(eNodeType) && oReader.GetDepth() >= nDepth && XmlUtils::XmlNodeType_EndElement != eNodeType)
+				{
+					if (eNodeType == XmlUtils::XmlNodeType_Text || eNodeType == XmlUtils::XmlNodeType_Whitespace || eNodeType == XmlUtils::XmlNodeType_SIGNIFICANT_WHITESPACE)
+					{
+						const char* pValue = oReader.GetTextChar();
+						if(bTrimLeft)
+						{
+							bTrimLeft = false;
+							pValue += NSStringExt::FindFirstNotOfA(pValue, " \n\r\t");
+						}
+						if('\0' != pValue[0])
+						{
+							pTextLast = new CText();
+							NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pValue, strlen(pValue), pTextLast->m_sText);
+							m_arrItems.push_back( pTextLast );
+						}
+					}
+					else if (eNodeType == XmlUtils::XmlNodeType_Element)
+					{
+						WritingElement *pItem = fromXMLElem(oReader);
+						if ( pItem )
+							m_arrItems.push_back( pItem );
+						bTrimLeft = false;
+						pTextLast = NULL;
+					}
+				}
+				if(bTrimRight && pTextLast)
+				{
+					NSStringExt::RTrim(pTextLast->m_sText, L" \n\r\t");
 				}
 			}
 			virtual std::wstring toXML() const

Common/DocxFormat/Source/DocxFormat/Logic/RunContent.h

@@ -810,9 +810,7 @@ namespace OOX
 			{
 				return et_w_t;
 			}
-		private:
-
-			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			static void ReadAttributes(XmlUtils::CXmlLiteReader& oReader, nullable<SimpleTypes::CXmlSpace<> >& oSpace)
 			{
 				if ( oReader.GetAttributesCount() <= 0 )
 					return;
@@ -825,7 +823,7 @@ namespace OOX
 				{
 					if ( _T("xml:space") == wsName )
 					{
-						m_oSpace = oReader.GetText();
+						oSpace = oReader.GetText();
 						break;
 					}
 
@@ -837,6 +835,12 @@ namespace OOX
 
 				oReader.MoveToElement();
 			}
+		private:
+
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes(oReader, m_oSpace);
+			}
 
 		public:
 

Common/DocxFormat/Source/DocxFormat/Logic/RunProperty.cpp

@@ -31,6 +31,21 @@
  */
 #include "RunProperty.h"
 #include "RunContent.h"
+#include "Run.h"
+
+#define FROM_XML_ELEM(oElem, oReader, pRun) \
+{ \
+	oElem.Init(); \
+	if(pRun) \
+	{ \
+		oElem->ReadAttributes(oReader); \
+		pRun->fromXMLElems(oReader); \
+	} \
+	else \
+	{ \
+		oElem->FromXML(oReader); \
+	} \
+}
 
 namespace OOX
 {
@@ -153,50 +168,35 @@ namespace OOX
 
 		void CRunProperty::fromXML(XmlUtils::CXmlLiteReader& oReader)
 		{
+			fromXML(oReader, NULL);
+		}
+		void CRunProperty::fromXML(XmlUtils::CXmlLiteReader& oReader, CRun* pRun)
+		{
+			//pRun for Run object -> XpertdocOnlineDemoEn.docx
 			if ( oReader.IsEmptyNode() )
 				return;
 
 			int nParentDepth = oReader.GetDepth();
 			while( oReader.ReadNextSiblingNode( nParentDepth )  )
 			{
-                std::wstring sName = oReader.GetName();
-				WritingElement *pItem = NULL;
+				std::wstring sName = oReader.GetName();
 
 				if ( _T("w:b") == sName )
-					m_oBold = oReader;
+					FROM_XML_ELEM(m_oBold, oReader, pRun)
 				else if ( _T("w:bCs") == sName )
-				{
-					if (!oReader.IsEmptyNode())
-					{
-						m_oBoldCs.Init();
-
-						int nParentDepth1 = oReader.GetDepth();
-						while( oReader.ReadNextSiblingNode( nParentDepth1 ) )
-						{
-							std::wstring sName1 = oReader.GetName();
-
-							if ( _T("w:t") == sName1 )
-							{
-								m_pText = new CText( oReader );
-								break;
-							}
-						}
-					}
-					else
-						m_oBoldCs = oReader;
-				}
+					FROM_XML_ELEM(m_oBoldCs, oReader, pRun)
 				else if ( _T("w:bdr") == sName )
 					m_oBdr = oReader;
 				else if ( _T("w:caps") == sName )
-					m_oCaps = oReader;
+					FROM_XML_ELEM(m_oCaps, oReader, pRun)
 				else if ( _T("w:color") == sName )
 					m_oColor = oReader;
 				else if ( _T("w:cs") == sName )
-					m_oCs = oReader;
+					FROM_XML_ELEM(m_oCs, oReader, pRun)
 				else if ( _T("w:del") == sName )
 					m_oDel = oReader;
 				else if ( _T("w:dstrike") == sName )
-					m_oDStrike = oReader;
+					FROM_XML_ELEM(m_oDStrike, oReader, pRun)
 				else if ( _T("w:eastAsianLayout") == sName )
 					m_oEastAsianLayout = oReader;
 				else if ( _T("w:effect") == sName )
@@ -204,7 +204,7 @@ namespace OOX
 				else if ( _T("w:em") == sName )
 					m_oEm = oReader;
 				else if ( _T("w:emboss") == sName )
-					m_oEmboss = oReader;
+					FROM_XML_ELEM(m_oEmboss, oReader, pRun)
 				else if ( _T("w:fitText") == sName )
 					m_oFitText = oReader;
 				else if ( _T("w:highlight") == sName )
@@ -212,25 +212,25 @@ namespace OOX
 				else if ( _T("w:ins") == sName )
 					m_oIns = oReader;
 				else if ( _T("w:i") == sName )
-					m_oItalic = oReader;
+					FROM_XML_ELEM(m_oItalic, oReader, pRun)
 				else if ( _T("w:iCs") == sName )
-					m_oItalicCs = oReader;
+					FROM_XML_ELEM(m_oItalicCs, oReader, pRun)
 				else if ( _T("w:imprint") == sName )
-					m_oImprint = oReader;
+					FROM_XML_ELEM(m_oImprint, oReader, pRun)
 				else if ( _T("w:kern") == sName )
 					m_oKern = oReader;
 				else if ( _T("w:lang") == sName )
-					m_oLang = oReader;
+					FROM_XML_ELEM(m_oLang, oReader, pRun)
 				else if ( _T("w:noProof") == sName )
-					m_oNoProof = oReader;
+					FROM_XML_ELEM(m_oNoProof, oReader, pRun)
 				else if ( _T("m:oMath") == sName )
-					m_oMath = oReader;
+					FROM_XML_ELEM(m_oMath, oReader, pRun)
 				else if ( _T("w:moveFrom") == sName )
 					m_oMoveFrom = oReader;
 				else if ( _T("w:moveTo") == sName )
 					m_oMoveTo = oReader;
 				else if ( _T("w:outline") == sName )
-					m_oOutline = oReader;
+					FROM_XML_ELEM(m_oOutline, oReader, pRun)
 				else if ( _T("w:position") == sName )
 					m_oPosition = oReader;
 				else if ( _T("w:rFonts") == sName )
@@ -244,21 +244,21 @@ namespace OOX
 				else if ( !m_oRStyle.IsInit() && _T("w:pStyle") == sName )
 					m_oRStyle = oReader;
 				else if ( _T("w:rtl") == sName )
-					m_oRtL = oReader;
+					FROM_XML_ELEM(m_oRtL, oReader, pRun)
 				else if ( _T("w:shadow") == sName )
-					m_oShadow = oReader;
+					FROM_XML_ELEM(m_oShadow, oReader, pRun)
 				else if ( _T("w:shd") == sName )
 					m_oShd = oReader;
 				else if ( _T("w:smallCaps") == sName )
-					m_oSmallCaps = oReader;
+					FROM_XML_ELEM(m_oSmallCaps, oReader, pRun)
 				else if ( _T("w:snapToGrid") == sName )
-					m_oSnapToGrid = oReader;
+					FROM_XML_ELEM(m_oSnapToGrid, oReader, pRun)
 				else if ( _T("w:spacing") == sName )
 					m_oSpacing = oReader;
 				else if ( _T("w:specVanish") == sName )
-					m_oSpecVanish = oReader;
+					FROM_XML_ELEM(m_oSpecVanish, oReader, pRun)
 				else if ( _T("w:strike") == sName )
-					m_oStrike = oReader;
+					FROM_XML_ELEM(m_oStrike, oReader, pRun)
 				else if ( _T("w:sz") == sName )
 					m_oSz = oReader;
 				else if ( _T("w:szCs") == sName )
@@ -266,13 +266,13 @@ namespace OOX
 				else if ( _T("w:u") == sName )
 					m_oU = oReader;
 				else if ( _T("w:vanish") == sName )
-					m_oVanish = oReader;
+					FROM_XML_ELEM(m_oVanish, oReader, pRun)
 				else if ( _T("w:vertAlign") == sName )
 					m_oVertAlign = oReader;
 				else if ( _T("w:w") == sName )
 					m_oW = oReader;
 				else if ( _T("w:webHidden") == sName )
-					m_oWebHidden = oReader;
+					FROM_XML_ELEM(m_oWebHidden, oReader, pRun)
 				else if (_T("w14:textOutline") == sName)
 					m_oTextOutline = oReader;
 				else if (_T("w14:textFill") == sName)

Common/DocxFormat/Source/DocxFormat/Logic/RunProperty.h

@@ -702,6 +702,7 @@ namespace OOX
 {
 	namespace Logic
 	{
+		class CRun;
 		class CRunProperty;
 
 		//--------------------------------------------------------------------------------
@@ -770,6 +771,7 @@ namespace OOX
 
 			virtual void fromXML(XmlUtils::CXmlNode& oNode);
 			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			void fromXML(XmlUtils::CXmlLiteReader& oReader, CRun* pRun);
             virtual std::wstring      toXML() const
 			{
                 std::wstring sResult = _T("<w:rPr>");

Common/DocxFormat/Source/XlsxFormat/CalcChain/CalcChain.h

@@ -106,16 +106,25 @@ namespace OOX
 				m_bSpreadsheets = true;
   				
 				CXlsx* xlsx = dynamic_cast<CXlsx*>(File::m_pMainDocument);
-				if (xlsx) xlsx->m_pCalcChain = this;
+				if (xlsx && xlsx->m_bNeedCalcChain) xlsx->m_pCalcChain = this;
 			}
 			CCalcChain(OOX::Document* pMain, const CPath& oRootPath, const CPath& oPath) : OOX::File(pMain), OOX::IFileContainer(pMain)
 			{
 				m_bSpreadsheets = true;
 
 				CXlsx* xlsx = dynamic_cast<CXlsx*>(File::m_pMainDocument);
-				if (xlsx) xlsx->m_pCalcChain = this;
-
-				read( oRootPath, oPath );
+				if (xlsx)
+				{
+					if(xlsx->m_bNeedCalcChain)
+					{
+						xlsx->m_pCalcChain = this;
+						read( oRootPath, oPath );
+					}
+				}
+				else
+				{
+					read( oRootPath, oPath );
+				}
 			}
 			virtual ~CCalcChain()
 			{

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

@@ -35,18 +35,65 @@ namespace OOX
 {
 	namespace Spreadsheet
 	{
-		void CText::fromXMLToXLSB(XmlUtils::CXmlLiteReader& oReader, SimpleTypes::Spreadsheet::ECellTypeType eType, _UINT16& nType, double& dValue, unsigned int& nValue, BYTE& bValue, std::wstring** psValue, bool& bForceFormula)
+		CStringXLSB::CStringXLSB(_UINT32 nSize)
 		{
-			SimpleTypes::EXmlSpace eSpace = SimpleTypes::xmlspaceDefault;
-			ReadAttributesToXLSB( oReader, eSpace );
+			m_nSize = nSize;
+			m_sBuffer = new WCHAR[m_nSize];
+			Clean();
+		}
+		CStringXLSB::~CStringXLSB()
+		{
+			RELEASEARRAYOBJECTS(m_sBuffer);
+		}
+		void CStringXLSB::Clean()
+		{
+			m_nLen = 0;
+		}
+		void CStringXLSB::fromXML(XmlUtils::CXmlLiteReader& oReader, bool bPreserve)
+		{
+			oReader.GetTextWithHHHH(bPreserve, m_sBuffer, m_nSize, m_nLen);
+		}
+		void CStringXLSB::fromStringA(const char* sVal)
+		{
+			LONG nLen = strlen((const char*)sVal);
+			checkBufferSize(NSFile::CUtf8Converter::GetUnicodeStringFromUTF8BufferSize(nLen));
+			NSFile::CUtf8Converter::GetUnicodeStringFromUTF8WithHHHH((const BYTE*)sVal, nLen, m_sBuffer, m_nLen);
+		}
+		void CStringXLSB::checkBufferSize(_UINT32 nRequired)
+		{
+			if(nRequired > m_nSize)
+			{
+				while(nRequired > m_nSize)
+				{
+					m_nSize *= 2;
+				}
+				RELEASEOBJECT(m_sBuffer);
+				m_sBuffer = new WCHAR[m_nSize];
+			}
+		}
+		CTextXLSB::CTextXLSB(_UINT32 nSize):m_oValue(nSize)
+		{
+			Clean();
+		}
+		void CTextXLSB::Clean()
+		{
+			m_bIsInit = false;
+			m_oSpace.SetValue(SimpleTypes::xmlspaceDefault);
+			m_dValue = 0;
+			m_nValue = 0;
+			m_oValue.Clean();
+		}
+		void CTextXLSB::fromXML(XmlUtils::CXmlLiteReader& oReader, SimpleTypes::Spreadsheet::ECellTypeType eType)
+		{
+			ReadAttributes( oReader );
 
 			if ( oReader.IsEmptyNode() )
 				return;
 
 			if(SimpleTypes::Spreadsheet::celltypeStr == eType || SimpleTypes::Spreadsheet::celltypeInlineStr == eType)
 			{
-				std::string sVal = oReader.GetText2A();
-				fromXMLToXLSB(sVal.c_str(), eSpace, eType, nType, dValue, nValue, bValue, psValue, bForceFormula);
+				m_bIsInit = true;
+				m_oValue.fromXML(oReader, SimpleTypes::xmlspacePreserve == m_oSpace.GetValue());
 			}
 			else
 			{
@@ -56,114 +103,86 @@ namespace OOX
 				{
 					if (eNodeType == XmlUtils::XmlNodeType_Text)
 					{
-						fromXMLToXLSB(oReader.GetTextChar(), eSpace, eType, nType, dValue, nValue, bValue, psValue, bForceFormula);
+						const char* pVal = oReader.GetTextChar();
+						if(pVal[0] == '\0')
+							continue;
+						m_bIsInit = true;
+						if(SimpleTypes::Spreadsheet::celltypeNumber == eType)
+						{
+							//todo RkNumber
+							try
+							{
+								m_dValue = atof(pVal);
+							}
+							catch(...)
+							{   //1.3912059045063478e-310
+								//Lighting Load Calculation.xls
+							}
+						}
+						else if(SimpleTypes::Spreadsheet::celltypeSharedString == eType)
+						{
+							try
+							{
+								m_nValue = atoi(pVal);
+							}
+							catch(...)
+							{
+							}
+						}
+						else if(SimpleTypes::Spreadsheet::celltypeError == eType)
+						{
+							if(strcmp("#NULL!", pVal) == 0)
+							{
+								m_nValue = 0x00;
+							}
+							else if(strcmp("#DIV/0!", pVal) == 0)
+							{
+								m_nValue = 0x07;
+							}
+							else if(strcmp("#VALUE!", pVal) == 0)
+							{
+								m_nValue = 0x0F;
+							}
+							else if(strcmp("#REF!", pVal) == 0)
+							{
+								m_nValue = 0x17;
+							}
+							else if(strcmp("#NAME?", pVal) == 0)
+							{
+								m_nValue = 0x1D;
+							}
+							else if(strcmp("#NUM!", pVal) == 0)
+							{
+								m_nValue = 0x24;
+							}
+							else if(strcmp("#N/A", pVal) == 0)
+							{
+								m_nValue = 0x2A;
+							}
+							else if(strcmp("#GETTING_DATA", pVal) == 0)
+							{
+								m_nValue = 0x2B;
+							}
+						}
+						else if(SimpleTypes::Spreadsheet::celltypeBool == eType)
+						{
+							SimpleTypes::COnOff<> oOnOff;
+							oOnOff.FromStringA(pVal);
+							m_nValue = oOnOff.ToBool() ? 1 : 0;
+						}
 					}
 				}
 			}
 		}
-		void CText::fromXMLToXLSB(const char* pVal, SimpleTypes::EXmlSpace eSpace, SimpleTypes::Spreadsheet::ECellTypeType eType, _UINT16& nType, double& dValue, unsigned int& nValue, BYTE& bValue, std::wstring** psValue, bool& bForceFormula)
-		{
-			if(pVal[0] == '\0')
-				return;
-			if(SimpleTypes::Spreadsheet::celltypeNumber == eType)
-			{
-				//todo RkNumber
-				nType = XLSB::rt_CELL_REAL;
-				try
-				{
-					dValue = atof(pVal);
-				}
-				catch(...)
-				{   //1.3912059045063478e-310
-					//Lighting Load Calculation.xls
-				}
-			}
-			else if(SimpleTypes::Spreadsheet::celltypeSharedString == eType)
-			{
-				nType = XLSB::rt_CELL_ISST;
-				try
-				{
-					nValue = atoi(pVal);
-				}
-				catch(...)
-				{
-				}
-			}
-			else if(SimpleTypes::Spreadsheet::celltypeError == eType)
-			{
-				nType = XLSB::rt_CELL_ERROR;
-				if(strcmp("#NULL!", pVal) == 0)
-				{
-					bValue = 0x00;
-				}
-				else if(strcmp("#DIV/0!", pVal) == 0)
-				{
-					bValue = 0x07;
-				}
-				else if(strcmp("#VALUE!", pVal) == 0)
-				{
-					bValue = 0x0F;
-				}
-				else if(strcmp("#REF!", pVal) == 0)
-				{
-					bValue = 0x17;
-				}
-				else if(strcmp("#NAME?", pVal) == 0)
-				{
-					bValue = 0x1D;
-				}
-				else if(strcmp("#NUM!", pVal) == 0)
-				{
-					bValue = 0x24;
-				}
-				else if(strcmp("#N/A", pVal) == 0)
-				{
-					bValue = 0x2A;
-				}
-				else if(strcmp("#GETTING_DATA", pVal) == 0)
-				{
-					bValue = 0x2B;
-				}
-			}
-			else if(SimpleTypes::Spreadsheet::celltypeBool == eType)
-			{
-				nType = XLSB::rt_CELL_BOOL;
-				SimpleTypes::COnOff<> oOnOff;
-				oOnOff.FromStringA(pVal);
-				bValue = oOnOff.ToBool() ? 1 : 0;
-			}
-			else if(SimpleTypes::Spreadsheet::celltypeInlineStr == eType)
-			{
-				nType = XLSB::rt_CELL_ST;
-				if(NULL == (*psValue))
-				{
-					(*psValue) = new std::wstring();
-				}
-				(*psValue)->append(NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pVal, (LONG)strlen(pVal)));
-				trimString(**psValue, eSpace);
-			}
-			else if(SimpleTypes::Spreadsheet::celltypeStr == eType)
-			{
-				bForceFormula = true;
-				nType = XLSB::rt_CELL_ST;
-				if(NULL == (*psValue))
-				{
-					(*psValue) = new std::wstring();
-				}
-				(*psValue)->append(NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE*)pVal, (LONG)strlen(pVal)));
-				trimString(**psValue, eSpace);
-			}
-		}
-		void CText::ReadAttributesToXLSB(XmlUtils::CXmlLiteReader& oReader, SimpleTypes::EXmlSpace& eSpace)
+		void CTextXLSB::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 		{
 			WritingElement_ReadAttributes_StartChar( oReader )
-				if ( strcmp("space", wsName) == 0 )
-				{
-					SimpleTypes::CXmlSpace<> oSpace;
-					oSpace.FromStringA(oReader.GetTextChar());
-					eSpace = oSpace.GetValue();
-					break;
-				}
+
+			if ( strcmp("xml:space", wsName) == 0 )
+			{
+				m_oSpace.FromStringA(oReader.GetTextChar());
+				break;
+			}
 
 			WritingElement_ReadAttributes_EndChar( oReader )
 		}

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

@@ -40,6 +40,36 @@ namespace OOX
 {
 	namespace Spreadsheet
 	{
+		class CStringXLSB
+		{
+		public:
+			CStringXLSB(_UINT32 nSize);
+			~CStringXLSB();
+			void Clean();
+			void fromXML(XmlUtils::CXmlLiteReader& oReader, bool bPreserve);
+			void fromStringA(const char* sVal);
+		public:
+			WCHAR* m_sBuffer;
+			LONG m_nSize;
+			LONG m_nLen;
+		protected:
+			void checkBufferSize(_UINT32 nRequired);
+		};
+		class CTextXLSB
+		{
+		public:
+			CTextXLSB(_UINT32 nSize);
+			void Clean();
+			void fromXML(XmlUtils::CXmlLiteReader& oReader, SimpleTypes::Spreadsheet::ECellTypeType eType);
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+		public:
+			bool m_bIsInit;
+			SimpleTypes::CXmlSpace<> m_oSpace;
+
+			double m_dValue;
+			_UINT32 m_nValue;
+			CStringXLSB m_oValue;
+		};
 		//необработано:
 		class CText : public WritingElement
 		{
@@ -100,9 +130,6 @@ namespace OOX
 
 				trimString(m_sText, GetSpace());
 			}
-			static void fromXMLToXLSB(XmlUtils::CXmlLiteReader& oReader, SimpleTypes::Spreadsheet::ECellTypeType eType, _UINT16& nType, double& dValue, unsigned int& nValue, BYTE& bValue, std::wstring** psValue, bool& bForceFormula);
-			static void fromXMLToXLSB(const char* pVal, SimpleTypes::EXmlSpace eSpace, SimpleTypes::Spreadsheet::ECellTypeType eType, _UINT16& nType, double& dValue, unsigned int& nValue, BYTE& bValue, std::wstring** psValue, bool& bForceFormula);
-
 			static void trimString(std::wstring& sVal, SimpleTypes::EXmlSpace eSpace);
 			std::wstring ToString() const
 			{
@@ -140,7 +167,6 @@ namespace OOX
 
 				oReader.MoveToElement();
 			}
-			static void ReadAttributesToXLSB(XmlUtils::CXmlLiteReader& oReader, SimpleTypes::EXmlSpace& eSpace);
 
 		public:
 

Common/DocxFormat/Source/XlsxFormat/SimpleTypes_Spreadsheet.h

@@ -1443,6 +1443,20 @@ namespace SimpleTypes
                     this->m_eValue = eDefValue;
                 return this->m_eValue;
 			}
+			ECellFormulaType FromStringA(const char* sValue)
+			{
+				if(strcmp("array", sValue) == 0)
+					this->m_eValue = cellformulatypeArray;
+				else if(strcmp("dataTable", sValue) == 0)
+					this->m_eValue = cellformulatypeDataTable;
+				else if(strcmp("normal", sValue) == 0)
+					this->m_eValue = cellformulatypeNormal;
+				else if(strcmp("shared", sValue) == 0)
+					this->m_eValue = cellformulatypeShared;
+				else
+					this->m_eValue = eDefValue;
+				return this->m_eValue;
+			}
 
 			virtual std::wstring     ToString  () const 
 			{

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

@@ -55,6 +55,76 @@ namespace OOX
 {
 	namespace Spreadsheet
 	{
+		class CFormulaXLSB
+		{
+		public:
+			CFormulaXLSB();
+			void Clean();
+			void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			_UINT32 getXLSBSize() const;
+			_UINT16 toXLSB(NSBinPptxRW::CXlsbBinaryWriter& oStream);
+			void toXLSBExt(NSBinPptxRW::CXlsbBinaryWriter& oStream);
+		public:
+			bool m_bIsInit;
+			CStringXLSB m_oFormula;
+			SimpleTypes::Spreadsheet::CCellFormulaType<SimpleTypes::Spreadsheet::cellformulatypeNormal> m_oT;
+			_INT32 m_nSi;
+			CStringXLSB m_oRef;
+			CStringXLSB m_oR1;
+			CStringXLSB m_oR2;
+			SimpleTypes::COnOff<> m_oAca;
+			SimpleTypes::COnOff<> m_oBx;
+			SimpleTypes::COnOff<> m_oCa;
+			SimpleTypes::COnOff<> m_oDel1;
+			SimpleTypes::COnOff<> m_oDel2;
+			SimpleTypes::COnOff<> m_oDt2D;
+			SimpleTypes::COnOff<> m_oDtr;
+		protected:
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+		};
+		class CCellXLSB
+		{
+		public:
+			CCellXLSB();
+			void Clean();
+			void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			void toXLSB(NSBinPptxRW::CXlsbBinaryWriter& oStream);
+		public:
+			_UINT32 m_nCol;
+			_UINT32 m_nStyle;
+			SimpleTypes::Spreadsheet::CCellTypeType<SimpleTypes::Spreadsheet::celltypeNumber> m_oType;
+			SimpleTypes::COnOff<> m_oShowPhonetic;
+
+			CTextXLSB m_oValue;
+			CFormulaXLSB m_oFormula;
+			nullable<CSi> m_oRichText;
+		protected:
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+		};
+		class CRowXLSB
+		{
+		public:
+			CRowXLSB();
+			void Clean();
+			void fromXMLToXLSB(XmlUtils::CXmlLiteReader& oReader, NSBinPptxRW::CXlsbBinaryWriter& oStream, CCellXLSB& oCell);
+			void toXLSB(NSBinPptxRW::CXlsbBinaryWriter& oStream);
+		public:
+			_UINT32 m_nR;
+			_UINT32 m_nS;
+			SimpleTypes::COnOff<> m_oCustomFormat;
+			double m_dHt;
+			SimpleTypes::COnOff<> m_oHidden;
+			SimpleTypes::COnOff<> m_oCustomHeight;
+			BYTE m_nOutlineLevel;
+			SimpleTypes::COnOff<> m_oCollapsed;
+			SimpleTypes::COnOff<> m_oThickBot;
+			SimpleTypes::COnOff<> m_oThickTop;
+			SimpleTypes::COnOff<> m_oPh;
+		protected:
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+		};
+
+
 		class CFormula : public WritingElement
 		{
 		public:
@@ -83,11 +153,7 @@ namespace OOX
 				m_sText = oReader.GetText3();
 			}
 			void fromXLSB (NSBinPptxRW::CBinaryFileReader& oStream);
-			_UINT16 toXLSB (NSBinPptxRW::CXlsbBinaryWriter& oStream);
 			void fromXLSBExt (NSBinPptxRW::CBinaryFileReader& oStream, _UINT16 nFlags);
-			void toXLSBExt (NSBinPptxRW::CXlsbBinaryWriter& oStream);
-			_UINT32 getXLSBSize() const;
-
 			virtual EElementType getType () const
 			{
 				return et_x_Formula;
@@ -152,9 +218,7 @@ namespace OOX
 			}
 			virtual void toXML(NSStringUtils::CStringBuilder& writer) const;
 			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
-			void fromXMLtoXLSB(XmlUtils::CXmlLiteReader& oReader, NSBinPptxRW::CXlsbBinaryWriter& oStream);
 			void fromXLSB (NSBinPptxRW::CBinaryFileReader& oStream, _UINT16 nType, _UINT32 nRow);
-			void toXLSB (NSBinPptxRW::CXlsbBinaryWriter& oStream) const;
 
 			virtual EElementType getType () const
 			{
@@ -270,13 +334,11 @@ namespace OOX
 			}
 			static bool parseRef(std::wstring sRef, int& nRow, int& nCol);
 			static bool parseRefA(const char* sRef, int& nRow, int& nCol);
-			static bool parseRefColA(const char* sRef, int& nCol);
+			static bool parseRefColA(const char* sRef, _UINT32& nCol);
 			static std::wstring combineRef(int nRow, int nCol);
 		private:
 			void PrepareForBinaryWriter();
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
-			void ReadAttributesToXLSB(XmlUtils::CXmlLiteReader& oReader, int& nCol, unsigned int& nStyle, SimpleTypes::Spreadsheet::CCellTypeType<>& oType, bool& bShowPhonetic);
-			void toXLSB2 (NSBinPptxRW::CXlsbBinaryWriter& oStream, int nCol, unsigned int nStyle, bool bShowPhonetic, _UINT16 nType, double dValue, unsigned int nValue, BYTE bValue, std::wstring** psValue, bool bForceFormula, const nullable<CFormula>& oFormula, const nullable<CSi>& oRichText) const;
 
 			nullable<std::string>								m_oRef;
 			nullable<SimpleTypes::CUnsignedDecimalNumber<>>		m_oRow;
@@ -329,6 +391,7 @@ namespace OOX
 			void toXMLStart(NSStringUtils::CStringBuilder& writer) const;
 			void toXMLEnd(NSStringUtils::CStringBuilder& writer) const;
 			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			void fromXMLToXLSB(XmlUtils::CXmlLiteReader& oReader, NSBinPptxRW::CXlsbBinaryWriter& oStream, CCellXLSB& oCell);
 			void fromXLSB (NSBinPptxRW::CBinaryFileReader& oStream, _UINT16 nType);
 			void toXLSB (NSBinPptxRW::CXlsbBinaryWriter& oStream) const;
 			virtual EElementType getType () const
@@ -396,7 +459,6 @@ namespace OOX
 			}
 			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
 			void fromXLSB (NSBinPptxRW::CBinaryFileReader& oStream, _UINT16 nType, CSVWriter::CCSVWriter* pCSVWriter, NSFile::CStreamWriter& oStreamWriter);
-			void toXLSB (NSBinPptxRW::CXlsbBinaryWriter& oStream) const;
 			virtual EElementType getType () const
 			{
 				return et_x_SheetData;

Common/DocxFormat/Source/XlsxFormat/Xlsx.h

@@ -102,6 +102,7 @@ namespace OOX
 			NSBinPptxRW::CXlsbBinaryWriter*					m_pXlsbWriter;
 			int												m_nLastReadRow;
 			int												m_nLastReadCol;
+			bool											m_bNeedCalcChain;// disable because it is useless but reading takes considerable time
 
 			std::vector<CWorksheet*>								m_arWorksheets;	//order as is
 			std::map<std::wstring, OOX::Spreadsheet::CWorksheet*>	m_mapWorksheets; //copy, for fast find - order by rId(name) 
@@ -124,6 +125,7 @@ namespace OOX
 				m_pXlsbWriter = NULL;
 				m_nLastReadRow = 0;
 				m_nLastReadCol = -1;
+				m_bNeedCalcChain = true;
 
 				bDeleteWorkbook			= false;
 				bDeleteSharedStrings	= false;

DesktopEditor/common/File.cpp

@@ -127,6 +127,26 @@ namespace NSFile
         return lCount + 1;
     }
     std::wstring CUtf8Converter::GetUnicodeStringFromUTF8_4bytes( BYTE* pBuffer, LONG lCount )
+    {
+        std::wstring strRes;
+        GetUnicodeStringFromUTF8_4bytes(pBuffer, lCount, strRes);
+        return strRes;
+    }
+    std::wstring CUtf8Converter::GetUnicodeStringFromUTF8_2bytes( BYTE* pBuffer, LONG lCount )
+    {
+        std::wstring strRes;
+        GetUnicodeStringFromUTF8_2bytes(pBuffer, lCount, strRes);
+        return strRes;
+    }
+
+    std::wstring CUtf8Converter::GetUnicodeStringFromUTF8( BYTE* pBuffer, LONG lCount )
+    {
+        std::wstring strRes;
+        GetUnicodeStringFromUTF8(pBuffer, lCount, strRes);
+        return strRes;
+    }
+
+    void CUtf8Converter::GetUnicodeStringFromUTF8_4bytes( BYTE* pBuffer, LONG lCount, std::wstring& sOutput )
     {
         WCHAR* pUnicodeString = new WCHAR[lCount + 1];
         LONG lIndexUnicode = 0;
@@ -205,13 +225,11 @@ namespace NSFile
 
         pUnicodeString[lIndexUnicode] = 0;
 
-        std::wstring strRes(pUnicodeString);
+        sOutput.append(pUnicodeString);
 
         delete [] pUnicodeString;
-
-        return strRes;
     }
-    std::wstring CUtf8Converter::GetUnicodeStringFromUTF8_2bytes( BYTE* pBuffer, LONG lCount )
+    void CUtf8Converter::GetUnicodeStringFromUTF8_2bytes( BYTE* pBuffer, LONG lCount, std::wstring& sOutput )
     {
         WCHAR* pUnicodeString = new WCHAR[lCount + 1];
         WCHAR* pStart = pUnicodeString;
@@ -295,18 +313,16 @@ namespace NSFile
 
         *pUnicodeString++ = 0;
 
-        std::wstring strRes(pStart);
+        sOutput.append(pStart);
 
         delete [] pStart;
-
-        return strRes;
     }
-
-    std::wstring CUtf8Converter::GetUnicodeStringFromUTF8( BYTE* pBuffer, LONG lCount )
+    void CUtf8Converter::GetUnicodeStringFromUTF8( BYTE* pBuffer, LONG lCount, std::wstring& sOutput )
     {
         if (sizeof(WCHAR) == 2)
-            return GetUnicodeStringFromUTF8_2bytes(pBuffer, lCount);
-        return GetUnicodeStringFromUTF8_4bytes(pBuffer, lCount);
+            GetUnicodeStringFromUTF8_2bytes(pBuffer, lCount, sOutput);
+        else
+            GetUnicodeStringFromUTF8_4bytes(pBuffer, lCount, sOutput);
     }
 
 #define CHECK_HHHH(pBuffer) \
@@ -445,7 +461,7 @@ namespace NSFile
         }
 
         pUnicodeString[lIndexUnicode] = 0;
-        lOutputCount = lIndexUnicode;
+		lOutputCount = lIndexUnicode;
     }
     void CUtf8Converter::GetUnicodeStringFromUTF8WithHHHH_2bytes( const BYTE* pBuffer, LONG lCount, wchar_t*& pUnicodes, LONG& lOutputCount )
     {
@@ -542,8 +558,8 @@ namespace NSFile
             }
         }
 
+		lOutputCount = pUnicodeString - pStart;
         *pUnicodeString++ = 0;
-        lOutputCount = pUnicodeString - pStart;
     }
     void CUtf8Converter::GetUnicodeStringFromUTF8WithHHHH( const BYTE* pBuffer, LONG lCount, wchar_t*& pUnicodes, LONG& lOutputCount )
     {

DesktopEditor/common/File.h

@@ -105,11 +105,15 @@ namespace NSFile
         static std::wstring GetUnicodeStringFromUTF8_2bytes( BYTE* pBuffer, LONG lCount );
         static std::wstring GetUnicodeStringFromUTF8( BYTE* pBuffer, LONG lCount );
 
+		static void GetUnicodeStringFromUTF8_4bytes( BYTE* pBuffer, LONG lCount, std::wstring& sOutput );
+		static void GetUnicodeStringFromUTF8_2bytes( BYTE* pBuffer, LONG lCount, std::wstring& sOutput );
+		static void GetUnicodeStringFromUTF8( BYTE* pBuffer, LONG lCount, std::wstring& sOutput );
+
         static void GetUnicodeStringFromUTF8WithHHHH_4bytes( const BYTE* pBuffer, LONG lCount, wchar_t*& pUnicodes, LONG& lOutputCount );
         static void GetUnicodeStringFromUTF8WithHHHH_2bytes( const BYTE* pBuffer, LONG lCount, wchar_t*& pUnicodes, LONG& lOutputCount );
         static void GetUnicodeStringFromUTF8WithHHHH( const BYTE* pBuffer, LONG lCount, wchar_t*& pUnicodes, LONG& lOutputCount );
 
-        static inline LONG GetUnicodeStringFromUTF8BufferSize( LONG lCount );
+        static LONG GetUnicodeStringFromUTF8BufferSize( LONG lCount );
 
         static void GetUtf8StringFromUnicode_4bytes(const wchar_t* pUnicodes, LONG lCount, BYTE*& pData, LONG& lOutputCount, bool bIsBOM = false);
         static void GetUtf8StringFromUnicode_2bytes(const wchar_t* pUnicodes, LONG lCount, BYTE*& pData, LONG& lOutputCount, bool bIsBOM = false);

DesktopEditor/common/StringExt.h

@@ -239,6 +239,50 @@ namespace NSStringExt
 			wsString.replace(nPos, nFromLen, wsTo);
 		}
 	}
+	static inline void LTrim(std::wstring &str, const wchar_t* chars)
+	{
+		str.erase(0, str.find_first_not_of(chars));
+	}
+	static inline void RTrim(std::wstring &str, const wchar_t* chars)
+	{
+		str.erase(str.find_last_not_of(chars) + 1);
+	}
+	static inline long FindFirstNotOfA(const char* str, const char* chars)
+	{
+		long res = 0;
+		while('\0' != str[res])
+		{
+			long index = 0;
+			while('\0' != chars[index] && chars[index] != str[res])
+			{
+				index++;
+			}
+			if('\0' == chars[index])
+			{
+				break;
+			}
+			res++;
+		}
+		return res;
+	}
+	static inline long FindLastNotOf(const wchar_t* str, unsigned int unLen, const wchar_t* chars)
+	{
+		long res = unLen - 1;
+		while(res >= 0)
+		{
+			long index = 0;
+			while('\0' != chars[index] && chars[index] != str[res])
+			{
+				index++;
+			}
+			if('\0' == chars[index])
+			{
+				break;
+			}
+			res--;
+		}
+		return res;
+	}
 }
 
 #endif // _BUILD_STRING_CROSSPLATFORM_H_

DesktopEditor/xml/include/xmlutils.h

@@ -115,6 +115,7 @@ namespace XmlUtils
                 std::string     GetText2A();
 		
 		std::wstring	GetText3();
+		void GetTextWithHHHH(bool bPreserve, wchar_t*& sBuffer, long& nSize, long& nLen);
 
 		std::wstring	GetOuterXml();
 		std::wstring	GetInnerXml();

DesktopEditor/xml/src/xmllight.cpp

@@ -164,6 +164,10 @@ namespace XmlUtils
 	{
 		return m_pInternal->GetText3();
 	}
+	void CXmlLiteReader::GetTextWithHHHH(bool bPreserve, wchar_t*& sBuffer, long& nSize, long& nLen)
+	{
+		return m_pInternal->GetTextWithHHHH(bPreserve, sBuffer, nSize,nLen);
+	}
 
 	std::wstring CXmlLiteReader::GetOuterXml()
 	{

DesktopEditor/xml/src/xmllight_private.h

@@ -33,6 +33,7 @@
 #define _BUILD_XMLLIGHT_PRIVATE_CROSSPLATFORM_H_
 
 #include "../../../DesktopEditor/common/File.h"
+#include "../../../DesktopEditor/common/StringExt.h"
 
 #ifdef _IOS
     #include <libxml2/libxml/xmlreader.h>
@@ -411,6 +412,65 @@ namespace XmlUtils
 
             return sResult;
         }
+		void CheckBufferSize(unsigned int nOffset, unsigned int nRequired, wchar_t*& sBuffer, long& nSize)
+		{
+			if(nOffset + nRequired > nSize)
+			{
+				if(0 == nSize)
+				{
+					nSize = nOffset + nRequired;
+				}
+				while(nOffset + nRequired > nSize)
+				{
+					nSize *= 2;
+				}
+				RELEASEOBJECT(sBuffer);
+				sBuffer = new WCHAR[nSize];
+			}
+		}
+		void GetTextWithHHHH(bool bPreserve, wchar_t*& sBuffer, long& nSize, long& nLen)
+		{
+			nLen = 0;
+			if ( !IsValid() )
+				return;
+
+			if ( 0 != xmlTextReaderIsEmptyElement(reader) )
+				return;
+			bool bTrimLeft, bTrimRight;
+			bTrimLeft = bTrimRight = !bPreserve;
+			LONG lOutputCount = 0;
+			int nDepth = GetDepth();
+			XmlNodeType eNodeType = XmlNodeType_EndElement;
+			while ( Read( eNodeType ) && GetDepth() >= nDepth && XmlNodeType_EndElement != eNodeType )
+			{
+				if ( eNodeType == XmlNodeType_Text || eNodeType == XmlNodeType_Whitespace || eNodeType == XmlNodeType_SIGNIFICANT_WHITESPACE )
+				{
+					const xmlChar* pValue = xmlTextReaderConstValue(reader);
+					if(NULL != pValue)
+					{
+						const char* pValueA = (const char*)pValue;
+						if(bTrimLeft)
+						{
+							bTrimLeft = false;
+							pValueA += NSStringExt::FindFirstNotOfA(pValueA, " \n\r\t");
+						}
+						if('\0' != pValueA[0])
+						{
+							LONG nLenA = strlen((const char*)pValueA);
+							LONG nRequired = NSFile::CUtf8Converter::GetUnicodeStringFromUTF8BufferSize(nLenA);
+							CheckBufferSize(nLen, nRequired, sBuffer, nSize);
+							wchar_t* sBufferCur = sBuffer + nLen;
+							NSFile::CUtf8Converter::GetUnicodeStringFromUTF8WithHHHH((const BYTE*)pValueA, nLenA, sBufferCur, lOutputCount);
+							nLen += lOutputCount;
+						}
+					}
+				}
+			}
+			if(bTrimRight)
+			{
+				nLen = NSStringExt::FindLastNotOf(sBuffer, nLen, L" \n\r\t") + 1;
+			}
+		}
         inline std::wstring GetOuterXml()
         {
             return GetXml(false);

X2tConverter/build/Mac/OfficeOdfConverter/OfficeOdfConverter/OfficeOdfConverter.mm

@@ -196,7 +196,7 @@ namespace NExtractTools
 
 namespace NExtractTools
 {
-    _UINT32 odf2oox_dir(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring & sTemp, InputParams& params)
+    _UINT32 __odf2oox_dir(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring & sTemp, InputParams& params)
     {
         std::wstring sTempUnpackedOdf = sTemp + FILE_SEPARATOR_STR + _T("odf_unpacked");
         NSDirectory::CreateDirectory(sTempUnpackedOdf);
@@ -210,12 +210,12 @@ namespace NExtractTools
         return nRes;
     }
     
-    _UINT32 odf2oox(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring & sTemp, InputParams& params)
+    _UINT32 __odf2oox(const std::wstring &sFrom, const std::wstring &sTo, const std::wstring & sTemp, InputParams& params)
     {
         std::wstring sTempUnpackedOox = sTemp + FILE_SEPARATOR_STR + _T("oox_unpacked");
         NSDirectory::CreateDirectory(sTempUnpackedOox);
         
-        _UINT32 nRes = odf2oox_dir(sFrom, sTempUnpackedOox, sTemp, params);
+        _UINT32 nRes = __odf2oox_dir(sFrom, sTempUnpackedOox, sTemp, params);
         if(SUCCEEDED_X2T(nRes))
         {
             COfficeUtils oCOfficeUtils(NULL);
@@ -288,7 +288,7 @@ namespace NExtractTools
         oInputParams.m_sPassword = new std::wstring(NExtractTools::nsstring_to_wstring(self.password));
     }
     
-    return NExtractTools::odf2oox(from, to, temp, oInputParams);
+    return NExtractTools::__odf2oox(from, to, temp, oInputParams);
 }
 
 - (int)odt2docx:(NSString*)nsFrom nsTo:(NSString*)nsTo nsTemp:(NSString*)nsTemp nsFontPath:(NSString*)nsFontPath {
@@ -304,7 +304,7 @@ namespace NExtractTools
         oInputParams.m_sPassword = new std::wstring(NExtractTools::nsstring_to_wstring(self.password));
     }
     
-    return NExtractTools::odf2oox(from, to, temp, oInputParams);
+    return NExtractTools::__odf2oox(from, to, temp, oInputParams);
 }
 
 - (int)ods2xlsx:(NSString*)nsFrom nsTo:(NSString*)nsTo nsTemp:(NSString*)nsTemp nsFontPath:(NSString*)nsFontPath {
@@ -320,7 +320,7 @@ namespace NExtractTools
         oInputParams.m_sPassword = new std::wstring(NExtractTools::nsstring_to_wstring(self.password));
     }
     
-    return NExtractTools::odf2oox(from, to, temp, oInputParams);
+    return NExtractTools::__odf2oox(from, to, temp, oInputParams);
 }
 
 - (int)odp2pptx:(NSString*)nsFrom nsTo:(NSString*)nsTo nsTemp:(NSString*)nsTemp nsFontPath:(NSString*)nsFontPath {
@@ -336,7 +336,7 @@ namespace NExtractTools
         oInputParams.m_sPassword = new std::wstring(NExtractTools::nsstring_to_wstring(self.password));
     }
     
-    return NExtractTools::odf2oox(from, to, temp, oInputParams);
+    return NExtractTools::__odf2oox(from, to, temp, oInputParams);
 }
 
 @end

XlsxSerializerCom/Reader/BinaryWriter.cpp

@@ -6357,20 +6357,21 @@ _UINT32 BinaryFileWriter::Open(const std::wstring& sInputDir, const std::wstring
 			if (bIsNoBase64)
 			{
 				pXlsx = new OOX::Spreadsheet::CXlsx();
+				pXlsx->m_bNeedCalcChain = false;
 
 				NSBinPptxRW::CXlsbBinaryWriter oXlsbWriter;
 				oXlsbWriter.CreateFileW(sFileDst);
 				//write dummy header and main table
 				oXlsbWriter.WriteStringUtf8(WriteFileHeader(0, g_nFormatVersionNoBase64));
 				oXlsbWriter.WriteReserved(GetMainTableSize());
-				int nDataStartPos = oXlsbWriter.GetPosition();
+				int nDataStartPos = oXlsbWriter.GetPositionAbsolute();
 				pXlsx->m_pXlsbWriter = &oXlsbWriter;
 				//parse
 				pXlsx->Read(OOX::CPath(sInputDir));
 
 				pXlsx->m_pXlsbWriter = NULL;
 				oXlsbWriter.CloseFile();
-				m_nLastFilePosOffset = oXlsbWriter.GetPosition() - nDataStartPos;
+				m_nLastFilePosOffset = oXlsbWriter.GetPositionAbsolute() - nDataStartPos;
 			}
 			else
 			{