diff --git a/ASCOfficeOdfFileW/source/Oox2OdfConverter/ConvertDiagram.cpp b/ASCOfficeOdfFileW/source/Oox2OdfConverter/ConvertDiagram.cpp index 5c1ad25960..b31f168039 100644 --- a/ASCOfficeOdfFileW/source/Oox2OdfConverter/ConvertDiagram.cpp +++ b/ASCOfficeOdfFileW/source/Oox2OdfConverter/ConvertDiagram.cpp @@ -85,9 +85,10 @@ void OoxConverter::convert(PPTX::Logic::Shape *oox_shape) if (type == SimpleTypes::shapetypeRect && oox_shape->txBody.IsInit()) type = 2000; - if (type == 2000 && oox_shape->txBody->bodyPr.fromWordArt.get_value_or(false)) + if (type == 2000 && oox_shape->txBody->bodyPr.IsInit() + && oox_shape->txBody->bodyPr->fromWordArt.get_value_or(false)) { - int wordart_type = convert(oox_shape->txBody->bodyPr.prstTxWarp.GetPointer()); + int wordart_type = convert(oox_shape->txBody->bodyPr->prstTxWarp.GetPointer()); if (wordart_type > 0) type = wordart_type; } @@ -111,7 +112,7 @@ void OoxConverter::convert(PPTX::Logic::Shape *oox_shape) odf_context()->drawing_context()->set_text( odf_context()->text_context()); //наложим внешние настройки для текста - convert(&oox_shape->txBody->bodyPr); + convert(oox_shape->txBody->bodyPr.GetPointer()); if (oox_shape->style.IsInit()) { @@ -281,15 +282,15 @@ void OoxConverter::convert(PPTX::Logic::PathBase *oox_path) } if (cubicBezTo) { - std::wstring path_elm = cubicBezTo->x1 + L" " + cubicBezTo->y1 + L" " + - cubicBezTo->x2 + L" " + cubicBezTo->y2 + L" " + - cubicBezTo->x3 + L" " + cubicBezTo->y3; + std::wstring path_elm = cubicBezTo->x[0] + L" " + cubicBezTo->y[0] + L" " + + cubicBezTo->x[1] + L" " + cubicBezTo->y[1] + L" " + + cubicBezTo->x[2] + L" " + cubicBezTo->y[2]; odf_context()->drawing_context()->add_path_element(std::wstring(L"C"), path_elm); } if (quadBezTo) { - std::wstring path_elm = quadBezTo->x1 + L" " + quadBezTo->y1 + L" " + - quadBezTo->x2 + L" " + quadBezTo->y2; + std::wstring path_elm = quadBezTo->x[0] + L" " + quadBezTo->y[0] + L" " + + quadBezTo->x[1] + L" " + quadBezTo->y[1]; odf_context()->drawing_context()->add_path_element(std::wstring(L"S"), path_elm); } if (arcTo) diff --git a/ASCOfficeOdfFileW/source/Oox2OdfConverter/Converter.cpp b/ASCOfficeOdfFileW/source/Oox2OdfConverter/Converter.cpp index 5929575331..45eb0dc02e 100644 --- a/ASCOfficeOdfFileW/source/Oox2OdfConverter/Converter.cpp +++ b/ASCOfficeOdfFileW/source/Oox2OdfConverter/Converter.cpp @@ -395,7 +395,7 @@ void OoxConverter::convert(OOX::Drawing::CDiagrammParts *oox_diagramm) if (oFile.is_init() && OOX::FileTypes::DiagDrawing == oFile->type()) { - _CP_OPT(double) x, y, width, height, cx = 0, cy = 0; + _CP_OPT(double) x, y, width, height, cx, cy; odf_context()->drawing_context()->get_size (width, height); odf_context()->drawing_context()->get_position (x, y); diff --git a/ASCOfficeOdfFileW/source/Oox2OdfConverter/Converter.h b/ASCOfficeOdfFileW/source/Oox2OdfConverter/Converter.h index 834ca156a1..9522aa01b5 100644 --- a/ASCOfficeOdfFileW/source/Oox2OdfConverter/Converter.h +++ b/ASCOfficeOdfFileW/source/Oox2OdfConverter/Converter.h @@ -270,7 +270,6 @@ namespace OOX class CT_Style1; class CT_Style; class CT_TextLanguageID; - class CRichText; class CTextProperties; } namespace Vml @@ -495,8 +494,8 @@ public: void convert(OOX::Spreadsheet::CT_LineSer *ser); void convert(OOX::Spreadsheet::CT_AxDataSource *cat, int type); void convert(OOX::Spreadsheet::CT_NumDataSource *val); - void convert(OOX::Spreadsheet::CRichText *rich); - void convert(OOX::Spreadsheet::CTextProperties *txPr); + //void convert(OOX::Spreadsheet::CRichText *rich); + //void convert(OOX::Spreadsheet::CTextProperties *txPr); void convert(OOX::Spreadsheet::CT_Tx *ct_tx); void convert(OOX::Spreadsheet::CT_Layout *ct_layout); void convert(OOX::Spreadsheet::CT_ManualLayout *ct_layout); diff --git a/ASCOfficeOdfFileW/source/Oox2OdfConverter/ConverterChart.cpp b/ASCOfficeOdfFileW/source/Oox2OdfConverter/ConverterChart.cpp index 99880c7d6f..27f4233c14 100644 --- a/ASCOfficeOdfFileW/source/Oox2OdfConverter/ConverterChart.cpp +++ b/ASCOfficeOdfFileW/source/Oox2OdfConverter/ConverterChart.cpp @@ -73,32 +73,32 @@ void OoxConverter::convert(OOX::Spreadsheet::CT_ChartSpace *oox_chart) odf_context()->chart_context()->end_plot_area(); } -void OoxConverter::convert(OOX::Spreadsheet::CRichText* rich) -{ - if (rich == NULL)return; - - odf_context()->chart_context()->start_text(); - OoxConverter::convert(rich->m_oBodyPr.GetPointer()); - - for (size_t i = 0; i < rich->m_arrItems.size();i++) - { - OoxConverter::convert(rich->m_arrItems[i]); - } - odf_context()->chart_context()->end_text(); -} -void OoxConverter::convert(OOX::Spreadsheet::CTextProperties* txPr) -{ - if (txPr == NULL)return; - - odf_context()->chart_context()->start_text(); - OoxConverter::convert(txPr->m_oBodyPr.GetPointer()); - - for (size_t i = 0; i < txPr->m_arrItems.size();i++) - { - OoxConverter::convert(txPr->m_arrItems[i]); - } - odf_context()->chart_context()->end_text(); -} +//void OoxConverter::convert(OOX::Spreadsheet::CRichText* rich) +//{ +// if (rich == NULL)return; +// +// odf_context()->chart_context()->start_text(); +// OoxConverter::convert(rich->m_oBodyPr.GetPointer()); +// +// for (size_t i = 0; i < rich->m_arrItems.size();i++) +// { +// OoxConverter::convert(rich->m_arrItems[i]); +// } +// odf_context()->chart_context()->end_text(); +//} +//void OoxConverter::convert(OOX::Spreadsheet::CTextProperties* txPr) +//{ +// if (txPr == NULL)return; +// +// odf_context()->chart_context()->start_text(); +// OoxConverter::convert(txPr->m_oBodyPr.GetPointer()); +// +// for (size_t i = 0; i < txPr->m_arrItems.size();i++) +// { +// OoxConverter::convert(txPr->m_arrItems[i]); +// } +// odf_context()->chart_context()->end_text(); +//} void OoxConverter::convert(OOX::Spreadsheet::CT_Tx* ct_tx) { if (ct_tx == NULL)return; diff --git a/ASCOfficePPTXFile/ASCOfficeDrawingConverter.cpp b/ASCOfficePPTXFile/ASCOfficeDrawingConverter.cpp index c4fa31a6e7..4eeda203cc 100644 --- a/ASCOfficePPTXFile/ASCOfficeDrawingConverter.cpp +++ b/ASCOfficePPTXFile/ASCOfficeDrawingConverter.cpp @@ -2754,7 +2754,11 @@ void CDrawingConverter::doc_LoadShape(PPTX::Logic::SpTreeElem *elem, XmlUtils::C { if (pShape->txBody.IsInit() == false) pShape->txBody = new PPTX::Logic::TxBody(); - pShape->txBody->bodyPr.vert = pShape->TextBoxBodyPr->vert; + + if (!pShape->txBody->bodyPr.IsInit()) + pShape->txBody->bodyPr = new PPTX::Logic::BodyPr(); + + pShape->txBody->bodyPr->vert = pShape->TextBoxBodyPr->vert; } pPair = oCSSParser.m_mapSettings.find(L"mso-rotate"); @@ -2765,7 +2769,11 @@ void CDrawingConverter::doc_LoadShape(PPTX::Logic::SpTreeElem *elem, XmlUtils::C pShape->TextBoxBodyPr->rot = _wtoi(pPair->second.c_str()) * 60000; //для docx, xlsx if (pShape->txBody.IsInit() == false) //для pptx pShape->txBody = new PPTX::Logic::TxBody(); - pShape->txBody->bodyPr.rot = pShape->TextBoxBodyPr->rot; + + if (!pShape->txBody->bodyPr.IsInit()) + pShape->txBody->bodyPr = new PPTX::Logic::BodyPr(); + + pShape->txBody->bodyPr->rot = pShape->TextBoxBodyPr->rot; }catch(...){} } @@ -5210,45 +5218,45 @@ void CDrawingConverter::ConvertMainPropsToVML(const std::wstring& bsMainProps, N pWriter.m_strStyleMain = oWriter.GetXmlString(); } -HRESULT CDrawingConverter::GetTxBodyBinary(const std::wstring& bsXml) -{ - XmlUtils::CXmlNode oNode; - if (!oNode.FromXmlString((std::wstring)bsXml)) - return S_FALSE; - - PPTX::Logic::TxBody oTxBody(oNode); +//HRESULT CDrawingConverter::GetTxBodyBinary(const std::wstring& bsXml) +//{ +// XmlUtils::CXmlNode oNode; +// if (!oNode.FromXmlString((std::wstring)bsXml)) +// return S_FALSE; +// +// PPTX::Logic::TxBody oTxBody(oNode); +// +// //m_pBinaryWriter->ClearNoAttack(); +// //ULONG lOldPos = m_pBinaryWriter->GetPosition(); +// m_pBinaryWriter->m_pCommon->CheckFontPicker(); +// //m_pBinaryWriter->m_pCommon->m_pNativePicker->Init(m_strFontDirectory); +// +// m_pBinaryWriter->WriteRecord1(0, oTxBody); +// +// //m_pBinaryWriter->SetPosition(lOldPos); +// +// //m_pBinaryWriter->ClearNoAttack(); +// return S_OK; +//} - //m_pBinaryWriter->ClearNoAttack(); - //ULONG lOldPos = m_pBinaryWriter->GetPosition(); - m_pBinaryWriter->m_pCommon->CheckFontPicker(); - //m_pBinaryWriter->m_pCommon->m_pNativePicker->Init(m_strFontDirectory); - - m_pBinaryWriter->WriteRecord1(0, oTxBody); - - //m_pBinaryWriter->SetPosition(lOldPos); - - //m_pBinaryWriter->ClearNoAttack(); - return S_OK; -} - -HRESULT CDrawingConverter::GetTxBodyXml(LONG lStart, std::wstring& sXml) -{ - m_pReader->Seek(lStart); - - BYTE type = m_pReader->GetUChar(); - if (0 != type) - return S_FALSE; - - PPTX::Logic::TxBody oTxBody; - oTxBody.fromPPTY(m_pReader); - - NSBinPptxRW::CXmlWriter oWriter; - oTxBody.toXmlWriterExcel(&oWriter); - - sXml = oWriter.GetXmlString(); - - return S_OK; -} +//HRESULT CDrawingConverter::GetTxBodyXml(LONG lStart, std::wstring& sXml) +//{ +// m_pReader->Seek(lStart); +// +// BYTE type = m_pReader->GetUChar(); +// if (0 != type) +// return S_FALSE; +// +// PPTX::Logic::TxBody oTxBody; +// oTxBody.fromPPTY(m_pReader); +// +// NSBinPptxRW::CXmlWriter oWriter; +// oTxBody.toXmlWriterExcel(&oWriter); +// +// sXml = oWriter.GetXmlString(); +// +// return S_OK; +//} HRESULT CDrawingConverter::SetFontDir(const std::wstring& bsFontDir) { diff --git a/ASCOfficePPTXFile/ASCOfficeDrawingConverter.h b/ASCOfficePPTXFile/ASCOfficeDrawingConverter.h index 26bb887628..3d8c0fc815 100644 --- a/ASCOfficePPTXFile/ASCOfficeDrawingConverter.h +++ b/ASCOfficePPTXFile/ASCOfficeDrawingConverter.h @@ -236,8 +236,6 @@ namespace NSBinPptxRW HRESULT WriteRels (const std::wstring& sType, const std::wstring& sTarget, const std::wstring& sTargetMode, long* lId); HRESULT LoadClrMap (const std::wstring& sXml); - HRESULT(GetTxBodyBinary) (const std::wstring& sXml); - HRESULT(GetTxBodyXml) (long lStart, std::wstring & Xml); HRESULT(SetFontDir) (const std::wstring& sFontDir); HRESULT SetFontPicker (COfficeFontPicker* pFontPicker); diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/AhBase.h b/ASCOfficePPTXFile/PPTXFormat/Logic/AhBase.h index e0018bce5c..403138b663 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/AhBase.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/AhBase.h @@ -45,9 +45,15 @@ namespace PPTX class AhBase : public WrapperWritingElement { public: - PPTX_LOGIC_BASE(AhBase) + WritingElement_AdditionConstructors(AhBase) + PPTX_LOGIC_BASE2(AhBase) - public: + virtual OOX::EElementType getType() const + { + if (ah.IsInit()) + return ah->getType(); + return OOX::et_Unknown; + } virtual void fromXML(XmlUtils::CXmlNode& node) { std::wstring name = XmlUtils::GetNameNoNS(node.GetName()); @@ -58,7 +64,16 @@ namespace PPTX ah.reset(new Logic::AhPolar(node)); else ah.reset(); } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + std::wstring sName = oReader.GetName(); + if (sName == L"a:ahXY") + ah.reset(new Logic::AhXY(oReader)); + else if(sName == L"a:ahPolar") + ah.reset(new Logic::AhPolar(oReader)); + else ah.reset(); + } virtual void GetAdjustHandleFrom(XmlUtils::CXmlNode& element) { XmlUtils::CXmlNode oNode; diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/AhPolar.h b/ASCOfficePPTXFile/PPTXFormat/Logic/AhPolar.h index 2ea1c4ec5b..3a4b22bea2 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/AhPolar.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/AhPolar.h @@ -43,9 +43,9 @@ namespace PPTX class AhPolar : public Ah { public: - PPTX_LOGIC_BASE(AhPolar) + WritingElement_AdditionConstructors(AhPolar) + PPTX_LOGIC_BASE2(AhPolar) - public: virtual void fromXML(XmlUtils::CXmlNode& node) { XmlUtils::CXmlNode oPos = node.ReadNode(_T("a:pos")); @@ -60,7 +60,46 @@ namespace PPTX node.ReadAttributeBase(L"minAng", minAng); node.ReadAttributeBase(L"minR", minR); } + virtual OOX::EElementType getType() const + { + return OOX::et_a_ahPolar; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + ReadAttributes( oReader ); + if ( oReader.IsEmptyNode() ) + return; + + int nParentDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth ) ) + { + std::wstring sName = oReader.GetName(); + + if (sName == L"a:pos") + { + ReadAttributes2(oReader); + } + } + } + void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("gdRefR"), gdRefR ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("minR"), minR ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("maxR"), maxR ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("gdRefAng"), gdRefAng ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("minAng"), minAng ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("maxAng"), maxAng ) + WritingElement_ReadAttributes_End( oReader ) + } + void ReadAttributes2(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("x"), x ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("y"), y ) + WritingElement_ReadAttributes_End( oReader ) + } virtual std::wstring toXML() const { XmlUtils::CAttribute oAttr1; diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/AhXY.h b/ASCOfficePPTXFile/PPTXFormat/Logic/AhXY.h index 671853f592..2cf312fbaf 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/AhXY.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/AhXY.h @@ -43,9 +43,9 @@ namespace PPTX class AhXY : public Ah { public: - PPTX_LOGIC_BASE(AhXY) + WritingElement_AdditionConstructors(AhXY) + PPTX_LOGIC_BASE2(AhXY) - public: virtual void fromXML(XmlUtils::CXmlNode& node) { XmlUtils::CXmlNode oPos = node.ReadNode(_T("a:pos")); @@ -60,7 +60,46 @@ namespace PPTX node.ReadAttributeBase(L"minX", minX); node.ReadAttributeBase(L"minY", minY); } + virtual OOX::EElementType getType() const + { + return OOX::et_a_ahXY; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + ReadAttributes( oReader ); + if ( oReader.IsEmptyNode() ) + return; + + int nParentDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth ) ) + { + std::wstring sName = oReader.GetName(); + + if (sName == L"a:pos") + { + ReadAttributes2(oReader); + } + } + } + void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("gdRefX"), gdRefX ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("minX"), minX ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("maxX"), maxX ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("gdRefY"), gdRefY ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("minY"), minY ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("maxY"), maxY ) + WritingElement_ReadAttributes_End( oReader ) + } + void ReadAttributes2(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("x"), x ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("y"), y ) + WritingElement_ReadAttributes_End( oReader ) + } virtual std::wstring toXML() const { XmlUtils::CAttribute oAttr1; diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/BodyPr.h b/ASCOfficePPTXFile/PPTXFormat/Logic/BodyPr.h index 57716390a5..b520f918f3 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/BodyPr.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/BodyPr.h @@ -51,9 +51,63 @@ namespace PPTX class BodyPr : public WrapperWritingElement { public: - PPTX_LOGIC_BASE(BodyPr) + WritingElement_AdditionConstructors(BodyPr) + PPTX_LOGIC_BASE2(BodyPr) - public: + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + ReadAttributes( oReader ); + + if ( oReader.IsEmptyNode() ) + return; + + int nCurDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nCurDepth ) ) + { + std::wstring strName = oReader.GetName(); + + if (L"a:prstTxWarp" == strName) + prstTxWarp = oReader; + else if (L"a:scene3d" == strName) + scene3d = oReader; + else if (L"a:sp3d" == strName) + sp3d = oReader; + else if (strName == L"a:noAutofit" || strName == L"a:spAutoFit" || strName == L"a:normAutofit") + Fit.fromXML(oReader); + else if (L"a:flatTx" == strName) + { + //oNode.ReadAttributeBase(L"z", flatTx); + } + + } + FillParentPointersForChilds(); + } + void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start ( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("anchor"), anchor ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("anchorCtr"), anchorCtr ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("bIns"), bIns ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("compatLnSpc"), compatLnSpc ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("forceAA"), forceAA ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("fromWordArt"), fromWordArt ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("horzOverflow"), horzOverflow ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("lIns"), lIns ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("numCol"), numCol ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("rIns"), rIns ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("rot"), rot ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("rtlCol"), rtlCol ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("spcCol"), spcCol ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("spcFirstLastPara"), spcFirstLastPara ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("tIns"), tIns ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("upright"), upright ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("vert"), vert ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("vertOverflow"), vertOverflow ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("wrap"), wrap ) + WritingElement_ReadAttributes_End ( oReader ) + + Normalize(); + } virtual void fromXML(XmlUtils::CXmlNode& node) { m_namespace = XmlUtils::GetNamespace(node.GetName()); @@ -172,10 +226,16 @@ namespace PPTX pWriter->EndNode(m_namespace + _T(":bodyPr")); } - void Merge(BodyPr& bodyPr)const + + void Merge(nullable& bodyPr)const { + if (!bodyPr.IsInit()) + { + bodyPr = new PPTX::Logic::BodyPr(); + } + if(Fit.type != TextFit::FitEmpty) - Fit.Merge(bodyPr.Fit); + Fit.Merge(bodyPr->Fit); /* nullable_property prstTxWarp; nullable_property scene3d; @@ -184,43 +244,43 @@ namespace PPTX */ // Attributes if(anchor.IsInit()) - bodyPr.anchor = *anchor; + bodyPr->anchor = *anchor; if(anchorCtr.IsInit()) - bodyPr.anchorCtr = *anchorCtr; + bodyPr->anchorCtr = *anchorCtr; if(bIns.IsInit()) - bodyPr.bIns = *bIns; + bodyPr->bIns = *bIns; if(compatLnSpc.IsInit()) - bodyPr.compatLnSpc = *compatLnSpc; + bodyPr->compatLnSpc = *compatLnSpc; if(forceAA.IsInit()) - bodyPr.forceAA = *forceAA; + bodyPr->forceAA = *forceAA; if(fromWordArt.IsInit()) - bodyPr.fromWordArt = *fromWordArt; + bodyPr->fromWordArt = *fromWordArt; if(horzOverflow.IsInit()) - bodyPr.horzOverflow = *horzOverflow; + bodyPr->horzOverflow = *horzOverflow; if(lIns.IsInit()) - bodyPr.lIns = *lIns; + bodyPr->lIns = *lIns; if(numCol.IsInit()) - bodyPr.numCol = *numCol; + bodyPr->numCol = *numCol; if(rIns.IsInit()) - bodyPr.rIns = *rIns; + bodyPr->rIns = *rIns; if(rot.IsInit()) - bodyPr.rot = *rot; + bodyPr->rot = *rot; if(rtlCol.IsInit()) - bodyPr.rtlCol = *rtlCol; + bodyPr->rtlCol = *rtlCol; if(spcCol.IsInit()) - bodyPr.spcCol = *spcCol; + bodyPr->spcCol = *spcCol; if(spcFirstLastPara.IsInit()) - bodyPr.spcFirstLastPara = *spcFirstLastPara; + bodyPr->spcFirstLastPara = *spcFirstLastPara; if(tIns.IsInit()) - bodyPr.tIns = *tIns; + bodyPr->tIns = *tIns; if(upright.IsInit()) - bodyPr.upright = *upright; + bodyPr->upright = *upright; if(vert.IsInit()) - bodyPr.vert = *vert; + bodyPr->vert = *vert; if(vertOverflow.IsInit()) - bodyPr.vertOverflow = *vertOverflow; + bodyPr->vertOverflow = *vertOverflow; if(wrap.IsInit()) - bodyPr.wrap = *wrap; + bodyPr->wrap = *wrap; } virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/CustGeom.h b/ASCOfficePPTXFile/PPTXFormat/Logic/CustGeom.h index 98a8c883be..128ff6635d 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/CustGeom.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/CustGeom.h @@ -47,7 +47,8 @@ namespace PPTX class CustGeom : public WrapperWritingElement { public: - PPTX_LOGIC_BASE(CustGeom) + WritingElement_AdditionConstructors(CustGeom) + PPTX_LOGIC_BASE2(CustGeom) CustGeom& operator=(const CustGeom& oSrc) { @@ -65,7 +66,107 @@ namespace PPTX return *this; } - public: + virtual OOX::EElementType getType() const + { + return OOX::et_a_custGeom; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + if ( oReader.IsEmptyNode() ) + return; + + int nParentDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth ) ) + { + std::wstring sName = oReader.GetName(); + + if (sName == L"a:avLst") + { + int nParentDepth1 = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth1 ) ) + { + std::wstring sName1 = oReader.GetName(); + + if (sName1 == L"a:gd") + { + Gd gd; + avLst.push_back(gd); + avLst.back().fromXML(oReader); + } + } + } + else if (sName == L"a:gdLst") + { + int nParentDepth1 = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth1 ) ) + { + std::wstring sName1 = oReader.GetName(); + + if (sName1 == L"a:gd") + { + Gd gd; + gdLst.push_back(gd); + gdLst.back().fromXML(oReader); + } + } + } + else if (sName == L"a:rect") + rect = oReader; + else if (sName == L"a:pathLst") + { + int nParentDepth1 = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth1 ) ) + { + std::wstring sName1 = oReader.GetName(); + + if (sName1 == L"a:path") + { + Path2D gd; + pathLst.push_back(gd); + pathLst.back().fromXML(oReader); + } + } + } + else if (sName == L"a:ahLst") + { + int nParentDepth1 = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth1 ) ) + { + std::wstring sName1 = oReader.GetName(); + + if (sName1 == L"a:ahPolar") + { + AhBase gd; + ahLst.push_back(gd); + ahLst.back().fromXML(oReader); + } + else if (sName1 == L"a:ahXY") + { + AhBase gd; + ahLst.push_back(gd); + ahLst.back().fromXML(oReader); + } + } + } + else if (sName == L"a:cxnLst") + { + int nParentDepth1 = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth1 ) ) + { + std::wstring sName1 = oReader.GetName(); + + if (sName1 == L"a:cxn") + { + Cxn gd; + cxnLst.push_back(gd); + cxnLst.back().fromXML(oReader); + } + } + } + } + FillParentPointersForChilds(); + } + virtual void fromXML(XmlUtils::CXmlNode& node) { XmlUtils::CXmlNode oNode; diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Cxn.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Cxn.h index a602d56a82..b7a30d38cc 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Cxn.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Cxn.h @@ -43,7 +43,8 @@ namespace PPTX class Cxn : public WrapperWritingElement { public: - PPTX_LOGIC_BASE(Cxn) + WritingElement_AdditionConstructors(Cxn) + PPTX_LOGIC_BASE2(Cxn) Cxn& operator=(const Cxn& oSrc) { @@ -55,8 +56,41 @@ namespace PPTX ang = oSrc.ang; return *this; } + virtual OOX::EElementType getType() const + { + return OOX::et_a_cxn; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + ReadAttributes( oReader ); - public: + if ( oReader.IsEmptyNode() ) + return; + + int nParentDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth ) ) + { + std::wstring sName = oReader.GetName(); + + if (sName == L"a:pos") + { + ReadAttributes2(oReader); + } + } + } + void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_ReadSingle( oReader, _T("ang"), ang ) + WritingElement_ReadAttributes_End( oReader ) + } + void ReadAttributes2(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("x"), x ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("y"), y ) + WritingElement_ReadAttributes_End( oReader ) + } virtual void fromXML(XmlUtils::CXmlNode& node) { ang = node.GetAttribute(_T("ang")); diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/DefaultShapeDefinition.h b/ASCOfficePPTXFile/PPTXFormat/Logic/DefaultShapeDefinition.h index bbc30d2cda..817d75b9ce 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/DefaultShapeDefinition.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/DefaultShapeDefinition.h @@ -95,7 +95,7 @@ namespace PPTX { XmlUtils::CNodeValue oValue; oValue.Write(spPr); - oValue.Write(bodyPr); + oValue.WriteNullable(bodyPr); oValue.Write(lstStyle); oValue.WriteNullable(style); @@ -105,7 +105,7 @@ namespace PPTX virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { pWriter->WriteRecord1(0, spPr); - pWriter->WriteRecord1(1, bodyPr); + pWriter->WriteRecord2(1, bodyPr); pWriter->WriteRecord1(2, lstStyle); pWriter->WriteRecord2(3, style); } @@ -127,8 +127,9 @@ namespace PPTX } case 1: { - bodyPr.m_namespace = _T("a"); - bodyPr.fromPPTY(pReader); + bodyPr = BodyPr(); + bodyPr->m_namespace = _T("a"); + bodyPr->fromPPTY(pReader); break; } case 2: @@ -160,7 +161,9 @@ namespace PPTX pWriter->m_lFlag = 0x04; spPr.toXmlWriter(pWriter); pWriter->m_lFlag = 0; - bodyPr.toXmlWriter(pWriter); + + if (bodyPr.IsInit()) + bodyPr->toXmlWriter(pWriter); lstStyle.toXmlWriter(pWriter); pWriter->Write(style); @@ -169,16 +172,19 @@ namespace PPTX public: SpPr spPr; - BodyPr bodyPr; + nullable bodyPr; TextListStyle lstStyle; nullable style; - public: - std::wstring m_name; + + std::wstring m_name; protected: virtual void FillParentPointersForChilds() { spPr.SetParentPointer(this); - bodyPr.SetParentPointer(this); + + if (bodyPr.IsInit()) + bodyPr->SetParentPointer(this); + lstStyle.SetParentPointer(this); if(style.IsInit()) style->SetParentPointer(this); diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Fills/BlipFill.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Fills/BlipFill.h index 49b5cdf577..f837ce814c 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Fills/BlipFill.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Fills/BlipFill.h @@ -78,7 +78,7 @@ namespace PPTX int nCurDepth = oReader.GetDepth(); while( oReader.ReadNextSiblingNode( nCurDepth ) ) { - std::wstring strName = oReader.GetName(); + std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName()); if (_T("blip") == strName) { if (!blip.IsInit()) diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Gd.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Gd.h index ab41763b48..8033b8b78e 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Gd.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Gd.h @@ -42,9 +42,25 @@ namespace PPTX class Gd : public WrapperWritingElement { public: - PPTX_LOGIC_BASE(Gd) + WritingElement_AdditionConstructors(Gd) + PPTX_LOGIC_BASE2(Gd) - public: + virtual OOX::EElementType getType () const + { + return OOX::et_a_gd; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + ReadAttributes( oReader ); + + } + void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start ( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("name"), name ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("fmla"), fmla ) + WritingElement_ReadAttributes_End ( oReader ) + } virtual void fromXML(XmlUtils::CXmlNode& node) { node.ReadAttributeBase(L"name", name); diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Geometry.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Geometry.h index 2d8615e20e..6341229de3 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Geometry.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Geometry.h @@ -45,9 +45,26 @@ namespace PPTX class Geometry : public WrapperWritingElement { public: - PPTX_LOGIC_BASE(Geometry) + WritingElement_AdditionConstructors(Geometry) + PPTX_LOGIC_BASE2(Geometry) - public: + virtual OOX::EElementType getType() const + { + if (m_geometry.IsInit()) + return m_geometry->getType(); + return OOX::et_Unknown; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName()); + + if (strName == _T("prstGeom")) + m_geometry.reset(new Logic::PrstGeom(oReader)); + else if (strName == _T("custGeom")) + m_geometry.reset(new Logic::CustGeom(oReader)); + else + m_geometry.reset(); + } virtual void fromXML(XmlUtils::CXmlNode& node) { std::wstring strName = XmlUtils::GetNameNoNS(node.GetName()); diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D.h index fde67bc0c1..0e1874a985 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D.h @@ -45,7 +45,8 @@ namespace PPTX class Path2D : public WrapperWritingElement { public: - PPTX_LOGIC_BASE(Path2D) + WritingElement_AdditionConstructors(Path2D) + PPTX_LOGIC_BASE2(Path2D) Path2D& operator=(const Path2D& oSrc) { @@ -62,8 +63,40 @@ namespace PPTX return *this; } + virtual OOX::EElementType getType() const + { + return OOX::et_a_path; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + ReadAttributes( oReader ); - public: + Paths.clear(); + if ( oReader.IsEmptyNode() ) + return; + + int nParentDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth ) ) + { + std::wstring sName = oReader.GetName(); + + UniPath2D p; + Paths.push_back(p); + Paths.back().fromXML(oReader); + } + + FillParentPointersForChilds(); + } + void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("extrusionOk"), extrusionOk) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("fill"), fill ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("h"), h ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("stroke"), stroke ) + WritingElement_ReadAttributes_Read_else_if( oReader, _T("w"), w ) + WritingElement_ReadAttributes_End( oReader ) + } virtual void fromXML(XmlUtils::CXmlNode& node) { node.ReadAttributeBase(L"extrusionOk", extrusionOk); @@ -229,12 +262,12 @@ namespace PPTX case GEOMETRY_TYPE_PATH_CUBICBEZTO: { Logic::CubicBezTo* p = new Logic::CubicBezTo(); - p->x1 = arr[0]; - p->y1 = arr[1]; - p->x2 = arr[2]; - p->y2 = arr[3]; - p->x3 = arr[4]; - p->y3 = arr[5]; + p->x[0] = arr[0]; + p->y[0] = arr[1]; + p->x[1] = arr[2]; + p->y[1] = arr[3]; + p->x[2] = arr[4]; + p->y[2] = arr[5]; oPath.Path2D.reset(p); break; } @@ -251,10 +284,10 @@ namespace PPTX case GEOMETRY_TYPE_PATH_QUADBEZTO: { Logic::QuadBezTo* p = new Logic::QuadBezTo(); - p->x1 = arr[0]; - p->y1 = arr[1]; - p->x2 = arr[2]; - p->y2 = arr[3]; + p->x[0] = arr[0]; + p->y[0] = arr[1]; + p->x[1] = arr[2]; + p->y[1] = arr[3]; oPath.Path2D.reset(p); break; } diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/ArcTo.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/ArcTo.h index 3661a9e0e7..a20be08b5c 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/ArcTo.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/ArcTo.h @@ -42,7 +42,8 @@ namespace PPTX class ArcTo : public PathBase { public: - PPTX_LOGIC_BASE(ArcTo) + WritingElement_AdditionConstructors(ArcTo) + PPTX_LOGIC_BASE2(ArcTo) ArcTo& operator=(const ArcTo& oSrc) { @@ -56,8 +57,23 @@ namespace PPTX return *this; } - - public: + virtual OOX::EElementType getType() const + { + return OOX::et_a_arcTo; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + ReadAttributes( oReader ); + } + void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("wR"), wR ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("hR"), hR) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("stAng"), stAng) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("swAng"), swAng) + WritingElement_ReadAttributes_End( oReader ) + } virtual void fromXML(XmlUtils::CXmlNode& node) { wR = node.GetAttribute(_T("wR")); diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/Close.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/Close.h index 8e4c81c571..15a7438bab 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/Close.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/Close.h @@ -43,7 +43,8 @@ namespace PPTX class Close : public PathBase { public: - PPTX_LOGIC_BASE(Close) + WritingElement_AdditionConstructors(Close) + PPTX_LOGIC_BASE2(Close) Close& operator=(const Close& oSrc) { @@ -52,8 +53,14 @@ namespace PPTX return *this; } + virtual OOX::EElementType getType() const + { + return OOX::et_a_close; + } - public: + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + } virtual void fromXML(XmlUtils::CXmlNode& node) { } diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/CubicBezTo.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/CubicBezTo.h index 5218dc893d..c9630efbdd 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/CubicBezTo.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/CubicBezTo.h @@ -43,24 +43,24 @@ namespace PPTX class CubicBezTo : public PathBase { public: - PPTX_LOGIC_BASE(CubicBezTo) + WritingElement_AdditionConstructors(CubicBezTo) + PPTX_LOGIC_BASE2(CubicBezTo) CubicBezTo& operator=(const CubicBezTo& oSrc) { parentFile = oSrc.parentFile; parentElement = oSrc.parentElement; - x1 = oSrc.x1; - y1 = oSrc.y1; - x2 = oSrc.x2; - y2 = oSrc.y2; - x3 = oSrc.x3; - y3 = oSrc.y3; + x[0] = oSrc.x[0]; + y[0] = oSrc.y[0]; + x[1] = oSrc.x[1]; + y[1] = oSrc.y[1]; + x[2] = oSrc.x[2]; + y[2] = oSrc.y[2]; return *this; } - public: virtual void fromXML(XmlUtils::CXmlNode& node) { XmlUtils::CXmlNodes oNodes; @@ -73,23 +73,53 @@ namespace PPTX XmlUtils::CXmlNode oNode; oNodes.GetAt(0, oNode); - x1 = oNode.GetAttribute(_T("x")); - y1 = oNode.GetAttribute(_T("y")); + x[0] = oNode.GetAttribute(_T("x")); + y[0] = oNode.GetAttribute(_T("y")); oNodes.GetAt(1, oNode); - x2 = oNode.GetAttribute(_T("x")); - y2 = oNode.GetAttribute(_T("y")); + x[1] = oNode.GetAttribute(_T("x")); + y[1] = oNode.GetAttribute(_T("y")); oNodes.GetAt(2, oNode); - x3 = oNode.GetAttribute(_T("x")); - y3 = oNode.GetAttribute(_T("y")); + x[2] = oNode.GetAttribute(_T("x")); + y[2] = oNode.GetAttribute(_T("y")); + } + } + } + virtual OOX::EElementType getType() const + { + return OOX::et_a_cubicBezTo; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + if ( oReader.IsEmptyNode() ) + return; + + int count = 0; + + int nParentDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth ) ) + { + std::wstring sName = oReader.GetName(); + + if (sName == L"a:pos") + { + ReadAttributes2(oReader, x[count], y[count]); + count++; } } } + void ReadAttributes2(XmlUtils::CXmlLiteReader& oReader, std::wstring & x, std::wstring & y) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("x"), x ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("y"), y ) + WritingElement_ReadAttributes_End( oReader ) + } virtual std::wstring toXML() const { - std::wstring str1 = L""; - std::wstring str2 = L""; - std::wstring str3 = L""; + std::wstring str1 = L""; + std::wstring str2 = L""; + std::wstring str3 = L""; return _T("") + str1 + str2 + str3 + _T(""); } @@ -101,22 +131,22 @@ namespace PPTX pWriter->StartNode(_T("a:pt")); pWriter->StartAttributes(); - pWriter->WriteAttribute(_T("x"), x1); - pWriter->WriteAttribute(_T("y"), y1); + pWriter->WriteAttribute(_T("x"), x[0]); + pWriter->WriteAttribute(_T("y"), y[0]); pWriter->EndAttributes(); pWriter->EndNode(_T("a:pt")); pWriter->StartNode(_T("a:pt")); pWriter->StartAttributes(); - pWriter->WriteAttribute(_T("x"), x2); - pWriter->WriteAttribute(_T("y"), y2); + pWriter->WriteAttribute(_T("x"), x[1]); + pWriter->WriteAttribute(_T("y"), y[1]); pWriter->EndAttributes(); pWriter->EndNode(_T("a:pt")); pWriter->StartNode(_T("a:pt")); pWriter->StartAttributes(); - pWriter->WriteAttribute(_T("x"), x3); - pWriter->WriteAttribute(_T("y"), y3); + pWriter->WriteAttribute(_T("x"), x[2]); + pWriter->WriteAttribute(_T("y"), y[2]); pWriter->EndAttributes(); pWriter->EndNode(_T("a:pt")); @@ -128,33 +158,29 @@ namespace PPTX pWriter->StartRecord(GEOMETRY_TYPE_PATH_CUBICBEZTO); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); - pWriter->WriteString1(0, x1); - pWriter->WriteString1(1, y1); - pWriter->WriteString1(2, x2); - pWriter->WriteString1(3, y2); - pWriter->WriteString1(4, x3); - pWriter->WriteString1(5, y3); + pWriter->WriteString1(0, x[0]); + pWriter->WriteString1(1, y[0]); + pWriter->WriteString1(2, x[1]); + pWriter->WriteString1(3, y[1]); + pWriter->WriteString1(4, x[2]); + pWriter->WriteString1(5, y[2]); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); pWriter->EndRecord(); } public: - std::wstring x1; - std::wstring y1; - std::wstring x2; - std::wstring y2; - std::wstring x3; - std::wstring y3; + std::wstring x[3]; + std::wstring y[3]; protected: virtual void FillParentPointersForChilds(){}; public: virtual std::wstring GetODString()const { - std::wstring str1 = L""; - std::wstring str2 = L""; - std::wstring str3 = L""; + std::wstring str1 = L""; + std::wstring str2 = L""; + std::wstring str3 = L""; return _T("") + str1 + str2 + str3 + _T(""); } diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/LineTo.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/LineTo.h index 96d7dc4f04..82e429c729 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/LineTo.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/LineTo.h @@ -43,7 +43,8 @@ namespace PPTX class LineTo : public PathBase { public: - PPTX_LOGIC_BASE(LineTo) + WritingElement_AdditionConstructors(LineTo) + PPTX_LOGIC_BASE2(LineTo) LineTo& operator=(const LineTo& oSrc) { @@ -55,7 +56,33 @@ namespace PPTX return *this; } - public: + virtual OOX::EElementType getType() const + { + return OOX::et_a_lineTo; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + if ( oReader.IsEmptyNode() ) + return; + + int nParentDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth ) ) + { + std::wstring sName = oReader.GetName(); + + if (sName == L"a:pos") + { + ReadAttributes2(oReader); + } + } + } + void ReadAttributes2(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("x"), x ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("y"), y ) + WritingElement_ReadAttributes_End( oReader ) + } virtual void fromXML(XmlUtils::CXmlNode& node) { XmlUtils::CXmlNode oNode; diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/MoveTo.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/MoveTo.h index 7e833e024c..7523ffcd53 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/MoveTo.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/MoveTo.h @@ -43,7 +43,8 @@ namespace PPTX class MoveTo : public PathBase { public: - PPTX_LOGIC_BASE(MoveTo) + WritingElement_AdditionConstructors(MoveTo) + PPTX_LOGIC_BASE2(MoveTo) MoveTo& operator=(const MoveTo& oSrc) { @@ -54,8 +55,34 @@ namespace PPTX y = oSrc.y; return *this; } + virtual OOX::EElementType getType() const + { + return OOX::et_a_moveTo; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + if ( oReader.IsEmptyNode() ) + return; + + int nParentDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth ) ) + { + std::wstring sName = oReader.GetName(); - public: + if (sName == L"a:pos") + { + ReadAttributes2(oReader); + } + } + } + + void ReadAttributes2(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("x"), x ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("y"), y ) + WritingElement_ReadAttributes_End( oReader ) + } virtual void fromXML(XmlUtils::CXmlNode& node) { XmlUtils::CXmlNode oNode; diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/QuadBezTo.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/QuadBezTo.h index 8790ce419b..1501fc3777 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/QuadBezTo.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Path2D/QuadBezTo.h @@ -42,21 +42,52 @@ namespace PPTX class QuadBezTo : public PathBase { public: - PPTX_LOGIC_BASE(QuadBezTo) + WritingElement_AdditionConstructors(QuadBezTo) + PPTX_LOGIC_BASE2(QuadBezTo) QuadBezTo& operator=(const QuadBezTo& oSrc) { parentFile = oSrc.parentFile; parentElement = oSrc.parentElement; - x1 = oSrc.x1; - y1 = oSrc.y1; - x2 = oSrc.x2; - y2 = oSrc.y2; + x[0] = oSrc.x[0]; + y[0] = oSrc.y[0]; + x[1] = oSrc.x[1]; + y[1] = oSrc.y[1]; return (*this); } - public: + virtual OOX::EElementType getType() const + { + return OOX::et_a_quadBezTo; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + if ( oReader.IsEmptyNode() ) + return; + + int count = 0; + + int nParentDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth ) ) + { + std::wstring sName = oReader.GetName(); + + if (sName == L"a:pos") + { + ReadAttributes2(oReader, x[count], y[count]); + count++; + } + } + + } + void ReadAttributes2(XmlUtils::CXmlLiteReader& oReader, std::wstring & x, std::wstring & y) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_Read_if ( oReader, _T("x"), x ) + WritingElement_ReadAttributes_Read_else_if ( oReader, _T("y"), y ) + WritingElement_ReadAttributes_End( oReader ) + } virtual void fromXML(XmlUtils::CXmlNode& node) { XmlUtils::CXmlNodes oNodes; @@ -69,19 +100,19 @@ namespace PPTX XmlUtils::CXmlNode oNode; oNodes.GetAt(0, oNode); - x1 = oNode.GetAttribute(_T("x")); - y1 = oNode.GetAttribute(_T("y")); + x[0] = oNode.GetAttribute(_T("x")); + y[0] = oNode.GetAttribute(_T("y")); oNodes.GetAt(1, oNode); - x2 = oNode.GetAttribute(_T("x")); - y2 = oNode.GetAttribute(_T("y")); + x[1] = oNode.GetAttribute(_T("x")); + y[1] = oNode.GetAttribute(_T("y")); } } } virtual std::wstring toXML() const { - std::wstring str1 = L""; - std::wstring str2 = L""; + std::wstring str1 = L""; + std::wstring str2 = L""; return _T("") + str1 + str2 + _T(""); } @@ -93,15 +124,15 @@ namespace PPTX pWriter->StartNode(_T("a:pt")); pWriter->StartAttributes(); - pWriter->WriteAttribute(_T("x"), x1); - pWriter->WriteAttribute(_T("y"), y1); + pWriter->WriteAttribute(_T("x"), x[0]); + pWriter->WriteAttribute(_T("y"), y[0]); pWriter->EndAttributes(); pWriter->EndNode(_T("a:pt")); pWriter->StartNode(_T("a:pt")); pWriter->StartAttributes(); - pWriter->WriteAttribute(_T("x"), x2); - pWriter->WriteAttribute(_T("y"), y2); + pWriter->WriteAttribute(_T("x"), x[1]); + pWriter->WriteAttribute(_T("y"), y[1]); pWriter->EndAttributes(); pWriter->EndNode(_T("a:pt")); @@ -113,27 +144,25 @@ namespace PPTX pWriter->StartRecord(GEOMETRY_TYPE_PATH_QUADBEZTO); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart); - pWriter->WriteString1(0, x1); - pWriter->WriteString1(1, y1); - pWriter->WriteString1(2, x2); - pWriter->WriteString1(3, y2); + pWriter->WriteString1(0, x[0]); + pWriter->WriteString1(1, y[0]); + pWriter->WriteString1(2, x[1]); + pWriter->WriteString1(3, y[1]); pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd); pWriter->EndRecord(); } public: - std::wstring x1; - std::wstring y1; - std::wstring x2; - std::wstring y2; + std::wstring x[2]; + std::wstring y[2]; protected: virtual void FillParentPointersForChilds(){}; public: virtual std::wstring GetODString()const { - std::wstring str1 = L""; - std::wstring str2 = L""; + std::wstring str1 = L""; + std::wstring str2 = L""; return _T("") + str1 + str2 + _T(""); } diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/PrstGeom.h b/ASCOfficePPTXFile/PPTXFormat/Logic/PrstGeom.h index 3dbbbfa506..eed4f32912 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/PrstGeom.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/PrstGeom.h @@ -44,7 +44,8 @@ namespace PPTX class PrstGeom : public WrapperWritingElement { public: - PPTX_LOGIC_BASE(PrstGeom) + WritingElement_AdditionConstructors(PrstGeom) + PPTX_LOGIC_BASE2(PrstGeom) PrstGeom& operator=(const PrstGeom& oSrc) { @@ -56,8 +57,47 @@ namespace PPTX return *this; } + virtual OOX::EElementType getType() const + { + return OOX::et_a_prstGeom; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + ReadAttributes( oReader ); - public: + if ( oReader.IsEmptyNode() ) + return; + + int nParentDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth ) ) + { + std::wstring sName = oReader.GetName(); + + if (sName == L"a:avLst") + { + int nParentDepth1 = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth1 ) ) + { + std::wstring sName1 = oReader.GetName(); + + if (sName1 == L"a:gd") + { + Gd gd; + avLst.push_back(gd); + avLst.back().fromXML(oReader); + } + } + } + } + + FillParentPointersForChilds(); + } + void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_ReadSingle( oReader, _T("r:prst"), prst) + WritingElement_ReadAttributes_End( oReader ) + } virtual void fromXML(XmlUtils::CXmlNode& node) { node.ReadAttributeBase(L"prst", prst); diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/PrstTxWarp.h b/ASCOfficePPTXFile/PPTXFormat/Logic/PrstTxWarp.h index 6ec391fc10..89deabfde7 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/PrstTxWarp.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/PrstTxWarp.h @@ -44,7 +44,8 @@ namespace PPTX class PrstTxWarp : public WrapperWritingElement { public: - PPTX_LOGIC_BASE(PrstTxWarp) + WritingElement_AdditionConstructors(PrstTxWarp) + PPTX_LOGIC_BASE2(PrstTxWarp) PrstTxWarp& operator=(const PrstTxWarp& oSrc) { @@ -56,8 +57,45 @@ namespace PPTX return *this; } + virtual OOX::EElementType getType () const + { + return OOX::et_a_prstTxWarp; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + ReadAttributes( oReader ); - public: + if ( oReader.IsEmptyNode() ) + return; + + int nCurDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nCurDepth ) ) + { + std::wstring strName = oReader.GetName(); + + if (_T("a:avLst") == strName) + { + int nCurDepth1 = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nCurDepth1 ) ) + { + std::wstring strName1 = oReader.GetName(); + + if (_T("a:gd") == strName1) + { + Gd gd; + avLst.push_back(gd); + avLst.back().fromXML(oReader); + } + } + } + } + } + void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start ( oReader ) + WritingElement_ReadAttributes_ReadSingle ( oReader, _T("prst"), prst ) + WritingElement_ReadAttributes_End ( oReader ) + } virtual void fromXML(XmlUtils::CXmlNode& node) { node.ReadAttributeBase(L"prst", prst); diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Shape.cpp b/ASCOfficePPTXFile/PPTXFormat/Logic/Shape.cpp index 18efe569f7..ba54f5da3e 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Shape.cpp +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Shape.cpp @@ -176,7 +176,7 @@ namespace PPTX if (pWriter->m_lDocType != XMLWRITER_DOC_TYPE_DOCX) { if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX && txBody.is_init()) - txBody->m_ns = _T("xdr"); + txBody->m_name = _T("xdr:txBody"); pWriter->Write(txBody); } @@ -198,7 +198,7 @@ namespace PPTX } else if (txBody.is_init()) { - txBody->m_ns = _T("wps"); + txBody->m_name = _T("wps:txBody"); pWriter->Write(txBody); } @@ -371,7 +371,7 @@ namespace PPTX pWriter->m_pMainDocument->getBinaryContent(strContent, *pWriter, lDataSize); pWriter->EndRecord(); - pWriter->WriteRecord1(5, txBody->bodyPr); + pWriter->WriteRecord2(5, txBody->bodyPr); } } else @@ -597,7 +597,9 @@ namespace PPTX if(!shape.txBody.is_init()) shape.txBody = new TxBody(); - txBody->bodyPr.Merge(shape.txBody->bodyPr); + if (txBody->bodyPr.IsInit()) + txBody->bodyPr->Merge(shape.txBody->bodyPr); + if(txBody->lstStyle.is_init()) { for (int i = 0; i < 10; i++) @@ -738,9 +740,9 @@ namespace PPTX if (txBody.is_init()) { - if (txBody->bodyPr.anchor.is_init()) + if (txBody->bodyPr.IsInit() && txBody->bodyPr->anchor.is_init()) { - std::wstring _strAnchor = txBody->bodyPr.anchor->get(); + std::wstring _strAnchor = txBody->bodyPr->anchor->get(); if (_strAnchor == L"t") oStylesWriter.WriteAttributeCSS(L"v-text-anchor", L"top"); else if (_strAnchor == L"b") diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeProperties.cpp b/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeProperties.cpp index fc00a12607..5bb68842a0 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeProperties.cpp +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeProperties.cpp @@ -65,7 +65,9 @@ namespace PPTX { if(Src.IsInit()) { - Src->bodyPr.Merge(bodyPr); + if (Src->bodyPr.IsInit()) + Src->bodyPr->Merge(bodyPr); + if(Src->lstStyle.IsInit()) { for(int i = 0; i < 10; i++) @@ -753,7 +755,9 @@ namespace PPTX void ShapeProperties::SetParentFilePointer(const WrapperFile* pFile) { - bodyPr.SetParentFilePointer(pFile); + if (bodyPr.IsInit()) + bodyPr->SetParentFilePointer(pFile); + for(int i = 0; i < 10; i ++) { levels[i]->SetParentFilePointer(pFile); @@ -766,45 +770,53 @@ namespace PPTX DWORD ShapeProperties::GetHyperlinkRGBA()const { - if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetRGBAFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetRGBAFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetRGBAFromMap(_T("hlink")); + if (!bodyPr.IsInit()) return 0; + + if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetRGBAFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetRGBAFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetRGBAFromMap(_T("hlink")); else return 0; } DWORD ShapeProperties::GetHyperlinkARGB()const { - if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetARGBFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetARGBFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetARGBFromMap(_T("hlink")); + if (!bodyPr.IsInit()) return 0; + + if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetARGBFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetARGBFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetARGBFromMap(_T("hlink")); else return 0; } DWORD ShapeProperties::GetHyperlinkBGRA()const { - if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetBGRAFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetBGRAFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetBGRAFromMap(_T("hlink")); + if (!bodyPr.IsInit()) return 0; + + if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetBGRAFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetBGRAFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetBGRAFromMap(_T("hlink")); else return 0; } DWORD ShapeProperties::GetHyperlinkABGR()const { - if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetABGRFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetABGRFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetABGRFromMap(_T("hlink")); + if (!bodyPr.IsInit()) return 0; + + if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetABGRFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetABGRFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetABGRFromMap(_T("hlink")); else return 0; } diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeProperties.h b/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeProperties.h index 2ded7a7c7d..f9ee611b2d 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeProperties.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeProperties.h @@ -56,7 +56,7 @@ namespace PPTX nullable fontStyle; nullable levels[10]; nullable masters[10]; - BodyPr bodyPr; + nullable bodyPr; //std::string MajorLatin; //std::string MinorLatin; @@ -80,7 +80,7 @@ namespace PPTX void SetMajorLatin(const TextFont& mjltFont){MajorLatin = mjltFont;}; void SetMinorLatin(const TextFont& mnltFont){MinorLatin = mnltFont;}; - std::wstring GetAnchor()const{return bodyPr.anchor.get_value_or(_T("t"));}; + std::wstring GetAnchor()const{return bodyPr.IsInit() ? bodyPr->anchor.get_value_or(L"t") : L"t";}; std::wstring GetParagraphAlgn (int level, const nullable& pParagraph)const; int GetParagraphLeftMargin (int level, const nullable& pParagraph)const; diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeTextProperties.cpp b/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeTextProperties.cpp index b1104b5ad3..4a265f2b0f 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeTextProperties.cpp +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeTextProperties.cpp @@ -101,7 +101,9 @@ namespace PPTX { if (Src.IsInit()) { - Src->bodyPr.Merge(bodyPr); + if (Src->bodyPr.IsInit()) + Src->bodyPr->Merge(bodyPr); + if (Src->lstStyle.IsInit()) { for(int i = 0; i < 10; i++) @@ -589,48 +591,57 @@ namespace PPTX DWORD CShapeTextProperties::GetHyperlinkRGBA()const { - if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetRGBAFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetRGBAFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetRGBAFromMap(_T("hlink")); + if (!bodyPr.IsInit()) return 0; + + if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetRGBAFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetRGBAFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetRGBAFromMap(_T("hlink")); else return 0; } DWORD CShapeTextProperties::GetHyperlinkARGB()const { - if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetARGBFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetARGBFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetARGBFromMap(_T("hlink")); + if (!bodyPr.IsInit()) return 0; + + if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetARGBFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetARGBFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetARGBFromMap(_T("hlink")); else return 0; } DWORD CShapeTextProperties::GetHyperlinkBGRA()const { - if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetBGRAFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetBGRAFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetBGRAFromMap(_T("hlink")); + if (!bodyPr.IsInit()) return 0; + + if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetBGRAFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetBGRAFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetBGRAFromMap(_T("hlink")); else return 0; } DWORD CShapeTextProperties::GetHyperlinkABGR()const { - if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetABGRFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetABGRFromMap(_T("hlink")); - else if(bodyPr.parentFileIs()) - return bodyPr.parentFileAs().GetABGRFromMap(_T("hlink")); + if (!bodyPr.IsInit()) return 0; + + if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetABGRFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetABGRFromMap(_T("hlink")); + else if(bodyPr->parentFileIs()) + return bodyPr->parentFileAs().GetABGRFromMap(_T("hlink")); else return 0; } void CShapeTextProperties::SetParentFilePointer(const WrapperFile* pFile) { - bodyPr.SetParentFilePointer(pFile); + if (bodyPr.IsInit()) + bodyPr->SetParentFilePointer(pFile); m_pFile = pFile; diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeTextProperties.h b/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeTextProperties.h index 758135843d..fc2494a256 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeTextProperties.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/ShapeTextProperties.h @@ -48,11 +48,11 @@ namespace PPTX class CFontInfo { public: - LONG FontRef; + LONG FontRef; std::wstring strFontName; - std::wstring strPanose; - std::wstring strPitchFamily; - BYTE Charset; + std::wstring strPanose; + std::wstring strPitchFamily; + BYTE Charset; public: CFontInfo() @@ -90,7 +90,7 @@ namespace PPTX LONG m_lTextType; nullable m_levels[10]; nullable m_body[10]; - BodyPr bodyPr; + nullable bodyPr; // просто указатель - он должен выставиться из темы std::vector*>* m_masters; @@ -135,7 +135,7 @@ namespace PPTX return -1; } - std::wstring GetAnchor()const{return bodyPr.anchor.get_value_or(_T("t"));}; + std::wstring GetAnchor()const{return bodyPr.IsInit() ? bodyPr->anchor.get_value_or(L"t") : L"t"; }; nullable_base GetParagraphAlgn (int level, const nullable& pParagraph)const; nullable_base GetParagraphLeftMargin (int level, const nullable& pParagraph)const; diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.cpp b/ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.cpp index 26e37bc96a..6a3c69d2b0 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.cpp +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.cpp @@ -44,26 +44,73 @@ namespace PPTX { Fill.m_type = UniFill::notInit; } - - SpPr::~SpPr() { } - - SpPr::SpPr(XmlUtils::CXmlNode& node) { fromXML(node); } - + SpPr::SpPr(XmlUtils::CXmlLiteReader& oReader) + { + fromXML(oReader); + } const SpPr& SpPr::operator =(XmlUtils::CXmlNode& node) { fromXML(node); return *this; } + const SpPr& SpPr::operator =(XmlUtils::CXmlLiteReader& oReader) + { + fromXML(oReader); + return *this; + } + void SpPr::fromXML(XmlUtils::CXmlLiteReader& oReader) + { + m_namespace = XmlUtils::GetNamespace(oReader.GetName()); + ReadAttributes( oReader ); + if ( oReader.IsEmptyNode() ) + return; + + int nParentDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nParentDepth ) ) + { + std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName()); + + if ( L"xfrm" == sName) + xfrm = oReader; + else if ( L"ln" == sName) + ln = oReader; + else if ( L"scene3d" == sName) + scene3d = oReader; + else if ( L"sp3d" == sName) + sp3d = oReader; + else if ( L"blipFill" == sName || + L"gradFill" == sName || + L"grpFill" == sName || + L"noFill" == sName || + L"pattFill" == sName || + L"solidFill" == sName ) + { + Fill.fromXML(oReader); + } + else if ( L"effectDag" == sName || + L"effectLst" == sName || + L"extLst" == sName ) + { + EffectList.fromXML(oReader); + } + else if ( L"prstGeom" == sName || + L"custGeom" == sName) + { + Geometry.fromXML(oReader); + } + } + FillParentPointersForChilds(); + } void SpPr::fromXML(XmlUtils::CXmlNode& node) { m_namespace = XmlUtils::GetNamespace(node.GetName()); diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.h b/ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.h index 84a028f9e1..4461930529 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.h @@ -57,12 +57,24 @@ namespace PPTX explicit SpPr(XmlUtils::CXmlNode& node); const SpPr& operator =(XmlUtils::CXmlNode& node); + explicit SpPr(XmlUtils::CXmlLiteReader& oReader); + const SpPr& operator =(XmlUtils::CXmlLiteReader& oReader); + virtual OOX::EElementType getType () const { - return OOX::et_p_spPr; + return OOX::et_a_spPr; } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader); virtual void fromXML(XmlUtils::CXmlNode& node); + + void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) + { + WritingElement_ReadAttributes_Start( oReader ) + WritingElement_ReadAttributes_ReadSingle( oReader, _T("bwMode"), bwMode ) + WritingElement_ReadAttributes_End( oReader ) + } + virtual std::wstring toXML() const; virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/Table/TableCell.h b/ASCOfficePPTXFile/PPTXFormat/Logic/Table/TableCell.h index 79c0a6bcca..f01273e37c 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/Table/TableCell.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/Table/TableCell.h @@ -148,7 +148,7 @@ namespace PPTX { txBody = new Logic::TxBody(); txBody->fromPPTY(pReader); - txBody->m_ns = _T("a"); + txBody->m_name = _T("a:txBody"); break; } default: diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/TextListStyle.h b/ASCOfficePPTXFile/PPTXFormat/Logic/TextListStyle.h index 8d1e9c9e52..6db8595768 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/TextListStyle.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/TextListStyle.h @@ -44,9 +44,9 @@ namespace PPTX class TextListStyle : public WrapperWritingElement { public: - PPTX_LOGIC_BASE(TextListStyle) + WritingElement_AdditionConstructors(TextListStyle) + PPTX_LOGIC_BASE2(TextListStyle) - public: virtual void fromXML(XmlUtils::CXmlNode& node) { m_name = node.GetName(); @@ -64,6 +64,44 @@ namespace PPTX FillParentPointersForChilds(); } + virtual OOX::EElementType getType () const + { + return OOX::et_Unknown;//a_bodyStyle; + } + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + m_name = oReader.GetName(); + + if ( oReader.IsEmptyNode() ) + return; + + int nCurDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nCurDepth ) ) + { + std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName()); + + if (_T("defPPr") == strName) + levels[9] = oReader; + else if (_T("lvl1pPr") == strName) + levels[0] = oReader; + else if (_T("lvl2pPr") == strName) + levels[1] = oReader; + else if (_T("lvl3pPr") == strName) + levels[2] = oReader; + else if (_T("lvl4pPr") == strName) + levels[3] = oReader; + else if (_T("lvl5pPr") == strName) + levels[4] = oReader; + else if (_T("lvl6pPr") == strName) + levels[5] = oReader; + else if (_T("lvl7pPr") == strName) + levels[6] = oReader; + else if (_T("lvl8pPr") == strName) + levels[7] = oReader; + else if (_T("lvl9pPr") == strName) + levels[8] = oReader; + } + } virtual std::wstring toXML() const { XmlUtils::CNodeValue oValue; @@ -139,10 +177,8 @@ namespace PPTX levels[i]->Merge(lstStyle->levels[i]); } public: - nullable levels[10]; - //private: - public: - mutable std::wstring m_name; + nullable levels[10]; + mutable std::wstring m_name; protected: virtual void FillParentPointersForChilds() { diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/TxBody.h b/ASCOfficePPTXFile/PPTXFormat/Logic/TxBody.h index 1f5ac4dc40..775e4eb3ca 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/TxBody.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/TxBody.h @@ -49,15 +49,27 @@ namespace PPTX public: TxBody() { - m_ns = _T("p"); + m_name = _T("p:txBody"); } virtual ~TxBody() {} - explicit TxBody(XmlUtils::CXmlNode& node) { fromXML(node); } + explicit TxBody(XmlUtils::CXmlNode& node) + { + fromXML(node); + } const TxBody& operator =(XmlUtils::CXmlNode& node) { fromXML(node); return *this; } + explicit TxBody(XmlUtils::CXmlLiteReader& oReader) + { + fromXML(oReader); + } + const TxBody& operator =(XmlUtils::CXmlLiteReader& oReader) + { + fromXML(oReader); + return *this; + } TxBody(const TxBody& oSrc) { *this = oSrc; } TxBody& operator=(const TxBody& oSrc) @@ -65,20 +77,49 @@ namespace PPTX parentFile = oSrc.parentFile; parentElement = oSrc.parentElement; - bodyPr = oSrc.bodyPr; - lstStyle = oSrc.lstStyle; - Paragrs = oSrc.Paragrs; + bodyPr = oSrc.bodyPr; + lstStyle = oSrc.lstStyle; + Paragrs = oSrc.Paragrs; - m_ns = oSrc.m_ns; + m_name = oSrc.m_name; return *this; } - public: + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + m_name = oReader.GetName(); + + if ( oReader.IsEmptyNode() ) + return; + + int nCurDepth = oReader.GetDepth(); + while( oReader.ReadNextSiblingNode( nCurDepth ) ) + { + std::wstring strName = oReader.GetName(); + if (_T("a:bodyPr") == strName) + { + bodyPr = oReader; + } + else if (_T("a:lstStyle") == strName) + { + lstStyle = oReader; + } + else if (_T("a:p") == strName) + { + Paragraph p; + Paragrs.push_back(p); + Paragrs.back().fromXML(oReader); + } + } + FillParentPointersForChilds(); + } virtual void fromXML(XmlUtils::CXmlNode& node) { Paragrs.clear(); + m_name = node.GetName(); + bodyPr = node.ReadNode(_T("a:bodyPr")); lstStyle = node.ReadNode(_T("a:lstStyle")); @@ -89,22 +130,25 @@ namespace PPTX virtual std::wstring toXML() const { XmlUtils::CNodeValue oValue; - oValue.Write(bodyPr); + + oValue.WriteNullable(bodyPr); oValue.WriteNullable(lstStyle); oValue.WriteArray(Paragrs); - return XmlUtils::CreateNode(_T("p:txBody"), oValue); + return XmlUtils::CreateNode(m_name, oValue); } virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const { - pWriter->StartNode(m_ns + _T(":txBody")); + pWriter->StartNode(m_name); pWriter->EndAttributes(); - bodyPr.m_namespace = _T("a"); - bodyPr.toXmlWriter(pWriter); - - if (lstStyle.is_init()) + if (bodyPr.IsInit()) + { + bodyPr->m_namespace = _T("a"); + bodyPr->toXmlWriter(pWriter); + } + if (lstStyle.IsInit()) lstStyle->m_name = _T("a:lstStyle"); pWriter->Write(lstStyle); @@ -112,7 +156,7 @@ namespace PPTX for (size_t i = 0; i < nCount; ++i) Paragrs[i].toXmlWriter(pWriter); - pWriter->EndNode(m_ns + _T(":txBody")); + pWriter->EndNode(m_name); } void toXmlWriterExcel(NSBinPptxRW::CXmlWriter* pWriter) const @@ -121,9 +165,11 @@ namespace PPTX pWriter->StartNode(_T("c:rich")); pWriter->EndAttributes(); */ - - bodyPr.m_namespace = _T("a"); - bodyPr.toXmlWriter(pWriter); + if (bodyPr.IsInit()) + { + bodyPr->m_namespace = _T("a"); + bodyPr->toXmlWriter(pWriter); + } if (lstStyle.is_init()) lstStyle->m_name = _T("a:lstStyle"); @@ -150,16 +196,18 @@ namespace PPTX void Merge(nullable& txBody)const { - if(!txBody.is_init()) - txBody = new TxBody(); - bodyPr.Merge(txBody->bodyPr); - if(lstStyle.is_init()) + if(!txBody.is_init()) return; + + if(bodyPr.IsInit()) + bodyPr->Merge(txBody->bodyPr); + + if(lstStyle.IsInit()) lstStyle->Merge(txBody->lstStyle); } virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const { - pWriter->WriteRecord1(0, bodyPr); + pWriter->WriteRecord2(0, bodyPr); pWriter->WriteRecord2(1, lstStyle); pWriter->WriteRecordArray(2, 0, Paragrs); } @@ -174,7 +222,8 @@ namespace PPTX { case 0: { - bodyPr.fromPPTY(pReader); + bodyPr = new Logic::BodyPr(); + bodyPr->fromPPTY(pReader); break; } case 1: @@ -206,15 +255,17 @@ namespace PPTX } public: - BodyPr bodyPr; + nullable bodyPr; nullable lstStyle; std::vector Paragrs; - std::wstring m_ns; + std::wstring m_name; protected: virtual void FillParentPointersForChilds() { - bodyPr.SetParentPointer(this); + if(bodyPr.is_init()) + bodyPr->SetParentPointer(this); + if(lstStyle.is_init()) lstStyle->SetParentPointer(this); @@ -226,9 +277,11 @@ namespace PPTX public: bool IsOneLineParagraphs() const { - if (!bodyPr.wrap.is_init()) - return false; - return (bodyPr.wrap->get() == _T("none")); + if (!bodyPr.is_init()) return false; + + if (!bodyPr->wrap.is_init()) return false; + + return (bodyPr->wrap->get() == _T("none")); } std::wstring GetDocxTxBoxContent(NSBinPptxRW::CBinaryFileWriter* pWriter, const nullable& shape_style); diff --git a/ASCOfficePPTXFile/PPTXFormat/Logic/UniPath2D.h b/ASCOfficePPTXFile/PPTXFormat/Logic/UniPath2D.h index 2cb9b2978f..94ab6a956e 100644 --- a/ASCOfficePPTXFile/PPTXFormat/Logic/UniPath2D.h +++ b/ASCOfficePPTXFile/PPTXFormat/Logic/UniPath2D.h @@ -49,9 +49,35 @@ namespace PPTX class UniPath2D : public WrapperWritingElement { public: - PPTX_LOGIC_BASE(UniPath2D) + WritingElement_AdditionConstructors(UniPath2D) + PPTX_LOGIC_BASE2(UniPath2D) - public: + virtual OOX::EElementType getType() const + { + if (Path2D.IsInit()) + return Path2D->getType(); + return OOX::et_Unknown; + } + + virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) + { + std::wstring name = XmlUtils::GetNameNoNS(oReader.GetName()); + + if (name == _T("moveTo")) + Path2D.reset(new Logic::MoveTo(oReader)); + else if (name == _T("lnTo")) + Path2D.reset(new Logic::LineTo(oReader)); + else if (name == _T("cubicBezTo")) + Path2D.reset(new Logic::CubicBezTo(oReader)); + else if (name == _T("close")) + Path2D.reset(new Logic::Close(oReader)); + else if (name == _T("arcTo")) + Path2D.reset(new Logic::ArcTo(oReader)); + else if (name == _T("quadBezTo")) + Path2D.reset(new Logic::QuadBezTo(oReader)); + else Path2D.reset(); + } + virtual void fromXML(XmlUtils::CXmlNode& node) { std::wstring name = XmlUtils::GetNameNoNS(node.GetName()); diff --git a/ASCOfficePPTXFile/PPTXLib/PPTXFormat.vcproj b/ASCOfficePPTXFile/PPTXLib/PPTXFormat.vcproj index 2d47495615..91e2b28e92 100644 --- a/ASCOfficePPTXFile/PPTXLib/PPTXFormat.vcproj +++ b/ASCOfficePPTXFile/PPTXLib/PPTXFormat.vcproj @@ -1,7 +1,7 @@ et_a_lightRig, // et_a_lin, // + et_a_lineTo, // et_a_ln, // et_a_lnDef, // et_a_lnRef, // diff --git a/Common/DocxFormat/Source/XlsxFormat/Chart/ChartSerialize.cpp b/Common/DocxFormat/Source/XlsxFormat/Chart/ChartSerialize.cpp index fe30522863..d12c4f2926 100644 --- a/Common/DocxFormat/Source/XlsxFormat/Chart/ChartSerialize.cpp +++ b/Common/DocxFormat/Source/XlsxFormat/Chart/ChartSerialize.cpp @@ -35,53 +35,6 @@ namespace OOX{ namespace Spreadsheet{ - void FromString_spPr(std::wstring *spPr, nullable & oSpPr) - { - XmlUtils::CXmlLiteReader oReaderLocal; - //сформируем полноценную xml-строку - std::wstring xmlString;// = L""; - xmlString += L""; - xmlString += *spPr; - xmlString += L""; - bool result =oReaderLocal.FromString(xmlString); - - result = oReaderLocal.ReadNextNode();//root ... skiping - result = oReaderLocal.ReadNextNode(); - - std::wstring sName = XmlUtils::GetNameNoNS(oReaderLocal.GetName()); - - if (_T("spPr") == sName) - oSpPr = oReaderLocal; - } - void FromString_txPr(std::wstring *txPr, nullable & oTxPr) - { - XmlUtils::CXmlLiteReader oReaderLocal; - //сформируем полноценную xml-строку - std::wstring xmlString ;//= L""; - xmlString += L""; - xmlString += *txPr; - xmlString += L""; - bool result =oReaderLocal.FromString(xmlString); - - result = oReaderLocal.ReadNextNode();//root ... skiping - - std::wstring sName = XmlUtils::GetNameNoNS(oReaderLocal.GetName()); - - if (_T("txPr") == sName) - oTxPr = oReaderLocal; - } bool FromXml_ST_PageSetupOrientation(std::wstring& val, ST_PageSetupOrientation& eOut) { bool bRes = true; @@ -1043,8 +996,6 @@ namespace OOX{ m_pivotSource = NULL; m_protection = NULL; m_chart = NULL; - m_spPr = NULL; - m_txPr = NULL; m_externalData = NULL; m_printSettings = NULL; m_userShapes = NULL; @@ -1070,10 +1021,6 @@ namespace OOX{ delete m_protection; if(NULL != m_chart) delete m_chart; - if(NULL != m_spPr) - delete m_spPr; - if(NULL != m_txPr) - delete m_txPr; if(NULL != m_externalData) delete m_externalData; if(NULL != m_printSettings) @@ -1147,19 +1094,11 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("txPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetInnerXml(); - *pNewElem = sVal; - m_txPr = pNewElem; - FromString_txPr(m_txPr, m_oTxPr); + m_oTxPr = oReader; } else if(_T("externalData") == sName) { @@ -1236,13 +1175,14 @@ namespace OOX{ std::wstring sNodeName = _T("c:chart"); m_chart->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } - if(NULL != m_txPr) + if (m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } if(NULL != m_externalData) { @@ -2151,7 +2091,6 @@ namespace OOX{ { m_idx = NULL; m_delete = NULL; - m_txPr = NULL; m_extLst = NULL; } CT_LegendEntry::~CT_LegendEntry() @@ -2160,8 +2099,6 @@ namespace OOX{ delete m_idx; if(NULL != m_delete) delete m_delete; - if(NULL != m_txPr) - delete m_txPr; if(NULL != m_extLst) delete m_extLst; } @@ -2186,11 +2123,7 @@ namespace OOX{ } else if(_T("txPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetInnerXml(); - *pNewElem = sVal; - m_txPr = pNewElem; - FromString_txPr(m_txPr, m_oTxPr); + m_oTxPr = oReader; } else if(_T("extLst") == sName) { @@ -2214,9 +2147,10 @@ namespace OOX{ std::wstring sNodeName = _T("c:delete"); m_delete->toXML(sNodeName, writer); } - if(NULL != m_txPr) + if (m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } if(NULL != m_extLst) { @@ -2237,13 +2171,15 @@ namespace OOX{ if(NULL != m_val) delete m_val; } - void CT_UnsignedInt::fromXML(XmlUtils::CXmlLiteReader& oReader){ + void CT_UnsignedInt::fromXML(XmlUtils::CXmlLiteReader& oReader) + { ReadAttributes(oReader); if(!oReader.IsEmptyNode()) oReader.ReadTillEnd(); } - void CT_UnsignedInt::toXML(std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const{ + void CT_UnsignedInt::toXML(std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const + { writer.WriteString(L"<"); writer.WriteString(sNodeName); if(NULL != m_val) @@ -2276,7 +2212,8 @@ namespace OOX{ if(NULL != m_uri) delete m_uri; } - void CT_Extension::fromXML(XmlUtils::CXmlLiteReader& oReader){ + void CT_Extension::fromXML(XmlUtils::CXmlLiteReader& oReader) + { ReadAttributes(oReader); if ( oReader.IsEmptyNode() ) @@ -2377,8 +2314,6 @@ namespace OOX{ m_legendPos = NULL; m_layout = NULL; m_overlay = NULL; - m_spPr = NULL; - m_txPr = NULL; m_extLst = NULL; } CT_Legend::~CT_Legend() @@ -2392,10 +2327,6 @@ namespace OOX{ delete m_layout; if(NULL != m_overlay) delete m_overlay; - if(NULL != m_spPr) - delete m_spPr; - if(NULL != m_txPr) - delete m_txPr; if(NULL != m_extLst) delete m_extLst; } @@ -2432,19 +2363,11 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("txPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetInnerXml(); - *pNewElem = sVal; - m_txPr = pNewElem; - FromString_txPr(m_txPr, m_oTxPr); + m_oTxPr = oReader; } else if(_T("extLst") == sName) { @@ -2454,7 +2377,8 @@ namespace OOX{ } } } - void CT_Legend::toXML(std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const{ + void CT_Legend::toXML(std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const + { writer.WriteString(L"<"); writer.WriteString(sNodeName); writer.WriteString(L">"); @@ -2482,13 +2406,14 @@ namespace OOX{ std::wstring sNodeName = _T("c:overlay"); m_overlay->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } - if(NULL != m_txPr) + if (m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } if(NULL != m_extLst) { @@ -2512,7 +2437,8 @@ namespace OOX{ if(NULL != m_extLst) delete m_extLst; } - void CT_Layout::fromXML(XmlUtils::CXmlLiteReader& oReader){ + void CT_Layout::fromXML(XmlUtils::CXmlLiteReader& oReader) + { if ( oReader.IsEmptyNode() ) return; int nParentDepth = oReader.GetDepth(); @@ -2533,7 +2459,8 @@ namespace OOX{ } } } - void CT_Layout::toXML(std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const{ + void CT_Layout::toXML(std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const + { writer.WriteString(L"<"); writer.WriteString(sNodeName); writer.WriteString(L">"); @@ -2849,8 +2776,6 @@ namespace OOX{ m_showVertBorder = NULL; m_showOutline = NULL; m_showKeys = NULL; - m_spPr = NULL; - m_txPr = NULL; m_extLst = NULL; } CT_DTable::~CT_DTable() @@ -2863,10 +2788,6 @@ namespace OOX{ delete m_showOutline; if(NULL != m_showKeys) delete m_showKeys; - if(NULL != m_spPr) - delete m_spPr; - if(NULL != m_txPr) - delete m_txPr; if(NULL != m_extLst) delete m_extLst; } @@ -2903,19 +2824,11 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("txPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetInnerXml(); - *pNewElem = sVal; - m_txPr = pNewElem; - FromString_txPr(m_txPr, m_oTxPr); + m_oTxPr = oReader; } else if(_T("extLst") == sName) { @@ -2949,13 +2862,14 @@ namespace OOX{ std::wstring sNodeName = _T("c:showKeys"); m_showKeys->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } - if(NULL != m_txPr) + if (m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } if(NULL != m_extLst) { @@ -2980,8 +2894,6 @@ namespace OOX{ m_majorTickMark = NULL; m_minorTickMark = NULL; m_tickLblPos = NULL; - m_spPr = NULL; - m_txPr = NULL; m_crossAx = NULL; m_crosses = NULL; m_crossesAt = NULL; @@ -3013,10 +2925,6 @@ namespace OOX{ delete m_minorTickMark; if(NULL != m_tickLblPos) delete m_tickLblPos; - if(NULL != m_spPr) - delete m_spPr; - if(NULL != m_txPr) - delete m_txPr; if(NULL != m_crossAx) delete m_crossAx; if(NULL != m_crosses) @@ -3105,19 +3013,11 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("txPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetInnerXml(); - *pNewElem = sVal; - m_txPr = pNewElem; - FromString_txPr(m_txPr, m_oTxPr); + m_oTxPr = oReader; } else if(_T("crossAx") == sName) { @@ -3216,13 +3116,14 @@ namespace OOX{ std::wstring sNodeName = _T("c:tickLblPos"); m_tickLblPos->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } - if(NULL != m_txPr) + if (m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } if(NULL != m_crossAx) { @@ -3479,12 +3380,9 @@ namespace OOX{ } CT_ChartLines::CT_ChartLines() { - m_spPr = NULL; } CT_ChartLines::~CT_ChartLines() { - if(NULL != m_spPr) - delete m_spPr; } void CT_ChartLines::fromXML(XmlUtils::CXmlLiteReader& oReader){ if ( oReader.IsEmptyNode() ) @@ -3495,11 +3393,7 @@ namespace OOX{ std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName()); if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } } } @@ -3507,9 +3401,9 @@ namespace OOX{ writer.WriteString(L"<"); writer.WriteString(sNodeName); writer.WriteString(L">"); - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } writer.WriteString(L"toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } - if(NULL != m_txPr) + if (m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } if(NULL != m_extLst) { @@ -3628,13 +3509,10 @@ namespace OOX{ EElementType CT_Title::getType(){return et_ct_title;} CT_Tx::CT_Tx() { - m_rich = NULL; m_strRef = NULL; } CT_Tx::~CT_Tx() { - if(NULL != m_rich) - delete m_rich; if(NULL != m_strRef) delete m_strRef; } @@ -3647,33 +3525,7 @@ namespace OOX{ std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName()); if(_T("rich") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetInnerXml(); - *pNewElem = sVal; - m_rich = pNewElem; - { - nullable oSpPr; - XmlUtils::CXmlLiteReader oReaderLocal; - //сформируем полноценную xml-строку - std::wstring xmlString;// = L""; - xmlString += L""; - xmlString += *m_rich; - xmlString += L""; - bool result =oReaderLocal.FromString(xmlString); - - result = oReaderLocal.ReadNextNode();//root ... skiping - - std::wstring sName = XmlUtils::GetNameNoNS(oReaderLocal.GetName()); - - if (_T("rich") == sName) - m_oRich = oReaderLocal; - } + m_oRich = oReader; } else if(_T("strRef") == sName) { @@ -3687,9 +3539,10 @@ namespace OOX{ writer.WriteString(L"<"); writer.WriteString(sNodeName); writer.WriteString(L">"); - if(NULL != m_rich) + if(m_oRich.IsInit()) { - writer.WriteString(_T("") + *m_rich + _T("")); + m_oRich->m_name = L"c:rich"; + writer.WriteString(m_oRich->toXML()); } if(NULL != m_strRef) { @@ -4190,8 +4043,6 @@ namespace OOX{ m_majorTickMark = NULL; m_minorTickMark = NULL; m_tickLblPos = NULL; - m_spPr = NULL; - m_txPr = NULL; m_crossAx = NULL; m_crosses = NULL; m_crossesAt = NULL; @@ -4228,10 +4079,6 @@ namespace OOX{ delete m_minorTickMark; if(NULL != m_tickLblPos) delete m_tickLblPos; - if(NULL != m_spPr) - delete m_spPr; - if(NULL != m_txPr) - delete m_txPr; if(NULL != m_crossAx) delete m_crossAx; if(NULL != m_crosses) @@ -4330,19 +4177,11 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("txPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetInnerXml(); - *pNewElem = sVal; - m_txPr = pNewElem; - FromString_txPr(m_txPr, m_oTxPr); + m_oTxPr = oReader; } else if(_T("crossAx") == sName) { @@ -4471,13 +4310,14 @@ namespace OOX{ std::wstring sNodeName = _T("c:tickLblPos"); m_tickLblPos->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } - if(NULL != m_txPr) + if (m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } if(NULL != m_crossAx) { @@ -4672,8 +4512,6 @@ namespace OOX{ m_majorTickMark = NULL; m_minorTickMark = NULL; m_tickLblPos = NULL; - m_spPr = NULL; - m_txPr = NULL; m_crossAx = NULL; m_crosses = NULL; m_crossesAt = NULL; @@ -4709,10 +4547,6 @@ namespace OOX{ delete m_minorTickMark; if(NULL != m_tickLblPos) delete m_tickLblPos; - if(NULL != m_spPr) - delete m_spPr; - if(NULL != m_txPr) - delete m_txPr; if(NULL != m_crossAx) delete m_crossAx; if(NULL != m_crosses) @@ -4809,19 +4643,11 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("txPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetInnerXml(); - *pNewElem = sVal; - m_txPr = pNewElem; - FromString_txPr(m_txPr, m_oTxPr); + m_oTxPr = oReader; } else if(_T("crossAx") == sName) { @@ -4944,13 +4770,14 @@ namespace OOX{ std::wstring sNodeName = _T("c:tickLblPos"); m_tickLblPos->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } - if(NULL != m_txPr) + if (m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } if(NULL != m_crossAx) { @@ -5011,8 +4838,6 @@ namespace OOX{ { m_layout = NULL; m_tx = NULL; - m_spPr = NULL; - m_txPr = NULL; } CT_DispUnitsLbl::~CT_DispUnitsLbl() { @@ -5020,10 +4845,6 @@ namespace OOX{ delete m_layout; if(NULL != m_tx) delete m_tx; - if(NULL != m_spPr) - delete m_spPr; - if(NULL != m_txPr) - delete m_txPr; } void CT_DispUnitsLbl::fromXML(XmlUtils::CXmlLiteReader& oReader){ if ( oReader.IsEmptyNode() ) @@ -5046,19 +4867,11 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("txPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetInnerXml(); - *pNewElem = sVal; - m_txPr = pNewElem; - FromString_txPr(m_txPr, m_oTxPr); + m_oTxPr = oReader; } } } @@ -5076,13 +4889,14 @@ namespace OOX{ std::wstring sNodeName = _T("c:tx"); m_tx->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } - if(NULL != m_txPr) + if (m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } writer.WriteString(L"toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } - if(NULL != m_txPr) + if (m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } if(NULL != m_crossAx) { @@ -5666,7 +5467,6 @@ namespace OOX{ m_idx = NULL; m_order = NULL; m_tx = NULL; - m_spPr = NULL; m_invertIfNegative = NULL; m_dLbls = NULL; m_xVal = NULL; @@ -5683,8 +5483,6 @@ namespace OOX{ delete m_order; if(NULL != m_tx) delete m_tx; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_invertIfNegative) delete m_invertIfNegative; for(size_t i = 0; i < m_dPt.size(); ++i) @@ -5736,11 +5534,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("invertIfNegative") == sName) { @@ -5823,9 +5617,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:tx"); m_tx->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_invertIfNegative) { @@ -5958,7 +5752,6 @@ namespace OOX{ m_marker = NULL; m_bubble3D = NULL; m_explosion = NULL; - m_spPr = NULL; m_pictureOptions = NULL; m_extLst = NULL; } @@ -5974,8 +5767,6 @@ namespace OOX{ delete m_bubble3D; if(NULL != m_explosion) delete m_explosion; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_pictureOptions) delete m_pictureOptions; if(NULL != m_extLst) @@ -6020,11 +5811,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("pictureOptions") == sName) { @@ -6069,9 +5856,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:explosion"); m_explosion->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_pictureOptions) { @@ -6092,7 +5879,6 @@ namespace OOX{ { m_symbol = NULL; m_size = NULL; - m_spPr = NULL; m_extLst = NULL; } CT_Marker::~CT_Marker() @@ -6101,8 +5887,6 @@ namespace OOX{ delete m_symbol; if(NULL != m_size) delete m_size; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_extLst) delete m_extLst; } @@ -6127,11 +5911,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("extLst") == sName) { @@ -6155,9 +5935,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:size"); m_size->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_extLst) { @@ -6567,9 +6347,9 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; + PPTX::Logic::SpPr* pNewElem = new PPTX::Logic::SpPr; + pNewElem->fromXML(oReader); + ItemsChoiceType3* eElemtype = new ItemsChoiceType3; *eElemtype = itemschoicetype3SPPR; m_Items.push_back(pNewElem); @@ -6790,10 +6570,10 @@ namespace OOX{ break; case itemschoicetype3SPPR: { - std::wstring* pTypeVal = static_cast(pVal); + PPTX::Logic::SpPr* pTypeVal = static_cast(pVal); if(NULL != pTypeVal) { - writer.WriteString(*pTypeVal); + writer.WriteString(pTypeVal->toXML()); } } break; @@ -6885,7 +6665,7 @@ namespace OOX{ break; case itemschoicetype3SPPR: { - std::wstring* pTypeVal = static_cast(pVal); + PPTX::Logic::SpPr* pTypeVal = static_cast(pVal); RELEASEOBJECT(pTypeVal); } break; @@ -7410,7 +7190,6 @@ namespace OOX{ CT_Trendline::CT_Trendline() { m_name = NULL; - m_spPr = NULL; m_trendlineType = NULL; m_order = NULL; m_period = NULL; @@ -7426,8 +7205,6 @@ namespace OOX{ { if(NULL != m_name) delete m_name; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_trendlineType) delete m_trendlineType; if(NULL != m_order) @@ -7465,11 +7242,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("trendlineType") == sName) { @@ -7546,9 +7319,9 @@ namespace OOX{ writer.WriteEncodeXmlString(*m_name); writer.WriteString(_T("")); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_trendlineType) { @@ -7737,8 +7510,6 @@ namespace OOX{ m_layout = NULL; m_tx = NULL; m_numFmt = NULL; - m_spPr = NULL; - m_txPr = NULL; m_extLst = NULL; } CT_TrendlineLbl::~CT_TrendlineLbl() @@ -7749,10 +7520,6 @@ namespace OOX{ delete m_tx; if(NULL != m_numFmt) delete m_numFmt; - if(NULL != m_spPr) - delete m_spPr; - if(NULL != m_txPr) - delete m_txPr; if(NULL != m_extLst) delete m_extLst; } @@ -7783,19 +7550,11 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("txPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetInnerXml(); - *pNewElem = sVal; - m_txPr = pNewElem; - FromString_txPr(m_txPr, m_oTxPr); + m_oTxPr = oReader; } else if(_T("extLst") == sName) { @@ -7824,13 +7583,14 @@ namespace OOX{ std::wstring sNodeName = _T("c:numFmt"); m_numFmt->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } - if(NULL != m_txPr) + if(m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } if(NULL != m_extLst) { @@ -7851,7 +7611,6 @@ namespace OOX{ m_plus = NULL; m_minus = NULL; m_val = NULL; - m_spPr = NULL; m_extLst = NULL; } CT_ErrBars::~CT_ErrBars() @@ -7870,8 +7629,6 @@ namespace OOX{ delete m_minus; if(NULL != m_val) delete m_val; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_extLst) delete m_extLst; } @@ -7926,11 +7683,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("extLst") == sName) { @@ -7979,9 +7732,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:val"); m_val->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_extLst) { @@ -8996,7 +8749,6 @@ namespace OOX{ m_idx = NULL; m_order = NULL; m_tx = NULL; - m_spPr = NULL; m_cat = NULL; m_val = NULL; m_extLst = NULL; @@ -9009,8 +8761,6 @@ namespace OOX{ delete m_order; if(NULL != m_tx) delete m_tx; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_cat) delete m_cat; if(NULL != m_val) @@ -9045,11 +8795,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("cat") == sName) { @@ -9090,9 +8836,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:tx"); m_tx->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_cat) { @@ -9117,14 +8863,11 @@ namespace OOX{ CT_BandFmt::CT_BandFmt() { m_idx = NULL; - m_spPr = NULL; } CT_BandFmt::~CT_BandFmt() { if(NULL != m_idx) delete m_idx; - if(NULL != m_spPr) - delete m_spPr; } void CT_BandFmt::fromXML(XmlUtils::CXmlLiteReader& oReader){ if ( oReader.IsEmptyNode() ) @@ -9141,11 +8884,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } } } @@ -9158,9 +8897,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:idx"); m_idx->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } writer.WriteString(L"toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_explosion) { @@ -10101,7 +9833,6 @@ namespace OOX{ m_idx = NULL; m_order = NULL; m_tx = NULL; - m_spPr = NULL; m_invertIfNegative = NULL; m_pictureOptions = NULL; m_dLbls = NULL; @@ -10119,8 +9850,6 @@ namespace OOX{ delete m_order; if(NULL != m_tx) delete m_tx; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_invertIfNegative) delete m_invertIfNegative; if(NULL != m_pictureOptions) @@ -10171,11 +9900,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("invertIfNegative") == sName) { @@ -10258,9 +9983,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:tx"); m_tx->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_invertIfNegative) { @@ -10967,7 +10692,6 @@ namespace OOX{ m_idx = NULL; m_order = NULL; m_tx = NULL; - m_spPr = NULL; m_marker = NULL; m_dLbls = NULL; m_xVal = NULL; @@ -10983,8 +10707,6 @@ namespace OOX{ delete m_order; if(NULL != m_tx) delete m_tx; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_marker) delete m_marker; for(size_t i = 0; i < m_dPt.size(); ++i) @@ -11034,11 +10756,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("marker") == sName) { @@ -11115,9 +10833,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:tx"); m_tx->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_marker) { @@ -11346,7 +11064,6 @@ namespace OOX{ m_idx = NULL; m_order = NULL; m_tx = NULL; - m_spPr = NULL; m_marker = NULL; m_dLbls = NULL; m_cat = NULL; @@ -11361,8 +11078,6 @@ namespace OOX{ delete m_order; if(NULL != m_tx) delete m_tx; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_marker) delete m_marker; for(size_t i = 0; i < m_dPt.size(); ++i) @@ -11404,11 +11119,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("marker") == sName) { @@ -11467,9 +11178,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:tx"); m_tx->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_marker) { @@ -11805,7 +11516,6 @@ namespace OOX{ m_idx = NULL; m_order = NULL; m_tx = NULL; - m_spPr = NULL; m_marker = NULL; m_dLbls = NULL; m_errBars = NULL; @@ -11822,8 +11532,6 @@ namespace OOX{ delete m_order; if(NULL != m_tx) delete m_tx; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_marker) delete m_marker; for(size_t i = 0; i < m_dPt.size(); ++i) @@ -11872,11 +11580,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("marker") == sName) { @@ -11953,9 +11657,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:tx"); m_tx->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_marker) { @@ -12097,12 +11801,9 @@ namespace OOX{ EElementType CT_UpDownBars::getType(){return et_ct_updownbars;} CT_UpDownBar::CT_UpDownBar() { - m_spPr = NULL; } CT_UpDownBar::~CT_UpDownBar() { - if(NULL != m_spPr) - delete m_spPr; } void CT_UpDownBar::fromXML(XmlUtils::CXmlLiteReader& oReader){ if ( oReader.IsEmptyNode() ) @@ -12113,11 +11814,7 @@ namespace OOX{ std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName()); if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } } } @@ -12125,9 +11822,9 @@ namespace OOX{ writer.WriteString(L"<"); writer.WriteString(sNodeName); writer.WriteString(L">"); - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } writer.WriteString(L"toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_pictureOptions) { @@ -12992,7 +12682,6 @@ namespace OOX{ { m_layout = NULL; m_dTable = NULL; - m_spPr = NULL; m_extLst = NULL; } CT_PlotArea::~CT_PlotArea() @@ -13013,8 +12702,6 @@ namespace OOX{ m_ItemsElementName1.clear(); if(NULL != m_dTable) delete m_dTable; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_extLst) delete m_extLst; } @@ -13219,11 +12906,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("extLst") == sName) { @@ -13257,9 +12940,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:dTable"); m_dTable->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_extLst) { @@ -13710,7 +13393,6 @@ namespace OOX{ CT_Surface::CT_Surface() { m_thickness = NULL; - m_spPr = NULL; m_pictureOptions = NULL; m_extLst = NULL; } @@ -13718,8 +13400,6 @@ namespace OOX{ { if(NULL != m_thickness) delete m_thickness; - if(NULL != m_spPr) - delete m_spPr; if(NULL != m_pictureOptions) delete m_pictureOptions; if(NULL != m_extLst) @@ -13740,11 +13420,7 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("pictureOptions") == sName) { @@ -13769,9 +13445,9 @@ namespace OOX{ std::wstring sNodeName = _T("c:thickness"); m_thickness->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } if(NULL != m_pictureOptions) { @@ -14118,8 +13794,6 @@ namespace OOX{ CT_PivotFmt::CT_PivotFmt() { m_idx = NULL; - m_spPr = NULL; - m_txPr = NULL; m_marker = NULL; m_dLbl = NULL; m_extLst = NULL; @@ -14128,10 +13802,6 @@ namespace OOX{ { if(NULL != m_idx) delete m_idx; - if(NULL != m_spPr) - delete m_spPr; - if(NULL != m_txPr) - delete m_txPr; if(NULL != m_marker) delete m_marker; if(NULL != m_dLbl) @@ -14154,19 +13824,11 @@ namespace OOX{ } else if(_T("spPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetOuterXml(); - *pNewElem = sVal; - m_spPr = pNewElem; - FromString_spPr(m_spPr, m_oSpPr); + m_oSpPr = oReader; } else if(_T("txPr") == sName) { - std::wstring* pNewElem = new std::wstring; - std::wstring sVal = oReader.GetInnerXml(); - *pNewElem = sVal; - m_txPr = pNewElem; - FromString_txPr(m_txPr, m_oTxPr); + m_oTxPr = oReader; } else if(_T("marker") == sName) { @@ -14197,13 +13859,14 @@ namespace OOX{ std::wstring sNodeName = _T("c:idx"); m_idx->toXML(sNodeName, writer); } - if(NULL != m_spPr) + if (m_oSpPr.IsInit()) { - writer.WriteString(*m_spPr); + writer.WriteString(m_oSpPr->toXML()); } - if(NULL != m_txPr) + if (m_oTxPr.IsInit()) { - writer.WriteString(_T("") + *m_txPr + _T("")); + m_oTxPr->m_name = L"c:txPr"; + writer.WriteString(m_oTxPr->toXML()); } if(NULL != m_marker) { diff --git a/Common/DocxFormat/Source/XlsxFormat/Chart/ChartSerialize.h b/Common/DocxFormat/Source/XlsxFormat/Chart/ChartSerialize.h index 6c710343c7..8127a06eb5 100644 --- a/Common/DocxFormat/Source/XlsxFormat/Chart/ChartSerialize.h +++ b/Common/DocxFormat/Source/XlsxFormat/Chart/ChartSerialize.h @@ -469,39 +469,27 @@ namespace OOX{ class CT_ChartSpace { public: - //Member - CT_Boolean* m_date1904; - //Member - CT_TextLanguageID* m_lang; - //Member - CT_Boolean* m_roundedCorners; - //Member - AlternateContent* m_AlternateContent; - //Member - CT_Style1* m_style; - //Member - std::wstring* m_clrMapOvr; - //Member - CT_PivotSource* m_pivotSource; - //Member - CT_Protection* m_protection; - //Member - CT_Chart* m_chart; - //Member - std::wstring *m_spPr; - nullable m_oSpPr; - std::wstring *m_txPr; - nullable m_oTxPr; - //Member - CT_ExternalData* m_externalData; - //Member - CT_PrintSettings* m_printSettings; - //Member - CT_RelId* m_userShapes; - //Member - CT_extLst* m_extLst; + CT_Boolean* m_date1904; + CT_TextLanguageID* m_lang; + CT_Boolean* m_roundedCorners; + AlternateContent* m_AlternateContent; + CT_Style1* m_style; + std::wstring* m_clrMapOvr; + CT_PivotSource* m_pivotSource; + CT_Protection* m_protection; + CT_Chart* m_chart; + + nullable m_oSpPr; + nullable m_oTxPr; + + CT_ExternalData* m_externalData; + CT_PrintSettings* m_printSettings; + CT_RelId* m_userShapes; + CT_extLst* m_extLst; + CT_ChartSpace(); ~CT_ChartSpace(); + void fromXML(XmlUtils::CXmlLiteReader& oReader); void toXML(const std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const; EElementType getType(); @@ -656,14 +644,11 @@ namespace OOX{ class CT_LegendEntry { public: - //Member - CT_UnsignedInt* m_idx; - //Member - CT_Boolean* m_delete; - //Member - std::wstring *m_txPr; - nullable m_oTxPr; - CT_extLst* m_extLst; + CT_UnsignedInt* m_idx; + CT_Boolean* m_delete; + nullable m_oTxPr; + CT_extLst* m_extLst; + CT_LegendEntry(); ~CT_LegendEntry(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -712,13 +697,11 @@ namespace OOX{ { public: CT_LegendPos *m_legendPos; - std::vector m_legendEntry; + std::vector m_legendEntry; CT_Layout *m_layout; CT_Boolean *m_overlay; - std::wstring *m_spPr; - nullable m_oSpPr; - std::wstring *m_txPr; - nullable m_oTxPr; + nullable m_oSpPr; + nullable m_oTxPr; CT_extLst * m_extLst; /*--------------------------------------------------*/ CT_Legend(); @@ -808,19 +791,14 @@ namespace OOX{ class CT_DTable { public: - //Member CT_Boolean* m_showHorzBorder; - //Member CT_Boolean* m_showVertBorder; - //Member CT_Boolean* m_showOutline; - //Member CT_Boolean* m_showKeys; - std::wstring *m_spPr; - nullable m_oSpPr; - std::wstring *m_txPr; - nullable m_oTxPr; - CT_extLst* m_extLst; + nullable m_oSpPr; + nullable m_oTxPr; + CT_extLst* m_extLst; + CT_DTable(); ~CT_DTable(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -841,10 +819,8 @@ namespace OOX{ CT_TickMark *m_majorTickMark; CT_TickMark *m_minorTickMark; CT_TickLblPos *m_tickLblPos; - std::wstring *m_spPr; - nullable m_oSpPr; - std::wstring *m_txPr; - nullable m_oTxPr; + nullable m_oSpPr; + nullable m_oTxPr; CT_UnsignedInt *m_crossAx; CT_Crosses *m_crosses; CT_Double *m_crossesAt; @@ -916,8 +892,7 @@ namespace OOX{ class CT_ChartLines { public: - std::wstring *m_spPr; - nullable m_oSpPr; + nullable m_oSpPr; /*--------------------------------------------------------------*/ CT_ChartLines(); ~CT_ChartLines(); @@ -928,14 +903,12 @@ namespace OOX{ class CT_Title { public: - CT_Tx *m_tx; - CT_Layout *m_layout; - CT_Boolean *m_overlay; - std::wstring *m_spPr; - nullable m_oSpPr; - std::wstring *m_txPr; - nullable m_oTxPr; - CT_extLst *m_extLst; + CT_Tx *m_tx; + CT_Layout *m_layout; + CT_Boolean *m_overlay; + nullable m_oSpPr; + nullable m_oTxPr; + CT_extLst *m_extLst; /*--------------------------------------------------------------*/ CT_Title(); ~CT_Title(); @@ -944,126 +917,13 @@ namespace OOX{ EElementType getType(); }; //-------------------------------------------------------------------------------- - // 21.2.2.156 rich (Rich Text) - //-------------------------------------------------------------------------------- - class CRichText : public WritingElementWithChilds - { - public: - WritingElementSpreadsheet_AdditionConstructors(CRichText) - CRichText() - { - } - virtual ~CRichText() - { - } - - public: - virtual std::wstring toXML() const - { - return _T(""); - } - virtual void toXML(NSStringUtils::CStringBuilder& writer) const - { - } - virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) - { - ReadAttributes( oReader ); - - if ( oReader.IsEmptyNode() ) - return; - - int nCurDepth = oReader.GetDepth(); - while( oReader.ReadNextSiblingNode( nCurDepth ) ) - { - std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName()); - - if ( _T("bodyPr") == sName ) - m_oBodyPr = oReader; - else if ( _T("p") == sName ) - m_arrItems.push_back( new Drawing::CParagraph( oReader )); - } - } - - virtual EElementType getType () const - { - return et_ChartRichText; - } - - private: - void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) - { - WritingElement_ReadAttributes_Start ( oReader ) - WritingElement_ReadAttributes_End ( oReader ) - } - public: - nullable m_oBodyPr; - //nullable m_oLstStyle; - not supported. - }; - //-------------------------------------------------------------------------------- - // 21.2.2.216 txPr (Text Properties) - //-------------------------------------------------------------------------------- - class CTextProperties : public WritingElementWithChilds - { - public: - WritingElementSpreadsheet_AdditionConstructors(CTextProperties) - CTextProperties() - { - } - virtual ~CTextProperties() - { - } - - public: - virtual std::wstring toXML() const - { - return _T(""); - } - virtual void toXML(NSStringUtils::CStringBuilder& writer) const - { - } - virtual void fromXML(XmlUtils::CXmlLiteReader& oReader) - { - ReadAttributes( oReader ); - - if ( oReader.IsEmptyNode() ) - return; - - int nCurDepth = oReader.GetDepth(); - while( oReader.ReadNextSiblingNode( nCurDepth ) ) - { - std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName()); - - if ( _T("bodyPr") == sName ) - m_oBodyPr = oReader; - else if ( _T("p") == sName ) - m_arrItems.push_back( new Drawing::CParagraph( oReader )); - } - } - - virtual EElementType getType () const - { - return et_ChartTextProperties; - } - - private: - void ReadAttributes(XmlUtils::CXmlLiteReader& oReader) - { - WritingElement_ReadAttributes_Start ( oReader ) - WritingElement_ReadAttributes_End ( oReader ) - } - public: - nullable m_oBodyPr; - //nullable m_oLstStyle; - not supported. - }; - //-------------------------------------------------------------------------------- // 21.2.2.214 tx (Chart Text) //-------------------------------------------------------------------------------- class CT_Tx { public: - std::wstring *m_rich; - nullable m_oRich; - CT_StrRef *m_strRef; + nullable m_oRich; + CT_StrRef *m_strRef; /*--------------------------------------------------------------*/ CT_Tx(); ~CT_Tx(); @@ -1190,55 +1050,31 @@ namespace OOX{ class CT_DateAx { public: - //Member - CT_UnsignedInt* m_axId; - //Member - CT_Scaling* m_scaling; - //Member - CT_Boolean* m_delete; - //Member - CT_AxPos* m_axPos; - //Member - CT_ChartLines* m_majorGridlines; - //Member - CT_ChartLines* m_minorGridlines; - //Member - CT_Title* m_title; - //Member - CT_NumFmt* m_numFmt; - //Member - CT_TickMark* m_majorTickMark; - //Member - CT_TickMark* m_minorTickMark; - //Member - CT_TickLblPos* m_tickLblPos; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; - std::wstring *m_txPr; - nullable m_oTxPr; - //Member - CT_UnsignedInt* m_crossAx; - //Member - CT_Crosses* m_crosses; - //Member - CT_Double* m_crossesAt; - //Member - CT_Boolean* m_auto; - //Member - CT_LblOffset* m_lblOffset; - //Member - CT_TimeUnit* m_baseTimeUnit; - //Member - CT_AxisUnit* m_majorUnit; - //Member - CT_TimeUnit* m_majorTimeUnit; - //Member - CT_AxisUnit* m_minorUnit; - //Member - CT_TimeUnit* m_minorTimeUnit; - //Member - CT_extLst* m_extLst; + CT_UnsignedInt* m_axId; + CT_Scaling* m_scaling; + CT_Boolean* m_delete; + CT_AxPos* m_axPos; + CT_ChartLines* m_majorGridlines; + CT_ChartLines* m_minorGridlines; + CT_Title* m_title; + CT_NumFmt* m_numFmt; + CT_TickMark* m_majorTickMark; + CT_TickMark* m_minorTickMark; + CT_TickLblPos* m_tickLblPos; + nullable m_oSpPr; + nullable m_oTxPr; + CT_UnsignedInt* m_crossAx; + CT_Crosses* m_crosses; + CT_Double* m_crossesAt; + CT_Boolean* m_auto; + CT_LblOffset* m_lblOffset; + CT_TimeUnit* m_baseTimeUnit; + CT_AxisUnit* m_majorUnit; + CT_TimeUnit* m_majorTimeUnit; + CT_AxisUnit* m_minorUnit; + CT_TimeUnit* m_minorTimeUnit; + CT_extLst* m_extLst; + CT_DateAx(); ~CT_DateAx(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -1306,12 +1142,8 @@ namespace OOX{ CT_TickMark* m_minorTickMark; //Member CT_TickLblPos* m_tickLblPos; - //Member - std::wstring *m_spPr; - nullable m_oSpPr; - std::wstring *m_txPr; - nullable m_oTxPr; - //Member + nullable m_oSpPr; + nullable m_oTxPr; CT_UnsignedInt* m_crossAx; //Member CT_Crosses* m_crosses; @@ -1340,17 +1172,14 @@ namespace OOX{ class CT_DispUnitsLbl { public: - //Member - CT_Layout* m_layout; - //Member - CT_Tx* m_tx; - //Member - std::wstring *m_spPr; - nullable m_oSpPr; - std::wstring *m_txPr; - nullable m_oTxPr; + CT_Layout* m_layout; + CT_Tx* m_tx; + nullable m_oSpPr; + nullable m_oTxPr; + CT_DispUnitsLbl(); ~CT_DispUnitsLbl(); + void fromXML(XmlUtils::CXmlLiteReader& oReader); void toXML(std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const; EElementType getType(); @@ -1399,51 +1228,31 @@ namespace OOX{ class CT_ValAx { public: - //Member - CT_UnsignedInt* m_axId; - //Member - CT_Scaling* m_scaling; - //Member - CT_Boolean* m_delete; - //Member - CT_AxPos* m_axPos; - //Member - CT_ChartLines* m_majorGridlines; - //Member - CT_ChartLines* m_minorGridlines; - //Member - CT_Title* m_title; - //Member - CT_NumFmt* m_numFmt; - //Member - CT_TickMark* m_majorTickMark; - //Member - CT_TickMark* m_minorTickMark; - //Member - CT_TickLblPos* m_tickLblPos; - //Member - std::wstring *m_spPr; - nullable m_oSpPr; - std::wstring *m_txPr; - nullable m_oTxPr; - //Member - CT_UnsignedInt* m_crossAx; - //Member - CT_Crosses* m_crosses; - //Member - CT_Double* m_crossesAt; - //Member - CT_CrossBetween* m_crossBetween; - //Member - CT_AxisUnit* m_majorUnit; - //Member - CT_AxisUnit* m_minorUnit; - //Member - CT_DispUnits* m_dispUnits; - //Member - CT_extLst* m_extLst; + CT_UnsignedInt* m_axId; + CT_Scaling* m_scaling; + CT_Boolean* m_delete; + CT_AxPos* m_axPos; + CT_ChartLines* m_majorGridlines; + CT_ChartLines* m_minorGridlines; + CT_Title* m_title; + CT_NumFmt* m_numFmt; + CT_TickMark* m_majorTickMark; + CT_TickMark* m_minorTickMark; + CT_TickLblPos* m_tickLblPos; + nullable m_oSpPr; + nullable m_oTxPr; + CT_UnsignedInt* m_crossAx; + CT_Crosses* m_crosses; + CT_Double* m_crossesAt; + CT_CrossBetween* m_crossBetween; + CT_AxisUnit* m_majorUnit; + CT_AxisUnit* m_minorUnit; + CT_DispUnits* m_dispUnits; + CT_extLst* m_extLst; + CT_ValAx(); ~CT_ValAx(); + void fromXML(XmlUtils::CXmlLiteReader& oReader); void toXML(std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const; EElementType getType(); @@ -1475,15 +1284,10 @@ namespace OOX{ class CT_BubbleSer { public: - //Member CT_UnsignedInt* m_idx; - //Member CT_UnsignedInt* m_order; - //Member - CT_SerTx* m_tx; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; + CT_SerTx* m_tx; + nullable m_oSpPr; //Member CT_Boolean* m_invertIfNegative; //Member @@ -1526,23 +1330,15 @@ namespace OOX{ class CT_DPt { public: - //Member - CT_UnsignedInt* m_idx; - //Member - CT_Boolean* m_invertIfNegative; - //Member - CT_Marker* m_marker; - //Member - CT_Boolean* m_bubble3D; - //Member - CT_UnsignedInt* m_explosion; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; - //Member - CT_PictureOptions* m_pictureOptions; - //Member - CT_extLst* m_extLst; + CT_UnsignedInt* m_idx; + CT_Boolean* m_invertIfNegative; + CT_Marker* m_marker; + CT_Boolean* m_bubble3D; + CT_UnsignedInt* m_explosion; + nullable m_oSpPr; + CT_PictureOptions* m_pictureOptions; + CT_extLst* m_extLst; + CT_DPt(); ~CT_DPt(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -1552,15 +1348,11 @@ namespace OOX{ class CT_Marker { public: - //Member - CT_MarkerStyle* m_symbol; - //Member - CT_MarkerSize* m_size; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; - //Member - CT_extLst* m_extLst; + CT_MarkerStyle* m_symbol; + CT_MarkerSize* m_size; + nullable m_oSpPr; + CT_extLst* m_extLst; + CT_Marker(); ~CT_Marker(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -1637,14 +1429,11 @@ namespace OOX{ class CT_DLbls { public: - //Member - std::vector m_dLbl; - //Member - std::vector m_ItemsElementName0; - //Member - std::vector m_Items; - //Member - CT_extLst* m_extLst; + std::vector m_dLbl; + std::vector m_ItemsElementName0; + std::vector m_Items; + CT_extLst* m_extLst; + CT_DLbls(); ~CT_DLbls(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -1687,13 +1476,9 @@ namespace OOX{ class CT_Trendline { public: - //Member - std::wstring* m_name; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; - //Member - CT_TrendlineType* m_trendlineType; + std::wstring* m_name; + nullable m_oSpPr; + CT_TrendlineType* m_trendlineType; //Member CT_Order* m_order; //Member @@ -1757,19 +1542,16 @@ namespace OOX{ class CT_TrendlineLbl { public: - //Member - CT_Layout* m_layout; - //Member - CT_Tx* m_tx; - //Member - CT_NumFmt* m_numFmt; - std::wstring *m_spPr; - nullable m_oSpPr; - std::wstring *m_txPr; - nullable m_oTxPr; - CT_extLst* m_extLst; + CT_Layout* m_layout; + CT_Tx* m_tx; + CT_NumFmt* m_numFmt; + nullable m_oSpPr; + nullable m_oTxPr; + CT_extLst* m_extLst; + CT_TrendlineLbl(); ~CT_TrendlineLbl(); + void fromXML(XmlUtils::CXmlLiteReader& oReader); void toXML(std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const; EElementType getType(); @@ -1791,11 +1573,9 @@ namespace OOX{ CT_NumDataSource* m_minus; //Member CT_Double* m_val; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; - //Member - CT_extLst* m_extLst; + nullable m_oSpPr; + CT_extLst* m_extLst; + CT_ErrBars(); ~CT_ErrBars(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -2019,21 +1799,14 @@ namespace OOX{ class CT_SurfaceSer { public: - //Member - CT_UnsignedInt* m_idx; - //Member - CT_UnsignedInt* m_order; - //Member - CT_SerTx* m_tx; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; - //Member - CT_AxDataSource* m_cat; - //Member - CT_NumDataSource* m_val; - //Member - CT_extLst* m_extLst; + CT_UnsignedInt* m_idx; + CT_UnsignedInt* m_order; + CT_SerTx* m_tx; + nullable m_oSpPr; + CT_AxDataSource* m_cat; + CT_NumDataSource* m_val; + CT_extLst* m_extLst; + CT_SurfaceSer(); ~CT_SurfaceSer(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -2043,11 +1816,9 @@ namespace OOX{ class CT_BandFmt { public: - //Member - CT_UnsignedInt* m_idx; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; + CT_UnsignedInt* m_idx; + nullable m_oSpPr; + CT_BandFmt(); ~CT_BandFmt(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -2154,17 +1925,11 @@ namespace OOX{ class CT_PieSer { public: - //Member - CT_UnsignedInt* m_idx; - //Member - CT_UnsignedInt* m_order; - //Member - CT_SerTx* m_tx; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; - //Member - CT_UnsignedInt* m_explosion; + CT_UnsignedInt* m_idx; + CT_UnsignedInt* m_order; + CT_SerTx* m_tx; + nullable m_oSpPr; + CT_UnsignedInt* m_explosion; //Member std::vector m_dPt; //Member @@ -2254,10 +2019,8 @@ namespace OOX{ //Member CT_UnsignedInt* m_order; //Member - CT_SerTx* m_tx; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; + CT_SerTx* m_tx; + nullable m_oSpPr; //Member CT_Boolean* m_invertIfNegative; //Member @@ -2427,9 +2190,7 @@ namespace OOX{ CT_UnsignedInt* m_order; //Member CT_SerTx* m_tx; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; + nullable m_oSpPr; //Member CT_Marker* m_marker; //Member @@ -2495,10 +2256,8 @@ namespace OOX{ //Member CT_UnsignedInt* m_order; //Member - CT_SerTx* m_tx; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; + CT_SerTx* m_tx; + nullable m_oSpPr; //Member CT_Marker* m_marker; //Member @@ -2581,10 +2340,8 @@ namespace OOX{ //Member CT_UnsignedInt* m_order; //Member - CT_SerTx* m_tx; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; + CT_SerTx* m_tx; + nullable m_oSpPr; //Member CT_Marker* m_marker; //Member @@ -2612,14 +2369,11 @@ namespace OOX{ class CT_UpDownBars { public: - //Member - CT_GapAmount* m_gapWidth; - //Member - CT_UpDownBar* m_upBars; - //Member - CT_UpDownBar* m_downBars; - //Member - CT_extLst* m_extLst; + CT_GapAmount* m_gapWidth; + CT_UpDownBar* m_upBars; + CT_UpDownBar* m_downBars; + CT_extLst* m_extLst; + CT_UpDownBars(); ~CT_UpDownBars(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -2629,9 +2383,8 @@ namespace OOX{ class CT_UpDownBar { public: - //Member - std::wstring* m_spPr; - nullable m_oSpPr; + nullable m_oSpPr; + CT_UpDownBar(); ~CT_UpDownBar(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -2740,9 +2493,7 @@ namespace OOX{ CT_UnsignedInt* m_order; //Member CT_SerTx* m_tx; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; + nullable m_oSpPr; //Member CT_PictureOptions* m_pictureOptions; //Member @@ -2803,9 +2554,7 @@ namespace OOX{ std::vector m_Items1; //Member CT_DTable* m_dTable; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; + nullable m_oSpPr; //Member CT_extLst* m_extLst; CT_PlotArea(); @@ -2833,15 +2582,11 @@ namespace OOX{ class CT_Surface { public: - //Member - CT_Thickness* m_thickness; - //Member - std::wstring* m_spPr; - nullable m_oSpPr; - //Member - CT_PictureOptions* m_pictureOptions; - //Member - CT_extLst* m_extLst; + CT_Thickness* m_thickness; + nullable m_oSpPr; + CT_PictureOptions* m_pictureOptions; + CT_extLst* m_extLst; + CT_Surface(); ~CT_Surface(); void fromXML(XmlUtils::CXmlLiteReader& oReader); @@ -2934,20 +2679,16 @@ namespace OOX{ class CT_PivotFmt { public: - //Member - CT_UnsignedInt* m_idx; - std::wstring *m_spPr; - nullable m_oSpPr; - std::wstring *m_txPr; - nullable m_oTxPr; - //Member - CT_Marker* m_marker; - //Member - CT_DLbl* m_dLbl; - //Member - CT_extLst* m_extLst; + CT_UnsignedInt* m_idx; + nullable m_oSpPr; + nullable m_oTxPr; + CT_Marker* m_marker; + CT_DLbl* m_dLbl; + CT_extLst* m_extLst; + CT_PivotFmt(); ~CT_PivotFmt(); + void fromXML(XmlUtils::CXmlLiteReader& oReader); void toXML(std::wstring& sNodeName, NSStringUtils::CStringBuilder& writer) const; EElementType getType(); diff --git a/Common/DocxFormat/Source/XlsxFormat/CommonInclude.h b/Common/DocxFormat/Source/XlsxFormat/CommonInclude.h index 3d138c0ba5..4ef7b66acc 100644 --- a/Common/DocxFormat/Source/XlsxFormat/CommonInclude.h +++ b/Common/DocxFormat/Source/XlsxFormat/CommonInclude.h @@ -41,6 +41,9 @@ #include "../DocxFormat/Drawing/DrawingTextProperties.h" #include "../DocxFormat/Drawing/DrawingParagraph.h" +#include "../../../../ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.h" +#include "../../../../ASCOfficePPTXFile/PPTXFormat/Logic/TxBody.h" + #include "ComplexTypes_Spreadsheet.h" #include "FileTypes_Spreadsheet.h" #include "WritingElement.h" diff --git a/X2tConverter/test/win32Test/X2tTest.vcproj b/X2tConverter/test/win32Test/X2tTest.vcproj index e1e1d53c19..4c18109d72 100644 --- a/X2tConverter/test/win32Test/X2tTest.vcproj +++ b/X2tConverter/test/win32Test/X2tTest.vcproj @@ -1,7 +1,7 @@ + + + + + + + + + + + + @@ -397,10 +425,6 @@ RelativePath="..\..\..\XlsxSerializerCom\Writer\BinaryCommonReader.h" > - - @@ -433,30 +457,6 @@ RelativePath="..\..\..\XlsxSerializerCom\Reader\BinaryWriter.h" > - - - - - - - - - - diff --git a/XlsxSerializerCom/Reader/ChartFromToBinary.cpp b/XlsxSerializerCom/Reader/ChartFromToBinary.cpp index 88e23e182b..2d00dcb202 100644 --- a/XlsxSerializerCom/Reader/ChartFromToBinary.cpp +++ b/XlsxSerializerCom/Reader/ChartFromToBinary.cpp @@ -854,22 +854,6 @@ namespace BinXlsxRW } return pNewElem; } - std::wstring* BinaryChartReader::GetTxBodyXml(long length) - { - std::wstring* pNewElem = new std::wstring; - if(length > 0) - { - long nCurPos = m_oBufferedStream.GetPos(); - std::wstring sXml; - HRESULT hRes = m_pOfficeDrawingConverter->GetTxBodyXml(nCurPos, sXml); - if (S_OK == hRes) - { - *pNewElem = sXml; - } - m_oBufferedStream.Seek(nCurPos + length); - } - return pNewElem; - } int BinaryChartReader::ReadCT_extLst(BYTE type, long length, void* poResult) { int res = c_oSerConstants::ReadOk; @@ -946,11 +930,13 @@ namespace BinXlsxRW } else if(c_oserct_chartspaceSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_chartspaceTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } //else if(c_oserct_chartspaceEXTERNALDATA == type) //{ @@ -1022,6 +1008,38 @@ namespace BinXlsxRW res = c_oSerConstants::ReadUnknown; return res; } + int BinaryChartReader::ReadCT_SpPr(BYTE type, long length, void* poResult) + { + int res = c_oSerConstants::ReadOk; + PPTX::Logic::SpPr* poVal = static_cast(poResult); + if(length > 0) + { + poVal->m_namespace = L"c"; + long nCurPos = m_oBufferedStream.GetPos(); + + BYTE typeRec1 = m_oBufferedStream.GetUChar(); + poVal->fromPPTY(&m_oBufferedStream); + + m_oBufferedStream.Seek(nCurPos + length); + } + return res; + } + int BinaryChartReader::ReadCT_TxPr(BYTE type, long length, void* poResult) + { + int res = c_oSerConstants::ReadOk; + PPTX::Logic::TxBody* poVal = static_cast(poResult); + if(length > 0) + { + poVal->m_name = L"c:txPr"; + long nCurPos = m_oBufferedStream.GetPos(); + + BYTE typeRec1 = m_oBufferedStream.GetUChar(); + poVal->fromPPTY(&m_oBufferedStream); + + m_oBufferedStream.Seek(nCurPos + length); + } + return res; + } int BinaryChartReader::ReadCT_RelId(long length, CT_RelId* poResult) { return Read1(length, &BinaryChartReader::ReadCT_RelId, this, poResult); @@ -1302,7 +1320,8 @@ namespace BinXlsxRW } else if(c_oserct_legendentryTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } else if(c_oserct_legendentryEXTLST == type) { @@ -1393,11 +1412,13 @@ namespace BinXlsxRW } else if(c_oserct_legendSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_legendTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } else if(c_oserct_legendEXTLST == type) { @@ -1571,11 +1592,13 @@ namespace BinXlsxRW } else if(c_oserct_dtableSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_dtableTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } else if(c_oserct_dtableEXTLST == type) { @@ -1659,11 +1682,13 @@ namespace BinXlsxRW } else if(c_oserct_seraxSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_seraxTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } else if(c_oserct_seraxCROSSAX == type) { @@ -1793,7 +1818,8 @@ namespace BinXlsxRW CT_ChartLines* poVal = static_cast(poResult); if(c_oserct_chartlinesSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else res = c_oSerConstants::ReadUnknown; @@ -1823,11 +1849,13 @@ namespace BinXlsxRW } else if(c_oserct_titleSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_titleTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } else if(c_oserct_titleEXTLST == type) { @@ -1845,7 +1873,10 @@ namespace BinXlsxRW CT_Tx* poVal = static_cast(poResult); if(c_oserct_txRICH == type) { - poVal->m_rich = GetTxBodyXml(length); + poVal->m_oRich = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oRich.GetPointer()); + + poVal->m_oRich->m_name = L"c:rich"; } else if(c_oserct_txSTRREF == type) { @@ -2095,11 +2126,13 @@ namespace BinXlsxRW } else if(c_oserct_dateaxSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_dateaxTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } else if(c_oserct_dateaxCROSSAX == type) { @@ -2286,11 +2319,13 @@ namespace BinXlsxRW } else if(c_oserct_cataxSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_cataxTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } else if(c_oserct_cataxCROSSAX == type) { @@ -2374,11 +2409,13 @@ namespace BinXlsxRW } else if(c_oserct_dispunitslblSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_dispunitslblTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } else res = c_oSerConstants::ReadUnknown; @@ -2518,11 +2555,13 @@ namespace BinXlsxRW } else if(c_oserct_valaxSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_valaxTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } else if(c_oserct_valaxCROSSAX == type) { @@ -2629,7 +2668,8 @@ namespace BinXlsxRW } else if(c_oserct_bubbleserSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_bubbleserINVERTIFNEGATIVE == type) { @@ -2751,7 +2791,8 @@ namespace BinXlsxRW } else if(c_oserct_dptSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_dptPICTUREOPTIONS == type) { @@ -2787,7 +2828,8 @@ namespace BinXlsxRW } else if(c_oserct_markerSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_markerEXTLST == type) { @@ -3008,24 +3050,31 @@ namespace BinXlsxRW { CT_Boolean* pNewElem = new CT_Boolean; res = Read1(length, &BinaryChartReader::ReadCT_Boolean, this, pNewElem); + poVal->m_Items.push_back(pNewElem); + ItemsChoiceType3* eElemtype = new ItemsChoiceType3; *eElemtype = itemschoicetype3SHOWVAL; poVal->m_ItemsElementName0.push_back(eElemtype); - poVal->m_Items.push_back(pNewElem); } else if(c_oserct_dlblsSPPR == type) { ItemsChoiceType3* eElemtype = new ItemsChoiceType3; *eElemtype = itemschoicetype3SPPR; poVal->m_ItemsElementName0.push_back(eElemtype); - poVal->m_Items.push_back(GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR)); + + PPTX::Logic::SpPr * pNewElem = new PPTX::Logic::SpPr(); + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, pNewElem); + poVal->m_Items.push_back(pNewElem); } else if(c_oserct_dlblsTXPR == type) { ItemsChoiceType3* eElemtype = new ItemsChoiceType3; *eElemtype = itemschoicetype3TXPR; poVal->m_ItemsElementName0.push_back(eElemtype); - poVal->m_Items.push_back(GetTxBodyXml(length)); + + PPTX::Logic::TxBody * pNewElem = new PPTX::Logic::TxBody(); + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, pNewElem); + poVal->m_Items.push_back(pNewElem); } else if(c_oserct_dlblsEXTLST == type) { @@ -3151,7 +3200,10 @@ namespace BinXlsxRW ItemsChoiceType4* eElemtype = new ItemsChoiceType4; *eElemtype = itemschoicetype4SPPR; poVal->m_ItemsElementName0.push_back(eElemtype); - poVal->m_Items.push_back(GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR)); + + PPTX::Logic::SpPr *pNewElem = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, pNewElem); + poVal->m_Items.push_back(pNewElem); } else if(c_oserct_dlblTX == type) { @@ -3167,7 +3219,10 @@ namespace BinXlsxRW ItemsChoiceType4* eElemtype = new ItemsChoiceType4; *eElemtype = itemschoicetype4TXPR; poVal->m_ItemsElementName0.push_back(eElemtype); - poVal->m_Items.push_back(GetTxBodyXml(length)); + + PPTX::Logic::TxBody * pNewElem = new PPTX::Logic::TxBody(); + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, pNewElem); + poVal->m_Items.push_back(pNewElem); } else if(c_oserct_dlblEXTLST == type) { @@ -3206,7 +3261,8 @@ namespace BinXlsxRW } else if(c_oserct_trendlineSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_trendlineTRENDLINETYPE == type) { @@ -3339,11 +3395,13 @@ namespace BinXlsxRW } else if(c_oserct_trendlinelblSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_trendlinelblTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } else if(c_oserct_trendlinelblEXTLST == type) { @@ -3403,7 +3461,8 @@ namespace BinXlsxRW } else if(c_oserct_errbarsSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_errbarsEXTLST == type) { @@ -3806,7 +3865,8 @@ namespace BinXlsxRW } else if(c_oserct_surfaceserSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_surfaceserCAT == type) { @@ -3842,7 +3902,8 @@ namespace BinXlsxRW } else if(c_oserct_bandfmtSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else res = c_oSerConstants::ReadUnknown; @@ -4042,7 +4103,8 @@ namespace BinXlsxRW } else if(c_oserct_pieserSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_pieserEXPLOSION == type) { @@ -4220,7 +4282,8 @@ namespace BinXlsxRW } else if(c_oserct_barserSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_barserINVERTIFNEGATIVE == type) { @@ -4549,7 +4612,8 @@ namespace BinXlsxRW } else if(c_oserct_scatterserSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_scatterserMARKER == type) { @@ -4692,7 +4756,8 @@ namespace BinXlsxRW } else if(c_oserct_radarserSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_radarserMARKER == type) { @@ -4867,7 +4932,8 @@ namespace BinXlsxRW } else if(c_oserct_lineserSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_lineserMARKER == type) { @@ -4965,7 +5031,8 @@ namespace BinXlsxRW CT_UpDownBar* poVal = static_cast(poResult); if(c_oserct_updownbarSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else res = c_oSerConstants::ReadUnknown; @@ -5196,7 +5263,8 @@ namespace BinXlsxRW } else if(c_oserct_areaserSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_areaserPICTUREOPTIONS == type) { @@ -5498,7 +5566,8 @@ namespace BinXlsxRW } else if(c_oserct_plotareaSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_plotareaEXTLST == type) { @@ -5536,7 +5605,8 @@ namespace BinXlsxRW } else if(c_oserct_surfaceSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_surfacePICTUREOPTIONS == type) { @@ -5686,11 +5756,13 @@ namespace BinXlsxRW } else if(c_oserct_pivotfmtSPPR == type) { - poVal->m_spPr = GetRecordXml(length, XMLWRITER_RECORD_TYPE_SPPR); + poVal->m_oSpPr = new PPTX::Logic::SpPr; + res = Read1(length, &BinaryChartReader::ReadCT_SpPr, this, poVal->m_oSpPr.GetPointer()); } else if(c_oserct_pivotfmtTXPR == type) { - poVal->m_txPr = GetTxBodyXml(length); + poVal->m_oTxPr = new PPTX::Logic::TxBody; + res = Read1(length, &BinaryChartReader::ReadCT_TxPr, this, poVal->m_oTxPr.GetPointer()); } else if(c_oserct_pivotfmtMARKER == type) { @@ -5982,18 +6054,7 @@ namespace BinXlsxRW HRESULT hRes = m_pOfficeDrawingConverter->GetRecordBinary(nRecordType, sXml); m_oBcw.WriteItemEnd(nCurPos); } - void BinaryChartWriter::GetTxBodyBinary(int nType, std::wstring& sXml_) - { - int nCurPos = m_oBcw.WriteItemStart(nType); - - std::wstring sXml = L""; - sXml += sXml_; - sXml += L""; - - m_pOfficeDrawingConverter->GetTxBodyBinary(sXml); - m_oBcw.WriteItemEnd(nCurPos); - } - void BinaryChartWriter::WriteCT_extLst(CT_extLst& oVal) + void BinaryChartWriter::WriteCT_extLst(CT_extLst& oVal) { for(size_t i = 0, length = oVal.m_ext.size(); i < length; ++i) { @@ -6061,13 +6122,17 @@ namespace BinXlsxRW WriteCT_Chart(*oVal.m_chart); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_chartspaceSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_chartspaceSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_chartspaceTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_chartspaceTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } //if(NULL != oVal.m_externalData) //{ @@ -6351,9 +6416,11 @@ namespace BinXlsxRW WriteCT_Boolean(*oVal.m_delete); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_legendentryTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_legendentryTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_extLst) { @@ -6426,13 +6493,17 @@ namespace BinXlsxRW WriteCT_Boolean(*oVal.m_overlay); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_legendSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_legendSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_legendTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_legendTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_extLst) { @@ -6574,13 +6645,17 @@ namespace BinXlsxRW WriteCT_Boolean(*oVal.m_showKeys); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_dtableSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_dtableSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_dtableTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_dtableTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_extLst) { @@ -6657,13 +6732,17 @@ namespace BinXlsxRW WriteCT_TickLblPos(*oVal.m_tickLblPos); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_seraxSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_seraxSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_seraxTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_seraxTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_crossAx) { @@ -6766,9 +6845,11 @@ namespace BinXlsxRW } void BinaryChartWriter::WriteCT_ChartLines(CT_ChartLines& oVal) { - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_chartlinesSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_chartlinesSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } } void BinaryChartWriter::WriteCT_Title(CT_Title& oVal) @@ -6791,13 +6872,17 @@ namespace BinXlsxRW WriteCT_Boolean(*oVal.m_overlay); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_titleSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_titleSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_titleTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_titleTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_extLst) { @@ -6808,9 +6893,11 @@ namespace BinXlsxRW } void BinaryChartWriter::WriteCT_Tx(CT_Tx& oVal) { - if(NULL != oVal.m_rich) + if(oVal.m_oRich.IsInit()) { - GetTxBodyBinary(c_oserct_txRICH, (*oVal.m_rich)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_txRICH); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oRich); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_strRef) { @@ -7012,13 +7099,17 @@ namespace BinXlsxRW WriteCT_TickLblPos(*oVal.m_tickLblPos); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_dateaxSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_dateaxSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_dateaxTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_dateaxTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_crossAx) { @@ -7183,13 +7274,17 @@ namespace BinXlsxRW WriteCT_TickLblPos(*oVal.m_tickLblPos); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_cataxSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_cataxSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_cataxTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_cataxTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_crossAx) { @@ -7266,13 +7361,17 @@ namespace BinXlsxRW WriteCT_Tx(*oVal.m_tx); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_dispunitslblSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_dispunitslblSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_dispunitslblTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_dispunitslblTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } } void BinaryChartWriter::WriteCT_BuiltInUnit(CT_BuiltInUnit& oVal) @@ -7390,13 +7489,17 @@ namespace BinXlsxRW WriteCT_TickLblPos(*oVal.m_tickLblPos); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_valaxSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_valaxSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_valaxTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_valaxTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_crossAx) { @@ -7486,9 +7589,11 @@ namespace BinXlsxRW WriteCT_SerTx(*oVal.m_tx); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_bubbleserSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_bubbleserSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_invertIfNegative) { @@ -7610,9 +7715,11 @@ namespace BinXlsxRW WriteCT_UnsignedInt(*oVal.m_explosion); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_dptSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_dptSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_pictureOptions) { @@ -7641,9 +7748,11 @@ namespace BinXlsxRW WriteCT_MarkerSize(*oVal.m_size); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_markerSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_markerSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_extLst) { @@ -7884,19 +7993,23 @@ namespace BinXlsxRW break; case itemschoicetype3SPPR: { - std::wstring* pTypeVal = static_cast(pVal); + PPTX::Logic::SpPr* pTypeVal = static_cast(pVal); if(NULL != pTypeVal) { - GetRecordBinary(c_oserct_dlblsSPPR, (*pTypeVal), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_dlblsSPPR); + m_oBcw.m_oStream.WriteRecord1(0, (*pTypeVal)); + m_oBcw.WriteItemEnd(nCurPos); } } break; case itemschoicetype3TXPR: { - std::wstring* pTypeVal = static_cast(pVal); + PPTX::Logic::TxBody* pTypeVal = static_cast(pVal); if(NULL != pTypeVal) { - GetTxBodyBinary(c_oserct_dlblsTXPR, (*pTypeVal)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_dlblsTXPR); + m_oBcw.m_oStream.WriteRecord1(0, (*pTypeVal)); + m_oBcw.WriteItemEnd(nCurPos); } } break; @@ -8048,10 +8161,12 @@ namespace BinXlsxRW break; case itemschoicetype4SPPR: { - std::wstring* pTypeVal = static_cast(pVal); + PPTX::Logic::SpPr* pTypeVal = static_cast(pVal); if(NULL != pTypeVal) { - GetRecordBinary(c_oserct_dlblSPPR, (*pTypeVal), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_dlblSPPR); + m_oBcw.m_oStream.WriteRecord1(0, (*pTypeVal)); + m_oBcw.WriteItemEnd(nCurPos); } } break; @@ -8068,10 +8183,12 @@ namespace BinXlsxRW break; case itemschoicetype4TXPR: { - std::wstring* pTypeVal = static_cast(pVal); + PPTX::Logic::TxBody* pTypeVal = static_cast(pVal); if(NULL != pTypeVal) { - GetTxBodyBinary(c_oserct_dlblTXPR, (*pTypeVal)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_dlblTXPR); + m_oBcw.m_oStream.WriteRecord1(0, (*pTypeVal)); + m_oBcw.WriteItemEnd(nCurPos); } } break; @@ -8095,9 +8212,11 @@ namespace BinXlsxRW m_oBcw.m_oStream.WriteStringW4(*oVal.m_name); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_trendlineSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_trendlineSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_trendlineType) { @@ -8208,13 +8327,17 @@ namespace BinXlsxRW WriteCT_NumFmt(*oVal.m_numFmt); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_trendlinelblSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_trendlinelblSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_trendlinelblTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_trendlinelblTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_extLst) { @@ -8267,9 +8390,11 @@ namespace BinXlsxRW WriteCT_Double(*oVal.m_val); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_errbarsSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_errbarsSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_extLst) { @@ -8627,9 +8752,11 @@ namespace BinXlsxRW WriteCT_SerTx(*oVal.m_tx); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_surfaceserSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_surfaceserSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_cat) { @@ -8658,9 +8785,11 @@ namespace BinXlsxRW WriteCT_UnsignedInt(*oVal.m_idx); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_bandfmtSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_bandfmtSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } } void BinaryChartWriter::WriteCT_SurfaceChart(CT_SurfaceChart& oVal) @@ -8843,9 +8972,11 @@ namespace BinXlsxRW WriteCT_SerTx(*oVal.m_tx); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_pieserSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_pieserSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_explosion) { @@ -9008,9 +9139,11 @@ namespace BinXlsxRW WriteCT_SerTx(*oVal.m_tx); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_barserSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_barserSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_invertIfNegative) { @@ -9324,9 +9457,11 @@ namespace BinXlsxRW WriteCT_SerTx(*oVal.m_tx); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_scatterserSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_scatterserSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_marker) { @@ -9472,9 +9607,11 @@ namespace BinXlsxRW WriteCT_SerTx(*oVal.m_tx); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_radarserSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_radarserSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_marker) { @@ -9647,9 +9784,11 @@ namespace BinXlsxRW WriteCT_SerTx(*oVal.m_tx); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_lineserSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_lineserSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_marker) { @@ -9743,9 +9882,11 @@ namespace BinXlsxRW } void BinaryChartWriter::WriteCT_UpDownBar(CT_UpDownBar& oVal) { - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_updownbarSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_updownbarSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } } void BinaryChartWriter::WriteCT_Line3DChart(CT_Line3DChart& oVal) @@ -9973,9 +10114,11 @@ namespace BinXlsxRW WriteCT_SerTx(*oVal.m_tx); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_areaserSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_areaserSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_pictureOptions) { @@ -10115,9 +10258,11 @@ namespace BinXlsxRW WriteCT_DTable(*oVal.m_dTable); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_plotareaSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_plotareaSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_extLst) { @@ -10373,9 +10518,11 @@ namespace BinXlsxRW WriteCT_Thickness(*oVal.m_thickness); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_surfaceSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_surfaceSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_pictureOptions) { @@ -10488,13 +10635,17 @@ namespace BinXlsxRW WriteCT_UnsignedInt(*oVal.m_idx); m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_spPr) + if (oVal.m_oSpPr.IsInit()) { - GetRecordBinary(c_oserct_pivotfmtSPPR, (*oVal.m_spPr), XMLWRITER_RECORD_TYPE_SPPR); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_pivotfmtSPPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oSpPr); + m_oBcw.WriteItemEnd(nCurPos); } - if(NULL != oVal.m_txPr) + if (oVal.m_oTxPr.IsInit()) { - GetTxBodyBinary(c_oserct_pivotfmtTXPR, (*oVal.m_txPr)); + int nCurPos = m_oBcw.WriteItemStart(c_oserct_pivotfmtTXPR); + m_oBcw.m_oStream.WriteRecord2(0, oVal.m_oTxPr); + m_oBcw.WriteItemEnd(nCurPos); } if(NULL != oVal.m_marker) { diff --git a/XlsxSerializerCom/Reader/ChartFromToBinary.h b/XlsxSerializerCom/Reader/ChartFromToBinary.h index 74f4741cf1..165fe3e2d4 100644 --- a/XlsxSerializerCom/Reader/ChartFromToBinary.h +++ b/XlsxSerializerCom/Reader/ChartFromToBinary.h @@ -59,7 +59,6 @@ namespace BinXlsxRW { int ReadCT_RelId (long length, CT_RelId* poResult); private: std::wstring* GetRecordXml (long length, int nRecordType); - std::wstring* GetTxBodyXml (long length); int ReadCT_extLst (BYTE type, long length, void* poResult); int ReadCT_ChartSpace (BYTE type, long length, void* poResult); @@ -201,6 +200,8 @@ namespace BinXlsxRW { int ReadAlternateContent (BYTE type, long length, void* poResult); int ReadAlternateContentChoice (BYTE type, long length, void* poResult); int ReadAlternateContentFallback(BYTE type, long length, void* poResult); + int ReadCT_SpPr (BYTE type, long length, void* poResult); + int ReadCT_TxPr (BYTE type, long length, void* poResult); }; class BinaryChartWriter { @@ -348,15 +349,14 @@ namespace BinXlsxRW { void WriteAlternateContent(AlternateContent& oVal); void WriteAlternateContentChoice(AlternateContentChoice& oVal); void WriteAlternateContentFallback(AlternateContentFallback& oVal); - + private: void toBin(ItemsChoiceType5 eType, void* pVal); void toBin(ItemsChoiceType6 eType, void* pVal); void toBin(ItemsChoiceType4 eType, void* pVal); - void GetRecordBinary(int nType, std::wstring& sXml, int nRecordType); - void GetTxBodyBinary(int nType, std::wstring& sXml); void toBin(ItemsChoiceType3 eType, void* pVal); + void GetRecordBinary(int nType, std::wstring& sXml, int nRecordType); }; } #endif // #ifndef CHART_FROM_TO_BINARY