..

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

@@ -85,9 +85,10 @@ void OoxConverter::convert(PPTX::Logic::Shape *oox_shape)
 
 		if (type == SimpleTypes::shapetypeRect && oox_shape->txBody.IsInit()) type = 2000;
 
-		if (type == 2000 && oox_shape->txBody->bodyPr.fromWordArt.get_value_or(false))
+		if (type == 2000 && oox_shape->txBody->bodyPr.IsInit() 
+			&& oox_shape->txBody->bodyPr->fromWordArt.get_value_or(false))
 		{
-			int wordart_type = convert(oox_shape->txBody->bodyPr.prstTxWarp.GetPointer());
+			int wordart_type = convert(oox_shape->txBody->bodyPr->prstTxWarp.GetPointer());
 
 			if (wordart_type > 0) type = wordart_type;
 		}
@@ -111,7 +112,7 @@ void OoxConverter::convert(PPTX::Logic::Shape *oox_shape)
 			odf_context()->drawing_context()->set_text( odf_context()->text_context());
 			
 		//наложим внешние настройки для текста
-			convert(&oox_shape->txBody->bodyPr);			
+			convert(oox_shape->txBody->bodyPr.GetPointer());			
 			
 			if (oox_shape->style.IsInit())
 			{
@@ -281,15 +282,15 @@ void OoxConverter::convert(PPTX::Logic::PathBase *oox_path)
 	}
 	if (cubicBezTo)
 	{
-		std::wstring path_elm =	cubicBezTo->x1 + L" " + cubicBezTo->y1 + L" " +
-								cubicBezTo->x2 + L" " + cubicBezTo->y2 + L" " +
-								cubicBezTo->x3 + L" " + cubicBezTo->y3;	
+		std::wstring path_elm =	cubicBezTo->x[0] + L" " + cubicBezTo->y[0] + L" " +
+								cubicBezTo->x[1] + L" " + cubicBezTo->y[1] + L" " +
+								cubicBezTo->x[2] + L" " + cubicBezTo->y[2];	
 		odf_context()->drawing_context()->add_path_element(std::wstring(L"C"), path_elm);
 	}
 	if (quadBezTo)
 	{
-		std::wstring path_elm =	quadBezTo->x1 + L" " + quadBezTo->y1 + L" " +
-								quadBezTo->x2 + L" " + quadBezTo->y2;	
+		std::wstring path_elm =	quadBezTo->x[0] + L" " + quadBezTo->y[0] + L" " +
+								quadBezTo->x[1] + L" " + quadBezTo->y[1];	
 		odf_context()->drawing_context()->add_path_element(std::wstring(L"S"), path_elm);
 	}
 	if (arcTo)

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
@@ -495,8 +494,8 @@ public:
 		void convert(OOX::Spreadsheet::CT_LineSer				*ser);
 		void convert(OOX::Spreadsheet::CT_AxDataSource			*cat, int type);
 		void convert(OOX::Spreadsheet::CT_NumDataSource			*val);
-		void convert(OOX::Spreadsheet::CRichText				*rich);
-		void convert(OOX::Spreadsheet::CTextProperties			*txPr);
+		//void convert(OOX::Spreadsheet::CRichText				*rich);
+		//void convert(OOX::Spreadsheet::CTextProperties		*txPr);
 		void convert(OOX::Spreadsheet::CT_Tx					*ct_tx);
 		void convert(OOX::Spreadsheet::CT_Layout				*ct_layout);
 		void convert(OOX::Spreadsheet::CT_ManualLayout			*ct_layout);

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

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/Backdrop.h

@@ -43,9 +43,60 @@ namespace PPTX
 		class Backdrop : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Backdrop)
+			WritingElement_AdditionConstructors(Backdrop)
+			PPTX_LOGIC_BASE2(Backdrop)
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_backdrop;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+					nullable_int x, y, z;
+
+					if (strName == L"a:anchor")
+					{
+						ReadAttributes(oReader, x, y, z);
+						anchorX = x.get_value_or(0);
+						anchorY = y.get_value_or(0);
+						anchorZ = z.get_value_or(0);
+					}
+					else if (strName == L"a:norm")
+					{
+						ReadAttributes(oReader, x, y, z);
+						normX = x.get_value_or(0);
+						normY = y.get_value_or(0);
+						normZ = z.get_value_or(0);
+					}
+					else if (strName == L"a:up")
+					{
+						ReadAttributes(oReader, x, y, z);
+						
+						upX = x.get_value_or(0);
+						upY = y.get_value_or(0);
+						upZ = z.get_value_or(0);
+					}
+				}
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader, nullable_int & x, nullable_int & y, nullable_int & z )
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("x"), x)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("y"), y)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("z"), z)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("dx"), x)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("dy"), y)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("dz"), z)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				XmlUtils::CXmlNode oNodeA = node.ReadNode(_T("a:anchor"));

ASCOfficePPTXFile/PPTXFormat/Logic/Bevel.h

@@ -44,9 +44,27 @@ namespace PPTX
 		class Bevel : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Bevel)
+			WritingElement_AdditionConstructors(Bevel)
+			PPTX_LOGIC_BASE2(Bevel)
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_bevel;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_name	= XmlUtils::GetNameNoNS(oReader.GetName());
+
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("w"), w)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("h"), h)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("prst"), prst)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_name	= XmlUtils::GetNameNoNS(node.GetName());

ASCOfficePPTXFile/PPTXFormat/Logic/BodyPr.h

@@ -51,9 +51,63 @@ namespace PPTX
 		class BodyPr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BodyPr)
+			WritingElement_AdditionConstructors(BodyPr)
+			PPTX_LOGIC_BASE2(BodyPr)
 
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+					
+					if (L"a:prstTxWarp" == strName)
+						prstTxWarp = oReader;
+					else if (L"a:scene3d" == strName)
+						scene3d = oReader;
+					else if (L"a:sp3d" == strName)
+						sp3d = oReader;
+					else if (strName == L"a:noAutofit" || strName == L"a:spAutoFit" || strName == L"a:normAutofit")
+						Fit.fromXML(oReader);
+					else if (L"a:flatTx" == strName)
+					{
+						//oNode.ReadAttributeBase(L"z", flatTx);
+					}
+					
+				}
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("anchor"), anchor )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("anchorCtr"), anchorCtr )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("bIns"), bIns )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("compatLnSpc"), compatLnSpc )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("forceAA"), forceAA )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("fromWordArt"), fromWordArt )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("horzOverflow"), horzOverflow )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("lIns"), lIns )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("numCol"), numCol )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("rIns"), rIns )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("rot"), rot )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("rtlCol"), rtlCol )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("spcCol"), spcCol )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("spcFirstLastPara"), spcFirstLastPara )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("tIns"), tIns )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("upright"), upright )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("vert"), vert )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("vertOverflow"), vertOverflow )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("wrap"), wrap )
+				WritingElement_ReadAttributes_End	( oReader )
+
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_namespace = XmlUtils::GetNamespace(node.GetName());
@@ -172,10 +226,16 @@ namespace PPTX
 				pWriter->EndNode(m_namespace + _T(":bodyPr"));
 			}
 
