Error writing xlsx (wrong ConditionalFormatting place)

ASCOfficeDocxFile2/BinWriter/BinWriters.h

@@ -780,28 +780,22 @@ namespace BinDocxRW
 					m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
 					m_oBcw.m_oStream.WriteBOOL(rPr.m_oVanish->m_oVal.ToBool());
 				}
-				if (false != rPr.m_sTextOutline.IsInit())
+				if (false != rPr.m_oTextOutline.IsInit())
 				{
-                    std::wstring sTextOutline = rPr.m_sTextOutline.get2();
-					//делаем replace потому что читать имена node без namespace можем а атрибуты нет, потому что храним их в map
-                    XmlUtils::replace_all(sTextOutline, L"w14:", L"");
-
-                    m_oBcw.m_oStream.WriteBYTE(c_oSerProp_rPrType::TextOutline);
+					m_oBcw.m_oStream.WriteBYTE(c_oSerProp_rPrType::TextOutline);
 					m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Variable);
 					int nCurPos = m_oBcw.WriteItemWithLengthStart();
-					m_pOfficeDrawingConverter->GetRecordBinary(XMLWRITER_RECORD_TYPE_TEXT_OUTLINE, sTextOutline);
+					
+					m_oBcw.m_oStream.WriteRecord2(0, rPr.m_oTextOutline);
 					m_oBcw.WriteItemWithLengthEnd(nCurPos);
 				}
-				if (false != rPr.m_sTextFill.IsInit())
+				if (rPr.m_oTextFill.getType() != OOX::et_Unknown)
 				{
-                    std::wstring sTextFill = rPr.m_sTextFill.get2();
-					//делаем replace потому что читать имена node без namespace можем а атрибуты нет, потому что храним их в map
-                    XmlUtils::replace_all(sTextFill, L"w14:", L"");
-
                     m_oBcw.m_oStream.WriteBYTE(c_oSerProp_rPrType::TextFill);
 					m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Variable);
 					int nCurPos = m_oBcw.WriteItemWithLengthStart();
-					m_pOfficeDrawingConverter->GetRecordBinary(XMLWRITER_RECORD_TYPE_TEXT_FILL, sTextFill);
+					
+					m_oBcw.m_oStream.WriteRecord1(0, rPr.m_oTextFill);
 					m_oBcw.WriteItemWithLengthEnd(nCurPos);
 				}
 				if(rPr.m_oDel.IsInit())

ASCOfficeDocxFile2/DocWrapper/DocxSerializer.cpp

@@ -61,7 +61,7 @@ bool BinDocxRW::CDocxSerializer::ConvertDocxToDoct(const std::wstring& sSrcFileN
 
     if(S_OK == oCOfficeUtils.ExtractToDirectory(sSrcFileName, strDirSrc, NULL, 0))
 		if(saveToFile(strEditorBin, strDirSrc, sXMLOptions))
-            if(S_OK == oCOfficeUtils.CompressFileOrDirectory(strDirDst, sDstFileName, -1))
+            if(S_OK == oCOfficeUtils.CompressFileOrDirectory(strDirDst, sDstFileName))
 				return true;
 	return false;
 }
@@ -88,7 +88,7 @@ bool BinDocxRW::CDocxSerializer::ConvertDoctToDocx(const std::wstring& sSrcFileN
 
         if(loadFromFile(sEditorBin, strDirDst, sXMLOptions, sThemePath, sMediaPath, sEmbedPath))
         {
-            if(S_OK == oCOfficeUtils.CompressFileOrDirectory(strDirDst, sDstFileName, -1))
+            if(S_OK == oCOfficeUtils.CompressFileOrDirectory(strDirDst, sDstFileName, true))
 				return true;
         }
     }

ASCOfficeDocxFile2/DocWrapper/XlsxSerializer.cpp

@@ -275,7 +275,7 @@ namespace BinXlsxRW{
 		oXlsx.Write(oPath, sAdditionalContentTypes);
 		//zip
 		COfficeUtils oOfficeUtils(NULL);
-		oOfficeUtils.CompressFileOrDirectory(sTempDir, sDstFile, -1);
+		oOfficeUtils.CompressFileOrDirectory(sTempDir, sDstFile, true);
 		//clean
 		NSDirectory::DeleteDirectory(sTempDir);
 	}

ASCOfficeOdfFile/OdfFileTest/OdfFileTest.cpp

@@ -34,7 +34,6 @@
 #include <stdio.h>
 #include <tchar.h>
 
-
 #include "../../OfficeUtils/src/OfficeUtils.h"
 #include "../../DesktopEditor/common/Directory.h"
 #include "../src/ConvertOO2OOX.h"
@@ -55,7 +54,7 @@ int _tmain(int argc, _TCHAR* argv[])
 	HRESULT hr = S_OK;
 //////////////////////////////////////////////////////////////////////////
 	std::wstring srcFileName	= argv[1];
-	std::wstring dstPath		= argc > 2 ? argv[2] : srcFileName + L"-my.docx"; //xlsx pptx
+	std::wstring dstPath		= argc > 2 ? argv[2] : srcFileName + L"-my.xlsx"; //xlsx pptx docx
 	
 	std::wstring outputDir		= NSDirectory::GetFolderPath(dstPath);
 	
@@ -73,7 +72,7 @@ int _tmain(int argc, _TCHAR* argv[])
 
 	if (hr != S_OK)  return hr;
    
-	if (S_OK != oCOfficeUtils.CompressFileOrDirectory(dstTempPath.c_str(), dstPath.c_str(), -1))
+	if (S_OK != oCOfficeUtils.CompressFileOrDirectory(dstTempPath.c_str(), dstPath.c_str(), true))
         return hr;
 	
 	NSDirectory::DeleteDirectory(dstTempPath);

ASCOfficeOdfFile/OdfFileTest/OdfFileTest.vcproj

@@ -64,6 +64,8 @@
 			<Tool
 				Name="VCLinkerTool"
 				AdditionalDependencies="gdi32.lib Rpcrt4.lib"
+				ShowProgress="0"
+				Version=""
 				LinkIncremental="2"
 				GenerateDebugInformation="true"
 				SubSystem="1"

ASCOfficeOdfFile/linux/OdfFileReaderLib.pro

@@ -24,7 +24,8 @@ DEFINES +=  UNICODE \
             _USE_LIBXML2_READER_ \
             _USE_XMLLITE_READER_ \
             USE_LITE_READER \
-            LIBXML_READER_ENABLED
+            LIBXML_READER_ENABLED \
+            DONT_WRITE_EMBEDDED_FONTS
 
 INCLUDEPATH += ../include
 INCLUDEPATH += ../../DesktopEditor/freetype-2.5.2/include

ASCOfficeOdfFile/src/docx/docx_package.cpp

@@ -47,12 +47,12 @@ docx_content_types_file::docx_content_types_file()
     content()->add_default(L"jpg",     L"image/jpeg");
     content()->add_default(L"png",     L"image/png");
 	//
-    content()->add_override(L"/_rels/.rels",                  L"application/vnd.openxmlformats-package.relationships+xml");
-    content()->add_override(L"/word/_rels/document.xml.rels", L"application/vnd.openxmlformats-package.relationships+xml");
     content()->add_override(L"/word/document.xml",            L"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml");
 	content()->add_override(L"/word/settings.xml",            L"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml");
     content()->add_override(L"/word/styles.xml",              L"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml");
     content()->add_override(L"/word/fontTable.xml",           L"application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml");
+    //content()->add_override(L"/word/_rels/document.xml.rels", L"application/vnd.openxmlformats-package.relationships+xml");
+    //content()->add_override(L"/_rels/.rels",                  L"application/vnd.openxmlformats-package.relationships+xml");
     content()->add_override(L"/docProps/app.xml",             L"application/vnd.openxmlformats-officedocument.extended-properties+xml");
     content()->add_override(L"/docProps/core.xml",            L"application/vnd.openxmlformats-package.core-properties+xml");
 }

ASCOfficeOdfFile/src/odf/draw_frame.cpp

@@ -381,7 +381,7 @@ std::wstring draw_object::office_convert(odf_document * odfDocument, int type)
 		std::wstring temp_file = folderPath + FILE_SEPARATOR_STR + href_result;
 
 		COfficeUtils oCOfficeUtils(NULL);
-		oCOfficeUtils.CompressFileOrDirectory(objectOutPath.c_str(), temp_file.c_str(), -1);
+		oCOfficeUtils.CompressFileOrDirectory(objectOutPath.c_str(), temp_file.c_str(), true);
 	}	
     NSDirectory::DeleteDirectory(objectOutPath);
 	

ASCOfficeOdfFileW/source/Oox2OdfConverter/ConvertDiagram.cpp

@@ -33,8 +33,10 @@
 #include "../utils.h"
 
 #include "../../../Common/DocxFormat/Source/DocxFormat/Diagram/DiagramDrawing.h"
-#include "../../../Common/DocxFormat/Source/Common/SimpleTypes_Drawing.h"
+#include "../../../Common/DocxFormat/Source/XlsxFormat/Chart/Chart.h"
 
+#include "../../../Common/DocxFormat/Source/Common/SimpleTypes_Drawing.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/GraphicFrame.h"
 #include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Shape.h"
 #include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Colors/SrgbClr.h"
 #include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Colors/PrstClr.h"
@@ -56,6 +58,106 @@ namespace Oox2Odf
 	{
 		return (1.0 * emu / (635 * 20.0));
 	}
+
+void OoxConverter::convert(PPTX::Logic::GraphicFrame *oox_graphic_frame)
+{
+	if (!oox_graphic_frame)return;
+
+////////////////////////////////////////////////////////////////////////////////
+	odf_context()->drawing_context()->start_drawing();
+	
+	convert(&oox_graphic_frame->nvGraphicFramePr);		
+	
+	if ( oox_graphic_frame->chartRec.IsInit())
+	{
+		convert(oox_graphic_frame->chartRec.GetPointer());
+	}
+	else if ( oox_graphic_frame->smartArt.IsInit())
+	{
+		OoxConverter::convert(oox_graphic_frame->smartArt.GetPointer());
+	}
+	else if ( oox_graphic_frame->pic.IsInit())
+	{
+		OoxConverter::convert(oox_graphic_frame->pic.GetPointer());
+	}
+	else if ( oox_graphic_frame->table.IsInit())
+	{
+		OoxConverter::convert(oox_graphic_frame->table.GetPointer());
+	}
+	else if ( oox_graphic_frame->element.IsInit())
+	{
+		OoxConverter::convert(oox_graphic_frame->element->GetElem().operator->());
+	}
+	odf_context()->drawing_context()->end_drawing();
+}
+void OoxConverter::convert(PPTX::Logic::NvGraphicFramePr *oox_framePr)
+{
+	if (oox_framePr == NULL) return;
+
+}
+void OoxConverter::convert(PPTX::Logic::Table *oox_table)
+{
+	if (oox_table == NULL) return;
+
+}
+void OoxConverter::convert(PPTX::Logic::SmartArt *oox_smart_art)
+{
+	if (oox_smart_art == NULL) return;
+	if (oox_smart_art->id_data.IsInit() == false) return;
+
+	oox_smart_art->LoadDrawing();
+
+	if (oox_smart_art->m_diag.IsInit())
+	{
+		_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);
+
+		oox_current_child_document = dynamic_cast<OOX::IFileContainer*>(oox_smart_art->m_oCommonRels.operator->());
+
+		odf_context()->drawing_context()->start_group();
+
+		odf_context()->drawing_context()->set_group_size (width, height, width, height);
+		odf_context()->drawing_context()->set_group_position (x, y, cx, cy);
+
+		convert(oox_smart_art->m_diag.GetPointer());
+
+		odf_context()->drawing_context()->end_group();
+		oox_current_child_document = NULL;
+	}
+}
+void OoxConverter::convert(PPTX::Logic::ChartRec *oox_chart)
+{
+	if (!oox_chart) return;
+	if( !oox_chart->id_data.IsInit()) return;
+
+	_CP_OPT(double) width, height;
+	odf_context()->drawing_context()->get_size (width, height);
+				
+	smart_ptr<OOX::File> oFile = find_file_by_id (oox_chart->id_data->get());
+	if (oFile.IsInit())
+	{
+		OOX::Spreadsheet::CChartSpace* pChart = (OOX::Spreadsheet::CChartSpace*)oFile.operator->();
+		
+		if (pChart)
+		{
+			oox_current_child_document_spreadsheet = dynamic_cast<OOX::Spreadsheet::IFileContainer*>(pChart);	
+			odf_context()->drawing_context()->start_object(odf_context()->get_next_name_object());
+			{
+				odf_context()->start_chart();
+					odf_context()->chart_context()->set_chart_size(width, height);		
+		
+					OoxConverter::convert(pChart->m_oChartSpace.m_oSpPr.GetPointer());			
+			
+					OoxConverter::convert(&pChart->m_oChartSpace);
+				odf_context()->end_chart();
+			}
+			odf_context()->drawing_context()->end_object();	
+			oox_current_child_document_spreadsheet = NULL;
+		}
+	}
+}
 void OoxConverter::convert(PPTX::Logic::SpTree *oox_shape_tree)
 {
 	if (oox_shape_tree == NULL) return;
@@ -85,9 +187,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 +214,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 +384,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)

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

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
@@ -312,6 +311,7 @@ namespace PPTX
 {
 	namespace Logic
 	{
+		class GraphicFrame;
 		class SpTree;
 		class Shape;
 		class SpPr;
@@ -343,6 +343,10 @@ namespace PPTX
 		class Fld;
 		class Br;
 		class MathParaWrapper;
+		class NvGraphicFramePr;
+		class Table;
+		class ChartRec;
+		class SmartArt;
 	}
 }
 
@@ -428,11 +432,12 @@ public:
 		void convert(OOX::Drawing::CRun							*oox_run);
 		void convert(OOX::Drawing::CRunProperty					*oox_run_pr, cpdoccore::odf_writer::style_text_properties	* text_properties);
 		void convert(OOX::Drawing::CLineSpacing					*oox_spacing, cpdoccore::odf_types::length_or_percent & length_or_percent);
-//.diagram & pptx................................................................................................................................
-		void convert(PPTX::Logic::TextSpacing					*oox_spacing, cpdoccore::odf_types::length_or_percent & length_or_percent);
+//drawingML & pptx................................................................................................................................
+		void convert(PPTX::Logic::GraphicFrame					*oox_graphicFrame);
 		void convert(PPTX::Logic::SpTree						*oox_shape_tree);
 		void convert(PPTX::Logic::Shape							*oox_shape);
 		void convert(PPTX::Logic::SpPr							*oox_spPr, PPTX::Logic::ShapeStyle* oox_sp_style = NULL);
+		void convert(PPTX::Logic::TextSpacing					*oox_spacing, cpdoccore::odf_types::length_or_percent & length_or_percent);
 		int	 convert(PPTX::Logic::PrstTxWarp					*oox_text_preset);
 		void convert(PPTX::Logic::PrstGeom						*oox_geom);
 		void convert(PPTX::Logic::CustGeom						*oox_geom);
@@ -458,6 +463,10 @@ public:
 		void convert(PPTX::Logic::Fld							*oox_fld);
 		void convert(PPTX::Logic::Br							*oox_br);
 		void convert(PPTX::Logic::MathParaWrapper				*oox_math);
+		void convert(PPTX::Logic::NvGraphicFramePr				*oox_framePr);
+		void convert(PPTX::Logic::ChartRec						*oox_chart);
+		void convert(PPTX::Logic::SmartArt						*oox_smart_art);
+		void convert(PPTX::Logic::Table							*oox_table);
 //.chart............................................................................................................................
 		void convert(OOX::Spreadsheet::CT_ChartSpace			*oox_chart);
 		void convert(OOX::Spreadsheet::CT_Title					*ct_title);
@@ -495,8 +504,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);

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;

ASCOfficeOdfFileW/source/Oox2OdfConverter/DocxConverter.cpp

@@ -2074,8 +2074,9 @@ void DocxConverter::convert(OOX::Logic::CRunProperty *oox_run_pr, odf_writer::st
 	}
 
 	bool set_color = false;
