DocumentServer-v-9.2.0/core/OOXML/Binary/Document/BinWriter/BinEquationWriter.cpp

/*
 * (c) Copyright Ascensio System SIA 2010-2023
 *
 * This program is a free software product. You can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License (AGPL)
 * version 3 as published by the Free Software Foundation. In accordance with
 * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
 * that Ascensio System SIA expressly excludes the warranty of non-infringement
 * of any third-party rights.
 *
 * This program is distributed WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
 * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
 *
 * You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
 * street, Riga, Latvia, EU, LV-1050.
 *
 * The  interactive user interfaces in modified source and object code versions
 * of the Program must display Appropriate Legal Notices, as required under
 * Section 5 of the GNU AGPL version 3.
 *
 * Pursuant to Section 7(b) of the License you must retain the original Product
 * logo when distributing the program. Pursuant to Section 7(e) we decline to
 * grant you any rights under trademark law for use of our trademarks.
 *
 * All the Product's GUI elements, including illustrations and icon sets, as
 * well as technical writing content are licensed under the terms of the
 * Creative Commons Attribution-ShareAlike 4.0 International. See the License
 * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 */

#include "BinEquationWriter.h"
#include "../../Presentation/BinaryFileReaderWriter.h"
#include "../../../Common/SimpleTypes_OMath.h"

namespace MathEquation
{
	EquationRun::EquationRun()
	{
		bNormal = false;
	}
	void EquationRun::AddChar(std::wstring sChar, TMathFont* pNewFont, LONG lSize)
	{
		str = sChar;
		pFont = pNewFont;
		nTextSize = lSize;
		bAccent = false;
	}
	bool EquationRun::CompareFont(TMathFont* pNewFont)
	{
		if ( pNewFont->sName == pFont->sName && pNewFont->bBold == pFont->bBold && pNewFont->bItalic == pFont->bItalic )
			return true;
		else
			return false;
	}
	void EquationRun::SetAccent(bool bAcc, MEMBELTYPE type)
	{
		bAccent = bAcc;
		eType = type;
	}
	TMathFont* EquationRun::GetFont()
	{
		return pFont;
	}
	LONG EquationRun::GetSize()
	{
		return nTextSize;
	}

	RunManager::RunManager()
	{
		bAlligment = false;
	}
	void RunManager::SetAlligment(bool bPos)
	{
		bAlligment = bPos;
		return;
	}
	bool RunManager::GetAlligment()
	{
		return bAlligment;
	}
	void RunManager::Add(EquationRun oElem)
	{
		arrRun.push_back(oElem);
		return;
	}
	bool RunManager::IsEmpty()
	{
		return arrRun.empty();
	}
	LONG RunManager::GetSize()
	{
		return (LONG)arrRun.size();
	}
	bool RunManager::GetElem (LONG lPos, EquationRun &oRun)
	{
		if (lPos < (LONG)arrRun.size() )
		{
			oRun = arrRun[lPos];
			return true;
		}
		return false;
	}
	void RunManager::Clear()
	{
		arrRun.clear();
		return;
	}
	void RunManager::RemoveElem (LONG lPos)
	{
		arrRun.erase(arrRun.begin()+lPos);
		return;
	}
	void RunManager::Delete(LONG lStart, LONG lCount)
	{
		arrRun.erase(arrRun.begin()+lStart, arrRun.begin()+lCount);
		return;
	}
	void RunManager::AddAccent (MEMBELTYPE eType)
	{
		LONG lPos = GetSize() - 1;

		if (lPos < 0) return;

		EquationRun oRun;
		oRun = arrRun[lPos];
		RemoveElem(lPos);

		oRun.bAccent = true;
		oRun.eType = eType;
		Add(oRun);
	}

    BinaryEquationWriter::BinaryEquationWriter(NSBinPptxRW::CBinaryFileWriter *pStream) : bEmbel(false), m_pStream(pStream)
	{
	}
	void BinaryEquationWriter::WriteRPR(TMathFont* pFont, LONG nSize, bool bIsOpen)
	{
		if (NULL != pFont)
		{
			int nCurPos;
			//if (bIsOpen)
				nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::RPr);
			//else
			//	nCurPos = WriteItemStart(BinDocxRW::c_oSerRunType::rPr);

			std::wstring sFontName = L"Cambria Math";
			{
                m_pStream->WriteBYTE(BinDocxRW::c_oSerProp_rPrType::FontAscii);
                m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Variable);
                m_pStream->WriteStringW(sFontName);

                m_pStream->WriteBYTE(BinDocxRW::c_oSerProp_rPrType::FontHAnsi);
                m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Variable);
                m_pStream->WriteStringW(sFontName);