-			void Merge(BodyPr& bodyPr)const
+			
+			void Merge(nullable<BodyPr>& 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 +244,43 @@ namespace PPTX
 	*/
 				// Attributes
 				if(anchor.IsInit())
-					bodyPr.anchor = *anchor;
+					bodyPr->anchor = *anchor;
 				if(anchorCtr.IsInit())
-					bodyPr.anchorCtr = *anchorCtr;
+					bodyPr->anchorCtr = *anchorCtr;
 				if(bIns.IsInit())
-					bodyPr.bIns = *bIns;
+					bodyPr->bIns = *bIns;
 				if(compatLnSpc.IsInit())
-					bodyPr.compatLnSpc = *compatLnSpc;
+					bodyPr->compatLnSpc = *compatLnSpc;
 				if(forceAA.IsInit())
-					bodyPr.forceAA = *forceAA;
+					bodyPr->forceAA = *forceAA;
 				if(fromWordArt.IsInit())
-					bodyPr.fromWordArt = *fromWordArt;
+					bodyPr->fromWordArt = *fromWordArt;
 				if(horzOverflow.IsInit())
-					bodyPr.horzOverflow = *horzOverflow;
+					bodyPr->horzOverflow = *horzOverflow;
 				if(lIns.IsInit())
-					bodyPr.lIns = *lIns;
+					bodyPr->lIns = *lIns;
 				if(numCol.IsInit())
-					bodyPr.numCol = *numCol;
+					bodyPr->numCol = *numCol;
 				if(rIns.IsInit())
-					bodyPr.rIns = *rIns;
+					bodyPr->rIns = *rIns;
 				if(rot.IsInit())
-					bodyPr.rot = *rot;
+					bodyPr->rot = *rot;
 				if(rtlCol.IsInit())
-					bodyPr.rtlCol = *rtlCol;
+					bodyPr->rtlCol = *rtlCol;
 				if(spcCol.IsInit())
-					bodyPr.spcCol = *spcCol;
+					bodyPr->spcCol = *spcCol;
 				if(spcFirstLastPara.IsInit())
-					bodyPr.spcFirstLastPara = *spcFirstLastPara;
+					bodyPr->spcFirstLastPara = *spcFirstLastPara;
 				if(tIns.IsInit())
-					bodyPr.tIns = *tIns;
+					bodyPr->tIns = *tIns;
 				if(upright.IsInit())
-					bodyPr.upright = *upright;
+					bodyPr->upright = *upright;
 				if(vert.IsInit())
-					bodyPr.vert = *vert;
+					bodyPr->vert = *vert;
 				if(vertOverflow.IsInit())
-					bodyPr.vertOverflow = *vertOverflow;
+					bodyPr->vertOverflow = *vertOverflow;
 				if(wrap.IsInit())
-					bodyPr.wrap = *wrap;
+					bodyPr->wrap = *wrap;
 			}
 
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BuAutoNum.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class BuAutoNum : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BuAutoNum)
+			WritingElement_AdditionConstructors(BuAutoNum)
+			PPTX_LOGIC_BASE2(BuAutoNum)
 
 			BuAutoNum& operator=(const BuAutoNum& oSrc)
 			{
@@ -55,8 +56,14 @@ namespace PPTX
 
 				return *this;
 			}
-
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_buChar;
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"type", type);
@@ -64,7 +71,15 @@ namespace PPTX
 
 				Normalize();
 			}
-
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_Read_if	  ( oReader, L"startAt",	startAt)
+					WritingElement_ReadAttributes_Read_else_if( oReader, L"type",		type)
+				WritingElement_ReadAttributes_End	( oReader )		
+				
+				Normalize();
+			}
 			virtual std::wstring toXML() const
 			{
 				XmlUtils::CAttribute oAttr;

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BuBlip.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class BuBlip : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BuBlip)
+			WritingElement_AdditionConstructors(BuBlip)
+			PPTX_LOGIC_BASE2(BuBlip)
 
 			BuBlip& operator=(const BuBlip& oSrc)
 			{
@@ -54,7 +55,28 @@ namespace PPTX
 				return *this;
 			}
 
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+                    std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+
+					if (strName == L"blip")
+					{
+						blip  = oReader;
+						break;
+					}
+				}
+			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_buBlip;
+			}
+
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				blip = node.ReadNodeNoNS(_T("blip"));

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BuChar.h

@@ -42,7 +42,8 @@ namespace PPTX
 		class BuChar : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BuChar)
+			WritingElement_AdditionConstructors(BuChar)
+			PPTX_LOGIC_BASE2(BuChar)
 
 			BuChar& operator=(const BuChar& oSrc)
 			{
@@ -52,13 +53,27 @@ namespace PPTX
 				Char = oSrc.Char;
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_buAutoNum;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
 
-		public:
+				if ( oReader.IsEmptyNode() )
+					return;
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+				WritingElement_ReadAttributes_ReadSingle ( oReader, L"char", Char)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				Char = node.GetAttribute(_T("char"));
 			}
-
 			virtual std::wstring toXML() const
 			{
 				XmlUtils::CAttribute oAttr;

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BuClr.h

@@ -43,7 +43,32 @@ namespace PPTX
 		class BuClr : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BuClr)
+			WritingElement_AdditionConstructors(BuClr)
+			PPTX_LOGIC_BASE2(BuClr)
+
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+                    std::wstring sName = oReader.GetName();
+
+				}
+			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_buClr;
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
 
 			BuClr& operator=(const BuClr& oSrc)
 			{
@@ -59,7 +84,6 @@ namespace PPTX
 			virtual DWORD GetBGRA()const{return Color.GetBGRA();};
 			virtual DWORD GetABGR()const{return Color.GetABGR();};
 
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				Color.GetColorFrom(node);

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BuClrTx.h

@@ -42,7 +42,8 @@ namespace PPTX
 		class BuClrTx : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BuClrTx)
+			WritingElement_AdditionConstructors(BuClrTx)
+			PPTX_LOGIC_BASE2(BuClrTx)
 
 			BuClrTx& operator=(const BuClrTx& oSrc)
 			{
@@ -51,8 +52,29 @@ namespace PPTX
 
 				return *this;
 			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_buClrTx;
+			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
 
-		public:
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+                    std::wstring sName = oReader.GetName();
+
+				}
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BuFontTx.h

@@ -42,7 +42,8 @@ namespace PPTX
 		class BuFontTx : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BuFontTx)
+			WritingElement_AdditionConstructors(BuFontTx)
+			PPTX_LOGIC_BASE2(BuFontTx)
 
 			BuFontTx& operator=(const BuFontTx& oSrc)
 			{
@@ -50,8 +51,31 @@ namespace PPTX
 				parentElement	= oSrc.parentElement;
 				return *this;
 			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+                    std::wstring sName = oReader.GetName();
+
+				}
+			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_buFontTx;
+			}
+
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
 
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BuNone.h

@@ -42,7 +42,8 @@ namespace PPTX
 		class BuNone : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BuNone)
+			WritingElement_AdditionConstructors(BuNone)
+			PPTX_LOGIC_BASE2(BuNone)
 
 			BuNone& operator=(const BuNone& oSrc)
 			{
@@ -51,8 +52,13 @@ namespace PPTX
 
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_buNone;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BuSzPct.h

@@ -42,7 +42,8 @@ namespace PPTX
 		class BuSzPct : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BuSzPct)
+			WritingElement_AdditionConstructors(BuSzPct)
+			PPTX_LOGIC_BASE2(BuSzPct)
 
 			BuSzPct& operator=(const BuSzPct& oSrc)
 			{
@@ -52,8 +53,22 @@ namespace PPTX
 				val = oSrc.val;
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_buSzPct;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("val"), val)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				val = node.ReadAttributeInt(_T("val"));
@@ -79,19 +94,24 @@ namespace PPTX
 				pWriter->StartRecord(BULLET_TYPE_SIZE_PCT);
 
 				pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
-				pWriter->WriteInt1(0, val);
+				pWriter->WriteInt1(0, val.get_value_or(0));
 				pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
 
 				pWriter->EndRecord();
 			}
 		public:
-			int val;
+			nullable_int val;
 		protected:
 			virtual void FillParentPointersForChilds(){};
 
 			AVSINLINE void Normalize()
 			{
-				normalize_value(val, 25000, 400000);
+				if (val.IsInit())
+				{
+					int tmp = *val;
+					normalize_value(tmp, 25000, 400000);
+					val = tmp;
+				}
 			}
 		};
 	} // namespace Logic

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BuSzPts.h

@@ -42,7 +42,8 @@ namespace PPTX
 		class BuSzPts : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BuSzPts)
+			WritingElement_AdditionConstructors(BuSzPts)
+			PPTX_LOGIC_BASE2(BuSzPts)
 
 			BuSzPts& operator=(const BuSzPts& oSrc)
 			{
@@ -52,8 +53,20 @@ namespace PPTX
 				val = oSrc.val;
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_buSzPts;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("val"), val)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				val = node.ReadAttributeInt(_T("val"));
@@ -79,18 +92,23 @@ namespace PPTX
 				pWriter->StartRecord(BULLET_TYPE_SIZE_PTS);
 
 				pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
-				pWriter->WriteInt1(0, val);
+				pWriter->WriteInt1(0, val.get_value_or(0));
 				pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
 
 				pWriter->EndRecord();
 			}
 		public:
-			int val;
+			nullable_int val;
 		protected:
 			virtual void FillParentPointersForChilds(){};
 			AVSINLINE void Normalize()
 			{
-				normalize_value(val, 100, 400000);
+				if (val.IsInit())
+				{
+					int tmp = *val;
+					normalize_value(tmp, 100, 400000);
+					val = tmp;
+				}
 			}
 		};
 	} // namespace Logic

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BuSzTx.h

@@ -42,7 +42,8 @@ namespace PPTX
 		class BuSzTx : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BuSzTx)
+			WritingElement_AdditionConstructors(BuSzTx)
+			PPTX_LOGIC_BASE2(BuSzTx)
 
 			BuSzTx& operator=(const BuSzTx& oSrc)
 			{
@@ -51,8 +52,13 @@ namespace PPTX
 
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_buSzTx;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/Bullet.h

@@ -46,7 +46,8 @@ namespace PPTX
 		class Bullet : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Bullet)