-	if (oox_run_pr->m_oGradFill.IsInit())
+	if (oox_run_pr->m_oTextFill.getType() == OOX::et_a_gradFill)
 	{
+		NSCommon::smart_ptr<PPTX::Logic::GradFill> gradFill = oox_run_pr->m_oTextFill.Fill.smart_dynamic_cast<PPTX::Logic::GradFill>();
 		odf_writer::odf_drawing_context	 *drawing_context = odf_context()->drawing_context();
 		if (drawing_context)
 		{
@@ -2083,7 +2084,7 @@ void DocxConverter::convert(OOX::Logic::CRunProperty *oox_run_pr, odf_writer::st
 			{
 				odf_context()->drawing_context()->start_area_properties();
 				{		
-					OoxConverter::convert(oox_run_pr->m_oGradFill.GetPointer(), NULL);
+					OoxConverter::convert(gradFill.operator->());
 				}
 				odf_context()->drawing_context()->end_area_properties();
 

ASCOfficeOdfFileW/source/Oox2OdfConverter/XlsxConverter.cpp

@@ -64,7 +64,7 @@ XlsxConverter::XlsxConverter(const std::wstring & path, const ProgressCallback*
 
     pCallBack = CallBack;
 
-    xlsx_current_drawing = NULL;
+    xlsx_current_container = NULL;
 
 	if (UpdateProgress(400000))return;
 }
@@ -98,8 +98,8 @@ smart_ptr<OOX::File> XlsxConverter::find_file_by_id(std::wstring sId)
 {
 	smart_ptr<OOX::File> oFile;
 	
-	if (xlsx_current_drawing)
-		oFile = xlsx_current_drawing->Find(sId);
+	if (xlsx_current_container)
+		oFile = xlsx_current_container->Find(sId);
 	else if (oox_current_child_document)
 		oFile = oox_current_child_document->Find(sId);
 	else if (oox_current_child_document_spreadsheet)
@@ -113,9 +113,9 @@ std::wstring XlsxConverter::find_link_by_id (std::wstring sId, int type)
 
 	if (type == 1)
 	{
-		if (ref.empty() && xlsx_current_drawing)
+		if (ref.empty() && xlsx_current_container)
 		{
-			smart_ptr<OOX::File> oFile = xlsx_current_drawing->Find(sId);
+			smart_ptr<OOX::File> oFile = xlsx_current_container->Find(sId);
 			if (oFile.IsInit() && OOX::Spreadsheet::FileTypes::Image == oFile->type())
 			{
 				OOX::Spreadsheet::Image* pImage = (OOX::Spreadsheet::Image*)oFile.operator->();
@@ -1760,11 +1760,7 @@ void XlsxConverter::convert(OOX::Spreadsheet::CCellAnchor *oox_anchor)
 	{
 		convert(oox_anchor->m_oConnShape.GetPointer());
 	}	
-	else if (oox_anchor->m_oGraphicFrame.IsInit())//chart
-	{
-		convert(oox_anchor->m_oGraphicFrame.GetPointer());
-	}	
-	else if (oox_anchor->m_oGroupShape.IsInit())//chart
+	else if (oox_anchor->m_oGroupShape.IsInit())
 	{
 		convert(oox_anchor->m_oGroupShape.GetPointer());
 	}	
@@ -1773,7 +1769,8 @@ void XlsxConverter::convert(OOX::Spreadsheet::CCellAnchor *oox_anchor)
 void XlsxConverter::convert(OOX::Spreadsheet::CDrawing *oox_drawing)
 {
 	if (!oox_drawing)return;
-	xlsx_current_drawing = oox_drawing;
+	
+	xlsx_current_container = dynamic_cast<OOX::Spreadsheet::IFileContainer*>(oox_drawing);
 
 	for (unsigned int dr = 0 ; dr < oox_drawing->m_arrItems.size(); dr++)
 	{
@@ -1782,7 +1779,7 @@ void XlsxConverter::convert(OOX::Spreadsheet::CDrawing *oox_drawing)
 		ods_context->end_drawings();
 	}
 
-	xlsx_current_drawing = NULL;
+	xlsx_current_container = NULL;
 }
 
 
@@ -1840,11 +1837,6 @@ void XlsxConverter::convert(OOX::Spreadsheet::CGroupShape* oox_group_shape)
 				OOX::Spreadsheet::CPic* item = static_cast<OOX::Spreadsheet::CPic*>(oox_group_shape->m_arrItems[i]);
 				convert(item);
 			}break;
-			case OOX::Spreadsheet::et_xdr_GraphicFrame:
-			{
-				OOX::Spreadsheet::CGraphicFrame* item = static_cast<OOX::Spreadsheet::CGraphicFrame*>(oox_group_shape->m_arrItems[i]);
-				convert(item);
-			}break;
 		}
 	}
 	ods_context->drawing_context()->end_group();
@@ -1913,64 +1905,6 @@ void XlsxConverter::convert(OOX::Spreadsheet::CShape* oox_shape)
 
 }
 
-void XlsxConverter::convert(OOX::Spreadsheet::CGraphicFrame* oox_graphic_frame)
-{
-	if (!oox_graphic_frame)return;
-
-	if (!oox_graphic_frame->m_oGraphic.IsInit()) return;
-	if (!oox_graphic_frame->m_oGraphic->m_oGraphicData.IsInit()) return;
-
-////////////////////////////////////////////////////////////////////////////////
-	ods_context->drawing_context()->start_drawing();
-	
-	if (oox_graphic_frame->m_oNvGraphicFramePr.IsInit())
-	{
-		OoxConverter::convert(oox_graphic_frame->m_oNvGraphicFramePr->m_oCNvPr.GetPointer());		
-	}	
-	
-	if ( OOX::Drawing::graphictypeChart == oox_graphic_frame->m_oGraphic->m_oGraphicData->m_eGraphicType)
-	{
-		convert(oox_graphic_frame->m_oGraphic->m_oGraphicData->m_oChart.GetPointer());
-	}
-	else if ( OOX::Drawing::graphictypeDiagram == oox_graphic_frame->m_oGraphic->m_oGraphicData->m_eGraphicType)
-	{
-		OoxConverter::convert(oox_graphic_frame->m_oGraphic->m_oGraphicData->m_oDiagrammParts.GetPointer());
-	}
-	ods_context->drawing_context()->end_drawing();
-}
-
-void XlsxConverter::convert(OOX::Spreadsheet::CGraphicChart *oox_chart)
-{
-	if (!oox_chart) return;
-	if( !oox_chart->m_oRId.IsInit()) return;
-
-	_CP_OPT(double) width, height;
-	odf_context()->drawing_context()->get_size (width, height);
-				
-	smart_ptr<OOX::File> oFile = xlsx_current_drawing->Find(oox_chart->m_oRId->GetValue());
-	if (oFile.IsInit() && OOX::Spreadsheet::FileTypes::Charts == oFile->type())
-	{
-		OOX::Spreadsheet::CChartSpace* pChart = (OOX::Spreadsheet::CChartSpace*)oFile.operator->();
-		
-		if (pChart)
-		{
-			oox_current_child_document_spreadsheet = dynamic_cast<OOX::Spreadsheet::IFileContainer*>(pChart);	
-			odf_context()->drawing_context()->start_object(ods_context->get_next_name_object());
-			{
-				odf_context()->start_chart();
-					odf_context()->chart_context()->set_chart_size(width, height);		
-		
-					OoxConverter::convert(pChart->m_oChartSpace.m_oSpPr.GetPointer());			
-			
-					OoxConverter::convert(&pChart->m_oChartSpace);
-				odf_context()->end_chart();
-			}
-			odf_context()->drawing_context()->end_object();	
-			oox_current_child_document_spreadsheet = NULL;
-		}
-	}
-}
-
 void XlsxConverter::convert(OOX::Spreadsheet::CConnShape* oox_shape)
 {
 	if (!oox_shape)return;

ASCOfficeOdfFileW/source/Oox2OdfConverter/XlsxConverter.h

@@ -144,7 +144,7 @@ namespace Oox2Odf
 		void convert(OOX::Spreadsheet::WritingElement	*oox_unknown);
     private:		
 		OOX::Spreadsheet::CXlsx					*xlsx_document;
-		OOX::Spreadsheet::CDrawing				*xlsx_current_drawing; //пока сюда .. потом покрасивше, для внешних ссылок
+		OOX::Spreadsheet::IFileContainer		*xlsx_current_container; 
 		
 		odf_writer::ods_conversion_context		*ods_context;
 
@@ -199,9 +199,7 @@ namespace Oox2Odf
 		void convert(OOX::Spreadsheet::CPic							*oox_picture);
 		void convert(OOX::Spreadsheet::CShape						*oox_shape);
 		void convert(OOX::Spreadsheet::CConnShape					*oox_conn_shape);
-		void convert(OOX::Spreadsheet::CGraphicFrame				*oox_graphic_frame);
 		void convert(OOX::Spreadsheet::CGroupShape					*oox_group_shape);
-		void convert(OOX::Spreadsheet::CGraphicChart				*oox_chart);
 	
 		void convert(OOX::Spreadsheet::CConditionalFormatting		*oox_cond_fmt);
 		void convert(OOX::Spreadsheet::CConditionalFormattingRule	*oox_cond_rule);

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

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

ASCOfficePPTXFile/PPTXFormat/FileContainer.cpp

@@ -73,9 +73,9 @@ namespace PPTX
 		{
 			directory = directory.substr(0, pos_ppt - 1); //root directory
 		}
-		CArray<std::wstring> arrFiles = NSDirectory::GetFiles(directory, true);
+        std::vector<std::wstring> arrFiles = NSDirectory::GetFiles(directory, true);
 
-		for (int i = 0 ; i < arrFiles.GetCount(); i++)
+        for (size_t i = 0 ; i < arrFiles.size(); i++)
 		{
 			if (std::wstring::npos != arrFiles[i].find(filename))
 			{

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 = XmlUtils::GetNameNoNS(oReader.GetName());
 
+				if (sName == L"ahXY")
+					ah.reset(new Logic::AhXY(oReader));
+				else if(sName == L"ahPolar")
+					ah.reset(new Logic::AhPolar(oReader));
+				else ah.reset();
+			}
 			virtual void GetAdjustHandleFrom(XmlUtils::CXmlNode& element)
 			{
 				XmlUtils::CXmlNode oNode;

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;

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;

ASCOfficePPTXFile/PPTXFormat/Logic/BodyPr.h

@@ -51,9 +51,67 @@ namespace PPTX
 		class BodyPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BodyPr)
+			WritingElement_AdditionConstructors(BodyPr)
+			
+			BodyPr(std::wstring ns = L"a")
+			{
+				m_namespace = ns;
+			}			
 
-		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());
@@ -93,6 +151,8 @@ namespace PPTX
 
 			virtual std::wstring toXML() const
 			{
+				if (m_namespace.empty()) m_namespace = L"a";
+
 				XmlUtils::CAttribute oAttr;
 				oAttr.Write(_T("rot"), rot);
 				oAttr.Write(_T("spcFirstLastPara"), spcFirstLastPara);
@@ -132,6 +192,8 @@ namespace PPTX
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
+				if (m_namespace.empty()) m_namespace = L"a";
+
 				pWriter->StartNode(m_namespace + _T(":bodyPr"));
 
 				pWriter->StartAttributes();
@@ -172,10 +234,16 @@ namespace PPTX
 				pWriter->EndNode(m_namespace + _T(":bodyPr"));
 			}
 
-			void Merge(BodyPr& bodyPr)const
+			
+			void Merge(nullable<BodyPr>& 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> prstTxWarp;
 				nullable_property<Scene3d> scene3d;
@@ -184,43 +252,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

ASCOfficePPTXFile/PPTXFormat/Logic/CNvCxnSpPr.h

@@ -42,8 +42,13 @@ namespace PPTX
 		class CNvCxnSpPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(CNvCxnSpPr)
+			WritingElement_AdditionConstructors(CNvCxnSpPr)
 				
+			CNvCxnSpPr(std::wstring ns = L"p")
+			{
+				m_namespace = ns;
+			}
+
 			CNvCxnSpPr& operator=(const CNvCxnSpPr& oSrc)
 			{
 				parentFile		= oSrc.parentFile;
@@ -68,9 +73,58 @@ namespace PPTX
 				return *this;
 			}
 
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+				
+				if ( oReader.IsEmptyNode() )
+					return;
+					
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if (strName == L"a:cxnSpLocks")
+					{
+						ReadAttributesLocks(oReader);
+					}
+					else if (strName == L"a:stCxn")
+					{
+						ReadAttributes(oReader, stCxn_id, stCxn_idx);
+					}
+					else if (strName == L"a:endCxn")
+					{
+						ReadAttributes(oReader, endCxn_id, endCxn_idx);
+					}
+				}
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader, nullable_int & id, nullable_int & idx )
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("id"),	id)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("idx"),	idx)
+				WritingElement_ReadAttributes_End( oReader )
+			}
+			void ReadAttributesLocks(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("noAdjustHandles"),	noAdjustHandles)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noChangeArrowheads"),	noChangeArrowheads)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noChangeAspect"), noChangeAspect)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noChangeShapeType"), noChangeShapeType)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noEditPoints"), noEditPoints)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noGrp"), noGrp)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noMove"), noMove)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noResize"), noResize)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noRot"), noRot)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noSelect"), noSelect)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
+				m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 				XmlUtils::CXmlNode l_Locks;
 				if (node.GetNode(_T("a:cxnSpLocks"), l_Locks))
 				{
@@ -132,17 +186,17 @@ namespace PPTX
 				if (_T("") != oAttr3.m_strValue)
 					oValue.m_strValue += XmlUtils::CreateNode(_T("a:endCxn"), oAttr3);
 
-                return XmlUtils::CreateNode(_T("p:cNvCxnSpPr"), oValue);
+                return XmlUtils::CreateNode(m_namespace + L":cNvCxnSpPr", oValue);
 			}
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
-                if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-                    pWriter->StartNode(_T("wps:cNvCxnSpPr"));
-                else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-                    pWriter->StartNode(_T("xdr:cNvCxnSpPr"));
-                else
-                     pWriter->StartNode(_T("p:cNvCxnSpPr"));
+               	std::wstring namespace_ = m_namespace;
+				
+				if		(pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)	namespace_ = _T("wps");
+				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = _T("xdr");
+
+				pWriter->StartNode(namespace_ + L":cNvCxnSpPr");
 
                 pWriter->EndAttributes();
 
@@ -181,12 +235,7 @@ namespace PPTX
 					pWriter->EndNode(_T("a:endCxn"));
 				}
 
-                if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-                    pWriter->EndNode(_T("wps:cNvCxnSpPr"));
-                else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-                    pWriter->EndNode(_T("xdr:cNvCxnSpPr"));
-                else
-                    pWriter->EndNode(_T("p:cNvCxnSpPr"));
+                pWriter->EndNode(namespace_ + L":cNvCxnSpPr");
 			}
 
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
@@ -299,7 +348,8 @@ namespace PPTX
 				pReader->Seek(_end_rec);
 			}
 
-		public:
+			std::wstring	m_namespace;
+
 			nullable_bool	noAdjustHandles;
 			nullable_bool	noChangeArrowheads;
 			nullable_bool	noChangeAspect;

ASCOfficePPTXFile/PPTXFormat/Logic/CNvGraphicFramePr.h

@@ -42,7 +42,12 @@ namespace PPTX
 		class CNvGraphicFramePr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(CNvGraphicFramePr)
+			WritingElement_AdditionConstructors(CNvGraphicFramePr)
+
+			CNvGraphicFramePr(std::wstring ns = L"p")
+			{
+				m_namespace = ns;
+			}
 
 			CNvGraphicFramePr& operator=(const CNvGraphicFramePr& oSrc)
 			{
@@ -56,12 +61,43 @@ namespace PPTX
 				noResize		= oSrc.noResize;
 				noSelect		= oSrc.noSelect;
 
+				m_namespace		= oSrc.m_namespace;
+
 				return *this;
 			}
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+				
+				if ( oReader.IsEmptyNode() )
+					return;
+						
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
 
-		public:
+					if (strName == L"a:graphicFrameLocks")
+					{
+						ReadAttributesLocks(oReader);
+					}
+				}
+			}
+			void ReadAttributesLocks(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("noChangeAspect"),	noChangeAspect)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noGrp"),	noGrp)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noMove"), noMove)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noResize"), noResize)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noDrilldown"), noDrilldown)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noSelect"), noSelect)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
+				m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 				XmlUtils::CXmlNode oNode;			
 				if (node.GetNode(_T("a:graphicFrameLocks"), oNode))
 				{
@@ -84,18 +120,16 @@ namespace PPTX
 				oAttr.Write(_T("noResize"), noResize);
 				oAttr.Write(_T("noSelect"), noSelect);
 
-				if (_T("") == oAttr.m_strValue)
-					return _T("<p:cNvGraphicFramePr/>");
-
-				return _T("<p:cNvGraphicFramePr>") + XmlUtils::CreateNode(_T("a:graphicFrameLocks"), oAttr) + _T("</p:cNvGraphicFramePr>");
+				return XmlUtils::CreateNode(m_namespace + L":cNvGraphicFramePr>", XmlUtils::CreateNode(_T("a:graphicFrameLocks"), oAttr));
 			}
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->StartNode(_T("xdr:cNvGraphicFramePr"));
-				else
-					pWriter->StartNode(_T("p:cNvGraphicFramePr"));
+				std::wstring namespace_ = m_namespace;
+
+				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = L"xdr";
+
+				pWriter->StartNode(namespace_ + L":cNvGraphicFramePr");
 				
 				pWriter->EndAttributes();
 				
@@ -114,10 +148,7 @@ namespace PPTX
 
 				pWriter->EndNode(_T("a:graphicFrameLocks"));
 
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->EndNode(_T("xdr:cNvGraphicFramePr"));
-				else
-					pWriter->EndNode(_T("p:cNvGraphicFramePr"));
+				pWriter->EndNode(namespace_ + L":cNvGraphicFramePr");
 			}
 
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
@@ -182,8 +213,8 @@ namespace PPTX
 
 				pReader->Seek(_end_rec);
 			}
+			std::wstring	m_namespace;
 
-		public:
 			nullable_bool	noChangeAspect;
 			nullable_bool	noDrilldown;
 			nullable_bool	noGrp;

ASCOfficePPTXFile/PPTXFormat/Logic/CNvGrpSpPr.cpp

@@ -35,7 +35,6 @@ namespace PPTX
 {
 	namespace Logic
 	{
-
          CNvGrpSpPr& CNvGrpSpPr::operator=(const CNvGrpSpPr& oSrc)
         {
             parentFile		= oSrc.parentFile;
@@ -54,6 +53,8 @@ namespace PPTX
 
 		void CNvGrpSpPr::fromXML(XmlUtils::CXmlNode& node)
 		{
+			m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 			XmlUtils::CXmlNode oNode;
 			if (node.GetNode(_T("a:grpSpLocks"), oNode))
 			{
@@ -66,8 +67,36 @@ namespace PPTX
 				oNode.ReadAttributeBase(L"noUngrp", noUngrp);
 			}
 		}
+		void CNvGrpSpPr::ReadAttributesLocks(XmlUtils::CXmlLiteReader& oReader)
+		{
+			WritingElement_ReadAttributes_Start( oReader )
+				WritingElement_ReadAttributes_Read_if		( oReader, _T("noChangeAspect"),	noChangeAspect)
+				WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noGrp"),	noGrp)
+				WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noMove"), noMove)
+				WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noResize"), noResize)
+				WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noRot"), noRot)
+				WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noSelect"), noSelect)
+				WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noUngrp"), noUngrp)
+			WritingElement_ReadAttributes_End( oReader )
+		}
+		void CNvGrpSpPr::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+			m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+			
+			if ( oReader.IsEmptyNode() )
+				return;
+					
+			int nParentDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nParentDepth ) )
+			{
+				std::wstring strName = oReader.GetName();
 
-
+				if (strName == L"a:grpSpLocks")
+				{
+					ReadAttributesLocks(oReader);
+				}
+			}
+		}
 		std::wstring CNvGrpSpPr::toXML() const
 		{
 			XmlUtils::CAttribute oAttr;
@@ -79,10 +108,7 @@ namespace PPTX
 			oAttr.Write(_T("noSelect"), noSelect);
 			oAttr.Write(_T("noUngrp"), noUngrp);
 
-			if (_T("") == oAttr.m_strValue)
-				return _T("<p:cNvGrpSpPr/>");
-
-			return _T("<p:cNvGrpSpPr>") + XmlUtils::CreateNode(_T("a:grpSpLocks"), oAttr) + _T("</p:cNvGrpSpPr>");
+			return XmlUtils::CreateNode(m_namespace + L":cNvGrpSpPr", XmlUtils::CreateNode(_T("a:grpSpLocks"), oAttr));
 		}
 
 	} // namespace Logic

ASCOfficePPTXFile/PPTXFormat/Logic/CNvGrpSpPr.h

@@ -42,18 +42,26 @@ namespace PPTX
 		class CNvGrpSpPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(CNvGrpSpPr)
+			WritingElement_AdditionConstructors(CNvGrpSpPr)
 
-            CNvGrpSpPr&         operator=(const CNvGrpSpPr& oSrc);
+			CNvGrpSpPr(std::wstring ns = L"p")
+			{
+				m_namespace = ns;
+			}
+
+            CNvGrpSpPr& operator=(const CNvGrpSpPr& oSrc);
 
-        public:
             virtual void fromXML(XmlUtils::CXmlNode& node);
+            virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
 
             virtual std::wstring toXML() const;
 
