Добавлена конвертиция формул из doc в docx

git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@58430 954022d7-b5bf-4e40-9824-e11837661b57

ASCOfficeDocxFile2/ASCOfficeDocxFile2.vcproj

@@ -708,6 +708,10 @@
 			<Filter
 				Name="Writer"
 				>
+				<File
+					RelativePath=".\BinWriter\BinEquationWriter.h"
+					>
+				</File>
 				<File
 					RelativePath=".\BinWriter\BinReaderWriterDefines.h"
 					>

ASCOfficeDocxFile2/BinWriter/BinEquationWriter.h

+#ifndef BINEQUATIONWRITER_H
+#define BINEQUATIONWRITER_H
+
+#include "BinReaderWriterDefines.h"
+#include "../../Common/DocxFormat/Source/MathEquation/OutputDev.h"
+#include "String.h"
+#include <stack>
+
+/*namespace BinDocxRW
+{
+	class BinaryCommonWriter;
+}*/
+namespace MathEquation
+{
+	class BinaryEquationWriter : public IOutputDev
+	{
+		public:
+			NSBinPptxRW::CBinaryFileWriter &m_oStream;
+			//Streams::CBufferedStream &m_oStream;
+			std::stack<int> m_aEquationStack;
+			std::stack<int> m_aNArrayStack;
+			std::stack<int> m_aRunStack;
+			std::stack<int> m_aFractionStack;
+			std::stack<int> m_aGroupChrStack; 
+			std::stack<int> m_aRadicalStack;
+			std::stack<int> m_aMatrixStack;
+			std::stack<int> m_aLimitStack;
+			std::stack<int> m_aLimitElemsStack;
+		public:
+			BinaryEquationWriter(NSBinPptxRW::CBinaryFileWriter &oStream) : bEmbel(false), m_oStream(oStream)
+			{				
+			}
+
+			int WriteItemStart(BYTE type)
+			{
+				//type
+				m_oStream.WriteBYTE(type);
+				return WriteItemWithLengthStart();
+			}
+			void WriteItemEnd(int nStart)
+			{
+				WriteItemWithLengthEnd(nStart);
+			}
+			int WriteItemWithLengthStart()
+			{
+				//       
+				int nStartPos = m_oStream.GetPosition();
+				m_oStream.Skip(4);	
+				return nStartPos;
+			}
+			void WriteItemWithLengthEnd(int nStart)
+			{
+				//Length
+				int nEnd = m_oStream.GetPosition();
+				m_oStream.SetPosition(nStart);
+				m_oStream.WriteLONG(nEnd - nStart - 4);
+				m_oStream.SetPosition(nEnd);
+			}
+
+
+			virtual void BeginEquation()
+			{
+				int nCurPos = WriteItemStart(BinDocxRW::c_oSerParType::OMath);
+				m_aEquationStack.push(nCurPos);
+			}
+			virtual void EndEquation()
+			{
+				int nCurPos = m_aEquationStack.top();
+				WriteItemEnd(nCurPos);
+				m_aEquationStack.pop();
+			}
+			virtual void BeginBlock()
+			{
+				if (!m_aCommandStack.empty())
+				{
+					CBaseCommand* pCommand = TopCommand();
+					pCommand->Next();
+					pCommand->WriteBeginBlock(this);
+				}
+			}
+			virtual void EndBlock()
+			{
+				if (!m_aCommandStack.empty())
+				{
+					CBaseCommand* pCommand = TopCommand();
+					pCommand->WriteEndBlock(this);
+				}
+			}
+			virtual void SetSize(uint16_t nSize)
+			{
+			}
+			virtual void BeginChar(Unicode_t uChar, uint8_t nTypeFace, bool bSpecialSymbol)
+			{
+				if (m_aRunStack.empty());
+				{
+					int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::MRun);
+					m_aRunStack.push(nCurPos);
+				}
+
+				if (uChar)
+				{
+					CString str;
+					if (bSpecialSymbol)
+					{
+						switch(uChar)
+						{
+							case specialsymAlignment:  str.Insert(0,0x0089); break;
+							case specialsymZeroSpace:  str.Insert(0,0x200B); break;
+							case specialsymThinSpace:  str.Insert(0,0x2009); break; break;
+							case specialsymThickSpace: str.Insert(0,0x2004); break;
+							case specialsymLargeSpace: str.Insert(0,0x2005); break;
+							case specialsymOnePtSpace: str.Insert(0,0x2003); break;
+						}
+					}
+					else
+						str.Insert(0,uChar);
+
+					int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::MText);
+					m_oStream.WriteStringW(str);
+					WriteItemEnd(nCurPos1);
+				}
+
+
+				TMathFont* pFont = GetFont(nTypeFace);
+
+				if (NULL != pFont)
+				{
+					int nCurPos2 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::RPr);
+					
+					if (false != pFont->bBold)
+					{
+						m_oStream.WriteBYTE(BinDocxRW::c_oSerProp_rPrType::Bold);
+						m_oStream.WriteBYTE(BinDocxRW::c_oSerPropLenType::Byte);
+						m_oStream.WriteBOOL(true);
+					}
+					if (false != pFont->bItalic)
+					{
+						m_oStream.WriteBYTE(BinDocxRW::c_oSerProp_rPrType::Italic);
+						m_oStream.WriteBYTE(BinDocxRW::c_oSerPropLenType::Byte);
+						m_oStream.WriteBOOL(true);
+					}
+					CString sFontName;
+					sFontName.Format(_T("%S"), pFont->sName.c_str());
+					if (sFontName)
+					{
+						m_oStream.WriteBYTE(BinDocxRW::c_oSerProp_rPrType::FontAscii);
+						m_oStream.WriteBYTE(BinDocxRW::c_oSerPropLenType::Variable);
+						m_oStream.WriteStringW(sFontName);
+
+						m_oStream.WriteBYTE(BinDocxRW::c_oSerProp_rPrType::FontHAnsi);
+						m_oStream.WriteBYTE(BinDocxRW::c_oSerPropLenType::Variable);
+						m_oStream.WriteStringW(sFontName);
+					}
+
+					WriteItemEnd(nCurPos2);
+				}
+
+				bEmbel = false;
+
+			}
+			virtual void AddCharEmbel(MEMBELTYPE eType)
+			{
+			}
+			virtual void EndChar()
+			{
+				int nCurPos = m_aRunStack.top();
+				WriteItemEnd(nCurPos);
+				m_aRunStack.pop();
+			}
+			virtual void BeginMatrix(uint8_t nVAlign, MMATRIXHORALIGN eHorAlign, MMATRIXVERALIGN eVerAlign, bool bEqualRows, bool bEqualCols, uint8_t nRows, uint8_t nCols, uint8_t* pVerBorders, uint8_t* pHorBorders)
+			{
+				CMatrixCommand* pCommand = (CMatrixCommand*)PushCommand(commandMatrix);
+				pCommand->SetProps(nRows, nCols);
+
+				int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Matrix);
+				m_aMatrixStack.push(nCurPos);
+
+				int nCurPos2 = WriteItemStart(BinDocxRW::c_oSer_OMathBottomNodesType::Mcs);
+				int nCurPos3 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Mc);
+				int nCurPos4 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::McPr);
+
+				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::Count, nCols);
+
+				BYTE horAlign;
+				switch(eHorAlign)
+				{
+					case matrixhoralignLeft:		horAlign = SimpleTypes::xalignLeft;
+					case matrixhoralignCenter:		horAlign = SimpleTypes::xalignCenter;
+					case matrixhoralignRight:		horAlign = SimpleTypes::xalignRight;
+					case matrixhoralignEqualSign:	horAlign = SimpleTypes::xalignCenter;
+					case matrixhoralignCommaSign:	horAlign = SimpleTypes::xalignCenter;
+				}
+				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::McJc, horAlign);
+
+				WriteItemEnd(nCurPos4);
+				WriteItemEnd(nCurPos3);
+				WriteItemEnd(nCurPos2);
+
+
+			}
+			virtual void EndMatrix()
+			{
+				PopCommand();
+
+				int nCurPos = m_aMatrixStack.top();
+				WriteItemEnd(nCurPos);
+				m_aMatrixStack.pop();
+			}
+			virtual void StartPile(uint8_t nHAlign, uint8_t nVAlign)
+			{
+			}
+			virtual void EndPile()
+			{
+			}
+			virtual void BeginBrackets(MBRACKETSTYPE eType, bool bOpen, bool bClose)
+			{
+				PushCommand(commandBrackets);
+
+				int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Delimiter);
+				m_aRadicalStack.push(nCurPos);
+
+				int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::DelimiterPr);
+
+				if (!bOpen)
+					WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::BegChr, _T(""));
+				else
+				{
+					CString strOpen;
+					switch(eType)
+					{
+						case bracketsAngle:				strOpen.Insert(0, 0x27E8); break;
+						case bracketsRound:				strOpen.Insert(0, 0x0028); break;
+						case bracketsCurve:				strOpen.Insert(0, 0x007B); break;
+						case bracketsSquare:			strOpen.Insert(0, 0x005B); break;
+						case bracketsLine:				strOpen.Insert(0, 0x007C); break;
+						case bracketsDLine:				strOpen.Insert(0, 0x2016); break;
+						case bracketsFloor:				strOpen.Insert(0, 0x23A3); break;
+						case bracketsCeil:				strOpen.Insert(0, 0x23A1); break;
+						case bracketsSquareOpenOpen:	strOpen.Insert(0, 0x005B); break;
+						case bracketsSquareCloseClose:	strOpen.Insert(0, 0x005D); break;
+						case bracketsSquareCloseOpen:	strOpen.Insert(0, 0x005D); break;
+						case bracketsSquareRound:		strOpen.Insert(0, 0x005B); break;
+						case bracketsRoundSquare:		strOpen.Insert(0, 0x0028); break;
+					}
+					WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::BegChr, strOpen);
+				}
+
+				if (!bClose)
+					WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::EndChr, _T(""));
+				else
+				{
+					CString strEnd;
+					switch(eType)
+					{
+						case bracketsAngle:				strEnd.Insert(0, 0x27E9); break;
+						case bracketsRound:				strEnd.Insert(0, 0x0029); break;
+						case bracketsCurve:				strEnd.Insert(0, 0x007D); break;
+						case bracketsSquare:			strEnd.Insert(0, 0x005D); break;
+						case bracketsLine:				strEnd.Insert(0, 0x007C); break;
+						case bracketsDLine:				strEnd.Insert(0, 0x2016); break;
+						case bracketsFloor:				strEnd.Insert(0, 0x23A6); break;
+						case bracketsCeil:				strEnd.Insert(0, 0x23A4); break;
+						case bracketsSquareOpenOpen:	strEnd.Insert(0, 0x005B); break;
+						case bracketsSquareCloseClose:	strEnd.Insert(0, 0x005D); break;
+						case bracketsSquareCloseOpen:	strEnd.Insert(0, 0x005B); break;
+						case bracketsSquareRound:		strEnd.Insert(0, 0x0029); break;
+						case bracketsRoundSquare:		strEnd.Insert(0, 0x005D); break;
+					}
+					WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::EndChr, strEnd);
+				}
+
+				WriteItemEnd(nCurPos1);
+			}
+			virtual void EndBrackets  (MBRACKETSTYPE eType, bool bOpen, bool bClose)
+			{
+				PopCommand();
+			}
+			virtual void BeginRoot(bool bDegree)
+			{
+				PushCommand(commandRoot);
+
+				int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Rad);
+				m_aRadicalStack.push(nCurPos);
+
+				int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::RadPr);
+				if (!bDegree)
+					WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::DegHide, true);
+				WriteItemEnd(nCurPos1);
+			}
+			virtual void EndRoot  ()
+			{
+				PopCommand();
+
+				int nCurPos = m_aRadicalStack.top();
+				WriteItemEnd(nCurPos);
+				m_aRadicalStack.pop();
+			}
+			virtual void BeginFraction(MFRACTIONTYPES eType, bool bInline)
+			{
+				PushCommand(commandFraction);
+
+				int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Fraction);
+				m_aFractionStack.push(nCurPos);
+
+				int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::FPr);
+				BYTE fracType;
+				switch(eType)
+				{
+					case fractionRegular:	
+						fracType = SimpleTypes::fTypeBar; 
+						break;
+					case fractionSlanted:	
+						if (bInline)
+							fracType = SimpleTypes::fTypeLin;
+						else
+							fracType = SimpleTypes::fTypeSkw;
+						break;
+				}
+				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::Type, fracType);
+
+				WriteItemEnd(nCurPos1);
+			}
+			virtual void EndFraction  ()
+			{
+				PopCommand();
+
+				int nCurPos = m_aFractionStack.top();
+				WriteItemEnd(nCurPos);
+				m_aFractionStack.pop();
+			}
+			virtual void BeginScript(MSCRIPTALIGN eAlign, bool bBase = false, bool bSup = false, bool bSub = false, bool bInline = true)
+			{
+				CScriptCommand* pCommand = (CScriptCommand*)PushCommand(commandScript);
+				pCommand->SetProps(bInline, bBase, bSup, bSub);
+			}
+			virtual void EndScript  ()
+			{
+				PopCommand();
+			}
+			virtual void BeginBar(MBARTYPE eType, bool bTop)
+			{
+				PushCommand(commandBar);
+
+				int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::GroupChr);
+				m_aGroupChrStack.push(nCurPos);
+
+				int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::GroupChrPr);
+				
+				BYTE pos, vertJc;
+				if (bTop)
+				{
+					pos		= SimpleTypes::tbTop;
+					vertJc	= SimpleTypes::tbBot;
+				}
+				else
+				{
+					pos		= SimpleTypes::tbBot;
+					vertJc	= SimpleTypes::tbTop;
+				}
+
+				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::Pos, pos);
+				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::VertJc, vertJc);
+
+				CString str;
+				switch(eType)
+				{
+					case bartypeLine:			str.Insert(0,0x0305);break;
+					case bartypeDoubleLine:		str.Insert(0,0x033F);break;
+					case bartypeArrowLeft:		str.Insert(0,0x20D6);break;
+					case bartypeArrowRight:		str.Insert(0,0x20D7);break;
+					case bartypeArrowDouble:	str.Insert(0,0x20E1);break;
+				}
+				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+
+				WriteItemEnd(nCurPos1);
+
+			}
+			virtual void EndBar  ()
+			{
+				PopCommand();
+
+				int nCurPos = m_aGroupChrStack.top();
+				WriteItemEnd(nCurPos);
+				m_aGroupChrStack.pop();
+			}
+			virtual void BeginArrow(MARROWTYPE eType, bool bTop)
+			{
+				PushCommand(commandArrow);
+
+				int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::GroupChr);
+				m_aGroupChrStack.push(nCurPos);
+
+				int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::GroupChrPr);
+				
+				BYTE pos, vertJc;
+				if (bTop)
+				{
+					pos		= SimpleTypes::tbBot;
+					vertJc	= SimpleTypes::tbBot;
+				}
+				else
+				{
+					pos		= SimpleTypes::tbTop;
+					vertJc	= SimpleTypes::tbTop;
+				}
+
+				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::Pos, pos);
+				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::VertJc, vertJc);
+
+				CString str;
+				switch(eType)
+				{
+					case arrowtypeLeft:			str.Insert(0,0x2190);break;
+					case arrowtypeRight:		str.Insert(0,0x2192);break;
+					case arrowtypeDouble:		str.Insert(0,0x2194);break;
+				}
+				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+
+				WriteItemEnd(nCurPos1);
+			}
+			virtual void EndArrow  ()
+			{
+				PopCommand();
+
+				int nCurPos = m_aGroupChrStack.top();
+				WriteItemEnd(nCurPos);
+				m_aGroupChrStack.pop();
+			}
+			virtual void BeginIntegral(MINTEGRALTYPE eType)
+			{
+				PushCommand(commandIntegral);
+
+				int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Nary);
+				m_aNArrayStack.push(nCurPos);
+
+				int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::NaryPr);
+				CString str;
+				switch(eType)
+				{		
+					case integraltypeSingle:
+						str.Insert(0,0x222B);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
+						break;
+					case integraltypeSingleRSub:
+						str.Insert(0,0x222B);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
+						break;
+					case integraltypeSingleRSubSup:
+						str.Insert(0,0x222B);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						break;
+					case integraltypeSingleOriented:
+						str.Insert(0,0x222E);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
+						break;
+					case integraltypeSingleOrientedRSub:
+						str.Insert(0,0x222E);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
+						break;
+
+					case integraltypeDouble:
+						str.Insert(0,0x222C);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
+						break;
+					case integraltypeDoubleRSub:
+						str.Insert(0,0x222C);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
+						break;
+					case integraltypeDoubleOriented:
+						str.Insert(0,0x222F);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
+						break;
+					case integraltypeDoubleOrientedRSub:
+						str.Insert(0,0x222F);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+
+					case integraltypeTriple:
+						str.Insert(0,0x222D);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
+						break;
+					case integraltypeTripleRSub:
+						str.Insert(0,0x222D);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case integraltypeTripleOriented:
+						str.Insert(0,0x2230);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr); 
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
+						break;
+					case integraltypeTripleOrientedRSub:
+						str.Insert(0,0x2230);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+
+					case integraltypeSingleCSubSup:
+						str.Insert(0,0x222B);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						break;
+					case integraltypeSingleCSub:
+						str.Insert(0,0x222B);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
+						break;
+					case integraltypeSingleOrientedCSub:
+						str.Insert(0,0x222E);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+
+					case integraltypeDoubleOrientedCSub:
+						str.Insert(0,0x222F);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case integraltypeDoubleCSub:
+						str.Insert(0,0x222C);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+
+					case integraltypeTripleOrientedCSub:
+						str.Insert(0,0x2230);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case integraltypeTripleCSub:
+						str.Insert(0,0x222D);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+				}
+
+				
+				WriteItemEnd(nCurPos1);
+			}
+			virtual void EndIntegral  ()
+			{
+				PopCommand();
+
+				int nCurPos = m_aNArrayStack.top();
+				WriteItemEnd(nCurPos);
+				m_aNArrayStack.pop();
+			}
+			virtual void BeginVerticalBrace(bool bTop)
+			{
+				BYTE pos, vertJc;
+				CString chr;
+				if (bTop)
+				{
+					chr.Insert(0,0x23DE);
+					vertJc = SimpleTypes::verticaljcBottom;
+					pos = SimpleTypes::tbTop;
+					int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::LimUpp);
+					m_aLimitStack.push(nCurPos);
+
+					int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::LimUppPr);
+					//+ctrlprp
+					WriteItemEnd(nCurPos1);
+				}
+				else
+				{
+					chr.Insert(0,0x23DF);
+					vertJc = SimpleTypes::verticaljcTop;
+					pos = SimpleTypes::tbBot;
+					int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::LimLow);
+					m_aLimitStack.push(nCurPos);
+
+					int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::LimLowPr);
+					//+ctrlprp
+					WriteItemEnd(nCurPos1);
+				}
+				
+
+				int nCurPos2 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
+				int nCurPos3 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::GroupChr);
+
+				int nCurPos4 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::GroupChrPr);
+				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, chr);
+				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::Pos, pos);
+				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::VertJc, vertJc);
+				WriteItemEnd(nCurPos4);
+
+				int nCurPos5 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
+				PushCommand(commandVerticalBrace);
+				WriteItemEnd(nCurPos5);
+				
+				WriteItemEnd(nCurPos3);
+				WriteItemEnd(nCurPos2);
+			}
+			virtual void EndVerticalBrace  ()
+			{
+				PopCommand();
+
+				int nCurPos = m_aLimitStack.top();
+				WriteItemEnd(nCurPos);
+				m_aLimitStack.pop();
+			}
+			virtual void BeingNArray(MNARRAYTYPE eType)
+			{
+				CNArrayCommand* pCommand = (CNArrayCommand*)PushCommand(commandNArray);
+				pCommand->SetType(eType);
+
+				int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Nary);
+				m_aNArrayStack.push(nCurPos);
+
+				int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::NaryPr);
+				CString str;
+				switch(eType)
+				{		
+					case narySumCSub:
+						str.Insert(0,0x2211);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case narySumCSubSup:
+						str.Insert(0,0x2211);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup); 
+						break;
+					case narySum:
+						str.Insert(0,0x2211);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
+						break;
+					case narySumRSub:
+						str.Insert(0,0x2211);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case narySumRSubSup:
+						str.Insert(0,0x2211);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						break;
+
+					case naryProdCSub:
+						str.Insert(0,0x220F);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case naryProdCSubSup:
+						str.Insert(0,0x220F);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup); 
+						break;
+					case naryProd:
+						str.Insert(0,0x220F);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
+						break;
+					case naryProdRSub:
+						str.Insert(0,0x220F);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case naryProdRSubSup:
+						str.Insert(0,0x220F);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						break;
+
+					case naryCoProdCSub:
+						str.Insert(0,0x2210);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case naryCoProdCSubSup:
+						str.Insert(0,0x2210);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup); 
+						break;
+					case naryCoProd:
+						str.Insert(0,0x2210);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
+						break;
+					case naryCoProdRSub:
+						str.Insert(0,0x2210);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case naryCoProdRSubSup:
+						str.Insert(0,0x2210);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						break;
+
+					case naryUnionCSub:
+						str.Insert(0,0x22C3);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case naryUnionCSubSup:
+						str.Insert(0,0x22C3);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup); 
+						break;
+					case naryUnion:
+						str.Insert(0,0x22C3);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
+						break;
+					case naryUnionRSub:
+						str.Insert(0,0x22C3);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case naryUnionRSubSup:
+						str.Insert(0,0x22C3);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						break;
+
+					case naryIntersectCSub:
+						str.Insert(0,0x22C2);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case naryIntersectCSubSup:
+						str.Insert(0,0x22C2);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup); 
+						break;
+					case naryIntersect:
+						str.Insert(0,0x22C2);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocSubSup);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
+						break;
+					case naryIntersectRSub:
+						str.Insert(0,0x22C2);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true); 
+						break;
+					case naryIntersectRSubSup:
+						str.Insert(0,0x22C2);
+						WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
+						WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, SimpleTypes::limLocUndOvr);
+						break;
+
+				}
+
+				
+				WriteItemEnd(nCurPos1);
+			}
+			virtual void EndNArray  ()
+			{
+				CNArrayCommand* pCommand = (CNArrayCommand*)TopCommand();
+				MNARRAYTYPE eType = pCommand->GetType();
+				PopCommand();
+
+				int nCurPos = m_aNArrayStack.top();
+				WriteItemEnd(nCurPos);
+				m_aNArrayStack.pop();
+			}
+			virtual void BeginLongDivision(MLONGDIVISION eType)
+			{
+				PushCommand(commandLongDivision);
+			}
+			virtual void EndLongDivision  ()
+			{
+				PopCommand();
+			}
+			virtual void BeginAngleBracketsWithSeparator(MANGLEBRACKETSWITHSEPARATORTYPE eType)
+			{
+				CBracketsWithSeparatorCommand* pCommand = (CBracketsWithSeparatorCommand*)PushCommand(commandBracketsSep);
+				pCommand->SetType(eType);
+			}
+			virtual void EndAngleBracketsWithSeparator  ()
+			{
+				PopCommand();
+			}
+
+			void AddFont(uint8_t nTypeFace, std::string sName, bool bBold, bool bItalic)
+			{
+				TMathFont aFont;
+				aFont.sName   = sName;
+				aFont.bBold   = bBold;
+				aFont.bItalic = bItalic;
+				m_mFonts[nTypeFace] = aFont;
+			}
+			void WriteItemVal(BYTE name, BYTE val)
+			{
+				int nCurPos = WriteItemStart(name);
+
+				m_oStream.WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
+				m_oStream.WriteBYTE(BinDocxRW::c_oSerPropLenType::Byte);
+				m_oStream.WriteBYTE(val);
+
+				WriteItemEnd(nCurPos);
+			}
+			void WriteItemVal(BYTE name, LONG val)
+			{
+				int nCurPos = WriteItemStart(name);
+
+				m_oStream.WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
+				m_oStream.WriteBYTE(BinDocxRW::c_oSerPropLenType::Long);
+				m_oStream.WriteLONG(val);
+
+				WriteItemEnd(nCurPos);
+			}
+			void WriteItemVal(BYTE name, BOOL val)
+			{
+				int nCurPos = WriteItemStart(name);
+
+				m_oStream.WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
+				m_oStream.WriteBYTE(BinDocxRW::c_oSerPropLenType::Byte);
+				m_oStream.WriteBOOL(val);
+
+				WriteItemEnd(nCurPos);
+			}
+			void WriteItemValStr(BYTE name, CString val)
+			{
+				int nCurPos = WriteItemStart(name);
+
+				m_oStream.WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
+				m_oStream.WriteBYTE(BinDocxRW::c_oSerPropLenType::Variable);
+				m_oStream.WriteStringW(val);
+
+				WriteItemEnd(nCurPos);
+			}
+
+		private:
+		enum ECommandType
+		{
+			commandMatrix        = 0x00,
+			commandBrackets      = 0x01,
+			commandRoot          = 0x02,
+			commandFraction      = 0x03,
+			commandScript        = 0x04,
+			commandBar           = 0x05,
+			commandArrow         = 0x06,
+			commandIntegral      = 0x07,
+			commandVerticalBrace = 0x08,
+			commandNArray        = 0x09,
+			commandLongDivision  = 0x0a,
+			commandBracketsSep   = 0x0b
+		};
+
+		class CBaseCommand
+		{
+		public:
+
+			CBaseCommand() : nBlockNum(-1)
+			{
+			}
+
+			virtual ~CBaseCommand() 
+			{
+			}
+
+			void Next() 
+			{
+				nBlockNum++;
+			}
+
+			int GetBlockNum()
+			{
+				return nBlockNum;
+			}
+
+			virtual ECommandType GetCommand() = 0;
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter) = 0;
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)   = 0;
+
+		protected:
+			int nBlockNum;
+		};
+
+		class CMatrixCommand : public CBaseCommand
+		{
+		public:
+			CMatrixCommand() : nRows(0), nCols(0) {}
+			virtual ~CMatrixCommand() {}
+			virtual ECommandType GetCommand()
+			{
+				return commandMatrix;
+			}
+
+			void SetProps(int nRows, int nCols)
+			{
+				this->nRows = nRows;
+				this->nCols = nCols;
+			}
+
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{
+				int nCurRow = nBlockNum / nCols;
+				int nCurCol = nBlockNum % nCols;
+				
+				if (0 == nCurCol)
+					nRowPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Mr);
+
+				nColPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
+			}
+
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				int nCurRow = nBlockNum / nCols;
+				int nCurCol = nBlockNum % nCols;
+
+				pWriter->WriteItemEnd(nColPos);
+
+				if (nCols - 1 == nCurCol)
+					pWriter->WriteItemEnd(nRowPos);
+			}
+		private:
+			int nRowPos;
+			int nColPos;
+			int nRows;
+			int nCols;
+		};
+		class CBracketsCommand : public CBaseCommand
+		{
+		public:
+			CBracketsCommand() {}
+			virtual ~CBracketsCommand() {}
+			virtual ECommandType GetCommand(){return commandBrackets;}
+
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{
+				nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
+			}
+
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				pWriter->WriteItemEnd(nElemPos);
+			}
+		private:
+			int nElemPos;
+		};
+		class CRootCommand : public CBaseCommand
+		{
+		public:
+			CRootCommand() {}
+			virtual ~CRootCommand() {}
+			virtual ECommandType GetCommand(){return commandRoot;}
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{
+				if (0 == nBlockNum)
+					nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
+				else if (1 == nBlockNum)
+					nDegPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Deg);	
+			}
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				if (0 == nBlockNum)
+					pWriter->WriteItemEnd(nElemPos);
+				else if (1 == nBlockNum)
+					pWriter->WriteItemEnd(nDegPos);	
+			}
+		private:
+			int nElemPos;
+			int nDegPos;
+		};
+		class CFractionCommand : public CBaseCommand
+		{
+		public:
+			CFractionCommand() {}
+			virtual ~CFractionCommand() {}
+			virtual ECommandType GetCommand(){return commandFraction;}
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{
+				if (0 == nBlockNum)
+					nNumPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Num);	
+				else if (1 == nBlockNum)
+					nDenPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Den);		
+			}
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				if (0 == nBlockNum)
+					pWriter->WriteItemEnd(nNumPos);
+				else if (1 == nBlockNum)
+					pWriter->WriteItemEnd(nDenPos);
+			}
+		private:
+			int nNumPos;
+			int nDenPos;
+		};
+		class CScriptCommand : public CBaseCommand
+		{
+		public:
+			CScriptCommand() {}
+			virtual ~CScriptCommand() {}
+			virtual ECommandType GetCommand(){return commandScript;}
+
+			void SetProps(bool bInline, bool bBase, bool bSup, bool bSub)
+			{
+				this->bBase   = bBase;
+				this->bInline = bInline;
+				this->bSub    = bSub;
+				this->bSup    = bSup;
+			}
+
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{									
+				Write(pWriter, true);
+			}
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				Write(pWriter, false);
+			}
+
+		private:
+
+			void Write(BinaryEquationWriter* pWriter, bool bBegin)
+			{
+				if (bInline)
+				{
+					if (0 == nBlockNum)
+					{
+						if (bBase)
+							WriteNode("base", pWriter, bBegin);
+						else if (bSub)
+							WriteNode("sub", pWriter, bBegin);
+						else if (bSup)
+							WriteNode("sup", pWriter, bBegin);
+					}
+					else if (1 == nBlockNum)
+					{
+						if (bBase)
+						{
+							if (bSub)
+								WriteNode("sub", pWriter, bBegin);
+							else if (bSup)
+								WriteNode("sup", pWriter, bBegin);
+						}
+						else if (bSub && bSup)
+						{
+							WriteNode("sup", pWriter, bBegin);
+						}
+					}
+					else if (2 == nBlockNum)
+					{
+						if (bBase && bSub && bSup)
+							WriteNode("sup", pWriter, bBegin);
+					}
+				}
+				else
+				{
+					if (0 == nBlockNum)
+					{
+						if (bSub)
+							WriteNode("sub", pWriter, bBegin);
+						else if (bSup)
+							WriteNode("sup", pWriter, bBegin);
+						else if (bBase)
+							WriteNode("base", pWriter, bBegin);
+					}
+					else if (1 == nBlockNum)
+					{
+						if (bSub)
+						{
+							if (bSup)
+								WriteNode("sup", pWriter, bBegin);
+							else if (bBase)
+								WriteNode("base", pWriter, bBegin);
+						}
+						else if (bSup && bBase)
+						{
+							WriteNode("base", pWriter, bBegin);
+						}
+					}
+					else if (2 == nBlockNum)
+					{
+						if (bBase && bSub && bSup)
+							WriteNode("base", pWriter, bBegin);
+					}
+				}
+			}
+
+			void WriteNode(const char* sNodeName, BinaryEquationWriter* pWriter, bool bNodeBegin)
+			{
+				if (bNodeBegin)
+					pWriter->WriteNodeBegin(sNodeName);
+				else
+					pWriter->WriteNodeEnd(sNodeName);
+			}
+
+		private:
+			bool bBase;
+			bool bSup;
+			bool bSub;
+			bool bInline;
+		};
+		class CBarCommand : public CBaseCommand
+		{
+		public:
+			CBarCommand() {}
+			virtual ~CBarCommand() {}
+			virtual ECommandType GetCommand(){return commandBar;}
+
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{
+				nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
+			}
+
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				pWriter->WriteItemEnd(nElemPos);
+			}
+		private:
+			int nElemPos;
+		};
+		class CArrowCommand : public CBaseCommand
+		{
+		public:
+			CArrowCommand() {}
+			virtual ~CArrowCommand() {}
+			virtual ECommandType GetCommand(){return commandArrow;}
+
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{
+				nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
+			}
+
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				pWriter->WriteItemEnd(nElemPos);
+			}
+		private:
+			int nElemPos;
+		};
+		class CIntegralCommand : public CBaseCommand
+		{
+		public:
+			CIntegralCommand() {}
+			virtual ~CIntegralCommand() {}
+			virtual ECommandType GetCommand(){return commandIntegral;}
+
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{									
+				Write(pWriter, true);
+			}
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				Write(pWriter, false);
+			}
+
+		private:
+
+			void Write(BinaryEquationWriter* pWriter, bool bBeginNode)
+			{
+				if (0 == nBlockNum)
+				{
+					if (bBeginNode)
+						nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
+					else
+						pWriter->WriteItemEnd(nElemPos);
+				}
+				else if (1 == nBlockNum)
+				{
+					if (bBeginNode)
+						nSubPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Sub);
+					else
+						pWriter->WriteItemEnd(nSubPos);
+				}
+				else if (2 == nBlockNum)
+				{
+					if (bBeginNode)
+						nSupPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Sup);
+					else
+						pWriter->WriteItemEnd(nSupPos);
+				}
+			}
+
+		private:
+			int nSubPos;
+			int nSupPos;
+			int nElemPos;
+		};
+		class CVerticalBraceCommand : public CBaseCommand
+		{
+		public:
+			CVerticalBraceCommand() {}
+			virtual ~CVerticalBraceCommand() {}
+			virtual ECommandType GetCommand(){return commandVerticalBrace;}
+
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{
+				if (0 == nBlockNum)
+					pWriter->WriteNodeBegin("base");
+				else
+					pWriter->WriteNodeBegin("brace-base");
+			}
+
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				if (0 == nBlockNum)
+					pWriter->WriteNodeEnd("base");
+				else
+					pWriter->WriteNodeEnd("brace-base");
+			}
+		private:
+			int nBasePos;
+			int nBraceBasePos;
+		};
+		class CNArrayCommand : public CBaseCommand
+		{
+		public:
+			CNArrayCommand() {}
+			virtual ~CNArrayCommand() {}
+			virtual ECommandType GetCommand(){return commandNArray;}
+
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{									
+				Write(pWriter, true);
+			}
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				Write(pWriter, false);
+			}
+
+			void SetType(MNARRAYTYPE eType)
+			{
+				this->eType = eType;
+			}
+
+			MNARRAYTYPE GetType()
+			{
+				return eType;
+			}
+
+		private:
+
+			void Write(BinaryEquationWriter* pWriter, bool bBeginNode)
+			{
+				if (0 == nBlockNum)
+				{
+					if (bBeginNode)
+						nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
+					else
+						pWriter->WriteItemEnd(nElemPos);
+				}
+				else if (1 == nBlockNum)
+				{
+					if (bBeginNode)
+						nSubPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Sub);
+					else
+						pWriter->WriteItemEnd(nSubPos);
+				}
+				else if (2 == nBlockNum)
+				{
+					if (bBeginNode)
+						nSupPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Sup);
+					else
+						pWriter->WriteItemEnd(nSupPos);
+				}
+			}
+
+		private:
+			int nSubPos;
+			int nSupPos;
+			int nElemPos;
+			MNARRAYTYPE eType;
+		};
+
+		class CLongDivisionCommand : public CBaseCommand
+		{
+		public:
+			CLongDivisionCommand() {}
+			virtual ~CLongDivisionCommand() {}
+			virtual ECommandType GetCommand(){return commandLongDivision;}
+
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{
+				if (0 == nBlockNum)
+					pWriter->WriteNodeBegin("base");
+				else
+					pWriter->WriteNodeBegin("result");
+			}
+
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				if (0 == nBlockNum)
+					pWriter->WriteNodeEnd("base");
+				else
+					pWriter->WriteNodeEnd("result");
+			}
+		};
+		class CBracketsWithSeparatorCommand : public CBaseCommand
+		{
+		public:
+			CBracketsWithSeparatorCommand() {}
+			virtual ~CBracketsWithSeparatorCommand() {}
+			virtual ECommandType GetCommand(){return commandBracketsSep;}
+		
+			void SetType(MANGLEBRACKETSWITHSEPARATORTYPE eType)
+			{
+				this->eType = eType;
+			}
+
+			virtual void WriteBeginBlock(BinaryEquationWriter* pWriter)
+			{									
+				Write(pWriter, true);
+			}
+			virtual void WriteEndBlock(BinaryEquationWriter* pWriter)
+			{
+				Write(pWriter, false);
+			}
+
+		private:
+
+			void Write(BinaryEquationWriter* pWriter, bool bBeginNode)
+			{
+				if (0 == nBlockNum)
+				{
+					if (angbrwithsepBoth == eType || angbrwithsepLeft == eType)
+						WriteNode("left", pWriter, bBeginNode);
+					else
+						WriteNode("right", pWriter, bBeginNode);
+				}
+				else if (1 == nBlockNum)
+				{
+					WriteNode("right", pWriter, bBeginNode);
+				}
+			}
+
+			void WriteNode(const char* sNodeName, BinaryEquationWriter* pWriter, bool bNodeBegin)
+			{
+				if (bNodeBegin)
+					pWriter->WriteNodeBegin(sNodeName);
+				else
+					pWriter->WriteNodeEnd(sNodeName);
+			}
+		private:
+
+			MANGLEBRACKETSWITHSEPARATORTYPE eType;
+
+		};
+		CBaseCommand* PushCommand(ECommandType eType)
+		{
+			CBaseCommand* pCommand = NULL;
+			switch(eType)
+			{
+			case commandMatrix:        pCommand = new CMatrixCommand(); break;
+			case commandBrackets:      pCommand = new CBracketsCommand(); break;
+			case commandRoot:          pCommand = new CRootCommand(); break;
+			case commandFraction:      pCommand = new CFractionCommand(); break;
+			case commandScript:        pCommand = new CScriptCommand(); break;
+			case commandBar:           pCommand = new CBarCommand(); break;
+			case commandArrow:         pCommand = new CArrowCommand(); break;
+			case commandIntegral:      pCommand = new CIntegralCommand(); break;
+			case commandVerticalBrace: pCommand = new CVerticalBraceCommand(); break;
+			case commandNArray:        pCommand = new CNArrayCommand(); break;
+			case commandLongDivision:  pCommand = new CLongDivisionCommand(); break;
+			case commandBracketsSep:   pCommand = new CBracketsWithSeparatorCommand(); break;
+			}
+
+			m_aCommandStack.push(pCommand);
+
+			return pCommand;
+		}
+		void PopCommand()
+		{
+			CBaseCommand* pCommand = m_aCommandStack.top();
+			if (pCommand)
+				delete pCommand;
+
+			m_aCommandStack.pop();
+		}
+
+		CBaseCommand* TopCommand()
+		{
+			return m_aCommandStack.top();
+		}
+		void WriteNodeBegin(const char* sName, bool bAttributes = false)
+		{
+			rRet += "<";
+			rRet += sName;
+
+			if (!bAttributes)
+				rRet += ">";
+		}
+		void WriteNodeEnd(bool bEmpty = false)
+		{
+			if (bEmpty)
+				rRet += "/>";
+			else
+				rRet += ">";
+		}
+		void WriteNodeEnd(const char* sName)
+		{
+			rRet += "</";
+			rRet += sName;
+			rRet += ">";
+		}
+		void WriteBOOLAttribute(const char* sName, bool bValue)
+		{
+			rRet += " ";
+			rRet += sName;
+			rRet += "=\"";
+			if (bValue)
+				rRet += "true";
+			else
+				rRet += "false";
+			rRet += "\"";
+		}
+
+		void WriteStringAttribute(const char* sName, std::string sValue)
+		{
+			/*rRet += " ";
+			rRet += sName;
+			rRet += "=\"";
+			rRet += sValue;
+			rRet += "\"";*/
+		}
+		void WriteStringAttribute(const char* sName, Unicode_t uChar)
+		{
+			/*rRet += " ";
+			rRet += sName;
+			rRet += "=\"";
+			rRet += uChar;
+			rRet += "\"";*/
+		}
+		void WriteIntAttribute(const char* sName, int nValue)
+		{
+			/*rRet += " ";
+			rRet += sName;
+			rRet += "=\"";
+			rRet += String::CreateFromInt32(nValue);
+			rRet += "\"";*/
+		}
+
+		private:
+
+			CString rRet;
+
+			bool bEmbel;
+			std::stack<CBaseCommand*> m_aCommandStack;
+	};
+} 
+#endif //BINEQUATIONWRITER_H
\ No newline at end of file