+			WritingElement_AdditionConstructors(Bullet)
+			PPTX_LOGIC_BASE2(Bullet)
 
 			Bullet& operator=(const Bullet& oSrc)
 			{
@@ -57,8 +58,27 @@ namespace PPTX
 
 				return *this;
 			}
+			virtual OOX::EElementType getType () const
+			{
+				if (m_Bullet.IsInit())
+					return m_Bullet->getType();
+				return OOX::et_Unknown;
+			}		
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+                std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
 
-		public:
+				if (strName == _T("buNone"))
+					m_Bullet.reset(new Logic::BuNone(oReader));
+				else if (strName == _T("buChar"))
+					m_Bullet.reset(new Logic::BuChar(oReader));
+				else if (strName == _T("buAutoNum"))
+					m_Bullet.reset(new Logic::BuAutoNum(oReader));
+				else if (strName == _T("buBlip"))
+					m_Bullet.reset(new Logic::BuBlip(oReader));
+				else 
+					m_Bullet.reset();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				std::wstring strName = XmlUtils::GetNameNoNS(node.GetName());
@@ -71,7 +91,8 @@ namespace PPTX
 					m_Bullet.reset(new Logic::BuAutoNum(node));
 				else if (strName == _T("buBlip"))
 					m_Bullet.reset(new Logic::BuBlip(node));
-				else m_Bullet.reset();
+				else 
+					m_Bullet.reset();
 			}
 
 			virtual void ReadBulletFrom(XmlUtils::CXmlNode& element)
@@ -85,7 +106,8 @@ namespace PPTX
 					m_Bullet.reset(new Logic::BuAutoNum(oNode));
 				else if (element.GetNode(_T("a:buBlip"), oNode))
 					m_Bullet.reset(new Logic::BuBlip(oNode));
-				else m_Bullet.reset();
+				else
+					m_Bullet.reset();
 			}
 
 			virtual bool is_init()const{return (m_Bullet.IsInit());};

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BulletColor.h

@@ -44,7 +44,8 @@ namespace PPTX
 		class BulletColor : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BulletColor)
+			WritingElement_AdditionConstructors(BulletColor)
+			PPTX_LOGIC_BASE2(BulletColor)
 
 			BulletColor& operator=(const BulletColor& oColor)
 			{
@@ -55,8 +56,23 @@ namespace PPTX
 
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				if (m_Color.IsInit())
+					return m_Color->getType();
+				return OOX::et_Unknown;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+                std::wstring strName = oReader.GetName();
 
-		public:
+				if (strName == _T("a:buClrTx"))
+					m_Color.reset(new Logic::BuClrTx(oReader));
+				else if (strName == _T("a:buClr"))
+					m_Color.reset(new Logic::BuClr(oReader));
+				else 
+					m_Color.reset();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				std::wstring strName = node.GetName();
@@ -65,7 +81,8 @@ namespace PPTX
 					m_Color.reset(new Logic::BuClrTx(node));
 				else if (strName == _T("a:buClr"))
 					m_Color.reset(new Logic::BuClr(node));
-				else m_Color.reset();
+				else 
+					m_Color.reset();
 			}
 
 			void ReadBulletColorFrom(XmlUtils::CXmlNode& element)
@@ -75,7 +92,8 @@ namespace PPTX
 					m_Color.reset(new Logic::BuClrTx(oNode));
 				else if (element.GetNode(_T("a:buClr"), oNode))
 					m_Color.reset(new Logic::BuClr(oNode));
-				else m_Color.reset();
+				else 
+					m_Color.reset();
 			}
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
 			{

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BulletSize.h

@@ -45,7 +45,8 @@ namespace PPTX
 		class BulletSize : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BulletSize)
+			WritingElement_AdditionConstructors(BulletSize)
+			PPTX_LOGIC_BASE2(BulletSize)
 
 			BulletSize& operator=(const BulletSize& oSrc)
 			{
@@ -56,8 +57,26 @@ namespace PPTX
 
 				return *this;
 			}
+			virtual OOX::EElementType getType () const
+			{
+				if (m_Size.IsInit())
+					return m_Size->getType();
+				return OOX::et_Unknown;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				std::wstring strName = oReader.GetName();
+				
+				if (strName == _T("a:buSzTx"))
+					m_Size.reset(new Logic::BuSzTx(oReader));
+				else if (strName == _T("a:buSzPct"))
+					m_Size.reset(new Logic::BuSzPct(oReader));
+				else if (strName == _T("a:buSzPts"))
+					m_Size.reset(new Logic::BuSzPts(oReader));
+				else 
+					m_Size.reset();
+			}
 
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				std::wstring strName = node.GetName();
@@ -68,7 +87,8 @@ namespace PPTX
 					m_Size.reset(new Logic::BuSzPct(node));
 				else if (strName == _T("a:buSzPts"))
 					m_Size.reset(new Logic::BuSzPts(node));
-				else m_Size.reset();
+				else 
+					m_Size.reset();
 			}
 
 			virtual void ReadBulletSizeFrom(XmlUtils::CXmlNode& element)
@@ -80,7 +100,8 @@ namespace PPTX
 					m_Size.reset(new Logic::BuSzPct(oNode));
 				else if(element.GetNode(_T("a:buSzPts"), oNode))
 					m_Size.reset(new Logic::BuSzPts(oNode));
-				else m_Size.reset();
+				else
+					m_Size.reset();
 			}
 			virtual bool is_init()const{return (m_Size.IsInit());};
 			virtual bool has_spec_size()const{return ((is_init()) && (!is<BuSzTx>()));};

ASCOfficePPTXFile/PPTXFormat/Logic/Bullets/BulletTypeface.h

@@ -44,7 +44,8 @@ namespace PPTX
 		class BulletTypeface : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BulletTypeface)
+			WritingElement_AdditionConstructors(BulletTypeface)
+			PPTX_LOGIC_BASE2(BulletTypeface)
 
 			BulletTypeface& operator=(const BulletTypeface& oSrc)
 			{
@@ -55,8 +56,22 @@ namespace PPTX
 
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType () const
+			{
+				if (m_Typeface.IsInit())
+					return m_Typeface->getType();
+				return OOX::et_Unknown;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				std::wstring strName = oReader.GetName();
+				if (strName == _T("a:buFontTx"))
+					m_Typeface.reset(new Logic::BuFontTx(oReader));
+				else if (strName == _T("a:buFont"))
+					m_Typeface.reset(new Logic::TextFont(oReader));
+				else 
+					m_Typeface.reset();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				std::wstring strName = node.GetName();
@@ -65,7 +80,8 @@ namespace PPTX
 					m_Typeface.reset(new Logic::BuFontTx(node));
 				else if (strName == _T("a:buFont"))
 					m_Typeface.reset(new Logic::TextFont(node));
-				else m_Typeface.reset();
+				else 
+					m_Typeface.reset();
 			}
 
 			virtual void ReadBulletTypefaceFrom(XmlUtils::CXmlNode& element)

ASCOfficePPTXFile/PPTXFormat/Logic/Camera.h

@@ -45,9 +45,41 @@ namespace PPTX
 		class Camera : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Camera)
+			WritingElement_AdditionConstructors(Camera)
+			PPTX_LOGIC_BASE2(Camera)
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_camera;
+			}	
+			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 (strName == L"a:rot")
+					{
+						rot = oReader;
+						break;
+					}
+				}
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("prst"), prst)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("fov"), fov)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("zoom"), zoom)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				prst	= node.GetAttribute(_T("prst"));

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

@@ -42,8 +42,40 @@ namespace PPTX
 		class ColorModifier : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(ColorModifier)
-		public:
+			WritingElement_AdditionConstructors(ColorModifier)
+			PPTX_LOGIC_BASE2(ColorModifier)
+
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_prstClr;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				name = oReader.GetName();
+
+				ReadAttributes( oReader );
+
+				if (XmlUtils::GetNameNoNS(name) == _T("alpha"))
+				{
+					ReadAttributes2( oReader );
+				}
+			}
+			void ReadAttributes2(XmlUtils::CXmlLiteReader& oReader)
+			{
+				nullable_string sTmp;
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
+					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("val"), sTmp)
+				WritingElement_ReadAttributes_End( oReader )
+
+                if (val.is_init() && sTmp.is_init() && sTmp->find(wchar_t('%')) != -1)
+					*val = (*val) * 1000; 
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
+					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("val"), val)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				name	= node.GetName();

ASCOfficePPTXFile/PPTXFormat/Logic/Colors/PrstClr.h