-
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
+				std::wstring ns = m_namespace;
+				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
+					ns = L"xdr";
+
 				if (!noChangeAspect.is_init() &&
 					!noGrp.is_init() &&
 					!noMove.is_init() &&
@@ -62,17 +70,11 @@ namespace PPTX
 					!noSelect.is_init() &&
 					!noUngrp.is_init())
 				{
-					if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-						pWriter->WriteString(_T("<xdr:cNvGrpSpPr/>"));
-					else
-						pWriter->WriteString(_T("<p:cNvGrpSpPr/>"));
+					pWriter->WriteString(L"<" + ns + L":cNvGrpSpPr/>");
 					return;
 				}
 
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->WriteString(_T("<xdr:cNvGrpSpPr>"));
-				else
-					pWriter->WriteString(_T("<p:cNvGrpSpPr>"));
+				pWriter->WriteString(L"<" + ns + L":cNvGrpSpPr>");
 
 				pWriter->StartNode(_T("a:grpSpLocks"));
 
@@ -88,10 +90,7 @@ namespace PPTX
 				
 				pWriter->EndNode(_T("a:grpSpLocks"));
 
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->WriteString(_T("</xdr:cNvGrpSpPr>"));
-				else
-					pWriter->WriteString(_T("</p:cNvGrpSpPr>"));
+				pWriter->WriteString(L"</" + ns + L":cNvGrpSpPr>");
 			}
 
 			void toXmlWriter2(const std::wstring& strNS, NSBinPptxRW::CXmlWriter* pWriter) const
@@ -192,8 +191,8 @@ namespace PPTX
 
 				pReader->Seek(_end_rec);
 			}
+			std::wstring		m_namespace;
 
-		public:
 			nullable_bool		noChangeAspect;
 			nullable_bool		noGrp;
 			nullable_bool		noMove;
@@ -202,6 +201,7 @@ namespace PPTX
 			nullable_bool		noSelect;
 			nullable_bool		noUngrp;
 		protected:
+			void ReadAttributesLocks(XmlUtils::CXmlLiteReader& oReader);
 			virtual void FillParentPointersForChilds(){};
 		};
 	} // namespace Logic

ASCOfficePPTXFile/PPTXFormat/Logic/CNvPicPr.h

@@ -44,7 +44,12 @@ namespace PPTX
 		{
 		public:
 			
-			PPTX_LOGIC_BASE(CNvPicPr)
+			WritingElement_AdditionConstructors(CNvPicPr)
+
+			CNvPicPr(std::wstring ns = L"p")
+			{
+				m_namespace = ns;
+			}
 
 			CNvPicPr& operator=(const CNvPicPr& oSrc)
 			{
@@ -65,10 +70,52 @@ namespace PPTX
 				noRot					= oSrc.noRot;
 				noSelect				= oSrc.noSelect;
 
+				m_namespace				= oSrc.m_namespace;
+
 				return *this;
 			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_ReadSingle( oReader, _T("preferRelativeResize"), preferRelativeResize )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
 
-		public:
+				ReadAttributes( oReader );
+
+				if ( oReader.IsEmptyNode() )
+					return;
+					
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if (_T("a:picLocks") == strName)
+					{
+						ReadAttributesLocks(oReader);
+					}
+				}
+			}
+			void ReadAttributesLocks(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("noAdjustHandles"),	noAdjustHandles)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noChangeArrowheads"),	noChangeArrowheads)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noChangeAspect"), noChangeAspect)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noChangeShapeType"), noChangeShapeType)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noCrop"), noCrop)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noEditPoints"), noEditPoints)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noGrp"), noGrp)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noMove"), noMove)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noResize"), noResize)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noRot"), noRot)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noSelect"), noSelect)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"preferRelativeResize", preferRelativeResize);
@@ -118,12 +165,12 @@ namespace PPTX
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-					pWriter->StartNode(_T("pic:cNvPicPr"));
-				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->StartNode(_T("xdr:cNvPicPr"));
-				else
-					pWriter->StartNode(_T("p:cNvPicPr"));
+				std::wstring namespace_ = m_namespace;
+				
+				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)			namespace_ = L"pic";
+				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = L"xdr";
+
+				pWriter->StartNode(namespace_ + L":cNvPicPr");
 
 				pWriter->StartAttributes();
 				pWriter->WriteAttribute(_T("preferRelativeResize"), preferRelativeResize);
@@ -157,13 +204,7 @@ namespace PPTX
 					pWriter->EndAttributes();
 					pWriter->EndNode(_T("a:picLocks"));
 				}
-
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-					pWriter->EndNode(_T("pic:cNvPicPr"));
-				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->EndNode(_T("xdr:cNvPicPr"));
-				else
-					pWriter->EndNode(_T("p:cNvPicPr"));
+				pWriter->EndNode(namespace_ + L":cNvPicPr");
 			}
 
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
@@ -262,8 +303,8 @@ namespace PPTX
 
 				pReader->Seek(_end_rec);
 			}
+			std::wstring		m_namespace;
 
-		public:
 			nullable_bool		preferRelativeResize;
 
 			nullable_bool		noAdjustHandles;

ASCOfficePPTXFile/PPTXFormat/Logic/CNvPr.h

@@ -44,15 +44,54 @@ namespace PPTX
 		class CNvPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(CNvPr)
+			WritingElement_AdditionConstructors(CNvPr)
+
+			CNvPr(std::wstring ns = L"p")
+			{
+				m_namespace = ns;
+			}
 
 			virtual OOX::EElementType getType () const
 			{
 				return OOX::et_p_cNvPr;
 			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				nullable_int id_;
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("id"),	id_)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("name"),	name)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("descr"), descr)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("hidden"), hidden)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("title"), title)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				id = id_.get_value_or(0);
+				Normalize();
+			}
+			virtual void 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 = oReader.GetName();
+					if (sName == L"a:hlinkClick")
+						hlinkClick = oReader;
+					else if (sName == L"a:hlinkHover")
+						hlinkHover = oReader;
+				}
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
+				m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 				id		= node.ReadAttributeInt(L"id");
 				name	= node.GetAttribute(L"name");
 				
@@ -79,18 +118,15 @@ namespace PPTX
 				oValue.WriteNullable(hlinkClick);
 				oValue.WriteNullable(hlinkHover);
 
-				return XmlUtils::CreateNode(_T("p:cNvPr"), oAttr, oValue);
+				return XmlUtils::CreateNode(m_namespace + L":cNvPr", oAttr, oValue);
 			}
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
-                std::wstring namespace_;
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-                    namespace_= _T("pic");
-				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-                    namespace_= _T("xdr");
-				else
-                    namespace_= _T("p");
+                std::wstring namespace_ = m_namespace;
+				
+				if		(pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)	namespace_= _T("pic");
+				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_= _T("xdr");
 
                 toXmlWriter2(namespace_, pWriter);
 
@@ -196,7 +232,8 @@ namespace PPTX
 				pReader->Seek(_end_rec);
 			}
 
-		public:
+			std::wstring		m_namespace;
+
 			int					id;
 			std::wstring		name;
 			nullable_string		descr;

ASCOfficePPTXFile/PPTXFormat/Logic/CNvSpPr.h

@@ -42,7 +42,12 @@ namespace PPTX
 		class CNvSpPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(CNvSpPr)
+			WritingElement_AdditionConstructors(CNvSpPr)
+
+			CNvSpPr(std::wstring ns = L"p")
+			{
+				m_namespace = ns;
+			}
 
 			CNvSpPr& operator=(const CNvSpPr& oSrc)
 			{
@@ -65,9 +70,52 @@ namespace PPTX
 				return *this;
 			}
 
-		public:
+			virtual void 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 strName = oReader.GetName();
+
+					if (strName == L"a:spLocks")
+					{
+						ReadAttributesLocks(oReader);
+					}
+				}
+			}
+			void ReadAttributesLocks(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("noAdjustHandles"),	noAdjustHandles)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noGrp"),	noGrp)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noMove"), noMove)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noRot"), noRot)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noResize"), noResize)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noTextEdit"), noTextEdit)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noSelect"), noSelect)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noChangeArrowheads"), noChangeArrowheads)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noChangeShapeType"), noChangeShapeType)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noChangeAspect"), noChangeAspect)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("noEditPoints"), noEditPoints)
+				WritingElement_ReadAttributes_End( oReader )
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_ReadSingle( oReader, _T("txBox"),	txBox)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
+				m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 				node.ReadAttributeBase(L"txBox", txBox);
 				
 				XmlUtils::CXmlNode l_Locks;
@@ -105,16 +153,18 @@ namespace PPTX
 				oAttr2.Write(_T("noTextEdit"), noTextEdit);
 
 				if (_T("") == oAttr2.m_strValue)
-					return XmlUtils::CreateNode(_T("p:cNvSpPr"), oAttr1);
+					return XmlUtils::CreateNode(m_namespace + L":cNvSpPr", oAttr1);
 
-				return XmlUtils::CreateNode(_T("p:cNvSpPr"), oAttr1, XmlUtils::CreateNode(_T("a:spLocks"), oAttr2));
+				return XmlUtils::CreateNode(m_namespace + L":cNvSpPr", oAttr1, XmlUtils::CreateNode(_T("a:spLocks"), oAttr2));
 			}
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->StartNode(_T("xdr:cNvSpPr"));
-				else
-					pWriter->StartNode(_T("p:cNvSpPr"));
+				std::wstring namespace_ = m_namespace;
+
+				if		(pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)	namespace_ = _T("wps");
+				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = _T("xdr");
+
+				pWriter->StartNode(namespace_ + L":cNvSpPr");
 
 				pWriter->StartAttributes();
 				pWriter->WriteAttribute(_T("txBox"), txBox);
@@ -151,10 +201,7 @@ namespace PPTX
 					pWriter->EndNode(_T("a:spLocks"));
 				}
 				
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->EndNode(_T("xdr:cNvSpPr"));
-				else
-					pWriter->EndNode(_T("p:cNvSpPr"));
+				pWriter->EndNode(namespace_ + L":cNvSpPr");
 			}
 
 			void toXmlWriter2(const std::wstring& strNS, NSBinPptxRW::CXmlWriter* pWriter) const
@@ -296,7 +343,8 @@ namespace PPTX
 				pReader->Seek(_end_rec);
 			}
 
-		public:
+			std::wstring	m_namespace;
+
 			nullable_bool txBox;
 			nullable_bool noAdjustHandles;
 			nullable_bool noChangeArrowheads;

ASCOfficePPTXFile/PPTXFormat/Logic/CSld.h

@@ -45,9 +45,12 @@ namespace PPTX
 		class CSld : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(CSld)
+			WritingElement_AdditionConstructors(CSld)
+			PPTX_LOGIC_BASE2(CSld)
 
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"name", attrName);

ASCOfficePPTXFile/PPTXFormat/Logic/Cell3D.h

@@ -45,15 +45,43 @@ namespace PPTX
 		class Cell3D : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Cell3D)
+			WritingElement_AdditionConstructors(Cell3D)
 
-		public:
+			Cell3D()
+			{
+			}
+
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+
+				if ( oReader.IsEmptyNode() )
+					return;
+					
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if (_T("bevel") == strName)
+						bevel = oReader;
+					else if (_T("lightRig") == strName)
+						lightRig = oReader;
+				}
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("prstMaterial"), prstMaterial )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"prstMaterial", prstMaterial);
 
 				bevel		= node.ReadNodeNoNS(_T("bevel"));
-				lightRig	= node.ReadNode(_T("a:lightRig"));
+				lightRig	= node.ReadNodeNoNS(_T("lightRig"));
 
 				FillParentPointersForChilds();
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/ClrMap.h

@@ -43,8 +43,13 @@ namespace PPTX
 		class ClrMap : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(ClrMap)
+			WritingElement_AdditionConstructors(ClrMap)
+			PPTX_LOGIC_BASE2(ClrMap)
 
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_clrMap;
+			}	
 			ClrMap& operator=(const ClrMap& oSrc)
 			{
 				parentFile		= oSrc.parentFile;
@@ -60,7 +65,57 @@ namespace PPTX
 				return *this;
 			}
 
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_name = oReader.GetName();
+
+				ColorMap.clear();
+
+				ReadAttributes(oReader);
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				Limit::ColorSchemeIndex lColorIndex_accent1;
+				Limit::ColorSchemeIndex lColorIndex_accent2;
+				Limit::ColorSchemeIndex lColorIndex_accent3;
+				Limit::ColorSchemeIndex lColorIndex_accent4;
+				Limit::ColorSchemeIndex lColorIndex_accent5;
+				Limit::ColorSchemeIndex lColorIndex_accent6;
+				Limit::ColorSchemeIndex lColorIndex_bg1;
+				Limit::ColorSchemeIndex lColorIndex_bg2;
+				Limit::ColorSchemeIndex lColorIndex_tx1;
+				Limit::ColorSchemeIndex lColorIndex_tx2;
+				Limit::ColorSchemeIndex lColorIndex_folHlink;
+				Limit::ColorSchemeIndex lColorIndex_hlink;
+				
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("accent1"), lColorIndex_accent1)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("accent2"), lColorIndex_accent2 )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("accent3"), lColorIndex_accent3 )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("accent4"), lColorIndex_accent4 )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("accent5"), lColorIndex_accent5 )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("accent6"), lColorIndex_accent6 )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("bg1"), lColorIndex_bg1 )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("bg2"), lColorIndex_bg2 )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("tx1"), lColorIndex_tx1 )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("tx1"), lColorIndex_tx2 )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("folHlink"), lColorIndex_folHlink )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("hlink"), lColorIndex_hlink )
+				WritingElement_ReadAttributes_End( oReader )
+				
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("accent1"), lColorIndex_accent1));
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("accent2"), lColorIndex_accent2));
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("accent3"), lColorIndex_accent3));
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("accent4"), lColorIndex_accent4));
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("accent5"), lColorIndex_accent5));
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("accent6"), lColorIndex_accent6));
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("bg1"), lColorIndex_bg1));
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("bg2"), lColorIndex_bg2));
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("tx1"), lColorIndex_tx1));
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("tx2"), lColorIndex_tx2));
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("folHlink"), lColorIndex_folHlink));
+				ColorMap.insert(std::pair<std::wstring,Limit::ColorSchemeIndex>(_T("hlink"), lColorIndex_hlink));
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_name = node.GetName();

ASCOfficePPTXFile/PPTXFormat/Logic/ClrMapOvr.h

@@ -43,9 +43,34 @@ namespace PPTX
 		class ClrMapOvr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(ClrMapOvr)
+			WritingElement_AdditionConstructors(ClrMapOvr)
+			PPTX_LOGIC_BASE2(ClrMapOvr)
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_clrMapOvr;
+			}	
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				if ( oReader.IsEmptyNode() )
+					return;
+					
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if ( L"overrideClrMapping" == sName)
+					{
+						overrideClrMapping = oReader;
+						break;
+					}
+				}
+				if (overrideClrMapping.is_init())
+					overrideClrMapping->m_name = _T("a:overrideClrMapping");
+				
+				FillParentPointersForChilds();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				overrideClrMapping = node.ReadNodeNoNS(_T("overrideClrMapping"));

ASCOfficePPTXFile/PPTXFormat/Logic/Colors/ColorModifier.h

@@ -63,7 +63,7 @@ namespace PPTX
 			void ReadAttributes2(XmlUtils::CXmlLiteReader& oReader)
 			{
 				nullable_string sTmp;
-				WritingElement_ReadAttributes_Start( oReader )
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
 					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("val"), sTmp)
 				WritingElement_ReadAttributes_End( oReader )
 
@@ -72,7 +72,7 @@ namespace PPTX
 			}
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
-				WritingElement_ReadAttributes_Start( oReader )
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
 					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("val"), val)
 				WritingElement_ReadAttributes_End( oReader )
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Colors/PrstClr.h

@@ -69,7 +69,7 @@ namespace PPTX
 			}
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
-				WritingElement_ReadAttributes_Start( oReader )
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
 					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("val"), val)
 				WritingElement_ReadAttributes_End( oReader )
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Colors/SchemeClr.h

@@ -58,7 +58,7 @@ namespace PPTX
 
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
-				WritingElement_ReadAttributes_Start( oReader )
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
 					WritingElement_ReadAttributes_Read_if     ( oReader, _T("val"), val)
 				WritingElement_ReadAttributes_End( oReader )
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Colors/SrgbClr.h

@@ -55,7 +55,7 @@ namespace PPTX
 			{
 				std::wstring val;
 
-				WritingElement_ReadAttributes_Start( oReader )
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
 					WritingElement_ReadAttributes_Read_if     ( oReader, _T("val"), val)
 				WritingElement_ReadAttributes_End( oReader )
                

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;

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

ASCOfficePPTXFile/PPTXFormat/Logic/CxnSp.cpp

@@ -41,28 +41,58 @@ namespace PPTX
 {
 	namespace Logic
 	{
-
-		CxnSp::CxnSp()
+		CxnSp::CxnSp(std::wstring ns)
 		{
+			m_namespace = ns;
 		}
-
 		CxnSp::~CxnSp()
 		{
 		}
-
 		CxnSp::CxnSp(XmlUtils::CXmlNode& node)
 		{
 			fromXML(node);
 		}
-
 		const CxnSp& CxnSp::operator =(XmlUtils::CXmlNode& node)
 		{
 			fromXML(node);
 			return *this;
 		}
+		CxnSp::CxnSp(XmlUtils::CXmlLiteReader& oReader)
+		{
+			fromXML(oReader);
+		}
+		const CxnSp& CxnSp::operator =(XmlUtils::CXmlLiteReader& oReader)
+		{
+			fromXML(oReader);
+			return *this;
+		}
+		void CxnSp::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+			m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+
+			if ( oReader.IsEmptyNode() )
+				return;
+					
+			int nParentDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nParentDepth ) )
+			{
+				std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+				if (_T("nvCxnSpPr") == strName)
+					nvCxnSpPr = oReader;
+				else if (_T("spPr") == strName)
+					spPr = oReader;
+				else if (_T("style") == strName)
+					style = oReader;
+			}
+
+			FillParentPointersForChilds();
+		}
 
 		void CxnSp::fromXML(XmlUtils::CXmlNode& node)
 		{
+			m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 			XmlUtils::CXmlNodes oNodes;
 			if (node.GetNodes(_T("*"), oNodes))
 			{
@@ -93,7 +123,7 @@ namespace PPTX
 			oValue.Write(spPr);
 			oValue.WriteNullable(style);
 
-			return XmlUtils::CreateNode(_T("<p:cxnSp>"), oValue);
+			return XmlUtils::CreateNode(m_namespace + L":cxnSp", oValue);
 		}
 
 		void CxnSp::FillParentPointersForChilds()

ASCOfficePPTXFile/PPTXFormat/Logic/CxnSp.h

@@ -46,13 +46,23 @@ namespace PPTX
 		class CxnSp : public WrapperWritingElement
 		{
 		public:
-			CxnSp();
+			CxnSp(std::wstring ns = L"p");
 			virtual ~CxnSp();			
+			
 			explicit CxnSp(XmlUtils::CXmlNode& node);
 			const CxnSp& operator =(XmlUtils::CXmlNode& node);
 
-		public:
+			explicit CxnSp(XmlUtils::CXmlLiteReader& oReader);
+			const CxnSp& operator =(XmlUtils::CXmlLiteReader& oReader);
+
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_cxnSp;
+			}
+
 			virtual void fromXML(XmlUtils::CXmlNode& node);
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			
 			virtual std::wstring toXML() const;
 			virtual void GetRect(Aggplus::RECT& pRect)const;
 
@@ -72,12 +82,12 @@ namespace PPTX
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
-                if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-                    pWriter->StartNode(_T("wps:cxnSp"));
-                else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-                    pWriter->StartNode(_T("xdr:cxnSp"));
-                else
-                    pWriter->StartNode(_T("p:cxnSp"));
+				std::wstring namespace_ = m_namespace;
+
+                if		(pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)	namespace_ = L"wps";
+                else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = L"xdr";
+                    
+				pWriter->StartNode(namespace_ + L":cxnSp");
 
                 pWriter->EndAttributes();
 
@@ -87,19 +97,13 @@ namespace PPTX
                 if (style.is_init())
                 {
                     if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-                        style->m_ns = _T("wps");
+                        style->m_namespace = _T("wps");
                     else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-                        style->m_ns = _T("xdr");
+                        style->m_namespace = _T("xdr");
 
                     pWriter->Write(style);
                 }
-
-                if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-                    pWriter->EndNode(_T("wps:cxnSp"));
-                else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-                    pWriter->EndNode(_T("xdr:cxnSp"));
-                else
-                     pWriter->EndNode(_T("p:cxnSp"));
+				pWriter->EndNode(namespace_ + L":cxnSp");
 			}
 
 			virtual void fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