                m_pStream->WriteBYTE(BinDocxRW::c_oSerProp_rPrType::FontAE);
                m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Variable);
                m_pStream->WriteStringW(sFontName);
			}
			if (nTextSize)
			{
                m_pStream->WriteBYTE(BinDocxRW::c_oSerProp_rPrType::FontSize);
                m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Long);
                m_pStream->WriteLONG(nSize);

                /*m_pStream->WriteBYTE(BinDocxRW::c_oSerProp_rPrType::FontSizeCS);
                m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Long);
                m_pStream->WriteLONG(nSize);*/
			}
			WriteItemEnd(nCurPos);
		}
		return;
	}
	void BinaryEquationWriter::WriteMRPR(EquationRun oRun)
	{

		int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::MRPr);
		BYTE eStyle = SimpleTypes::stylePlain;
		if (oRun.pFont && (oRun.pFont->bBold || oRun.pFont->bItalic))
		{
			if (oRun.pFont->bBold)
			{
				if (oRun.pFont->bItalic)
					eStyle = SimpleTypes::styleBoldItalic;
				else
					eStyle = SimpleTypes::styleBold;
			}
			else if ( oRun.pFont->bItalic )
				eStyle = SimpleTypes::styleItalic;
		}
		WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::Sty, eStyle );

		if (oRun.bNormal)
			WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::Nor, oRun.bNormal);
		WriteItemEnd(nCurPos);
		return;
	}
	void BinaryEquationWriter::WriteRunContent(EquationRun oRun, bool bIsOpen)
	{
		TMathFont* pCurFont = oRun.pFont;
		int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::MRun);
		WriteRPR(oRun.pFont, oRun.nTextSize, bIsOpen);
		WriteMRPR(oRun);
		int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::MText);
        m_pStream->WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
        m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Variable);
        m_pStream->WriteStringW(oRun.str);
		WriteItemEnd(nCurPos1);
		WriteItemEnd(nCurPos);
	}
	void BinaryEquationWriter::CutRun(int nCount)
	{
		LONG lSize = oRManager.GetSize();
		if (nCount < lSize+1)
		{
			for (int i=0; i<nCount; i++)
				oRManager.Delete(0,1);
		}
	}
	void BinaryEquationWriter::WriteRun(bool bLast)
	{
		bool bIsOpen;
		if (!m_aCommandStack.empty())
			bIsOpen = m_aCommandStack.top()->IsOpenNode(); //if false write ctrlPrp
		else
			bIsOpen = true;

		std::wstring sText;
		LONG lSize = oRManager.GetSize();

		if (bLast)
			lSize--;
		if (lSize > 0)
		{
			for (int i=0; i<lSize; i++)
			{
				EquationRun oRun;
				bool bRes = oRManager.GetElem( i, oRun);
				if (bRes)
				{
					if (!oRun.bAccent)
					{
						WriteRunContent(oRun, bIsOpen);
					}
					else
					{
						if (embelPrime == oRun.eType || embelDPrime == oRun.eType || embelTPrime == oRun.eType)
						{
							int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SSup);
							int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SSupPr);
							std::wstring str;
							switch (oRun.eType)
							{
								case embelPrime:     str =  0x2032; break;
								case embelDPrime:    str =  0x2033; break;
								case embelTPrime:    str =  0x2034; break;
							}
							WriteItemEnd(nCurPos1);

							nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Sup);
							EquationRun oSupRun;
							oSupRun.AddChar(str, oRun.GetFont(), oRun.GetSize());
							WriteRunContent(oSupRun, bIsOpen);
							WriteItemEnd(nCurPos1);

							nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
							WriteRunContent(oRun, bIsOpen);
							WriteItemEnd(nCurPos1);
							WriteItemEnd(nCurPos);
						}
						else if (embelLPrime == oRun.eType)
						{
							int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SPre);
							int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SPrePr);
							std::wstring str;
							str =  0x0060;
							WriteItemEnd(nCurPos1);

							nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Sup);
							EquationRun oSupRun;
							oSupRun.AddChar(str, oRun.GetFont(), oRun.GetSize());
							WriteRunContent(oSupRun, bIsOpen);
							WriteItemEnd(nCurPos1);

							nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
							WriteRunContent(oRun, bIsOpen);
							WriteItemEnd(nCurPos1);
							WriteItemEnd(nCurPos);
						}
						else
						{
							int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Acc);
							int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::AccPr);
							std::wstring str;
							switch (oRun.eType)
							{
								case embelDot:       str =  0x0307; break;
								case embelDDot:      str =  0x0308; break;
								case embelDDDot:     str =  0x20DB; break;
								case embelTilde:     str =  0x0303; break;
								case embelHat:       str =  0x0302; break;
								case embelSlash:     str =  0x002F; break;
								case embelLArrow:    str =  0x20D6; break;
								case embelRArrow:    str =  0x20D7; break;
								case embelDArrow:    str =  0x20E1; break;
								case embelLHarpoon:  str =  0x20D0; break;
								case embelRHarpoon:  str =  0x20D1; break;
								case embelStrikeout: str =  0x0336; break;
								case embelBar:       str =  0x0305; break;
								case embelFrown:     str =  0x0311; break;
								case embelSmile:     str =  0x0306; break;
							}
							WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
							WriteItemEnd(nCurPos1);

							int nCurPos2 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);

							WriteRunContent(oRun, bIsOpen);

							WriteItemEnd(nCurPos2);
							WriteItemEnd(nCurPos);
						}
					}
				}
			}
			oRManager.Delete(0,lSize);
		}
		oRManager.SetAlligment(false);
		return;
	}
	int BinaryEquationWriter::WriteItemStart(BYTE type)
	{
		//type
        m_pStream->WriteBYTE(type);
		return WriteItemWithLengthStart();
	}
	void BinaryEquationWriter::WriteItemEnd(int nStart)
	{
		WriteItemWithLengthEnd(nStart);
	}
	int BinaryEquationWriter::WriteItemWithLengthStart()
	{
		//Запоминаем позицию чтобы в конце записать туда длину
        int nStartPos = m_pStream->GetPosition();
        m_pStream->Skip(4);
		return nStartPos;
	}
	void BinaryEquationWriter::WriteItemWithLengthEnd(int nStart)
	{
		//Length
        int nEnd = m_pStream->GetPosition();
        m_pStream->SetPosition(nStart);
        m_pStream->WriteLONG(nEnd - nStart - 4);
        m_pStream->SetPosition(nEnd);
	}
	void BinaryEquationWriter::BeginEquation()
	{
		int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::OMath);
		m_aEquationStack.push(nCurPos);
	}
	void BinaryEquationWriter::EndEquation()
	{
		if (!oRManager.IsEmpty())
			WriteRun();

		if (!m_aEquationStack.empty())
		{
			int nCurPos = m_aEquationStack.top();
			WriteItemEnd(nCurPos);
			m_aEquationStack.pop();
		}
	}
	void BinaryEquationWriter::BeginBlock()
	{
		if (!m_aCommandStack.empty())
		{
			CBaseCommand* pCommand = TopCommand();
			pCommand->Next();
			pCommand->WriteBeginBlock(this);
		}
	}
	void BinaryEquationWriter::EndBlock()
	{
		if (!m_aCommandStack.empty())
		{
			CBaseCommand* pCommand = TopCommand();
			pCommand->WriteEndBlock(this);
		}
	}
	void BinaryEquationWriter::SetSize(uint16_t nSize)
	{
		nTextSize = nSize*2;
	}
	void BinaryEquationWriter::BeginChar(unsigned short uChar, unsigned char nTypeFace, bool bSpecialSymbol)
	{
		bool bIsOpen;
		if (!m_aCommandStack.empty())
			bIsOpen = m_aCommandStack.top()->IsOpenNode(); //if false write ctrlPrp
		else
			bIsOpen = true;

		TMathFont* pFont = GetFont(nTypeFace);
		if (!pFont && !bIsOpen)
			return;

		EquationRun oRun;
		if (uChar)
		{
			std::wstring str;
			if (bSpecialSymbol)
			{
				switch(uChar)
				{
					case specialsymAlignment:
					{
						str = 0x200A;
						if (oRManager.GetAlligment())
							oRun.bNormal = true;
						else
							oRManager.SetAlligment(true);
					}
					break;
					case specialsymZeroSpace:  str = 0x200B; break;
					case specialsymThinSpace:  str = 0x2009; break;
					case specialsymThickSpace: str = 0x2005; break;
					case specialsymLargeSpace: str = 0x2003; break;
					case specialsymOnePtSpace: str = 0x200A; break;
				}
			}
			else
			{
				if (uChar == 0x0026)
				{
					if (oRManager.GetAlligment())
						oRun.bNormal = true;
					else
						oRManager.SetAlligment(true);
				}
				else if (uChar == 0x03C6)
					uChar = 0x03D5;
				else if (uChar == 0x03D5)
					uChar = 0x03C6;
				str =  uChar;
			}

			oRun.AddChar(str, pFont, nTextSize);
			oRManager.Add(oRun);
		}
	}
	void BinaryEquationWriter::AddCharEmbel(MEMBELTYPE eType)
	{
		oRManager.AddAccent(eType);
	}
	void BinaryEquationWriter::EndChar()
	{
		/*if (!m_aRunStack.empty())
		{
			int nCurPos = m_aRunStack.top();
			WriteItemEnd(nCurPos);
			m_aRunStack.pop();

			if (bEmbel)
			{
				int nCurPos;
				if (!m_aAccentStack.empty())
				{
					nCurPos = m_aAccentStack.top();
					m_aAccentStack.pop();
					WriteItemEnd(nCurPos);
				}
				if (!m_aAccentStack.empty())
				{
					nCurPos = m_aAccentStack.top();
					m_aAccentStack.pop();
					WriteItemEnd(nCurPos);
				}
				bEmbel = false;
			}
		}*/
	}
	void BinaryEquationWriter::BeginMatrix(unsigned char nVAlign, MMATRIXHORALIGN eHorAlign, MMATRIXVERALIGN eVerAlign, bool bEqualRows, bool bEqualCols, unsigned char nRows, unsigned char nCols, unsigned char* pVerBorders, unsigned char* pHorBorders)
	{
		if (!oRManager.IsEmpty())
			WriteRun();

		CMatrixCommand* pCommand = (CMatrixCommand*)PushCommand(commandMatrix);
		pCommand->SetProps(nRows, nCols);

		int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Matrix);
		m_aMatrixStack.push(nCurPos);
		int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::MPr);
		WriteItemValLong(BinDocxRW::c_oSer_OMathBottomNodesType::Row, nRows);

		int nCurPos2 = WriteItemStart(BinDocxRW::c_oSer_OMathBottomNodesType::Mcs);
		int nCurPos3 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Mc);
		int nCurPos4 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::McPr);

		WriteItemValLong(BinDocxRW::c_oSer_OMathBottomNodesType::Count, nCols);

		BYTE horAlign;
		switch(eHorAlign)
		{
			case matrixhoralignLeft:		horAlign = SimpleTypes::xalignLeft;		break;
			case matrixhoralignCenter:		horAlign = SimpleTypes::xalignCenter;	break;
			case matrixhoralignRight:		horAlign = SimpleTypes::xalignRight;	break;
			case matrixhoralignEqualSign:	horAlign = SimpleTypes::xalignCenter;	break;
			case matrixhoralignCommaSign:	horAlign = SimpleTypes::xalignCenter;	break;
		}
		WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::McJc, horAlign);

		WriteItemEnd(nCurPos4);
		WriteItemEnd(nCurPos3);
		WriteItemEnd(nCurPos2);
		WriteItemEnd(nCurPos1);

	}
	void BinaryEquationWriter::EndMatrix()
	{
		PopCommand();

		if (!m_aMatrixStack.empty())
		{
			int nCurPos = m_aMatrixStack.top();
			WriteItemEnd(nCurPos);
			m_aMatrixStack.pop();
		}
	}
	void BinaryEquationWriter::StartPile(unsigned char nHAlign, unsigned char nVAlign)
	{
		switch (nHAlign)
		{
		case 1:
		case 4: nHAlignPile = SimpleTypes::xalignLeft; break;
		case 2: nHAlignPile = SimpleTypes::xalignCenter; break;
		case 3:
		case 5: nHAlignPile = SimpleTypes::xalignRight; break;
		default: nHAlignPile = SimpleTypes::xalignLeft; break;
		}

		if (m_aCommandStack.empty())
		{
			PushCommand(commandEqArray);
		}
		m_aCommandStack.top()->SetPile(true, nHAlignPile);
	}
	void BinaryEquationWriter::EndPile()
	{
		if (!m_aCommandStack.empty())
		{
			m_aCommandStack.top()->SetPile(false, SimpleTypes::xalignLeft);
			CBaseCommand* pCommand = TopCommand();
			pCommand->WriteEndBlock(this);

			int nRows = 0;
			if (!m_aRowsCounter.empty())
			{
				nRows = m_aRowsCounter.top();
				m_aRowsCounter.pop();
			}
			int nPos = -1;
			if (!m_aRowsPosCounter.empty())
			{
				nPos = m_aRowsPosCounter.top();
				m_aRowsPosCounter.pop();
			}
            int nEnd = m_pStream->GetPosition();
			if (nPos >= 0)
			{
                m_pStream->SetPosition(nPos);
                m_pStream->WriteLONG(nRows);
			}
            m_pStream->SetPosition(nEnd);

			ECommandType type;
			type = pCommand->GetCommand();
			if (type == commandIntegral || type == commandNArray)
				pCommand->Next();
		}
		nHAlignPile = SimpleTypes::xalignLeft;
	}
	void BinaryEquationWriter::BeginBrackets(MBRACKETSTYPE eType, bool bOpen, bool bClose)
	{
		if (!oRManager.IsEmpty())
			WriteRun();

		PushCommand(commandBrackets);

		int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Delimiter);
		m_aDelimiterStack.push(nCurPos);
		int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::DelimiterPr);

		int nCurPos2 = WriteItemStart(BinDocxRW::c_oSer_OMathBottomNodesType::Column);

        m_pStream->WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
        m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Long);

        int nStartPos = m_pStream->GetPosition();
        m_pStream->Skip(4);
		m_aDelimiterCounter.push(nStartPos);

		WriteItemEnd(nCurPos2);

		if (!bOpen)
			WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::BegChr, _T(""));
		else
		{
			std::wstring strOpen;
			switch(eType)
			{
				case bracketsAngle:				strOpen =  0x27E8; break;
				case bracketsRound:				strOpen =  0x0028; break;
				case bracketsCurve:				strOpen =  0x007B; break;
				case bracketsSquare:			strOpen =  0x005B; break;
				case bracketsLine:				strOpen =  0x007C; break;
				case bracketsDLine:				strOpen =  0x2016; break;
				case bracketsFloor:				strOpen =  0x230A; break;
				case bracketsCeil:				strOpen =  0x2308; break;
				case bracketsSquareOpenOpen:	strOpen =  0x005B; break;
				case bracketsSquareCloseClose:	strOpen =  0x005D; break;
				case bracketsSquareCloseOpen:	strOpen =  0x005D; break;
				case bracketsSquareRound:		strOpen =  0x005B; break;
				case bracketsRoundSquare:		strOpen =  0x0028; break;
			}
			WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::BegChr, strOpen);
		}

		if (!bClose)
			WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::EndChr, _T(""));
		else
		{
			std::wstring strEnd;
			switch(eType)
			{
				case bracketsAngle:				strEnd =  0x27E9; break;
				case bracketsRound:				strEnd =  0x0029; break;
				case bracketsCurve:				strEnd =  0x007D; break;
				case bracketsSquare:			strEnd =  0x005D; break;
				case bracketsLine:				strEnd =  0x007C; break;
				case bracketsDLine:				strEnd =  0x2016; break;
				case bracketsFloor:				strEnd =  0x230B; break;
				case bracketsCeil:				strEnd =  0x2309; break;
				case bracketsSquareOpenOpen:	strEnd =  0x005B; break;
				case bracketsSquareCloseClose:	strEnd =  0x005D; break;
				case bracketsSquareCloseOpen:	strEnd =  0x005B; break;
				case bracketsSquareRound:		strEnd =  0x0029; break;
				case bracketsRoundSquare:		strEnd =  0x005D; break;
			}
			WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::EndChr, strEnd);
		}

		WriteItemEnd(nCurPos1);
	}
	void BinaryEquationWriter::EndBrackets  (MBRACKETSTYPE eType, bool bOpen, bool bClose)
	{
		if (!m_aDelimiterCounter.empty())
		{
			int nCount = m_aCommandStack.top()->GetCount();
			int nPos = m_aDelimiterCounter.top();
            int nEnd = m_pStream->GetPosition();
            m_pStream->SetPosition(nPos);
            m_pStream->WriteLONG(nCount);
            m_pStream->SetPosition(nEnd);
			m_aDelimiterCounter.pop();
		}

		PopCommand();
		if (!m_aDelimiterStack.empty())
		{
			int nCurPos = m_aDelimiterStack.top();
			WriteItemEnd(nCurPos);
			m_aDelimiterStack.pop();
		}
	}
	void BinaryEquationWriter::BeginRoot(bool bDegree)
	{
		if (!oRManager.IsEmpty())
			WriteRun();

		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);
	}
	void BinaryEquationWriter::EndRoot  ()
	{
		PopCommand();

		if (!m_aRadicalStack.empty())
		{
			int nCurPos = m_aRadicalStack.top();
			WriteItemEnd(nCurPos);
			m_aRadicalStack.pop();
		}
	}
	void BinaryEquationWriter::BeginFraction(MFRACTIONTYPES eType, bool bInline)
	{
		if (!oRManager.IsEmpty())
			WriteRun();

		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);
	}
	void BinaryEquationWriter::EndFraction  ()
	{
		PopCommand();

		if (!m_aFractionStack.empty())
		{
			int nCurPos = m_aFractionStack.top();
			WriteItemEnd(nCurPos);
			m_aFractionStack.pop();
		}
	}
	void BinaryEquationWriter::BeginScript(MSCRIPTALIGN eAlign, bool bBase, bool bSup, bool bSub, bool bInline)
	{
		bool bSaveLastRun = false;
		if (!bBase && !oRManager.IsEmpty())
			bSaveLastRun = true;

		WriteRun(bSaveLastRun);

		CScriptCommand* pCommand = (CScriptCommand*)PushCommand(commandScript);
		pCommand->SetProps(bInline, bBase, bSup, bSub);

		int nCurPos;
		int nCurPos1;
		switch(eAlign)
		{
			case scriptalignRight:
			case scriptalignCenter:
			case scriptalignLeft:
				if (bSub)
				{
					if (bSup)
					{
						nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SSubSup);
						nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SSubSupPr);
					}
					else
					{
						nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SSub);
						nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SSubPr);
					}
				}
				else if (bSup)
				{
					nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SSup);
					nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SSupPr);
				}
				break;
			/*case scriptalignLeft: можно сделать так, но выглядеть будет плохо
			{
				nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SPre);
				nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::SPrePr);
			}
			break;*/
		}
		if (bInline)
			WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::AlnScr, true);
		WriteItemEnd(nCurPos1);
		m_aScriptStack.push(nCurPos);

		if (!bBase && !oRManager.IsEmpty())
		{
			int nCurPos2 = nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
			WriteRun();
			WriteItemEnd(nCurPos2);
		}
	}
	void BinaryEquationWriter::EndScript  ()
	{
		PopCommand();

		if (!m_aScriptStack.empty())
		{
			int nCurPos = m_aScriptStack.top();
			WriteItemEnd(nCurPos);
			m_aScriptStack.pop();
		}
	}
	void BinaryEquationWriter::BeginBar(MBARTYPE eType, bool bTop)
	{
		if (!oRManager.IsEmpty())
			WriteRun();

		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);

		std::wstring str;
		switch(eType)
		{
			case bartypeLine:			str = 0x0305;break;
			case bartypeDoubleLine:		str = 0x033F;break;
			case bartypeArrowLeft:		str = 0x20D6;break;
			case bartypeArrowRight:		str = 0x20D7;break;
			case bartypeArrowDouble:	str = 0x20E1;break;
		}
		WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);

		WriteItemEnd(nCurPos1);

	}
	void BinaryEquationWriter::EndBar  ()
	{
		PopCommand();

		if (!m_aGroupChrStack.empty())
		{
			int nCurPos = m_aGroupChrStack.top();
			WriteItemEnd(nCurPos);
			m_aGroupChrStack.pop();
		}
	}
	void BinaryEquationWriter::BeginArrow(MARROWTYPE eType, bool bTop)
	{
		if (!oRManager.IsEmpty())
			WriteRun();

		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);

		std::wstring str;
		switch(eType)
		{
			case arrowtypeLeft:			str = 0x2190;break;
			case arrowtypeRight:		str = 0x2192;break;
			case arrowtypeDouble:		str = 0x2194;break;
		}
		WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);

		WriteItemEnd(nCurPos1);
	}
	void BinaryEquationWriter::EndArrow  ()
	{
		PopCommand();

		if (!m_aGroupChrStack.empty())
		{
			int nCurPos = m_aGroupChrStack.top();
			WriteItemEnd(nCurPos);
			m_aGroupChrStack.pop();
		}
	}
	void BinaryEquationWriter::BeginIntegral(MINTEGRALTYPE eType)
	{
		if (!oRManager.IsEmpty())
			WriteRun();

		PushCommand(commandIntegral);

		int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Nary);
		m_aNArrayStack.push(nCurPos);
		int lCount = 0;

		int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::NaryPr);
		std::wstring str;
		switch(eType)
		{
		//todooo проверить запись .. (BYTE)SimpleTypes::ххх
			case integraltypeSingle:
				str = 0x222B;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
				lCount = 1;
				break;
			case integraltypeSingleRSub:
				str = 0x222B;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 1;
				break;
			case integraltypeSingleRSubSup:
				str = 0x222B;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				lCount = 1;
				break;
			case integraltypeSingleOriented:
				str = 0x222E;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
				lCount = 1;
				break;
			case integraltypeSingleOrientedRSub:
				str = 0x222E;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 1;
				break;

			case integraltypeDouble:
				str = 0x222C;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
				lCount = 2;
				break;
			case integraltypeDoubleRSub:
				str = 0x222C;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 2;
				break;
			case integraltypeDoubleOriented:
				str = 0x222F;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
				lCount = 2;
				break;
			case integraltypeDoubleOrientedRSub:
				str = 0x222F;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 2;
				break;

			case integraltypeTriple:
				str = 0x222D;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
				lCount = 3;
				break;
			case integraltypeTripleRSub:
				str = 0x222D;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 3;
				break;
			case integraltypeTripleOriented:
				str = 0x2230;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
				lCount = 3;
				break;
			case integraltypeTripleOrientedRSub:
				str = 0x2230;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 3;
				break;

			case integraltypeSingleCSubSup:
				str = 0x222B;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				lCount = 1;
				break;
			case integraltypeSingleCSub:
				str = 0x222B;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 1;
				break;
			case integraltypeSingleOrientedCSub:
				str = 0x222E;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 1;
				break;

			case integraltypeDoubleOrientedCSub:
				str = 0x222F;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 2;
				break;
			case integraltypeDoubleCSub:
				str = 0x222C;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 2;
				break;

			case integraltypeTripleOrientedCSub:
				str = 0x2230;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 3;
				break;
			case integraltypeTripleCSub:
				str = 0x222D;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				lCount = 3;
				break;
		}
		m_aNArrayCutStack.push(lCount);


		WriteItemEnd(nCurPos1);
	}
	void BinaryEquationWriter::EndIntegral  ()
	{
		PopCommand();

		if (!m_aNArrayCutStack.empty())
		{
			int lCount = m_aNArrayCutStack.top();
			if (!oRManager.IsEmpty())
				CutRun(lCount);
			m_aNArrayCutStack.pop();
		}

		if (!m_aNArrayStack.empty())
		{
			int nCurPos = m_aNArrayStack.top();
			WriteItemEnd(nCurPos);
			m_aNArrayStack.pop();
		}
	}
	void BinaryEquationWriter::BeginVerticalBrace(bool bTop)
	{
		if (!oRManager.IsEmpty())
			WriteRun();

		BYTE pos, vertJc;
		std::wstring chr;
		if (bTop)
		{
			chr = 0x23DE;
			vertJc = SimpleTypes::verticaljcTop;
			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 = 0x23DF;
			vertJc = SimpleTypes::verticaljcBottom;
			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);
		m_aLimitStack.push(nCurPos2);
		int nCurPos3 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::GroupChr);
		m_aLimitStack.push(nCurPos3);

		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);

		PushCommand(commandVerticalBrace);

	}
	void BinaryEquationWriter::EndVerticalBrace  ()
	{
		PopCommand();

		if (!m_aLimitStack.empty())
		{
			int nCurPos = m_aLimitStack.top();
			WriteItemEnd(nCurPos);
			m_aLimitStack.pop();
		}
	}
	void BinaryEquationWriter::BeingNArray(MNARRAYTYPE eType)
	{
		if (!oRManager.IsEmpty())
			WriteRun();

		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);
		std::wstring str;
		switch(eType)
		{
			case narySumCSub:
				str = 0x2211;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				break;
			case narySumCSubSup:
				str = 0x2211;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				break;
			case narySum:
				str = 0x2211;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
				break;
			case narySumRSub:
				str = 0x2211;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				break;
			case narySumRSubSup:
				str = 0x2211;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				break;

			case naryProdCSub:
				str = 0x220F;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				break;
			case naryProdCSubSup:
				str = 0x220F;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				break;
			case naryProd:
				str = 0x220F;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
				break;
			case naryProdRSub:
				str = 0x220F;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				break;
			case naryProdRSubSup:
				str = 0x220F;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				break;

			case naryCoProdCSub:
				str = 0x2210;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				break;
			case naryCoProdCSubSup:
				str = 0x2210;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				break;
			case naryCoProd:
				str = 0x2210;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
				break;
			case naryCoProdRSub:
				str = 0x2210;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				break;
			case naryCoProdRSubSup:
				str = 0x2210;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				break;

			case naryUnionCSub:
				str = 0x22C3;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				break;
			case naryUnionCSubSup:
				str = 0x22C3;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				break;
			case naryUnion:
				str = 0x22C3;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
				break;
			case naryUnionRSub:
				str = 0x22C3;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				break;
			case naryUnionRSubSup:
				str = 0x22C3;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				break;

			case naryIntersectCSub:
				str = 0x22C2;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				break;
			case naryIntersectCSubSup:
				str = 0x22C2;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				break;
			case naryIntersect:
				str = 0x22C2;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocUndOvr);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SubHide, true);
				break;
			case naryIntersectRSub:
				str = 0x22C2;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::SupHide, true);
				break;
			case naryIntersectRSubSup:
				str = 0x22C2;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::Chr, str);
				WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::LimLoc, (BYTE)SimpleTypes::limLocSubSup);
				break;

		}
		m_aNArrayCutStack.push(1);

		WriteItemEnd(nCurPos1);
	}
	void BinaryEquationWriter::EndNArray  ()
	{
		CNArrayCommand* pCommand = (CNArrayCommand*)TopCommand();
		MNARRAYTYPE eType = pCommand->GetType();
		PopCommand();

		if (!m_aNArrayCutStack.empty())
		{
			int lCount = m_aNArrayCutStack.top();
			if (!oRManager.IsEmpty())
				CutRun(lCount);
			m_aNArrayCutStack.pop();
		}

		if (!m_aNArrayStack.empty())
		{
			int nCurPos = m_aNArrayStack.top();
			WriteItemEnd(nCurPos);
			m_aNArrayStack.pop();
		}
	}
	void BinaryEquationWriter::BeginLongDivision(MLONGDIVISION eType)
	{
		if (!oRManager.IsEmpty())
			WriteRun();
		if (eType == longdivisionWithResult)
		{
			PushCommand(commandLongDivision);

			int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Fraction);
			m_aFractionStack.push(nCurPos);

			int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::FPr);
			BYTE fType = SimpleTypes::fTypeBar;
			WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::Type, fType);

			WriteItemEnd(nCurPos1);
		}
		else if (eType == longdivisionRegular)
		{
			BeginBrackets(bracketsLine, true, false);
		}
	}
	void BinaryEquationWriter::EndLongDivision  ()
	{

		ECommandType eType;
		CBaseCommand* pCommand = TopCommand();
		eType = pCommand->GetCommand();
		if (eType == commandLongDivision)
		{
			EndFraction();
		}
		else if (eType == commandBrackets)
		{
			MBRACKETSTYPE ebType = MBRACKETSTYPE::bracketsAngle; //???
			EndBrackets(ebType, false, false);
		}
	}
	void BinaryEquationWriter::BeginAngleBracketsWithSeparator(MANGLEBRACKETSWITHSEPARATORTYPE eType)
	{
		if (!oRManager.IsEmpty())
			WriteRun();

		CBracketsWithSeparatorCommand* pCommand = (CBracketsWithSeparatorCommand*)PushCommand(commandBracketsSep);
		pCommand->SetType(eType);

		int nCurPos = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Delimiter);
		m_aDelimiterStack.push(nCurPos);

		int nCurPos1 = WriteItemStart(BinDocxRW::c_oSer_OMathContentType::DelimiterPr);
		std::wstring beg, sep, end;
		switch (eType)
		{
			case angbrwithsepBoth:	// < | >
				beg = 0x27E8; sep =  0x007C; end =  0x27E9;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::BegChr, beg);
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::SepChr, sep);
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::EndChr, end);
				WriteItemValLong(BinDocxRW::c_oSer_OMathBottomNodesType::Column, 2);
				break;
			case angbrwithsepLeft:	// < |
				beg = 0x27E8; end =  0x007C;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::BegChr, beg);
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::EndChr, end);
				WriteItemValLong(BinDocxRW::c_oSer_OMathBottomNodesType::Column, 1);
				break;
			case angbrwithsepRight:	// | >
				beg = 0x007C; end =  0x27E9;
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::BegChr, beg);
				WriteItemValStr(BinDocxRW::c_oSer_OMathBottomNodesType::EndChr, end);
				WriteItemValLong(BinDocxRW::c_oSer_OMathBottomNodesType::Column, 1);
				break;
		}
		WriteItemEnd(nCurPos1);

	}
	void BinaryEquationWriter::EndAngleBracketsWithSeparator  ()
	{
		PopCommand();

		if (!m_aDelimiterStack.empty())
		{
			int nCurPos = m_aDelimiterStack.top();
			WriteItemEnd(nCurPos);
			m_aDelimiterStack.pop();
		}
	}
	void BinaryEquationWriter::AddFont(unsigned char nTypeFace, std::string sName, bool bBold, bool bItalic)
	{
		TMathFont aFont;
		aFont.sName   = sName;
		aFont.bBold   = bBold;
		aFont.bItalic = bItalic;
		m_mFonts[nTypeFace] = aFont;
	}
	void BinaryEquationWriter::WriteItemVal(BYTE name, BYTE val)
	{
		int nCurPos = WriteItemStart(name);

        m_pStream->WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
        m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Byte);
        m_pStream->WriteBYTE(val);

		WriteItemEnd(nCurPos);
	}
	void BinaryEquationWriter::WriteItemValLong(BYTE name, LONG val)
	{
		int nCurPos = WriteItemStart(name);

        m_pStream->WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
        m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Long);
        m_pStream->WriteLONG(val);

		WriteItemEnd(nCurPos);
	}
	void BinaryEquationWriter::WriteItemVal(BYTE name, bool val)
	{
		int nCurPos = WriteItemStart(name);

        m_pStream->WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
        m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Byte);
        m_pStream->WriteBOOL(val);

		WriteItemEnd(nCurPos);
	}
	void BinaryEquationWriter::WriteItemValStr(BYTE name, std::wstring val)
	{
		int nCurPos = WriteItemStart(name);

        m_pStream->WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
        m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Variable);
        m_pStream->WriteStringW(val);

		WriteItemEnd(nCurPos);
	}

	BinaryEquationWriter::CBaseCommand::CBaseCommand() : nBlockNum(-1), bPile(false), bEqArrayStart(false), nCount(0), nHAlignPile(2)
	{
	}
	BinaryEquationWriter::CBaseCommand::~CBaseCommand()
	{
	}
	void BinaryEquationWriter::CBaseCommand::Next()
	{
		bool bCurPile;
		bCurPile = GetPile();
		if (!bCurPile || (nBlockNum == -1))
			nBlockNum++;
	}
	bool BinaryEquationWriter::CBaseCommand::IsOpenNode()
	{
		return bOpenNode;
	}
	int BinaryEquationWriter::CBaseCommand::GetCount()
	{
		return nCount;
	}
	void BinaryEquationWriter::CBaseCommand::SetPile(bool bSetPile, BYTE nHPile)
	{
		nHAlignPile = nHPile;
		bPile = bSetPile;
		bEqArrayStart = !bSetPile;
	}
	bool BinaryEquationWriter::CBaseCommand::GetPile()
	{
		return bPile;
	}
	int BinaryEquationWriter::CBaseCommand::GetBlockNum()
	{
		return nBlockNum;
	}
	void BinaryEquationWriter::CBaseCommand::WriteBeginNode(BinaryEquationWriter* pWriter, BYTE elem)
	{
		int nElemPos;
		if (bEqArrayStart)
		{
			nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
			nRows++;
		}
		else
		{
			nElemPos = pWriter->WriteItemStart(elem);
			nCount++;
		}
		m_aBaseStack.push(nElemPos);

		if (bPile && !bEqArrayStart)
		{
			bEqArrayStart = true;
			nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::EqArr);
			m_aBaseStack.push(nElemPos);


			nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::EqArrPr);

			pWriter->WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::McJc, nHAlignPile);

			int nCurPos1 = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathBottomNodesType::Row);
            pWriter->m_pStream->WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
            pWriter->m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Long);
			pWriter->m_aRowsPosCounter.push( pWriter->WriteItemWithLengthStart());
			pWriter->WriteItemEnd(nCurPos1);



			pWriter->WriteItemEnd(nElemPos);

			nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
			nRows = 1;
			m_aBaseStack.push(nElemPos);
		}
	}
	void BinaryEquationWriter::CBaseCommand::WriteBeginNode(BinaryEquationWriter* pWriter)
	{
		int nElemPos;
		if (bEqArrayStart)
		{
			nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
			nRows++;
			m_aBaseStack.push(nElemPos);
		}
		if (bPile && !bEqArrayStart)
		{
			bEqArrayStart = true;
			nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::EqArr);
			m_aBaseStack.push(nElemPos);


			nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::EqArrPr);

			pWriter->WriteItemVal(BinDocxRW::c_oSer_OMathBottomNodesType::McJc, nHAlignPile);

			int nCurPos1 = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathBottomNodesType::Row);
            pWriter->m_pStream->WriteBYTE(BinDocxRW::c_oSer_OMathBottomNodesValType::Val);
            pWriter->m_pStream->WriteBYTE(BinDocxRW::c_oSerPropLenType::Long);
			pWriter->m_aRowsPosCounter.push(pWriter->WriteItemWithLengthStart());
			pWriter->WriteItemEnd(nCurPos1);



			pWriter->WriteItemEnd(nElemPos);

			nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
			nRows = 1;
			m_aBaseStack.push(nElemPos);
		}
	}
	void BinaryEquationWriter::CBaseCommand::WriteEndNode(BinaryEquationWriter* pWriter)
			{
				int nCurPos = -1;
				if (!m_aBaseStack.empty())
				{
					nCurPos = m_aBaseStack.top();
					m_aBaseStack.pop();
				}
				if (!pWriter->oRManager.IsEmpty())
				{
					pWriter->WriteRun();
				}

				if (bPile && bEqArrayStart)
				{
					if (nCurPos > 0)
						pWriter->WriteItemEnd(nCurPos);
				}
				else if (!bPile && !bEqArrayStart)
				{
					if (nCurPos > 0)
						pWriter->WriteItemEnd(nCurPos);
				}
				else if (!bPile && bEqArrayStart)
				{
					pWriter->m_aRowsCounter.push(nRows);
					bEqArrayStart = false;

					if (nCurPos > 0)
						pWriter->WriteItemEnd(nCurPos);//eqArr

					if (!m_aBaseStack.empty())
					{
						nCurPos = m_aBaseStack.top();
						m_aBaseStack.pop();
						pWriter->WriteItemEnd(nCurPos);
					}
				}
			}

	BinaryEquationWriter::CMatrixCommand::CMatrixCommand() : nRows(0), nCols(0) {}
	BinaryEquationWriter::CMatrixCommand::~CMatrixCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CMatrixCommand::GetCommand()
	{
		return commandMatrix;
	}
	void BinaryEquationWriter::CMatrixCommand::SetProps(int nRows, int nCols)
	{
		this->nRows = nRows;
		this->nCols = nCols;
	}
	void BinaryEquationWriter::CMatrixCommand::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);
	}
	void BinaryEquationWriter::CMatrixCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
			{
				int nCurRow = nBlockNum / nCols;
				int nCurCol = nBlockNum % nCols;

				if (!pWriter->oRManager.IsEmpty())
				{
					pWriter->WriteRun();
				}
				pWriter->WriteItemEnd(nColPos);

				if (nCols - 1 == nCurCol)
					pWriter->WriteItemEnd(nRowPos);
			}

	BinaryEquationWriter::CBracketsCommand::CBracketsCommand() {}
	BinaryEquationWriter::CBracketsCommand::~CBracketsCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CBracketsCommand::GetCommand(){return commandBrackets;}
	void BinaryEquationWriter::CBracketsCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CBracketsCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CBracketsCommand::Write(BinaryEquationWriter* pWriter, bool bBeginNode)
			{
				bOpenNode = bBeginNode;
				if (0 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
					else
						WriteEndNode(pWriter);
				}
			}

	BinaryEquationWriter::CRootCommand::CRootCommand() {}
	BinaryEquationWriter::CRootCommand::~CRootCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CRootCommand::GetCommand(){return commandRoot;}
	void BinaryEquationWriter::CRootCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CRootCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CRootCommand::Write(BinaryEquationWriter* pWriter, bool bBeginNode)
			{
				bOpenNode = bBeginNode;
				if (0 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
					else
						WriteEndNode(pWriter);
				}
				else if (1 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Deg);
					else
						WriteEndNode(pWriter);
				}
			}

	BinaryEquationWriter::CFractionCommand::CFractionCommand() {}
	BinaryEquationWriter::CFractionCommand::~CFractionCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CFractionCommand::GetCommand(){return commandFraction;}
	void BinaryEquationWriter::CFractionCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CFractionCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CFractionCommand::Write(BinaryEquationWriter* pWriter, bool bBeginNode)
			{
				bOpenNode = bBeginNode;
				if (0 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Num);
					else
						WriteEndNode(pWriter);
				}
				else if (1 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Den);
					else
						WriteEndNode(pWriter);
				}
			}

	BinaryEquationWriter::CScriptCommand::CScriptCommand() {}
	BinaryEquationWriter::CScriptCommand::~CScriptCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CScriptCommand::GetCommand(){return commandScript;}
	void BinaryEquationWriter::CScriptCommand::SetProps(bool bInline, bool bBase, bool bSup, bool bSub)
	{
		this->bBase   = bBase;
		this->bInline = bInline;
		this->bSub    = bSub;
		this->bSup    = bSup;
	}
	void BinaryEquationWriter::CScriptCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CScriptCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CScriptCommand::Write(BinaryEquationWriter* pWriter, bool bBegin)
			{
				bOpenNode = bBegin;
				if (bInline)
				{
					if (0 == nBlockNum)
					{
						if (bBase)
						{
							if (bBegin)
								WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
							else
								WriteEndNode(pWriter);
						}
						else if (bSub)
						{
							if (bBegin)
								WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sub);
							else
								WriteEndNode(pWriter);
						}
						else if (bSup)
						{
							if (bBegin)
								WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sup);
							else
								WriteEndNode(pWriter);
						}
					}
					else if (1 == nBlockNum)
					{
						if (bBase)
						{
							if (bSub)
							{
								if (bBegin)
									WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sub);
								else
									WriteEndNode(pWriter);
							}
							else if (bSup)
							{
								if (bBegin)
									WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sup);
								else
									WriteEndNode(pWriter);
							}
						}
						else if (bSub && bSup)
						{
							if (bBegin)
								WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sup);
							else
								WriteEndNode(pWriter);
						}
					}
					else if (2 == nBlockNum)
					{
						if (bSup)
						{
							if (bBegin)
								WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sup);
							else
								WriteEndNode(pWriter);
						}
					}
				}
				else
				{
					if (0 == nBlockNum) //sSubSup
					{
						if (bSub)
						{
							if (bBegin)
								WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sub);
							else
								WriteEndNode(pWriter);
						}
						else if (bSup)
						{
							if (bBegin)
								WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sup);
							else
								WriteEndNode(pWriter);
						}
						else if (bBase)
						{
							if (bBegin)
								WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
							else
								WriteEndNode(pWriter);
						}
					}
					else if (1 == nBlockNum)
					{
						if (bSub)
						{
							if (bSup)
							{
								if (bBegin)
									WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sup);
								else
									WriteEndNode(pWriter);
							}
							else if (bBase)
							{
								if (bBegin)
									WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
								else
									WriteEndNode(pWriter);
							}
						}
						else if (bSup && bBase)
						{
							if (bBegin)
								WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
							else
								WriteEndNode(pWriter);
						}
					}
					else if (2 == nBlockNum)
					{
						if (bBase && bSub && bSup)
						{
							if (bBegin)
								WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
							else
								WriteEndNode(pWriter);
						}
					}
				}
			}

	BinaryEquationWriter::CBarCommand::CBarCommand() {}
	BinaryEquationWriter::CBarCommand::~CBarCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CBarCommand::GetCommand(){return commandBar;}
	void BinaryEquationWriter::CBarCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CBarCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CBarCommand::Write(BinaryEquationWriter* pWriter, bool bBeginNode)
			{
				bOpenNode = bBeginNode;
				if (bBeginNode)
					WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
				else
					WriteEndNode(pWriter);
			}

	BinaryEquationWriter::CArrowCommand::CArrowCommand() {}
	BinaryEquationWriter::CArrowCommand::~CArrowCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CArrowCommand::GetCommand(){return commandArrow;}
	void BinaryEquationWriter::CArrowCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		nElemPos = pWriter->WriteItemStart(BinDocxRW::c_oSer_OMathContentType::Element);
	}
	void BinaryEquationWriter::CArrowCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		pWriter->WriteItemEnd(nElemPos);
	}

	BinaryEquationWriter::CEqArrayCommand::CEqArrayCommand() {}
	BinaryEquationWriter::CEqArrayCommand::~CEqArrayCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CEqArrayCommand::GetCommand(){ return commandEqArray; }
	void BinaryEquationWriter::CEqArrayCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CEqArrayCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CEqArrayCommand::Write(BinaryEquationWriter* pWriter, bool bBeginNode)
			{
				bOpenNode = bBeginNode;
				if (bBeginNode)
					WriteBeginNode(pWriter);
				else
					WriteEndNode(pWriter);
			}

	BinaryEquationWriter::CIntegralCommand::CIntegralCommand() {}
	BinaryEquationWriter::CIntegralCommand::~CIntegralCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CIntegralCommand::GetCommand(){return commandIntegral;}
	void BinaryEquationWriter::CIntegralCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CIntegralCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CIntegralCommand::Write(BinaryEquationWriter* pWriter, bool bBeginNode)
			{
				bOpenNode = bBeginNode;
				if (0 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
					else
						WriteEndNode(pWriter);
				}
				else if (1 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sub);
					else
						WriteEndNode(pWriter);
				}
				else if (2 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sup);
					else
						WriteEndNode(pWriter);
				}
			}

	BinaryEquationWriter::CVerticalBraceCommand::CVerticalBraceCommand() {}
	BinaryEquationWriter::CVerticalBraceCommand::~CVerticalBraceCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CVerticalBraceCommand::GetCommand(){return commandVerticalBrace;}
	void BinaryEquationWriter::CVerticalBraceCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CVerticalBraceCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CVerticalBraceCommand::Write(BinaryEquationWriter* pWriter, bool bBeginNode)
			{
				bOpenNode = bBeginNode;
				if (0 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
					else
					{
						WriteEndNode(pWriter);

						if (!bPile)
						{
							pWriter->PopCommand();

							int nCurPos = pWriter->m_aLimitStack.top();
							pWriter->WriteItemEnd(nCurPos); //groupChr
							pWriter->m_aLimitStack.pop();

							nCurPos = pWriter->m_aLimitStack.top();
							pWriter->WriteItemEnd(nCurPos); //lim element
							pWriter->m_aLimitStack.pop();

							pWriter->PushCommand(commandVerticalBraceLim);
							CBaseCommand* pCommand = pWriter->TopCommand();
							pCommand->WriteBeginBlock(pWriter);
						}
					}
				}
			}

	BinaryEquationWriter::CVerticalBraceLimCommand::CVerticalBraceLimCommand() {}
	BinaryEquationWriter::CVerticalBraceLimCommand::~CVerticalBraceLimCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CVerticalBraceLimCommand::GetCommand(){return commandVerticalBraceLim;}
	void BinaryEquationWriter::CVerticalBraceLimCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CVerticalBraceLimCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CVerticalBraceLimCommand::Write(BinaryEquationWriter* pWriter, bool bBeginNode)
			{
				bOpenNode = bBeginNode;
				if (0 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Lim);
					else
						WriteEndNode(pWriter);
				}
			}

	BinaryEquationWriter::CNArrayCommand::CNArrayCommand() {}
	BinaryEquationWriter::CNArrayCommand::~CNArrayCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CNArrayCommand::GetCommand(){return commandNArray;}
	void BinaryEquationWriter::CNArrayCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CNArrayCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CNArrayCommand::SetType(MNARRAYTYPE eType)
	{
		this->eType = eType;
	}
	MNARRAYTYPE BinaryEquationWriter::CNArrayCommand::GetType()
	{
		return eType;
	}
	void BinaryEquationWriter::CNArrayCommand::Write(BinaryEquationWriter* pWriter, bool bBeginNode)
			{
				bOpenNode = bBeginNode;
				if (0 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
					else
						WriteEndNode(pWriter);
				}
				else if (1 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sub);
					else
						WriteEndNode(pWriter);
				}
				else if (2 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Sup);
					else
						WriteEndNode(pWriter);
				}
			}

	BinaryEquationWriter::CLongDivisionCommand::CLongDivisionCommand() {}
	BinaryEquationWriter::CLongDivisionCommand::~CLongDivisionCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CLongDivisionCommand::GetCommand(){ return commandLongDivision; }
	void BinaryEquationWriter::CLongDivisionCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CLongDivisionCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CLongDivisionCommand::Write(BinaryEquationWriter* pWriter, bool bBeginNode)
			{
				bOpenNode = bBeginNode;
				if (1 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Num);
					else
						WriteEndNode(pWriter);
				}
				else if (0 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Den);
					else
						WriteEndNode(pWriter);
				}
			}

	BinaryEquationWriter::CBracketsWithSeparatorCommand::CBracketsWithSeparatorCommand() {}
	BinaryEquationWriter::CBracketsWithSeparatorCommand::~CBracketsWithSeparatorCommand() {}
	BinaryEquationWriter::ECommandType BinaryEquationWriter::CBracketsWithSeparatorCommand::GetCommand(){return commandBracketsSep;}
	void BinaryEquationWriter::CBracketsWithSeparatorCommand::SetType(MANGLEBRACKETSWITHSEPARATORTYPE eType)
	{
		this->eType = eType;
	}
	void BinaryEquationWriter::CBracketsWithSeparatorCommand::WriteBeginBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, true);
	}
	void BinaryEquationWriter::CBracketsWithSeparatorCommand::WriteEndBlock(BinaryEquationWriter* pWriter)
	{
		Write(pWriter, false);
	}
	void BinaryEquationWriter::CBracketsWithSeparatorCommand::Write(BinaryEquationWriter* pWriter, bool bBeginNode)
			{
				bOpenNode = bBeginNode;
				if (0 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
					else
						WriteEndNode(pWriter);
				}
				else if (1 == nBlockNum)
				{
					if (bBeginNode)
						WriteBeginNode(pWriter, BinDocxRW::c_oSer_OMathContentType::Element);
					else
						WriteEndNode(pWriter);
				}
			}

	BinaryEquationWriter::CBaseCommand* BinaryEquationWriter::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 commandVerticalBraceLim:	pCommand = new CVerticalBraceLimCommand(); break;
		case commandNArray:				pCommand = new CNArrayCommand(); break;
		case commandLongDivision:		pCommand = new CLongDivisionCommand(); break;
		case commandBracketsSep:		pCommand = new CBracketsWithSeparatorCommand(); break;
		case commandEqArray:			pCommand = new CEqArrayCommand(); break;
		}

		m_aCommandStack.push(pCommand);

		return pCommand;
	}
	void BinaryEquationWriter::PopCommand()
	{
		CBaseCommand* pCommand = m_aCommandStack.top();
		if (pCommand)
			delete pCommand;

		m_aCommandStack.pop();
	}
	BinaryEquationWriter::CBaseCommand* BinaryEquationWriter::TopCommand()
	{
		return m_aCommandStack.top();
	}
}