@@ -43,9 +43,36 @@ namespace PPTX
 		class PrstClr : public ColorBase
 		{
 		public:
-			PPTX_LOGIC_BASE(PrstClr)
+			WritingElement_AdditionConstructors(PrstClr)
+			PPTX_LOGIC_BASE2(PrstClr)
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_prstClr;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+
+					ColorModifier m;
+					Modifiers.push_back(m);
+					Modifiers.back().fromXML(oReader);
+				}
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
+					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("val"), val)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				val = node.GetAttribute(_T("val"));

ASCOfficePPTXFile/PPTXFormat/Logic/Colors/SchemeClr.cpp

@@ -49,6 +49,23 @@ namespace PPTX
 			Modifiers.clear();
 			node.LoadArray(_T("*"), Modifiers);
 		}
+		void SchemeClr::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+			ReadAttributes( oReader );
+
+			if ( oReader.IsEmptyNode() )
+				return;
+
+			int nCurDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nCurDepth ) )
+			{
+                std::wstring strName = oReader.GetName();
+
+				ColorModifier m;
+				Modifiers.push_back(m);
+				Modifiers.back().fromXML(oReader);
+			}
+		}
 
 		std::wstring SchemeClr::toXML() const
 		{

ASCOfficePPTXFile/PPTXFormat/Logic/Colors/SchemeClr.h

@@ -44,12 +44,24 @@ namespace PPTX
 		class SchemeClr : public ColorBase
 		{
 		public:
-			PPTX_LOGIC_BASE(SchemeClr)
+			WritingElement_AdditionConstructors(SchemeClr)
+			PPTX_LOGIC_BASE2(SchemeClr)
 
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
 			virtual void fromXML(XmlUtils::CXmlNode& node);
 			virtual std::wstring toXML() const;
 
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_schemeClr;
+			}	
+
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("val"), val)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
 				std::wstring sNodeNamespace;

ASCOfficePPTXFile/PPTXFormat/Logic/Colors/SrgbClr.h

@@ -43,9 +43,47 @@ namespace PPTX
 		class SrgbClr : public ColorBase
 		{
 		public:
-			PPTX_LOGIC_BASE(SrgbClr)
+			WritingElement_AdditionConstructors(SrgbClr)
+			PPTX_LOGIC_BASE2(SrgbClr)
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_srgbClr;
+			}	
+
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				std::wstring val;
+
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("val"), val)
+				WritingElement_ReadAttributes_End( oReader )
+               
+				if (6 == val.length())
+                {
+                    red		= HexString2Int(val.substr(0, 2));
+                    green	= HexString2Int(val.substr(2, 2));
+                    blue	= HexString2Int(val.substr(4, 2));
+                }	
+			
+			}
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+
+					ColorModifier m;
+					Modifiers.push_back(m);
+					Modifiers.back().fromXML(oReader);
+				}
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				std::wstring val = node.GetAttribute(_T("val"));

ASCOfficePPTXFile/PPTXFormat/Logic/Colors/SysClr.h