@@ -123,8 +127,7 @@ namespace PPTX
 						}
 						case 2:
 						{
-							style = new ShapeStyle();
-							style->m_ns = _T("p");
+							style = new ShapeStyle(L"p");
 							style->fromPPTY(pReader);
 							break;
 						}
@@ -138,7 +141,8 @@ namespace PPTX
 				pReader->Seek(_end_rec);
 			}
 
-		public:
+			std::wstring			m_namespace;
+
 			NvCxnSpPr				nvCxnSpPr;
 			SpPr					spPr;
 			nullable<ShapeStyle>	style;

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,8 @@ namespace PPTX
 						}
 						case 1:
 						{
-							bodyPr.m_namespace = _T("a");
-							bodyPr.fromPPTY(pReader);
+							bodyPr = BodyPr(L"a");
+							bodyPr->fromPPTY(pReader);
 							break;
 						}
 						case 2:
@@ -139,8 +139,7 @@ namespace PPTX
 						}
 						case 3:
 						{
-							style = new ShapeStyle();
-							style->m_ns = _T("a");
+							style = new ShapeStyle(L"a");
 							style->fromPPTY(pReader);
 							break;
 						}
@@ -160,7 +159,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 +170,19 @@ namespace PPTX
 
 		public:
 			SpPr					spPr;
-			BodyPr					bodyPr;
+			nullable<BodyPr>		bodyPr;
 			TextListStyle			lstStyle;
 			nullable<ShapeStyle>	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);

ASCOfficePPTXFile/PPTXFormat/Logic/EffectProperties.h

@@ -63,7 +63,7 @@ namespace PPTX
 			}
 			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
 			{
-				std::wstring strName = oReader.GetName();
+				std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
 					
 				if (strName == _T("effectLst"))
 					List.reset(new Logic::EffectLst(oReader));

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/ClrChange.h

@@ -73,9 +73,9 @@ namespace PPTX
 					std::wstring strName = oReader.GetName();
 
 					if (strName == L"a:clrTo")
-						ClrTo.fromXML(oReader);
+						ClrTo.fromXMLParent(oReader);
 					else if (strName == L"a:clrFrom")
-						ClrFrom.fromXML(oReader);
+						ClrFrom.fromXMLParent(oReader);
 				}
 				FillParentPointersForChilds();
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/ExtP.h

@@ -52,9 +52,48 @@ namespace PPTX
 		class Ext : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Ext)
+			WritingElement_AdditionConstructors(Ext)
 
-		public:
+			Ext()
+			{
+			}
+
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				if ( oReader.IsEmptyNode() )
+					return;
+						
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if (strName == L"media")
+					{
+						ReadAttributes(oReader);
+						//std::wstring xmkl = media.GetXml();
+
+						int nParentDepth1 = oReader.GetDepth();
+						while( oReader.ReadNextSiblingNode( nParentDepth1 ) )
+						{
+							std::wstring strName1 = XmlUtils::GetNameNoNS(oReader.GetName());
+
+							if (strName1 == L"trim")
+							{
+								ReadAttributes(oReader);
+							}
+						}
+					}
+				}
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("st"),	st)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("end"),	end)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("r:embed"),	link)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				XmlUtils::CXmlNode media;
@@ -95,11 +134,9 @@ namespace PPTX
 				pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
 			}
 
-		public:
-
 			OOX::RId				link;
 
-			// trim
+		// trim
 			nullable_double			st;
 			nullable_double			end;
 

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/Blip.h

@@ -46,8 +46,11 @@ namespace PPTX
 		{
 		public:
 			WritingElement_AdditionConstructors(Blip)
-			PPTX_LOGIC_BASE2(Blip)
 
+			Blip(std::wstring ns = L"a")
+			{
+				m_namespace = ns;
+			}	
 			Blip& operator=(const Blip& oSrc)
 			{
 				parentFile		= oSrc.parentFile;
@@ -179,10 +182,9 @@ namespace PPTX
 			nullable_limit<Limit::BlipCompression> cstate;
 			nullable<OOX::RId> embed;
 			nullable<OOX::RId> link;
-		//private:
 		public:
 			std::wstring m_namespace;
-		//internal
+
 			std::wstring oleRid;
 			std::wstring oleFilepathBin;
 			std::wstring oleFilepathImg;

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/BlipFill.h

@@ -50,7 +50,11 @@ namespace PPTX
 		{
 		public:
 			WritingElement_AdditionConstructors(BlipFill)
-			PPTX_LOGIC_BASE2(BlipFill)
+			
+			BlipFill(std::wstring ns = L"p")
+			{
+				m_namespace = ns;
+			}
 
 			BlipFill& operator=(const BlipFill& oSrc)
 			{
@@ -78,7 +82,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())	

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/GradFill.h

@@ -49,8 +49,12 @@ namespace PPTX
 		{
 		public:
 			WritingElement_AdditionConstructors(GradFill)
-			PPTX_LOGIC_BASE2(GradFill)
-
+			
+			GradFill(std::wstring ns = L"a")
+			{
+				m_namespace = ns;
+			}
+			
 			GradFill& operator=(const GradFill& oSrc)
 			{
 				parentFile		= oSrc.parentFile;
@@ -74,6 +78,8 @@ namespace PPTX
 			}
 			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
 			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+
 				ReadAttributes( oReader );
 
 				if ( oReader.IsEmptyNode() )
@@ -95,7 +101,6 @@ namespace PPTX
 						int nCurDepth1 = oReader.GetDepth();
 						while( oReader.ReadNextSiblingNode( nCurDepth1 ) )
 						{
-							std::wstring sName1 = XmlUtils::GetNameNoNS(oReader.GetName());
 							Gs g; GsLst.push_back(g);
 							GsLst.back().fromXML(oReader);
 						}
@@ -104,7 +109,7 @@ namespace PPTX
 			}
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
-				WritingElement_ReadAttributes_Start	( oReader )
+				WritingElement_ReadAttributes_Start_No_NS	( oReader )
 					WritingElement_ReadAttributes_Read_if     ( oReader, _T("rotWithShape"), rotWithShape )
 					WritingElement_ReadAttributes_Read_else_if( oReader, _T("flip"), flip )
 				WritingElement_ReadAttributes_End	( oReader )
@@ -164,7 +169,7 @@ namespace PPTX
 				oValue.WriteNullable(lin);
 				oValue.WriteNullable(tileRect);
 
-				std::wstring strName = (_T("") == m_namespace) ? _T("gradFill") : (m_namespace + _T(":gradFill"));
+				std::wstring strName = m_namespace.empty() ? _T("gradFill") : (m_namespace + _T(":gradFill"));
 				return XmlUtils::CreateNode(strName, oAttr, oValue);
 			}
 
@@ -179,7 +184,7 @@ namespace PPTX
 				}
 				else
 				{
-					strName = (_T("") == m_namespace) ? _T("gradFill") : (m_namespace + _T(":gradFill"));
+					strName = m_namespace.empty() ? _T("gradFill") : (m_namespace + _T(":gradFill"));
 				}
 
 				pWriter->StartNode(strName);

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/NoFill.h

@@ -44,8 +44,11 @@ namespace PPTX
 		{
 		public:
 			WritingElement_AdditionConstructors(NoFill)
-			PPTX_LOGIC_BASE2(NoFill)
-
+			
+			NoFill(std::wstring ns = L"a")
+			{
+				m_namespace = ns;
+			}
 			NoFill& operator=(const NoFill& oSrc)
 			{
 				parentFile		= oSrc.parentFile;

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/PattFill.h

@@ -45,8 +45,11 @@ namespace PPTX
 		{
 		public:
 			WritingElement_AdditionConstructors(PattFill)
-			PPTX_LOGIC_BASE2(PattFill)
-
+			
+			PattFill(std::wstring ns = L"a")
+			{
+				m_namespace = ns;
+			}
 			PattFill& operator=(const PattFill& oSrc)
 			{
 				parentFile		= oSrc.parentFile;
@@ -71,9 +74,9 @@ namespace PPTX
 				{
                     std::wstring sName = oReader.GetName();
 					if (sName == L"a:fgClr")
-						fgClr.fromXML(oReader);
+						fgClr.fromXMLParent(oReader);
 					if (sName == L"a:bgClr")
-						bgClr.fromXML(oReader);
+						bgClr.fromXMLParent(oReader);
 				}
 				FillParentPointersForChilds();	
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/SolidFill.h

@@ -45,8 +45,11 @@ namespace PPTX
 		{
 		public:
 			WritingElement_AdditionConstructors(SolidFill)
-			PPTX_LOGIC_BASE2(SolidFill)
-
+			
+			SolidFill(std::wstring ns = L"a")
+			{
+				m_namespace = ns;
+			}
 			SolidFill& operator=(const SolidFill& oSrc)
 			{
 				parentFile		= oSrc.parentFile;

ASCOfficePPTXFile/PPTXFormat/Logic/FontRef.h

@@ -44,9 +44,32 @@ namespace PPTX
 		class FontRef : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(FontRef)
+			WritingElement_AdditionConstructors(FontRef)
 
-		public:
+			FontRef()
+			{
+			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_Unknown;
+			}
+
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_name = oReader.GetName();
+
+				ReadAttributes( oReader );
+				
+				Color.fromXMLParent(oReader);
+				
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_ReadSingle( oReader, _T("idx"), idx )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_name = node.GetName();

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

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

ASCOfficePPTXFile/PPTXFormat/Logic/GraphicFrame.cpp

@@ -43,8 +43,9 @@ namespace PPTX
 {
 	namespace Logic
 	{
-		GraphicFrame::GraphicFrame()
+		GraphicFrame::GraphicFrame(std::wstring ns) : nvGraphicFramePr(ns)
 		{
+			m_namespace = ns;
 		}
 
 		GraphicFrame::~GraphicFrame()
@@ -61,9 +62,146 @@ namespace PPTX
 			fromXML(node);
 			return *this;
 		}
+		GraphicFrame::GraphicFrame(XmlUtils::CXmlLiteReader& oReader)
+		{
+			fromXML(oReader);
+		}
+
+		const GraphicFrame& GraphicFrame::operator =(XmlUtils::CXmlLiteReader& oReader)
+		{
+			fromXML(oReader);
+			return *this;
+		}
+		void GraphicFrame::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+			m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+
+			if ( oReader.IsEmptyNode() )
+				return;
+
+			int nCurDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nCurDepth ) )
+			{
+				fromXML2(oReader);
+			}
+			
+			FillParentPointersForChilds();
+		}
+		void GraphicFrame::ReadAttributes3(XmlUtils::CXmlLiteReader& oReader)
+		{
+			WritingElement_ReadAttributes_Start( oReader )
+				WritingElement_ReadAttributes_ReadSingle ( oReader, _T("spid"), spid )
+			WritingElement_ReadAttributes_End( oReader )
+		}
+		void GraphicFrame::fromXML2(XmlUtils::CXmlLiteReader& oReader)
+		{
+			std::wstring strName		= XmlUtils::GetNameNoNS(oReader.GetName());
+			std::wstring strNamespace	= XmlUtils::GetNamespace(oReader.GetName());
+			
+			if (L"xfrm" == strName && strNamespace != L"xdr")
+				xfrm = oReader;
+			else if (L"nvGraphicFramePr" == strName)
+				nvGraphicFramePr.fromXML( oReader );
+				
+			else if (L"graphic" == strName)
+			{
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName1 = oReader.GetName();
+					if (strName1 == L"a:graphicData")
+					{
+						fromXML3(oReader);
+					}
+				}
+			}
+		}
+		bool GraphicFrame::fromXML3(XmlUtils::CXmlLiteReader& oReader)
+		{
+			bool result = false;
+			if ( oReader.IsEmptyNode() )
+				return result;
+
+			int nCurDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nCurDepth ) )
+			{
+				std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+				if (strName == L"tbl")
+				{
+					table = oReader;
+					result = true;
+				}
+
+				else if (strName == L"oleObj")
+				{
+					ReadAttributes3(oReader);
+
+					int nCurDepth1 = oReader.GetDepth();
+					while( oReader.ReadNextSiblingNode( nCurDepth1 ) )
+					{
+						std::wstring strName1 = XmlUtils::GetNameNoNS(oReader.GetName());
+						if (strName1 == L"pic")
+						{
+							result = true;
+							pic = oReader;
+							//pic->fromXMLOle(oNode2);
+							
+							if (xfrm.IsInit())
+								xfrm->Merge(pic->spPr.xfrm);
+						}
+					}
+				}
+				else if (strName == L"relIds")
+				{
+					smartArt = oReader;
+					result = true;
+				}
+				else if (strName == L"chart")
+				{
+					chartRec = oReader;
+					result = true;
+				}
+				else if (strName == L"legacyDrawing")
+				{
+					ReadAttributes3(oReader);
+					result = true;
+				}
+				else if (strName == L"AlternateContent")
+				{
+					int nCurDepth1 = oReader.GetDepth();
+					while( oReader.ReadNextSiblingNode( nCurDepth1 ) )
+					{
+						std::wstring strName1 = oReader.GetName();
+
+						if (strName1 == L"mc:Choice")
+						{
+							result = fromXML3(oReader);
+							if (result)
+								break;
+						}
+						else if (strName1 == L"mc:Fallback")
+						{
+							result = fromXML3(oReader);
+							if (result)
+								break;
+						}
+					}
+				}
+				else
+				{
+					element = oReader;
+					if (element.IsInit())
+						result = true;
+				}
+			}
+			return result;
+		}
 
 		void GraphicFrame::fromXML(XmlUtils::CXmlNode& node)
 		{
+			m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 			XmlUtils::CXmlNodes oNodes;
 			if (node.GetNodes(L"*", oNodes))
 			{
@@ -159,21 +297,12 @@ namespace PPTX
 
 		void GraphicFrame::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 		{
-			std::wstring strNS = L"";
-			if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX && pWriter->m_lGroupIndex >= 0)
-			{
-				pWriter->StartNode(L"wpg:graphicFrame");
-				strNS = L"wpg";
-			}
-			else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX && pWriter->m_lGroupIndex >= 0)
-			{
-				pWriter->StartNode(L"xdr:graphicFrame");
-				strNS = L"xdr";
-			}
-			else
-			{
-				pWriter->StartNode(L"p:graphicFrame");
-			}
+			std::wstring namespace_ = m_namespace;
+			
+			if		(pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX && pWriter->m_lGroupIndex >= 0)	namespace_ = L"wpg";
+			else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX && pWriter->m_lGroupIndex >= 0) namespace_ = L"xdr";
+
+			pWriter->StartNode(namespace_ + L":graphicFrame");
 
 			pWriter->EndAttributes();
 
@@ -181,10 +310,8 @@ namespace PPTX
 			
 			if (xfrm.IsInit())
 			{
-				if (strNS.empty())
-					xfrm->toXmlWriter(pWriter);
-				else
-					xfrm->toXmlWriter2(strNS, pWriter);
+				xfrm->m_ns = namespace_;
+				xfrm->toXmlWriter(pWriter);
 			}
 
             if (table.is_init())
@@ -200,12 +327,7 @@ namespace PPTX
 				pWriter->WriteString(L"</a:graphicData></a:graphic>");
 			}
 
-			if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX && pWriter->m_lGroupIndex >= 0)
-				pWriter->EndNode(L"wpg:graphicFrame");
-			else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX && pWriter->m_lGroupIndex >= 0)
-				pWriter->EndNode(L"xdr:graphicFrame");
-			else
-				pWriter->EndNode(L"p:graphicFrame");
+			pWriter->EndNode(namespace_ + L":graphicFrame");
 		}
 
 		void GraphicFrame::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
@@ -229,6 +351,7 @@ namespace PPTX
             if (smartArt.is_init() && !table.is_init() && !chartRec.is_init() && !spid.is_init())
 			{
 				smartArt->LoadDrawing(pWriter);
+				
 				if (smartArt->m_diag.is_init())
 				{
 					smartArt->m_diag->nvGrpSpPr.cNvPr	= nvGraphicFramePr.cNvPr;
@@ -385,6 +508,9 @@ namespace PPTX
 			}				
 
 			pReader->Seek(_end_rec);
+
+			if (!xfrm.IsInit())
+				xfrm = new Logic::Xfrm();
 		}
 
 		void GraphicFrame::GetRect(Aggplus::RECT& pRect)const
@@ -403,28 +529,38 @@ namespace PPTX
 
 		std::wstring GraphicFrame::toXML() const
 		{
-			//XML::XNode node;
-			//if(dm.is_init())
-			//{
-			//	return XML::XElement(ns.p + "graphicFrame",
-			//			XML::Write(nvGraphicFramePr) +
-			//			XML::Write(xfrm) +
-			//			XML::XElement(ns.a + "graphic",
-			//				XML::XElement(ns.a + "graphicData", //Возможно, здесь надо добавить ури
-			//					XML::XElement(ns.dgm + "relIds",
-			//						XML::XNamespace(ns.dgm) +
-			//						XML::XNamespace(ns.r) +
-			//						XML::XAttribute(ns.r + "dm", dm) +
-			//						XML::XAttribute(ns.r + "lo", lo) +
-			//						XML::XAttribute(ns.r + "qs", qs) +
-			//						XML::XAttribute(ns.r + "cs", cs)
-			//					)
-			//				)
-			//			)
-			//		);
-			//}
-			//return node;
-			return L"";
+			std::wstring sXml;
+			
+			sXml += L"<" + m_namespace + L":graphicFrame macro=\"\">";
+
+			sXml += nvGraphicFramePr.toXML();
+
+			sXml += L"<" + m_namespace + L":xfrm><a:off x=\"0\" y=\"0\"/><a:ext cx=\"0\" cy=\"0\"/>";
+			sXml += L"</" + m_namespace + L":xfrm>";
+
+			if (xfrm.IsInit())
+			{
+				xfrm->m_ns = m_namespace;
+				sXml += xfrm->toXML();
+			}
+
+            if (table.IsInit())
+			{
+				sXml += L"<a:graphic><a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/table\">";
+                sXml += table->toXML();
+				sXml += L"</a:graphicData></a:graphic>";
+			}
+			else if (chartRec.IsInit())
+			{
+				sXml += L"<a:graphic><a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/chart\">";
+				sXml += chartRec->toXML();
+				sXml += L"</a:graphicData></a:graphic>";
+			}
+
+			sXml += L"</" + m_namespace + L":graphicFrame>";			
+			sXml += L"<" + m_namespace + L":clientData/>";
+
+			return sXml;
 		}
 
 		void GraphicFrame::FillParentPointersForChilds()