ASCOfficeDocxFile2/BinWriter/BinReaderWriterDefines.h

@@ -422,7 +422,8 @@ extern int g_nCurFormatVersion;
 		fldstart = 9,
 		fldend = 10,
 		CommentReference = 11,
-		pptxDrawing = 12
+		pptxDrawing = 12,
+		object = 13
 	};}
 	namespace c_oSerImageType{enum c_oSerImageType
 	{

ASCOfficeDocxFile2/BinWriter/BinWriters.h

@@ -6,6 +6,8 @@
 #include "../../Common/Base64.h"
 #include "../../ASCOfficePPTXFile/Editor/FontCutter.h"
 #include "../../XlsxSerializerCom/Reader/BinaryWriter.h"
+#include "../../Common/DocxFormat/Source/MathEquation/MathEquation.h"
+#include "BinEquationWriter.h"
 
 namespace BinDocxRW
 {
@@ -4614,6 +4616,29 @@ namespace BinDocxRW
 						WriteComment(OOX::et_w_commentReference, pCommentReference->m_oId);
 						break;
 					}
+				/*case OOX::et_w_object:
+					{
+						int nCurPos = m_oBcw.WriteItemStart(c_oSerRunType::object);
+
+						OOX::Logic::CObject* pObject = static_cast<OOX::Logic::CObject*>(item);
+
+						OOX::Rels::CRelationShip* oRels = NULL;
+						smart_ptr<OOX::File> pFile = m_oParamsDocumentWriter.m_pRels->Find( OOX::RId(pObject->m_oOleObject->m_oId.get().GetValue()));
+
+						CString sLink;
+						if (pFile.IsInit() && OOX::FileTypes::OleObject == pFile->type())
+						{
+							OOX::HyperLink* pHyperlinkFile = static_cast<OOX::HyperLink*>(pFile.operator ->());
+							sLink = pHyperlinkFile->Uri().GetPath();
+						}
+						MathEquation::BinaryEquationWriter oBinEqWriter(m_oBcw.m_oStream);
+
+						MathEquation::CEquationReader oReader(sLink);
+						oReader.SetOutputDev(&oBinEqWriter);
+						oReader.Parse();
+						m_oBcw.WriteItemEnd(nCurPos);
+						break;
+					}*/
 				}
 			}
 		}

Common/DocxFormat/Projects/DocxFormat2005.vcproj

@@ -1409,6 +1409,34 @@
 				>
 			</File>
 		</Filter>
+		<Filter
+			Name="Equation"
+			>
+			<File
+				RelativePath="..\Source\MathEquation\LEStream.h"
+				>
+			</File>
+			<File
+				RelativePath="..\Source\MathEquation\MathEquation.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\Source\MathEquation\MathEquation.h"
+				>
+			</File>
+			<File
+				RelativePath="..\Source\MathEquation\OutputDev.h"
+				>
+			</File>
+			<File
+				RelativePath="..\Source\MathEquation\String.h"
+				>
+			</File>
+			<File
+				RelativePath="..\Source\MathEquation\Types.h"
+				>
+			</File>
+		</Filter>
 		<File
 			RelativePath="..\Source\SystemUtility\FileSystem\Directory.cpp"
 			>