@@ -44,7 +44,8 @@ namespace PPTX
 		class SysClr : public ColorBase
 		{
 		public:
-			PPTX_LOGIC_BASE(SysClr)
+			WritingElement_AdditionConstructors(SysClr)
+			PPTX_LOGIC_BASE2(SysClr)
 
 			virtual DWORD GetRGBA(DWORD RGBA) const
 			{
@@ -146,7 +147,33 @@ namespace PPTX
 				Modifiers.clear();
 				node.LoadArray(_T("*"), Modifiers);
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_sysClr;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
 
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+
+					ColorModifier m;
+					Modifiers.push_back(m);
+					Modifiers.back().fromXML(oReader);
+				}
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("val"), val)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 
 			virtual std::wstring toXML() const
 			{

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/DefaultShapeDefinition.h

@@ -95,7 +95,7 @@ namespace PPTX
 			{
 				XmlUtils::CNodeValue oValue;
 				oValue.Write(spPr);
-				oValue.Write(bodyPr);
+				oValue.WriteNullable(bodyPr);
 				oValue.Write(lstStyle);
 				oValue.WriteNullable(style);
 
@@ -105,7 +105,7 @@ namespace PPTX
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
 			{
 				pWriter->WriteRecord1(0, spPr);
-				pWriter->WriteRecord1(1, bodyPr);
+				pWriter->WriteRecord2(1, bodyPr);
 				pWriter->WriteRecord1(2, lstStyle);
 				pWriter->WriteRecord2(3, style);
 			}
@@ -127,8 +127,9 @@ namespace PPTX
 						}
 						case 1:
 						{
-							bodyPr.m_namespace = _T("a");
-							bodyPr.fromPPTY(pReader);
+							bodyPr = BodyPr();
+							bodyPr->m_namespace = _T("a");
+							bodyPr->fromPPTY(pReader);
 							break;
 						}
 						case 2:
@@ -160,7 +161,9 @@ namespace PPTX
 				pWriter->m_lFlag = 0x04;
 				spPr.toXmlWriter(pWriter);
 				pWriter->m_lFlag = 0;
-				bodyPr.toXmlWriter(pWriter);
+				
+				if (bodyPr.IsInit())
+					bodyPr->toXmlWriter(pWriter);
 				lstStyle.toXmlWriter(pWriter);
 				pWriter->Write(style);
 
@@ -169,16 +172,19 @@ namespace PPTX
 
 		public:
 			SpPr					spPr;
-			BodyPr					bodyPr;
+			nullable<BodyPr>		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/EffectDag.cpp

@@ -35,7 +35,24 @@ namespace PPTX
 {
 	namespace Logic
 	{
+		void EffectDag::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+            Effects.clear();
+			ReadAttributes( oReader );
 
+			if ( oReader.IsEmptyNode() )
+				return;
+
+			int nCurDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nCurDepth ) )
+			{
+                std::wstring sName = oReader.GetName();
+				
+				UniEffect uni;
+				Effects.push_back(uni);
+				Effects.back().fromXML(oReader);
+			}
+		}
 		void EffectDag::fromXML(XmlUtils::CXmlNode& node)
 		{
 			m_name	= node.GetName();

ASCOfficePPTXFile/PPTXFormat/Logic/EffectDag.h

@@ -44,10 +44,10 @@ namespace PPTX
 
 		class EffectDag : public WrapperWritingElement
 		{
-		public:
+		public:			
+			WritingElement_AdditionConstructors(EffectDag)
+			PPTX_LOGIC_BASE2(EffectDag)
 			
-			PPTX_LOGIC_BASE(EffectDag)
-
 			EffectDag& operator=(const EffectDag& oSrc)
 			{
 				parentFile		= oSrc.parentFile;
@@ -59,11 +59,22 @@ namespace PPTX
 				m_name = oSrc.m_name;
 				return *this;
 			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_effectDag;
+			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_Read_if	  ( oReader, L"name",	name)
+					WritingElement_ReadAttributes_Read_else_if( oReader, L"type",	type)
+				WritingElement_ReadAttributes_End	( oReader )
+			}
 
-		public:
             virtual void fromXML(XmlUtils::CXmlNode& node);
 
-
             virtual std::wstring toXML() const;
 
 			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
@@ -93,7 +104,7 @@ namespace PPTX
 			std::vector<UniEffect>						Effects;
 			nullable_string								name;
 			nullable_limit<Limit::EffectContainerType>	type;
-			std::wstring										m_name;
+			std::wstring								m_name;
 		protected:
             virtual void FillParentPointersForChilds();
 		};

ASCOfficePPTXFile/PPTXFormat/Logic/EffectLst.cpp

@@ -35,8 +35,6 @@ namespace PPTX
 {
 	namespace Logic
 	{
-
-
 		void EffectLst::fromXML(XmlUtils::CXmlNode& node)
 		{
 			blur		= node.ReadNode(_T("a:blur"));
@@ -50,7 +48,37 @@ namespace PPTX
 
 			FillParentPointersForChilds();
 		}
+		void EffectLst::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+			ReadAttributes( oReader );
 
+			if ( oReader.IsEmptyNode() )
+				return;
+
+			int nCurDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nCurDepth ) )
+			{
+                std::wstring strName = oReader.GetName();
+			
+				if (strName == L"a:blur")
+					blur = oReader;
+				if (strName == L"a:fillOverlay")
+					fillOverlay = oReader;
+				if (strName == L"a:glow")
+					glow = oReader;
+				if (strName == L"a:innerShdw")
+					innerShdw = oReader;
+				if (strName == L"a:outerShdw")
+					outerShdw	= oReader;
+				if (strName == L"a:prstShdw")
+					prstShdw = oReader;
+				if (strName == L"a:reflection")
+					reflection	= oReader;
+				if (strName == L"a:softEdge")
+					softEdge = oReader;
+
+			}
+		}
 		std::wstring EffectLst::toXML() const
 		{
 			std::wstring str = _T("<a:effectLst>");

ASCOfficePPTXFile/PPTXFormat/Logic/EffectLst.h

@@ -47,17 +47,27 @@ namespace PPTX
 {
 	namespace Logic
 	{
-
 		class EffectLst : public WrapperWritingElement
 		{
-		public:
-			
-			PPTX_LOGIC_BASE(EffectLst)
+		public:			
+			WritingElement_AdditionConstructors(EffectLst)
+			PPTX_LOGIC_BASE2(EffectLst)
 
             EffectLst& operator=(const EffectLst& oSrc);
 
-		public:
-            virtual void fromXML(XmlUtils::CXmlNode& node);
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_effectLst;
+			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
+			
+			virtual void fromXML(XmlUtils::CXmlNode& node);
 
             virtual std::wstring toXML() const;
 
@@ -78,14 +88,14 @@ namespace PPTX
 			}
 
 		public:
-			nullable<Blur> blur;
-			nullable<FillOverlay> fillOverlay;
-			nullable<Glow> glow;
-			nullable<InnerShdw> innerShdw;
-			nullable<OuterShdw> outerShdw;
-			nullable<PrstShdw> prstShdw;
-			nullable<Reflection> reflection;
-			nullable<SoftEdge> softEdge;
+			nullable<Blur>			blur;
+			nullable<FillOverlay>	fillOverlay;
+			nullable<Glow>			glow;
+			nullable<InnerShdw>		innerShdw;
+			nullable<OuterShdw>		outerShdw;
+			nullable<PrstShdw>		prstShdw;
+			nullable<Reflection>	reflection;
+			nullable<SoftEdge>		softEdge;
 		protected:
             virtual void FillParentPointersForChilds();
 

ASCOfficePPTXFile/PPTXFormat/Logic/EffectProperties.h

@@ -44,7 +44,8 @@ namespace PPTX
 		class EffectProperties : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(EffectProperties)
+			WritingElement_AdditionConstructors(EffectProperties)
+			PPTX_LOGIC_BASE2(EffectProperties)
 
 			EffectProperties& operator=(const EffectProperties& oSrc)
 			{
@@ -54,7 +55,23 @@ namespace PPTX
 				return *this;
 			}
 
-		public:
+			virtual OOX::EElementType getType () const
+			{
+				if (List.IsInit())
+					return List->getType();
+				return OOX::et_Unknown;
+			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+					
+				if (strName == _T("effectLst"))
+					List.reset(new Logic::EffectLst(oReader));
+				else if(strName == _T("effectDag"))
+					List.reset(new Logic::EffectDag(oReader));
+				else 
+					List.reset();
+			}
 			
 			virtual bool is_init() const {return (List.IsInit());};
 

ASCOfficePPTXFile/PPTXFormat/Logic/EffectStyle.cpp

@@ -44,7 +44,24 @@ namespace PPTX
 
 			FillParentPointersForChilds();
 		}
+		void EffectStyle::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+			if ( oReader.IsEmptyNode() )
+				return;
 
+			int nCurDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nCurDepth ) )
+			{
+				std::wstring strName = oReader.GetName();
+				if (strName == L"a:scene3d")
+					scene3d = oReader;
+				else if (strName == L"a:sp3d")
+					sp3d = oReader;
+				else
+					EffectList.fromXML(oReader);
+			}
+			FillParentPointersForChilds();
+		}
 
 		std::wstring EffectStyle::toXML() const
 		{

ASCOfficePPTXFile/PPTXFormat/Logic/EffectStyle.h

@@ -46,7 +46,8 @@ namespace PPTX
 		class EffectStyle : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(EffectStyle)
+			WritingElement_AdditionConstructors(EffectStyle)
+			PPTX_LOGIC_BASE2(EffectStyle)
 
 			EffectStyle& operator=(const EffectStyle& oSrc)
 			{
@@ -58,8 +59,11 @@ namespace PPTX
 				sp3d = oSrc.sp3d;
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_effectStyle;
+			}	
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
             virtual void fromXML(XmlUtils::CXmlNode& node);
 
             virtual std::wstring toXML() const;

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/AlphaBiLevel.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class AlphaBiLevel : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(AlphaBiLevel)
+			WritingElement_AdditionConstructors(AlphaBiLevel)
+			PPTX_LOGIC_BASE2(AlphaBiLevel)
 
 			AlphaBiLevel& operator=(const AlphaBiLevel& oSrc)
 			{
@@ -54,7 +55,22 @@ namespace PPTX
 				return *this;
 			}
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_alphaBiLevel;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_ReadSingle     ( oReader, _T("thresh"), thresh)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"thresh", thresh);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/AlphaCeiling.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class AlphaCeiling : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(AlphaCeiling)
+			WritingElement_AdditionConstructors(AlphaCeiling)
+			PPTX_LOGIC_BASE2(AlphaCeiling)
 			
 			AlphaCeiling& operator=(const AlphaCeiling& oSrc)
 			{
@@ -59,7 +60,13 @@ namespace PPTX
 				pWriter->EndRecord();
 			}
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_alphaCeiling;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/AlphaFloor.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class AlphaFloor : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(AlphaFloor)
+			WritingElement_AdditionConstructors(AlphaFloor)
+			PPTX_LOGIC_BASE2(AlphaFloor)
 
 			AlphaFloor& operator=(const AlphaFloor& oSrc)
 			{
@@ -52,12 +53,16 @@ namespace PPTX
 
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_alphaFloor;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 			}
-
 			virtual std::wstring toXML() const
 			{
 				return _T("<a:alphaFloor/>");

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/AlphaInv.h

@@ -44,7 +44,8 @@ namespace PPTX
 		class AlphaInv : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(AlphaInv)
+			WritingElement_AdditionConstructors(AlphaInv)
+			PPTX_LOGIC_BASE2(AlphaInv)
 
 			AlphaInv& operator=(const AlphaInv& oSrc)
 			{
@@ -55,7 +56,23 @@ namespace PPTX
 				return *this;
 			}
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_alphaInv;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+
+					Color.fromXML(oReader);
+				}
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				Color.GetColorFrom(node);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/AlphaMod.h

@@ -44,7 +44,8 @@ namespace PPTX
 		class AlphaMod : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(AlphaMod)
+			WritingElement_AdditionConstructors(AlphaMod)
+			PPTX_LOGIC_BASE2(AlphaMod)
 
 			AlphaMod& operator=(const AlphaMod& oSrc)
 			{
@@ -54,8 +55,28 @@ namespace PPTX
 				cont = oSrc.cont;
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_alphaMod;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+					if (strName == L"a:cont")
+					{
+						cont = oReader;
+						break;
+					}
+				}
+				FillParentPointersForChilds();
+			}
 
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				cont = node.ReadNode(_T("a:cont"));

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/AlphaModFix.h

@@ -43,8 +43,8 @@ namespace PPTX
 		class AlphaModFix : public WrapperWritingElement
 		{
 		public:
-
-			PPTX_LOGIC_BASE(AlphaModFix)
+			WritingElement_AdditionConstructors(AlphaModFix)
+			PPTX_LOGIC_BASE2(AlphaModFix)
 
 			AlphaModFix& operator=(const AlphaModFix& oSrc)
 			{
@@ -53,9 +53,23 @@ namespace PPTX
 
 				amt = oSrc.amt;
 				return *this;
+			}			
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_alphaModFix;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("amt"), amt)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
 			}
-			
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"amt", amt);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/AlphaOutset.h

@@ -44,7 +44,8 @@ namespace PPTX
 		{
 		public:
 			
-			PPTX_LOGIC_BASE(AlphaOutset)
+			WritingElement_AdditionConstructors(AlphaOutset)
+			PPTX_LOGIC_BASE2(AlphaOutset)
 
 			AlphaOutset& operator=(const AlphaOutset& oSrc)
 			{
@@ -54,8 +55,20 @@ namespace PPTX
 				rad = oSrc.rad;
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_alphaOutset;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("rad"), rad)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"rad", rad);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/AlphaRepl.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class AlphaRepl : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(AlphaRepl)
+			WritingElement_AdditionConstructors(AlphaRepl)
+			PPTX_LOGIC_BASE2(AlphaRepl)
 
 			AlphaRepl& operator=(const AlphaRepl& oSrc)
 			{
@@ -53,8 +54,22 @@ namespace PPTX
 				a = oSrc.a;
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_alphaRepl;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("a"), a)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"a", a);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/BiLevel.h