ASCOfficePPTXFile/PPTXFormat/Logic/GraphicFrame.h

@@ -49,29 +49,46 @@ namespace PPTX
 		class GraphicFrame : public WrapperWritingElement
 		{
 		public:
-			GraphicFrame();
+			GraphicFrame(std::wstring ns = L"p");
 			virtual ~GraphicFrame();			
+			
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_graphicFrame;
+			}
+			explicit GraphicFrame(XmlUtils::CXmlLiteReader& oReader);
+			const GraphicFrame& operator =(XmlUtils::CXmlLiteReader& oReader);
+
 			explicit GraphicFrame(XmlUtils::CXmlNode& node);
 			const GraphicFrame& operator =(XmlUtils::CXmlNode& node);
 
 			virtual void fromXML(XmlUtils::CXmlNode& node);
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+					void fromXML2(XmlUtils::CXmlLiteReader& oReader);
+					bool fromXML3(XmlUtils::CXmlLiteReader& oReader);
+
+			void ReadAttributes3(XmlUtils::CXmlLiteReader& oReader);
+			
 			virtual std::wstring toXML() const;
 			virtual void GetRect(Aggplus::RECT& pRect)const;
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const;
 	
-
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const;
 			virtual void fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader);
 
+			std::wstring			m_namespace;
+
 			NvGraphicFramePr		nvGraphicFramePr;
 
 			nullable<Xfrm>			xfrm;
+
 			nullable_string			spid;
             nullable<Table>			table;
 			nullable<SmartArt>		smartArt;
 			nullable<ChartRec>		chartRec;
 			nullable<Pic>			pic;
+			nullable<SpTreeElem>	element;
 
 			std::wstring GetVmlXmlBySpid(std::wstring & rels)	const;
 		protected:

ASCOfficePPTXFile/PPTXFormat/Logic/GrpSpPr.h

@@ -48,8 +48,11 @@ namespace PPTX
 		class GrpSpPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(GrpSpPr)
+			WritingElement_AdditionConstructors(GrpSpPr)
 
+			GrpSpPr()
+			{
+			}
 			GrpSpPr& operator=(const GrpSpPr& oSrc)
 			{
 				parentFile		= oSrc.parentFile;
@@ -66,7 +69,9 @@ namespace PPTX
 			{
 				return OOX::et_p_groupSpPr;
 			}
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"bwMode", bwMode);

ASCOfficePPTXFile/PPTXFormat/Logic/Gs.h

@@ -71,13 +71,14 @@ namespace PPTX
 				while( oReader.ReadNextSiblingNode( nCurDepth ) )
 				{
 					color.fromXML(oReader);
+					break;
 				}
 				FillParentPointersForChilds();
 			}
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
 				nullable_int tmp;
-				WritingElement_ReadAttributes_Start	( oReader )
+				WritingElement_ReadAttributes_Start_No_NS	( oReader )
 					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("pos"), tmp)
 				WritingElement_ReadAttributes_End	( oReader )
 

ASCOfficePPTXFile/PPTXFormat/Logic/LineJoin.h

@@ -51,7 +51,7 @@ namespace PPTX
 
 			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
 			{
-				std::wstring name = oReader.GetName();
+				std::wstring name = XmlUtils::GetNameNoNS(oReader.GetName());
 
 				type = JoinEmpty;
 
@@ -80,7 +80,7 @@ namespace PPTX
 			}
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
-				WritingElement_ReadAttributes_Start	( oReader )
+				WritingElement_ReadAttributes_Start_No_NS	( oReader )
 					WritingElement_ReadAttributes_Read_if     ( oReader, _T("lim"), lim )
 				WritingElement_ReadAttributes_End	( oReader )
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Ln.h

@@ -56,7 +56,7 @@ namespace PPTX
 			{
 				//m_eDashType   = OOX::Drawing::linedashtypeUnknown;
 
-                std::wstring sName = oReader.GetName();
+				m_name = oReader.GetName();
 
 				ReadAttributes( oReader );
 
@@ -66,31 +66,31 @@ namespace PPTX
 				int nCurDepth = oReader.GetDepth();
 				while ( oReader.ReadNextSiblingNode( nCurDepth ) )
 				{
-					sName = oReader.GetName();
-					if (_T("a:bevel") == sName	||
-						_T("a:miter") == sName  ||
-						_T("a:round") == sName )
+					std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
+					if (_T("bevel") == sName	||
+						_T("miter") == sName  ||
+						_T("round") == sName )
 					{
 						Join.fromXML(oReader);
 					}
-					else if ( _T("a:tailEnd") == sName )
+					else if ( _T("tailEnd") == sName )
 						tailEnd = oReader;
-					else if ( _T("a:headEnd") == sName )
+					else if ( _T("headEnd") == sName )
 						headEnd = oReader;
 
-					else if (	_T("a:gradFill")	== sName ||
-								_T("a:noFill")		== sName ||
-								_T("a:pattFill")	== sName ||
-								_T("a:solidFill")	== sName )
+					else if (	_T("gradFill")	== sName ||
+								_T("noFill")	== sName ||
+								_T("pattFill")	== sName ||
+								_T("solidFill")	== sName )
 					{
 						Fill.fromXML(oReader);
 					}
-					else if ( _T("a:custDash") == sName )
+					else if ( _T("custDash") == sName )
 					{
 						//custDash = oReader;
 						//m_eDashType = OOX::Drawing::linedashtypeCustom;
 					}
-					else if ( _T("a:prstDash") == sName )
+					else if ( _T("prstDash") == sName )
 					{
 						prstDash = oReader;
 						//m_eDashType = OOX::Drawing::linedashtypePreset;
@@ -102,7 +102,7 @@ namespace PPTX
 			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
-				m_name = _T("a:ln");
+				m_name = node.GetName();
 
 				node.ReadAttributeBase(L"algn", algn);
 				node.ReadAttributeBase(L"cap", cap);
@@ -120,7 +120,7 @@ namespace PPTX
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
 				// Читаем атрибуты
-				WritingElement_ReadAttributes_Start( oReader )
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
 				WritingElement_ReadAttributes_Read_if     ( oReader, _T("algn"), algn )
 				WritingElement_ReadAttributes_Read_else_if( oReader, _T("cap"),  cap )
 				WritingElement_ReadAttributes_Read_else_if( oReader, _T("cmpd"), cmpd )
@@ -131,11 +131,20 @@ namespace PPTX
 			}
 			virtual std::wstring toXML() const
 			{
+				std::wstring _name = m_name;
+				if (_name.empty())
+					_name = _T("a:ln");
+
+				std::wstring sAttrNamespace;
+
+				if (_name == L"w14:textOutline")
+					sAttrNamespace = _T("w14:");
+
 				XmlUtils::CAttribute oAttr;
-				oAttr.Write(_T("w"), w);
-				oAttr.WriteLimitNullable(_T("cap"), cap);
-				oAttr.WriteLimitNullable(_T("cmpd"), cmpd);
-				oAttr.WriteLimitNullable(_T("algn"), algn);
+				oAttr.Write				(sAttrNamespace + _T("w"),		w);
+				oAttr.WriteLimitNullable(sAttrNamespace + _T("cap"),	cap);
+				oAttr.WriteLimitNullable(sAttrNamespace + _T("cmpd"),	cmpd);
+				oAttr.WriteLimitNullable(sAttrNamespace + _T("algn"),	algn);
 
 				XmlUtils::CNodeValue oValue;
 				oValue.Write(Fill);
@@ -144,14 +153,15 @@ namespace PPTX
 				oValue.WriteNullable(headEnd);
 				oValue.WriteNullable(tailEnd);
 
-				return XmlUtils::CreateNode(_T("a:ln"), oAttr, oValue);
+				return XmlUtils::CreateNode(_name, oAttr, oValue);
 			}
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
 				std::wstring _name = m_name;
-				if (_name == _T(""))
+				if (_name.empty())
 					_name = _T("a:ln");
+				
 				std::wstring sAttrNamespace;
 				if (XMLWRITER_DOC_TYPE_WORDART == pWriter->m_lDocType)
 				{

ASCOfficePPTXFile/PPTXFormat/Logic/Media/AudioCD.h

@@ -42,7 +42,11 @@ namespace PPTX
 		class AudioCD : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(AudioCD)
+			WritingElement_AdditionConstructors(AudioCD)
+
+			AudioCD()
+			{
+			}
 
 			AudioCD& operator=(const AudioCD& oSrc)
 			{
@@ -57,8 +61,10 @@ namespace PPTX
 
 				return *this;
 			}
-
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				//todooo
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				XmlUtils::CXmlNode oMem;

ASCOfficePPTXFile/PPTXFormat/Logic/Media/MediaFile.h

@@ -42,9 +42,12 @@ namespace PPTX
 	{
 		class MediaFile : public WrapperWritingElement
 		{
-		public:
-			
-			PPTX_LOGIC_BASE(MediaFile)
+		public:			
+			WritingElement_AdditionConstructors(MediaFile)
+
+			MediaFile()
+			{
+			}
 
 			MediaFile& operator=(const MediaFile& oSrc)
 			{
@@ -57,15 +60,25 @@ namespace PPTX
 
 				return *this;
 			}
-
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				name = XmlUtils::GetNameNoNS(oReader.GetName());
+				
+				ReadAttributes(oReader);
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				name		= XmlUtils::GetNameNoNS(node.GetName());
 				link		= node.GetAttribute(_T("r:link"));
 				node.ReadAttributeBase(L"contentType", contentType);
 			}
-
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("r:link"),	link)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("contentType"),	contentType)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual std::wstring toXML() const
 			{
 				XmlUtils::CAttribute oAttr;
@@ -75,7 +88,7 @@ namespace PPTX
 				return XmlUtils::CreateNode(_T("a:") + name, oAttr);
 			}
 		public:
-			std::wstring				name;
+			std::wstring		name;
 			OOX::RId			link;
 			nullable_string		contentType;
 		protected:

ASCOfficePPTXFile/PPTXFormat/Logic/NvCxnSpPr.h

@@ -46,7 +46,12 @@ namespace PPTX
 		class NvCxnSpPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(NvCxnSpPr)
+			WritingElement_AdditionConstructors(NvCxnSpPr)
+
+			NvCxnSpPr(std::wstring ns = L"p")
+			{
+				m_namespace = ns;
+			}
 
 			NvCxnSpPr& operator=(const NvCxnSpPr& oSrc)
 			{
@@ -60,12 +65,33 @@ namespace PPTX
 				return *this;
 			}
 
-		public:
-            virtual void fromXML(XmlUtils::CXmlNode& node)
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
 			{
-				cNvPr		= node.ReadNode(_T("p:cNvPr"));
-				cNvCxnSpPr	= node.ReadNode(_T("p:cNvCxnSpPr"));
-				nvPr		= node.ReadNode(_T("p:nvPr"));
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+				
+				if ( oReader.IsEmptyNode() )
+					return;
+					
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if (strName == L"cNvPr")
+						cNvPr = oReader;
+					else if(strName == L"cNvCxnSpPr")
+						cNvCxnSpPr = oReader;
+					else if(strName == L"nvPr")
+						nvPr = oReader;
+				}
+			}
+			virtual void fromXML(XmlUtils::CXmlNode& node)
+			{
+				m_namespace = XmlUtils::GetNamespace(node.GetName());
+
+				cNvPr		= node.ReadNodeNoNS(_T("cNvPr"));
+				cNvCxnSpPr	= node.ReadNodeNoNS(_T("cNvCxnSpPr"));
+				nvPr		= node.ReadNodeNoNS(_T("nvPr"));
 
 				FillParentPointersForChilds();
 			}
@@ -77,26 +103,16 @@ namespace PPTX
 				oValue.Write(cNvCxnSpPr);
 				oValue.Write(nvPr);
 
-				return XmlUtils::CreateNode(_T("<p:nvCxnSpPr>"), oValue);
+				return XmlUtils::CreateNode(m_namespace + L":nvCxnSpPr", oValue);
 			}
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
-               std::wstring namespace_;
-               if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-                {
-                    pWriter->StartNode(_T("wps:nvCxnSpPr"));
-                    namespace_ = _T("wps");
-                }
-                else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-                {
-                    pWriter->StartNode(_T("xdr:nvCxnSpPr"));
-                    namespace_ = _T("xdr");
-                }
-                else
-                {
-                    pWriter->StartNode(_T("p:nvCxnSpPr"));
-                    namespace_ = _T("p");
-                }
+				std::wstring namespace_ = m_namespace;
+				
+				if		(pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)	namespace_ = _T("wps");
+				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = _T("xdr");
+
+				pWriter->StartNode(namespace_ + L":nvCxnSpPr");
 
 				pWriter->EndAttributes();
 
@@ -104,12 +120,7 @@ namespace PPTX
 				cNvCxnSpPr.toXmlWriter(pWriter);
                 nvPr.toXmlWriter2(namespace_, pWriter);
 
-                 if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-                     pWriter->EndNode(_T("wps:nvCxnSpPr"));
-                 else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-                     pWriter->EndNode(_T("xdr:nvCxnSpPr"));
-                 else
-                     pWriter->EndNode(_T("p:nvCxnSpPr"));
+				pWriter->EndNode(namespace_ + L":nvCxnSpPr");
 			}
 
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
@@ -151,10 +162,11 @@ namespace PPTX
 				pReader->Seek(_end_rec);
 			}
 
-		public:
-			CNvPr		cNvPr;
-			CNvCxnSpPr	cNvCxnSpPr;
-			NvPr		nvPr;
+			std::wstring	m_namespace;
+
+			CNvPr			cNvPr;
+			CNvCxnSpPr		cNvCxnSpPr;
+			NvPr			nvPr;
 		protected:
 			virtual void FillParentPointersForChilds()
 			{

ASCOfficePPTXFile/PPTXFormat/Logic/NvGraphicFramePr.h

@@ -46,8 +46,12 @@ namespace PPTX
 		class NvGraphicFramePr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(NvGraphicFramePr)
+			WritingElement_AdditionConstructors(NvGraphicFramePr)
 
+			NvGraphicFramePr(std::wstring ns = L"p") : cNvPr(ns), cNvGraphicFramePr(ns), nvPr(ns)
+			{
+				m_namespace = ns;
+			}
 			NvGraphicFramePr& operator=(const NvGraphicFramePr& oSrc)
 			{
 				parentFile		= oSrc.parentFile;
@@ -57,16 +61,40 @@ namespace PPTX
 				cNvGraphicFramePr	= oSrc.cNvGraphicFramePr;
 				nvPr				= oSrc.nvPr;
 
+				m_namespace		= oSrc.m_namespace;
+
 				return *this;
 			}
 
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
-				cNvPr				= node.ReadNode(_T("p:cNvPr"));
-				cNvGraphicFramePr	= node.ReadNode(_T("p:cNvGraphicFramePr"));
-				nvPr				= node.ReadNode(_T("p:nvPr"));
+				m_namespace			= XmlUtils::GetNamespace(node.GetName());
 
+				cNvPr				= node.ReadNodeNoNS(_T("cNvPr"));
+				cNvGraphicFramePr	= node.ReadNodeNoNS(_T("cNvGraphicFramePr"));
+				nvPr				= node.ReadNodeNoNS(_T("nvPr"));
+
+				FillParentPointersForChilds();
+			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+
+				if ( oReader.IsEmptyNode() )
+					return;
+					
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if (sName == L"cNvPr")
+						cNvPr.fromXML( oReader);
+					else if (sName == L"cNvGraphicFramePr")
+						cNvGraphicFramePr.fromXML( oReader);
+					else if (sName == L"nvPr")
+						nvPr.fromXML( oReader);
+				}
 				FillParentPointersForChilds();
 			}
 
@@ -77,7 +105,7 @@ namespace PPTX
 				oValue.Write(cNvGraphicFramePr);
 				oValue.Write(nvPr);
 
-				return XmlUtils::CreateNode(_T("p:nvGraphicFramePr"), oValue);
+				return XmlUtils::CreateNode(m_namespace + L":nvGraphicFramePr", oValue);
 			}
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
@@ -150,7 +178,9 @@ namespace PPTX
 				pReader->Seek(_end_rec);
 			}
 
-		public:
+			
+			std::wstring		m_namespace;
+
 			CNvPr				cNvPr;
 			CNvGraphicFramePr	cNvGraphicFramePr;
 			NvPr				nvPr;

ASCOfficePPTXFile/PPTXFormat/Logic/NvGrpSpPr.cpp

@@ -38,45 +38,45 @@ namespace PPTX
 
 		void NvGrpSpPr::fromXML(XmlUtils::CXmlNode& node)
 		{
+			m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 			cNvPr		= node.ReadNode(_T("p:cNvPr"));
 			cNvGrpSpPr	= node.ReadNode(_T("p:cNvGrpSpPr"));
 			nvPr		= node.ReadNode(_T("p:nvPr"));
 
 			FillParentPointersForChilds();
-   /*
-            XmlUtils::CXmlNodes oNodes;
-            if (node.GetNodes(_T("*"), oNodes))
-            {
-                int nCount = oNodes.GetCount();
-                for (int i = 0; i < nCount; ++i)
-                {
-                    XmlUtils::CXmlNode oNode;
-                    oNodes.GetAt(i, oNode);
-
-                    std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
-
-                    if (_T("cNvPr") == strName)
-                        cNvPr = oNode;
-                    else if (_T("cNvGrpSpPr") == strName)
-                        cNvGrpSpPr = oNode;
-                    else if (_T("nvPr") == strName)
-                        nvPr = oNode;
-                }
-            }
-
-            FillParentPointersForChilds();
-      from header (old)*/
-		}
+ 		}
+		void NvGrpSpPr::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+			m_namespace = XmlUtils::GetNamespace(oReader.GetName());
 
