/* * (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 "oMathContent.h" namespace OOX { namespace Logic { //-------------------------------------------------------------------------------- // CCtrlPr 22.1.2.23 (Control Properties) //-------------------------------------------------------------------------------- CCtrlPr::CCtrlPr(OOX::Document *pMain) : WritingElement(pMain) { } CCtrlPr::~CCtrlPr() { } EElementType CCtrlPr::getType() const { return et_m_ctrlPr; } //-------------------------------------------------------------------------------- // CAccPr 22.1.2.2 (Accent Properties) //-------------------------------------------------------------------------------- CAccPr::CAccPr(OOX::Document *pMain) : WritingElement(pMain) { } CAccPr::~CAccPr() { } void CAccPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:chr") == sName ) m_oChr = new OOX::Logic::CChr( oItem ); else if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } } } } } void CAccPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:chr") == sName ) m_oChr = oReader; else if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; } } EElementType CAccPr::getType() const { return et_m_accPr; } //-------------------------------------------------------------------------------- // CAcc 22.1.2.1 (Accent) //-------------------------------------------------------------------------------- CAcc::CAcc(OOX::Document *pMain) : WritingElement(pMain) { } CAcc::~CAcc() { } void CAcc::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { XmlUtils::CXmlNode oItem; for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:accPr") == sName ) { m_oAccPr = new OOX::Logic::CAccPr(); *m_oAccPr = oItem; } else if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } } } } } void CAcc::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:accPr") == sName ) m_oAccPr = oReader; else if ( _T("m:e") == sName ) m_oElement = oReader; } } EElementType CAcc::getType() const { return et_m_acc; } //-------------------------------------------------------------------------------- // CArgPr 22.1.2.5 (Argument Properties) //-------------------------------------------------------------------------------- CArgPr::CArgPr(OOX::Document *pMain) : WritingElement(pMain) { } CArgPr::~CArgPr() { } void CArgPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { XmlUtils::CXmlNode oItem; for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:argSz") == sName ) m_oArgSz = new OOX::Logic::CArgSz( oItem ); } } } } void CArgPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:argSz") == sName ) m_oArgSz = oReader; } } std::wstring CArgPr::toXML() const { std::wstring sResult = _T(""); if ( m_oArgSz.IsInit() ) sResult += m_oArgSz->toXML(); sResult += _T(""); return sResult; } EElementType CArgPr::getType() const { return et_m_argPr; } //-------------------------------------------------------------------------------- // CBarPr 22.1.2.8 (Bar Properties) //-------------------------------------------------------------------------------- CBarPr::CBarPr(OOX::Document *pMain) : WritingElement(pMain) { } CBarPr::~CBarPr() { } void CBarPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } else if ( _T("m:pos") == sName ) m_oPos = new OOX::Logic::CPos( oItem ); } } } } void CBarPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; else if ( _T("m:pos") == sName ) m_oPos = oReader; } } EElementType CBarPr::getType() const { return et_m_barPr; } //-------------------------------------------------------------------------------- // CBar 22.1.2.7 (Bar) //-------------------------------------------------------------------------------- CBar::CBar(OOX::Document *pMain) : WritingElement(pMain) { } CBar::~CBar() { } void CBar::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { XmlUtils::CXmlNode oItem; for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:barPr") == sName ) { m_oBarPr = new OOX::Logic::CBarPr(); *m_oBarPr = oItem; } else if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } } } } } void CBar::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:barPr") == sName ) m_oBarPr = oReader; else if ( _T("m:e") == sName ) m_oElement = oReader; } } EElementType CBar::getType() const { return et_m_bar; } //-------------------------------------------------------------------------------- // CBorderBoxPr 22.1.2.12 (Border-Box Properties) //-------------------------------------------------------------------------------- CBorderBoxPr::CBorderBoxPr(OOX::Document *pMain) : WritingElement(pMain) { } CBorderBoxPr::~CBorderBoxPr() { } void CBorderBoxPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } else if ( _T("m:hideBot") == sName ) m_oHideBot = new OOX::Logic::CHideBot( oItem ); else if ( _T("m:hideLeft") == sName ) m_oHideLeft = new OOX::Logic::CHideLeft( oItem ); else if ( _T("m:hideRight") == sName ) m_oHideRight = new OOX::Logic::CHideRight( oItem ); else if ( _T("m:hideTop") == sName ) m_oHideTop = new OOX::Logic::CHideTop( oItem ); else if ( _T("m:strikeBLTR") == sName ) m_oStrikeBLTR = new OOX::Logic::CStrikeBLTR( oItem ); else if ( _T("m:strikeH") == sName ) m_oStrikeH = new OOX::Logic::CStrikeH( oItem ); else if ( _T("m:strikeTLBR") == sName ) m_oStrikeTLBR = new OOX::Logic::CStrikeTLBR( oItem ); else if ( _T("m:strikeV") == sName ) m_oStrikeV = new OOX::Logic::CStrikeV( oItem ); } } } } void CBorderBoxPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; else if ( _T("m:hideBot") == sName ) m_oHideBot = oReader; else if ( _T("m:hideLeft") == sName ) m_oHideLeft = oReader; else if ( _T("m:hideRight") == sName ) m_oHideRight = oReader; else if ( _T("m:hideTop") == sName ) m_oHideTop = oReader; else if ( _T("m:strikeBLTR") == sName ) m_oStrikeBLTR = oReader; else if ( _T("m:strikeH") == sName ) m_oStrikeH = oReader; else if ( _T("m:strikeTLBR") == sName ) m_oStrikeTLBR = oReader; else if ( _T("m:strikeV") == sName ) m_oStrikeV = oReader; } } EElementType CBorderBoxPr::getType() const { return et_m_borderBoxPr; } //-------------------------------------------------------------------------------- // CBorderBox 22.1.2.11 (Border-Box Object) //-------------------------------------------------------------------------------- CBorderBox::CBorderBox(OOX::Document *pMain) : WritingElement(pMain) { } CBorderBox::~CBorderBox() { } void CBorderBox::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:borderBoxPr") == sName ) { m_oBorderBoxPr = new OOX::Logic::CBorderBoxPr(); *m_oBorderBoxPr = oItem; } else if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } } } } } void CBorderBox::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:borderBoxPr") == sName ) m_oBorderBoxPr = oReader; else if ( _T("m:e") == sName ) m_oElement = oReader; } } EElementType CBorderBox::getType() const { return et_m_borderBox; } //-------------------------------------------------------------------------------- // CBrk 22.1.2.15 (Break) //-------------------------------------------------------------------------------- CBrk::CBrk(OOX::Document *pMain) : WritingElement(pMain) { } CBrk::~CBrk() { } void CBrk::fromXML(XmlUtils::CXmlNode& oNode) { XmlMacroReadAttributeBase( oNode, _T("m:alnAt"), m_alnAt ); } void CBrk::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes( oReader ); if ( !oReader.IsEmptyNode() ) oReader.ReadTillEnd(); } std::wstring CBrk::toXML() const { std::wstring sResult = _T("ToString(); sResult += _T("\" />"); return sResult; } EElementType CBrk::getType() const { return et_m_brk; } void CBrk::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_Start( oReader ) WritingElement_ReadAttributes_ReadSingle( oReader, _T("m:alnAt"), m_alnAt ) WritingElement_ReadAttributes_End( oReader ) } //-------------------------------------------------------------------------------- // CBoxPr 22.1.2.14 (Box Properties) //-------------------------------------------------------------------------------- CBoxPr::CBoxPr(OOX::Document *pMain) : WritingElement(pMain) { } CBoxPr::~CBoxPr() { } void CBoxPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:aln") == sName ) m_oAln = new OOX::Logic::CAln( oItem ); else if ( _T("m:brk") == sName ) { m_oBrk = new OOX::Logic::CBrk(); *m_oBrk = oItem; } else if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } else if ( _T("m:diff") == sName ) m_oDiff = new OOX::Logic::CDiff( oItem ); else if ( _T("m:noBreak") == sName ) m_oNoBreak = new OOX::Logic::CNoBreak( oItem ); else if ( _T("m:opEmu") == sName ) m_oOpEmu = new OOX::Logic::COpEmu( oItem ); } } } } void CBoxPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:aln") == sName ) m_oAln = oReader; else if ( _T("m:brk") == sName ) m_oBrk = oReader; else if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; else if ( _T("m:diff") == sName ) m_oDiff = oReader; else if ( _T("m:noBreak") == sName ) m_oNoBreak = oReader; else if ( _T("m:opEmu") == sName ) m_oOpEmu = oReader; } } EElementType CBoxPr::getType() const { return et_m_boxPr; } //-------------------------------------------------------------------------------- // CBox 22.1.2.13 (Box Object) //-------------------------------------------------------------------------------- CBox::CBox(OOX::Document *pMain) : WritingElement(pMain) { } CBox::~CBox() { } void CBox::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:boxPr") == sName ) { m_oBoxPr = new OOX::Logic::CBoxPr(); *m_oBoxPr = oItem; } else if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } } } } } void CBox::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:boxPr") == sName ) m_oBoxPr = oReader; else if ( _T("m:e") == sName ) m_oElement = oReader; } } EElementType CBox::getType() const { return et_m_box; } //-------------------------------------------------------------------------------- // CDelimiterPr 22.1.2.31 (Delimiter Properties) //-------------------------------------------------------------------------------- CDelimiterPr::CDelimiterPr(OOX::Document *pMain) : WritingElement(pMain) { } CDelimiterPr::~CDelimiterPr() { } void CDelimiterPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:begChr") == sName ) m_oBegChr = new OOX::Logic::CBegChr( oItem ); else if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } else if ( _T("m:endChr") == sName ) m_oEndChr = new OOX::Logic::CEndChr( oItem ); else if ( _T("m:grow") == sName ) m_oGrow = new OOX::Logic::CGrow( oItem ); else if ( _T("m:sepChr") == sName ) m_oSepChr = new OOX::Logic::CSepChr( oItem ); else if ( _T("m:shp") == sName ) m_oShp = new OOX::Logic::CShp( oItem ); } } } } void CDelimiterPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:begChr") == sName ) m_oBegChr = oReader; else if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; else if ( _T("m:endChr") == sName ) m_oEndChr = oReader; else if ( _T("m:grow") == sName ) m_oGrow = oReader; else if ( _T("m:sepChr") == sName ) m_oSepChr = oReader; else if ( _T("m:shp") == sName ) m_oShp = oReader; } } std::wstring CDelimiterPr::toXML() const { std::wstring sResult = _T(""); if ( m_oBegChr.IsInit() ) sResult += m_oBegChr->toXML(); if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); if ( m_oEndChr.IsInit() ) sResult += m_oEndChr->toXML(); if ( m_oGrow.IsInit() ) sResult += m_oGrow->toXML(); if ( m_oSepChr.IsInit() ) sResult += m_oSepChr->toXML(); if ( m_oShp.IsInit() ) sResult += m_oShp->toXML(); sResult += _T(""); return sResult; } EElementType CDelimiterPr::getType() const { return et_m_dPr; } //-------------------------------------------------------------------------------- // CDelimiter 22.1.2.24 (Delimiter Object) //-------------------------------------------------------------------------------- CDelimiter::CDelimiter(OOX::Document *pMain) : WritingElementWithChilds<>(pMain) { m_lColumn = 0; } CDelimiter::~CDelimiter() { } EElementType CDelimiter::getType() const { return et_m_d; } //-------------------------------------------------------------------------------- // CEqArrPr 22.1.2.35 (Array Object) //-------------------------------------------------------------------------------- CEqArrPr::CEqArrPr(OOX::Document *pMain) : WritingElement(pMain) { } CEqArrPr::~CEqArrPr() { } void CEqArrPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:baseJc") == sName ) m_oBaseJc = new OOX::Logic::CBaseJc( oItem ); else if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } else if ( _T("m:maxDist") == sName ) m_oMaxDist = new OOX::Logic::CMaxDist( oItem ); else if ( _T("m:objDist") == sName ) m_oObjDist = new OOX::Logic::CObjDist( oItem ); else if ( _T("m:rSp") == sName ) m_oRSp = new OOX::Logic::CRSp( oItem ); else if ( _T("m:rSpRule") == sName ) m_oRSpRule = new OOX::Logic::CRSpRule( oItem ); } } } } void CEqArrPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:baseJc") == sName ) m_oBaseJc = oReader; else if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; else if ( _T("m:maxDist") == sName ) m_oMaxDist = oReader; else if ( _T("m:objDist") == sName ) m_oObjDist = oReader; else if ( _T("m:rSp") == sName ) m_oRSp = oReader; else if ( _T("m:rSpRule") == sName ) m_oRSpRule = oReader; } } EElementType CEqArrPr::getType() const { return et_m_eqArrPr; } //-------------------------------------------------------------------------------- // CEqArr 22.1.2.34 (Array Object) //-------------------------------------------------------------------------------- CEqArr::CEqArr(OOX::Document *pMain) : WritingElementWithChilds<>(pMain) { m_lRow = 0; } CEqArr::~CEqArr() { } void CEqArr::fromXML(XmlUtils::CXmlNode& oNode) { m_lRow = 0; std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:eqArrPr") == sName ) AssignPtrXmlContent(pItem, CEqArrPr, oItem) else if ( _T("m:e") == sName ) AssignPtrXmlContent(pItem, CElement, oItem) if ( pItem ) m_arrItems.push_back( pItem ); } } } } void CEqArr::fromXML(XmlUtils::CXmlLiteReader& oReader) { m_lRow = 0; if ( oReader.IsEmptyNode() ) return; int nCurDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nCurDepth ) ) { std::wstring sName = oReader.GetName(); WritingElement *pItem = NULL; if ( _T("m:eqArrPr") == sName ) AssignPtrXmlContent(pItem, CEqArrPr, oReader) else if ( _T("m:e") == sName ) { AssignPtrXmlContent(pItem, CElement, oReader) m_lRow++; } if ( pItem ) m_arrItems.push_back( pItem ); } } std::wstring CEqArr::toXML() const { std::wstring sResult = _T(""); for ( size_t i = 0; i < m_arrItems.size(); ++i) { if ( m_arrItems[i] ) { sResult += m_arrItems[i]->toXML(); } } sResult += _T(""); return sResult; } EElementType CEqArr::getType() const { return et_m_eqArr; } //-------------------------------------------------------------------------------- // CFPr 22.1.2.38 (Fraction Properties) //-------------------------------------------------------------------------------- CFPr::CFPr(OOX::Document *pMain) : WritingElement(pMain) { } CFPr::~CFPr() { } void CFPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:type") == sName ) m_oType = new OOX::Logic::CType( oItem ); else if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } } } } } void CFPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; else if ( _T("m:type") == sName ) m_oType = oReader; } } std::wstring CFPr::toXML() const { std::wstring sResult = _T(""); if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); if ( m_oType.IsInit() ) sResult += m_oType->toXML(); sResult += _T(""); return sResult; } EElementType CFPr::getType() const { return et_m_fPr; } //-------------------------------------------------------------------------------- // CFraction 22.1.2.36 (Fraction Object) //-------------------------------------------------------------------------------- CFraction::CFraction(OOX::Document *pMain) : WritingElement(pMain) { } CFraction::~CFraction() { } void CFraction::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:den") == sName ) { m_oDen = new OOX::Logic::CDen(); *m_oDen = oItem; } else if ( _T("m:fPr") == sName ) { m_oFPr = new OOX::Logic::CFPr(); *m_oFPr = oItem; } else if ( _T("m:num") == sName ) { m_oNum = new OOX::Logic::CNum(); *m_oNum = oItem; } } } } } void CFraction::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:den") == sName ) m_oDen = oReader; else if ( _T("m:fPr") == sName ) m_oFPr = oReader; else if ( _T("m:num") == sName ) m_oNum = oReader; } } EElementType CFraction::getType() const { return et_m_f; } //-------------------------------------------------------------------------------- // CFuncPr 22.1.2.40 (Function Properties) //-------------------------------------------------------------------------------- CFuncPr::CFuncPr(OOX::Document *pMain) : WritingElement(pMain) { } CFuncPr::~CFuncPr() { } void CFuncPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { XmlUtils::CXmlNode oItem; for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } } } } } void CFuncPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; } } std::wstring CFuncPr::toXML() const { std::wstring sResult = _T(""); if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); sResult += _T(""); return sResult; } EElementType CFuncPr::getType() const { return et_m_funcPr; } //-------------------------------------------------------------------------------- // CFunc 22.1.2.39 (Function Apply Object) //-------------------------------------------------------------------------------- CFunc::CFunc(OOX::Document *pMain) : WritingElement(pMain) { } CFunc::~CFunc() { } void CFunc::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } else if ( _T("m:fName") == sName ) { m_oFName = new OOX::Logic::CFName(); *m_oFName = oItem; } else if ( _T("m:funcPr") == sName ) { m_oFuncPr = new OOX::Logic::CFuncPr(); *m_oFuncPr = oItem; } } } } } void CFunc::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:e") == sName ) m_oElement = oReader; else if ( _T("m:fName") == sName ) m_oFName = oReader; else if ( _T("m:funcPr") == sName ) m_oFuncPr = oReader; } } EElementType CFunc::getType() const { return et_m_func; } //-------------------------------------------------------------------------------- // CGroupChrPr 22.1.2.42 (Group-Character Properties ) //-------------------------------------------------------------------------------- CGroupChrPr::CGroupChrPr(OOX::Document *pMain) : WritingElement(pMain) { } CGroupChrPr::~CGroupChrPr() { } void CGroupChrPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { XmlUtils::CXmlNode oItem; for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:chr") == sName ) m_oChr = new OOX::Logic::CChr( oItem ); else if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } else if ( _T("m:pos") == sName ) m_oPos = new OOX::Logic::CPos( oItem ); else if ( _T("m:vertJc") == sName ) m_oVertJc = new OOX::Logic::CVertJc( oItem ); } } } } void CGroupChrPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:chr") == sName ) m_oChr = oReader; else if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; else if ( _T("m:pos") == sName ) m_oPos = oReader; else if ( _T("m:vertJc") == sName ) m_oVertJc = oReader; } } std::wstring CGroupChrPr::toXML() const { std::wstring sResult = _T(""); if ( m_oChr.IsInit() ) sResult += m_oChr->toXML(); if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); if ( m_oPos.IsInit() ) sResult += m_oPos->toXML(); if ( m_oVertJc.IsInit() ) sResult += m_oVertJc->toXML(); sResult += _T(""); return sResult; } EElementType CGroupChrPr::getType() const { return et_m_groupChrPr; } //-------------------------------------------------------------------------------- // CGroupChr 22.1.2.41 (Group-Character Object) //-------------------------------------------------------------------------------- CGroupChr::CGroupChr(OOX::Document *pMain) : WritingElement(pMain) { } CGroupChr::~CGroupChr() { } void CGroupChr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } else if ( _T("m:groupChrPr") == sName ) { m_oGroupChrPr = new OOX::Logic::CGroupChrPr(); *m_oGroupChrPr = oItem; } } } } } void CGroupChr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:e") == sName ) m_oElement = oReader; else if ( _T("m:groupChrPr") == sName ) m_oGroupChrPr = oReader; } } EElementType CGroupChr::getType() const { return et_m_groupChr; } //-------------------------------------------------------------------------------- // CLimLowPr 22.1.2.55 (Lower-Limit Properties) //-------------------------------------------------------------------------------- CLimLowPr::CLimLowPr(OOX::Document *pMain) : WritingElement(pMain) { } CLimLowPr::~CLimLowPr() { } void CLimLowPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } } } } } void CLimLowPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; } } std::wstring CLimLowPr::toXML() const { std::wstring sResult = _T(""); if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); sResult += _T(""); return sResult; } EElementType CLimLowPr::getType() const { return et_m_limLowPr; } //-------------------------------------------------------------------------------- // CLimLow 22.1.2.54 (Lower-Limit Object) //-------------------------------------------------------------------------------- CLimLow::CLimLow(OOX::Document *pMain) : WritingElement(pMain) { } CLimLow::~CLimLow() { } void CLimLow::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } else if ( _T("m:lim") == sName ) { m_oLim = new OOX::Logic::CLim(); *m_oLim = oItem; } else if ( _T("m:limLowPr") == sName ) { m_oLimLowPr = new OOX::Logic::CLimLowPr(); *m_oLimLowPr = oItem; } } } } } void CLimLow::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:e") == sName ) m_oElement = oReader; else if ( _T("m:lim") == sName ) m_oLim = oReader; else if ( _T("m:limLowPr") == sName ) m_oLimLowPr = oReader; } } EElementType CLimLow::getType() const { return et_m_limLow; } //-------------------------------------------------------------------------------- // CLimUppPr 22.1.2.57 (Upper-Limit Properties) //-------------------------------------------------------------------------------- CLimUppPr::CLimUppPr(OOX::Document *pMain) : WritingElement(pMain) { } CLimUppPr::~CLimUppPr() { } void CLimUppPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } } } } } void CLimUppPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; } } std::wstring CLimUppPr::toXML() const { std::wstring sResult = _T(""); if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); sResult += _T(""); return sResult; } EElementType CLimUppPr::getType() const { return et_m_limUppPr; } //-------------------------------------------------------------------------------- // CLimUpp 22.1.2.56 (Upper-Limit Object) //-------------------------------------------------------------------------------- CLimUpp::CLimUpp(OOX::Document *pMain) : WritingElement(pMain) { } CLimUpp::~CLimUpp() { } EElementType CLimUpp::getType() const { return et_m_limUpp; } //-------------------------------------------------------------------------------- // CMathFont 22.1.2.61 (Math Font) //-------------------------------------------------------------------------------- CMathFont::CMathFont(OOX::Document *pMain) : WritingElement(pMain) { } CMathFont::~CMathFont() { } void CMathFont::fromXML(XmlUtils::CXmlNode& oNode) { XmlMacroReadAttributeBase( oNode, _T("m:val"), m_val ); } void CMathFont::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes( oReader ); if ( !oReader.IsEmptyNode() ) oReader.ReadTillEnd(); } std::wstring CMathFont::toXML() const { if (!m_val.IsInit()) return L""; std::wstring sResult = _T(""); return sResult; } EElementType CMathFont::getType() const { return et_m_mathFont; } void CMathFont::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_Start( oReader ) WritingElement_ReadAttributes_ReadSingle( oReader, _T("m:val"), m_val ) WritingElement_ReadAttributes_End( oReader ) } //-------------------------------------------------------------------------------- // CMathPr 22.1.2.62 (Math Properties) //-------------------------------------------------------------------------------- CMathPr::CMathPr(OOX::Document *pMain) : WritingElement(pMain) { } CMathPr::~CMathPr() { } EElementType CMathPr::getType() const { return et_m_mathPr; } //-------------------------------------------------------------------------------- // CMcPr 22.1.2.66 (Matrix Column Properties) //-------------------------------------------------------------------------------- CMcPr::CMcPr(OOX::Document *pMain) : WritingElement(pMain) { } CMcPr::~CMcPr() { } void CMcPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:count") == sName ) m_oCount = new OOX::Logic::CCount( oItem ); else if ( _T("m:mcJc") == sName ) m_oMcJc = new OOX::Logic::CMcJc( oItem ); } } } } void CMcPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:count") == sName ) m_oCount = oReader; else if ( _T("m:mcJc") == sName ) m_oMcJc = oReader; } } std::wstring CMcPr::toXML() const { std::wstring sResult = _T(""); if ( m_oCount.IsInit() ) sResult += m_oCount->toXML(); if ( m_oMcJc.IsInit() ) sResult += m_oMcJc->toXML(); sResult += _T(""); return sResult; } EElementType CMcPr::getType() const { return et_m_mcPr; } //-------------------------------------------------------------------------------- // CMc 22.1.2.64 (Matrix Column) //-------------------------------------------------------------------------------- CMc::CMc(OOX::Document *pMain) : WritingElement(pMain) { } CMc::~CMc() { } void CMc::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { XmlUtils::CXmlNode oItem; for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:mcPr") == sName ) { m_oMcPr = new OOX::Logic::CMcPr(); *m_oMcPr = oItem; } } } } } void CMc::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:mcPr") == sName ) m_oMcPr = oReader; } } EElementType CMc::getType() const { return et_m_mc; } //-------------------------------------------------------------------------------- // CMcs 22.1.2.67 (Matrix Columns) //-------------------------------------------------------------------------------- CMcs::CMcs(OOX::Document *pMain) : WritingElementWithChilds<>(pMain) { } CMcs::~CMcs() { } void CMcs::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:mc") == sName ) AssignPtrXmlContent(pItem, Logic::CMc, oItem) if ( pItem ) m_arrItems.push_back( pItem ); } } } } void CMcs::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nCurDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nCurDepth ) ) { std::wstring sName = oReader.GetName(); WritingElement *pItem = NULL; if ( _T("m:mc") == sName ) AssignPtrXmlContent(pItem, Logic::CMc, oReader) if ( pItem ) m_arrItems.push_back( pItem ); } } std::wstring CMcs::toXML() const { std::wstring sResult = _T(""); for ( size_t i = 0; i < m_arrItems.size(); ++i) { if ( m_arrItems[i] ) { sResult += m_arrItems[i]->toXML(); } } sResult += _T(""); return sResult; } EElementType CMcs::getType() const { return et_m_mcs; } //-------------------------------------------------------------------------------- // CMPr 22.1.2.68 (Matrix Properties) //-------------------------------------------------------------------------------- CMPr::CMPr(OOX::Document *pMain) : WritingElement(pMain) { } EElementType CMPr::getType() const { return et_m_mPr; } //-------------------------------------------------------------------------------- // CMr 22.1.2.69 (Matrix Row) //-------------------------------------------------------------------------------- CMr::CMr(OOX::Document *pMain) : WritingElementWithChilds<>(pMain) { m_lCol = 0; } CMr::~CMr() { } void CMr::fromXML(XmlUtils::CXmlNode& oNode) { m_lCol = 0; std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:e") == sName ) { AssignPtrXmlContent(pItem, Logic::CElement, oItem) m_lCol++; } if ( pItem ) m_arrItems.push_back( pItem ); } } } } void CMr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; m_lCol = 0; int nCurDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nCurDepth ) ) { std::wstring sName = oReader.GetName(); WritingElement *pItem = NULL; if ( _T("m:e") == sName ) { AssignPtrXmlContent(pItem, Logic::CElement, oReader) m_lCol++; } if ( pItem ) m_arrItems.push_back( pItem ); } } std::wstring CMr::toXML() const { std::wstring sResult = _T(""); for ( size_t i = 0; i < m_arrItems.size(); ++i) { if ( m_arrItems[i] ) { sResult += m_arrItems[i]->toXML(); } } sResult += _T(""); return sResult; } EElementType CMr::getType() const { return et_m_mr; } LONG CMr::GetCol() { return m_lCol; } //-------------------------------------------------------------------------------- // CMatrix 22.1.2.60 (Matrix Object) //-------------------------------------------------------------------------------- CMatrix::CMatrix(OOX::Document *pMain) : WritingElementWithChilds<>(pMain) { m_lRow = 0; } CMatrix::~CMatrix() { } void CMatrix::fromXML(XmlUtils::CXmlNode& oNode) { m_lRow = 0; std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:mPr") == sName ) AssignPtrXmlContent(pItem, CMPr, oItem) else if ( _T("m:mr") == sName ) { AssignPtrXmlContent(pItem, CMr, oItem) m_lRow++; } if (pItem) m_arrItems.push_back(pItem); } } } } void CMatrix::fromXML(XmlUtils::CXmlLiteReader& oReader) { m_lRow = 0; if ( oReader.IsEmptyNode() ) return; int nCurDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nCurDepth ) ) { std::wstring sName = oReader.GetName(); WritingElement *pItem = NULL; if ( _T("m:mPr") == sName ) AssignPtrXmlContent(pItem, CMPr, oReader) else if ( _T("m:mr") == sName ) { AssignPtrXmlContent(pItem, CMr, oReader) m_lRow++; } if ( pItem ) m_arrItems.push_back( pItem ); } } std::wstring CMatrix::toXML() const { std::wstring sResult = _T(""); for ( size_t i = 0; i < m_arrItems.size(); ++i) { if ( m_arrItems[i] ) { sResult += m_arrItems[i]->toXML(); } } sResult += _T(""); return sResult; } EElementType CMatrix::getType() const { return et_m_m; } //-------------------------------------------------------------------------------- // CNaryPr 22.1.2.72 (n-ary Properties) //-------------------------------------------------------------------------------- CNaryPr::CNaryPr(OOX::Document *pMain) : WritingElement(pMain) { } CNaryPr::~CNaryPr() { } EElementType CNaryPr::getType() const { return et_m_naryPr; } //-------------------------------------------------------------------------------- // CNary 22.1.2.70 (n-ary Operator Object) //-------------------------------------------------------------------------------- CNary::CNary(OOX::Document *pMain) : WritingElement(pMain) { } CNary::~CNary() { } void CNary::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } else if ( _T("m:naryPr") == sName ) { m_oNaryPr = new OOX::Logic::CNaryPr(); *m_oNaryPr = oItem; } else if ( _T("m:sub") == sName ) { m_oSub = new OOX::Logic::CSub(); *m_oSub = oItem; } else if ( _T("m:sup") == sName ) { m_oSup = new OOX::Logic::CSup(); *m_oSup = oItem; } } } } } void CNary::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:e") == sName ) m_oElement = oReader; else if ( _T("m:naryPr") == sName ) m_oNaryPr = oReader; else if ( _T("m:sub") == sName ) m_oSub = oReader; else if ( _T("m:sup") == sName ) m_oSup = oReader; } } EElementType CNary::getType() const { return et_m_nary; } //-------------------------------------------------------------------------------- // COMathParaPr 22.1.2.79 //-------------------------------------------------------------------------------- COMathParaPr::COMathParaPr(OOX::Document *pMain) : WritingElement(pMain) { } COMathParaPr::~COMathParaPr() { } void COMathParaPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:jc") == sName ) m_oMJc = new OOX::Logic::CMJc( oItem ); } } } } void COMathParaPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nCurDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nCurDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:jc") == sName ) m_oMJc = oReader; } } std::wstring COMathParaPr::toXML() const { std::wstring sResult = _T(""); if ( m_oMJc.IsInit() ) sResult += m_oMJc->toXML(); sResult += _T(""); return sResult; } EElementType COMathParaPr::getType() const { return et_m_oMathParaPr; } //-------------------------------------------------------------------------------- // CPhantPr 22.1.2.82 (Phantom Properties) //-------------------------------------------------------------------------------- CPhantPr::CPhantPr(OOX::Document *pMain) : WritingElement(pMain) { } CPhantPr::~CPhantPr() { } void CPhantPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } else if ( _T("m:show") == sName ) m_oShow = new OOX::Logic::CShow( oItem ); else if ( _T("m:transp") == sName ) m_oTransp = new OOX::Logic::CTransp( oItem ); else if ( _T("m:zeroAsc") == sName ) m_oZeroAsc = new OOX::Logic::CZeroAsc( oItem ); else if ( _T("m:zeroDesc") == sName ) m_oZeroDesc = new OOX::Logic::CZeroDesc( oItem ); else if ( _T("m:zeroWid") == sName ) m_oZeroWid = new OOX::Logic::CZeroWid( oItem ); } } } } void CPhantPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; else if ( _T("m:show") == sName ) m_oShow = oReader; else if ( _T("m:transp") == sName ) m_oTransp = oReader; else if ( _T("m:zeroAsc") == sName ) m_oZeroAsc = oReader; else if ( _T("m:zeroDesc") == sName ) m_oZeroDesc = oReader; else if ( _T("m:zeroWid") == sName ) m_oZeroWid = oReader; } } std::wstring CPhantPr::toXML() const { std::wstring sResult = _T(""); if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); if ( m_oShow.IsInit() ) sResult += m_oShow->toXML(); if ( m_oTransp.IsInit() ) sResult += m_oTransp->toXML(); if ( m_oZeroAsc.IsInit() ) sResult += m_oZeroAsc->toXML(); if ( m_oZeroDesc.IsInit() ) sResult += m_oZeroDesc->toXML(); if ( m_oZeroWid.IsInit() ) sResult += m_oZeroWid->toXML(); sResult += _T(""); return sResult; } EElementType CPhantPr::getType() const { return et_m_phantPr; } //-------------------------------------------------------------------------------- // CPhant 22.1.2.81 (Phantom Object) //-------------------------------------------------------------------------------- CPhant::CPhant(OOX::Document *pMain) : WritingElement(pMain) { } CPhant::~CPhant() { } void CPhant::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } else if ( _T("m:phantPr") == sName ) { m_oPhantPr = new OOX::Logic::CPhantPr(); *m_oPhantPr = oItem; } } } } } void CPhant::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:e") == sName ) m_oElement = oReader; else if ( _T("m:phantPr") == sName ) m_oPhantPr = oReader; } } EElementType CPhant::getType() const { return et_m_phant; } //-------------------------------------------------------------------------------- // CMText 22.1.2.116 (Math Text) //-------------------------------------------------------------------------------- CMText::CMText(OOX::Document *pMain) : WritingElement(pMain) { } CMText::~CMText() { } void CMText::fromXML(XmlUtils::CXmlNode& oNode) { XmlMacroReadAttributeBase( oNode, _T("xml:space"), m_oSpace ); m_sText = oNode.GetText(); } void CMText::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes( oReader ); if ( oReader.IsEmptyNode() ) return; m_sText = oReader.GetText2(); } std::wstring CMText::toXML() const { std::wstring sResult; if ( m_oSpace.IsInit() ) sResult = _T("ToString() + _T("\">"); else sResult = _T(""); sResult += XmlUtils::EncodeXmlString(m_sText); sResult += _T(""); return sResult; } EElementType CMText::getType() const { return et_m_t; } void CMText::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.GetAttributesCount() <= 0 ) return; if ( !oReader.MoveToFirstAttribute() ) return; std::wstring wsName = oReader.GetName(); while( !wsName.empty() ) { if ( _T("xml:space") == wsName ) { m_oSpace = oReader.GetText(); break; } if ( !oReader.MoveToNextAttribute() ) break; wsName = oReader.GetName(); } oReader.MoveToElement(); } //-------------------------------------------------------------------------------- // CMRPr 22.1.2.91 (Run Properties) //-------------------------------------------------------------------------------- CMRPr::CMRPr(OOX::Document *pMain) : WritingElement(pMain) { } CMRPr::~CMRPr() { } EElementType CMRPr::getType() const { return et_m_rPr; } //-------------------------------------------------------------------------------- // CMRun 22.1.2.87 (Math Run) //-------------------------------------------------------------------------------- CMRun::CMRun(OOX::Document *pMain) : WritingElementWithChilds<>(pMain) { } CMRun::~CMRun() { ClearItems(); } void CMRun::ClearItems() { m_oARPr.reset(); m_oMRPr.reset(); m_oRPr.reset(); m_oDel.reset(); m_oIns.reset(); WritingElementWithChilds<>::ClearItems(); } void CMRun::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement* pItem = NULL; if (L"w:annotationRef" == sName) AssignPtrXmlContent(pItem, CAnnotationRef, oItem) else if (L"w:br" == sName) AssignPtrXmlContent(pItem, CBr, oItem) else if (L"w:commentReference" == sName) AssignPtrXmlContent(pItem, CCommentReference, oItem) else if (L"w:contentPart" == sName) AssignPtrXmlContent(pItem, CContentPart, oItem) else if (L"w:continuationSeparator" == sName) AssignPtrXmlContent(pItem, CContinuationSeparator, oItem) else if (L"w:cr" == sName) AssignPtrXmlContent(pItem, CCr, oItem) else if (L"w:dayLong" == sName) AssignPtrXmlContent(pItem, CDayLong, oItem) else if (L"w:dayShort" == sName) AssignPtrXmlContent(pItem, CDayShort, oItem) else if (L"w:delInstrText" == sName) AssignPtrXmlContent(pItem, CDelInstrText, oItem) else if (L"w:delText" == sName) AssignPtrXmlContent(pItem, CDelText, oItem) else if (L"w:drawing" == sName) AssignPtrXmlContent(pItem, CDrawing, oItem) else if (L"w:endnoteRef" == sName) AssignPtrXmlContent(pItem, CEndnoteRef, oItem) else if (L"w:endnoteReference" == sName) AssignPtrXmlContent(pItem, CEndnoteReference, oItem) else if (L"w:fldChar" == sName) AssignPtrXmlContent(pItem, CFldChar, oItem) else if (L"w:footnoteRef" == sName) AssignPtrXmlContent(pItem, CFootnoteRef, oItem) else if (L"w:footnoteReference" == sName) AssignPtrXmlContent(pItem, CFootnoteReference, oItem) else if (L"w:instrText" == sName) AssignPtrXmlContent(pItem, CInstrText, oItem) else if (L"w:lastRenderedPageBreak" == sName) AssignPtrXmlContent(pItem, CLastRenderedPageBreak, oItem) else if (L"w:monthLong" == sName) AssignPtrXmlContent(pItem, CMonthLong, oItem) else if (L"w:monthShort" == sName) AssignPtrXmlContent(pItem, CMonthShort, oItem) else if (L"w:noBreakHyphen" == sName) AssignPtrXmlContent(pItem, CNoBreakHyphen, oItem) else if (L"w:object" == sName) AssignPtrXmlContent(pItem, CObject, oItem) else if (L"w:pgNum" == sName) AssignPtrXmlContent(pItem, CPgNum, oItem) else if (L"w:pict" == sName) AssignPtrXmlContent(pItem, CPicture, oItem) else if (L"w:ptab" == sName) AssignPtrXmlContent(pItem, CPTab, oItem) else if (L"w:ruby" == sName) AssignPtrXmlContent(pItem, CRuby, oItem) else if (L"w:separator" == sName) AssignPtrXmlContent(pItem, CSeparator, oItem) else if (L"w:softHyphen" == sName) AssignPtrXmlContent(pItem, CSoftHyphen, oItem) else if (L"w:sym" == sName) AssignPtrXmlContent(pItem, CSym, oItem) else if (L"m:t" == sName) AssignPtrXmlContent(pItem, CMText, oItem) else if (L"w:t" == sName) AssignPtrXmlContent(pItem, CText, oItem) else if (L"w:tab" == sName) AssignPtrXmlContent(pItem, CTab, oItem) else if (L"w:yearLong" == sName) AssignPtrXmlContent(pItem, CYearLong, oItem) else if (L"w:yearShort" == sName) AssignPtrXmlContent(pItem, CYearShort, oItem) else if ( L"w:del" == sName ) m_oDel = oItem; else if ( L"w:ins" == sName ) m_oIns = oItem; else if ( L"m:rPr" == sName ) m_oMRPr = oItem ; else if ( L"w:rPr" == sName ) m_oRPr = oItem; else if ( L"a:rPr" == sName ) m_oARPr = oItem; if (pItem) m_arrItems.push_back(pItem); } } } } void CMRun::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); WritingElement* pItem = NULL; if (L"w:annotationRef" == sName) pItem = new CAnnotationRef(); else if (L"w:br" == sName) pItem = new CBr(); else if (L"w:commentReference" == sName) pItem = new CCommentReference(); else if (L"w:contentPart" == sName) pItem = new CContentPart(); else if (L"w:continuationSeparator" == sName) pItem = new CContinuationSeparator(); else if (L"w:cr" == sName) pItem = new CCr(); else if (L"w:dayLong" == sName) pItem = new CDayLong(); else if (L"w:dayShort" == sName) pItem = new CDayShort(); else if (L"w:delInstrText" == sName) pItem = new CDelInstrText(); else if (L"w:delText" == sName) pItem = new CDelText(); else if (L"w:drawing" == sName) pItem = new CDrawing(); else if (L"w:endnoteRef" == sName) pItem = new CEndnoteRef(); else if (L"w:endnoteReference" == sName) pItem = new CEndnoteReference(); else if (L"w:fldChar" == sName) pItem = new CFldChar(); else if (L"w:footnoteRef" == sName) pItem = new CFootnoteRef(); else if (L"w:footnoteReference" == sName) pItem = new CFootnoteReference(); else if (L"w:instrText" == sName) pItem = new CInstrText(); else if (L"w:lastRenderedPageBreak" == sName) pItem = new CLastRenderedPageBreak(); else if (L"w:monthLong" == sName) pItem = new CMonthLong(); else if (L"w:monthShort" == sName) pItem = new CMonthShort(); else if (L"w:noBreakHyphen" == sName) pItem = new CNoBreakHyphen(); else if (L"w:object" == sName) pItem = new CObject(); else if (L"w:pgNum" == sName) pItem = new CPgNum(); else if (L"w:pict" == sName) pItem = new CPicture(); else if (L"w:ptab" == sName) pItem = new CPTab(); else if (L"w:ruby" == sName) pItem = new CRuby(); else if (L"w:separator" == sName) pItem = new CSeparator(); else if (L"w:softHyphen" == sName) pItem = new CSoftHyphen(); else if (L"w:sym" == sName) pItem = new CSym(); else if (L"w:t" == sName) pItem = new CText(); else if (L"w:tab" == sName) pItem = new CTab(); else if (L"w:yearLong" == sName) pItem = new CYearLong(); else if (L"m:t" == sName) pItem = new CMText(); else if (L"w:del" == sName) m_oDel = oReader; else if (L"w:ins" == sName) m_oIns = oReader; else if (L"m:rPr" == sName) m_oMRPr = oReader; else if (L"w:rPr" == sName) m_oRPr = oReader; else if (L"a:rPr" == sName) { std::wstring sXml = oReader.GetOuterXml(); XmlUtils::CXmlNode node; node.FromXmlString(sXml); m_oARPr = node; } if (pItem) { pItem->fromXML(oReader); m_arrItems.push_back(pItem); } } } EElementType CMRun::getType() const { return et_m_r; } //-------------------------------------------------------------------------------- // CMDel //-------------------------------------------------------------------------------- CMDel::CMDel(OOX::Document *pMain) : WritingElement(pMain) { } CMDel::~CMDel() { } void CMDel::fromXML(XmlUtils::CXmlNode& oNode) { XmlMacroReadAttributeBase( oNode, _T("w:author"), m_sAuthor ); XmlMacroReadAttributeBase( oNode, _T("w:date"), m_oDate ); XmlMacroReadAttributeBase( oNode, _T("w:id"), m_oId ); XmlMacroReadAttributeBase( oNode, _T("oouserid"), m_sUserId ); m_oRun = oNode; } void CMDel::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); m_oRun = oReader; } std::wstring CMDel::toXML() const { std::wstring sResult; sResult += _T("ToString()); sResult += _T("\" "); } if ( m_oId.IsInit() ) { sResult += _T(" w:id=\""); sResult += m_oId->ToString(); sResult += _T("\" "); } if ( m_sUserId.IsInit() ) { sResult += _T(" oouserid=\""); sResult += XmlUtils::EncodeXmlString(m_sUserId.get2()); sResult += _T("\" "); } sResult += _T(">"); if(m_oRun.IsInit()) { sResult += m_oRun->toXMLInner(); } sResult += _T(""); return sResult; } EElementType CMDel::getType() const { return et_w_ins; } void CMDel::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { WritingElement_ReadAttributes_Start( oReader ) WritingElement_ReadAttributes_Read_if ( oReader, _T("w:author"), m_sAuthor ) WritingElement_ReadAttributes_Read_else_if( oReader, _T("w:date"), m_oDate ) WritingElement_ReadAttributes_Read_else_if( oReader, _T("w:id"), m_oId ) WritingElement_ReadAttributes_Read_else_if( oReader, _T("oouserid"), m_sUserId ) WritingElement_ReadAttributes_End( oReader ) } //-------------------------------------------------------------------------------- // CMIns //-------------------------------------------------------------------------------- CMIns::CMIns(OOX::Document *pMain) : WritingElement(pMain) { } CMIns::~CMIns() { } void CMIns::fromXML(XmlUtils::CXmlNode& oNode) { XmlMacroReadAttributeBase( oNode, _T("w:author"), m_sAuthor ); XmlMacroReadAttributeBase( oNode, _T("w:date"), m_oDate ); XmlMacroReadAttributeBase( oNode, _T("w:id"), m_oId ); XmlMacroReadAttributeBase( oNode, _T("oouserid"), m_sUserId ); m_oRun = oNode; } void CMIns::fromXML(XmlUtils::CXmlLiteReader& oReader) { ReadAttributes(oReader); m_oRun = oReader; } std::wstring CMIns::toXML() const { std::wstring sResult; sResult += _T("ToString()); sResult += _T("\" "); } if ( m_oId.IsInit() ) { sResult += _T(" w:id=\""); sResult += m_oId->ToString(); sResult += _T("\" "); } if ( m_sUserId.IsInit() ) { sResult += _T(" oouserid=\""); sResult += XmlUtils::EncodeXmlString(m_sUserId.get2()); sResult += _T("\" "); } sResult += _T(">"); if(m_oRun.IsInit()) { sResult += m_oRun->toXMLInner(); } sResult += L""; return sResult; } EElementType CMIns::getType() const { return et_w_ins; } void CMIns::ReadAttributes(XmlUtils::CXmlLiteReader& oReader) { // Читаем атрибуты WritingElement_ReadAttributes_Start( oReader ) WritingElement_ReadAttributes_Read_if ( oReader, _T("w:author"), m_sAuthor ) WritingElement_ReadAttributes_Read_else_if( oReader, _T("w:date"), m_oDate ) WritingElement_ReadAttributes_Read_else_if( oReader, _T("w:id"), m_oId ) WritingElement_ReadAttributes_Read_else_if( oReader, _T("oouserid"), m_sUserId ) WritingElement_ReadAttributes_End( oReader ) } //-------------------------------------------------------------------------------- // CRadPr 22.1.2.89 (Radical Properties) //-------------------------------------------------------------------------------- CRadPr::CRadPr(OOX::Document *pMain) : WritingElement(pMain) { } CRadPr::~CRadPr() { } void CRadPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } else if ( _T("m:degHide") == sName ) m_oDegHide = new OOX::Logic::CDegHide( oItem ); } } } } void CRadPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; else if ( _T("m:degHide") == sName ) m_oDegHide = oReader; } } std::wstring CRadPr::toXML() const { std::wstring sResult = _T(""); if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); if ( m_oDegHide.IsInit() ) sResult += m_oDegHide->toXML(); sResult += _T(""); return sResult; } EElementType CRadPr::getType() const { return et_m_radPr; } //-------------------------------------------------------------------------------- // CRad 22.1.2.88 (Radical Object) //-------------------------------------------------------------------------------- CRad::CRad(OOX::Document *pMain) : WritingElement(pMain) { } CRad::~CRad() { } void CRad::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:radPr") == sName ) { m_oRadPr = new OOX::Logic::CRadPr(); *m_oRadPr = oItem; } else if ( _T("m:deg") == sName ) { m_oDeg = new OOX::Logic::CDeg(); *m_oDeg = oItem; } else if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } } } } } void CRad::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:deg") == sName ) m_oDeg = oReader; else if ( _T("m:e") == sName ) m_oElement = oReader; else if ( _T("m:radPr") == sName ) m_oRadPr = oReader; } } std::wstring CRad::toXML() const { std::wstring sResult = _T(""); if ( m_oRadPr.IsInit()) sResult += m_oRadPr->toXML(); if ( m_oDeg.IsInit() ) sResult += m_oDeg->toXML(); if ( m_oElement.IsInit() ) sResult += m_oElement->toXML(); sResult += _T(""); return sResult; } EElementType CRad::getType() const { return et_m_rad; } //-------------------------------------------------------------------------------- // CSPrePr 22.1.2.100 (Pre-Sub-Superscript Properties)) //-------------------------------------------------------------------------------- CSPrePr::CSPrePr(OOX::Document *pMain) : WritingElement(pMain) { } CSPrePr::~CSPrePr() { } void CSPrePr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } } } } } void CSPrePr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; } } std::wstring CSPrePr::toXML() const { std::wstring sResult = _T(""); if (m_oCtrlPr.IsInit()) sResult += m_oCtrlPr->toXML(); sResult += _T(""); return sResult; } EElementType CSPrePr::getType() const { return et_m_sPrePr; } //-------------------------------------------------------------------------------- // CSPre 22.1.2.99 (Pre-Sub-Superscript Object) //-------------------------------------------------------------------------------- CSPre::CSPre(OOX::Document *pMain) : WritingElement(pMain) { } CSPre::~CSPre() { } void CSPre::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { XmlUtils::CXmlNode oItem; for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:sPrePr") == sName ) { m_oSPrePr = new OOX::Logic::CSPrePr(); *m_oSPrePr = oItem; } else if ( _T("m:sub") == sName ) { m_oSub = new OOX::Logic::CSub(); *m_oSub = oItem; } else if ( _T("m:sup") == sName ) { m_oSup = new OOX::Logic::CSup(); *m_oSup = oItem; } else if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } } } } } void CSPre::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:e") == sName ) m_oElement = oReader; else if ( _T("m:sPrePr") == sName ) m_oSPrePr = oReader; else if ( _T("m:sub") == sName ) m_oSub = oReader; else if ( _T("m:sup") == sName ) m_oSup = oReader; } } std::wstring CSPre::toXML() const { std::wstring sResult = _T(""); if ( m_oSPrePr.IsInit() ) sResult += m_oSPrePr->toXML(); if ( m_oElement.IsInit() ) sResult += m_oElement->toXML(); if ( m_oSub.IsInit() ) sResult += m_oSub->toXML(); if ( m_oSup.IsInit() ) sResult += m_oSup->toXML(); sResult += _T(""); return sResult; } EElementType CSPre::getType() const { return et_m_sPre; } //-------------------------------------------------------------------------------- // CSSubPr 22.1.2.102 (Subscript Properties) //-------------------------------------------------------------------------------- CSSubPr::CSSubPr(OOX::Document *pMain) : WritingElement(pMain) { } CSSubPr::~CSSubPr() { } void CSSubPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } } } } } void CSSubPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; } } std::wstring CSSubPr::toXML() const { std::wstring sResult = _T(""); if (m_oCtrlPr.IsInit()) sResult += m_oCtrlPr->toXML(); sResult += _T(""); return sResult; } EElementType CSSubPr::getType() const { return et_m_sSubPr; } //-------------------------------------------------------------------------------- // CSSub 22.1.2.101 (Subscript Object) //-------------------------------------------------------------------------------- CSSub::CSSub(OOX::Document *pMain) : WritingElement(pMain) { } CSSub::~CSSub() { } void CSSub::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:sSubPr") == sName ) { m_oSSubPr = new OOX::Logic::CSSubPr(); *m_oSSubPr = oItem; } else if ( _T("m:sub") == sName ) { m_oSub = new OOX::Logic::CSub(); *m_oSub = oItem; } else if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } } } } } void CSSub::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:e") == sName ) m_oElement = oReader; else if ( _T("m:sSubPr") == sName ) m_oSSubPr = oReader; else if ( _T("m:sub") == sName ) m_oSub = oReader; } } std::wstring CSSub::toXML() const { std::wstring sResult = _T(""); if (m_oSSubPr.IsInit()) sResult += m_oSSubPr->toXML(); if (m_oElement.IsInit()) sResult += m_oElement->toXML(); if (m_oSub.IsInit()) sResult += m_oSub->toXML(); sResult += _T(""); return sResult; } EElementType CSSub::getType() const { return et_m_sSub; } //-------------------------------------------------------------------------------- // CSSubSupPr 22.1.2.104 (Sub-Superscript Properties) //-------------------------------------------------------------------------------- CSSubSupPr::CSSubSupPr(OOX::Document *pMain) : WritingElement(pMain) { } CSSubSupPr::~CSSubSupPr() { } void CSSubSupPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:alnScr") == sName ) m_oAlnScr = new OOX::Logic::CAlnScr( oItem ); else if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } } } } } void CSSubSupPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:alnScr") == sName ) m_oAlnScr = oReader; else if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; } } std::wstring CSSubSupPr::toXML() const { std::wstring sResult = _T(""); if (m_oAlnScr.IsInit()) sResult += m_oAlnScr->toXML(); if (m_oCtrlPr.IsInit()) sResult += m_oCtrlPr->toXML(); sResult += _T(""); return sResult; } EElementType CSSubSupPr::getType() const { return et_m_sSubSupPr; } //-------------------------------------------------------------------------------- // CSSubSup 22.1.2.103 (Sub-Superscript Object) //-------------------------------------------------------------------------------- CSSubSup::CSSubSup(OOX::Document *pMain) : WritingElement(pMain) { } CSSubSup::~CSSubSup() { } void CSSubSup::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:sSubSupPr") == sName ) { m_oSSubSupPr = new OOX::Logic::CSSubSupPr(); *m_oSSubSupPr = oItem; } else if ( _T("m:sup") == sName ) { m_oSup = new OOX::Logic::CSup(); *m_oSup = oItem; } else if ( _T("m:sub") == sName ) { m_oSub = new OOX::Logic::CSub(); *m_oSub = oItem; } else if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } } } } } void CSSubSup::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:e") == sName ) m_oElement = oReader; else if ( _T("m:sSubSupPr") == sName ) m_oSSubSupPr = oReader; else if ( _T("m:sub") == sName ) m_oSub = oReader; else if ( _T("m:sup") == sName ) m_oSup = oReader; } } std::wstring CSSubSup::toXML() const { std::wstring sResult = _T(""); if (m_oSSubSupPr.IsInit()) sResult += m_oSSubSupPr->toXML(); if (m_oElement.IsInit()) sResult += m_oElement->toXML(); if (m_oSub.IsInit()) sResult += m_oSub->toXML(); if (m_oSup.IsInit()) sResult += m_oSup->toXML(); sResult += _T(""); return sResult; } EElementType CSSubSup::getType() const { return et_m_sSubSup; } //-------------------------------------------------------------------------------- // CSSupPr 22.1.2.106 (Superscript Properties) //-------------------------------------------------------------------------------- CSSupPr::CSSupPr(OOX::Document *pMain) : WritingElement(pMain) { } CSSupPr::~CSSupPr() { } void CSSupPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { XmlUtils::CXmlNode oItem; for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:ctrlPr") == sName ) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } } } } } void CSSupPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:ctrlPr") == sName ) m_oCtrlPr = oReader; } } std::wstring CSSupPr::toXML() const { std::wstring sResult = _T(""); if (m_oCtrlPr.IsInit()) sResult += m_oCtrlPr->toXML(); sResult += _T(""); return sResult; } EElementType CSSupPr::getType() const { return et_m_sSupPr; } //-------------------------------------------------------------------------------- // CSSup 22.1.2.105 (Superscript Object) //-------------------------------------------------------------------------------- CSSup::CSSup(OOX::Document *pMain) : WritingElement(pMain) { } CSSup::~CSSup() { } void CSSup::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if ( oNode.GetNodes( _T("*"), oChilds ) ) { for ( size_t nIndex = 0; nIndex < oChilds.size(); nIndex++ ) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if ( _T("m:sSupPr") == sName ) { m_oSSupPr = new OOX::Logic::CSSupPr(); *m_oSSupPr = oItem; } else if ( _T("m:sup") == sName ) { m_oSup = new OOX::Logic::CSup(); *m_oSup = oItem; } else if ( _T("m:e") == sName ) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } } } } } void CSSup::fromXML(XmlUtils::CXmlLiteReader& oReader) { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nParentDepth ) ) { std::wstring sName = oReader.GetName(); if ( _T("m:e") == sName ) m_oElement = oReader; else if ( _T("m:sSupPr") == sName ) m_oSSupPr = oReader; else if ( _T("m:sup") == sName ) m_oSup = oReader; } } std::wstring CSSup::toXML() const { std::wstring sResult = _T(""); if (m_oSSupPr.IsInit()) sResult += m_oSSupPr->toXML(); if (m_oElement.IsInit()) sResult += m_oElement->toXML(); if (m_oSup.IsInit()) sResult += m_oSup->toXML(); sResult += _T(""); return sResult; } EElementType CSSup::getType() const { return et_m_sSup; } // void CMathPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if (oNode.GetNodes(L"*", oChilds)) { for (size_t nIndex = 0; nIndex < oChilds.size(); nIndex++) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = XmlUtils::GetNameNoNS(oItem.GetName()); WritingElement *pItem = NULL; if (L"brkBin" == sName) m_oBrkBin = oItem; else if (L"brkBinSub" == sName) m_oBrkBinSub = oItem; else if (L"defJc" == sName) m_oDefJc = oItem; else if (L"w:dispDef" == sName) m_oDispDef = oItem; else if (L"w:interSp" == sName) m_oInterSp = oItem; else if (L"intLim" == sName) m_oIntLim = oItem; else if (L"intraSp" == sName) m_oIntraSp = oItem; else if (L"lMargin" == sName) m_oLMargin = oItem; else if (L"mathFont" == sName) m_oMathFont = oItem; else if (L"naryLim" == sName) m_oNaryLim = oItem; else if (L"postSp" == sName) m_oPostSp = oItem; else if (L"preSp" == sName) m_oPreSp = oItem; else if (L"rMargin" == sName) m_oRMargin = oItem; else if (L"smallFrac" == sName) m_oSmallFrac = oItem; else if (L"wrapIndent" == sName) m_oWrapIndent = oItem; else if (L"wrapRight" == sName) m_oWrapRight = oItem; } } } } void CMathPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if (oReader.IsEmptyNode()) return; int nCurDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nCurDepth)) { std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName()); WritingElement *pItem = NULL; if (L"brkBin" == sName) m_oBrkBin = oReader; else if (L"brkBinSub" == sName) m_oBrkBinSub = oReader; else if (L"defJc" == sName) m_oDefJc = oReader; else if (L"dispDef" == sName) m_oDispDef = oReader; else if (L"interSp" == sName) m_oInterSp = oReader; else if (L"intLim" == sName) m_oIntLim = oReader; else if (L"intraSp" == sName) m_oIntraSp = oReader; else if (L"lMargin" == sName) m_oLMargin = oReader; else if (L"mathFont" == sName) m_oMathFont = oReader; else if (L"naryLim" == sName) m_oNaryLim = oReader; else if (L"postSp" == sName) m_oPostSp = oReader; else if (L"preSp" == sName) m_oPreSp = oReader; else if (L"rMargin" == sName) m_oRMargin = oReader; else if (L"smallFrac" == sName) m_oSmallFrac = oReader; else if (L"wrapIndent" == sName) m_oWrapIndent = oReader; else if (L"wrapRight" == sName) m_oWrapRight = oReader; } } std::wstring CMathPr::toXML() const { std::wstring sResult = L""; if (m_oMathFont.IsInit()) sResult += m_oMathFont->toXML(); if (m_oBrkBin.IsInit()) sResult += m_oBrkBin->toXML(); if (m_oBrkBinSub.IsInit()) sResult += m_oBrkBinSub->toXML(); if (m_oSmallFrac.IsInit()) sResult += m_oSmallFrac->toXML(); if (m_oDispDef.IsInit()) sResult += m_oDispDef->toXML(); if (m_oLMargin.IsInit()) sResult += m_oLMargin->toXML(); if (m_oRMargin.IsInit()) sResult += m_oRMargin->toXML(); if (m_oDefJc.IsInit()) sResult += m_oDefJc->toXML(); if (m_oPreSp.IsInit()) sResult += m_oPreSp->toXML(); if (m_oPostSp.IsInit()) sResult += m_oPostSp->toXML(); if (m_oInterSp.IsInit()) sResult += m_oInterSp->toXML(); if (m_oIntraSp.IsInit()) sResult += m_oIntraSp->toXML(); if (m_oWrapIndent.IsInit()) sResult += m_oWrapIndent->toXML(); if (m_oWrapRight.IsInit()) sResult += m_oWrapRight->toXML(); if (m_oIntLim.IsInit()) sResult += m_oIntLim->toXML(); if (m_oNaryLim.IsInit()) sResult += m_oNaryLim->toXML(); sResult += L""; return sResult; } void CMRPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if (oNode.GetNodes(L"*", oChilds)) { for (size_t nIndex = 0; nIndex < oChilds.size(); nIndex++) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if (L"m:aln" == sName) m_oAln = new OOX::Logic::CAln(oItem); else if (L"m:brk" == sName) { m_oBrk = new OOX::Logic::CBrk(); m_oBrk = oItem; } else if (L"m:lit" == sName) m_oLit = new OOX::Logic::CLit(oItem); else if (L"m:nor" == sName) m_oNor = new OOX::Logic::CNor(oItem); else if (L"m:scr" == sName) m_oScr = new OOX::Logic::CScr(oItem); else if (L"m:sty" == sName) m_oSty = new OOX::Logic::CSty(oItem); } } } } void CMRPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"m:aln" == sName) m_oAln = oReader; else if (L"m:brk" == sName) m_oBrk = oReader; else if (L"m:lit" == sName) m_oLit = oReader; else if (L"m:nor" == sName) m_oNor = oReader; else if (L"m:scr" == sName) m_oScr = oReader; else if (L"m:sty" == sName) m_oSty = oReader; } } std::wstring CMRPr::toXML() const { std::wstring sResult = L""; if (m_oAln.IsInit()) sResult += m_oAln->toXML(); if (m_oBrk.IsInit()) sResult += m_oBrk->toXML(); if (m_oLit.IsInit()) sResult += m_oLit->toXML(); if (m_oNor.IsInit()) sResult += m_oNor->toXML(); if (m_oScr.IsInit()) sResult += m_oScr->toXML(); if (m_oSty.IsInit()) sResult += m_oSty->toXML(); sResult += L""; return sResult; } void CNaryPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if (oNode.GetNodes(L"*", oChilds)) { for (size_t nIndex = 0; nIndex < oChilds.size(); nIndex++) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if (L"m:ctrlPr" == sName) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } else if (L"m:chr" == sName) m_oChr = new OOX::Logic::CChr(oItem); else if (L"m:grow" == sName) m_oGrow = new OOX::Logic::CGrow(oItem); else if (L"m:limLoc" == sName) m_oLimLoc = new OOX::Logic::CLimLoc(oItem); else if (L"m:subHide" == sName) m_oSubHide = new OOX::Logic::CSubHide(oItem); else if (L"m:supHide" == sName) m_oSupHide = new OOX::Logic::CSupHide(oItem); } } } } void CNaryPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"m:chr" == sName) m_oChr = oReader; else if (L"m:ctrlPr" == sName) m_oCtrlPr = oReader; else if (L"m:grow" == sName) m_oGrow = oReader; else if (L"m:limLoc" == sName) m_oLimLoc = oReader; else if (L"m:subHide" == sName) m_oSubHide = oReader; else if (L"m:supHide" == sName) m_oSupHide = oReader; } } std::wstring CNaryPr::toXML() const { std::wstring sResult = L""; if (m_oChr.IsInit()) sResult += m_oChr->toXML(); if (m_oCtrlPr.IsInit()) sResult += m_oCtrlPr->toXML(); if (m_oGrow.IsInit()) sResult += m_oGrow->toXML(); if (m_oLimLoc.IsInit()) sResult += m_oLimLoc->toXML(); if (m_oSubHide.IsInit()) sResult += m_oSubHide->toXML(); if (m_oSupHide.IsInit()) sResult += m_oSupHide->toXML(); sResult += L""; return sResult; } void CMPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if (oNode.GetNodes(L"*", oChilds)) { XmlUtils::CXmlNode oItem; for (size_t nIndex = 0; nIndex < oChilds.size(); nIndex++) { if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if (L"m:baseJc" == sName) m_oBaseJc = new OOX::Logic::CBaseJc(oItem); else if (L"m:cGp" == sName) m_oCGp = new OOX::Logic::CCGp(oItem); else if (L"m:cGpRule" == sName) m_oCGpRule = new OOX::Logic::CCGpRule(oItem); else if (L"m:cSp" == sName) m_oCSp = new OOX::Logic::CCSp(oItem); else if (L"m:ctrlPr" == sName) { m_oCtrlPr = new OOX::Logic::CCtrlPr(); *m_oCtrlPr = oItem; } else if (L"m:mcs" == sName) { m_oMcs = new OOX::Logic::CMcs(); *m_oMcs = oItem; } else if (L"m:plcHide" == sName) m_oPlcHide = new OOX::Logic::CPlcHide(oItem); else if (L"m:rSp" == sName) m_oRSp = new OOX::Logic::CRSp(oItem); else if (L"m:rSpRule" == sName) m_oRSpRule = new OOX::Logic::CRSpRule(oItem); } } } } void CMPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"m:baseJc" == sName) m_oBaseJc = oReader; else if (L"m:cGp" == sName) m_oCGp = oReader; else if (L"m:cGpRule" == sName) m_oCGpRule = oReader; else if (L"m:cSp" == sName) m_oCSp = oReader; else if (L"m:ctrlPr" == sName) m_oCtrlPr = oReader; else if (L"m:mcs" == sName) m_oMcs = oReader; else if (L"m:plcHide" == sName) m_oPlcHide = oReader; else if (L"m:rSp" == sName) m_oRSp = oReader; else if (L"m:rSpRule" == sName) m_oRSpRule = oReader; } } std::wstring CMPr::toXML() const { std::wstring sResult = L""; if (m_oBaseJc.IsInit()) sResult += m_oBaseJc->toXML(); if (m_oCGp.IsInit()) sResult += m_oCGp->toXML(); if (m_oCGpRule.IsInit()) sResult += m_oCGpRule->toXML(); if (m_oCSp.IsInit()) sResult += m_oCSp->toXML(); if (m_oCtrlPr.IsInit()) sResult += m_oCtrlPr->toXML(); if (m_oMcs.IsInit()) sResult += m_oMcs->toXML(); if (m_oPlcHide.IsInit()) sResult += m_oPlcHide->toXML(); if (m_oRSp.IsInit()) sResult += m_oRSp->toXML(); if (m_oRSpRule.IsInit()) sResult += m_oRSpRule->toXML(); sResult += L""; return sResult; } std::wstring CAcc::toXML() const { std::wstring sResult = L""; if ( m_oAccPr.IsInit()) sResult += m_oAccPr->toXML(); if ( m_oElement.IsInit()) sResult += m_oElement->toXML(); sResult += L""; return sResult; } std::wstring CAccPr::toXML() const { std::wstring sResult = L""; if ( m_oChr.IsInit() ) sResult += m_oChr->toXML(); if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); sResult += L""; return sResult; } std::wstring CBar::toXML() const { std::wstring sResult = L""; if ( m_oBarPr.IsInit() ) sResult += m_oBarPr->toXML(); if ( m_oElement.IsInit() ) sResult += m_oElement->toXML(); sResult += L""; return sResult; } std::wstring CBarPr::toXML() const { std::wstring sResult = L""; if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); if ( m_oPos.IsInit() ) sResult += m_oPos->toXML(); sResult += L""; return sResult; } std::wstring CBorderBox::toXML() const { std::wstring sResult = L""; if ( m_oBorderBoxPr.IsInit() ) sResult += m_oBorderBoxPr->toXML(); if ( m_oElement.IsInit() ) sResult += m_oElement->toXML(); sResult += L""; return sResult; } std::wstring CBorderBoxPr::toXML() const { std::wstring sResult = L""; if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); if ( m_oHideBot.IsInit() ) sResult += m_oHideBot->toXML(); if ( m_oHideLeft.IsInit() ) sResult += m_oHideLeft->toXML(); if ( m_oHideRight.IsInit() ) sResult += m_oHideRight->toXML(); if ( m_oHideTop.IsInit() ) sResult += m_oHideTop->toXML(); if ( m_oStrikeBLTR.IsInit() ) sResult += m_oStrikeBLTR->toXML(); if ( m_oStrikeH.IsInit() ) sResult += m_oStrikeH->toXML(); if ( m_oStrikeTLBR.IsInit() ) sResult += m_oStrikeTLBR->toXML(); if ( m_oStrikeV.IsInit() ) sResult += m_oStrikeV->toXML(); sResult += L""; return sResult; } std::wstring CBox::toXML() const { std::wstring sResult = L""; if ( m_oBoxPr.IsInit() ) sResult += m_oBoxPr->toXML(); if ( m_oElement.IsInit() ) sResult += m_oElement->toXML(); sResult += L""; return sResult; } std::wstring CBoxPr::toXML() const { std::wstring sResult = L""; if ( m_oAln.IsInit() ) sResult += m_oAln->toXML(); if ( m_oBrk.IsInit() ) sResult += m_oBrk->toXML(); if ( m_oCtrlPr.IsInit() ) sResult += m_oCtrlPr->toXML(); if ( m_oDiff.IsInit() ) sResult += m_oDiff->toXML(); if ( m_oNoBreak.IsInit() ) sResult += m_oNoBreak->toXML(); if ( m_oOpEmu.IsInit() ) sResult += m_oOpEmu->toXML(); sResult += L""; return sResult; } void CCtrlPr::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if (oNode.GetNodes(L"*", oChilds)) { for (size_t nIndex = 0; nIndex < oChilds.size(); nIndex++) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if (L"w:rP" == sName) m_oRPr = new OOX::Logic::CRunProperty(oItem); else if (L"a:rPr" == sName) { m_oARPr = new PPTX::Logic::RunProperties(); *m_oARPr = oItem; } else if (L"w:ins" == sName) m_oIns = new OOX::Logic::CRPrChange(oItem); else if (L"w:del" == sName) m_oDel = new OOX::Logic::CRPrChange(oItem); } } } } void CCtrlPr::fromXML(XmlUtils::CXmlLiteReader& oReader) { if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"w:rPr" == sName) m_oRPr = oReader; else if (L"a:rPr" == sName) { std::wstring sXml = oReader.GetOuterXml(); XmlUtils::CXmlNode node; node.FromXmlString(sXml); m_oARPr = node; } else if (L"w:ins" == sName) m_oIns = oReader; else if (L"w:del" == sName) m_oDel = oReader; } } std::wstring CCtrlPr::toXML() const { std::wstring sResult = L""; if (m_oRPr.IsInit()) sResult += m_oRPr->toXML(); if (m_oARPr.IsInit()) sResult += m_oARPr->toXML(); if (m_oIns.IsInit()) sResult += m_oIns->toXML(); if (m_oDel.IsInit()) sResult += m_oDel->toXML(); sResult += L""; return sResult; } void CDelimiter::fromXML(XmlUtils::CXmlNode& oNode) { m_lColumn = 0; std::vector oChilds; if (oNode.GetNodes(L"*", oChilds)) { for (size_t nIndex = 0; nIndex < oChilds.size(); nIndex++) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if (L"m:dPr" == sName) AssignPtrXmlContent(pItem, CDelimiterPr, oItem) else if (L"m:e" == sName) { AssignPtrXmlContent(pItem, CElement, oItem) //нужно заранее знать колисество столбцов для отрисовки m_lColumn++; } if (pItem) m_arrItems.push_back(pItem); } } } } void CDelimiter::fromXML(XmlUtils::CXmlLiteReader& oReader) { m_lColumn = 0; if (oReader.IsEmptyNode()) return; int nCurDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nCurDepth)) { std::wstring sName = oReader.GetName(); WritingElement *pItem = NULL; if (L"m:dPr" == sName) AssignPtrXmlContent(pItem, CDelimiterPr, oReader) else if (L"m:e" == sName) { AssignPtrXmlContent(pItem, CElement, oReader) //нужно заранее знать колисество столбцов для отрисовки m_lColumn++; } if (pItem) m_arrItems.push_back(pItem); } } std::wstring CDelimiter::toXML() const { std::wstring sResult = L""; for (size_t i = 0; i < m_arrItems.size(); ++i) { if (m_arrItems[i]) { sResult += m_arrItems[i]->toXML(); } } sResult += L""; return sResult; } std::wstring CEqArrPr::toXML() const { std::wstring sResult = L""; if (m_oBaseJc.IsInit()) sResult += m_oBaseJc->toXML(); if (m_oCtrlPr.IsInit()) sResult += m_oCtrlPr->toXML(); if (m_oMaxDist.IsInit()) sResult += m_oMaxDist->toXML(); if (m_oObjDist.IsInit()) sResult += m_oObjDist->toXML(); if (m_oRSp.IsInit()) sResult += m_oRSp->toXML(); if (m_oRSpRule.IsInit()) sResult += m_oRSpRule->toXML(); sResult += L""; return sResult; } std::wstring CFraction::toXML() const { std::wstring sResult = L""; if ( m_oDen.IsInit() ) sResult += m_oDen->toXML(); if ( m_oFPr.IsInit() ) sResult += m_oFPr->toXML(); if ( m_oNum.IsInit() ) sResult += m_oNum->toXML(); sResult += L""; return sResult; } std::wstring CFunc::toXML() const { std::wstring sResult = L""; if ( m_oElement.IsInit() ) sResult += m_oElement->toXML(); if ( m_oFName.IsInit() ) sResult += m_oFName->toXML(); if ( m_oFuncPr.IsInit() ) sResult += m_oFuncPr->toXML(); sResult += L""; return sResult; } std::wstring CGroupChr::toXML() const { std::wstring sResult = L""; if ( m_oElement.IsInit() ) sResult += m_oElement->toXML(); if ( m_oGroupChrPr.IsInit() ) sResult += m_oGroupChrPr->toXML(); sResult += L""; return sResult; } std::wstring CLimLow::toXML() const { std::wstring sResult = L""; if ( m_oElement.IsInit() ) sResult += m_oElement->toXML(); if ( m_oLim.IsInit() ) sResult += m_oLim->toXML(); if ( m_oLimLowPr.IsInit() ) sResult += m_oLimLowPr->toXML(); sResult += L""; return sResult; } void CLimUpp::fromXML(XmlUtils::CXmlNode& oNode) { std::vector oChilds; if (oNode.GetNodes(L"*", oChilds)) { for (size_t nIndex = 0; nIndex < oChilds.size(); nIndex++) { XmlUtils::CXmlNode& oItem = oChilds[nIndex]; if ( oItem.IsValid( ) ) { std::wstring sName = oItem.GetName(); WritingElement *pItem = NULL; if (L"m:e" == sName) { m_oElement = new OOX::Logic::CElement(); *m_oElement = oItem; } else if (L"m:lim" == sName) { m_oLim = new OOX::Logic::CLim(); *m_oLim = oItem; } else if (L"m:limUppPr" == sName) { m_oLimUppPr = new OOX::Logic::CLimUppPr(); *m_oLimUppPr = oItem; } } } } } void CLimUpp::fromXML(XmlUtils::CXmlLiteReader& oReader) { if (oReader.IsEmptyNode()) return; int nParentDepth = oReader.GetDepth(); while (oReader.ReadNextSiblingNode(nParentDepth)) { std::wstring sName = oReader.GetName(); if (L"m:e" == sName) m_oElement = oReader; else if (L"m:lim" == sName) m_oLim = oReader; else if (L"m:limUppPr" == sName) m_oLimUppPr = oReader; } } std::wstring CLimUpp::toXML() const { std::wstring sResult = L""; if ( m_oElement.IsInit() ) sResult += m_oElement->toXML(); if ( m_oLim.IsInit() ) sResult += m_oLim->toXML(); if ( m_oLimUppPr.IsInit() ) sResult += m_oLimUppPr->toXML(); sResult += L""; return sResult; } std::wstring CMc::toXML() const { std::wstring sResult = L""; if ( m_oMcPr.IsInit() ) sResult += m_oMcPr->toXML(); sResult += L""; return sResult; } std::wstring CNary::toXML() const { std::wstring sResult = L""; if ( m_oElement.IsInit() ) sResult += m_oElement->toXML(); if ( m_oNaryPr.IsInit() ) sResult += m_oNaryPr->toXML(); if ( m_oSub.IsInit() ) sResult += m_oSub->toXML(); if ( m_oSup.IsInit() ) sResult += m_oSup->toXML(); sResult += L""; return sResult; } std::wstring CPhant::toXML() const { std::wstring sResult = L""; if ( m_oElement.IsInit() ) sResult += m_oElement->toXML(); if ( m_oPhantPr.IsInit() ) sResult += m_oPhantPr->toXML(); sResult += L""; return sResult; } std::wstring CMRun::toXML() const { std::wstring sResult = L""; sResult += toXMLInner(); sResult += L""; return sResult; } std::wstring CMRun::toXMLInner() const { std::wstring sResult; if (m_oIns.IsInit() ) sResult += m_oIns->toXML(); if ( m_oDel.IsInit() ) sResult += m_oDel->toXML(); if ( m_oMRPr.IsInit() ) sResult += m_oMRPr->toXML(); if ( m_oARPr.IsInit() ) sResult += m_oARPr->toXML(); if ( m_oRPr.IsInit() ) sResult += m_oRPr->toXML(); for (size_t i = 0; i < m_arrItems.size(); ++i) { if (m_arrItems[i]) { sResult += m_arrItems[i]->toXML(); } } return sResult; } } }