@@ -44,7 +44,8 @@ namespace PPTX
 		{
 		public:
 			
-			PPTX_LOGIC_BASE(BiLevel)
+			WritingElement_AdditionConstructors(BiLevel)
+			PPTX_LOGIC_BASE2(BiLevel)
 
 			BiLevel& operator=(const BiLevel& oSrc)
 			{
@@ -54,8 +55,22 @@ namespace PPTX
 				thresh = oSrc.thresh;
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_biLevel;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("thresh"), thresh)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"thresh", thresh);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/Blend.h

@@ -45,8 +45,8 @@ namespace PPTX
 		class Blend : public WrapperWritingElement
 		{
 		public:
-			
-			PPTX_LOGIC_BASE(Blend)
+			WritingElement_AdditionConstructors(Blend)
+			PPTX_LOGIC_BASE2(Blend)
 
 			Blend& operator=(const Blend& oSrc)
 			{
@@ -57,8 +57,32 @@ namespace PPTX
 				blend = oSrc.blend;
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_blend;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+				if ( oReader.IsEmptyNode() )
+					return;
 
-		public:
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+
+					if (strName == L"a:cont")
+						cont = oReader;
+				}
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("blend"), blend)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				cont	= node.ReadNode(_T("a:cont"));

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/Blur.h

@@ -43,7 +43,8 @@ namespace PPTX
 		{
 		public:
 			
-			PPTX_LOGIC_BASE(Blur)
+			WritingElement_AdditionConstructors(Blur)
+			PPTX_LOGIC_BASE2(Blur)
 
 			Blur& operator=(const Blur& oSrc)
 			{
@@ -55,7 +56,21 @@ namespace PPTX
 				return *this;
 			}
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_blur;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("rad"), rad)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("grow"), grow)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"rad", rad);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/ClrChange.h

@@ -44,7 +44,8 @@ namespace PPTX
 		class ClrChange : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(ClrChange)
+			WritingElement_AdditionConstructors(ClrChange)
+			PPTX_LOGIC_BASE2(ClrChange)
 
 			ClrChange& operator=(const ClrChange& oSrc)
 			{
@@ -56,8 +57,35 @@ namespace PPTX
 				useA	= oSrc.useA;
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_clrChange;
+			}	
+			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 (strName == L"a:clrTo")
+						ClrTo.fromXMLParent(oReader);
+					else if (strName == L"a:clrFrom")
+						ClrFrom.fromXMLParent(oReader);
+				}
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("useA"), useA)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
                 XmlUtils::CXmlNode node1 = node.ReadNode(_T("a:clrFrom"));

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/ClrRepl.h

@@ -45,7 +45,8 @@ namespace PPTX
 		{
 		public:
 			
-			PPTX_LOGIC_BASE(ClrRepl)
+			WritingElement_AdditionConstructors(ClrRepl)
+			PPTX_LOGIC_BASE2(ClrRepl)
 
 			ClrRepl& operator=(const ClrRepl& oSrc)
 			{
@@ -55,8 +56,24 @@ namespace PPTX
 				Color = oSrc.Color;
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_clrRepl;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				if ( oReader.IsEmptyNode() )
+					return;
 
-		public:
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+
+					Color.fromXML(oReader);
+				}
+				FillParentPointersForChilds();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				Color.GetColorFrom(node);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/Duotone.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class Duotone : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Duotone)
+			WritingElement_AdditionConstructors(Duotone)
+			PPTX_LOGIC_BASE2(Duotone)
 
 			Duotone& operator=(const Duotone& oSrc)
 			{
@@ -53,15 +54,32 @@ namespace PPTX
 				Colors = oSrc.Colors;
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_duotone;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				if ( oReader.IsEmptyNode() )
+					return;
 
-		public:
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+
+					UniColor col;
+					Colors.push_back(col);
+					Colors.back().fromXML(oReader);
+				}
+				FillParentPointersForChilds();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				Colors.clear();
 				node.LoadArray(_T("*"), Colors);
 				FillParentPointersForChilds();
 			}
-
 			virtual std::wstring toXML() const
 			{
 				XmlUtils::CNodeValue oValue;

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/EffectElement.h

@@ -44,7 +44,8 @@ namespace PPTX
 		{
 		public:
 			
-			PPTX_LOGIC_BASE(EffectElement)
+			WritingElement_AdditionConstructors(EffectElement)
+			PPTX_LOGIC_BASE2(EffectElement)
 
 			EffectElement& operator=(const EffectElement& oSrc)
 			{
@@ -54,8 +55,21 @@ namespace PPTX
 				ref = oSrc.ref;
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_effect;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("ref"), ref)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"ref", ref);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/FillEffect.h

@@ -44,7 +44,8 @@ namespace PPTX
 		{
 		public:
 			
-			PPTX_LOGIC_BASE(FillEffect)
+			WritingElement_AdditionConstructors(FillEffect)
+			PPTX_LOGIC_BASE2(FillEffect)
 			
 			FillEffect& operator=(const FillEffect& oSrc)
 			{
@@ -54,8 +55,24 @@ namespace PPTX
 				Fill = oSrc.Fill;
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_fill;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				if ( oReader.IsEmptyNode() )
+					return;
 
-		public:
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+
+					Fill.fromXML(oReader);
+				}
+				FillParentPointersForChilds();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				Fill.GetFillFrom(node);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/FillOverlay.h

@@ -46,7 +46,8 @@ namespace PPTX
 		{
 		public:
 			
-			PPTX_LOGIC_BASE(FillOverlay)
+			WritingElement_AdditionConstructors(FillOverlay)
+			PPTX_LOGIC_BASE2(FillOverlay)
 
 			FillOverlay& operator=(const FillOverlay& oSrc)
 			{
@@ -58,7 +59,32 @@ namespace PPTX
 				return *this;
 			}
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_fillOverlay;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+
+					Fill.fromXML(oReader);
+				}
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("blend"), blend)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				Fill.GetFillFrom(node);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/Glow.h

@@ -40,11 +40,11 @@ namespace PPTX
 {
 	namespace Logic
 	{
-
 		class Glow : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Glow)
+			WritingElement_AdditionConstructors(Glow)
+			PPTX_LOGIC_BASE2(Glow)
 
 			Glow& operator=(const Glow& oSrc)
 			{
@@ -55,14 +55,40 @@ namespace PPTX
 				rad = oSrc.rad;
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_clrRepl;
+			}	
+			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();
+
+					Color.fromXML(oReader);
+				}
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("rad"), rad)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				Color.GetColorFrom(node);
 				node.ReadAttributeBase(L"rad", rad);
+				
 				FillParentPointersForChilds();
-
 				Normalize();
 			}
 

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/Grayscl.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class Grayscl : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Grayscl)
+			WritingElement_AdditionConstructors(Grayscl)
+			PPTX_LOGIC_BASE2(Grayscl)
 
 			Grayscl& operator=(const Grayscl& oSrc)
 			{
@@ -52,8 +53,13 @@ namespace PPTX
 
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_grayscl;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 			}

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/HslEffect.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class HslEffect : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(HslEffect)
+			WritingElement_AdditionConstructors(HslEffect)
+			PPTX_LOGIC_BASE2(HslEffect)
 
 			HslEffect& operator=(const HslEffect& oSrc)
 			{
@@ -55,8 +56,24 @@ namespace PPTX
 				sat = oSrc.sat;
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_hsl;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("hue"), hue)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("sat"), sat)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("lum"), lum)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"hue", hue);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/InnerShdw.h

@@ -44,7 +44,8 @@ namespace PPTX
 		class InnerShdw : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(InnerShdw)
+			WritingElement_AdditionConstructors(InnerShdw)
+			PPTX_LOGIC_BASE2(InnerShdw)
 
 			InnerShdw& operator=(const InnerShdw& oSrc)
 			{
@@ -57,8 +58,36 @@ namespace PPTX
 				dist	= oSrc.dist;
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_innerShdw;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+				
+				if ( oReader.IsEmptyNode() )
+					return;
 
-		public:
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+					Color.fromXML(oReader);
+				}
+
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("blurRad"), blurRad)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("dir"), dir)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("dist"), dist)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				Color.GetColorFrom(node);
@@ -66,8 +95,8 @@ namespace PPTX
 				node.ReadAttributeBase(L"dir", dir);
 				node.ReadAttributeBase(L"dist", dist);
 
-				FillParentPointersForChilds();
 				Normalize();