+			if ( oReader.IsEmptyNode() )
+				return;
+				
+			int nParentDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nParentDepth ) )
+			{
+				std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
 
+				if (sName == L"cNvPr")
+					cNvPr = oReader;
+				else if (sName == L"cNvGrpSpPr")
+					cNvGrpSpPr = oReader;
+				else if (sName == L"nvPr")
+					nvPr = oReader;
+			}
+	
+			FillParentPointersForChilds();
+ 		}
 		std::wstring NvGrpSpPr::toXML() const
 		{
 			XmlUtils::CNodeValue oValue;
+			
 			oValue.Write(cNvPr);
 			oValue.Write(cNvGrpSpPr);
 			oValue.Write(nvPr);
 
-			return XmlUtils::CreateNode(_T("p:nvGrpSpPr"), oValue);
+			return XmlUtils::CreateNode(m_namespace + L":nvGrpSpPr", oValue);
 		}
 
 		void NvGrpSpPr::FillParentPointersForChilds()

ASCOfficePPTXFile/PPTXFormat/Logic/NvGrpSpPr.h

@@ -46,7 +46,12 @@ namespace PPTX
 		class NvGrpSpPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(NvGrpSpPr)
+			WritingElement_AdditionConstructors(NvGrpSpPr)
+
+			NvGrpSpPr()
+			{
+				m_namespace = L"p";
+			}
 
 			NvGrpSpPr& operator=(const NvGrpSpPr& oSrc)
 			{
@@ -62,49 +67,18 @@ namespace PPTX
 			{
 				return OOX::et_p_NvGrpSpPr;
 			}
-		public:
+
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
 			virtual void fromXML(XmlUtils::CXmlNode& node);
-			//{
-			//	XmlUtils::CXmlNodes oNodes;
-			//	if (node.GetNodes(_T("*"), oNodes))
-			//	{
-			//		int nCount = oNodes.GetCount();
-			//		for (int i = 0; i < nCount; ++i)
-			//		{
-			//			XmlUtils::CXmlNode oNode;
-			//			oNodes.GetAt(i, oNode);
-			//virtual void fromXML(XmlUtils::CXmlNode& node);
+			
             virtual std::wstring toXML() const;
-			//			std::wstring strName = XmlUtils::GetNameNoNS(oNode.GetName());
 
-			//			if (_T("cNvPr") == strName)
-			//				cNvPr = oNode;
-			//			else if (_T("cNvGrpSpPr") == strName)
-			//				cNvGrpSpPr = oNode;
-			//			else if (_T("nvPr") == strName)
-			//				nvPr = oNode;
-			//		}
-			//	}
-
-			//	FillParentPointersForChilds();
-			//}
-
-			//virtual std::wstring toXML() const;
-			//{
-			//	XmlUtils::CNodeValue oValue;
-			//	oValue.Write(cNvPr);
-			//	oValue.Write(cNvGrpSpPr);
-			//	oValue.Write(nvPr);
-
-			//	return XmlUtils::CreateNode(_T("p:nvGrpSpPr"), oValue);
-			//}
-
-			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
+			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const 
 			{
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->StartNode(_T("xdr:nvGrpSpPr"));
-				else
-					pWriter->StartNode(_T("p:nvGrpSpPr"));
+				std::wstring namespace_ = m_namespace;
+				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = L"xdr";
+
+				pWriter->StartNode(namespace_ + L":nvGrpSpPr");
 				
 				pWriter->EndAttributes();
 
@@ -112,12 +86,11 @@ namespace PPTX
 				cNvGrpSpPr.toXmlWriter(pWriter);
 
 				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_PPTX)
+				{
 					nvPr.toXmlWriter(pWriter);
+				}
 
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->EndNode(_T("xdr:nvGrpSpPr"));
-				else
-					pWriter->EndNode(_T("p:nvGrpSpPr"));
+				pWriter->EndNode(namespace_ + L":nvGrpSpPr");
 			}
 
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
@@ -159,17 +132,14 @@ namespace PPTX
 				pReader->Seek(_end_rec);
 			}
 
-		public:
+			std::wstring			m_namespace;
+
 			CNvPr		cNvPr;
 			CNvGrpSpPr	cNvGrpSpPr;
 			NvPr		nvPr;
 		protected:
 			virtual void FillParentPointersForChilds();
-			//{
-			//	cNvPr.SetParentPointer(this);
-			//	cNvGrpSpPr.SetParentPointer(this);
-			//	nvPr.SetParentPointer(this);
-			//}
+
 		};
 	} // namespace Logic
 } // namespace PPTX

ASCOfficePPTXFile/PPTXFormat/Logic/NvPicPr.h

@@ -46,8 +46,12 @@ namespace PPTX
 		class NvPicPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(NvPicPr)
+			WritingElement_AdditionConstructors(NvPicPr)
 
+			NvPicPr(std::wstring ns = L"p")
+			{
+				m_namespace = ns;
+			}
 			NvPicPr& operator=(const NvPicPr& oSrc)
 			{
 				parentFile		= oSrc.parentFile;
@@ -57,12 +61,35 @@ namespace PPTX
 				cNvPicPr	= oSrc.cNvPicPr;
 				nvPr		= oSrc.nvPr;
 
+				m_namespace	= oSrc.m_namespace;
+
 				return *this;
 			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+
+				if ( oReader.IsEmptyNode() )
+					return;
+					
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if (_T("cNvPr") == strName)
+						cNvPr.fromXML( oReader);
+					else if (_T("cNvPicPr") == strName)
+						cNvPicPr.fromXML( oReader);
+					else if (_T("nvPr") == strName)
+						nvPr.fromXML( oReader);
+				}
+			}
 
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
+				m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 				XmlUtils::CXmlNodes oNodes;
 				if (node.GetNodes(_T("*"), oNodes))
 				{
@@ -93,17 +120,17 @@ namespace PPTX
 				oValue.Write(cNvPicPr);
 				oValue.Write(nvPr);
 
-				return XmlUtils::CreateNode(_T("p:nvPicPr"), oValue);
+				return XmlUtils::CreateNode(m_namespace + L":nvPicPr", oValue);
 			}
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-					pWriter->StartNode(_T("pic:nvPicPr"));
-				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->StartNode(_T("xdr:nvPicPr"));
-				else
-					pWriter->StartNode(_T("p:nvPicPr"));
+				std::wstring namespace_ = m_namespace;
+
+				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)			namespace_ = L"pic";
+				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = L"xdr";
+
+				pWriter->StartNode(namespace_ + L":nvPicPr");
 
 				pWriter->EndAttributes();
 
@@ -113,12 +140,7 @@ namespace PPTX
 				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_PPTX)
 					nvPr.toXmlWriter(pWriter);
 
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-					pWriter->EndNode(_T("pic:nvPicPr"));
-				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->EndNode(_T("xdr:nvPicPr"));
-				else
-					pWriter->EndNode(_T("p:nvPicPr"));
+				pWriter->EndNode(namespace_ + L":nvPicPr");
 			}
 
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
@@ -159,11 +181,11 @@ namespace PPTX
 
 				pReader->Seek(_end_rec);
 			}
+			std::wstring	m_namespace;
 
-		public:
-			CNvPr		cNvPr;
-			CNvPicPr	cNvPicPr;
-			NvPr		nvPr;
+			CNvPr			cNvPr;
+			CNvPicPr		cNvPicPr;
+			NvPr			nvPr;
 		protected:
 			virtual void FillParentPointersForChilds()
 			{

ASCOfficePPTXFile/PPTXFormat/Logic/NvPr.h

@@ -44,8 +44,12 @@ namespace PPTX
 		class NvPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(NvPr)
-				
+			WritingElement_AdditionConstructors(NvPr)
+			
+			NvPr(std::wstring ns = L"p")
+			{
+				m_namespace = ns;
+			}
 			NvPr& operator=(const NvPr& oSrc)
 			{
 				isPhoto		=	oSrc.isPhoto;
@@ -58,19 +62,58 @@ namespace PPTX
 				
 				return *this;
 			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+				
+				ReadAttributes(oReader);
 
-		public:
+				if ( oReader.IsEmptyNode() )
+					return;
+						
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if (strName == L"ph")
+						ph = oReader;
+					else if (strName == L"extLst")
+					{
+						int nParentDepth1 = oReader.GetDepth();
+						while( oReader.ReadNextSiblingNode( nParentDepth1 ) )
+						{
+							Ext element;
+							element.fromXML(oReader);
+							extLst.push_back (element);
+						}
+					}
+					else
+					{
+						media.fromXML(oReader);
+					}
+				}
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("isPhoto"),	isPhoto)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("userDrawn"),	userDrawn)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
+				m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 				node.ReadAttributeBase(L"isPhoto", isPhoto);
 				node.ReadAttributeBase(L"userDrawn", userDrawn);
 
-				ph			= node.ReadNode(_T("p:ph"));
+				ph = node.ReadNodeNoNS(_T("ph"));
 				media.GetMediaFrom(node);
 
-				XmlUtils::CXmlNode list;
-				if (node.GetNode(_T("p:extLst"), list))
-				{
+				XmlUtils::CXmlNode list = node.ReadNodeNoNS(_T("extLst"));
+				if (list.IsValid())
+				{		
 					XmlUtils::CXmlNodes oNodes;
 					if (list.GetNodes(_T("*"), oNodes))
 					{
@@ -102,13 +145,9 @@ namespace PPTX
 			}
             virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
             {
-                std::wstring namespace_;
-                if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-                    namespace_= _T("pic");
-                else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-                    namespace_= _T("xdr");
-                else
-                    namespace_= _T("p");
+                std::wstring namespace_ = m_namespace;
+                if		(pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)	namespace_= _T("pic");
+                else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_= _T("xdr");
 
                 toXmlWriter2(namespace_, pWriter);
             }
@@ -191,17 +230,16 @@ namespace PPTX
 
 				pReader->Seek(_end_rec);
 			}
+			std::wstring		m_namespace;
+	// Attributes
+			nullable_bool		isPhoto;
+			nullable_bool		userDrawn;
 
-		public:
-			// Attributes
-			nullable_bool			isPhoto;
-			nullable_bool			userDrawn;
-
-			//Childs
-			nullable<Ph>			ph;
-			UniMedia				media;
-			//custDataLst
-			std::vector<Ext>			extLst;
+	//Childs
+			nullable<Ph>		ph;
+			UniMedia			media;
+	//custDataLst
+			std::vector<Ext>	extLst;
 		protected:
 			virtual void FillParentPointersForChilds()
 			{

ASCOfficePPTXFile/PPTXFormat/Logic/NvSpPr.h

@@ -46,7 +46,12 @@ namespace PPTX
 		class NvSpPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(NvSpPr)
+			WritingElement_AdditionConstructors(NvSpPr)
+
+			NvSpPr(std::wstring ns = L"p")
+			{
+				m_namespace = ns;
+			}
 
 			NvSpPr& operator=(const NvSpPr& oSrc)
 			{
@@ -58,10 +63,32 @@ namespace PPTX
 				nvPr	= oSrc.nvPr;
 				return *this;
 			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
 
-		public:
+				if ( oReader.IsEmptyNode() )
+					return;
+					
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if (_T("cNvPr") == strName)
+						cNvPr = oReader;
+					else if (_T("cNvSpPr") == strName)
+						cNvSpPr = oReader;
+					else if (_T("nvPr") == strName)
+						nvPr = oReader;
+				}
+
+				FillParentPointersForChilds();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
+				m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 				XmlUtils::CXmlNodes oNodes;
 				if (node.GetNodes(_T("*"), oNodes))
 				{
@@ -91,15 +118,17 @@ namespace PPTX
 				oValue.Write(cNvSpPr);
 				oValue.Write(nvPr);
 
-				return XmlUtils::CreateNode(_T("p:nvSpPr"), oValue);
+				return XmlUtils::CreateNode(m_namespace + L":nvSpPr", oValue);
 			}
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->StartNode(_T("xdr:nvSpPr"));
-				else
-					pWriter->StartNode(_T("p:nvSpPr"));
+				std::wstring namespace_ = m_namespace;
+				
+				if		(pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)	namespace_ = _T("wps");
+				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = _T("xdr");
+
+				pWriter->StartNode( namespace_ + L":nvSpPr");
 
 				pWriter->EndAttributes();
 
@@ -109,10 +138,7 @@ namespace PPTX
 				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_PPTX)
 					nvPr.toXmlWriter(pWriter);
 				
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->EndNode(_T("xdr:nvSpPr"));
-				else
-					pWriter->EndNode(_T("p:nvSpPr"));
+				pWriter->EndNode( namespace_ + L":nvSpPr");
 			}
 
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
@@ -154,10 +180,11 @@ namespace PPTX
 				pReader->Seek(_end_rec);
 			}
 
-		public:
-			CNvPr	cNvPr;
-			CNvSpPr cNvSpPr;
-			NvPr	nvPr;
+			std::wstring	m_namespace;
+
+			CNvPr			cNvPr;
+			CNvSpPr			cNvSpPr;
+			NvPr			nvPr;
 		protected:
 			virtual void FillParentPointersForChilds()
 			{

ASCOfficePPTXFile/PPTXFormat/Logic/Paragraph.h

@@ -127,7 +127,7 @@ namespace PPTX
 				int nParentDepth = oReader.GetDepth();
 				while( oReader.ReadNextSiblingNode( nParentDepth ) )
 				{
-					std::wstring strName = oReader.GetName();
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
 					WritingElement *pItem = NULL;
 
 					if (_T("pPr") == strName)

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

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

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)
 			{
 			}

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"<a:pt x=\"" + x1 + L"\" y=\"" + y1 + L"\" />";
-				std::wstring str2 = L"<a:pt x=\"" + x2 + L"\" y=\"" + y2 + L"\" />";
-				std::wstring str3 = L"<a:pt x=\"" + x3 + L"\" y=\"" + y3 + L"\" />";
+				std::wstring str1 = L"<a:pt x=\"" + x[0] + L"\" y=\"" + y[0] + L"\" />";
+				std::wstring str2 = L"<a:pt x=\"" + x[1] + L"\" y=\"" + y[1] + L"\" />";
+				std::wstring str3 = L"<a:pt x=\"" + x[2] + L"\" y=\"" + y[2] + L"\" />";
 
 				return _T("<a:cubicBezTo>") + str1 + str2 + str3 + _T("</a:cubicBezTo>");
 			}
@@ -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"<pt x=\"" + x1 + L"\" y=\"" + y1 + L"\"/>";
-				std::wstring str2 = L"<pt x=\"" + x2 + L"\" y=\"" + y2 + L"\"/>";
-				std::wstring str3 = L"<pt x=\"" + x3 + L"\" y=\"" + y3 + L"\"/>";
+				std::wstring str1 = L"<pt x=\"" + x[0] + L"\" y=\"" + y[0] + L"\"/>";
+				std::wstring str2 = L"<pt x=\"" + x[1] + L"\" y=\"" + y[1] + L"\"/>";
+				std::wstring str3 = L"<pt x=\"" + x[2] + L"\" y=\"" + y[2] + L"\"/>";
 
 				return _T("<cubicBezTo>") + str1 + str2 + str3 + _T("</cubicBezTo>");
 			}

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;

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;

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"<a:pt x=\"" + x1 + L"\" y=\"" + y1 + L"\" />";
-				std::wstring str2 = L"<a:pt x=\"" + x2 + L"\" y=\"" + y2 + L"\" />";
+				std::wstring str1 = L"<a:pt x=\"" + x[0] + L"\" y=\"" + y[0] + L"\" />";
+				std::wstring str2 = L"<a:pt x=\"" + x[1] + L"\" y=\"" + y[1] + L"\" />";
 
 				return _T("<a:quadBezTo>") + str1 + str2 + _T("</a:quadBezTo>");
 			}
@@ -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"<a:pt x=\"" + x1 + L"\" y=\"" + y1 + L"\" />";
-				std::wstring str2 = L"<a:pt x=\"" + x2 + L"\" y=\"" + y2 + L"\" />";
+				std::wstring str1 = L"<a:pt x=\"" + x[0] + L"\" y=\"" + y[0] + L"\" />";
+				std::wstring str2 = L"<a:pt x=\"" + x[1] + L"\" y=\"" + y[1] + L"\" />";
 
 				return _T("<quadBezTo>") + str1 + str2 + _T("</quadBezTo>");
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Ph.h

@@ -44,9 +44,26 @@ namespace PPTX
 		class Ph : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Ph)
+			WritingElement_AdditionConstructors(Ph)
 
-		public:
+			Ph()
+			{
+			}
+				
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes(oReader);
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("hasCustomPrompt"),	hasCustomPrompt)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("idx"),	idx)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("orient"),	orient)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("sz"),	sz)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("type"),	type)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"hasCustomPrompt", hasCustomPrompt);

ASCOfficePPTXFile/PPTXFormat/Logic/Pic.cpp

@@ -261,31 +261,59 @@ namespace PPTX
 			return sRes;
 		}
 
-		Pic::Pic()
+		Pic::Pic(std::wstring ns)
 		{
+			m_namespace = ns;
 		}
-
-
 		Pic::~Pic()
 		{
 		}
-	
-
 		Pic::Pic(XmlUtils::CXmlNode& node)
 		{
 			fromXML(node);
 		}
-
-
 		const Pic& Pic::operator =(XmlUtils::CXmlNode& node)
 		{
 			fromXML(node);
 			return *this;
 		}
+		Pic::Pic(XmlUtils::CXmlLiteReader& oReader)
+		{
+			fromXML(oReader);
+		}
+		const Pic& Pic::operator =(XmlUtils::CXmlLiteReader& oReader)
+		{
+			fromXML(oReader);
+			return *this;
+		}
+		void Pic::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+			m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+			
+			if ( oReader.IsEmptyNode() )
+				return;
+					
+			int nParentDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nParentDepth ) )
+			{
+				std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
 
+				if (_T("nvPicPr") == strName)
+					nvPicPr = oReader;
+				else if (_T("blipFill") == strName)
+					blipFill = oReader;
+				else if (_T("spPr") == strName)
+					spPr = oReader;
+				else if (_T("style") == strName)
+					style = oReader;
+			}
+			FillParentPointersForChilds();
+		}
 
 		void Pic::fromXML(XmlUtils::CXmlNode& node)
 		{
+			m_namespace = XmlUtils::GetNamespace(node.GetName());
+
 			XmlUtils::CXmlNodes oNodes;
 			if (node.GetNodes(_T("*"), oNodes))
 			{
@@ -327,7 +355,6 @@ namespace PPTX
 			FillParentPointersForChilds();
 		}
 
-
 		std::wstring Pic::toXML() const
 		{
 			XmlUtils::CNodeValue oValue;
@@ -336,7 +363,7 @@ namespace PPTX
 			oValue.Write(spPr);
 			oValue.WriteNullable(style);
 
-			return XmlUtils::CreateNode(_T("p:pic"), oValue);
+			return XmlUtils::CreateNode(m_namespace + L":pic", oValue);
 		}
 
 		void Pic::FillParentPointersForChilds()

ASCOfficePPTXFile/PPTXFormat/Logic/Pic.h

@@ -215,13 +215,23 @@ namespace PPTX
 		class Pic : public WrapperWritingElement
 		{
 		public:
-			Pic();
+			Pic(std::wstring ns = L"p");
 			virtual ~Pic();
+
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_pic;
+			}
+
 			explicit Pic(XmlUtils::CXmlNode& node);
 			const Pic& operator =(XmlUtils::CXmlNode& node);
+			
+			explicit Pic(XmlUtils::CXmlLiteReader& oReader);
+			const Pic& operator =(XmlUtils::CXmlLiteReader& oReader);
 
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node);
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			
 			virtual std::wstring toXML() const;
 			virtual void GetRect(Aggplus::RECT& pRect)const;
 			virtual std::wstring GetFullPicName()const;
@@ -255,16 +265,14 @@ namespace PPTX
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
+				std::wstring namespace_ = m_namespace;
 				bool bOle = false;
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->StartNode(_T("xdr:pic"));
-				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-				{
-					pWriter->StartNode(_T("pic:pic"));
-					pWriter->StartAttributes();
-					pWriter->WriteAttribute(_T("xmlns:pic"), (std::wstring)_T("http://schemas.openxmlformats.org/drawingml/2006/picture"));
-				}
-				else
+				
+				if		(pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = L"xdr";
+				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)	namespace_ = L"pic";
+
+				if (pWriter->m_lDocType != XMLWRITER_DOC_TYPE_XLSX && 
+					pWriter->m_lDocType != XMLWRITER_DOC_TYPE_DOCX)
 				{
 					if(oleObject.IsInit() && oleObject->isValid())
 					{
@@ -301,22 +309,19 @@ namespace PPTX
 
 						pWriter->WriteString(L"<p:embed/>");
 					}
-					pWriter->StartNode(_T("p:pic"));
 				}
+				pWriter->StartNode(namespace_ + L":pic");
 
+				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
+				{
+					pWriter->StartAttributes();
+					pWriter->WriteAttribute(_T("xmlns:pic"), (std::wstring)_T("http://schemas.openxmlformats.org/drawingml/2006/picture"));
+				}
 				pWriter->EndAttributes();
 
 				nvPicPr.toXmlWriter(pWriter);
 
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					blipFill.m_namespace = _T("xdr");
-				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-					blipFill.m_namespace = _T("pic");
-				else 
-					blipFill.m_namespace = _T("p");
-
-				if (blipFill.blip.is_init())
-					blipFill.blip->m_namespace = _T("a");
+				blipFill.m_namespace = namespace_;
 				blipFill.toXmlWriter(pWriter);
 
 				pWriter->m_lFlag = 1;
@@ -325,19 +330,16 @@ namespace PPTX
 				
 				pWriter->Write(style);
 
-				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					pWriter->EndNode(_T("xdr:pic"));
-				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-					pWriter->EndNode(_T("pic:pic"));
-				else
+				pWriter->EndNode(namespace_ + L":pic");
+				
+				if (pWriter->m_lDocType != XMLWRITER_DOC_TYPE_XLSX &&
+					pWriter->m_lDocType != XMLWRITER_DOC_TYPE_DOCX)
 				{
-					pWriter->EndNode(_T("p:pic"));
 					if(bOle)
 					{
 						pWriter->WriteString(L"</p:oleObj></a:graphicData></a:graphic></p:graphicFrame>");
 					}
 				}
-
 			}
 
 			virtual void fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
@@ -367,8 +369,7 @@ namespace PPTX
 						}
 						case 3:
 						{
-							style = new ShapeStyle();
-							style->m_ns = _T("p");
+							style = new ShapeStyle(L"p");
 							style->fromPPTY(pReader);
 							break;
 						}
@@ -401,13 +402,13 @@ namespace PPTX
 
 			void toXmlWriterVML(NSBinPptxRW::CXmlWriter* pWriter, smart_ptr<PPTX::WrapperFile>& oTheme, smart_ptr<PPTX::WrapperWritingElement>& oClrMap, bool in_group = false);
 			void fromXMLOle(XmlUtils::CXmlNode& node);
-		public:
 
 			NvPicPr					nvPicPr;
 			BlipFill				blipFill;
 			SpPr					spPr;
 			nullable<ShapeStyle>	style;
-			//internal
+		//internal
+			std::wstring			m_namespace;
 			nullable<COLEObject>	oleObject;
 		protected:
 			virtual void FillParentPointersForChilds();

ASCOfficePPTXFile/PPTXFormat/Logic/PrstDash.h

@@ -57,7 +57,7 @@ namespace PPTX
 			}
 			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
 			{
-				WritingElement_ReadAttributes_Start( oReader )
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
 					WritingElement_ReadAttributes_Read_if     ( oReader, _T("val"), val )
 				WritingElement_ReadAttributes_End( oReader )
 			}

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

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

ASCOfficePPTXFile/PPTXFormat/Logic/RunElem.h

@@ -59,7 +59,7 @@ namespace PPTX
 			}		
 			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
 			{
-				std::wstring name = oReader.GetName();
+				std::wstring name = XmlUtils::GetNameNoNS(oReader.GetName());
 
 				if(name == _T("r"))
 					Elem.reset(new Logic::Run(oReader));

ASCOfficePPTXFile/PPTXFormat/Logic/RunProperties.h

@@ -98,14 +98,19 @@ namespace PPTX
 		{
 		public:
 			WritingElement_AdditionConstructors(RunProperties)
-			PPTX_LOGIC_BASE2(RunProperties)
 			
+			RunProperties()
+			{
+				m_name = L"a:rPr";
+			}
 			virtual OOX::EElementType getType () const
 			{
 				return OOX::et_a_rPr;
 			}
 			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
 			{
+				m_name = oReader.GetName();
+
 				ReadAttributes( oReader );
 
 				if ( oReader.IsEmptyNode() )
@@ -114,34 +119,34 @@ namespace PPTX
 				int nParentDepth = oReader.GetDepth();
 				while( oReader.ReadNextSiblingNode( nParentDepth ) )
 				{
-					std::wstring sName = oReader.GetName();
+					std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
 					
-					if (L"a:blipFill"	== sName	||
-						L"a:gradFill"	== sName	||
-						L"a:grpFill"	== sName	||
-						L"a:noFill"		== sName	||
-						L"a:pattFill"	== sName	||
-						L"a:solidFill" == sName )
+					if (L"blipFill"	== sName	||
+						L"gradFill"	== sName	||
+						L"grpFill"	== sName	||
+						L"noFill"	== sName	||
+						L"pattFill"	== sName	||
+						L"solidFill" == sName )
 					{
 						Fill.fromXML(oReader);
 					}
-					else if ( _T("a:ln") == sName )
+					else if ( _T("ln") == sName )
 						ln = oReader;
-					else if ( _T("a:cs") == sName )
+					else if ( _T("cs") == sName )
 						cs = oReader;					
-					else if ( _T("a:ea") == sName )
+					else if ( _T("ea") == sName )
 						ea = oReader;				
-					else if ( _T("a:latin") == sName )
+					else if ( _T("latin") == sName )
 						latin = oReader;			
-					else if ( _T("a:sym") == sName )
+					else if ( _T("sym") == sName )
 						sym = oReader;		
-					else if ( _T("a:hlinkClick") == sName )
+					else if ( _T("hlinkClick") == sName )
 						hlinkClick = oReader;			
-					else if ( _T("a:rtl") == sName )
+					else if ( _T("rtl") == sName )
 						rtl = oReader;
-					else if (	L"a:effectDag"	== sName	||
-								L"a:effectLst"	== sName	||
-								L"a:extLst"		== sName )
+					else if (	L"effectDag"	== sName	||
+								L"effectLst"	== sName	||
+								L"extLst"		== sName )
 					{
 						EffectList.fromXML(oReader);		
 					}

ASCOfficePPTXFile/PPTXFormat/Logic/Shape.cpp

@@ -41,8 +41,9 @@ namespace PPTX
 {
 	namespace Logic
 	{
-		Shape::Shape()
+		Shape::Shape(std::wstring name_)
 		{
+			m_name = name_;
 		}
 
 		Shape::~Shape()
@@ -53,15 +54,61 @@ namespace PPTX
 		{
 			fromXML(node);
 		}
-
 		const Shape& Shape::operator =(XmlUtils::CXmlNode& node)
 		{
 			fromXML(node);
 			return *this;
 		}
+		Shape::Shape(XmlUtils::CXmlLiteReader& oReader)
+		{
+			fromXML(oReader);
+		}
+		const Shape& Shape::operator =(XmlUtils::CXmlLiteReader& oReader)
+		{
+			fromXML(oReader);
+			return *this;
+		}
+		void Shape::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+			m_name = oReader.GetName();
 
+			ReadAttributes( oReader );
+			
+			if ( oReader.IsEmptyNode() )
+				return;
+					
+			int nParentDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nParentDepth ) )
+			{
+				std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+				if (_T("nvSpPr") == strName)
+					nvSpPr = oReader;
+				else if (_T("spPr") == strName)
+					spPr = oReader;
+				else if (_T("style") == strName)
+					style = oReader;
+				else if (_T("txBody") == strName)
+					txBody = oReader;
+				else if (_T("txXfrm")  == strName)
+					txXfrm = oReader;
+				else if (_T("txbx") == strName || _T("textbox") == strName)
+					txBody = oReader;
+				else if (_T("cNvPr") == strName)
+					nvSpPr.cNvPr = oReader;
+				else if (_T("cNvSpPr") == strName)
+					nvSpPr.cNvSpPr = oReader;
+				else if (_T("txSp") == strName)
+					txBody = oReader;
+				else if (_T("bodyPr") == strName)
+					TextBoxBodyPr = oReader;
+			}
+			FillParentPointersForChilds();
+		}
 		void Shape::fromXML(XmlUtils::CXmlNode& node)
 		{
+			m_name = node.GetName();
+
 			node.ReadAttributeBase(L"useBgFill", attrUseBgFill);
 
 			XmlUtils::CXmlNodes oNodes;
@@ -112,7 +159,6 @@ namespace PPTX
 
 			FillParentPointersForChilds();
 		}
-
 		std::wstring Shape::toXML() const
 		{
 			XmlUtils::CAttribute oAttr;
@@ -124,17 +170,17 @@ namespace PPTX
 			oValue.WriteNullable(style);
 			oValue.WriteNullable(txBody);
 
-			return XmlUtils::CreateNode(_T("p:sp"), oAttr, oValue);
+			return XmlUtils::CreateNode(m_name, oAttr, oValue);
 		}		
 
 		void Shape::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 		{
-			if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-				pWriter->StartNode(_T("wps:wsp"));
-			else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-				pWriter->StartNode(_T("xdr:sp"));
-			else
-				pWriter->StartNode(_T("p:sp"));
+			std::wstring name_ = m_name;
+
+			if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)			name_ = L"wps:wsp";
+			else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	name_ = L"xdr:sp";
+				
+			pWriter->StartNode(name_);
 
 			pWriter->StartAttributes();
 			pWriter->WriteAttribute(_T("useBgFill"), attrUseBgFill);
@@ -142,7 +188,6 @@ namespace PPTX
 
 			if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
 			{
-				//nvSpPr.cNvPr.toXmlWriter2(_T("wps"), pWriter);
 				nvSpPr.cNvSpPr.toXmlWriter2(_T("wps"), pWriter);
 			}
 			else
@@ -166,9 +211,9 @@ namespace PPTX
 			if (style.is_init())
 			{
 				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-					style->m_ns = _T("wps");
+					style->m_namespace = _T("wps");
 				else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-					style->m_ns = _T("xdr");
+					style->m_namespace = _T("xdr");
 
                 pWriter->Write(style);
             }
@@ -176,7 +221,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 +243,7 @@ namespace PPTX
 				}
 				else if (txBody.is_init())
 				{
-					txBody->m_ns = _T("wps");
+					txBody->m_name = _T("wps:txBody");
 					pWriter->Write(txBody);
 				}
 
@@ -208,12 +253,7 @@ namespace PPTX
 				}
 			}
 
-			if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
-				pWriter->EndNode(_T("wps:wsp"));
-			else if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)
-				pWriter->EndNode(_T("xdr:sp"));
-			else
-				pWriter->EndNode(_T("p:sp"));
+			pWriter->EndNode(name_);
 		}
 		
 		void Shape::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
@@ -257,8 +297,7 @@ namespace PPTX
 					}
 					case 2:
 					{
-						style = new ShapeStyle();
-						style->m_ns = _T("p");
+						style = new ShapeStyle(L"p");
 						style->fromPPTY(pReader);
 						break;
 					}
@@ -371,7 +410,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 +636,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 +779,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")

ASCOfficePPTXFile/PPTXFormat/Logic/Shape.h

@@ -275,19 +275,31 @@ namespace PPTX
 		class Shape : public WrapperWritingElement
 		{
 		public:
-			Shape();
+			Shape(std::wstring name_ = L"p:sp");
 			virtual ~Shape();			
+			
 			explicit Shape(XmlUtils::CXmlNode& node);
 			const Shape& operator =(XmlUtils::CXmlNode& node);
 
+			explicit Shape(XmlUtils::CXmlLiteReader& oReader);
+			const Shape& operator =(XmlUtils::CXmlLiteReader& oReader);
+
 			virtual OOX::EElementType getType () const
 			{
-				return OOX::et_p_Shape;
+				return OOX::et_a_Shape;
 			}
 
 			virtual void fromXML(XmlUtils::CXmlNode& node);
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+
 			virtual std::wstring toXML() const;
 
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_ReadSingle( oReader, _T("useBgFill"),	attrUseBgFill)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			std::wstring GetText()const{if(txBody.IsInit()) return txBody->GetText(); return _T(""); };
 
 			void GetShapeFullDescription(Shape& shape, int level = 0)const;
@@ -312,6 +324,8 @@ namespace PPTX
 			virtual void toXmlWriter	(NSBinPptxRW::CXmlWriter* pWriter) const;			
 			virtual void fromPPTY		(NSBinPptxRW::CBinaryFileReader* pReader);
 
+			std::wstring			m_name;
+
 			NvSpPr					nvSpPr;
 			SpPr					spPr;
 			nullable<ShapeStyle>	style;
@@ -324,7 +338,7 @@ namespace PPTX
 			bool								isFontRefInSlide;
 			mutable nullable<TextParagraphPr>	body[10];
  
-			// Attributes
+	// Attributes
 			nullable_bool			attrUseBgFill;
 		protected:
 			virtual void FillParentPointersForChilds();

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<Slide>())
-				return bodyPr.parentFileAs<Slide>().GetRGBAFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideLayout>())
-				return bodyPr.parentFileAs<SlideLayout>().GetRGBAFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideMaster>())
-				return bodyPr.parentFileAs<SlideMaster>().GetRGBAFromMap(_T("hlink"));
+			if (!bodyPr.IsInit()) return 0;
+
+			if(bodyPr->parentFileIs<Slide>())
+				return bodyPr->parentFileAs<Slide>().GetRGBAFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideLayout>())
+				return bodyPr->parentFileAs<SlideLayout>().GetRGBAFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideMaster>())
+				return bodyPr->parentFileAs<SlideMaster>().GetRGBAFromMap(_T("hlink"));
 			else return 0;
 		}
 
 		DWORD ShapeProperties::GetHyperlinkARGB()const
 		{
-			if(bodyPr.parentFileIs<Slide>())
-				return bodyPr.parentFileAs<Slide>().GetARGBFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideLayout>())
-				return bodyPr.parentFileAs<SlideLayout>().GetARGBFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideMaster>())
-				return bodyPr.parentFileAs<SlideMaster>().GetARGBFromMap(_T("hlink"));
+			if (!bodyPr.IsInit()) return 0;
+
+			if(bodyPr->parentFileIs<Slide>())
+				return bodyPr->parentFileAs<Slide>().GetARGBFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideLayout>())
+				return bodyPr->parentFileAs<SlideLayout>().GetARGBFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideMaster>())
+				return bodyPr->parentFileAs<SlideMaster>().GetARGBFromMap(_T("hlink"));
 			else return 0;
 		}
 
 		DWORD ShapeProperties::GetHyperlinkBGRA()const
 		{
-			if(bodyPr.parentFileIs<Slide>())
-				return bodyPr.parentFileAs<Slide>().GetBGRAFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideLayout>())
-				return bodyPr.parentFileAs<SlideLayout>().GetBGRAFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideMaster>())
-				return bodyPr.parentFileAs<SlideMaster>().GetBGRAFromMap(_T("hlink"));
+			if (!bodyPr.IsInit()) return 0;
+
+			if(bodyPr->parentFileIs<Slide>())
+				return bodyPr->parentFileAs<Slide>().GetBGRAFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideLayout>())
+				return bodyPr->parentFileAs<SlideLayout>().GetBGRAFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideMaster>())
+				return bodyPr->parentFileAs<SlideMaster>().GetBGRAFromMap(_T("hlink"));
 			else return 0;
 		}
 
 		DWORD ShapeProperties::GetHyperlinkABGR()const
 		{
-			if(bodyPr.parentFileIs<Slide>())
-				return bodyPr.parentFileAs<Slide>().GetABGRFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideLayout>())
-				return bodyPr.parentFileAs<SlideLayout>().GetABGRFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideMaster>())
-				return bodyPr.parentFileAs<SlideMaster>().GetABGRFromMap(_T("hlink"));
+			if (!bodyPr.IsInit()) return 0;
+
+			if(bodyPr->parentFileIs<Slide>())
+				return bodyPr->parentFileAs<Slide>().GetABGRFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideLayout>())
+				return bodyPr->parentFileAs<SlideLayout>().GetABGRFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideMaster>())
+				return bodyPr->parentFileAs<SlideMaster>().GetABGRFromMap(_T("hlink"));
 			else return 0;
 		}
 

ASCOfficePPTXFile/PPTXFormat/Logic/ShapeProperties.h

@@ -56,7 +56,7 @@ namespace PPTX
 			nullable<FontRef>			fontStyle;
 			nullable<TextParagraphPr>	levels[10];
 			nullable<TextParagraphPr>	masters[10];
-			BodyPr bodyPr;
+			nullable<BodyPr>			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<TextParagraphPr>& pParagraph)const;
 			int	GetParagraphLeftMargin		(int level, const nullable<TextParagraphPr>& pParagraph)const;

ASCOfficePPTXFile/PPTXFormat/Logic/ShapeStyle.h

@@ -44,8 +44,12 @@ namespace PPTX
 		class ShapeStyle : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(ShapeStyle)
+			WritingElement_AdditionConstructors(ShapeStyle)
 
+			ShapeStyle(std::wstring ns = L"a")
+			{
+				m_namespace = ns;
+			}	
 			ShapeStyle& operator=(const ShapeStyle& oSrc)
 			{
 				parentFile		= oSrc.parentFile;
@@ -56,7 +60,7 @@ namespace PPTX
 				effectRef	= oSrc.effectRef;
 				fontRef		= oSrc.fontRef;
 
-				m_ns		= oSrc.m_ns;
+				m_namespace	= oSrc.m_namespace;
 
 				return *this;
 			}
@@ -64,10 +68,33 @@ namespace PPTX
 			{
 				return OOX::et_p_style;
 			}