+				FillParentPointersForChilds();
 			}
 
 			virtual std::wstring toXML() const

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/LumEffect.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class LumEffect : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(LumEffect)
+			WritingElement_AdditionConstructors(LumEffect)
+			PPTX_LOGIC_BASE2(LumEffect)
 
 			LumEffect& operator=(const LumEffect& oSrc)
 			{
@@ -54,8 +55,21 @@ namespace PPTX
 				contrast = oSrc.contrast;
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_lum;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("bright"), bright)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("contrast"), contrast)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"bright", bright);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/OuterShdw.h

@@ -45,7 +45,8 @@ namespace PPTX
 		class OuterShdw : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(OuterShdw)
+			WritingElement_AdditionConstructors(OuterShdw)
+			PPTX_LOGIC_BASE2(OuterShdw)
 
 			OuterShdw& operator=(const OuterShdw& oSrc)
 			{
@@ -66,8 +67,42 @@ namespace PPTX
 
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_innerShdw;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+				
+				if ( oReader.IsEmptyNode() )
+					return;
 
-		public:
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+					Color.fromXML(oReader);
+				}
+
+				FillParentPointersForChilds();
+		}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("blurRad"), blurRad)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("dir"), dir)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("dist"), dist)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("algnt"), algn)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("kx"), kx)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("ky"), ky)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("rotWithShape"), rotWithShape)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("sx"), sx)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("sy"), sy)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				Color.GetColorFrom(node);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/PrstShdw.h

@@ -45,7 +45,8 @@ namespace PPTX
 		class PrstShdw : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(PrstShdw)
+			WritingElement_AdditionConstructors(PrstShdw)
+			PPTX_LOGIC_BASE2(PrstShdw)
 
 			PrstShdw& operator=(const PrstShdw& oSrc)
 			{
@@ -60,8 +61,37 @@ namespace PPTX
 
 				return *this;
 			}
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_prstShdw;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+				
+				if ( oReader.IsEmptyNode() )
+					return;
 
-		public:
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = oReader.GetName();
+					Color.fromXML(oReader);
+				}
+
+				Normalize();
+				FillParentPointersForChilds();
+		}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("prst"), prst)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("dir"),	 dir)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("dist"), dist)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				Color.GetColorFrom(node);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/Reflection.h

@@ -44,7 +44,8 @@ namespace PPTX
 		class Reflection : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Reflection)
+			WritingElement_AdditionConstructors(Reflection)
+			PPTX_LOGIC_BASE2(Reflection)
 
 			Reflection& operator=(const Reflection& oSrc)
 			{
@@ -68,8 +69,35 @@ namespace PPTX
 
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_reflection;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("blurRad"), blurRad)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("dir"), dir)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("fadeDir"), fadeDir)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("dist"), dist)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("algnt"), algn)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("kx"), kx)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("ky"), ky)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("rotWithShape"), rotWithShape)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("sx"), sx)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("sy"), sy)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("stA"), stA)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("endA"), endA)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("stPos"), stPos)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("endPos"), endPos)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"algn", algn);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/RelOff.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class RelOff : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(RelOff)
+			WritingElement_AdditionConstructors(RelOff)
+			PPTX_LOGIC_BASE2(RelOff)
 
 			RelOff& operator=(const RelOff& oSrc)
 			{
@@ -54,8 +55,21 @@ namespace PPTX
 				ty = oSrc.ty;
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_relOff;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("tx"), tx)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("ty"), ty)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"tx", tx);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/SoftEdge.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class SoftEdge : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(SoftEdge)
+			WritingElement_AdditionConstructors(SoftEdge)
+			PPTX_LOGIC_BASE2(SoftEdge)
 
 			SoftEdge& operator=(const SoftEdge& oSrc)
 			{
@@ -53,8 +54,20 @@ namespace PPTX
 				rad = oSrc.rad;
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_softEdge;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("rad"), rad)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"rad", rad);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/TintEffect.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class TintEffect : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(TintEffect)
+			WritingElement_AdditionConstructors(TintEffect)
+			PPTX_LOGIC_BASE2(TintEffect)
 
 			TintEffect& operator=(const TintEffect& oSrc)
 			{
@@ -54,8 +55,23 @@ namespace PPTX
 				hue = oSrc.hue;
 				return *this;
 			}
-			
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_tint;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("amt"), amt)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("hue"), hue)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"amt", amt);

ASCOfficePPTXFile/PPTXFormat/Logic/Effects/XfrmEffect.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class XfrmEffect : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(XfrmEffect)
+			WritingElement_AdditionConstructors(XfrmEffect)
+			PPTX_LOGIC_BASE2(XfrmEffect)
 
 			XfrmEffect& operator=(const XfrmEffect& oSrc)
 			{
@@ -59,8 +60,27 @@ namespace PPTX
 				
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_xfrm;
+			}	
+			void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("kx"), kx)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("ky"), ky)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("sx"), sx)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("sy"), sy)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("tx"), tx)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("ty"), ty)
+				WritingElement_ReadAttributes_End( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"kx", kx);

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/Blip.cpp

@@ -41,6 +41,26 @@ namespace PPTX
 {
 	namespace Logic
 	{
+		void Blip::fromXML(XmlUtils::CXmlLiteReader& oReader)
+		{
+			ReadAttributes( oReader );
+
+			Effects.clear();
+			if ( oReader.IsEmptyNode() )
+				return;
+				
+			int nParentDepth = oReader.GetDepth();
+			while( oReader.ReadNextSiblingNode( nParentDepth ) )
+			{
+				std::wstring sName = oReader.GetName();
+
+				UniEffect uni;
+				Effects.push_back(uni);
+				Effects.back().fromXML(oReader);
+			}
+		
+			FillParentPointersForChilds();
+		}
 		void Blip::fromXML(XmlUtils::CXmlNode& node)
 		{
 			m_namespace = XmlUtils::GetNamespace(node.GetName());

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/Blip.h

@@ -45,7 +45,8 @@ namespace PPTX
 		class Blip : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Blip)
+			WritingElement_AdditionConstructors(Blip)
+			PPTX_LOGIC_BASE2(Blip)
 
 			Blip& operator=(const Blip& oSrc)
 			{
@@ -66,8 +67,19 @@ namespace PPTX
 
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_blip;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("r:embed"), embed)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("r:link"), link )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("cstate"), cstate )
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node);
 			virtual std::wstring toXML() const;
 

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/BlipFill.h

@@ -49,7 +49,8 @@ namespace PPTX
 		class BlipFill : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(BlipFill)
+			WritingElement_AdditionConstructors(BlipFill)
+			PPTX_LOGIC_BASE2(BlipFill)
 
 			BlipFill& operator=(const BlipFill& oSrc)
 			{
@@ -67,8 +68,50 @@ namespace PPTX
 				m_namespace = oSrc.m_namespace;
 				return *this;
 			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
 
-		public:
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+					if (_T("blip") == strName)
+					{
+						if (!blip.IsInit())	
+							blip = oReader;
+					}
+					else if (_T("srcRect") == strName)
+					{
+						if (!srcRect.IsInit())	
+							srcRect = oReader;
+					}
+					else if (_T("tile") == strName)
+					{
+						if (!tile.IsInit())	
+							tile = oReader;
+					}
+					else if (_T("stretch") == strName)
+					{
+						if (!stretch.IsInit())	
+							stretch = oReader;
+					}
+				}
+			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_blipFill;
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("dpi"), dpi)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("rotWithShape"), rotWithShape )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_namespace = XmlUtils::GetNamespace(node.GetName());

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/GradFill.h

@@ -48,7 +48,8 @@ namespace PPTX
 		class GradFill : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(GradFill)
+			WritingElement_AdditionConstructors(GradFill)
+			PPTX_LOGIC_BASE2(GradFill)
 
 			GradFill& operator=(const GradFill& oSrc)
 			{
@@ -67,8 +68,48 @@ namespace PPTX
 				
 				return *this;
 			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_gradFill;
+			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
 
-		public:
+				ReadAttributes( oReader );
+
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					std::wstring strName = XmlUtils::GetNameNoNS(oReader.GetName());
+					
+					if (_T("path") == strName)
+						path = oReader;
+					else if (_T("lin") == strName)
+						lin = oReader;
+					else if (_T("tileRect") == strName)
+						tileRect = oReader;
+					else if (_T("gsLst") == strName)
+					{
+						int nCurDepth1 = oReader.GetDepth();
+						while( oReader.ReadNextSiblingNode( nCurDepth1 ) )
+						{
+							Gs g; GsLst.push_back(g);
+							GsLst.back().fromXML(oReader);
+						}
+					}
+				}
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& 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 )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_namespace = XmlUtils::GetNamespace(node.GetName());
@@ -124,7 +165,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);
 			}
 
@@ -139,7 +180,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

@@ -43,7 +43,8 @@ namespace PPTX
 		class NoFill : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(NoFill)
+			WritingElement_AdditionConstructors(NoFill)
+			PPTX_LOGIC_BASE2(NoFill)
 
 			NoFill& operator=(const NoFill& oSrc)
 			{
@@ -53,8 +54,19 @@ namespace PPTX
 				m_namespace = oSrc.m_namespace;
 				return *this;
 			}
-
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_noFill;
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_namespace = XmlUtils::GetNamespace(node.GetName());
@@ -87,7 +99,8 @@ namespace PPTX
 		class GrpFill : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(GrpFill)
+			WritingElement_AdditionConstructors(GrpFill)
+			PPTX_LOGIC_BASE2(GrpFill)
 
 			GrpFill& operator=(const GrpFill& oSrc)
 			{
@@ -97,8 +110,19 @@ namespace PPTX
 				m_namespace = oSrc.m_namespace;
 				return *this;
 			}
-
-		public:
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_grpFill;
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_namespace = XmlUtils::GetNamespace(node.GetName());

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/PattFill.h

@@ -41,11 +41,11 @@ namespace PPTX
 {
 	namespace Logic
 	{
-
 		class PattFill : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(PattFill)
+			WritingElement_AdditionConstructors(PattFill)
+			PPTX_LOGIC_BASE2(PattFill)
 
 			PattFill& operator=(const PattFill& oSrc)
 			{
@@ -59,8 +59,34 @@ namespace PPTX
 
 				return *this;
 			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
 
-		public:
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+                    std::wstring sName = oReader.GetName();
+					if (sName == L"a:fgClr")
+						fgClr.fromXMLParent(oReader);
+					if (sName == L"a:bgClr")
+						bgClr.fromXMLParent(oReader);
+				}
+				FillParentPointersForChilds();	
+			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_pattFill;
+			}
+			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)
 			{
 				m_namespace = XmlUtils::GetNamespace(node.GetName());

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/SolidFill.h

@@ -44,7 +44,8 @@ namespace PPTX
 		class SolidFill : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(SolidFill)
+			WritingElement_AdditionConstructors(SolidFill)
+			PPTX_LOGIC_BASE2(SolidFill)
 
 			SolidFill& operator=(const SolidFill& oSrc)
 			{
@@ -56,8 +57,27 @@ namespace PPTX
 
 				return *this;
 			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				if ( oReader.IsEmptyNode() )
+					return;
+				
+				m_namespace = XmlUtils::GetNamespace(oReader.GetName());
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+                    std::wstring sName = oReader.GetName();
+					
+					Color.fromXML(oReader);
+				}
+				FillParentPointersForChilds();
+			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_solidFill;
+			}
 
-		public:
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
                 m_namespace = XmlUtils::GetNamespace(node.GetName());

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/Stretch.h

@@ -44,7 +44,8 @@ namespace PPTX
 		class Stretch : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Stretch)
+			WritingElement_AdditionConstructors(Stretch)
+			PPTX_LOGIC_BASE2(Stretch)
 
 			Stretch& operator=(const Stretch& oSrc)
 			{
@@ -54,8 +55,19 @@ namespace PPTX
 				fillRect = oSrc.fillRect;
 				return *this;
 			}
-
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_stretch;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					if (_T("fillRect") == XmlUtils::GetNameNoNS(oReader.GetName()))
+						fillRect = oReader;
+				}
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				XmlUtils::CXmlNodes oNodes;

ASCOfficePPTXFile/PPTXFormat/Logic/Fills/Tile.h

@@ -45,7 +45,8 @@ namespace PPTX
 		class Tile : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Tile)
+			WritingElement_AdditionConstructors(Tile)
+			PPTX_LOGIC_BASE2(Tile)
 
 			Tile& operator=(const Tile& oSrc)
 			{
@@ -62,7 +63,25 @@ namespace PPTX
 				return *this;
 			}
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_tile;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("algn"), algn )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("flip"), flip )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("sx"), sx )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("sy"), sy )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("tx"), tx )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("ty"), ty )
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"algn", algn);

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/Gs.h

@@ -43,7 +43,8 @@ namespace PPTX
 		class Gs : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Gs)
+			WritingElement_AdditionConstructors(Gs)
+			PPTX_LOGIC_BASE2(Gs)
 
 			Gs& operator=(const Gs& oSrc)
 			{
@@ -55,8 +56,34 @@ namespace PPTX
 				
 				return *this;
 			}
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_gs;
+			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
 
-		public:
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+					color.fromXML(oReader);
+					break;
+				}
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				nullable_int tmp;
+				WritingElement_ReadAttributes_Start_No_NS	( oReader )
+					WritingElement_ReadAttributes_ReadSingle ( oReader, _T("pos"), tmp)
+				WritingElement_ReadAttributes_End	( oReader )
+
+				pos = tmp.get_value_or(0);
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				pos		= node.ReadAttributeInt(L"pos");

ASCOfficePPTXFile/PPTXFormat/Logic/Hyperlink.h

@@ -45,9 +45,45 @@ namespace PPTX
 		class Hyperlink : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Hyperlink)
+			WritingElement_AdditionConstructors(Hyperlink)
+			PPTX_LOGIC_BASE2(Hyperlink)
 
-		public:
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_hyperlink;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+
+				if ( oReader.IsEmptyNode() )
+					return;
+
+				int nCurDepth = oReader.GetDepth();
+				while( oReader.ReadNextSiblingNode( nCurDepth ) )
+				{
+                    std::wstring sName = XmlUtils::GetNameNoNS(oReader.GetName());
+					if (sName == L"snd")
+					{
+						snd	= oReader;
+						break;
+					}
+
+				}
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("r:id"), id )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("invalidUrl"), invalidUrl )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("action"), action )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("tgtFrame"), tgtFrame )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("tooltip"), tooltip )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("history"), history)
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("highlightClick"), highlightClick )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("endSnd"), endSnd )
+				WritingElement_ReadAttributes_End	( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_name = XmlUtils::GetNameNoNS(node.GetName());

ASCOfficePPTXFile/PPTXFormat/Logic/LightRig.h

@@ -46,16 +46,46 @@ namespace PPTX
 		class LightRig : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(LightRig)
+			WritingElement_AdditionConstructors(LightRig)
+			PPTX_LOGIC_BASE2(LightRig)
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_lightRig;
+			}	
+			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 (strName == L"a:rot")
+					{
+						rot = oReader;
+						break;
+					}
+				}
+				FillParentPointersForChilds();
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("dir"), dir)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("rig"), rig)
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				dir = node.GetAttribute(_T("dir"));
 				rig = node.GetAttribute(_T("rig"));
 
-                std::wstring sRotNodeName = _T("a:rot");
-                rot = node.ReadNode(sRotNodeName);
+                rot = node.ReadNode(L"a:rot");
 				FillParentPointersForChilds();
 			}
 			virtual std::wstring toXML() const

ASCOfficePPTXFile/PPTXFormat/Logic/Lin.h

@@ -43,9 +43,26 @@ namespace PPTX
 		class Lin : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(Lin)
+			WritingElement_AdditionConstructors(Lin)
+			PPTX_LOGIC_BASE2(Lin)
 
-		public:
+			virtual OOX::EElementType getType () const
+			{
+				return OOX::et_a_lin;
+			}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				WritingElement_ReadAttributes_Start	( oReader )
+					WritingElement_ReadAttributes_Read_if		( oReader, _T("ang"), ang)
+					WritingElement_ReadAttributes_Read_else_if	( oReader, _T("scaled"), scaled)
+				WritingElement_ReadAttributes_End	( oReader )
+				
+				Normalize();
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				node.ReadAttributeBase(L"ang", ang);

ASCOfficePPTXFile/PPTXFormat/Logic/LineEnd.h

@@ -44,9 +44,26 @@ namespace PPTX
 		class LineEnd : public WrapperWritingElement
 		{
 		public:
-			PPTX_LOGIC_BASE(LineEnd)
+			WritingElement_AdditionConstructors(LineEnd)
+			PPTX_LOGIC_BASE2(LineEnd)
 
-		public:
+			virtual OOX::EElementType getType() const
+			{
+				return OOX::et_a_buSzPts;
+			}			
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader)
+			{
+				ReadAttributes( oReader );
+			}
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+			{
+				// Читаем атрибуты
+				WritingElement_ReadAttributes_Start_No_NS( oReader )
+					WritingElement_ReadAttributes_Read_if     ( oReader, _T("w"), w )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("type"), type )
+					WritingElement_ReadAttributes_Read_else_if( oReader, _T("len"), len )
+				WritingElement_ReadAttributes_End( oReader )
+			}
 			virtual void fromXML(XmlUtils::CXmlNode& node)
 			{
 				m_name = node.GetName();