-		public:
+			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+					
+					if (_T("lnRef") == strName)
+						lnRef.fromXML(oReader);
+					else if (_T("fillRef") == strName)
+						fillRef.fromXML(oReader);
+					else if (_T("effectRef") == strName)
+						effectRef.fromXML(oReader);
+					else if (_T("fontRef") == strName)
+						fontRef.fromXML(oReader);
+				}
+				FillParentPointersForChilds();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
-				m_ns = XmlUtils::GetNamespace(node.GetName());
+				m_namespace = XmlUtils::GetNamespace(node.GetName());
 
 				XmlUtils::CXmlNodes oNodes;
 				if (node.GetNodes(_T("*"), oNodes))
@@ -106,12 +133,12 @@ namespace PPTX
 				oValue.Write(effectRef);
 				oValue.Write(fontRef);
 
-				return XmlUtils::CreateNode(m_ns + _T(":style"), oAttr, oValue);
+				return XmlUtils::CreateNode(m_namespace + _T(":style"), oAttr, oValue);
 			}
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
-				pWriter->StartNode(m_ns + _T(":style"));
+				pWriter->StartNode(m_namespace + _T(":style"));
 				pWriter->EndAttributes();
 
 				lnRef.toXmlWriter(pWriter);
@@ -119,7 +146,7 @@ namespace PPTX
 				effectRef.toXmlWriter(pWriter);
 				fontRef.toXmlWriter(pWriter);
 				
-				pWriter->EndNode(m_ns + _T(":style"));
+				pWriter->EndNode(m_namespace + _T(":style"));
 			}
 
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
@@ -177,7 +204,7 @@ namespace PPTX
 			StyleRef	effectRef;
 			FontRef		fontRef;
 
-			mutable std::wstring m_ns;
+			mutable std::wstring m_namespace;
 		protected:
 			virtual void FillParentPointersForChilds()
 			{

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<Slide>())
-				return bodyPr.parentFileAs<Slide>().GetRGBAFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideLayout>())
-				return bodyPr.parentFileAs<SlideLayout>().GetRGBAFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideMaster>())
-				return bodyPr.parentFileAs<SlideMaster>().GetRGBAFromMap(_T("hlink"));
+			if (!bodyPr.IsInit()) return 0;
+			
+			if(bodyPr->parentFileIs<Slide>())
+				return bodyPr->parentFileAs<Slide>().GetRGBAFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideLayout>())
+				return bodyPr->parentFileAs<SlideLayout>().GetRGBAFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideMaster>())
+				return bodyPr->parentFileAs<SlideMaster>().GetRGBAFromMap(_T("hlink"));
 			else return 0;
 		}
 		DWORD CShapeTextProperties::GetHyperlinkARGB()const
 		{
-			if(bodyPr.parentFileIs<Slide>())
-				return bodyPr.parentFileAs<Slide>().GetARGBFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideLayout>())
-				return bodyPr.parentFileAs<SlideLayout>().GetARGBFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideMaster>())
-				return bodyPr.parentFileAs<SlideMaster>().GetARGBFromMap(_T("hlink"));
+			if (!bodyPr.IsInit()) return 0;
+	
+			if(bodyPr->parentFileIs<Slide>())
+				return bodyPr->parentFileAs<Slide>().GetARGBFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideLayout>())
+				return bodyPr->parentFileAs<SlideLayout>().GetARGBFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideMaster>())
+				return bodyPr->parentFileAs<SlideMaster>().GetARGBFromMap(_T("hlink"));
 			else return 0;
 		}
 		DWORD CShapeTextProperties::GetHyperlinkBGRA()const
 		{
-			if(bodyPr.parentFileIs<Slide>())
-				return bodyPr.parentFileAs<Slide>().GetBGRAFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideLayout>())
-				return bodyPr.parentFileAs<SlideLayout>().GetBGRAFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideMaster>())
-				return bodyPr.parentFileAs<SlideMaster>().GetBGRAFromMap(_T("hlink"));
+			if (!bodyPr.IsInit()) return 0;
+
+			if(bodyPr->parentFileIs<Slide>())
+				return bodyPr->parentFileAs<Slide>().GetBGRAFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideLayout>())
+				return bodyPr->parentFileAs<SlideLayout>().GetBGRAFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideMaster>())
+				return bodyPr->parentFileAs<SlideMaster>().GetBGRAFromMap(_T("hlink"));
 			else return 0;
 		}
 		DWORD CShapeTextProperties::GetHyperlinkABGR()const
 		{
-			if(bodyPr.parentFileIs<Slide>())
-				return bodyPr.parentFileAs<Slide>().GetABGRFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideLayout>())
-				return bodyPr.parentFileAs<SlideLayout>().GetABGRFromMap(_T("hlink"));
-			else if(bodyPr.parentFileIs<SlideMaster>())
-				return bodyPr.parentFileAs<SlideMaster>().GetABGRFromMap(_T("hlink"));
+			if (!bodyPr.IsInit()) return 0;
+
+			if(bodyPr->parentFileIs<Slide>())
+				return bodyPr->parentFileAs<Slide>().GetABGRFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideLayout>())
+				return bodyPr->parentFileAs<SlideLayout>().GetABGRFromMap(_T("hlink"));
+			else if(bodyPr->parentFileIs<SlideMaster>())
+				return bodyPr->parentFileAs<SlideMaster>().GetABGRFromMap(_T("hlink"));
 			else return 0;
 		}
 
 		void CShapeTextProperties::SetParentFilePointer(const WrapperFile* pFile)
 		{
-			bodyPr.SetParentFilePointer(pFile);
+			if (bodyPr.IsInit())
+				bodyPr->SetParentFilePointer(pFile);
 
 			m_pFile = pFile;
 

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<TextParagraphPr>	m_levels[10];
 			nullable<TextParagraphPr>	m_body[10];
-			BodyPr bodyPr;
+			nullable<BodyPr>			bodyPr;
 
 			// просто указатель - он должен выставиться из темы
 			std::vector<nullable<TextParagraphPr>*>*	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<WORD> GetParagraphAlgn		(int level, const nullable<TextParagraphPr>& pParagraph)const;
 			nullable_base<LONG>	GetParagraphLeftMargin	(int level, const nullable<TextParagraphPr>& pParagraph)const;

ASCOfficePPTXFile/PPTXFormat/Logic/SmartArt.cpp

@@ -46,9 +46,15 @@ namespace PPTX
 	{
 		void SmartArt::LoadDrawing(NSBinPptxRW::CBinaryFileWriter* pWriter)
 		{
+			if (m_diag.IsInit()) 
+				return ;
+
 			FileContainer* pRels = NULL;
-			if (pWriter->m_pCommonRels->is_init())
-				pRels = pWriter->m_pCommonRels->operator ->();
+			if (pWriter)
+			{
+				if (pWriter->m_pCommonRels->is_init())
+					pRels = pWriter->m_pCommonRels->operator ->();
+			}
 
 			smart_ptr<OOX::File>	oFileData;
 			smart_ptr<OOX::File>	oFileDrawing;
@@ -101,7 +107,7 @@ namespace PPTX
                 pDiagramDrawing = dynamic_cast<OOX::CDiagramDrawing*>(oFileDrawing.operator->());
 			}
 
-			if (!pDiagramDrawing)
+			if (!pDiagramDrawing && pDiagramData)
 			{
 				// easy4cargo1.pptx - слайд 2 - в диаграмме Smart вместо ссылки на drawing.xml ссылка на стороннюю картинку
                OOX::CPath pathDiagramData = pDiagramData->m_strFilename;
@@ -118,7 +124,9 @@ namespace PPTX
 
 			if ((pDiagramDrawing) && (pDiagramDrawing->m_oShapeTree.IsInit()))
 			{
-				m_diag			= pDiagramDrawing->m_oShapeTree;
+				m_diag = pDiagramDrawing->m_oShapeTree;
+				FillParentPointersForChilds();
+
 				m_oCommonRels	= smart_ptr<PPTX::CCommonRels>( new PPTX::CCommonRels());
 				m_oCommonRels->_read(pDiagramDrawing->m_oReadPath);
 			}
@@ -169,7 +177,15 @@ namespace PPTX
 			*oDrawingConverter.m_pBinaryWriter->m_pCommonRels = pOldRels;
 			oDrawingConverter.m_pBinaryWriter = pOldWriter;
 		}
+		std::wstring ChartRec::toXML() const
+		{
+			if (!id_data.is_init() || NULL == m_bData)
+				return L"";
+            std::wstring strData = L"<c:chart xmlns:c=\"http://schemas.openxmlformats.org/drawingml/2006/chart\" \
+xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" r:id=\"" + id_data->ToString() + L"\"/>";
 
+			return strData;
+		}
 		void ChartRec::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 		{
 			if (!id_data.is_init() || NULL == m_bData)

ASCOfficePPTXFile/PPTXFormat/Logic/SmartArt.h

@@ -42,7 +42,11 @@ namespace PPTX
 		class SmartArt : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(SmartArt)
+			WritingElement_AdditionConstructors(SmartArt)
+
+			SmartArt()
+			{
+			}
 
 			SmartArt& operator=(const SmartArt& oSrc)
 			{
@@ -52,15 +56,28 @@ namespace PPTX
 				m_diag = oSrc.m_diag;
 				return *this;
 			}
-
-		public:
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_Read_if	  ( oReader, _T("r:cs"), id_color)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("r:dm"), id_data)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("r:lo"), id_layout)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("r:qs"), id_style)
+				WritingElement_ReadAttributes_End	( oReader )
+			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+				//FillParentPointersForChilds();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"r:dm", id_data);
-				FillParentPointersForChilds();
+				node.ReadAttributeBase(L"r:cs", id_color);
+				node.ReadAttributeBase(L"r:lo", id_layout);
+				node.ReadAttributeBase(L"r:qs", id_style);
+				//FillParentPointersForChilds();
 			}
-
-
 			virtual std::wstring toXML() const
 			{
 				return _T("");
@@ -86,9 +103,10 @@ namespace PPTX
 				pReader->SkipRecord();
 			}
 
-		public:
-
-			nullable<OOX::RId> id_data;
+			nullable<OOX::RId>				id_data;
+			nullable<OOX::RId>				id_color;
+			nullable<OOX::RId>				id_layout;
+			nullable<OOX::RId>				id_style;
 
 			nullable<PPTX::Logic::SpTree>	m_diag;
 			smart_ptr<PPTX::CCommonRels>	m_oCommonRels;
@@ -100,34 +118,24 @@ namespace PPTX
 			}
 
 		public:
-			void LoadDrawing(NSBinPptxRW::CBinaryFileWriter* pWriter);
+			void LoadDrawing(NSBinPptxRW::CBinaryFileWriter* pWriter = NULL);
 		};
 
 		class ChartRec : public WrapperWritingElement
 		{
 		public:
+			WritingElement_AdditionConstructors(ChartRec)
+			
 			ChartRec()	
 			{
 				m_bData = false;
 				m_lChartNumber = 0;
 			}
-			virtual ~ChartRec() 
-			{
-			}
-			explicit ChartRec(XmlUtils::CXmlNode& node)	
-			{ 
-				fromXML(node); 
-			}
-			const ChartRec& operator =(XmlUtils::CXmlNode& node)
-			{
-				fromXML(node);
-				return *this;
-			}
+
 			ChartRec(const ChartRec& oSrc) 
 			{ 
 				*this = oSrc; 
 			}
-
 			ChartRec& operator=(const ChartRec& oSrc)
 			{
 				parentFile		= oSrc.parentFile;
@@ -135,8 +143,18 @@ namespace PPTX
 
 				return *this;
 			}
-
-		public:
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("r:id"), id_data )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_bData = false;
+				ReadAttributes( oReader );
+				FillParentPointersForChilds();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_bData = false;
@@ -144,24 +162,16 @@ namespace PPTX
 				node.ReadAttributeBase(L"r:id", id_data);
 				FillParentPointersForChilds();
 			}
-
-
-			virtual std::wstring toXML() const
-			{
-				return _T("");
-			}
-
+			virtual std::wstring toXML() const;
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const;
+			
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const;
-
 			virtual void fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader);
 
-		public:
+			nullable<OOX::RId>	id_data;
 
-			nullable<OOX::RId> id_data;
-
-			LONG m_lChartNumber;
-			bool m_bData;
+			LONG				m_lChartNumber;
+			bool				m_bData;
 		protected:
 			virtual void FillParentPointersForChilds()
 			{				

ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.cpp

@@ -39,31 +39,78 @@ namespace PPTX
 {
 	namespace Logic
 	{
-
-		SpPr::SpPr()
+		SpPr::SpPr(std::wstring ns)
 		{
+			m_namespace = ns;
 			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());

ASCOfficePPTXFile/PPTXFormat/Logic/SpPr.h

@@ -52,17 +52,30 @@ namespace PPTX
 		class SpPr : public WrapperWritingElement
 		{
 		public:
-			SpPr();
-			virtual ~SpPr();			
+			SpPr(std::wstring ns = L"a");
+			virtual ~SpPr();	
+
 			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

ASCOfficePPTXFile/PPTXFormat/Logic/SpTree.h

@@ -49,7 +49,11 @@ namespace PPTX
 		class SpTree : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(SpTree)
+			WritingElement_AdditionConstructors(SpTree)
+
+			SpTree()
+			{
+			}
 
 			SpTree& operator=(const SpTree& oSrc)
 			{
@@ -70,7 +74,43 @@ namespace PPTX
 			{
 				return OOX::et_p_ShapeTree;
 			}
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_name = oReader.GetName();
+				
+				SpTreeElems.clear();
+
+				if ( oReader.IsEmptyNode() )
+					return;
+					
+				int nParentDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nParentDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if (strName == L"nvGrpSpPr")
+						nvGrpSpPr.fromXML(oReader);
+					else if (strName == L"grpSpPr")
+						grpSpPr.fromXML(oReader);
+					else if (_T("cNvPr") == strName)
+					{
+						nvGrpSpPr.cNvPr = oReader;
+					}
+					else if (_T("cNvGrpSpPr") == strName)
+					{
+						nvGrpSpPr.cNvGrpSpPr = oReader;
+					}
+					else
+					{
+						SpTreeElem elem(oReader);
+						if (elem.is_init())
+							SpTreeElems.push_back(elem);
+					}
+				}
+
+				FillParentPointersForChilds();
+			}
+
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_name = node.GetName();
@@ -256,9 +296,8 @@ namespace PPTX
 			Logic::NvGrpSpPr		nvGrpSpPr;
 			Logic::GrpSpPr			grpSpPr;
 			std::vector<SpTreeElem>	SpTreeElems;
-		//private:
-		public:
-			std::wstring m_name;
+
+			std::wstring			m_name;
 		protected:
 			virtual void FillParentPointersForChilds()
 			{

ASCOfficePPTXFile/PPTXFormat/Logic/SpTreeElem.cpp

@@ -180,7 +180,6 @@ namespace PPTX
 			}
 			*/
 		}
-
         void CalculateLine(PPTX::Logic::SpPr& oSpPr, nullable<ShapeStyle>& pShapeStyle, NSCommon::smart_ptr<PPTX::WrapperFile>& _oTheme,
                            NSCommon::smart_ptr<PPTX::WrapperWritingElement>& _oClrMap, std::wstring& strAttr, std::wstring& strNode, bool bOle)
 		{
@@ -213,30 +212,65 @@ namespace PPTX
 				strAttr += s;
 			}
 		}
-
 		SpTreeElem::SpTreeElem()
 		{
 		}
-
-
 		SpTreeElem::~SpTreeElem()
 		{
 		}
-	
-
 		SpTreeElem::SpTreeElem(XmlUtils::CXmlNode& node)
 		{
 			fromXML(node);
 		}
-
-
 		const SpTreeElem& SpTreeElem::operator =(XmlUtils::CXmlNode& node)
 		{
 			fromXML(node);
 			return *this;
 		}
+		SpTreeElem::SpTreeElem(XmlUtils::CXmlLiteReader& oReader)
+		{
+			fromXML(oReader);
+		}
+		const SpTreeElem& SpTreeElem::operator =(XmlUtils::CXmlLiteReader& oReader)
+		{
+			fromXML(oReader);
+			return *this;
+		}
+		void SpTreeElem::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+			std::wstring name = XmlUtils::GetNameNoNS(oReader.GetName());
 
-
+			if (name == _T("sp") || name == _T("wsp"))
+				m_elem.reset(new Logic::Shape(oReader));
+			else if (name == _T("pic"))
+				m_elem.reset(new Logic::Pic(oReader));
+			else if (name == _T("cxnSp"))
+				m_elem.reset(new Logic::CxnSp(oReader));
+			else if (name == _T("grpSp") || name == _T("wgp") || name == _T("spTree") || name == _T("lockedCanvas"))
+				m_elem.reset(new Logic::SpTree(oReader));
+			else if (name == _T("graphicFrame"))
+				m_elem.reset(new Logic::GraphicFrame(oReader));
+			else if (name == _T("AlternateContent"))
+			{
+				bool isEmpty = true;
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+					if (strName == L"mc:Choice")
+					{
+						//GetAttributeIfExist(L"Requires", sRequires) && L"a14" == sRequires)
+						fromXML(oReader);
+						break;
+					}
+					else if (strName == L"mc:Fallback")
+					{
+						fromXML(oReader);
+					}
+				}
+			}
+			else m_elem.reset();
+		}
 		void SpTreeElem::fromXML(XmlUtils::CXmlNode& node)
 		{
 			std::wstring name = XmlUtils::GetNameNoNS(node.GetName());

ASCOfficePPTXFile/PPTXFormat/Logic/SpTreeElem.h

@@ -51,17 +51,28 @@ namespace PPTX
 		public:
 			SpTreeElem();
 			virtual ~SpTreeElem();
+
+			virtual OOX::EElementType getType () const
+			{
+				if (m_elem.IsInit())
+					return m_elem->getType();
+				return OOX::et_Unknown;
+			}
 			explicit SpTreeElem(XmlUtils::CXmlNode& node);
 			const SpTreeElem& operator =(XmlUtils::CXmlNode& node);
 
+			explicit SpTreeElem(XmlUtils::CXmlLiteReader& oReader);
+			const SpTreeElem& operator =(XmlUtils::CXmlLiteReader& oReader);
+
 			SpTreeElem& operator=(const SpTreeElem& oSrc)
 			{
 				m_elem = oSrc.m_elem;
 				return *this;
 			}
 			
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node);
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+
 			virtual std::wstring toXML() const;
             virtual bool is_init() const {return (m_elem.IsInit());}
 

ASCOfficePPTXFile/PPTXFormat/Logic/StyleRef.h

@@ -44,9 +44,33 @@ namespace PPTX
 		class StyleRef : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(StyleRef)
+			WritingElement_AdditionConstructors(StyleRef)
 
-		public:
+			StyleRef()
+			{
+			}
+
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_Unknown;
+			}
+
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_name = oReader.GetName();
+
+				ReadAttributes( oReader );
+				
+				Color.fromXMLParent(oReader);
+				
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_ReadSingle( oReader, _T("idx"), idx )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_name = node.GetName();