.

.gitignore

@@ -43,3 +43,4 @@ OfficeUtils/win32/OfficeUtilsLib/OfficeUtilsLib/ReadMe.txt
 *.pdb
 *.tlb
 *.idb
+**/.hg

ASCOfficeDocFile/DocDocxConverter/OfficeDrawing/PathParser.h

@@ -35,11 +35,23 @@
 
 namespace DocFileFormat
 {
+	struct _guides
+	{
+		unsigned char type;
+
+		unsigned char param_type1;
+		unsigned char param_type2;
+		unsigned char param_type3;
+
+		WORD param1;
+		WORD param2;
+		WORD param3;
+	};
 	class PathParser
 	{
 	public:
 
-		PathParser (const unsigned char* pSegmentInfo, unsigned int pSegmentInfoSize, const unsigned char* pVertices, unsigned int pVerticesSize)
+		PathParser (const unsigned char* pSegmentInfo, unsigned int pSegmentInfoSize, const unsigned char* pVertices, unsigned int pVerticesSize, std::vector<_guides> & guides)
 		{
 			if ((pSegmentInfo != NULL) && (pSegmentInfoSize > 0))
 			{
@@ -105,31 +117,40 @@ namespace DocFileFormat
 				unsigned short nElemsAlloc	=	FormatUtils::BytesToUInt16(pVertices, 2, pVerticesSize);
 				unsigned short cb			=	FormatUtils::BytesToUInt16(pVertices, 4, pVerticesSize);
 
-				if (0xfff0 == cb)
-				{
-					cb	=	4;
-
-					for (unsigned short i = 0; i < nElems; ++i)
+				for (unsigned short i = 0; i < nElems; ++i)
+				{				
+					POINT point;	
+					if (0xfff0 == cb)
 					{
-						POINT point;
-
+						cb	=	4;						
 						point.x	= FormatUtils::BytesToInt16(pVertices + 6, (i * cb), pVerticesSize);
 						point.y	= FormatUtils::BytesToInt16(pVertices + 6, (i * cb) + (cb / 2), pVerticesSize);
-
-						m_arPoints.push_back(point);
 					}
-				}
-				else
-				{
-					for (unsigned short i = 0; i < nElems; ++i)
+					else
 					{
-						POINT point;
-
 						point.x	= FormatUtils::BytesToInt32(pVertices + 6, (i * cb), pVerticesSize);
 						point.y	= FormatUtils::BytesToInt32(pVertices + 6, (i * cb) + (cb / 2), pVerticesSize);
-
-						m_arPoints.push_back(point);
 					}
+
+					LONG lMinF = (LONG)0x80000000;
+					if (lMinF <= point.x)
+					{
+						int index = (DWORD)point.x - 0x80000000;
+						if (index >= 0 && index < guides.size())
+						{
+							point.x = guides[index].param3;
+						}
+					}
+					if (lMinF <= point.y)
+					{
+						int index = (DWORD)point.y - 0x80000000;
+						if (index >= 0 && index < guides.size())
+						{
+							point.y = guides[index].param3;
+						}
+					}
+
+					m_arPoints.push_back(point);
 				}
 			}
 		}

ASCOfficeDocFile/DocDocxConverter/OfficeDrawing/ShapeContainer.h

@@ -106,21 +106,20 @@ namespace DocFileFormat
 			return new ShapeContainer( _reader, bodySize, typeCode, version, instance );
 		}
 
-		std::list<OptionEntry> ExtractOptions() const
+		std::vector<OptionEntryPtr> ExtractOptions() const
 		{
-			std::list<OptionEntry> ret;
+			std::vector<OptionEntryPtr> ret;
 
 			//build the list of all option entries of this shape
 			for ( std::vector<Record*>::const_iterator iter = this->Children.begin(); iter != this->Children.end(); iter++ )
 			{
 				ShapeOptions* opt = dynamic_cast<ShapeOptions*>( *iter );
 
-				if ( opt != NULL )
+				if ( opt == NULL ) continue;
+				
+				for ( size_t i = 0; i < opt->Options.size(); i++)
 				{
-					for ( std::vector<OptionEntry>::iterator oeIter = opt->Options.begin(); oeIter != opt->Options.end(); oeIter++ )
-					{
-						ret.push_back( *oeIter );
-					}
+					ret.push_back( opt->Options[i]);
 				}
 			}
 

ASCOfficeDocFile/DocDocxConverter/OfficeDrawing/ShapeOptions.h

@@ -568,18 +568,19 @@ namespace DocFileFormat
 
 	struct OptionEntry
 	{
-		OptionEntry() :	pid(PropertyId_left), fBid(false), fComplex(false), op(0), opComplex(NULL) 
+		OptionEntry() :	pid(PropertyId_left), fBid(false), fComplex(false), op(0)
 		{
-
 		}
 
 		PropertyId		pid;
 		bool			fBid;
 		bool			fComplex;
 		unsigned int	op;
-		unsigned char*			opComplex;
+		std::shared_ptr<unsigned char>	opComplex;
 	};
 
+	typedef std::shared_ptr<OptionEntry> OptionEntryPtr;
+
 	class ShapeOptions: public Record
 	{
 	public: 
@@ -587,8 +588,8 @@ namespace DocFileFormat
 		static const unsigned short TYPE_CODE_0xF121 = 0xF121;
 		static const unsigned short TYPE_CODE_0xF122 = 0xF122;
 
-		std::vector<OptionEntry>			Options;
-		std::map<PropertyId, OptionEntry>	OptionsByID;
+		std::vector<OptionEntryPtr>				Options;
+		std::map<PropertyId, OptionEntryPtr>	OptionsByID;
 
 		ShapeOptions() : Record()
 		{
@@ -596,8 +597,8 @@ namespace DocFileFormat
 
 		virtual ~ShapeOptions()
 		{
-			for (std::vector<OptionEntry>::iterator iter = Options.begin(); iter != Options.end(); ++iter)
-				RELEASEARRAYOBJECTS( iter->opComplex );
+			//for (std::vector<OptionEntry>::iterator iter = Options.begin(); iter != Options.end(); ++iter)
+			//	RELEASEARRAYOBJECTS( iter->opComplex );
 		}
 
 		ShapeOptions (IBinaryReader* _reader, unsigned int size, unsigned int typeCode, unsigned int version, unsigned int instance) : Record (_reader, size, typeCode, version, instance)
@@ -606,16 +607,16 @@ namespace DocFileFormat
 
 			//instance is the count of properties stored in this record
 
-			OptionEntry entry;
 			//parse the flags and the simple values
 			for (unsigned int i = 0; i < instance; ++i)
 			{
+				OptionEntryPtr entry = std::shared_ptr<OptionEntry>(new OptionEntry());
 				unsigned short flag	=	Reader->ReadUInt16();
 
-				entry.pid			=	(PropertyId)FormatUtils::BitmaskToInt (flag, 0x3FFF);
-				entry.fBid			=	FormatUtils::BitmaskToBool (flag, 0x4000);
-				entry.fComplex		=	FormatUtils::BitmaskToBool (flag, 0x8000);
-				entry.op			=	Reader->ReadUInt32();
+				entry->pid			=	(PropertyId)FormatUtils::BitmaskToInt (flag, 0x3FFF);
+				entry->fBid			=	FormatUtils::BitmaskToBool (flag, 0x4000);
+				entry->fComplex		=	FormatUtils::BitmaskToBool (flag, 0x8000);
+				entry->op			=	Reader->ReadUInt32();
 
 				Options.push_back( entry );
 			}
@@ -625,21 +626,12 @@ namespace DocFileFormat
 			//of the OptionEntry arry, sorted by pid
 			for (unsigned int i = 0; i < instance; ++i)
 			{
-				if (Options[i].fComplex)
-				{
-					int read_size =  (int)Options[i].op + 6 ; //???? 	
-					//todooo !!!! проверить все остальные !! тут размер в зависимости от типа Complex!!!		
-					switch(Options[i].pid)
-					{
-					case PropertyId::gtextUNICODE:
-					case PropertyId::gtextFont:
-						read_size =  (int)Options[i].op;
-						break;
-					}
-					Options[i].opComplex = Reader->ReadBytes( read_size, true );
+				if (Options[i]->fComplex && Options[i]->op > 0)
+				{			
+					Options[i]->opComplex = std::shared_ptr<unsigned char>(Reader->ReadBytes( Options[i]->op, true ));
 				}
 
-				OptionsByID.insert(std::pair<PropertyId, OptionEntry>(Options[i].pid, Options[i]));
+				OptionsByID.insert(std::make_pair(Options[i]->pid, Options[i]));
 			}
 
             Reader->Seek(( pos + size ), 0/*STREAM_SEEK_SET*/);

ASCOfficeDocFile/DocDocxConverter/VMLPictureMapping.cpp

@@ -241,7 +241,7 @@ namespace DocFileFormat
 		std::wstring strHeight = FormatUtils::DoubleToWideString( height.ToPoints() );
 		std::wstring strStyle;
 	
-		std::list<OptionEntry> options;
+		std::vector<OptionEntryPtr> options;
 		
 		PictureFrameType type;
 		if ((pict->shapeContainer || pict->blipStoreEntry) && pict->shapeContainer->Children.size() > 0)
@@ -282,9 +282,9 @@ namespace DocFileFormat
 		}
 //todooo oбъединить с shape_mapping		
 
-		std::list<OptionEntry>::iterator end = options.end();
-		for (std::list<OptionEntry>::iterator iter = options.begin(); iter != end; ++iter)
+		for (size_t i = 0; i < options.size(); i++)
 		{
+			OptionEntryPtr & iter = options[i];
 			switch ( iter->pid )
 			{
 			case wzEquationXML:
@@ -292,7 +292,7 @@ namespace DocFileFormat
 					m_isEquation = true;
 					m_isEmbedded = true;
 					
-					m_embeddedData = std::string((char*)iter->opComplex, iter->op);
+					m_embeddedData = std::string((char*)iter->opComplex.get(), iter->op);
 
 					if (ParseEmbeddedEquation( m_embeddedData, m_equationXml))
 					{
@@ -303,7 +303,7 @@ namespace DocFileFormat
 				{
 					//встроенная неведомая хуйня
 					m_isEmbedded	= true;
-					m_embeddedData	= std::string((char*)iter->opComplex, iter->op);
+					m_embeddedData	= std::string((char*)iter->opComplex.get(), iter->op);
 					
 					//if (ParseEmbeddedBlob( m_embeddedData, m_blobXml)) // todoooo
 					//{

ASCOfficeDocFile/DocDocxConverter/VMLShapeMapping.cpp

@@ -143,8 +143,9 @@ namespace DocFileFormat
 			ShapeContainer* groupShape		=	static_cast<ShapeContainer*>(container->Children[0]);
 			GroupShapeRecord* gsr			=	static_cast<GroupShapeRecord*>(groupShape->Children[0]);
 			Shape* shape					=	static_cast<Shape*>(groupShape->Children[1]);
-			std::list<OptionEntry> options	=	groupShape->ExtractOptions();
-			ChildAnchor* anchor				=	groupShape->FirstChildWithType<ChildAnchor>();
+			
+			ChildAnchor* anchor					=	groupShape->FirstChildWithType<ChildAnchor>();			
+			std::vector<OptionEntryPtr> options	=	groupShape->ExtractOptions();
 
 			m_shapeId = GetShapeID(shape);
 
@@ -155,14 +156,13 @@ namespace DocFileFormat
 			m_pXmlWriter->WriteAttribute( L"coordsize", ( FormatUtils::IntToWideString(gsr->rcgBounds.size.cx) + L"," + FormatUtils::IntToWideString(gsr->rcgBounds.size.cy)));
 
 			// Write wrap coords			
-			std::list<OptionEntry>::const_iterator end = options.end();
-			for (std::list<OptionEntry>::const_iterator iter = options.begin(); iter != end; ++iter)
+			for (size_t i = 0; i < options.size(); i++)
 			{
-				switch (iter->pid)
+				switch (options[i]->pid)
 				{
-				case pWrapPolygonVertices:
+					case pWrapPolygonVertices:
 					{
-						std::wstring wrapCoords	= getWrapCoords(*iter);
+						std::wstring wrapCoords	= GetWrapCoords(options[i]);
 						if (wrapCoords.length())
 							m_pXmlWriter->WriteAttribute(L"wrapcoords", wrapCoords);
 					}
@@ -226,9 +226,9 @@ namespace DocFileFormat
 		bool			freeform =	true;
 		std::wstring	sShapeId;
 
-		std::list<OptionEntry> options	=	pContainer->ExtractOptions();
-		ChildAnchor* pAnchor			=	pContainer->FirstChildWithType<ChildAnchor>();
-		ClientAnchor* clientAnchor		=	pContainer->FirstChildWithType<ClientAnchor>();
+		std::vector<OptionEntryPtr> options	=	pContainer->ExtractOptions();
+		ChildAnchor* pAnchor				=	pContainer->FirstChildWithType<ChildAnchor>();
+		ClientAnchor* clientAnchor			=	pContainer->FirstChildWithType<ClientAnchor>();
 
 		WriteBeginShapeNode (pShape);
 
@@ -294,13 +294,17 @@ namespace DocFileFormat
 
 		std::wstring					sTextboxStyle;
 		
-		std::wstring					adjValues[8];
 		ShadowStyleBooleanProperties	shadowBoolean(0);
-		std::vector<std::wstring>		arrInscribe;
+		
+		OptionEntryPtr				opSegmentInfo;
+		OptionEntryPtr				opVerticles;
+		OptionEntryPtr				opInscribe;
+		OptionEntryPtr				opConnectAngles;
+		OptionEntryPtr				opConnectLocs;
 
-		std::list<OptionEntry>::const_iterator end = options.end();
-		for (std::list<OptionEntry>::const_iterator iter = options.begin(); iter != end; ++iter)
+		for (size_t i = 0; i < options.size(); i++)
 		{
+			OptionEntryPtr & iter = options[i];
 			switch (iter->pid)
 			{
 	//BOOLEANS
@@ -335,19 +339,16 @@ namespace DocFileFormat
 					}
 				}
 				break;
-
 			case protectionBooleans:
 				{
 					ProtectionBooleanProperties booleans(iter->op);
 				}
 				break;
-
 			case diagramBooleans:
 				{
 					DiagramBooleanProperties booleans(iter->op);
 				}
 				break;
-
 			case groupShapeBooleans:
 				{
 					GroupShapeBooleanProperties booleans(iter->op);
@@ -357,56 +358,80 @@ namespace DocFileFormat
 					}
 				}
 				break;
-
-				// GEOMETRY
-
+// GEOMETRY
+			case shapePath :
+				{
+					bHavePath =	true;
+				}break;
+			case pVertices:
+				{
+					opVerticles = iter;
+				}break;
+			case pSegmentInfo:
+				{
+					opSegmentInfo = iter;
+				}break;
+			case pGuides:
+				{
+					GetGuides(iter);
+				}break;
+			case pConnectionSites:
+				{
+					opConnectLocs = iter;
+				}break;
+			case pConnectionSitesDir:
+				{
+					opConnectAngles	= iter;
+				}break;
+			case pInscribe:
+				{
+					opInscribe	= iter;
+				}break;
 			case adjustValue:
 				{
-					adjValues[0]	=	FormatUtils::IntToWideString( (int)iter->op );
-                    nAdjValues		=	(std::max)(nAdjValues,1);
+					m_nAdjValues[0] = (int)iter->op;
+                    nAdjValues		= (std::max)(nAdjValues,1);
 				}
 				break;
-
 			case adjust2Value:
 				{
-					adjValues[1]	=	FormatUtils::IntToWideString( (int)iter->op );
-                    nAdjValues		=	(std::max)(nAdjValues,2);
+					m_nAdjValues[1] = (int)iter->op;
+                    nAdjValues		= (std::max)(nAdjValues, 2);
 				}
 				break;
-
 			case adjust3Value:
 				{
-					adjValues[2]	=	FormatUtils::IntToWideString( (int)iter->op );
-                    nAdjValues		=	(std::max)(nAdjValues,3);
+					m_nAdjValues[2] = (int)iter->op;
+                    nAdjValues		=(std::max)(nAdjValues, 3);
 				}break;
 			case adjust4Value:
 				{
-					adjValues[3]	=	FormatUtils::IntToWideString( (int)iter->op );
-                    nAdjValues		=	(std::max)(nAdjValues,4);
+					m_nAdjValues[3] = (int)iter->op;
+                    nAdjValues		= (std::max)(nAdjValues, 4);
 				}break;
 			case adjust5Value:
 				{
-					adjValues[4]	=	FormatUtils::IntToWideString( (int)iter->op );
-                    nAdjValues		=	(std::max)(nAdjValues,5);
+					m_nAdjValues[4] = (int)iter->op;
+                    nAdjValues		= (std::max)(nAdjValues, 5);
 				}break;
 			case adjust6Value:
 				{
-					adjValues[5]	=	FormatUtils::IntToWideString( (int)iter->op );
-                    nAdjValues		=	(std::max)(nAdjValues,6);
+					m_nAdjValues[5] = (int)iter->op;
+                    nAdjValues		= (std::max)(nAdjValues, 6);
 				}break;
 			case adjust7Value:
 				{
-					adjValues[6]	=	FormatUtils::IntToWideString( (int)iter->op );
-                    nAdjValues		=	(std::max)(nAdjValues,7);
+					m_nAdjValues[6] = (int)iter->op;
+                    nAdjValues		= (std::max)(nAdjValues, 7);
 				}break;
 			case adjust8Value:
 				{
-					adjValues[7]	=	FormatUtils::IntToWideString( (int)iter->op );
-                    nAdjValues		=	(std::max)(nAdjValues,8);
+					m_nAdjValues[7] = (int)iter->op;
+                    nAdjValues		= (std::max)(nAdjValues, 8);
 				}break;
 			case pWrapPolygonVertices:
 				{
-					std::wstring wrapCoords = getWrapCoords(*iter);
+					std::wstring wrapCoords = GetWrapCoords(iter);
 
 					if (!wrapCoords.empty())
 					{
@@ -421,13 +446,6 @@ namespace DocFileFormat
 				{
 					yCoord = iter->op;
 				}break;
-			case pGuides:
-				{
-				}break;
-			case pInscribe:
-				{
-					arrInscribe = GetTextRectangles(*iter);
-				}break;
 // OUTLINE
 			case lineColor:
 				{
@@ -497,7 +515,7 @@ namespace DocFileFormat
 				}break;
 			case fillShadeColors:
 				{
-					appendValueAttribute(&m_fill, L"colors", getFillColorString( iter->opComplex, iter->op ));
+					appendValueAttribute(&m_fill, L"colors", getFillColorString( iter->opComplex.get(), iter->op ));
 				}break;
 			case fillFocus:
 				{
@@ -602,7 +620,7 @@ namespace DocFileFormat
 			case pibName:
 				{
 					std::wstring name;
-					FormatUtils::GetSTLCollectionFromBytes<std::wstring>(&name, iter->opComplex, iter->op, ENCODING_UTF16);
+					FormatUtils::GetSTLCollectionFromBytes<std::wstring>(&name, iter->opComplex.get(), iter->op, ENCODING_UTF16);
 					if (!name.empty())
 						appendValueAttribute(&m_imagedata, L"o:title", FormatUtils::XmlEncode(name));
 				}break;
@@ -676,10 +694,10 @@ namespace DocFileFormat
 					hasTextbox	=	true;
 					nLTxID		=	(((iter->op) >> 16) & 0xFFFF);
 				}break;
-			case dxTextLeft:	{ndxTextLeft	= (int)iter->op;break;}
-			case dyTextTop:		{ndyTextTop		= (int)iter->op;break;}
-			case dxTextRight:	{ndxTextRight	= (int)iter->op;break;}
-			case dyTextBottom:	{ndyTextBottom	= (int)iter->op;break;}
+			case dxTextLeft:	{ndxTextLeft	= (int)iter->op;	break;}
+			case dyTextTop:		{ndyTextTop		= (int)iter->op;	break;}
+			case dxTextRight:	{ndxTextRight	= (int)iter->op;	break;}
+			case dyTextBottom:	{ndyTextBottom	= (int)iter->op;	break;}
 			case txflTextFlow:
 				{
 					switch(iter->op)
@@ -700,7 +718,7 @@ namespace DocFileFormat
 // Word Art
 			case gtextUNICODE:
 				{
-					std::wstring text = NSStringExt::CConverter::GetUnicodeFromUTF16((unsigned short*)iter->opComplex, (iter->op)/2);
+					std::wstring text = NSStringExt::CConverter::GetUnicodeFromUTF16((unsigned short*)iter->opComplex.get(), (iter->op)/2);
 
 					text = FormatUtils::XmlEncode(text);
 
@@ -713,7 +731,7 @@ namespace DocFileFormat
 				}break;
 			case gtextFont:
 				{
-					std::wstring font = NSStringExt::CConverter::GetUnicodeFromUTF16((unsigned short*)iter->opComplex, (iter->op)/2);
+					std::wstring font = NSStringExt::CConverter::GetUnicodeFromUTF16((unsigned short*)iter->opComplex.get(), (iter->op)/2);
 					int i = font.size();
 					while (i > 0)
 					{
@@ -764,31 +782,31 @@ namespace DocFileFormat
 						appendStyleProperty(&m_textPathStyle, L"font-weight", L"bold");
 					}
 				}break;
-  // PATH
-				case shapePath :
-				{
-					bHavePath			=	true;
-
-					std::wstring path	=	ParsePath(options);
-
-					if (false == path.empty())
-						m_pXmlWriter->WriteAttribute (L"path", path);
-				}break;
-				default:
+			default:
 				{
 					int val = iter->op;
 				}break;
 			}
 		}
 
-		if (false == bHavePath)		//	фигура может быть задана только наборами вершин и индексов
+		if (opVerticles && opSegmentInfo)
 		{
-			std::wstring path	=	ParsePath(options);
+			const unsigned char*	pVP	=	opVerticles->opComplex.get();
+			unsigned int			nVP	=	opVerticles->op;
+			const unsigned char*	pSI	=	opSegmentInfo->opComplex.get();
+			unsigned int			nSI	=	opSegmentInfo->op;
+		
+			PathParser oParser (pSI, nSI, pVP, nVP, m_arrGuides);
+			std::wstring path	=	oParser.GetVmlPath();
 
 			if (false == path.empty())
 				m_pXmlWriter->WriteAttribute (L"path", path);
 		}
-
+		if (freeform && (xCoord == 0 || yCoord == 0 ))
+		{
+			xCoord = 21600;
+			yCoord = 21600;
+		}
 		if ( !filled )
 		{
 			m_pXmlWriter->WriteAttribute( L"filled", L"f" );
@@ -804,10 +822,10 @@ namespace DocFileFormat
 			m_pXmlWriter->WriteAttribute(L"o:allowincell", L"f");
 		}
 
-		if ( ( xCoord > 0 ) && ( yCoord > 0 ) )
+		if ( xCoord > 0 && yCoord > 0 )
 		{
 			m_pXmlWriter->WriteAttribute( L"coordsize", ( FormatUtils::IntToWideString( xCoord ) + L"," + FormatUtils::IntToWideString( yCoord ) ));
-		}
+		} 
 
 		int nCode	=	0;
 		if (pShape->GetShapeType())
@@ -819,17 +837,17 @@ namespace DocFileFormat
 		{
 			if (nAdjValues)												
 			{
-				m_pXmlWriter->WriteAttribute(L"arcsize", adjValues[0]);
+				m_pXmlWriter->WriteAttribute(L"arcsize", m_nAdjValues[0]);
 			}
 		}
 		else
 		{
-			if (nAdjValues)												
+			if (nAdjValues > 0)												
 			{
-				std::wstring adjTag	= adjValues[0];
+				std::wstring adjTag	= std::to_wstring(m_nAdjValues[0]);
 
 				for (int i = 1; i < nAdjValues; ++i)
-					adjTag += std::wstring(L",") + adjValues[i];
+					adjTag += L"," + std::to_wstring(m_nAdjValues[i]);
 
 				m_pXmlWriter->WriteAttribute(L"adj", adjTag);
 			}
@@ -982,10 +1000,24 @@ namespace DocFileFormat
 		}
 		if (freeform)
 		{
-			if (arrInscribe.size())
+			if (opInscribe || opConnectAngles || opConnectLocs)
 			{
+				std::vector<std::wstring>	arrInscribe			= GetTextRectangles(opInscribe);
+				std::wstring				strConnectAngles	= GetConnectAngles(opConnectAngles);
+				std::wstring				strConnectLocs		= GetConnectLocs(opConnectLocs);
+				
 				m_pXmlWriter->WriteNodeBegin(L"v:path", true);
-				m_pXmlWriter->WriteAttribute(L"textboxrect", arrInscribe[0]);
+				if (!arrInscribe.empty())
+					m_pXmlWriter->WriteAttribute(L"textboxrect", arrInscribe[0]);
+				if (!strConnectAngles.empty() || !strConnectLocs.empty())
+				{
+					m_pXmlWriter->WriteAttribute(L"o:connecttype", L"custom");
+					if (!strConnectLocs.empty())
+						m_pXmlWriter->WriteAttribute(L"o:connectlocs", strConnectLocs);
+					if (!strConnectAngles.empty())
+						m_pXmlWriter->WriteAttribute(L"o:connectangles", strConnectAngles);
+				}
+
 				m_pXmlWriter->WriteNodeEnd(L"", true);
 			}
 		}
@@ -1182,11 +1214,13 @@ namespace DocFileFormat
 	}
 
 	/// Build the VML wrapcoords string for a given pWrapPolygonVertices
-	std::wstring VMLShapeMapping::getWrapCoords(const OptionEntry& pWrapPolygonVertices) const
+	std::wstring VMLShapeMapping::GetWrapCoords(const OptionEntryPtr& pWrapPolygonVertices) const
 	{
+		if (!pWrapPolygonVertices) return L"";
+
 		std::wstring coords;
 
-		MemoryStream oStream(pWrapPolygonVertices.opComplex, pWrapPolygonVertices.op);
+		MemoryStream oStream(pWrapPolygonVertices->opComplex.get(), pWrapPolygonVertices->op);
 		std::list<int> arrVertices;
 
 		unsigned short nElems		=	oStream.ReadUInt16();
@@ -1498,7 +1532,7 @@ namespace DocFileFormat
 		}
 	}
 
-	void VMLShapeMapping::AppendOptionsToStyle (std::wstring* oStyle, const std::list<OptionEntry>& options, int zIndex) const
+	void VMLShapeMapping::AppendOptionsToStyle (std::wstring* oStyle, const std::vector<OptionEntryPtr>& options, int zIndex) const
 	{
 		bool bRelH = false;
 		bool bRelV = false;
@@ -1508,9 +1542,9 @@ namespace DocFileFormat
 
 		bool bZIndex = false;
 
-		std::list<OptionEntry>::const_iterator end = options.end();
-		for (std::list<OptionEntry>::const_iterator iter = options.begin(); iter != end; ++iter)
+		for (size_t i = 0; i < options.size(); i++)
 		{
+			const OptionEntryPtr & iter = options[i];
 			switch (iter->pid)
 			{
 //	POSITIONING
@@ -1616,15 +1650,16 @@ namespace DocFileFormat
 	}
 
 	//
-	std::wstring VMLShapeMapping::buildStyle (const Shape* shape, const ChildAnchor* anchor, const std::list<OptionEntry>& options, int zIndex) const
+	std::wstring VMLShapeMapping::buildStyle (const Shape* shape, const ChildAnchor* anchor, const std::vector<OptionEntryPtr>& options, int zIndex) const
 	{
 		std::wstring style;
 
-		// Check if some properties are set that cause the dimensions to be twisted
 		bool twistDimensions = false;
-		std::list<OptionEntry>::const_iterator end = options.end();
-		for (std::list<OptionEntry>::const_iterator iter = options.begin(); iter != end; ++iter)
+		
+		for (size_t i = 0; i < options.size(); i++)
 		{
+			const OptionEntryPtr & iter = options[i];
+
 			if (geometryTextBooleanProperties ==  iter->pid)
 			{
 				GeometryTextBooleanProperties props(iter->op);
@@ -1860,61 +1895,210 @@ namespace DocFileFormat
 
 		return wrapType;
 	}
-
-	std::wstring VMLShapeMapping::ParsePath (const std::list<OptionEntry>& options) const
+	std::wstring VMLShapeMapping::GetConnectAngles(const OptionEntryPtr& opAngles) const
 	{
-		const unsigned char* pVP		=	NULL;
-		unsigned int nVP	=	0;
-		const unsigned char* pSI		=	NULL;
-		unsigned int nSI	=	0;
+		if (!opAngles)				return L"";
+		if (!opAngles->opComplex)	return L"";
 		
-		std::list<OptionEntry>::const_iterator end = options.end();
-		for (std::list<OptionEntry>::const_iterator iter = options.begin(); iter != end; ++iter)
+		MemoryStream reader(opAngles->opComplex.get(), opAngles->op);
+
+		unsigned short nElems		=	reader.ReadUInt16();
+		unsigned short nElemsAlloc	=	reader.ReadUInt16();
+		unsigned short nElemSize	=	reader.ReadUInt16();
+
+		bool bTruncated = false;
+
+        if (0xFFF0 == nElemSize)
+        {
+            nElemSize = 4;
+            bTruncated = true;
+        }
+
+        long dwSize = nElems * nElemSize;
+
+        if (opAngles->op - 6 != (dwSize))
+        {
+            bool b = false;
+        }
+		if (nElemSize < 1) return L"";
+
+		int count = dwSize / nElemSize; 
+
+		std::wstring angles;
+		for (int i = 0; i < count; ++i)
 		{
-			if (iter->pid == pVertices)
-			{
-				pVP =	iter->opComplex;
-				nVP	=	iter->op;	
-			}
-
-			if (iter->pid == pSegmentInfo)
-			{
-				pSI =	iter->opComplex;
-				nSI	=	iter->op;	
-			}
+            DWORD v = reader.ReadUInt32();
+			double val = (double)((WORD)(v >> 16) + ((WORD)(v) / 65536.0));
+			angles += std::to_wstring((int)val) + (i < (count - 1) ? L"," : L"");
 		}
+		return angles;
+	}
+	int VMLShapeMapping::UpdateFromGuides(const int val)  const
+	{
+		int new_val = val;
+        LONG lMinF = (LONG)0x80000000;
+        if (lMinF <= val)
+        {
+            int index = (DWORD)val - 0x80000000;
+		
+			if (index >= 0 && index < m_arrGuides.size())
+			{
+				new_val = m_arrGuides[index].param3;
+			}
 
-		PathParser oParser (pSI, nSI, pVP, nVP);
-		return oParser.GetVmlPath();
+        }
+		return new_val;
+	}
+	void VMLShapeMapping::GetGuides( const OptionEntryPtr& opGuides )
+	{
+		if (!opGuides)				return;
+		if (!opGuides->opComplex)	return;
+		
+		MemoryStream reader(opGuides->opComplex.get(), opGuides->op);
+
+		unsigned short nElems		=	reader.ReadUInt16();
+		unsigned short nElemsAlloc	=	reader.ReadUInt16();
+		unsigned short nElemSize	=	reader.ReadUInt16();
+
+		bool bTruncated = false;
+
+        if (0xFFF0 == nElemSize)
+        {
+            nElemSize = 4;
+            bTruncated = true;
+        }
+        long dwSize = nElems * nElemSize;
+
+        if (opGuides->op - 6 != (dwSize))
+        {
+            bool b = false;
+        }
+		int count = dwSize / nElemSize;  //1x (int or short)
+		for (int i = 0; i < count; ++i)
+		{
+			_guides g;
+			WORD flags	= reader.ReadUInt16();
+
+			g.type = flags & 0x1FFF;
+
+			g.param_type1 = (unsigned char)(flags & 0x04);
+			g.param_type2 = (unsigned char)(flags & 0x02);
+			g.param_type3 = (unsigned char)(flags & 0x01);
+
+			g.param1	= reader.ReadUInt16();
+			g.param2	= reader.ReadUInt16();
+			g.param3	= reader.ReadUInt16();
+
+			m_arrGuides.push_back(g);
+		}
 	}
 
-	//
-	std::vector<std::wstring> VMLShapeMapping::GetTextRectangles(const OptionEntry& inscribe) const 
+	std::wstring VMLShapeMapping::GetConnectLocs( const OptionEntryPtr& opLocs ) const
 	{
-		MemoryStream reader(inscribe.opComplex, inscribe.op + 6);
+		if (!opLocs)			return L"";
+		if (!opLocs->opComplex) return L"";
 
-		unsigned short elems		=	reader.ReadUInt16();
-		unsigned short allocElems	=	reader.ReadUInt16();
-		unsigned short cb			=	reader.ReadUInt16();
-	
+		MemoryStream reader(opLocs->opComplex.get(), opLocs->op);
+
+		unsigned short nElems		=	reader.ReadUInt16();
+		unsigned short nElemsAlloc	=	reader.ReadUInt16();
+		unsigned short nElemSize	=	reader.ReadUInt16();
+
+		bool bTruncated = false;
+
+        if (0xFFF0 == nElemSize)
+        {
+            nElemSize = 4;
+            bTruncated = true;
+        }
+
+        long dwSize = nElems * nElemSize;
+
+        if (opLocs->op - 6 != (dwSize))
+        {
+            bool b = false;
+        }
+		int count = dwSize / nElemSize;  //2x (int or short)
+		
+		std::wstring locs;
+		for (int i = 0; i < count; ++i)
+		{
+			POINT pt;
+
+			if (bTruncated)
+			{
+				pt.x =	reader.ReadInt16();
+				pt.y =	reader.ReadInt16();
+			}
+			else
+			{
+				pt.x =	reader.ReadInt32();
+				pt.y =	reader.ReadInt32();
+			}
+           
+			pt.x = UpdateFromGuides(pt.x);
+			pt.y = UpdateFromGuides(pt.y);
+			
+			locs += std::to_wstring(pt.x) + L"," + std::to_wstring(pt.y) + (i < (count - 1) ? L";" : L"");
+		}
+
+		return locs;
+	}
+
+	std::vector<std::wstring> VMLShapeMapping::GetTextRectangles( const OptionEntryPtr& opInscribe ) const
+	{
 		std::vector<std::wstring> rectangles;
+		
+		if (!opInscribe) return rectangles;
+		if (!opInscribe->opComplex) return rectangles;
 
-		if (16 != cb) return rectangles; // TODO: доделать
+		MemoryStream reader(opInscribe->opComplex.get(), opInscribe->op);
 
-		int count = (inscribe.op) / 16;
+		unsigned short nElems		=	reader.ReadUInt16();
+		unsigned short nElemsAlloc	=	reader.ReadUInt16();
+		unsigned short nElemSize	=	reader.ReadUInt16();
 
+		bool bTruncated = false;
+
+        if (0xFFF0 == nElemSize)
+        {
+            nElemSize = 4;
+            bTruncated = true;
+        }
+
+        long dwSize = nElems * nElemSize;
+
+        if (opInscribe->op - 6 != (dwSize))
+        {
+            bool b = false;
+        }
+		int count = dwSize / nElemSize; //4x (int or short)
+		
 		for (int i = 0; i < count; ++i)
 		{
 			RECT rc;
 
-			rc.top		=	reader.ReadInt32();
-			rc.left		=	reader.ReadInt32();
-			rc.right	=	reader.ReadInt32();
-			rc.bottom	=	reader.ReadInt32();
+			if (bTruncated)
+			{
+				rc.top		=	reader.ReadInt16();
+				rc.left		=	reader.ReadInt16();
+				rc.right	=	reader.ReadInt16();
+				rc.bottom	=	reader.ReadInt16();
+			}
+			else
+			{
+				rc.top		=	reader.ReadInt32();
+				rc.left		=	reader.ReadInt32();
+				rc.right	=	reader.ReadInt32();
+				rc.bottom	=	reader.ReadInt32();
+			}
+			rc.top		= UpdateFromGuides(rc.top);
+			rc.left		= UpdateFromGuides(rc.left);
+			rc.right	= UpdateFromGuides(rc.right);
+			rc.bottom	= UpdateFromGuides(rc.bottom);
 
-			std::wstringstream sstream;
-			sstream << boost::wformat(L"%d,%d,%d,%d") % rc.top % rc.left % rc.right % rc.bottom; 
-			rectangles.push_back(sstream.str());
+			rectangles.push_back(	std::to_wstring(rc.top)		+ L","	+ std::to_wstring(rc.left) + L"," + 
+									std::to_wstring(rc.right)	+ L","	+ std::to_wstring(rc.bottom));
 		}
 
 		return rectangles;

ASCOfficeDocFile/DocDocxConverter/VMLShapeMapping.h

@@ -77,17 +77,10 @@ namespace DocFileFormat
 
 		void WritePrimitiveProps(DrawingPrimitive	* primitive, bool root);
 
-		// Converts a group of shapes
 		void WriteGroup(const GroupContainer* pContainer);
-		// Converts a single shape
 		void WriteShape (const ShapeContainer* pContainer);
 
-		/// Generates a string id for the given shape
 		std::wstring GenShapeId(const Shape* pShape) const;
-		/// Build the VML wrapcoords string for a given pWrapPolygonVertices
-		std::wstring getWrapCoords( const OptionEntry& pWrapPolygonVertices ) const;
-		/// Copies the picture from the binary stream to the zip archive 
-		/// and creates the relationships for the image.
 		bool copyPicture( const BlipStoreEntry* bse );
 		std::wstring GetTargetExt( Global::BlipType _type ) const;
 		
@@ -98,21 +91,22 @@ namespace DocFileFormat
 		
 		std::wstring getTextboxAnchor( unsigned int anchor ) const;
 				
-		void AppendOptionsToStyle( std::wstring* style, const std::list<OptionEntry>& options, int zIndex ) const;
+		std::wstring buildStyle		( const Shape* shape, const ChildAnchor* anchor, const std::vector<OptionEntryPtr>& options, int zIndex ) const;
+		void AppendOptionsToStyle	( std::wstring* style, const std::vector<OptionEntryPtr>& options, int zIndex ) const;
 		
-		std::wstring buildStyle		( const Shape* shape, const ChildAnchor* anchor, const std::list<OptionEntry>& options, int zIndex ) const;
+		int UpdateFromGuides(const int val) const;
+
 		std::wstring getLineStyle	( unsigned int p ) const;
 		std::wstring getArrowStyle	( unsigned int op ) const;
 		std::wstring getArrowLength	( unsigned int op ) const;
 		std::wstring getArrowWidth	( unsigned int op ) const;
 		std::wstring getFillMethod	( unsigned int p ) const;
 		std::wstring getFillColorString( const unsigned char* p, unsigned int size ) const;
-		/// Returns the OpenXML fill type of a fill effect
+
 		std::wstring getFillType	( unsigned int p ) const;
 		std::wstring getShadowType	( unsigned int p ) const;
-		/// Returns the OpenXML wrap type of the shape
+
 		std::wstring getWrapType	(const Spa* pSpa) const;
-		std::wstring ParsePath		(const std::list<OptionEntry>& options) const;
 
 		void WriteBeginShapeNode	(const Shape* pShape);
 		void WriteEndShapeNode		(const Shape* pShape);
@@ -121,9 +115,15 @@ namespace DocFileFormat
 		std::wstring GetLineFrom	(const ChildAnchor* pAnchor) const;
 		std::wstring GetLineTo		(const ChildAnchor* pAnchor) const;
 
-		std::vector<std::wstring> GetTextRectangles(const OptionEntry& inscribe) const;
+		std::wstring				GetWrapCoords		( const OptionEntryPtr& pOpt ) const;
+		std::vector<std::wstring>	GetTextRectangles	( const OptionEntryPtr& pOpt ) const;
+		std::wstring				GetConnectAngles	( const OptionEntryPtr& pOpt ) const;
+		std::wstring				GetConnectLocs		( const OptionEntryPtr& pOpt ) const;
+		void						GetGuides			( const OptionEntryPtr& pOpt );
 
-	private: 
+		int								m_nAdjValues[8];
+		std::vector<_guides>			m_arrGuides;
+		
 		bool							m_isInlineShape;
 		Spa*							m_pSpa;
 		IMapping*						m_pCaller;

ASCOfficeDocxFile2/BinReader/Readers.h

@@ -3801,19 +3801,228 @@ public:
 	{
 		int res = c_oSerConstants::ReadOk;
 		CFldSimple* pFldSimple = static_cast<CFldSimple*>(poResult);
-		if ( c_oSer_HyperlinkType::Link == type )
+		if ( c_oSer_FldSimpleType::Instr == type )
 			pFldSimple->sInstr = m_oBufferedStream.GetString3(length);
-		else if ( c_oSer_HyperlinkType::Content == type )
+		else if ( c_oSer_FldSimpleType::Content == type )
 		{
 			XmlUtils::CStringWriter* pPrevWriter = m_pCurWriter;
 			m_pCurWriter = &pFldSimple->writer;
 			res = Read1(length, &Binary_DocumentTableReader::ReadParagraphContent, this, NULL);
 			m_pCurWriter = pPrevWriter;
 		}
+		else if ( c_oSer_FldSimpleType::FFData == type )
+		{
+			OOX::Logic::CFFData oFFData;
+			res = Read1(length, &Binary_DocumentTableReader::ReadFFData, this, &oFFData);
+			pFldSimple->writer.WriteString(oFFData.toXML());
+		}
 		else
 			res = c_oSerConstants::ReadUnknown;
 		return res;
 	}
+	int ReadFFData(BYTE type, long length, void* poResult)
+	{
+		int res = c_oSerConstants::ReadOk;
+		OOX::Logic::CFFData* pFFData = static_cast<OOX::Logic::CFFData*>(poResult);
+		if ( c_oSerFFData::CalcOnExit == type )
+		{
+			pFFData->m_oCalcOnExit.Init();
+			pFFData->m_oCalcOnExit->m_oVal.FromBool(m_oBufferedStream.GetBool());
+		}
+		else if ( c_oSerFFData::CheckBox == type )
+		{
+			pFFData->m_oCheckBox.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadFFCheckBox, this, pFFData->m_oCheckBox.GetPointer());
+		}
+		else if ( c_oSerFFData::DDList == type )
+		{
+			pFFData->m_oDDList.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadDDList, this, pFFData->m_oDDList.GetPointer());
+		}
+		else if ( c_oSerFFData::Enabled == type )
+		{
+			pFFData->m_oEnabled.Init();
+			pFFData->m_oEnabled->m_oVal.FromBool(m_oBufferedStream.GetBool());
+		}
+		else if ( c_oSerFFData::EntryMacro == type )
+		{
+			std::wstring sVal = m_oBufferedStream.GetString3(length);
+			pFFData->m_oEntryMacro.Init();
+			pFFData->m_oEntryMacro->m_oVal.Init();
+			pFFData->m_oEntryMacro->m_oVal->SetValue(sVal);
+		}
+		else if ( c_oSerFFData::ExitMacro == type )
+		{
+			std::wstring sVal = m_oBufferedStream.GetString3(length);
+			pFFData->m_oExitMacro.Init();
+			pFFData->m_oExitMacro->m_oVal.Init();
+			pFFData->m_oExitMacro->m_oVal->SetValue(sVal);
+		}
+		else if ( c_oSerFFData::HelpText == type )
+		{
+			pFFData->m_oHelpText.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadFFHelpText, this, pFFData->m_oHelpText.GetPointer());
+		}
+		else if ( c_oSerFFData::Label == type )
+		{
+			pFFData->m_oLabel.Init();
+			pFFData->m_oLabel->m_oVal.Init();
+			pFFData->m_oLabel->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		}
+		else if ( c_oSerFFData::Name == type )
+		{
+			std::wstring sVal = m_oBufferedStream.GetString3(length);
+			pFFData->m_oName.Init();
+			pFFData->m_oName->m_oVal.Init();
+			pFFData->m_oName->m_oVal->SetValue(sVal);
+		}
+		else if ( c_oSerFFData::StatusText == type )
+		{
+			pFFData->m_oStatusText.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadFFStatusText, this, pFFData->m_oStatusText.GetPointer());
+		}
+		else if ( c_oSerFFData::TabIndex == type )
+		{
+			pFFData->m_oTabIndex.Init();
+			pFFData->m_oTabIndex->m_oVal.Init();
+			pFFData->m_oTabIndex->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		}
+		else if ( c_oSerFFData::TextInput == type )
+		{
+			pFFData->m_oTextInput.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadTextInput, this, pFFData->m_oTextInput.GetPointer());
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadFFCheckBox(BYTE type, long length, void* poResult)
+	{
+		int res = c_oSerConstants::ReadOk;
+		OOX::Logic::CFFCheckBox* pFFCheckBox = static_cast<OOX::Logic::CFFCheckBox*>(poResult);
+		if ( c_oSerFFData::CBChecked == type )
+		{
+			pFFCheckBox->m_oChecked.Init();
+			pFFCheckBox->m_oChecked->m_oVal.FromBool(m_oBufferedStream.GetBool());
+		}
+		else if ( c_oSerFFData::CBDefault == type )
+		{
+			pFFCheckBox->m_oDefault.Init();
+			pFFCheckBox->m_oDefault->m_oVal.FromBool(m_oBufferedStream.GetBool());
+		}
+		else if ( c_oSerFFData::CBSize == type )
+		{
+			pFFCheckBox->m_oSize.Init();
+			pFFCheckBox->m_oSize->m_oVal.Init();
+			pFFCheckBox->m_oSize->m_oVal->FromHps(m_oBufferedStream.GetULong());
+		}
+		else if ( c_oSerFFData::CBSizeAuto == type )
+		{
+			pFFCheckBox->m_oSizeAuto.Init();
+			pFFCheckBox->m_oSizeAuto->m_oVal.FromBool(m_oBufferedStream.GetBool());
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadDDList(BYTE type, long length, void* poResult)
+	{
+		int res = c_oSerConstants::ReadOk;
+		OOX::Logic::CFFDDList* pDDList = static_cast<OOX::Logic::CFFDDList*>(poResult);
+		if ( c_oSerFFData::DLDefault == type )
+		{
+			pDDList->m_oDefault.Init();
+			pDDList->m_oDefault->m_oVal.Init();
+			pDDList->m_oDefault->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		}
+		else if ( c_oSerFFData::DLResult == type )
+		{
+			pDDList->m_oResult.Init();
+			pDDList->m_oResult->m_oVal.Init();
+			pDDList->m_oResult->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		}
+		else if ( c_oSerFFData::DLListEntry == type )
+		{
+			ComplexTypes::Word::String* pVal = new ComplexTypes::Word::String();
+			pVal->m_sVal.Init();
+			pVal->m_sVal->append(m_oBufferedStream.GetString3(length));
+			pDDList->m_arrListEntry.push_back(pVal);
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadFFHelpText(BYTE type, long length, void* poResult)
+	{
+		int res = c_oSerConstants::ReadOk;
+		ComplexTypes::Word::CFFHelpText* pHelpText = static_cast<ComplexTypes::Word::CFFHelpText*>(poResult);
+		if ( c_oSerFFData::HTType == type )
+		{
+			pHelpText->m_oType.Init();
+			pHelpText->m_oType->SetValue((SimpleTypes::EInfoTextType)m_oBufferedStream.GetUChar());
+		}
+		else if ( c_oSerFFData::HTVal == type )
+		{
+			std::wstring sVal = m_oBufferedStream.GetString3(length);
+			pHelpText->m_oVal.Init();
+			pHelpText->m_oVal->SetValue(sVal);
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadFFStatusText(BYTE type, long length, void* poResult)
+	{
+		int res = c_oSerConstants::ReadOk;
+		ComplexTypes::Word::CFFStatusText* pStatusText = static_cast<ComplexTypes::Word::CFFStatusText*>(poResult);
+		if ( c_oSerFFData::HTType == type )
+		{
+			pStatusText->m_oType.Init();
+			pStatusText->m_oType->SetValue((SimpleTypes::EInfoTextType)m_oBufferedStream.GetUChar());
+		}
+		else if ( c_oSerFFData::HTVal == type )
+		{
+			std::wstring sVal = m_oBufferedStream.GetString3(length);
+			pStatusText->m_oVal.Init();
+			pStatusText->m_oVal->SetValue(sVal);
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadTextInput(BYTE type, long length, void* poResult)
+	{
+		int res = c_oSerConstants::ReadOk;
+		OOX::Logic::CFFTextInput* pTextInput = static_cast<OOX::Logic::CFFTextInput*>(poResult);
+		if ( c_oSerFFData::TIDefault == type )
+		{
+			pTextInput->m_oDefault.Init();
+			pTextInput->m_oDefault->m_sVal.Init();
+			pTextInput->m_oDefault->m_sVal->append(m_oBufferedStream.GetString3(length));
+		}
+		else if ( c_oSerFFData::TIFormat == type )
+		{
+			pTextInput->m_oFormat.Init();
+			pTextInput->m_oFormat->m_sVal.Init();
+			pTextInput->m_oFormat->m_sVal->append(m_oBufferedStream.GetString3(length));
+		}
+		else if ( c_oSerFFData::TIMaxLength == type )
+		{
+			pTextInput->m_oMaxLength.Init();
+			pTextInput->m_oMaxLength->m_oVal.Init();
+			pTextInput->m_oMaxLength->m_oVal->SetValue(m_oBufferedStream.GetLong());
+		}
+		else if ( c_oSerFFData::TIType == type )
+		{
+			pTextInput->m_oType.Init();
+			pTextInput->m_oType->m_oVal.Init();
+			pTextInput->m_oType->m_oVal->SetValue((SimpleTypes::EFFTextType)m_oBufferedStream.GetUChar());
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+
 	int ReadHyperlink(BYTE type, long length, void* poResult)
 	{		
 		int res = c_oSerConstants::ReadOk;

ASCOfficeDocxFile2/BinWriter/BinReaderWriterDefines.h

@@ -912,7 +912,8 @@ extern int g_nCurFormatVersion;
 	namespace c_oSer_FldSimpleType{ enum c_oSer_FldSimpleType
 	{
 		Content = 0,
-		Instr = 1
+		Instr = 1,
+		FFData = 2
 	};}
 	namespace c_oSer_ColorThemeType{ enum c_oSer_ColorThemeType
 	{
@@ -1044,6 +1045,34 @@ extern int g_nCurFormatVersion;
 		Temporary = 34,
 		MultiLine = 35
 	};}
+	namespace c_oSerFFData{enum c_oSerFFData
+	{
+		CalcOnExit = 0,
+		CheckBox = 1,
+		DDList = 2,
+		Enabled = 3,
+		EntryMacro = 4,
+		ExitMacro = 5,
+		HelpText = 6,
+		Label = 7,
+		Name = 8,
+		StatusText = 9,
+		TabIndex = 10,
+		TextInput = 11,
+		CBChecked = 12,
+		CBDefault = 13,
+		CBSize = 14,
+		CBSizeAuto = 15,
+		DLDefault = 16,
+		DLResult = 17,
+		DLListEntry = 18,
+		HTType = 19,
+		HTVal = 20,
+		TIDefault = 21,
+		TIFormat = 22,
+		TIMaxLength = 23,
+		TIType = 24,
+	};}
 }
 
 #endif	// #ifndef DOCX_BIN_READER_WRITER_DEFINES

ASCOfficeDocxFile2/BinWriter/BinWriters.h

@@ -3321,11 +3321,208 @@ namespace BinDocxRW
 			nCurPos = m_oBcw.WriteItemStart(c_oSer_FldSimpleType::Instr);
                 m_oBcw.m_oStream.WriteStringW3(*pFldSimple->m_sInstr);
 			m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			//FFData
+			if(pFldSimple->m_oFFData.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSer_FldSimpleType::FFData);
+				WriteFFData(pFldSimple->m_oFFData.get());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
 			//Content
 			nCurPos = m_oBcw.WriteItemStart(c_oSer_FldSimpleType::Content);
 				WriteParagraphContent(pFldSimple->m_arrItems);
 			m_oBcw.WriteItemWithLengthEnd(nCurPos);
 		}
+		void WriteFFData(const OOX::Logic::CFFData& oFFData)
+		{
+			int nCurPos = 0;
+			if(oFFData.m_oCalcOnExit.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::CalcOnExit);
+				m_oBcw.m_oStream.WriteBOOL(oFFData.m_oCalcOnExit->m_oVal.ToBool());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oFFData.m_oCheckBox.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::CheckBox);
+				WriteFFCheckBox(oFFData.m_oCheckBox.get());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oFFData.m_oDDList.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::DDList);
+				WriteDDList(oFFData.m_oDDList.get());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oFFData.m_oEnabled.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::Enabled);
+				m_oBcw.m_oStream.WriteBOOL(oFFData.m_oEnabled->m_oVal.ToBool());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oFFData.m_oEntryMacro.IsInit() && oFFData.m_oEntryMacro->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::EntryMacro);
+				m_oBcw.m_oStream.WriteStringW3(oFFData.m_oEntryMacro->m_oVal->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oFFData.m_oExitMacro.IsInit() && oFFData.m_oExitMacro->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::ExitMacro);
+				m_oBcw.m_oStream.WriteStringW3(oFFData.m_oExitMacro->m_oVal->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oFFData.m_oHelpText.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::HelpText);
+				WriteFFHelpText(oFFData.m_oHelpText.get());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oFFData.m_oLabel.IsInit() && oFFData.m_oLabel->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::Label);
+				m_oBcw.m_oStream.WriteLONG(oFFData.m_oLabel->m_oVal->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oFFData.m_oName.IsInit() && oFFData.m_oName->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::Name);
+				m_oBcw.m_oStream.WriteStringW3(oFFData.m_oName->m_oVal->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oFFData.m_oStatusText.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::StatusText);
+				WriteFFStatusText(oFFData.m_oStatusText.get());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oFFData.m_oTabIndex.IsInit() && oFFData.m_oTabIndex->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::TabIndex);
+				m_oBcw.m_oStream.WriteLONG(oFFData.m_oTabIndex->m_oVal->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oFFData.m_oTextInput.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::TextInput);
+				WriteTextInput(oFFData.m_oTextInput.get());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+		}
+		void WriteFFCheckBox(const OOX::Logic::CFFCheckBox& oCheckBox)
+		{
+			int nCurPos = 0;
+			if(oCheckBox.m_oChecked.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::CBChecked);
+				m_oBcw.m_oStream.WriteBOOL(oCheckBox.m_oChecked->m_oVal.ToBool());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oCheckBox.m_oDefault.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::CBDefault);
+				m_oBcw.m_oStream.WriteBOOL(oCheckBox.m_oDefault->m_oVal.ToBool());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oCheckBox.m_oSize.IsInit() && oCheckBox.m_oSize->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::CBSize);
+				m_oBcw.m_oStream.WriteULONG(oCheckBox.m_oSize->m_oVal->ToHps());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oCheckBox.m_oSizeAuto.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::CBSizeAuto);
+				m_oBcw.m_oStream.WriteBOOL(oCheckBox.m_oSizeAuto->m_oVal.ToBool());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+		}
+		void WriteDDList(const OOX::Logic::CFFDDList& oDDList)
+		{
+			int nCurPos = 0;
+			if(oDDList.m_oDefault.IsInit() && oDDList.m_oDefault->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::DLDefault);
+				m_oBcw.m_oStream.WriteLONG(oDDList.m_oDefault->m_oVal->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oDDList.m_oResult.IsInit() && oDDList.m_oResult->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::DLResult);
+				m_oBcw.m_oStream.WriteLONG(oDDList.m_oResult->m_oVal->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			for(int i = 0 ; i < oDDList.m_arrListEntry.size(); ++i)
+			{
+				ComplexTypes::Word::String* pVal = oDDList.m_arrListEntry[i];
+				if(pVal->m_sVal.IsInit())
+				{
+					nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::DLListEntry);
+					m_oBcw.m_oStream.WriteStringW3(pVal->m_sVal.get());
+					m_oBcw.WriteItemWithLengthEnd(nCurPos);
+				}
+			}
+		}
+		void WriteFFHelpText(const ComplexTypes::Word::CFFHelpText& oHelpText)
+		{
+			int nCurPos = 0;
+			if(oHelpText.m_oType.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::HTType);
+				m_oBcw.m_oStream.WriteBYTE(oHelpText.m_oType->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oHelpText.m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::HTVal);
+				m_oBcw.m_oStream.WriteStringW3(oHelpText.m_oVal->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+		}
+		void WriteFFStatusText(const ComplexTypes::Word::CFFStatusText& oStatusText)
+		{
+			int nCurPos = 0;
+			if(oStatusText.m_oType.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::HTType);
+				m_oBcw.m_oStream.WriteBYTE(oStatusText.m_oType->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oStatusText.m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::HTVal);
+				m_oBcw.m_oStream.WriteStringW3(oStatusText.m_oVal->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+		}
+		void WriteTextInput(const OOX::Logic::CFFTextInput& oTextInput)
+		{
+			int nCurPos = 0;
+			if(oTextInput.m_oDefault.IsInit() && oTextInput.m_oDefault->m_sVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::TIDefault);
+				m_oBcw.m_oStream.WriteStringW3(oTextInput.m_oDefault->m_sVal.get());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oTextInput.m_oFormat.IsInit() && oTextInput.m_oFormat->m_sVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::TIFormat);
+				m_oBcw.m_oStream.WriteStringW3(oTextInput.m_oFormat->m_sVal.get());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oTextInput.m_oMaxLength.IsInit() && oTextInput.m_oMaxLength->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::TIMaxLength);
+				m_oBcw.m_oStream.WriteLONG(oTextInput.m_oMaxLength->m_oVal->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if(oTextInput.m_oType.IsInit() && oTextInput.m_oType->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerFFData::TIType);
+				m_oBcw.m_oStream.WriteBYTE(oTextInput.m_oType->m_oVal->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+		}
 		
 		void WriteHyperlink(OOX::Logic::CHyperlink* pHyperlink)
 		{

ASCOfficeOdfFile/OdfFileTest/OdfFileTest.vcproj

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="windows-1251"?>
 <VisualStudioProject
 	ProjectType="Visual C++"
-	Version="8.00"
+	Version="8,00"
 	Name="OdfFileReaderTest"
 	ProjectGUID="{C2882DDD-07E6-4314-AD4B-48F43F38D722}"
 	RootNamespace="ASCOfficeOdfFileTest"

ASCOfficeOdfFile/src/docx/drawing_object_description.h

@@ -49,6 +49,8 @@ struct _rect
 
 struct drawing_object_description
 {
+	bool									bNotes_;
+
 	oox::RelsType							type_;
 
 	std::wstring							name_;	

ASCOfficeOdfFile/src/docx/pptx_conversion_context.cpp

@@ -132,7 +132,7 @@ void pptx_conversion_context::process_layouts()
 							type == odf_types::presentation_class::header		||
 							type == odf_types::presentation_class::page_number)
 						{
-							if (frame->idx_in_owner <0)
+							if (frame->idx_in_owner < 0)
 								frame->idx_in_owner = last_idx_placeHolder++;
 
 							frame->pptx_convert_placeHolder(*this);
@@ -153,7 +153,9 @@ void pptx_conversion_context::process_master_pages()
 	get_text_context().set_process_layouts(true);
 
 	//берем только актуальные
-	for (size_t master_index =0; master_index < masters.content.size();master_index++)
+	odf_reader::office_element_ptr master_notes_;
+	
+	for (size_t master_index = 0; master_index < masters.content.size(); master_index++)
 	{
 		start_master(master_index);
 		
@@ -163,10 +165,21 @@ void pptx_conversion_context::process_master_pages()
 		if (master)
 		{
 			master->pptx_convert(*this);
+		
+			if (!master_notes_ && master->presentation_notes_)
+				master_notes_ = master->presentation_notes_;
 		}
+
 		
 		end_master();	
 	}
+
+	if (master_notes_)
+	{
+		start_master_notes();
+			master_notes_->pptx_convert(*this);
+		end_master_notes();
+	}
 	process_masters_ = false;
 	get_text_context().set_process_layouts(false);
 
@@ -180,15 +193,15 @@ void pptx_conversion_context::process_theme(std::wstring  name)
 {
 	int current = themes_.size() + 1;
 
-	if (name.length()<1)
+	if (name.empty())
 	{
 		name = L"User Theme: " + boost::lexical_cast<std::wstring>(current);
 	}
  	start_theme(name);
 	//
-		pptx_serialize_clrScheme(current_theme().clrSchemeData());
-		pptx_serialize_fmtScheme(current_theme().fmtSchemeData());
-		pptx_serialize_fontScheme(current_theme().fontSchemeData());
+		pptx_serialize_clrScheme	(current_theme().clrSchemeData());
+		pptx_serialize_fmtScheme	(current_theme().fmtSchemeData());
+		pptx_serialize_fontScheme	(current_theme().fontSchemeData());
 	//
 	end_theme();
 
@@ -209,8 +222,6 @@ void pptx_conversion_context::start_document()
 
 void pptx_conversion_context::end_document()
 {
-    unsigned int count = 1;
-   
 	for (size_t i = 0; i < slideMasters_.size(); i++)
     {
 		pptx_xml_slideMaster_ptr& slideM = slideMasters_[i];
@@ -230,10 +241,11 @@ void pptx_conversion_context::end_document()
                 CP_XML_ATTR(L"r:id", slideM->rId());            
             }
         }
-		count++;
 	}
+	if (!slideMasters_.empty())
+		presentation_.slidesProperties() << slideMasters_[0]->Sizes().str();
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-	count=0;
 	for (size_t i = 0; i < slides_.size(); i++)
     {
 		pptx_xml_slide_ptr& slide = slides_[i];
@@ -249,13 +261,12 @@ void pptx_conversion_context::end_document()
         {
             CP_XML_NODE(L"p:sldId")
             {
-                CP_XML_ATTR(L"id", 0x100 + count); 
+                CP_XML_ATTR(L"id", 0x100 + i); 
                 CP_XML_ATTR(L"r:id", slide->rId());            
             }
         }
-		count++;
     }
-///////////////////////////////////////////////////////////////////////////////////////////
+//----------------------------------------------------------------------------------
 	for (size_t i = 0; i < slideLayouts_.size(); i++)
     {
 		pptx_xml_slideLayout_ptr& slideL = slideLayouts_[i];
@@ -267,30 +278,42 @@ void pptx_conversion_context::end_document()
 
         output_document_->get_ppt_files().add_slideLayout(content);//slideMaster.xml
 	}
-//////////////////////////////////////////////////////////////////////////////////////////////////
-	//размеры страниц в презентации
-    odf_reader::odf_read_context & context =  root()->odf_context();
-    odf_reader::page_layout_container & pageLayouts = context.pageLayoutContainer();
-	
-	if ((pageLayouts.master_pages().size() > 0) && (pageLayouts.master_pages()[0]->attlist_.style_name_))//default
-	{
-		const std::wstring masterStyleName = pageLayouts.master_pages()[0]->attlist_.style_name_.get();
-		const std::wstring pageProperties = root()->odf_context().pageLayoutContainer().page_layout_name_by_style(masterStyleName);
+//----------------------------------------------------------------------------------
+	for (size_t i = 0; i < notes_.size(); i++)
+    {
+		pptx_xml_slideNotes_ptr& slideN = notes_[i];
 
-		odf_reader::page_layout_instance *pages_layouts = root()->odf_context().pageLayoutContainer().page_layout_by_name(pageProperties);
-		
-		if (pages_layouts)pages_layouts->pptx_convert(*this);
+        package::slide_content_ptr content = package::slide_content::create();
+
+		slideN->write_to(content->content());
+        content->add_rels(slideN->Rels());//media & links rels
+
+        output_document_->get_ppt_files().add_notes(content);
 	}
-	/////////////////////////////////////////////////////////////////////////////////////////////
-	pptx_serialize_size(current_presentation().notesSlidesSize(),6858000,9144000,L"p:notesSz");
+	if (slideNotesMaster_)
+	{
+		package::slide_content_ptr content = package::slide_content::create();
+
+		slideNotesMaster_->write_to(content->content());
+        content->add_rels(slideNotesMaster_->Rels());//media & links rels
+
+        output_document_->get_ppt_files().add_notesMaster(content);
+		
+		CP_XML_WRITER(presentation_.slideNotesMastersData())//presentation.xml
+		{
+			CP_XML_NODE(L"p:notesMasterId")
+			{
+				CP_XML_ATTR(L"r:id", slideNotesMaster_->rId());            
+			}
+		}
+	}
+	//else
+		pptx_serialize_size(current_presentation().slidesNotesProperties(), 6858000, 9144000, L"p:notesSz");
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-	//добавляем диаграммы
 
-	count = 0;
 	for (size_t i = 0; i < charts_.size(); i++)
     {
-		count++;
 		package::chart_content_ptr content = package::chart_content::create();
 
 		charts_[i]->serialize(content->content());
@@ -300,7 +323,6 @@ void pptx_conversion_context::end_document()
 	
 	}
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////
-	//добавляем темы
 	for (size_t i=0; i < themes_.size(); i++)
     {
 		output_document_->get_ppt_files().add_theme(themes_[i]);
@@ -308,10 +330,10 @@ void pptx_conversion_context::end_document()
 	}
     package::ppt_comments_files_ptr comments = package::ppt_comments_files::create(comments_context_handle_.content());
     
-	output_document_->get_ppt_files().set_presentation(presentation_);       
-	output_document_->get_ppt_files().set_comments(comments);
-	output_document_->get_ppt_files().set_authors_comments(authors_comments_);
-	output_document_->get_ppt_files().set_media(get_mediaitems(), applicationFonts_);
+	output_document_->get_ppt_files().set_presentation (presentation_);       
+	output_document_->get_ppt_files().set_comments (comments);
+	output_document_->get_ppt_files().set_authors_comments (authors_comments_);
+	output_document_->get_ppt_files().set_media (get_mediaitems(), applicationFonts_);
 
 	output_document_->get_content_types_file().set_media(get_mediaitems());
 }
@@ -321,7 +343,28 @@ void pptx_conversion_context::start_body()
 
 void pptx_conversion_context::end_body()
 {}
-
+pptx_xml_slideNotesMaster & pptx_conversion_context::current_notesMaster()
+{
+    if (slideNotesMaster_)
+    {
+        return *slideNotesMaster_;
+    }
+    else
+    {
+        throw std::runtime_error("internal error");
+    }
+}
+pptx_xml_slideNotes & pptx_conversion_context::current_notes()
+{
+    if (!notes_.empty())
+    {
+        return *notes_.back().get();
+    }
+    else
+    {
+        throw std::runtime_error("internal error");
+    }
+}
 pptx_xml_slide & pptx_conversion_context::current_slide()
 {
     if (!slides_.empty())
@@ -384,9 +427,18 @@ pptx_xml_slideMaster & pptx_conversion_context::current_master()
 }
 void pptx_conversion_context::create_new_slide(std::wstring const & name)
 {
-	pptx_xml_slide_ptr s = pptx_xml_slide::create(name,slides_.size()+1);
+	pptx_xml_slide_ptr s = pptx_xml_slide::create(name,slides_.size() + 1);
     slides_.push_back(s);
 }
+void pptx_conversion_context::create_new_slideNotes()
+{
+	pptx_xml_slideNotes_ptr s = pptx_xml_slideNotes::create( notes_.size() + 1);
+    notes_.push_back(s);
+}
+void pptx_conversion_context::create_new_slideNotesMaster()
+{
+	slideNotesMaster_ = pptx_xml_slideNotesMaster::create();
+}
 void pptx_conversion_context::create_new_slideLayout(int id)
 {
 	pptx_xml_slideLayout_ptr s = pptx_xml_slideLayout::create(id);
@@ -397,7 +449,6 @@ void pptx_conversion_context::create_new_slideMaster(int id)
 	pptx_xml_slideMaster_ptr s = pptx_xml_slideMaster::create(id);
     slideMasters_.push_back(s);
 }
-
 bool pptx_conversion_context::start_page(const std::wstring & pageName,	const std::wstring & pageStyleName,
 																		const std::wstring & pageLayoutName,
 																		const std::wstring & pageMasterName)
@@ -414,7 +465,7 @@ bool pptx_conversion_context::start_page(const std::wstring & pageName,	const st
 					root()->odf_context().styleContainer().presentation_layouts().add_or_find(pageLayoutName,pageMasterName);
 
 	current_slide().Rels().add(relationship(layout_id.second, L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout",
-		std::wstring(L"../slideLayouts/slideLayout")  + boost::lexical_cast<std::wstring>(layout_id.first) + L".xml"));
+		std::wstring(L"../slideLayouts/slideLayout")  + std::to_wstring(layout_id.first) + L".xml"));
 
     return true;
 }
@@ -506,6 +557,14 @@ bool pptx_conversion_context::start_master(int master_index)
 		current_master().add_layout(masters.content[master_index].layouts[i].Id, masters.content[master_index].layouts[i].rId, 0x80000000 + last_uniq_big_id++);
 	}
 
+//----------------------------------------------------------------------------------
+//размеры страниц в презентации
+	const std::wstring pageProperties = root()->odf_context().pageLayoutContainer().page_layout_name_by_style(masters.content[master_index].master_name);
+
+	odf_reader::page_layout_instance *pages_layouts = root()->odf_context().pageLayoutContainer().page_layout_by_name(pageProperties);
+	
+	if (pages_layouts)
+		pages_layouts->pptx_serialize(current_master().Sizes(), *this);
 
 	return true;
 }
@@ -530,47 +589,58 @@ void pptx_conversion_context::end_page()
 
 	get_slide_context().end_slide();
 }
-bool pptx_conversion_context::start_note(const std::wstring & pageName,	const std::wstring & pageStyleName,
-																		const std::wstring & pageLayoutName,
-																		const std::wstring & pageMasterName)
+bool pptx_conversion_context::start_page_notes()
 {
-	//   create_new_slide(pageName);
-	//get_slide_context().start_note();//pageName, pageStyleName);
+	create_new_slideNotes( );
 
-	//current_master_page_name_ = pageMasterName;
-	//current_layout_page_name_ = pageLayoutName;
-	//
-	////const std::wstring masterPageNameLayout = root()->odf_context().pageLayoutContainer().page_layout_name_by_style(current_master_page_name_);
+	current_slide().Rels().add(relationship(notes_.back()->rId(), L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide",
+								L"../notesSlides/notesSlide"  + std::to_wstring(notes_.size()) + L".xml"));
 
-	//std::pair<int,std::wstring> layout_id =
-	//				root()->odf_context().styleContainer().presentation_layouts().add_or_find(pageLayoutName,pageMasterName);
-
-	//current_slide().Rels().add(relationship(layout_id.second, L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout",
-	//	std::wstring(L"../slideLayouts/slideLayout")  + boost::lexical_cast<std::wstring>(layout_id.first) + L".xml"));
-
-	   return true;
+	get_slide_context().start_slide();
+	
+	current_notes().Rels().add(relationship(L"nId1", L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide",
+								L"../slides/slide"  + std::to_wstring(slides_.size()) + L".xml"));
+	
+	return true;
 }
 
-void pptx_conversion_context::end_note()
+void pptx_conversion_context::end_page_notes()
 {
-	//if (!get_comments_context().empty())
-	//   {
-	//       std::wstringstream strm;
-	//       get_comments_context().serialize(strm);        
-	//	
-	//	const std::pair<std::wstring, std::wstring> commentsName =
-	//           comments_context_handle_.add_comments_xml(strm.str(), get_comments_context().get_comments() );
+	get_slide_context().serialize_background(current_notes().Background());
+	get_slide_context().serialize_objects(current_notes().Data());
 
-	//	get_slide_context().add_rels(false, commentsName.second, L"../comments/" + commentsName.first, typeComment);
-	//   } 
+	get_slide_context().dump_rels(current_notes().Rels());//hyperlinks, mediaitems, ...
 
-	//get_slide_context().serialize_background(current_slide().Background());
-	//get_slide_context().serialize_objects	(current_slide().Data());
-	//get_slide_context().serialize_animations(current_slide().Timing());
-	//
-	//get_slide_context().dump_rels(current_slide().Rels());//hyperlinks, mediaitems, ...
+	get_slide_context().end_slide();
+}
+bool pptx_conversion_context::start_master_notes()
+{
+	create_new_slideNotesMaster( );
+	
+	get_slide_context().start_slide();
 
-	//get_slide_context().end_slide();
+	process_theme(L"");//add default theme - одинаковые но под разными именами
+	current_notesMaster().add_theme(current_theme().id(), L"tId1");	
+
+	get_slide_context().start_slide();
+	return true;
+}
+
+void pptx_conversion_context::end_master_notes()
+{
+	get_slide_context().serialize_background(current_notesMaster().Background());
+	get_slide_context().serialize_objects(current_notesMaster().Data());
+
+	get_slide_context().dump_rels(current_notesMaster().Rels());//hyperlinks, mediaitems, ...
+
+	get_slide_context().end_slide();
+	
+	for (size_t i = 0; i < notes_.size(); i++)
+	{
+		notes_[i]->Rels().add(relationship(L"nmId1", 
+			L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster",
+			L"../notesMasters/notesMaster1.xml"));
+	}
 }
 void pptx_conversion_context::end_layout()
 {

ASCOfficeOdfFile/src/docx/pptx_conversion_context.h

@@ -88,11 +88,11 @@ public:
 							const std::wstring & pageMasterName);
 	void end_page();
 	
-    bool start_note(const std::wstring & pageName, 
-							const std::wstring & pageStyleName,
-							const std::wstring & pageLayoutName,
-							const std::wstring & pageMasterName);
-	void end_note();
+    bool start_page_notes();
+	void end_page_notes();
+
+    bool start_master_notes();
+	void end_master_notes();
 
 	bool start_layout(	int layout_index);
 	void end_layout();
@@ -113,10 +113,13 @@ public:
         return odf_document_;
     }
 
-    pptx_xml_slide			& current_slide();
-	pptx_xml_slideLayout	& current_layout();
-	pptx_xml_slideMaster	& current_master();
-    pptx_xml_theme			& current_theme();
+    pptx_xml_slide					& current_slide();
+	pptx_xml_slideLayout			& current_layout();
+	pptx_xml_slideMaster			& current_master();
+    pptx_xml_theme					& current_theme();
+	pptx_xml_slideNotes				& current_notes();
+	pptx_xml_slideNotesMaster		& current_notesMaster();
+
     pptx_xml_presentation	& current_presentation();//собственно она одна
   
 	oox_chart_context	& current_chart();
@@ -144,6 +147,8 @@ private:
     void	create_new_slide(std::wstring const & name);
 	void	create_new_slideLayout(int id);
 	void	create_new_slideMaster(int id);
+    void	create_new_slideNotes();
+    void	create_new_slideNotesMaster();
 
 	package::pptx_document		* output_document_; 
     odf_reader::odf_document	* odf_document_;    
@@ -158,10 +163,12 @@ private:
 	std::vector<oox_chart_context_ptr> charts_;
 	
 	std::vector<pptx_xml_slide_ptr>			slides_;
+	std::vector<pptx_xml_slideNotes_ptr>	notes_;
 	std::vector<pptx_xml_slideMaster_ptr>	slideMasters_;
 	std::vector<pptx_xml_slideLayout_ptr>	slideLayouts_;
 	std::vector<pptx_xml_theme_ptr>			themes_;
 	
+	pptx_xml_slideNotesMaster_ptr			slideNotesMaster_;
 	pptx_xml_authors_comments_ptr			authors_comments_;
 	pptx_xml_presentation					presentation_;
 

ASCOfficeOdfFile/src/docx/pptx_drawing.cpp

@@ -155,8 +155,11 @@ void pptx_serialize_shape(std::wostream & strm, _pptx_drawing & val)
 				odf_reader::GetProperty(val.additional,L"no_rect",bNoRect);
 
 				if (!bNoRect)
-				{					
-					val.serialize_xfrm(CP_XML_STREAM(), L"a", true);
+				{	
+					if (val.cx != 0 || val.cy != 0) //layout
+					{
+						val.serialize_xfrm(CP_XML_STREAM(), L"a", true);
+					}
 					val.serialize_shape(CP_XML_STREAM());
 
 					oox_serialize_ln(CP_XML_STREAM(), val.additional);

ASCOfficeOdfFile/src/docx/pptx_output_xml.cpp

@@ -41,7 +41,7 @@
 namespace cpdoccore {
 namespace oox {
 
-
+//---------------------------------------------------------------------------------------------------------
 std::wstring pptx_xml_slide::name() const
 {
     return name_;
@@ -53,7 +53,7 @@ std::wstring pptx_xml_slide::rId() const
 
 pptx_xml_slide_ptr pptx_xml_slide::create(std::wstring const & name,int id)
 {
-	const std::wstring rId = std::wstring(L"sId") + boost::lexical_cast<std::wstring>(id);
+	const std::wstring rId = std::wstring(L"sId") + std::to_wstring(id);
     return boost::make_shared<pptx_xml_slide>(name,rId);
 }
 
@@ -68,15 +68,15 @@ pptx_xml_slide::~pptx_xml_slide()
 }
 std::wostream & pptx_xml_slide::Data()
 {
-    return slideData_;
+    return strmData_;
 }
 std::wostream & pptx_xml_slide::Background()
 {
-    return slideBackground_;
+    return strmBackground_;
 }
 std::wostream & pptx_xml_slide::Timing()
 {
-    return slideTiming_;
+    return strmTiming_;
 }
 rels & pptx_xml_slide::Rels()
 {
@@ -100,14 +100,14 @@ void pptx_xml_slide::write_to(std::wostream & strm)
             {
    				CP_XML_ATTR(L"name", name());   
 				
-				CP_XML_STREAM() << slideBackground_.str();
+				CP_XML_STREAM() << strmBackground_.str();
 
 				CP_XML_NODE(L"p:spTree")
 				{
-					CP_XML_STREAM() << slideData_.str();
+					CP_XML_STREAM() << strmData_.str();
 				}
             }
-			CP_XML_STREAM() << slideTiming_.str();
+			CP_XML_STREAM() << strmTiming_.str();
 			CP_XML_NODE(L"p:clrMapOvr")
 			{
 				CP_XML_NODE(L"a:masterClrMapping");
@@ -115,7 +115,7 @@ void pptx_xml_slide::write_to(std::wostream & strm)
 		}
 	}
 }
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//---------------------------------------------------------------------------------------------------------
 std::wstring pptx_xml_slideLayout::rId() const
 {
     return rId_;
@@ -123,7 +123,7 @@ std::wstring pptx_xml_slideLayout::rId() const
 
 pptx_xml_slideLayout_ptr pptx_xml_slideLayout::create(int id)
 {
-	const std::wstring rId = std::wstring(L"lrId") + boost::lexical_cast<std::wstring>(id);
+	const std::wstring rId = std::wstring(L"lrId") + std::to_wstring(id);
     return boost::make_shared<pptx_xml_slideLayout>(rId);
 }
 
@@ -137,7 +137,7 @@ pptx_xml_slideLayout::~pptx_xml_slideLayout()
 }
 std::wostream & pptx_xml_slideLayout::Data()
 {
-    return slideLayoutData_;
+    return strmData_;
 }
 rels & pptx_xml_slideLayout::Rels()
 {
@@ -166,7 +166,7 @@ void pptx_xml_slideLayout::write_to(std::wostream & strm)
             {
 				CP_XML_NODE(L"p:spTree")
 				{
-					CP_XML_STREAM() << slideLayoutData_.str();
+					CP_XML_STREAM() << strmData_.str();
 
 //в slideLayoutData_
 //contentPart (Content Part) §19.3.1.14
@@ -189,7 +189,7 @@ void pptx_xml_slideLayout::write_to(std::wostream & strm)
 	}
 }
 
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//---------------------------------------------------------------------------------------------------------
 std::wstring pptx_xml_slideMaster::rId() const
 {
     return rId_;
@@ -197,7 +197,7 @@ std::wstring pptx_xml_slideMaster::rId() const
 
 pptx_xml_slideMaster_ptr pptx_xml_slideMaster::create(int id)
 {
-	const std::wstring rId = std::wstring(L"smId") + boost::lexical_cast<std::wstring>(id);
+	const std::wstring rId = std::wstring(L"smId") + std::to_wstring(id);
     return boost::make_shared<pptx_xml_slideMaster>(rId,id);
 }
 
@@ -212,15 +212,19 @@ pptx_xml_slideMaster::~pptx_xml_slideMaster()
 }
 std::wostream & pptx_xml_slideMaster::Data()
 {
-    return slideMasterData_;
+    return strmData_;
 }
 std::wostream & pptx_xml_slideMaster::DataExtra()
 {
-    return slideMasterDataExtra_;
+    return strmDataExtra_;
 }
 std::wostream & pptx_xml_slideMaster::Background()
 {
-    return slideMasterBackground_;
+    return strmBackground_;
+}
+std::wstringstream & pptx_xml_slideMaster::Sizes()
+{
+    return strmSizes_;
 }
 rels & pptx_xml_slideMaster::Rels()
 {
@@ -229,7 +233,7 @@ rels & pptx_xml_slideMaster::Rels()
 void pptx_xml_slideMaster::add_theme(int id, const std::wstring & tId)
 {
 	rels_.add(relationship( tId, L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme",
-			std::wstring(L"../theme/theme")  + boost::lexical_cast<std::wstring>(id) + L".xml"));
+			std::wstring(L"../theme/theme")  + std::to_wstring(id) + L".xml"));
 }
 
 void pptx_xml_slideMaster::add_layout(int id, const std::wstring & rId, const unsigned int & uniqId)
@@ -237,7 +241,7 @@ void pptx_xml_slideMaster::add_layout(int id, const std::wstring & rId, const un
 	layoutsId_.push_back(std::pair<std::wstring, unsigned int>(rId, uniqId));
 
 	rels_.add(relationship( rId,L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout",
-			std::wstring(L"../slideLayouts/slideLayout")  + boost::lexical_cast<std::wstring>(id) + L".xml"));
+			std::wstring(L"../slideLayouts/slideLayout")  + std::to_wstring(id) + L".xml"));
 }
 
 void pptx_xml_slideMaster::write_to(std::wostream & strm)
@@ -255,11 +259,11 @@ void pptx_xml_slideMaster::write_to(std::wostream & strm)
            
 			CP_XML_NODE(L"p:cSld")
             {
-				CP_XML_STREAM() << slideMasterBackground_.str();
+				CP_XML_STREAM() << strmBackground_.str();
 
 				CP_XML_NODE(L"p:spTree")
 				{
-					CP_XML_STREAM() << slideMasterData_.str();
+					CP_XML_STREAM() << strmData_.str();
 				}
             }
 			CP_XML_NODE(L"p:clrMap")
@@ -288,7 +292,7 @@ void pptx_xml_slideMaster::write_to(std::wostream & strm)
 					}
 				}
 			}
-			CP_XML_STREAM() << slideMasterDataExtra_.str();
+			CP_XML_STREAM() << strmDataExtra_.str();
 			CP_XML_NODE(L"p:txStyles")
 			{
 				CP_XML_NODE(L"p:titleStyle");
@@ -299,6 +303,7 @@ void pptx_xml_slideMaster::write_to(std::wostream & strm)
 	}
 }
 
+//---------------------------------------------------------------------------------------------------------
 pptx_xml_theme_ptr pptx_xml_theme::create(std::wstring const & name,int id)
 {
     return boost::make_shared<pptx_xml_theme>(name,id);
@@ -336,6 +341,7 @@ void pptx_xml_theme::write_to(std::wostream & strm)
 		}
 	}
 }
+//---------------------------------------------------------------------------------------------------------
 pptx_xml_authors_comments_ptr pptx_xml_authors_comments::create()
 {
     return boost::make_shared<pptx_xml_authors_comments>();
@@ -399,6 +405,7 @@ void pptx_xml_authors_comments::write_to(std::wostream & strm)
 	}
 }
 
+//---------------------------------------------------------------------------------------------------------
 void pptx_xml_presentation::write_to(std::wostream & strm)
 {
     CP_XML_WRITER(strm)
@@ -412,14 +419,18 @@ void pptx_xml_presentation::write_to(std::wostream & strm)
             CP_XML_NODE(L"p:sldMasterIdLst")
             {
                 CP_XML_STREAM() << slideMastersData_.str();
-            }            
+            }       
+            CP_XML_NODE(L"p:notesMasterIdLst")
+            {
+                CP_XML_STREAM() << slideNotesMastersData_.str();
+            } 
 			CP_XML_NODE(L"p:sldIdLst")
             {
                 CP_XML_STREAM() << slidesData_.str();
             }
 			CP_XML_STREAM() << slidesProperties_.str();
 
-			CP_XML_STREAM() << notesSlidesSize_.str();
+			CP_XML_STREAM() << slidesNotesProperties_.str();
 
 			CP_XML_NODE(L"p:defaultTextStyle")//??
 			{
@@ -428,5 +439,155 @@ void pptx_xml_presentation::write_to(std::wostream & strm)
         }
 	}
 }
+//---------------------------------------------------------------------------------------------------------
+std::wstring pptx_xml_slideNotes::rId() const
+{
+    return rId_;
+}
+
+pptx_xml_slideNotes_ptr pptx_xml_slideNotes::create(int id)
+{
+	const std::wstring rId = std::wstring(L"nId") + std::to_wstring(id);
+    return boost::make_shared<pptx_xml_slideNotes>(rId);
+}
+
+pptx_xml_slideNotes::pptx_xml_slideNotes(std::wstring const & id)
+{
+	rId_ = id;
+}
+
+pptx_xml_slideNotes::~pptx_xml_slideNotes()
+{
+}
+std::wostream & pptx_xml_slideNotes::Data()
+{
+    return strmData_;
+}
+std::wostream & pptx_xml_slideNotes::Background()
+{
+    return strmBackground_;
+}
+
+rels & pptx_xml_slideNotes::Rels()
+{
+    return rels_;
+}
+
+void pptx_xml_slideNotes::write_to(std::wostream & strm)
+{
+    CP_XML_WRITER(strm)
+    {
+		CP_XML_NODE(L"p:notes")
+        {
+			CP_XML_ATTR(L"xmlns:a",		L"http://schemas.openxmlformats.org/drawingml/2006/main"); 
+			CP_XML_ATTR(L"xmlns:p",		L"http://schemas.openxmlformats.org/presentationml/2006/main");
+			CP_XML_ATTR(L"xmlns:r",		L"http://schemas.openxmlformats.org/officeDocument/2006/relationships"); 
+			CP_XML_ATTR(L"xmlns:p14",	L"http://schemas.microsoft.com/office/powerpoint/2010/main"); 
+			CP_XML_ATTR(L"xmlns:p15",	L"http://schemas.microsoft.com/office/powerpoint/2012/main"); 
+			CP_XML_ATTR(L"xmlns:mc",	L"http://schemas.openxmlformats.org/markup-compatibility/2006");
+           
+			CP_XML_NODE(L"p:cSld")
+            {
+				CP_XML_STREAM() << strmBackground_.str();
+
+				CP_XML_NODE(L"p:spTree")
+				{
+					CP_XML_STREAM() << strmData_.str();
+				}
+            }
+			CP_XML_NODE(L"p:clrMapOvr")
+			{
+				CP_XML_NODE(L"a:masterClrMapping");
+			}
+		}
+	}
+}
+//---------------------------------------------------------------------------------------------------------
+std::wstring pptx_xml_slideNotesMaster::rId() const
+{
+    return rId_;
+}
+
+pptx_xml_slideNotesMaster_ptr pptx_xml_slideNotesMaster::create()
+{
+	const std::wstring rId = std::wstring(L"nmId1");
+    return boost::make_shared<pptx_xml_slideNotesMaster>(rId, 1);
+}
+
+pptx_xml_slideNotesMaster::pptx_xml_slideNotesMaster(std::wstring const & rId, int id)
+{
+	rId_ = rId;
+	id_ = id;
+}
+
+pptx_xml_slideNotesMaster::~pptx_xml_slideNotesMaster()
+{
+}
+std::wostream & pptx_xml_slideNotesMaster::Data()
+{
+    return strmData_;
+}
+std::wostream & pptx_xml_slideNotesMaster::Background()
+{
+    return strmBackground_;
+}
+std::wostream & pptx_xml_slideNotesMaster::Sizes()
+{
+    return strmSizes_;
+}
+rels & pptx_xml_slideNotesMaster::Rels()
+{
+    return rels_;
+}
+void pptx_xml_slideNotesMaster::add_theme(int id, const std::wstring & tId)
+{
+	rels_.add(relationship( tId, L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme",
+		std::wstring(L"../theme/theme")  + std::to_wstring(id) + L".xml"));
+}
+
+void pptx_xml_slideNotesMaster::write_to(std::wostream & strm)
+{
+    CP_XML_WRITER(strm)
+    {
+		CP_XML_NODE(L"p:notesMaster")
+        {
+			CP_XML_ATTR(L"xmlns:a",		L"http://schemas.openxmlformats.org/drawingml/2006/main"); 
+			CP_XML_ATTR(L"xmlns:p",		L"http://schemas.openxmlformats.org/presentationml/2006/main");
+			CP_XML_ATTR(L"xmlns:r",		L"http://schemas.openxmlformats.org/officeDocument/2006/relationships"); 
+			CP_XML_ATTR(L"xmlns:p14",	L"http://schemas.microsoft.com/office/powerpoint/2010/main"); 
+			CP_XML_ATTR(L"xmlns:p15",	L"http://schemas.microsoft.com/office/powerpoint/2012/main"); 
+			CP_XML_ATTR(L"xmlns:mc",	L"http://schemas.openxmlformats.org/markup-compatibility/2006");
+           
+			CP_XML_NODE(L"p:cSld")
+            {
+				CP_XML_STREAM() << strmBackground_.str();
+
+				CP_XML_NODE(L"p:spTree")
+				{
+					CP_XML_STREAM() << strmData_.str();
+				}
+            }
+			CP_XML_NODE(L"p:clrMap")
+			{
+				CP_XML_ATTR(L"folHlink",L"folHlink");
+				CP_XML_ATTR(L"hlink",L"hlink");
+				CP_XML_ATTR(L"accent6",L"accent6");
+				CP_XML_ATTR(L"accent5",L"accent5");
+				CP_XML_ATTR(L"accent4",L"accent4");
+				CP_XML_ATTR(L"accent3",L"accent5");
+				CP_XML_ATTR(L"accent2",L"accent2");
+				CP_XML_ATTR(L"accent1",L"accent1");
+				CP_XML_ATTR(L"tx2",L"dk2");
+				CP_XML_ATTR(L"tx1",L"dk1");
+				CP_XML_ATTR(L"bg2",L"lt2");
+				CP_XML_ATTR(L"bg1",L"lt1");
+			}
+			CP_XML_NODE(L"p:notesStyle")
+			{
+			}
+		}
+	}
+}
+//---------------------------------------------------------------------------------------------------------
 }
 }

ASCOfficeOdfFile/src/docx/pptx_output_xml.h

@@ -49,7 +49,7 @@ class pptx_xml_slide: noncopyable
 public:
     pptx_xml_slide(std::wstring const & name,std::wstring const & id);
     ~pptx_xml_slide();
-public:
+
     std::wstring name() const;
     std::wstring rId() const;
    
@@ -65,41 +65,68 @@ public:
 
 private:
 	std::wstring name_;
-    std::wstringstream  slideData_;
-    std::wstringstream  slideBackground_;
-    std::wstringstream  slideTiming_;
+    std::wstringstream  strmData_;
+    std::wstringstream  strmBackground_;
+    std::wstringstream  strmTiming_;
 	std::wstring rId_;
 
 	rels rels_;
 };
-////////////////////////////////////////////////////////////////////////////////////
+//------------------------------------------------------------------------------------
+class pptx_xml_slideNotes;
+typedef _CP_PTR(pptx_xml_slideNotes) pptx_xml_slideNotes_ptr;
+
+class pptx_xml_slideNotes: noncopyable
+{
+public:
+    pptx_xml_slideNotes(std::wstring const & id);
+    ~pptx_xml_slideNotes();
+
+	std::wstring rId() const;
+   
+    std::wostream & Data();
+    std::wostream & Background();
+	
+	rels & Rels();
+    
+    void write_to(std::wostream & strm);
+
+    static pptx_xml_slideNotes_ptr create(int id);
+
+private:
+    std::wstringstream  strmData_;
+    std::wstringstream  strmBackground_;
+	std::wstring rId_;
+
+	rels rels_;
+};
+//------------------------------------------------------------------------------------
 class pptx_xml_presentation: noncopyable
 {
 public:
 	pptx_xml_presentation(){}
 	~pptx_xml_presentation(){}
 
-	std::wstringstream  & slidesData(){return slidesData_;}
-    std::wstringstream  & slideMastersData(){return slideMastersData_;}
-    std::wstringstream  & notesSlidesData(){return notesSlidesData_;}
+	std::wstringstream  & slidesData()				{return slidesData_;}
+    std::wstringstream  & slideMastersData()		{return slideMastersData_;}
+    std::wstringstream  & slideNotesMastersData()	{return slideNotesMastersData_;}
 
-    std::wstringstream  & slidesProperties(){return slidesProperties_;}
-    std::wstringstream  & notesSlidesSize(){return notesSlidesSize_;}
+    std::wstringstream  & slidesProperties()		{return slidesProperties_;}
+    std::wstringstream  & slidesNotesProperties()	{return slidesNotesProperties_;}
 
 	void write_to(std::wostream & strm);
 
 private:
     std::wstringstream  slidesProperties_;
-	std::wstringstream  notesSlidesSize_;
-
+	std::wstringstream  slidesNotesProperties_;
 
     std::wstringstream  slidesData_;
     std::wstringstream  slideMastersData_;
-    std::wstringstream  notesSlidesData_;
-	std::wstringstream  handoutMasterData_;
+    std::wstringstream  slideNotesMastersData_;
+	std::wstringstream  slideHandoutMasterData_;
 };
 
-//////////////////////////////////////////////////////////////////////////////////////
+//------------------------------------------------------------------------------------
 class pptx_xml_slideLayout;
 typedef _CP_PTR(pptx_xml_slideLayout) pptx_xml_slideLayout_ptr;
 
@@ -121,12 +148,12 @@ public:
     static pptx_xml_slideLayout_ptr create(int id);
 
 private:
-    std::wstringstream  slideLayoutData_;
+    std::wstringstream  strmData_;
 	std::wstring rId_;
 
 	rels rels_;
 };
-///////////////////////////////////////////////////////////////////////////////////////////
+//------------------------------------------------------------------------------------
 class pptx_xml_slideMaster;
 typedef _CP_PTR(pptx_xml_slideMaster) pptx_xml_slideMaster_ptr;
 
@@ -135,12 +162,13 @@ class pptx_xml_slideMaster: noncopyable
 public:
     pptx_xml_slideMaster(std::wstring const & rId, int id);
     ~pptx_xml_slideMaster();
-public:
+
     std::wstring rId() const;
    
-    std::wostream & Data();
-	std::wostream & DataExtra();
-	std::wostream & Background();
+    std::wostream		& Data();
+	std::wostream		& DataExtra();
+	std::wostream		& Background();
+	std::wstringstream	& Sizes();
 	rels & Rels();
 
 	void add_layout(int id, const std::wstring & rId, const unsigned int & uniqId);
@@ -151,9 +179,10 @@ public:
     static pptx_xml_slideMaster_ptr create(int id);
 
 private:
-    std::wstringstream  slideMasterData_;
-	std::wstringstream  slideMasterDataExtra_;
-    std::wstringstream  slideMasterBackground_;
+    std::wstringstream  strmData_;
+	std::wstringstream  strmDataExtra_;
+    std::wstringstream  strmBackground_;
+    std::wstringstream  strmSizes_;
 	
 	std::vector<std::pair<std::wstring, unsigned int>> layoutsId_;
 	std::wstring rId_;
@@ -163,7 +192,42 @@ private:
 
 	rels rels_;
 };
-////////////////////////////////////////////////////////////////////////////////////////////////////////
+//------------------------------------------------------------------------------------
+class pptx_xml_slideNotesMaster;
+typedef _CP_PTR(pptx_xml_slideNotesMaster) pptx_xml_slideNotesMaster_ptr;
+
+class pptx_xml_slideNotesMaster: noncopyable
+{
+public:
+    pptx_xml_slideNotesMaster(std::wstring const & rId, int id);
+    ~pptx_xml_slideNotesMaster();
+
+    std::wstring rId() const;
+   
+    std::wostream & Data();
+	std::wostream & Background();
+	std::wostream & Sizes();
+	rels & Rels();
+
+ 	void add_theme(int id, const std::wstring & tId);
+   
+    void write_to(std::wostream & strm);
+
+    static pptx_xml_slideNotesMaster_ptr create();
+
+private:
+    std::wstringstream  strmData_;
+    std::wstringstream  strmBackground_;
+    std::wstringstream  strmSizes_;
+	
+	std::wstring rId_;
+	int id_;
+
+	std::wstring themeId_;
+
+	rels rels_;
+};
+//------------------------------------------------------------------------------------
 class pptx_xml_theme;
 typedef _CP_PTR(pptx_xml_theme) pptx_xml_theme_ptr;
 
@@ -192,7 +256,7 @@ private:
 	std::wstring name_;
 	int id_;
 };
-////////////////////////////////////////////////////////////////////////////////////////////////////////
+//------------------------------------------------------------------------------------
 class pptx_xml_authors_comments;
 typedef _CP_PTR(pptx_xml_authors_comments) pptx_xml_authors_comments_ptr;
 

ASCOfficeOdfFile/src/docx/pptx_package.cpp

@@ -105,10 +105,11 @@ void slide_content::add_rels(rels & _r)
 		rels_->get_rels().add(r[i]);
 	}
 }
-////////////
-
+//---------------------------------------------------------------------------
 slides_files::slides_files()
-{}
+{
+	rels_ = NULL;
+}
 
 void slides_files::add_slide(slide_content_ptr slide)
 {
@@ -127,13 +128,13 @@ void slides_files::write(const std::wstring & RootPath)
     {
         if (!slides_[i]) continue;
 
-        const std::wstring fileName = std::wstring(L"slide") + boost::lexical_cast<std::wstring>( i + 1 ) + L".xml";
+        const std::wstring fileName = std::wstring(L"slide") + std::to_wstring( i + 1 ) + L".xml";
        
 		contentTypes->add_override(std::wstring(L"/ppt/slides/") + fileName, kWSConType);
 
         if (rels_)
         {
-            const std::wstring id = std::wstring(L"sId") + boost::lexical_cast<std::wstring>( i + 1);
+            const std::wstring id = std::wstring(L"sId") + std::to_wstring( i + 1);
             static const std::wstring kWSRel = L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
             const std::wstring fileRef = std::wstring(L"slides/") + fileName;
             rels_->add(id, kWSRel, fileRef);
@@ -149,7 +150,42 @@ void slides_files::write(const std::wstring & RootPath)
     }
 }
 
-////////////////////////////////////////////
+//---------------------------------------------------------------------------
+void notes_files::write(const std::wstring & RootPath)
+{
+    std::wstring path = RootPath + FILE_SEPARATOR_STR + L"notesSlides" ;
+    NSDirectory::CreateDirectory(path.c_str());
+
+	content_type_content * contentTypes = this->get_main_document()->get_content_types_file().content();
+	static const std::wstring kWSConType = L"application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml";
+    
+    for (int i = 0; i < slides_.size(); i++)
+    {
+        if (!slides_[i]) continue;
+
+		const std::wstring fileName = std::wstring(L"notesSlide") + std::to_wstring( i + 1 ) + L".xml";
+       
+		contentTypes->add_override(std::wstring(L"/ppt/notesSlides/") + fileName, kWSConType);
+
+        if (rels_)
+        {
+            const std::wstring id = std::wstring(L"nId") + std::to_wstring( i + 1);
+            static const std::wstring kWSRel = L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
+            const std::wstring fileRef = std::wstring(L"notesSlides/") + fileName;
+            rels_->add(id, kWSRel, fileRef);
+        }
+
+        slides_[i]->get_rel_file()->set_file_name(fileName + L".rels");//внитренние релсы
+        
+		rels_files relFiles;
+        relFiles.add_rel_file(slides_[i]->get_rel_file());
+        relFiles.write(path);           
+
+        package::simple_element(fileName, slides_[i]->str()).write(path);
+    }
+}
+
+//---------------------------------------------------------------------------
 slideMasters_files::slideMasters_files()
 {}
 
@@ -170,12 +206,12 @@ void slideMasters_files::write(const std::wstring & RootPath)
     {
         if (!slides_[i]) continue;
 
-        const std::wstring fileName = std::wstring(L"slideMaster") + boost::lexical_cast<std::wstring>( i + 1 ) + L".xml";
+		const std::wstring fileName = std::wstring(L"slideMaster") + std::to_wstring( i + 1 ) + L".xml";
         contentTypes->add_override(std::wstring(L"/ppt/slideMasters/") + fileName, kWSConType);
 
         if (rels_)
         {
-            const std::wstring id = std::wstring(L"smId") + boost::lexical_cast<std::wstring>( i + 1);
+            const std::wstring id = std::wstring(L"smId") + std::to_wstring( i + 1);
             static const std::wstring kWSRel = L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster";
             const std::wstring fileRef = std::wstring(L"slideMasters/") + fileName;
             rels_->add(id, kWSRel, fileRef);
@@ -191,7 +227,41 @@ void slideMasters_files::write(const std::wstring & RootPath)
     }
 }
 
-////////////////////////////////////////////
+//---------------------------------------------------------------------------
+void notesMaster_files::write(const std::wstring & RootPath)
+{
+    std::wstring path = RootPath + FILE_SEPARATOR_STR + L"notesMasters" ;
+    NSDirectory::CreateDirectory(path.c_str());
+
+	content_type_content * contentTypes = this->get_main_document()->get_content_types_file().content();
+	static const std::wstring kWSConType = L"application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml";
+   
+    for (int i = 0; i < slides_.size(); i++)
+    {
+        if (!slides_[i]) continue;
+
+		const std::wstring fileName = std::wstring(L"notesMaster") + std::to_wstring( i + 1 ) + L".xml";
+        contentTypes->add_override(std::wstring(L"/ppt/notesMasters/") + fileName, kWSConType);
+
+        if (rels_)
+        {
+            const std::wstring id = std::wstring(L"nmId") + std::to_wstring( i + 1);
+            static const std::wstring kWSRel = L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster";
+            const std::wstring fileRef = std::wstring(L"notesMasters/") + fileName;
+            rels_->add(id, kWSRel, fileRef);
+        }
+
+        slides_[i]->get_rel_file()->set_file_name(fileName + L".rels");//внитренние релсы
+        
+		rels_files relFiles;
+        relFiles.add_rel_file(slides_[i]->get_rel_file());
+        relFiles.write(path);           
+
+        package::simple_element(fileName, slides_[i]->str()).write(path);
+    }
+}
+
+
 slideLayouts_files::slideLayouts_files()
 {}
 
@@ -209,7 +279,7 @@ void slideLayouts_files::write(const std::wstring & RootPath)
     {
         if (!slides_[i]) continue;
 
-        const std::wstring fileName		= std::wstring(L"slideLayout") + boost::lexical_cast<std::wstring>( i + 1 ) + L".xml";
+        const std::wstring fileName		= std::wstring(L"slideLayout") + std::to_wstring( i + 1 ) + L".xml";
         const std::wstring kWSConType	= L"application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml";
        
 		content_type_content * contentTypes = get_main_document()->get_content_types_file().content();
@@ -225,7 +295,7 @@ void slideLayouts_files::write(const std::wstring & RootPath)
     }
 }
 
-///////////////////////////////////////////////////////////////////////////////////////
+//------------------------------------------------------------------------------------
 authors_comments_element::authors_comments_element(pptx_xml_authors_comments_ptr & authors_comments) : authors_comments_(authors_comments)
 {
 }
@@ -261,7 +331,7 @@ void ppt_charts_files::write(const std::wstring & RootPath)
     {
         if (!charts_[i]) continue;
 		
-		const std::wstring fileName = std::wstring(L"chart") + boost::lexical_cast<std::wstring>( i + 1 ) + L".xml";
+		const std::wstring fileName = std::wstring(L"chart") + std::to_wstring( i + 1 ) + L".xml";
         content_type_content * contentTypes = get_main_document()->get_content_types_file().content();
        
 		static const std::wstring kWSConType = L"application/vnd.openxmlformats-officedocument.drawingml.chart+xml";
@@ -291,7 +361,7 @@ void ppt_themes_files::write(const std::wstring & RootPath)
     {
         if (!themes_[i]) continue;
             
-		const std::wstring fileName		= std::wstring(L"theme") + boost::lexical_cast<std::wstring>( i + 1) + L".xml";
+		const std::wstring fileName		= std::wstring(L"theme") + std::to_wstring( i + 1) + L".xml";
 		const std::wstring kWSConType	= L"application/vnd.openxmlformats-officedocument.theme+xml";
        
 		content_type_content * contentTypes = get_main_document()->get_content_types_file().content();
@@ -345,6 +415,12 @@ void ppt_files::write(const std::wstring & RootPath)
     slideMasters_files_.set_main_document( this->get_main_document() );
     slideMasters_files_.write(path);
 	
+    notes_files_.set_main_document( this->get_main_document() );
+    notes_files_.write(path);
+
+    notesMaster_files_.set_rels(&rels_files_);
+    notesMaster_files_.set_main_document( this->get_main_document() );
+    notesMaster_files_.write(path);
 
 	//rels_files_.add( relationship( L"hId1",  L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument", L"ppt/presentation.xml" ) );
 
@@ -412,6 +488,10 @@ void ppt_files::add_slide(slide_content_ptr slide)
 {
     slides_files_.add_slide(slide);
 }
+void ppt_files::add_notes(slide_content_ptr slide)
+{
+    notes_files_.add_slide(slide);
+}
 void ppt_files::add_slideLayout(slide_content_ptr slide)
 {
     slideLayouts_files_.add_slide(slide);
@@ -420,7 +500,10 @@ void ppt_files::add_slideMaster(slide_content_ptr slide)
 {
     slideMasters_files_.add_slide(slide);
 }
-
+void ppt_files::add_notesMaster(slide_content_ptr slide)
+{
+    notesMaster_files_.add_slide(slide);
+}
 void ppt_files::set_media(mediaitems & _Mediaitems, CApplicationFonts *pAppFonts)
 {
 	if (_Mediaitems.count_image + _Mediaitems.count_media > 0)

ASCOfficeOdfFile/src/docx/pptx_package.h

@@ -41,8 +41,10 @@ namespace cpdoccore {
 namespace oox {
 
 class pptx_xml_presentation;
+
 class pptx_xml_theme;
 typedef _CP_PTR(pptx_xml_theme) pptx_xml_theme_ptr;
+
 class pptx_xml_authors_comments;
 typedef _CP_PTR(pptx_xml_authors_comments) pptx_xml_authors_comments_ptr;
 
@@ -55,7 +57,7 @@ public:
 };
 
 
-///////////////////////////////////////////////////////////////////////////////////
+//------------------------------------------------------------------------------
 class slide_content;
 typedef _CP_PTR(slide_content) slide_content_ptr;
 
@@ -72,11 +74,10 @@ public:
 	static _CP_PTR(slide_content) create();
 
 private:
-    std::wstringstream content_;
-    rels_file_ptr rels_;
+    std::wstringstream	content_;
+    rels_file_ptr		rels_;
 };
-
-//  slides_files
+//------------------------------------------------------------------------------
 class slides_files  : public element
 {
 public:
@@ -92,12 +93,18 @@ public:
     virtual void write(const std::wstring & RootPath);
 	void set_slide_ref(const std::wstring & ref_file_path,const std::wstring & ref_file_name);
 
-public:    
     std::vector<slide_content_ptr> slides_;
     rels_files * rels_;
 
 };
-//  slideLayouts_files
+//------------------------------------------------------------------------------
+class notes_files  : public slides_files
+{
+public:
+
+    virtual void write(const std::wstring & RootPath);
+};
+//------------------------------------------------------------------------------
 class slideLayouts_files  : public element
 {
 public:
@@ -107,12 +114,9 @@ public:
 
     virtual void write(const std::wstring & RootPath);
 
-public:    
     std::vector<slide_content_ptr> slides_;
 };
-
-///////////////////////////////////////////////////////////////////////////////
-
+//------------------------------------------------------------------------------
 class authors_comments_element : public element
 {
 public:
@@ -123,9 +127,7 @@ private:
     pptx_xml_authors_comments_ptr & authors_comments_;
 
 };
-/////////////////////////////////////////////////////////////////////////////////////////
-
-//  slideMasters_files
+//------------------------------------------------------------------------------
 class slideMasters_files  : public element
 {
 public:
@@ -140,16 +142,19 @@ public:
 
     virtual void write(const std::wstring & RootPath);
 
-public:    
     std::vector<slide_content_ptr> slides_;
     rels_files * rels_;
 };
-///////////////////////////////////////////////////////////
-
+//------------------------------------------------------------------------------
+class notesMaster_files  : public slideMasters_files
+{
+public:
+    virtual void write(const std::wstring & RootPath);
+};
+//------------------------------------------------------------------------------
 class ppt_comments_files;
 typedef _CP_PTR(ppt_comments_files) ppt_comments_files_ptr;
 
-// ppt_comments
 class ppt_comments_files: public element
 {
 public:
@@ -165,9 +170,7 @@ private:
     const std::vector<pptx_comment_elm> & comments_;
 
 };
-
-//////////////////////////////////////////////////////////////////////////////
-//  ppt_charts_files
+//------------------------------------------------------------------------------
 class ppt_charts_files  : public element
 {
 public:
@@ -179,8 +182,8 @@ public:
     std::vector<chart_content_ptr> charts_;
 
 };
-//////////////////////////////////////////////////////////////////////////////
-//  ppt_theme_files
+//------------------------------------------------------------------------------
+
 class ppt_themes_files  : public element
 {
 public:
@@ -192,13 +195,12 @@ public:
     std::vector<pptx_xml_theme_ptr> themes_;
 
 };
-///////////////////////////////////////////////////////////////////////////////////////////////////////
+//------------------------------------------------------------------------------
 class ppt_files : public element
 {
 public:
     ppt_files();
 
-public:
     virtual void write(const std::wstring & RootPath);
 
     void set_presentation(pptx_xml_presentation & presentation);
@@ -206,9 +208,11 @@ public:
 	void set_styles(element_ptr Element);
 	void set_comments(element_ptr Element);
 
-	void add_slide(slide_content_ptr sheet);
+	void add_slide		(slide_content_ptr sheet);
 	void add_slideLayout(slide_content_ptr sheet);
 	void add_slideMaster(slide_content_ptr sheet);
+	void add_notes		(slide_content_ptr sheet);
+	void add_notesMaster(slide_content_ptr sheet);
 	
 	void set_media(mediaitems & _Mediaitems, CApplicationFonts *pAppFonts);    
     void add_charts(chart_content_ptr chart);
@@ -217,25 +221,21 @@ public:
 	void set_authors_comments(pptx_xml_authors_comments_ptr & authors_comments);    
 
 private:
-    rels_files			rels_files_;
+    rels_files				rels_files_;
    
-	slides_files		slides_files_;    
-	slideLayouts_files	slideLayouts_files_;    
-	slideMasters_files	slideMasters_files_;
+	slides_files			slides_files_;    
+	slideLayouts_files		slideLayouts_files_;    
+	slideMasters_files		slideMasters_files_;
+	notes_files				notes_files_;    
+	notesMaster_files		notesMaster_files_;
 	
+	//slides_files		handoutMasters_files_; 	
 	ppt_themes_files	themes_files_;
 
     ppt_charts_files	charts_files_;
-	//slides_files		notesSlides_files_;
-	//slides_files		notesMasters_files_;
-	//slides_files		handoutMasters_files_;
- 	
-	element_ptr			authors_comments_;
-	
+	element_ptr			authors_comments_;	
 	element_ptr			presentation_;
-
     element_ptr			tableStyles_;
-
 	element_ptr			comments_;
     element_ptr			media_;
     element_ptr			embeddings_;
@@ -247,7 +247,6 @@ class pptx_document : public document
 public:
     pptx_document();
 
-public:
     virtual void write(const std::wstring & RootPath);
 
     virtual content_types_file	& get_content_types_file()	{ return content_type_file_; }

ASCOfficeOdfFile/src/docx/pptx_slide_context.cpp

@@ -53,7 +53,6 @@ typedef _CP_PTR(pptx_drawings) pptx_drawings_ptr;
 class pptx_slide_context::Impl
 {
 public:  
-	
 	struct _transition
 	{
 		bool					Enabled;
@@ -66,7 +65,7 @@ public:
 		bool					onClick;
 	};
 
-	Impl(const std::wstring & odfPacket) : mediaitems_(odfPacket),odfPacket_(odfPacket)
+	Impl(const std::wstring & odfPacket) : mediaitems_(odfPacket), odfPacket_(odfPacket)
     {
 		clear();
 	}
@@ -75,24 +74,17 @@ public:
 	std::vector<drawing_object_description> objects_;
 
 	_CP_OPT(_oox_fill)						background_fill_;
+
 	_transition								transition_;
 	bool									use_image_replacement_;
 
 	bool header, footer, date_time, slideNum;
 
-    void add_drawing(_pptx_drawing const & d,
-        bool isInternal,
-        std::wstring const & rid,
-        std::wstring const & ref,
-        RelsType type)
+    void add_drawing(_pptx_drawing const & d, bool isInternal, std::wstring const & rid, std::wstring const & ref, RelsType type)
     {
         pptx_drawings_->add(d, isInternal, rid, ref, type);
     }
-      void add_additional_rels(
-        bool isInternal,
-        std::wstring const & rid,
-        std::wstring const & ref,
-        RelsType type)
+	void add_additional_rels (bool isInternal, std::wstring const & rid, std::wstring const & ref, RelsType type)
     {
         pptx_drawings_->add(isInternal, rid, ref, type);
     }
@@ -107,16 +99,16 @@ public:
 	{
 		objects_.clear();
 		
-		background_fill_ = boost::none;
+		background_fill_		= boost::none;
 
-		header=false;
-		footer=false;
-		date_time=false;
-		slideNum=false;
+		header		= false;
+		footer		= false;
+		date_time	= false;
+		slideNum	= false;
 		
 		rId_ = 1;
 
-		pptx_drawings_ = pptx_drawings::create();
+		pptx_drawings_			= pptx_drawings::create();
 
 		transition_.Enabled = false;
 		transition_.Speed	= boost::none;
@@ -127,7 +119,6 @@ public:
     {
 		return rId_++;;
     }
-
     pptx_drawings_ptr get_drawings()
     {
         return pptx_drawings_;
@@ -137,7 +128,7 @@ public:
 	void process_drawings();
 
 private:
-	void process_common_properties(drawing_object_description& obj,_pptx_drawing & drawing);
+	void process_common_properties(drawing_object_description& obj, _pptx_drawing & drawing);
 
 	void process_shape	(drawing_object_description& obj, _pptx_drawing & drawing);
     void process_image	(drawing_object_description& obj, _pptx_drawing & drawing);
@@ -145,14 +136,15 @@ private:
 	void process_table	(drawing_object_description& obj, _pptx_drawing & drawing);
 	void process_object	(drawing_object_description& obj, _pptx_drawing & drawing);
 	
-	size_t rId_;
-	mediaitems mediaitems_;
-    pptx_drawings_ptr pptx_drawings_;
+	size_t				rId_;
+	mediaitems			mediaitems_;
+    pptx_drawings_ptr	pptx_drawings_;
+    pptx_drawings_ptr	pptx_notes_drawings_;
 };
 
 void pptx_slide_context::Impl::process_drawings()
 {
-	for (int i = 0; i < objects_.size(); i++)
+	for (size_t i = 0; i < objects_.size(); i++)
 	{
 		_pptx_drawing drawing	=_pptx_drawing();
 
@@ -175,17 +167,19 @@ void pptx_slide_context::Impl::process_drawings()
 }
 
 pptx_slide_context::pptx_slide_context(pptx_conversion_context & Context)
- : impl_(new pptx_slide_context::Impl(Context.root()->get_folder()))
+										: impl_(new pptx_slide_context::Impl(Context.root()->get_folder()))
 {    
-	hlinks_size_ = 0;
+	hlinks_size_	= 0;
 }
 void pptx_slide_context::start_slide()
 {    
 	impl_->clear(); // objects
-	hlinks_size_ = 0;
+	
+	hlinks_size_	= 0;
 	
 	default_set(); //for current object
 }
+
 /////////////////////////////////////////////////////////////////////////////////////////////////
 void pptx_slide_context::start_slide_animation()
 {    
@@ -202,10 +196,10 @@ void pptx_slide_context::start_slide_animation()
 
 void pptx_slide_context::set_transitionFilter(std::wstring & type,_CP_OPT(std::wstring) & dir,_CP_OPT(std::wstring) & dop,_CP_OPT(int) & time)
 {
-	impl_->transition_.Type	= type;
-	impl_->transition_.Time = time; // не путать длительность перехода с длительностью эффекта перехода (в oo его нет)
-	impl_->transition_.Dir = dir;
-	impl_->transition_.Param =	dop;
+	impl_->transition_.Type		= type;
+	impl_->transition_.Time		= time; // не путать длительность перехода с длительностью эффекта перехода (в oo его нет)
+	impl_->transition_.Dir		= dir;
+	impl_->transition_.Param	= dop;
 }
 
 void pptx_slide_context::set_transitionAction(bool val)
@@ -215,8 +209,8 @@ void pptx_slide_context::set_transitionAction(bool val)
 
 void pptx_slide_context::set_transitionSpeed(std::wstring val)
 {
-	if (val == L"medium")impl_->transition_.Speed=L"med";
-	else impl_->transition_.Speed= val;//fast / slow
+	if (val == L"medium")	impl_->transition_.Speed = L"med";
+	else					impl_->transition_.Speed = val;//fast / slow
 }
 
 
@@ -227,6 +221,7 @@ void pptx_slide_context::default_set()
     impl_->object_description_.name_		= L"";
 	impl_->object_description_.descriptor_  = L"";
 	impl_->object_description_.anchor_		= L"";
+
 	impl_->object_description_.additional_.clear();
 	
 	impl_->object_description_.clipping_string_= L"";
@@ -247,10 +242,10 @@ void pptx_slide_context::set_use_image_replacement()
 
 void pptx_slide_context::set_placeHolder_type(std::wstring typeHolder)
 {
-	if (typeHolder == L"ftr")	impl_->footer= true;
-	if (typeHolder == L"hdr")	impl_->header= true;
-	if (typeHolder == L"dt")	impl_->date_time= true;
-	if (typeHolder == L"sldNum")impl_->slideNum= true;
+	if (typeHolder == L"ftr")	impl_->footer		= true;
+	if (typeHolder == L"hdr")	impl_->header		= true;
+	if (typeHolder == L"dt")	impl_->date_time	= true;
+	if (typeHolder == L"sldNum")impl_->slideNum		= true;
 
 	impl_->object_description_.additional_.push_back(odf_reader::_property(L"PlaceHolderType",typeHolder));
 }
@@ -445,7 +440,7 @@ void pptx_slide_context::process_drawings()
 	return impl_->process_drawings();
 }
 
-void pptx_slide_context::Impl::process_image(drawing_object_description& pic, _pptx_drawing & drawing)
+void pptx_slide_context::Impl::process_image(drawing_object_description& obj, _pptx_drawing & drawing)
 {
 	int pos_replaicement = 0, pos_preview = 0;
 	
@@ -453,22 +448,22 @@ void pptx_slide_context::Impl::process_image(drawing_object_description& pic, _p
 	drawing.fill.type		= 2;
 	
 	_CP_OPT(std::wstring) sTextContent;
-	GetProperty(pic.additional_, L"text-content", sTextContent);
+	GetProperty(obj.additional_, L"text-content", sTextContent);
 	if (sTextContent)//в ms office на картинке нельзя сделать надпись - меняем тип на рект с заливкой картинкой
 	{
 		drawing.type		= typeShape;
 		drawing.sub_type	= 2;//rect
 	}
 
-	std::wstring fileName = odfPacket_ + FILE_SEPARATOR_STR + pic.xlink_href_;			
-	drawing.fill.bitmap->bCrop  = odf_reader::parse_clipping(pic.clipping_string_,fileName,drawing.fill.bitmap->cropRect, NULL);
+	std::wstring fileName = odfPacket_ + FILE_SEPARATOR_STR + obj.xlink_href_;			
+	drawing.fill.bitmap->bCrop  = odf_reader::parse_clipping(obj.clipping_string_, fileName, drawing.fill.bitmap->cropRect, NULL);
 	drawing.fill.bitmap->bStretch = true;
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////			
 	std::wstring ref;/// это ссылка на выходной внешний объект
 	bool isMediaInternal = false;
 	
-	drawing.fill.bitmap->rId = get_mediaitems().add_or_find(pic.xlink_href_, typeImage, isMediaInternal, ref);
+	drawing.fill.bitmap->rId = get_mediaitems().add_or_find(obj.xlink_href_, typeImage, isMediaInternal, ref);
 	
 	if (drawing.type == typeShape)
 	{
@@ -476,11 +471,13 @@ void pptx_slide_context::Impl::process_image(drawing_object_description& pic, _p
 	
 		isMediaInternal	= true;
 		std::wstring rId = get_mediaitems().add_or_find(L"", typeShape, isMediaInternal, ref);
+		
 		add_drawing(drawing, isMediaInternal, rId, ref, typeShape);//объект
 
-	}else if (!drawing.fill.bitmap->rId.empty())
+	}
+	else if (!drawing.fill.bitmap->rId.empty())
 	{
-		add_drawing(drawing, isMediaInternal, drawing.fill.bitmap->rId , ref, drawing.type);//объект
+		add_drawing(drawing, isMediaInternal, drawing.fill.bitmap->rId, ref, drawing.type);//объект
 	}
 }
 void pptx_slide_context::Impl::process_chart(drawing_object_description & obj, _pptx_drawing & drawing)
@@ -488,8 +485,9 @@ void pptx_slide_context::Impl::process_chart(drawing_object_description & obj, _
     std::wstring ref;
     bool isMediaInternal = true;
    
-	drawing.objectId = get_mediaitems().add_or_find(obj.xlink_href_, obj.type_, isMediaInternal, ref);        
-    add_drawing(drawing, isMediaInternal, drawing.objectId, ref, drawing.type);
+	drawing.objectId = get_mediaitems().add_or_find(obj.xlink_href_, obj.type_, isMediaInternal, ref);  
+	
+	add_drawing(drawing, isMediaInternal, drawing.objectId, ref, drawing.type);
 }
 
 void pptx_slide_context::Impl::process_table(drawing_object_description & obj, _pptx_drawing & drawing)
@@ -499,6 +497,7 @@ void pptx_slide_context::Impl::process_table(drawing_object_description & obj, _
 	std::wstring rId = get_mediaitems().add_or_find(L"", obj.type_, isMediaInternal, ref);        
    
 	add_drawing(drawing, isMediaInternal, rId, ref, drawing.type);
+
 }
 
 void pptx_slide_context::Impl::process_shape(drawing_object_description & obj, _pptx_drawing & drawing)
@@ -511,6 +510,7 @@ void pptx_slide_context::Impl::process_shape(drawing_object_description & obj, _
 	if (drawing.fill.bitmap)
 	{
 		drawing.fill.bitmap->rId = get_mediaitems().add_or_find(drawing.fill.bitmap->xlink_href_, typeImage, isMediaInternal, ref);
+		
 		add_additional_rels(isMediaInternal, drawing.fill.bitmap->rId, ref, typeImage);
 	}
 		
@@ -541,11 +541,12 @@ void pptx_slide_context::Impl::process_object(drawing_object_description& obj, _
 	drawing.objectId		= get_mediaitems().add_or_find(obj.xlink_href_, obj.type_, isMediaInternal, ref);      
 	drawing.objectProgId	= obj.descriptor_;
 
-    add_drawing(drawing, isMediaInternal, drawing.objectId, ref, drawing.type);
+	add_drawing(drawing, isMediaInternal, drawing.objectId, ref, drawing.type);
 
 	if (drawing.fill.bitmap)
 	{
 		drawing.fill.bitmap->rId = get_mediaitems().add_or_find(drawing.fill.bitmap->xlink_href_, typeImage, isMediaInternal, ref);
+		
 		add_additional_rels(isMediaInternal, drawing.fill.bitmap->rId, ref, typeImage);
 	}
 }
@@ -575,7 +576,6 @@ void pptx_slide_context::Impl::process_common_properties(drawing_object_descript
 	drawing.fill = pic.fill_;
 }
 
-
 void pptx_slide_context::dump_rels(rels & Rels)
 {
 	impl_->get_drawings()->dump_rels(Rels);
@@ -590,6 +590,7 @@ void pptx_slide_context::add_rels( bool isInternal, std::wstring const & rid, st
 {
 	impl_->add_additional_rels(isInternal, rid, ref, type);
 }
+
 void pptx_slide_context::set_footer()
 {
 	impl_->footer = true;
@@ -608,7 +609,7 @@ void pptx_slide_context::set_date_time()
 }
 void pptx_slide_context::serialize_background(std::wostream & strm, bool always)
 {
-	if (!always && ( (!impl_->background_fill_) || (impl_->background_fill_->type==0))) return;
+	if (!always && ( (!impl_->background_fill_) || (impl_->background_fill_->type == 0))) return;
   
 	CP_XML_WRITER(strm)
     {
@@ -618,7 +619,7 @@ void pptx_slide_context::serialize_background(std::wostream & strm, bool always)
 			{
 				if (impl_->background_fill_)
 				{
-					oox_serialize_fill(CP_XML_STREAM(),impl_->background_fill_.get());
+					oox_serialize_fill(CP_XML_STREAM(), impl_->background_fill_.get());
 				}
 				else
 				{
@@ -689,7 +690,6 @@ void pptx_slide_context::serialize_HeaderFooter(std::wostream & strm)
 		}
 	}
 }
-
 void pptx_slide_context::serialize_objects(std::wostream & strm)
 {
 	int next_id = impl_->next_rId();
@@ -701,8 +701,8 @@ void pptx_slide_context::serialize_objects(std::wostream & strm)
 		{
 			CP_XML_NODE(L"p:cNvPr")
 			{
-				CP_XML_ATTR(L"name",L"noGroup");
-				CP_XML_ATTR(L"id",next_id);
+				CP_XML_ATTR(L"name", L"noGroup");
+				CP_XML_ATTR(L"id", next_id);
 			}
 			CP_XML_NODE(L"p:cNvGrpSpPr");
 			CP_XML_NODE(L"p:nvPr");	

ASCOfficeOdfFile/src/docx/pptx_slide_context.h

@@ -89,16 +89,19 @@ public:
     void end_table();
 
 	void start_shape(int type);
-    void end_shape();
+    void end_shape	();
 	
 	void set_use_image_replacement();
 
 	bool empty() const;
 //////////////////////////////////////////////////////////////////////////////////////////////
-	void serialize_objects(std::wostream & strm);
-	void serialize_HeaderFooter(std::wostream & strm);
-	void serialize_background(std::wostream & strm, bool always=false);
-	void serialize_animations(std::wostream & strm);
+	
+	void serialize_HeaderFooter	(std::wostream & strm);
+	void serialize_animations	(std::wostream & strm);	
+	
+	void serialize_objects		(std::wostream & strm);
+	
+	void serialize_background	(std::wostream & strm, bool always = false);
 
 	void dump_rels(rels & Rels);
 
@@ -106,7 +109,7 @@ public:
 
 	mediaitems & get_mediaitems();
 
-	void add_background(_oox_fill & fill);
+	void add_background			(_oox_fill & fill);
 
 	void add_rels( bool isInternal,
         std::wstring const & rid,

ASCOfficeOdfFile/src/odf/anim_elements.cpp

@@ -58,6 +58,7 @@ const wchar_t * anim_par::name = L"par";
 
 void anim_par::add_attributes( const xml::attributes_wc_ptr & Attributes )
 {
+	attlist_.add_attributes(Attributes);
 }
 
 void anim_par::pptx_convert(oox::pptx_conversion_context & Context)
@@ -98,6 +99,7 @@ const wchar_t * anim_seq::name = L"seq";
 
 void anim_seq::add_attributes( const xml::attributes_wc_ptr & Attributes )
 {
+	attlist_.add_attributes(Attributes);
 }
 
 void anim_seq::pptx_convert(oox::pptx_conversion_context & Context)
@@ -129,8 +131,7 @@ const wchar_t * anim_transitionFilter::name = L"transitionFilter";
 
 void anim_transitionFilter::add_attributes( const xml::attributes_wc_ptr & Attributes )
 {
-	common_anim_smil_attlist_.add_attributes(Attributes);
-	anim_transition_filter_attlist_.add_attributes(Attributes);
+	attlist_.add_attributes(Attributes);
 }
 
 void anim_transitionFilter::pptx_convert(oox::pptx_conversion_context & Context)
@@ -142,20 +143,20 @@ void anim_transitionFilter::pptx_convert(oox::pptx_conversion_context & Context)
 
 	_CP_OPT(std::wstring) param;
 
-	if (anim_transition_filter_attlist_.smil_dur_)
+	if (attlist_.smil_dur_)
 	{
-		time = anim_transition_filter_attlist_.smil_dur_->get_value();
+		time = attlist_.smil_dur_->get_value();
 	}	
-	if (anim_transition_filter_attlist_.smil_fadeColor_)
+	if (attlist_.smil_fadeColor_)
 	{
-		color =anim_transition_filter_attlist_.smil_fadeColor_->get_hex_value();
+		color =attlist_.smil_fadeColor_->get_hex_value();
 	}
 
 	smil_transition_type::type transition_type;
 
-	if (anim_transition_filter_attlist_.smil_type_)
+	if (attlist_.smil_type_)
 	{
-		transition_type = anim_transition_filter_attlist_.smil_type_->get_type();
+		transition_type = attlist_.smil_type_->get_type();
 	}
 
 	switch(transition_type)
@@ -164,13 +165,13 @@ void anim_transitionFilter::pptx_convert(oox::pptx_conversion_context & Context)
 			type = L"split";
 			break; 
 		case smil_transition_type::irisWipe: 
-			if ((anim_transition_filter_attlist_.smil_subtype_) && (anim_transition_filter_attlist_.smil_subtype_.get()==L"diamond"))
+			if ((attlist_.smil_subtype_) && (attlist_.smil_subtype_.get()==L"diamond"))
 				type = L"diamond";
 			else
 				type = L"zoom";
 			break; 
 		case smil_transition_type::miscDiagonalWipe: 
-			if ((anim_transition_filter_attlist_.smil_subtype_) && (anim_transition_filter_attlist_.smil_subtype_.get()==L"doubleDiamond"))
+			if ((attlist_.smil_subtype_) && (attlist_.smil_subtype_.get()==L"doubleDiamond"))
 				type = L"diamond";
 			else
 				type = L"zoom";
@@ -197,10 +198,10 @@ void anim_transitionFilter::pptx_convert(oox::pptx_conversion_context & Context)
 		case smil_transition_type::singleSweepWipe: //
 		case smil_transition_type::doubleFanWipe: //
 			type = L"wheel";
-			if ((anim_transition_filter_attlist_.smil_subtype_)  && (anim_transition_filter_attlist_.smil_subtype_.get()==L"oneBlade"))	 param = L"1";
-			if ((anim_transition_filter_attlist_.smil_subtype_)  && (anim_transition_filter_attlist_.smil_subtype_.get()==L"threeBlade"))param = L"3";
-			if ((anim_transition_filter_attlist_.smil_subtype_)  && (anim_transition_filter_attlist_.smil_subtype_.get()==L"fourBlade")) param = L"4";
-			if ((anim_transition_filter_attlist_.smil_subtype_)  && (anim_transition_filter_attlist_.smil_subtype_.get()==L"eightBlade"))param = L"8";
+			if ((attlist_.smil_subtype_)  && (attlist_.smil_subtype_.get()==L"oneBlade"))	param = L"1";
+			if ((attlist_.smil_subtype_)  && (attlist_.smil_subtype_.get()==L"threeBlade"))	param = L"3";
+			if ((attlist_.smil_subtype_)  && (attlist_.smil_subtype_.get()==L"fourBlade"))	param = L"4";
+			if ((attlist_.smil_subtype_)  && (attlist_.smil_subtype_.get()==L"eightBlade"))	param = L"8";
 			break; 
 		case smil_transition_type::fanWipe: 
 			type = L"wedge";
@@ -211,22 +212,22 @@ void anim_transitionFilter::pptx_convert(oox::pptx_conversion_context & Context)
 			break;
 		case smil_transition_type::checkerBoardWipe:
 			type = L"checker";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"across")	dir = L"horz";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"down")	dir = L"vert";
+			if (attlist_.smil_subtype_.get()==L"across")	dir = L"horz";
+			if (attlist_.smil_subtype_.get()==L"down")		dir = L"vert";
 			break;
 		case smil_transition_type::blindsWipe:
 			type = L"blinds";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"vertical")	dir = L"vert";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"horizontal")	dir = L"horz";
+			if (attlist_.smil_subtype_.get()==L"vertical")		dir = L"vert";
+			if (attlist_.smil_subtype_.get()==L"horizontal")	dir = L"horz";
 			break;
 		case smil_transition_type::diagonalWipe:
 		case smil_transition_type::waterfallWipe:
 			type = L"strips";			
-			if (anim_transition_filter_attlist_.smil_subtype_)
+			if (attlist_.smil_subtype_)
 			{
-				if	(anim_transition_filter_attlist_.smil_subtype_.get()==L"horizontalLeft")	dir = L"rd";	
-				else if(anim_transition_filter_attlist_.smil_subtype_.get()==L"horizontalRight")dir = L"lu";	
-				else if(anim_transition_filter_attlist_.smil_subtype_.get()==L"verticalRight")	dir = L"ld";
+				if		(attlist_.smil_subtype_.get() == L"horizontalLeft")		dir = L"rd";	
+				else if (attlist_.smil_subtype_.get() == L"horizontalRight")	dir = L"lu";	
+				else if (attlist_.smil_subtype_.get() == L"verticalRight")		dir = L"ld";
 				else dir = L"ru";	
 			}
 			break;
@@ -235,13 +236,13 @@ void anim_transitionFilter::pptx_convert(oox::pptx_conversion_context & Context)
 			break;		
 		case smil_transition_type::randomBarWipe:
 			type = L"randomBar";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"vertical")	dir = L"vert";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"horizontal")	dir = L"horz";
+			if (attlist_.smil_subtype_.get() == L"vertical")	dir = L"vert";
+			if (attlist_.smil_subtype_.get() == L"horizontal")	dir = L"horz";
 			break;	
 		case smil_transition_type::pushWipe: 
 			type = L"push";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"combVertical")	{type = L"comb"; dir = L"vert";};
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"combHorizontal")	{type = L"comb"; dir = L"horz";};
+			if (attlist_.smil_subtype_.get()==L"combVertical")		{type = L"comb"; dir = L"vert";};
+			if (attlist_.smil_subtype_.get()==L"combHorizontal")	{type = L"comb"; dir = L"horz";};
 			break;	
 		case smil_transition_type::slideWipe: 
 			type = L"pull";
@@ -251,19 +252,19 @@ void anim_transitionFilter::pptx_convert(oox::pptx_conversion_context & Context)
 			break;
 		case smil_transition_type::barnDoorWipe: 
 			type = L"split";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"vertical")	param = L"vert";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"horizontal")	param = L"horz";			
+			if (attlist_.smil_subtype_.get()==L"vertical")		param = L"vert";
+			if (attlist_.smil_subtype_.get()==L"horizontal")	param = L"horz";			
 			break;
 		case smil_transition_type::barWipe:
 			type = L"wipe";
-			if (anim_transition_filter_attlist_.smil_subtype_)
+			if (attlist_.smil_subtype_)
 			{
-				if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromTopLeft")	{type = L"strips"; dir = L"rd";}
-				if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromBottomLeft")	{type = L"strips"; dir = L"ru";}
-				if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromTopRight")	{type = L"strips"; dir = L"ld";}
-				if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromBottomRight"){type = L"strips"; dir = L"lu";}
+				if (attlist_.smil_subtype_.get()==L"fromTopLeft")	{type = L"strips"; dir = L"rd";}
+				if (attlist_.smil_subtype_.get()==L"fromBottomLeft"){type = L"strips"; dir = L"ru";}
+				if (attlist_.smil_subtype_.get()==L"fromTopRight")	{type = L"strips"; dir = L"ld";}
+				if (attlist_.smil_subtype_.get()==L"fromBottomRight"){type = L"strips"; dir = L"lu";}
 				
-				if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fadeOverColor")	{type = L"fade"; param = L"0";}
+				if (attlist_.smil_subtype_.get()==L"fadeOverColor")	{type = L"fade"; param = L"0";}
 			}
 			break;
 ///////////////////////////////////////////////////////
@@ -281,39 +282,39 @@ void anim_transitionFilter::pptx_convert(oox::pptx_conversion_context & Context)
 			break;
 //////////////////////////////////////////////////////
 	}
-	if (anim_transition_filter_attlist_.smil_subtype_)
+	if (attlist_.smil_subtype_)
 	{
 		if (!dir)
 		{
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"leftToRight")
+			if (attlist_.smil_subtype_.get()==L"leftToRight")
 			{
-				if ((anim_transition_filter_attlist_.smil_direction_) && (anim_transition_filter_attlist_.smil_direction_.get()==L"reverse"))dir = L"l";
+				if ((attlist_.smil_direction_) && (attlist_.smil_direction_.get()==L"reverse"))dir = L"l";
 				else dir = L"r";
 			}
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"topToBottom")
+			if (attlist_.smil_subtype_.get()==L"topToBottom")
 			{
-				if ((anim_transition_filter_attlist_.smil_direction_) && (anim_transition_filter_attlist_.smil_direction_.get()==L"reverse"))dir = L"u";
+				if ((attlist_.smil_direction_) && (attlist_.smil_direction_.get()==L"reverse"))dir = L"u";
 				else dir = L"d";	
 			}
 
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromTop")		dir = L"d";	
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromLeft")		dir = L"r";	
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromRight")		dir = L"l";			
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromBottom")		dir = L"u";	
+			if (attlist_.smil_subtype_.get()==L"fromTop")		dir = L"d";	
+			if (attlist_.smil_subtype_.get()==L"fromLeft")		dir = L"r";	
+			if (attlist_.smil_subtype_.get()==L"fromRight")		dir = L"l";			
+			if (attlist_.smil_subtype_.get()==L"fromBottom")	dir = L"u";	
 			
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"topRight")		dir = L"ld";	
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"bottomLeft")		dir = L"lu";	
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"bottomRight")	dir = L"ru";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"topLeft")		dir = L"rd";	
+			if (attlist_.smil_subtype_.get()==L"topRight")		dir = L"ld";	
+			if (attlist_.smil_subtype_.get()==L"bottomLeft")	dir = L"lu";	
+			if (attlist_.smil_subtype_.get()==L"bottomRight")	dir = L"ru";
+			if (attlist_.smil_subtype_.get()==L"topLeft")		dir = L"rd";	
 		
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromTopLeft")	dir = L"rd";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromBottomLeft")	dir = L"ru";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromTopRight")	dir = L"ld";
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"fromBottomRight")dir = L"lu";
+			if (attlist_.smil_subtype_.get()==L"fromTopLeft")	dir = L"rd";
+			if (attlist_.smil_subtype_.get()==L"fromBottomLeft")dir = L"ru";
+			if (attlist_.smil_subtype_.get()==L"fromTopRight")	dir = L"ld";
+			if (attlist_.smil_subtype_.get()==L"fromBottomRight")dir = L"lu";
 
 		}
 		
-		if (!dir && (anim_transition_filter_attlist_.smil_direction_) && (anim_transition_filter_attlist_.smil_direction_.get()==L"reverse"))
+		if (!dir && (attlist_.smil_direction_) && (attlist_.smil_direction_.get()==L"reverse"))
 			dir = L"in";
 	}
 

ASCOfficeOdfFile/src/odf/anim_elements.h

@@ -56,9 +56,11 @@ public:
     static const ElementType type = typeAnimPar;
     CPDOCCORE_DEFINE_VISITABLE();
 
-  	office_element_ptr		 anim_par_;
-	office_element_ptr_array anim_seq_array_;
-	office_element_ptr_array content_;
+	odf_types::common_anim_smil_attlist		attlist_;
+  	
+	office_element_ptr						anim_par_;
+	office_element_ptr_array				anim_seq_array_;
+	office_element_ptr_array				content_;
 
 	virtual void pptx_convert(oox::pptx_conversion_context & Context);
 
@@ -79,7 +81,8 @@ public:
     static const ElementType type = typeAnimSeq;
     CPDOCCORE_DEFINE_VISITABLE();
 
-	office_element_ptr_array anim_par_array_;
+	odf_types::common_anim_smil_attlist		attlist_;
+	office_element_ptr_array				anim_par_array_;
    
 	virtual void pptx_convert(oox::pptx_conversion_context & Context);
 
@@ -103,12 +106,12 @@ class anim_transition_filter_attlist
 public:
     void add_attributes( const xml::attributes_wc_ptr & Attributes );
 	
-	_CP_OPT(std::wstring)	smil_direction_;
-	_CP_OPT(std::wstring)	smil_subtype_; 
+	_CP_OPT(std::wstring)						smil_direction_;
+	_CP_OPT(std::wstring)						smil_subtype_; 
 	_CP_OPT(odf_types::smil_transition_type)	smil_type_;
-	_CP_OPT(std::wstring)	smil_mode_;
-	_CP_OPT(odf_types::color)			smil_fadeColor_;
-	_CP_OPT(odf_types::clockvalue)		smil_dur_;
+	_CP_OPT(std::wstring)						smil_mode_;
+	_CP_OPT(odf_types::color)					smil_fadeColor_;
+	_CP_OPT(odf_types::clockvalue)				smil_dur_;
 };
 
 //anim:transitionFilter
@@ -122,11 +125,8 @@ public:
     CPDOCCORE_DEFINE_VISITABLE();
 
 	virtual void pptx_convert(oox::pptx_conversion_context & Context);
-///////////////////////////////////////////////////////////	
-	odf_types::common_anim_smil_attlist		common_anim_smil_attlist_;
-	anim_transition_filter_attlist			anim_transition_filter_attlist_;
-
 
+	anim_transition_filter_attlist	attlist_;
 private:
 	virtual void add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name){}
 	virtual void add_attributes( const xml::attributes_wc_ptr & Attributes );

ASCOfficeOdfFile/src/odf/datatypes/clockvalue.cpp

@@ -41,8 +41,13 @@ namespace cpdoccore { namespace odf_types {
 
 std::wostream & operator << (std::wostream & _Wostream, const clockvalue & _Val)
 {
- //  5ms     = 5 milliseconds
-	_Wostream << _Val.get_value() << "ms"; // todoooo усложнить ..
+ //  5ms = 5 milliseconds
+	if (_Val.get_value() < 0)	
+		_Wostream << L"indefinite";
+	else
+	{
+		_Wostream << _Val.get_value() << "ms"; // todoooo усложнить ..
+	}
     return _Wostream;    
 }
 
@@ -120,15 +125,20 @@ static bool parseTime(const std::wstring & Time, double & Hours, double & Minute
 }
 clockvalue clockvalue::parse(const std::wstring & Str)
 {
-    int v=0;
+ 	if (Str == L"indefinite")
+		return clockvalue(-1);
+	else
+	{
+		int v=0;
 
-	int ms=0;
-	double h=0,m=0,s =0;
-	bool res = parseTime(Str,h,m,s,ms);
+		int ms=0;
+		double h=0,m=0,s =0;
+		bool res = parseTime(Str,h,m,s,ms);
 
-	v = (((h*60)+m)*60+s)*1000+ms;
+		v = (((h*60)+m)*60+s)*1000+ms;
 
-    return clockvalue(v);
+		return clockvalue(v);
+	}
 }
 
 

ASCOfficeOdfFile/src/odf/datatypes/common_attlists.cpp

@@ -804,18 +804,32 @@ void common_presentation_attlist::serialize(CP_ATTR_NODE)
 
 void common_anim_smil_attlist::add_attributes( const xml::attributes_wc_ptr & Attributes )
 {
-	//CP_APPLY_ATTR(L"smil:direction", smil_direction_);
- //   CP_APPLY_ATTR(L"smil:subtype", smil_subtype_);
- //   CP_APPLY_ATTR(L"smil:type", smil_type_);
-	//CP_APPLY_ATTR(L"smil:dur", smil_dur_);
+	CP_APPLY_ATTR(L"presentation:node-type",	presentation_node_type_);
+	CP_APPLY_ATTR(L"smil:direction",			smil_direction_);
+    CP_APPLY_ATTR(L"smil:begin",				smil_begin_);
+	CP_APPLY_ATTR(L"smil:end",					smil_end_);
+	CP_APPLY_ATTR(L"smil:restart",				smil_restart_);
+	CP_APPLY_ATTR(L"smil:dur",					smil_dur_);
 
 }
 void common_anim_smil_attlist::apply_from(const common_anim_smil_attlist & Other)
 {
-    //_CP_APPLY_PROP(smil_direction_, Other.smil_direction_);
-    //_CP_APPLY_PROP(smil_subtype_, Other.smil_subtype_);
-    //_CP_APPLY_PROP(smil_type_, Other.smil_type_);
-   // _CP_APPLY_PROP(smil_dur_, Other.smil_dur_);
+	_CP_APPLY_PROP(presentation_node_type_, Other.presentation_node_type_);
+
+    _CP_APPLY_PROP(smil_direction_,		Other.smil_direction_);
+    _CP_APPLY_PROP(smil_begin_,			Other.smil_begin_);
+	_CP_APPLY_PROP(smil_end_,			Other.smil_end_);
+	_CP_APPLY_PROP(smil_restart_,		Other.smil_restart_);
+    _CP_APPLY_PROP(smil_dur_,			Other.smil_dur_);
+}
+void common_anim_smil_attlist::serialize(CP_ATTR_NODE)
+{
+	CP_XML_ATTR_OPT(L"smil:direction",			smil_direction_);
+	CP_XML_ATTR_OPT(L"smil:restart",			smil_restart_);
+	CP_XML_ATTR_OPT(L"smil:dur",				smil_dur_);
+	CP_XML_ATTR_OPT(L"presentation:node-type",	presentation_node_type_);
+	CP_XML_ATTR_OPT(L"smil:begin",				smil_begin_);
+	CP_XML_ATTR_OPT(L"smil:end",				smil_end_);
 }
 void union_common_draw_attlists::serialize(CP_ATTR_NODE)
 {

ASCOfficeOdfFile/src/odf/datatypes/common_attlists.h

@@ -575,15 +575,16 @@ class common_anim_smil_attlist
 public:
     void add_attributes	( const xml::attributes_wc_ptr & Attributes );
     void apply_from		(const common_anim_smil_attlist & Other);
-	void serialize		(CP_ATTR_NODE){}
+	void serialize		(CP_ATTR_NODE);
 
-	//_CP_OPT(std::wstring) smil_direction_;
-	//_CP_OPT(std::wstring) smil_subtype_; 
-	//_CP_OPT(std::wstring) smil_type_;
-	//_CP_OPT(std::wstring) smil_dur_;
+	_CP_OPT(std::wstring)			presentation_node_type_;
 
-	//_CP_OPT(color)	smil_fadeColor;
+	_CP_OPT(std::wstring)			smil_direction_;
+	_CP_OPT(std::wstring)			smil_restart_;
+	_CP_OPT(odf_types::clockvalue)	smil_dur_;
 
+	_CP_OPT(std::wstring)			smil_begin_;
+	_CP_OPT(std::wstring)			smil_end_;
 };
 
 }

ASCOfficeOdfFile/src/odf/datatypes/presentationclass.cpp

@@ -126,13 +126,15 @@ std::wstring presentation_class::get_type_ms()
 			res = L"sldNum";
 			break;
         case subtitle:
-		case page:
 		case notes:
 		case handout:
         case outline:
 		case text:
 			res = L"body";
 			break;
+		case page:
+			res = L"sldImg";
+			break;
 	}
 	return res;
 }

ASCOfficeOdfFile/src/odf/datatypes/smil_transitiontype.cpp

@@ -41,47 +41,47 @@ std::wostream & operator << (std::wostream & _Wostream, const smil_transition_ty
 {
 	switch(_Val.get_type())
 	{
-	case smil_transition_type::barWipe			:	_Wostream << L"barwipe"			; break;
-	case smil_transition_type::boxWipe			:	_Wostream << L"boxwipe"			; break;
-	case smil_transition_type::fourBoxWipe		:	_Wostream << L"fourboxwipe"		; break;
-	case smil_transition_type::barnDoorWipe		:	_Wostream << L"barndoorwipe"	; break;
-	case smil_transition_type::diagonalWipe		:	_Wostream << L"diagonalwipe"	; break;
-	case smil_transition_type::bowTieWipe		:	_Wostream << L"bowtiewipe"		; break;
-	case smil_transition_type::miscDiagonalWipe	:	_Wostream << L"miscdiagonalwipe"; break;
-	case smil_transition_type::veeWipe			:	_Wostream << L"veewipe"			; break;
-	case smil_transition_type::barnVeeWipe		:	_Wostream << L"barnveewipe"		; break;
-	case smil_transition_type::zigZagWipe		:	_Wostream << L"zigzagwipe"		; break;
-	case smil_transition_type::barnZigZagWipe	:	_Wostream << L"barnzigzagwipe"	; break;
-	case smil_transition_type::irisWipe			:	_Wostream << L"iriswipe"		; break;
-	case smil_transition_type::triangleWipe		:	_Wostream << L"trianglewipe"	; break;
-	case smil_transition_type::arrowHeadWipe	:	_Wostream << L"arrowheadwipe"	; break;
-	case smil_transition_type::pentagonWipe		:	_Wostream << L"pentagonwipe"	; break;
-	case smil_transition_type::hexagonWipe		:	_Wostream << L"hexagonwipe"		; break;
-	case smil_transition_type::ellipseWipe		:	_Wostream << L"ellipsewipe"		; break;
-	case smil_transition_type::eyeWipe			:	_Wostream << L"eyewipe"			; break;
-	case smil_transition_type::roundRectWipe	:	_Wostream << L"roundrectwipe"	; break;
-	case smil_transition_type::starWipe			:	_Wostream << L"starwipe"		; break;
-	case smil_transition_type::miscShapeWipe	:	_Wostream << L"miscshapewipe"	; break;
-	case smil_transition_type::clockWipe		:	_Wostream << L"clockwipe"		; break;
-	case smil_transition_type::pinWheelWipe		:	_Wostream << L"pinwheelwipe"	; break;
-	case smil_transition_type::singleSweepWipe	:	_Wostream << L"singlesweepwipe"	; break;
-	case smil_transition_type::fanWipe			:	_Wostream << L"fanwipe"			; break;
-	case smil_transition_type::doubleFanWipe	:	_Wostream << L"doublefanwipe"	; break;
-	case smil_transition_type::doubleSweepWipe	:	_Wostream << L"doublesweepwipe"	; break;
-	case smil_transition_type::saloonDoorWipe	:	_Wostream << L"saloondoorwipe"	; break;
-	case smil_transition_type::windshieldWipe	:	_Wostream << L"windshieldwipe"	; break;
-	case smil_transition_type::snakeWipe		:	_Wostream << L"snakewipe"		; break;
-	case smil_transition_type::spiralWipe		:	_Wostream << L"spiralwipe"		; break;
-	case smil_transition_type::parallelSnakesWipe:	_Wostream << L"parallelsnakeswipe"; break;
-	case smil_transition_type::boxSnakesWipe	:	_Wostream << L"boxsnakeswipe"	; break;
-	case smil_transition_type::waterfallWipe	:	_Wostream << L"waterfallwipe"	; break;
-	case smil_transition_type::pushWipe			:	_Wostream << L"pushwipe"		; break;
-	case smil_transition_type::slideWipe		:	_Wostream << L"slidewipe"		; break;
+	case smil_transition_type::barWipe			:	_Wostream << L"barWipe"			; break;
+	case smil_transition_type::boxWipe			:	_Wostream << L"boxWipe"			; break;
+	case smil_transition_type::fourBoxWipe		:	_Wostream << L"fourBoxWipe"		; break;
+	case smil_transition_type::barnDoorWipe		:	_Wostream << L"barnDoorWipe"	; break;
+	case smil_transition_type::diagonalWipe		:	_Wostream << L"diagonalWipe"	; break;
+	case smil_transition_type::bowTieWipe		:	_Wostream << L"bowTieWipe"		; break;
+	case smil_transition_type::miscDiagonalWipe	:	_Wostream << L"miscDiagonalWipe"; break;
+	case smil_transition_type::veeWipe			:	_Wostream << L"veeWipe"			; break;
+	case smil_transition_type::barnVeeWipe		:	_Wostream << L"barnVeeWipe"		; break;
+	case smil_transition_type::zigZagWipe		:	_Wostream << L"zigZagWipe"		; break;
+	case smil_transition_type::barnZigZagWipe	:	_Wostream << L"barnZigZagWipe"	; break;
+	case smil_transition_type::irisWipe			:	_Wostream << L"irisWipe"		; break;
+	case smil_transition_type::triangleWipe		:	_Wostream << L"triangleWipe"	; break;
+	case smil_transition_type::arrowHeadWipe	:	_Wostream << L"arrowHeadWipe"	; break;
+	case smil_transition_type::pentagonWipe		:	_Wostream << L"pentagonWipe"	; break;
+	case smil_transition_type::hexagonWipe		:	_Wostream << L"hexagonWipe"		; break;
+	case smil_transition_type::ellipseWipe		:	_Wostream << L"ellipseWipe"		; break;
+	case smil_transition_type::eyeWipe			:	_Wostream << L"eyeWipe"			; break;
+	case smil_transition_type::roundRectWipe	:	_Wostream << L"roundRectWipe"	; break;
+	case smil_transition_type::starWipe			:	_Wostream << L"starWipe"		; break;
+	case smil_transition_type::miscShapeWipe	:	_Wostream << L"miscShapeWipe"	; break;
+	case smil_transition_type::clockWipe		:	_Wostream << L"clockWipe"		; break;
+	case smil_transition_type::pinWheelWipe		:	_Wostream << L"pinWheelWipe"	; break;
+	case smil_transition_type::singleSweepWipe	:	_Wostream << L"singleSweepWipe"	; break;
+	case smil_transition_type::fanWipe			:	_Wostream << L"fanWipe"			; break;
+	case smil_transition_type::doubleFanWipe	:	_Wostream << L"doubleFanWipe"	; break;
+	case smil_transition_type::doubleSweepWipe	:	_Wostream << L"doubleSweepWipe"	; break;
+	case smil_transition_type::saloonDoorWipe	:	_Wostream << L"saloonDoorWipe"	; break;
+	case smil_transition_type::windshieldWipe	:	_Wostream << L"windshieldWipe"	; break;
+	case smil_transition_type::snakeWipe		:	_Wostream << L"snakeWipe"		; break;
+	case smil_transition_type::spiralWipe		:	_Wostream << L"spiralWipe"		; break;
+	case smil_transition_type::parallelSnakesWipe:	_Wostream << L"parallelSnakesWipe"; break;
+	case smil_transition_type::boxSnakesWipe	:	_Wostream << L"boxSnakesWipe"	; break;
+	case smil_transition_type::waterfallWipe	:	_Wostream << L"waterfallWipe"	; break;
+	case smil_transition_type::pushWipe			:	_Wostream << L"pushWipe"		; break;
+	case smil_transition_type::slideWipe		:	_Wostream << L"slideWipe"		; break;
 	case smil_transition_type::fade				:	_Wostream << L"fade"			; break;
-	case smil_transition_type::checkerBoardWipe	:	_Wostream << L"checkerboardwipe"; break;
-	case smil_transition_type::blindsWipe		:	_Wostream << L"blindswipe"		; break;
+	case smil_transition_type::checkerBoardWipe	:	_Wostream << L"checkerboardWipe"; break;
+	case smil_transition_type::blindsWipe		:	_Wostream << L"blindsWipe"		; break;
 	case smil_transition_type::dissolve			:	_Wostream << L"dissolve"		; break;
-	case smil_transition_type::randomBarWipe	:	_Wostream << L"randombarwipe"	; break;
+	case smil_transition_type::randomBarWipe	:	_Wostream << L"randomBarWipe"	; break;
 	}
     return _Wostream;
 }
@@ -91,47 +91,47 @@ smil_transition_type smil_transition_type::parse(const std::wstring & Str)
     std::wstring tmp = Str;
     boost::algorithm::to_lower(tmp);
 
-		 if(tmp == L"barwipe")			return smil_transition_type( barWipe );
-	else if(tmp == L"boxwipe")			return smil_transition_type( boxWipe );
-	else if(tmp == L"fourboxwipe")		return smil_transition_type( fourBoxWipe );
-	else if(tmp == L"barndoorwipe")		return smil_transition_type( barnDoorWipe );
-	else if(tmp == L"diagonalwipe")		return smil_transition_type( diagonalWipe );
-	else if(tmp == L"bowtiewipe")		return smil_transition_type( bowTieWipe );
-	else if(tmp == L"miscdiagonalwipe")	return smil_transition_type( miscDiagonalWipe );
-	else if(tmp == L"veewipe")			return smil_transition_type( veeWipe );
-	else if(tmp == L"barnveewipe")		return smil_transition_type( barnVeeWipe );
-	else if(tmp == L"zigzagwipe")		return smil_transition_type( zigZagWipe );
-	else if(tmp == L"barnzigzagwipe")	return smil_transition_type( barnZigZagWipe );
-	else if(tmp == L"iriswipe")			return smil_transition_type( irisWipe);
-	else if(tmp == L"trianglewipe")		return smil_transition_type( triangleWipe);
-	else if(tmp == L"arrowheadwipe")	return smil_transition_type( arrowHeadWipe );
-	else if(tmp == L"pentagonwipe")		return smil_transition_type( pentagonWipe );
-	else if(tmp == L"hexagonwipe")		return smil_transition_type( hexagonWipe );
-	else if(tmp == L"ellipsewipe")		return smil_transition_type( ellipseWipe );
-	else if(tmp == L"eyewipe")			return smil_transition_type( eyeWipe );
-	else if(tmp == L"roundrectwipe")	return smil_transition_type( roundRectWipe );
-	else if(tmp == L"starwipe")			return smil_transition_type( starWipe );
-	else if(tmp == L"miscshapewipe")	return smil_transition_type( miscShapeWipe );
-	else if(tmp == L"clockwipe")		return smil_transition_type( clockWipe );
-	else if(tmp == L"pinwheelwipe")		return smil_transition_type( pinWheelWipe );
-	else if(tmp == L"singlesweepwipe")	return smil_transition_type( singleSweepWipe);
-	else if(tmp == L"fanwipe")			return smil_transition_type( fanWipe );
-	else if(tmp == L"doublefanwipe")	return smil_transition_type( doubleFanWipe );
-	else if(tmp == L"doublesweepwipe")	return smil_transition_type( doubleSweepWipe );
-	else if(tmp == L"saloondoorwipe")	return smil_transition_type( saloonDoorWipe );
-	else if(tmp == L"windshieldwipe")	return smil_transition_type( windshieldWipe );
-	else if(tmp == L"snakewipe")		return smil_transition_type( snakeWipe );
-	else if(tmp == L"spiralwipe")		return smil_transition_type( spiralWipe );
-	else if(tmp == L"parallelsnakeswipe")return smil_transition_type( parallelSnakesWipe );
-	else if(tmp == L"boxsnakeswipe")	return smil_transition_type( boxSnakesWipe );
-	else if(tmp == L"waterfallwipe")	return smil_transition_type( waterfallWipe );
-	else if(tmp == L"pushwipe")			return smil_transition_type( pushWipe );
-	else if(tmp == L"slidewipe")		return smil_transition_type( slideWipe );
+		 if(tmp == L"barWipe")			return smil_transition_type( barWipe );
+	else if(tmp == L"boxWipe")			return smil_transition_type( boxWipe );
+	else if(tmp == L"fourboxWipe")		return smil_transition_type( fourBoxWipe );
+	else if(tmp == L"barndoorWipe")		return smil_transition_type( barnDoorWipe );
+	else if(tmp == L"diagonalWipe")		return smil_transition_type( diagonalWipe );
+	else if(tmp == L"bowtieWipe")		return smil_transition_type( bowTieWipe );
+	else if(tmp == L"miscdiagonalWipe")	return smil_transition_type( miscDiagonalWipe );
+	else if(tmp == L"veeWipe")			return smil_transition_type( veeWipe );
+	else if(tmp == L"barnveeWipe")		return smil_transition_type( barnVeeWipe );
+	else if(tmp == L"zigzagWipe")		return smil_transition_type( zigZagWipe );
+	else if(tmp == L"barnzigzagWipe")	return smil_transition_type( barnZigZagWipe );
+	else if(tmp == L"irisWipe")			return smil_transition_type( irisWipe);
+	else if(tmp == L"triangleWipe")		return smil_transition_type( triangleWipe);
+	else if(tmp == L"arrowheadWipe")	return smil_transition_type( arrowHeadWipe );
+	else if(tmp == L"pentagonWipe")		return smil_transition_type( pentagonWipe );
+	else if(tmp == L"hexagonWipe")		return smil_transition_type( hexagonWipe );
+	else if(tmp == L"ellipseWipe")		return smil_transition_type( ellipseWipe );
+	else if(tmp == L"eyeWipe")			return smil_transition_type( eyeWipe );
+	else if(tmp == L"roundrectWipe")	return smil_transition_type( roundRectWipe );
+	else if(tmp == L"starWipe")			return smil_transition_type( starWipe );
+	else if(tmp == L"miscshapeWipe")	return smil_transition_type( miscShapeWipe );
+	else if(tmp == L"clockWipe")		return smil_transition_type( clockWipe );
+	else if(tmp == L"pinwheelWipe")		return smil_transition_type( pinWheelWipe );
+	else if(tmp == L"singlesweepWipe")	return smil_transition_type( singleSweepWipe);
+	else if(tmp == L"fanWipe")			return smil_transition_type( fanWipe );
+	else if(tmp == L"doublefanWipe")	return smil_transition_type( doubleFanWipe );
+	else if(tmp == L"doublesweepWipe")	return smil_transition_type( doubleSweepWipe );
+	else if(tmp == L"saloondoorWipe")	return smil_transition_type( saloonDoorWipe );
+	else if(tmp == L"windshieldWipe")	return smil_transition_type( windshieldWipe );
+	else if(tmp == L"snakeWipe")		return smil_transition_type( snakeWipe );
+	else if(tmp == L"spiralWipe")		return smil_transition_type( spiralWipe );
+	else if(tmp == L"parallelsnakesWipe")return smil_transition_type( parallelSnakesWipe );
+	else if(tmp == L"boxsnakesWipe")	return smil_transition_type( boxSnakesWipe );
+	else if(tmp == L"waterfallWipe")	return smil_transition_type( waterfallWipe );
+	else if(tmp == L"pushWipe")			return smil_transition_type( pushWipe );
+	else if(tmp == L"slideWipe")		return smil_transition_type( slideWipe );
 	else if(tmp == L"fade")				return smil_transition_type( fade );
-	else if(tmp == L"checkerboardwipe")	return smil_transition_type( checkerBoardWipe);
-	else if(tmp == L"blindswipe")		return smil_transition_type( blindsWipe);
+	else if(tmp == L"checkerboardWipe")	return smil_transition_type( checkerBoardWipe);
+	else if(tmp == L"blindsWipe")		return smil_transition_type( blindsWipe);
 	else if(tmp == L"dissolve")			return smil_transition_type( dissolve);
-	else if(tmp == L"randombarwipe")	return smil_transition_type( randomBarWipe);
+	else if(tmp == L"randombarWipe")	return smil_transition_type( randomBarWipe);
 	else
     {
         return smil_transition_type( barWipe );

ASCOfficeOdfFile/src/odf/draw_page.cpp

@@ -74,6 +74,8 @@ void draw_page::add_child_element( xml::sax * Reader, const std::wstring & Ns, c
 {
 	if	CP_CHECK_NAME(L"anim", L"par") 
 		CP_CREATE_ELEMENT(animation_);
+    else if (L"presentation" == Ns && L"notes" == Name)
+        CP_CREATE_ELEMENT(presentation_notes_); 
 	else
 		CP_CREATE_ELEMENT(content_);
 }
@@ -202,8 +204,15 @@ void draw_page::pptx_convert(oox::pptx_conversion_context & Context)
 		std::wstring name = L"datetime:" + *attlist_.use_date_time_name_;
 		pptx_convert_placeHolder(Context, name, presentation_class::date_time);
 	}
+	
+	Context.end_page();
 
-    Context.end_page();
+ 	if (presentation_notes_)
+	{
+		Context.start_page_notes();
+		presentation_notes_->pptx_convert(Context);
+		Context.end_page_notes();
+	}  
 }
 //////////////////////////////////////////////////////////////////////////////////////////////////
 const wchar_t * presentation_footer_decl::ns = L"presentation";
@@ -253,60 +262,57 @@ void presentation_notes::add_attributes( const xml::attributes_wc_ptr & Attribut
     attlist_.add_attributes(Attributes);
 }
 
-//void presentation_notes::pptx_convert_placeHolder(oox::pptx_conversion_context & Context, std::wstring styleName, presentation_class::type PresentationClass)
-//{
-//	office_element_ptr elm = Context.root()->odf_context().drawStyles().find_by_style_name(styleName);
-//	//todooo если это элемент datatime -нужно вытащить формат поля
-//
-//	if (!elm)return;
-//
-//	int index=-1;
-//
-//    const std::wstring masterName = attlist_.master_page_name_.get_value_or(L"");
-//	style_master_page * master = Context.root()->odf_context().pageLayoutContainer().master_page_by_name(masterName);
-//
-//	//if (master)
-//	//	index = master->find_placeHolderIndex(PresentationClass, Context.last_idx_placeHolder);
-//
-//
-//	Context.get_slide_context().start_shape(1);
-//	Context.get_slide_context().set_placeHolder_type(presentation_class(PresentationClass).get_type_ms());
-//	Context.get_slide_context().set_placeHolder_idx(index);
-//	
-//	Context.get_text_context().start_object();
-//	
-//	if (PresentationClass == presentation_class::date_time)
-//	{
-//		Context.get_text_context().start_field(oox::datetime, L"");
-//	}
-//	
-//	elm->pptx_convert(Context);
-//	
-//	std::wstring text_content_ = Context.get_text_context().end_object();
-//
-//	if (text_content_.length()>0)
-//	{
-//		Context.get_slide_context().set_property(_property(L"text-content",text_content_));
-//	}
-//	Context.get_slide_context().set_property(_property(L"no_rect",true));
-//	Context.get_slide_context().end_shape();
-//
-//}
-//
+void presentation_notes::pptx_convert_placeHolder(oox::pptx_conversion_context & Context, std::wstring styleName, presentation_class::type PresentationClass)
+{
+	office_element_ptr elm = Context.root()->odf_context().drawStyles().find_by_style_name(styleName);
+	//todooo если это элемент datatime -нужно вытащить формат поля
+
+	if (!elm)return;
+
+	int index=-1;
+
+    const std::wstring masterName = attlist_.master_page_name_.get_value_or(L"");
+	style_master_page * master = Context.root()->odf_context().pageLayoutContainer().master_page_by_name(masterName);
+
+	//if (master)
+	//	index = master->find_placeHolderIndex(PresentationClass, Context.last_idx_placeHolder);
+
+
+	Context.get_slide_context().start_shape(1);
+	Context.get_slide_context().set_placeHolder_type(presentation_class(PresentationClass).get_type_ms());
+	Context.get_slide_context().set_placeHolder_idx(index);
+	
+	Context.get_text_context().start_object();
+	
+	if (PresentationClass == presentation_class::date_time)
+	{
+		Context.get_text_context().start_field(oox::datetime, L"");
+	}
+	
+	elm->pptx_convert(Context);
+	
+	std::wstring text_content_ = Context.get_text_context().end_object();
+
+	if (text_content_.length()>0)
+	{
+		Context.get_slide_context().set_property(_property(L"text-content",text_content_));
+	}
+	Context.get_slide_context().set_property(_property(L"no_rect",true));
+	Context.get_slide_context().end_shape();
+
+}
+
 void presentation_notes::pptx_convert(oox::pptx_conversion_context & Context)
 {
 	const std::wstring pageStyleName	= attlist_.draw_style_name_.get_value_or(L"");
-    const std::wstring pageName			= attlist_.draw_name_.get_value_or(L"");
     const std::wstring layoutName		= attlist_.page_layout_name_.get_value_or(L"");
     const std::wstring masterName		= attlist_.master_page_name_.get_value_or(L"");
 
     _CP_LOG << L"[info][pptx] process note slide" << std::endl;
 
-    Context.start_note(pageName, pageStyleName, layoutName, masterName);
-
 	if (attlist_.draw_style_name_)
 	{
-		style_instance * style_inst = Context.root()->odf_context().styleContainer().style_by_name(pageStyleName,style_family::DrawingPage, false);
+		style_instance * style_inst = Context.root()->odf_context().styleContainer().style_by_name(pageStyleName, style_family::DrawingPage, Context.process_masters_);
 
 		if ((style_inst) && (style_inst->content()))
 		{
@@ -341,18 +347,17 @@ void presentation_notes::pptx_convert(oox::pptx_conversion_context & Context)
 		content_[i]->pptx_convert(Context);
 	}
 
-	//if (attlist_.use_footer_name_)//from master_page
-	//{
-	//	std::wstring name = L"footer:" + *attlist_.use_footer_name_;
-	//	pptx_convert_placeHolder(Context, name, presentation_class::footer);
-	//}
-	//if (attlist_.use_date_time_name_)//from master_page
-	//{
-	//	std::wstring name = L"datetime:" + *attlist_.use_date_time_name_;
-	//	pptx_convert_placeHolder(Context, name, presentation_class::date_time);
-	//}
+	if (attlist_.use_footer_name_)//from master_page_notes
+	{
+		std::wstring name = L"footer:" + *attlist_.use_footer_name_;
+		pptx_convert_placeHolder(Context, name, presentation_class::footer);
+	}
+	if (attlist_.use_date_time_name_)//from master_page_notes
+	{
+		std::wstring name = L"datetime:" + *attlist_.use_date_time_name_;
+		pptx_convert_placeHolder(Context, name, presentation_class::date_time);
+	}
 
-    Context.end_note();
 }
 
 }

ASCOfficeOdfFile/src/odf/draw_page.h

@@ -81,6 +81,7 @@ private:
 
     office_element_ptr_array	content_;
 	office_element_ptr			animation_;
+	office_element_ptr			presentation_notes_;
 
 	draw_page_attr				attlist_;
 };
@@ -149,14 +150,14 @@ public:
     static const ElementType type = typePresentationNotes;
     CPDOCCORE_DEFINE_VISITABLE();
 
-    
 	virtual void pptx_convert(oox::pptx_conversion_context & Context);
 
 private:
-    virtual void add_attributes( const xml::attributes_wc_ptr & Attributes );
+	void pptx_convert_placeHolder(oox::pptx_conversion_context & Context, std::wstring styleName, odf_types::presentation_class::type PresentationClass);
+    
+	virtual void add_attributes( const xml::attributes_wc_ptr & Attributes );
 	virtual void add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name);
 
-
     office_element_ptr_array	content_;
 	draw_page_attr				attlist_;
 };

ASCOfficeOdfFile/src/odf/odfcontext.cpp

@@ -360,11 +360,11 @@ void page_layout_instance::docx_convert_serialize(std::wostream & strm, oox::doc
     if (props)
 		props->docx_convert_serialize(strm, Context);   
 }
-void page_layout_instance::pptx_convert(oox::pptx_conversion_context & Context)
+void page_layout_instance::pptx_serialize(std::wostream & strm, oox::pptx_conversion_context & Context)
 {
 	style_page_layout_properties * props = properties();
     if (props)
-		props->pptx_convert(Context);   
+		props->pptx_serialize(strm, Context);
 }
 
 void page_layout_container::add_page_layout(const style_page_layout * StylePageLayout)

ASCOfficeOdfFile/src/odf/odfcontext.h

@@ -195,7 +195,7 @@ public:
     
 	void docx_convert_serialize	(std::wostream & strm, oox::docx_conversion_context & Context);
  	void xlsx_serialize			(std::wostream & strm, oox::xlsx_conversion_context & Context);
-	void pptx_convert			(oox::pptx_conversion_context & Context);
+	void pptx_serialize			(std::wostream & strm, oox::pptx_conversion_context & Context);
    
     const style_page_layout * style_page_layout_;
 

ASCOfficeOdfFile/src/odf/styles.cpp

@@ -1378,6 +1378,50 @@ void style_page_layout_properties::pptx_convert(oox::pptx_conversion_context & C
     attlist_.pptx_convert(Context);        
 }
 
+void style_page_layout_properties::pptx_serialize(std::wostream & strm, oox::pptx_conversion_context & Context)
+{
+    if (attlist_.fo_page_width_ || attlist_.fo_page_height_ || attlist_.style_print_orientation_)
+    {
+        std::wstring w_w, w_h;
+
+		_INT64 h = 0, w = 0;
+		
+		if (attlist_.fo_page_width_)
+		{
+			w =  attlist_.fo_page_width_->get_value_unit(length::emu);
+			if (w < 914400) w = 914400;
+
+			w_w = boost::lexical_cast<std::wstring>(w);
+		}
+        if (attlist_.fo_page_height_)
+		{
+			h = attlist_.fo_page_height_->get_value_unit(length::emu);
+			if (h < 914400) h = 914400;
+
+			w_h = std::to_wstring(h);
+		}
+                
+        std::wstring w_orient = L"custom";
+
+		//if (w && h)
+		//{
+		//	double ratio = (double)w/(double)h;
+		//	if (abs(ratio - 16./9.)<0.01)	w_orient = L"screen16x9";
+		//	if (abs(ratio - 4./3.)<0.01)	w_orient = L"screen4x3";
+		//}
+        
+        strm << L"<p:sldSz ";
+        if (!w_h.empty())
+            strm << L"cy=\"" << w_h << L"\" ";
+
+        if (!w_w.empty())
+            strm << L"cx=\"" << w_w << L"\" ";
+	
+		strm << L"type=\"" << w_orient << L"\" ";
+
+        strm << L"/>";
+    }
+}
 
 // style-page-layout-properties-elements
 //////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1519,10 +1563,11 @@ void style_master_page::pptx_convert(oox::pptx_conversion_context & Context)
 		}
 	}
 	
-	BOOST_FOREACH(office_element_ptr elm, content_)
+	for (size_t i = 0; i < content_.size(); i++)
     {
-		elm->pptx_convert(Context);
+		content_[i]->pptx_convert(Context);
 	}
+
 }
 ////////////////
 
@@ -1698,9 +1743,9 @@ void style_presentation_page_layout::add_child_element( xml::sax * Reader, const
 }
 void style_presentation_page_layout::pptx_convert(oox::pptx_conversion_context & Context)
 {
-    BOOST_FOREACH(office_element_ptr elm, content_)
+	for (size_t i = 0; i < content_.size(); i++)
     {
-		elm->pptx_convert(Context);
+		content_[i]->pptx_convert(Context);
 	}
 }
 

ASCOfficeOdfFile/src/odf/styles.h

@@ -980,6 +980,7 @@ public:
     
 	bool docx_background_serialize(std::wostream & strm, oox::docx_conversion_context & Context, oox::_oox_fill & fill, int id);
 	void xlsx_serialize(std::wostream & strm, oox::xlsx_conversion_context & Context);
+	void pptx_serialize(std::wostream & strm, oox::pptx_conversion_context & Context);
 
     style_page_layout_properties() { }
 

ASCOfficeOdfFileW/linux/OdfFileWriterLib.pro

@@ -99,6 +99,8 @@ SOURCES += \
     ../source/OdfFormat/odf_settings_context.cpp \
     ../source/OdfFormat/office_settings.cpp \
     ../source/OdfFormat/mediaitems_utils.cpp \
+    ../source/OdfFormat/office_scripts.cpp \
+    ../source/OdfFormat/office_event_listeners.cpp \
     ../source/OdfFormat/anim_elements.cpp \
     ../source/OdfFormat/draw_page.cpp \
     ../source/OdfFormat/odp_conversion_context.cpp \
@@ -208,4 +210,6 @@ HEADERS += \
     ../source/OdfFormat/style_presentation.h \
     ../source/Oox2OdfConverter/PptxConverter.h \
     ../source/OdfFormat/anim_elements.h \
+    ../source/OdfFormat/office_event_listeners.h \
+    ../source/OdfFormat/office_scripts.h \
     ../source/OdfFormat/style_presentation.h

ASCOfficeOdfFileW/linux/odffilewriterlib_odf.cpp

@@ -91,3 +91,5 @@
 #include "../source/OdfFormat/odp_slide_context.cpp"
 #include "../source/OdfFormat/office_presentation.cpp"
 #include "../source/OdfFormat/style_presentation.cpp"
+#include "../source/OdfFormat/office_scripts.cpp"
+#include "../source/OdfFormat/office_event_listeners.cpp"

ASCOfficeOdfFileW/source/OdfFormat/anim_elements.cpp

@@ -59,6 +59,8 @@ void anim_par::create_child_element(const std::wstring & Ns, const std::wstring
 }
 void anim_par::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
 	if (type == typeAnimPar)
@@ -74,6 +76,8 @@ void anim_par::serialize(std::wostream & _Wostream)
     {
 		CP_XML_NODE_SIMPLE()
         {   
+			attlist_.serialize(CP_GET_XML_NODE());
+
 			if (anim_par_)
 				anim_par_->serialize(CP_XML_STREAM());
 			
@@ -98,6 +102,8 @@ void anim_seq::serialize(std::wostream & _Wostream)
     {
 		CP_XML_NODE_SIMPLE()
         {   
+			attlist_.serialize(CP_GET_XML_NODE());
+			
 			for (size_t i = 0; i < anim_par_array_.size(); i++)
 			{
 				anim_par_array_[i]->serialize(CP_XML_STREAM());
@@ -118,16 +124,18 @@ void anim_seq::add_child_element( const office_element_ptr & child)
 ////////////////////////////////////////////////////////////////
 void anim_transition_filter_attlist::serialize(CP_ATTR_NODE)
 {
-	CP_XML_ATTR_OPT(L"smil:direction",	smil_direction_);
     CP_XML_ATTR_OPT(L"smil:subtype",	smil_subtype_);
     CP_XML_ATTR_OPT(L"smil:type",		smil_type_);
 	CP_XML_ATTR_OPT(L"smil:fadeColor",	smil_fadeColor_);
 	CP_XML_ATTR_OPT(L"smil:mode",		smil_mode_);
-	CP_XML_ATTR_OPT(L"smil:dur",		smil_dur_);
 
 }
-
-const wchar_t * anim_transitionFilter::ns = L"anim";
+void anim_audio_attlist::serialize(CP_ATTR_NODE)
+{
+	CP_XML_ATTR_OPT(L"xlink:href",		xlink_href_);
+	CP_XML_ATTR_OPT(L"anim:audio-level",anim_audio_level_);
+}
+const wchar_t * anim_transitionFilter::ns	= L"anim";
 const wchar_t * anim_transitionFilter::name = L"transitionFilter";
 
 void anim_transitionFilter::serialize(std::wostream & _Wostream)
@@ -136,12 +144,26 @@ void anim_transitionFilter::serialize(std::wostream & _Wostream)
     {
 		CP_XML_NODE_SIMPLE()
         {   
-			common_anim_smil_attlist_.serialize(CP_GET_XML_NODE());
-			anim_transition_filter_attlist_.serialize(CP_GET_XML_NODE());
+			common_attlist_.serialize(CP_GET_XML_NODE());
+			filter_attlist_.serialize(CP_GET_XML_NODE());
+		}
+	}
+}
+//------------------------------------------------------------------------------------------------
+const wchar_t * anim_audio::ns = L"anim";
+const wchar_t * anim_audio::name = L"audio";
+
+void anim_audio::serialize(std::wostream & _Wostream)
+{
+	CP_XML_WRITER(_Wostream)
+    {
+		CP_XML_NODE_SIMPLE()
+        {   
+			common_attlist_.serialize(CP_GET_XML_NODE());
+			audio_attlist_.serialize(CP_GET_XML_NODE());
 		}
 	}
 }
 
-////////////////////////////////////////////////////////////////
 }
 }

ASCOfficeOdfFileW/source/OdfFormat/anim_elements.h

@@ -53,9 +53,10 @@ public:
     static const ElementType type = typeAnimPar;
     CPDOCCORE_DEFINE_VISITABLE();
 
-  	office_element_ptr		 anim_par_;
-	office_element_ptr_array anim_seq_array_;
-	office_element_ptr_array content_;
+	odf_types::common_anim_smil_attlist		attlist_;
+  	office_element_ptr						anim_par_;
+	office_element_ptr_array				anim_seq_array_;
+	office_element_ptr_array				content_;
 
 	virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
 	virtual void add_child_element( const office_element_ptr & child);
@@ -73,7 +74,8 @@ public:
     static const ElementType type = typeAnimSeq;
     CPDOCCORE_DEFINE_VISITABLE();
 
-	office_element_ptr_array anim_par_array_;
+	odf_types::common_anim_smil_attlist		attlist_;
+	office_element_ptr_array				anim_par_array_;
    
 	virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
 	virtual void add_child_element( const office_element_ptr & child);
@@ -81,25 +83,27 @@ public:
 	virtual void serialize(std::wostream & strm);
 };
 CP_REGISTER_OFFICE_ELEMENT2(anim_seq);
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//anim:iterate 
-//class anim_iterate : public office_element_impl<anim_iterate>//Итеративные анимации
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//----------------------------------------------------------------------------------------------------------------/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//anim:iterate 
+class anim_audio_attlist
+{
+public:
+	void serialize(CP_ATTR_NODE);
+	
+	_CP_OPT(std::wstring)			xlink_href_;
+	_CP_OPT(std::wstring)			anim_audio_level_; 
+};
 
 class anim_transition_filter_attlist
 {
 public:
 	void serialize(CP_ATTR_NODE);
 
-	_CP_OPT(std::wstring)						smil_direction_;
 	_CP_OPT(std::wstring)						smil_subtype_; 
 	_CP_OPT(odf_types::smil_transition_type)	smil_type_;
 	_CP_OPT(std::wstring)						smil_mode_;
 	_CP_OPT(odf_types::color)					smil_fadeColor_;
-	_CP_OPT(odf_types::clockvalue)				smil_dur_;
 };
 
 
@@ -117,12 +121,29 @@ public:
 
 	virtual void serialize(std::wostream & strm);
 ///////////////////////////////////////////////////////////	
-	odf_types::common_anim_smil_attlist		common_anim_smil_attlist_;
-	anim_transition_filter_attlist			anim_transition_filter_attlist_;
+	odf_types::common_anim_smil_attlist		common_attlist_;
+	anim_transition_filter_attlist			filter_attlist_;
 };
 CP_REGISTER_OFFICE_ELEMENT2(anim_transitionFilter);
 
-//anim:audio
+class anim_audio : public office_element_impl<anim_audio>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeAnimAudio;
+    CPDOCCORE_DEFINE_VISITABLE();
+
+	virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
+	virtual void add_child_element( const office_element_ptr & child){}
+
+	virtual void serialize(std::wostream & strm);
+///////////////////////////////////////////////////////////	
+	odf_types::common_anim_smil_attlist		common_attlist_;
+	anim_audio_attlist						audio_attlist_;
+};
+CP_REGISTER_OFFICE_ELEMENT2(anim_audio);
 //anim:command
 
 }

ASCOfficeOdfFileW/source/OdfFormat/draw_frame.cpp

@@ -73,10 +73,9 @@ void draw_chart_attlist::serialize(CP_ATTR_NODE)
     //CP_XML_ATTR_OPT(L"draw:filter-name", draw_filter_name_);
 }
 
-// draw:image
-//////////////////////////////////////////////////////////////////////////////////////////////////
-const wchar_t * draw_image::ns = L"draw";
-const wchar_t * draw_image::name = L"image";
+//-----------------------------------------------------------------------
+const wchar_t * draw_image::ns		= L"draw";
+const wchar_t * draw_image::name	= L"image";
 
 void draw_image::serialize(std::wostream & _Wostream)
 {
@@ -111,6 +110,8 @@ void draw_image::create_child_element(const std::wstring & Ns, const std::wstrin
 }
 void draw_image::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeOfficeBinaryData)
@@ -154,8 +155,7 @@ void draw_chart::add_child_element( const office_element_ptr & child_element)
 	content_.push_back(child_element);
 }
 
-// draw:g
-//////////////////////////////////////////////////////////////////////////////////////////////////
+///-----------------------------------------------------------------------
 const wchar_t * draw_g::ns = L"draw";
 const wchar_t * draw_g::name = L"g";
 
@@ -207,12 +207,12 @@ void draw_frame::serialize(std::wostream & _Wostream)
 void draw_frame::create_child_element(  const std::wstring & Ns, const std::wstring & Name)
 {
     if (CP_CHECK_NAME(L"draw", L"text-box") ||
-        CP_CHECK_NAME(L"draw", L"image") ||//копия чарта в виде картинки ну.. или просто картинка
-        CP_CHECK_NAME(L"draw", L"object") ||//месторасположение чарта
+        CP_CHECK_NAME(L"draw", L"image")	||//копия чарта в виде картинки ну.. или просто картинка
+        CP_CHECK_NAME(L"draw", L"object")	||//месторасположение чарта
         CP_CHECK_NAME(L"draw", L"object-ole") ||
-        CP_CHECK_NAME(L"draw", L"applet") ||
+        CP_CHECK_NAME(L"draw", L"applet")	||
         CP_CHECK_NAME(L"draw", L"floating-frame") ||
-        CP_CHECK_NAME(L"draw", L"plugin") ||
+        CP_CHECK_NAME(L"draw", L"plugin")	||
         CP_CHECK_NAME(L"table", L"table") 
         )
     {
@@ -242,9 +242,16 @@ void draw_frame::create_child_element(  const std::wstring & Ns, const std::wstr
 }
 void draw_frame::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
-    if (type == typeDrawImage || type == typeDrawTextBox || type == typeDrawObject || type == typeDrawObjectOle || type == typeTableTable)
+    if (type == typeDrawImage		|| 
+		type == typeDrawTextBox		|| 
+		type == typeDrawObject		|| 
+		type == typeDrawObjectOle	|| 
+		type == typeDrawPlugin	|| 
+		type == typeTableTable)
     {
 		draw_base::add_child_element(child_element);
     } 
@@ -259,8 +266,6 @@ void draw_frame::add_child_element( const office_element_ptr & child_element)
 
 }
 
-///////////////////////
-
 void draw_text_box_attlist::serialize(CP_ATTR_NODE)
 {
     CP_XML_ATTR_OPT(L"draw:chain-next-name", draw_chain_next_name_);
@@ -271,9 +276,8 @@ void draw_text_box_attlist::serialize(CP_ATTR_NODE)
     CP_XML_ATTR_OPT(L"fo:max-height", fo_max_height_);
 }
 
-// draw:text-box
-//////////////////////////////////////////////////////////////////////////////////////////////////
-const wchar_t * draw_text_box::ns = L"draw";
+//-----------------------------------------------------------------------
+const wchar_t * draw_text_box::ns	= L"draw";
 const wchar_t * draw_text_box::name = L"text-box";
 
 
@@ -285,9 +289,9 @@ void draw_text_box::serialize(std::wostream & _Wostream)
         {
 			draw_text_box_attlist_.serialize(CP_GET_XML_NODE());
 
-			BOOST_FOREACH(const office_element_ptr & elm, content_)
+			for (size_t i = 0; i < content_.size(); i++)
 			{
-				elm->serialize(CP_XML_STREAM());
+				content_[i]->serialize(CP_XML_STREAM());
 			}
 		}
 	}
@@ -302,8 +306,7 @@ void draw_text_box::add_child_element( const office_element_ptr & child_element)
    content_.push_back(child_element);
 }
 
-// draw:object
-//////////////////////////////////////////////////////////////////////////////////////////////////
+//-----------------------------------------------------------------------
 const wchar_t * draw_object::ns = L"draw";
 const wchar_t * draw_object::name = L"object";
 
@@ -326,10 +329,9 @@ void draw_object::add_child_element( const office_element_ptr & child_element)
 {
 	//CP_NOT_APPLICABLE_ELM();
 }
-// draw:object
-//////////////////////////////////////////////////////////////////////////////////////////////////
-const wchar_t * draw_object_ole::ns = L"draw";
-const wchar_t * draw_object_ole::name = L"object-ole";
+//-----------------------------------------------------------------------
+const wchar_t * draw_object_ole::ns		= L"draw";
+const wchar_t * draw_object_ole::name	= L"object-ole";
 
 void draw_object_ole::serialize(std::wostream & _Wostream)
 {
@@ -351,5 +353,37 @@ void draw_object_ole::add_child_element( const office_element_ptr & child_elemen
 {
 	//CP_NOT_APPLICABLE_ELM();
 }
+//-----------------------------------------------------------------------
+const wchar_t * draw_plugin::ns		= L"draw";
+const wchar_t * draw_plugin::name	= L"plugin";
+
+void draw_plugin::serialize(std::wostream & _Wostream)
+{
+	CP_XML_WRITER(_Wostream)
+    {
+		CP_XML_NODE_SIMPLE()
+        {
+			common_xlink_attlist_.serialize(CP_GET_XML_NODE());
+			CP_XML_ATTR_OPT(L"draw:mime-type", draw_mime_type_);
+			
+			for (size_t i = 0; i < content_.size(); i++)
+			{
+				content_[i]->serialize(CP_XML_STREAM());
+			}
+		}
+	}
+}
+
+void draw_plugin::create_child_element( const std::wstring & Ns, const std::wstring & Name)
+{
+	if CP_CHECK_NAME(L"draw", L"param")
+    {
+        CP_CREATE_ELEMENT(content_);
+    }
+}
+void draw_plugin::add_child_element( const office_element_ptr & child_element)
+{
+	content_.push_back(child_element);
+}
 }
 }

ASCOfficeOdfFileW/source/OdfFormat/draw_frame.h

@@ -235,10 +235,33 @@ public:
     virtual void serialize(std::wostream & _Wostream);
 
 	odf_types::common_xlink_attlist	common_xlink_attlist_;
-	_CP_OPT(std::wstring)	draw_class_id_;
+	_CP_OPT(std::wstring)			draw_class_id_;
 };
 
 CP_REGISTER_OFFICE_ELEMENT2(draw_object_ole)
 
+// draw:plugin
+class draw_plugin : public office_element_impl<draw_plugin>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeDrawPlugin;
+    CPDOCCORE_DEFINE_VISITABLE()
+
+	virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
+    virtual void add_child_element( const office_element_ptr & child_element);
+
+    virtual void serialize(std::wostream & _Wostream);
+
+	odf_types::common_xlink_attlist	common_xlink_attlist_;
+	_CP_OPT(std::wstring)			draw_mime_type_;
+
+    office_element_ptr_array		content_;
+};
+
+CP_REGISTER_OFFICE_ELEMENT2(draw_plugin)
+
 }
 }

ASCOfficeOdfFileW/source/OdfFormat/draw_page.cpp

@@ -46,17 +46,17 @@ namespace odf_writer {
 
 void draw_page_attr::serialize(CP_ATTR_NODE)
 {
-    CP_XML_ATTR_OPT(L"draw:id",			draw_id_);
+    CP_XML_ATTR_OPT(L"draw:id",					draw_id_);
 
-    CP_XML_ATTR_OPT(L"draw:name",		draw_name_);
-    CP_XML_ATTR_OPT(L"draw:style-name",	draw_style_name_);
+    CP_XML_ATTR_OPT(L"draw:name",				draw_name_);
+    CP_XML_ATTR_OPT(L"draw:style-name",			draw_style_name_);
+	CP_XML_ATTR_OPT(L"draw:master-page-name",	draw_master_page_name_);
     
-	CP_XML_ATTR_OPT(L"presentation:presentation-page-layout-name",	page_layout_name_);
-    CP_XML_ATTR_OPT(L"draw:master-page-name",						master_page_name_);
-    
-	CP_XML_ATTR_OPT(L"presentation:use-date-time-name",	use_date_time_name_);
-    CP_XML_ATTR_OPT(L"presentation:use-footer-name",	use_footer_name_);
-
+ 	CP_XML_ATTR_OPT(L"style:page-layout-name",	style_page_layout_name_); 
+	
+	CP_XML_ATTR_OPT(L"presentation:presentation-page-layout-name",	presentation_page_layout_name_);    
+	CP_XML_ATTR_OPT(L"presentation:use-date-time-name",				presentation_use_date_time_name_);
+    CP_XML_ATTR_OPT(L"presentation:use-footer-name",				presentation_use_footer_name_);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
@@ -72,6 +72,8 @@ void draw_page::create_child_element( const std::wstring & Ns, const std::wstrin
 }
 void draw_page::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 	if(type == typeAnimPar)
 		animation_ = child_element;

ASCOfficeOdfFileW/source/OdfFormat/draw_page.h

@@ -54,12 +54,13 @@ public:
 	_CP_OPT(std::wstring)		draw_name_;
 	_CP_OPT(std::wstring)		draw_id_;
 	_CP_OPT(std::wstring)		draw_style_name_;
+	_CP_OPT(std::wstring)		draw_master_page_name_;
 
-	_CP_OPT(std::wstring)		page_layout_name_;
-	_CP_OPT(std::wstring)		master_page_name_;
+	_CP_OPT(std::wstring)		style_page_layout_name_;
 
-	_CP_OPT(std::wstring)		use_footer_name_;
-	_CP_OPT(std::wstring)		use_date_time_name_;
+	_CP_OPT(std::wstring)		presentation_use_footer_name_;
+	_CP_OPT(std::wstring)		presentation_use_date_time_name_;
+	_CP_OPT(std::wstring)		presentation_page_layout_name_;
 };
 
 class draw_page : public office_element_impl<draw_page>

ASCOfficeOdfFileW/source/OdfFormat/draw_shapes.cpp

@@ -464,7 +464,9 @@ void draw_enhanced_geometry::create_child_element( const std::wstring & Ns, cons
 }
 void draw_enhanced_geometry::add_child_element( const office_element_ptr & child_element)
 {
- 	ElementType type = child_element->get_type();
+ 	if (!child_element) return;
+
+	ElementType type = child_element->get_type();
 
     if (type == typeDrawHandle)
 	{

ASCOfficeOdfFileW/source/OdfFormat/list.cpp

@@ -102,6 +102,8 @@ void text_list_item::create_child_element(const std::wstring & Ns, const std::ws
 }
 void text_list_item::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTextNumber)
@@ -148,6 +150,8 @@ void text_list_header::create_child_element(const std::wstring & Ns, const std::
 }
 void text_list_header::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTextNumber)

ASCOfficeOdfFileW/source/OdfFormat/mediaitems.h

@@ -42,7 +42,7 @@ class rels;
 class _mediaitems
 {
 public:
-    enum Type { typeUnknown = 0, typeImage, typeAudio, typeVideo};
+    enum Type { typeUnknown = 0, typeImage, typeMedia};
 	//oleObject ???
 
     _mediaitems()

ASCOfficeOdfFileW/source/OdfFormat/number_style.cpp

@@ -123,6 +123,8 @@ void number_style_base::create_child_element( const std::wstring & Ns, const std
 }
 void number_style_base::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeStyleTextProperties)

ASCOfficeOdfFileW/source/OdfFormat/object_package.cpp

@@ -185,12 +185,12 @@ namespace odf_writer
 		{
 			if (mediaitems_.count_media < 1)return;
 
-			std::wstring path = RootPath + FILE_SEPARATOR_STR + L"media";
+			std::wstring path = RootPath + FILE_SEPARATOR_STR + L"Media";
             NSDirectory::CreateDirectory(path);
 
 			BOOST_FOREACH( _mediaitems::item & item, mediaitems_.items() )
 			{
-				if (item.type == _mediaitems::typeAudio || item.type == _mediaitems::typeVideo)
+				if (item.type == _mediaitems::typeMedia)
 				{
 					std::wstring file_name_out = RootPath + FILE_SEPARATOR_STR + item.odf_ref;
 
@@ -342,14 +342,17 @@ namespace odf_writer
 					CP_XML_ATTR(L"xmlns:tableooo",		L"http://openoffice.org/2009/table" );
 					CP_XML_ATTR(L"xmlns:drawooo",		L"http://openoffice.org/2010/draw" );
 					CP_XML_ATTR(L"xmlns:chartooo",		L"http://openoffice.org/2010/chart" );
+					CP_XML_ATTR(L"xmlns:smil",			L"urn:oasis:names:tc:opendocument:xmlns:smil-compatible:1.0");
+					CP_XML_ATTR(L"xmlns:anim",			L"urn:oasis:names:tc:opendocument:xmlns:animation:1.0" );
 					CP_XML_ATTR(L"xmlns:calcext",		L"urn:org:documentfoundation:names:experimental:calc:xmlns:calcext:1.0" );
 					CP_XML_ATTR(L"xmlns:field",			L"urn:openoffice:names:experimental:ooo-ms-interop:xmlns:field:1.0" );
-					CP_XML_ATTR(L"xmlns:formx",			L"urn:openoffice:names:experimental:ooxml-odf_writer-interop:xmlns:form:1.0" );
+					CP_XML_ATTR(L"xmlns:formx",			L"urn:openoffice:names:experimental:ooxml-odf-interop:xmlns:form:1.0" );
 					CP_XML_ATTR(L"xmlns:loext",			L"urn:org:documentfoundation:names:experimental:office:xmlns:loext:1.0" ); 
 					CP_XML_ATTR(L"xmlns:css3t",			L"http://www.w3.org/TR/css3-text/" );
+					
 					CP_XML_ATTR(L"office:version",		L"1.2");				
 	
-					//CP_XML_NODE(L"office:scripts");
+					CP_XML_NODE(L"office:font-face-decls");
 					if (content_)
 					{
 						CP_XML_STREAM() << content_->styles_str();
@@ -402,6 +405,8 @@ namespace odf_writer
 					CP_XML_ATTR(L"xmlns:of",			L"urn:oasis:names:tc:opendocument:xmlns:of:1.2" );
 					CP_XML_ATTR(L"xmlns:xhtml",			L"http://www.w3.org/1999/xhtml" );
 					CP_XML_ATTR(L"xmlns:grddl",			L"http://www.w3.org/2003/g/data-view#" );
+					CP_XML_ATTR(L"xmlns:smil",			L"urn:oasis:names:tc:opendocument:xmlns:smil-compatible:1.0");
+					CP_XML_ATTR(L"xmlns:anim",			L"urn:oasis:names:tc:opendocument:xmlns:animation:1.0" );
 					CP_XML_ATTR(L"xmlns:officeooo",		L"http://openoffice.org/2009/office" );
 					CP_XML_ATTR(L"xmlns:textooo",		L"http://openoffice.org/2013/office" ); 
 					CP_XML_ATTR(L"xmlns:tableooo",		L"http://openoffice.org/2009/table" );
@@ -409,7 +414,7 @@ namespace odf_writer
 					CP_XML_ATTR(L"xmlns:chartooo",		L"http://openoffice.org/2010/chart" );
 					CP_XML_ATTR(L"xmlns:calcext",		L"urn:org:documentfoundation:names:experimental:calc:xmlns:calcext:1.0" );
 					CP_XML_ATTR(L"xmlns:field",			L"urn:openoffice:names:experimental:ooo-ms-interop:xmlns:field:1.0" );
-					CP_XML_ATTR(L"xmlns:formx",			L"urn:openoffice:names:experimental:ooxml-odf_writer-interop:xmlns:form:1.0" );
+					CP_XML_ATTR(L"xmlns:formx",			L"urn:openoffice:names:experimental:ooxml-odf-interop:xmlns:form:1.0" );
 					CP_XML_ATTR(L"xmlns:loext",			L"urn:org:documentfoundation:names:experimental:office:xmlns:loext:1.0" ); 
 					CP_XML_ATTR(L"xmlns:css3t",			L"http://www.w3.org/TR/css3-text/" );
 					CP_XML_ATTR(L"office:version",		L"1.2");		

ASCOfficeOdfFileW/source/OdfFormat/odf_conversion_context.cpp

@@ -35,6 +35,7 @@
 #include <boost/lexical_cast.hpp>
  
 #include "office_spreadsheet.h"
+#include "office_scripts.h"
 #include "office_chart.h"
 
 #include "office_elements_create.h"
@@ -128,6 +129,10 @@ void odf_conversion_context::end_document()
 		process_settings(object, isRoot);
 
 		package::content_content_ptr content_root_ = package::content_content::create();		
+
+		if (objects_.back().scripts)
+			objects_.back().scripts->serialize(content_root_->styles());	
+
 		object.content->serialize(content_root_->content());	
 		BOOST_FOREACH(const office_element_ptr & elm, object.content_styles)
 		{
@@ -193,6 +198,8 @@ void odf_conversion_context::start_presentation()
 {
 	create_object();
 	create_element(L"office", L"presentation", objects_.back().content, this, true);
+
+	create_element(L"office", L"scripts", objects_.back().scripts, this);
 }
 void odf_conversion_context::create_object()
 {
@@ -298,6 +305,15 @@ std::wstring odf_conversion_context::add_image(const std::wstring & image_file_n
 
 	return odf_ref_name;
 }
+std::wstring odf_conversion_context::add_media(const std::wstring & file_name)
+{
+	if (file_name.empty()) return L"";
+	
+	std::wstring odf_ref_name ;	
+	mediaitems()->add_or_find(file_name,_mediaitems::typeMedia, odf_ref_name);
+
+	return odf_ref_name;
+}
 void odf_conversion_context::add_tab(_CP_OPT(int) type, _CP_OPT(length) _length, _CP_OPT(int) leader)
 {
 	if (!temporary_.elm) return;

ASCOfficeOdfFileW/source/OdfFormat/odf_conversion_context.h

@@ -65,6 +65,7 @@ class odf_conversion_context : boost::noncopyable
 		std::wstring						name;
 
 		office_element_ptr					content;
+		office_element_ptr					scripts;
 		std::vector<office_element_ptr>		content_styles;
 		std::vector<office_element_ptr>		styles;	
 		office_element_ptr					settings;	
@@ -96,6 +97,7 @@ public:
 	virtual void					end_text_context()		= 0;
 
     std::wstring add_image(const std::wstring & image_file_name);
+    std::wstring add_media(const std::wstring & file_name);
 	
 	virtual odf_style_context		* styles_context();
 	

ASCOfficeOdfFileW/source/OdfFormat/odf_drawing_context.cpp

@@ -42,6 +42,7 @@
 #include "odf_text_context.h"
 #include "odf_style_context.h"
 #include "odf_conversion_context.h"
+#include "office_event_listeners.h"
 
 #include "draw_frame.h"
 #include "draw_shapes.h"
@@ -264,7 +265,7 @@ public:
 	bool			is_footer_;
 	bool			is_header_;
 	bool			is_background_;
-	_CP_OPT(bool)	is_presentation_;
+	_CP_OPT(int)	is_presentation_;
 
 	void				create_draw_base(int type);
 	office_element_ptr	create_draw_element(int type);
@@ -312,12 +313,12 @@ void odf_drawing_context::set_styles_context(odf_style_context*  styles_context)
 	impl_->styles_context_ = styles_context;
 }
 
-void odf_drawing_context::set_presentation (bool bMaster)
+void odf_drawing_context::set_presentation (int type)
 {
-	impl_->is_presentation_ = bMaster;
+	impl_->is_presentation_ = type;
 }
 
-_CP_OPT(bool) odf_drawing_context::get_presentation ()
+_CP_OPT(int) odf_drawing_context::get_presentation ()
 {
 	return impl_->is_presentation_;
 }
@@ -500,8 +501,8 @@ void odf_drawing_context::end_drawing()
 		if (impl_->current_drawing_state_.presentation_class_ || impl_->current_drawing_state_.presentation_placeholder_)
 		{
 			_CP_OPT(std::wstring) draw_layer;
-			if (impl_->is_presentation_.get() == true)
-			{//master				
+			if (impl_->is_presentation_.get() > 0)
+			{//masters				
 				draw_layer = L"backgroundobjects";
 
 				if (!impl_->current_drawing_state_.presentation_class_)	
@@ -1207,7 +1208,15 @@ void odf_drawing_context::set_placeholder_type (int val)
 	
 	switch(val)
 	{
-		case 0:		impl_->current_drawing_state_.presentation_class_ = presentation_class::outline; 	break;
+		case 0:
+		{
+			if (impl_->is_presentation_ == 2) //notes master
+				impl_->current_drawing_state_.presentation_class_ = presentation_class::notes; 
+			else if (impl_->is_presentation_ == 3) //handout master
+				impl_->current_drawing_state_.presentation_class_ = presentation_class::handout; 
+			else
+				impl_->current_drawing_state_.presentation_class_ = presentation_class::outline; 		
+		}break;
 		case 1:		impl_->current_drawing_state_.presentation_class_ = presentation_class::chart; 		break;
 		case 2:		impl_->current_drawing_state_.presentation_class_ = presentation_class::graphic; 	break;
 		case 3:		impl_->current_drawing_state_.presentation_class_ = presentation_class::title;		break;
@@ -1218,7 +1227,7 @@ void odf_drawing_context::set_placeholder_type (int val)
 		case 8:		impl_->current_drawing_state_.presentation_class_ = presentation_class::object;		break;
 		case 9:		impl_->current_drawing_state_.presentation_class_ = presentation_class::object;		break;
 		case 10:	impl_->current_drawing_state_.presentation_class_ = presentation_class::graphic;	break;
-		case 11:	impl_->current_drawing_state_.presentation_class_ = presentation_class::graphic;	break;
+		case 11:	impl_->current_drawing_state_.presentation_class_ = presentation_class::page;		break;
 		case 12:	impl_->current_drawing_state_.presentation_class_ = presentation_class::page_number;break;
 		case 13:	impl_->current_drawing_state_.presentation_class_ = presentation_class::subtitle;	break;
 		case 14:	impl_->current_drawing_state_.presentation_class_ = presentation_class::table;		break;
@@ -2324,14 +2333,37 @@ void odf_drawing_context::start_object(std::wstring name)
 	draw_object* object = dynamic_cast<draw_object*>(object_elm.get());
 	if (object == NULL)return;
 
-    object->common_xlink_attlist_.href_= std::wstring(L"./") + name;
-	object->common_xlink_attlist_.type_= xlink_type::Simple;
-	object->common_xlink_attlist_.show_ = xlink_show::Embed;
-	object->common_xlink_attlist_.actuate_= xlink_actuate::OnLoad;
+    object->common_xlink_attlist_.href_		= std::wstring(L"./") + name;
+	object->common_xlink_attlist_.type_		= xlink_type::Simple;
+	object->common_xlink_attlist_.show_		= xlink_show::Embed;
+	object->common_xlink_attlist_.actuate_	= xlink_actuate::OnLoad;
 
 	start_element(object_elm);
 }
+void odf_drawing_context::start_media(std::wstring name)
+{
+	start_frame();
 
+	office_element_ptr plugin_elm;
+	create_element(L"draw", L"plugin", plugin_elm, impl_->odf_context_);
+
+	draw_plugin* plugin = dynamic_cast<draw_plugin*>(plugin_elm.get());
+	if (plugin == NULL)return;
+
+    plugin->common_xlink_attlist_.href_		= name;
+	plugin->common_xlink_attlist_.type_		= xlink_type::Simple;
+	plugin->common_xlink_attlist_.show_		= xlink_show::Embed;
+	plugin->common_xlink_attlist_.actuate_	= xlink_actuate::OnLoad;
+
+	plugin->draw_mime_type_ = L"application/vnd.sun.star.media";
+	
+	start_element(plugin_elm);
+}
+void odf_drawing_context::end_media()
+{
+	end_element();
+	end_frame();
+}
 void odf_drawing_context::start_text_box()
 {	
 	impl_->current_drawing_state_.oox_shape_preset_ = 2000;
@@ -2361,6 +2393,95 @@ void odf_drawing_context::set_text_box_min_size(bool val)
 	}
 }
 
+void odf_drawing_context::start_action(std::wstring value)
+{
+	office_element_ptr elm_listeners;
+	create_element(L"office", L"event-listeners", elm_listeners, impl_->odf_context_);
+
+	start_element(elm_listeners);
+	
+	office_element_ptr elm;
+	create_element(L"presentation", L"event-listener", elm, impl_->odf_context_);
+
+	start_element(elm);
+	
+	presentation_event_listener * event_ = dynamic_cast<presentation_event_listener*>(impl_->current_level_.back().get());
+
+	if (event_)
+	{
+		event_->attlist_.script_event_name_ = L"dom:click";
+		
+		if (std::wstring::npos != value.find(L"noaction") ||
+			std::wstring::npos != value.find(L"media"))
+		{
+			event_->attlist_.script_event_name_ = boost::none;
+		}
+		else if (std::wstring::npos != value.find(L"program"))
+		{
+			event_->attlist_.presentation_action_ = L"execute";
+		}
+		else if (std::wstring::npos != value.find(L"hlinkshowjump"))
+		{
+			if (std::wstring::npos != value.find(L"previousslide"))
+				event_->attlist_.presentation_action_ = L"previous-page";
+			if (std::wstring::npos != value.find(L"nextslide"))
+				event_->attlist_.presentation_action_ = L"next-page";
+		}
+		else if (std::wstring::npos != value.find(L"hlinksldjump"))
+		{
+			event_->attlist_.presentation_action_ = L"previous-page";
+		}
+		else
+		{//hyperlink
+			event_->attlist_.presentation_action_	= L"show";
+		}
+	}
+}
+
+void odf_drawing_context::add_link(std::wstring href)
+{
+	if (href.empty()) return;
+
+	presentation_event_listener * event_ = dynamic_cast<presentation_event_listener*>(impl_->current_level_.back().get());
+
+	if (event_)
+	{
+		event_->attlist_.common_xlink_attlist_.href_	= href;
+		event_->attlist_.common_xlink_attlist_.type_	= xlink_type::Simple;
+		event_->attlist_.common_xlink_attlist_.show_	= xlink_show::Embed;
+		event_->attlist_.common_xlink_attlist_.actuate_	= xlink_actuate::OnRequest;
+	}
+}
+
+void odf_drawing_context::add_sound(std::wstring href)
+{
+	presentation_event_listener * event_ = dynamic_cast<presentation_event_listener*>(impl_->current_level_.back().get());
+	if (event_)
+	{
+		event_->attlist_.script_event_name_		= L"dom:click";
+		event_->attlist_.presentation_action_	= L"sound";
+	}
+
+	office_element_ptr elm;
+	create_element(L"presentation", L"sound", elm, impl_->odf_context_);
+
+	start_element(elm);
+
+	presentation_sound *sound = dynamic_cast<presentation_sound*>(elm.get());
+	if (sound)
+	{
+		sound->common_xlink_attlist_.href_		= href;
+		sound->common_xlink_attlist_.type_		= xlink_type::Simple;
+		sound->common_xlink_attlist_.show_		= xlink_show::New;
+		sound->common_xlink_attlist_.actuate_	= xlink_actuate::OnRequest;
+	}
+	end_element();
+}
+void odf_drawing_context::end_action()
+{
+	end_element();
+	end_element();
+}
 void odf_drawing_context::set_text_box_min_size(double w_pt, double h_pt)
 {
 	if (impl_->current_drawing_state_.elements_.empty()) return;
@@ -2619,15 +2740,15 @@ void odf_drawing_context::set_gradient_angle(double angle)
 	draw_gradient * gradient = dynamic_cast<draw_gradient *>(impl_->styles_context_->last_state(style_family::Gradient)->get_office_element().get());
 	if (!gradient) return;
 
-	gradient->draw_angle_ = (270-  angle) * 10;//(int)((360 - angle)/180. * 3.14159265358979323846);
+	gradient->draw_angle_ = (270 - angle) * 10;//(int)((360 - angle)/180. * 3.14159265358979323846);
 }
-void odf_drawing_context::set_gradient_rect(double l, double t, double r,double b)
+void odf_drawing_context::set_gradient_rect(double l, double t, double r, double b)
 {
 	draw_gradient * gradient = dynamic_cast<draw_gradient *>(impl_->styles_context_->last_state(style_family::Gradient)->get_office_element().get());
 	if (!gradient) return;
 	
-	gradient->draw_cy_ = percent((b-t)/2. + 50.);
-	gradient->draw_cx_ = percent((r-l)/2. + 50.);
+	gradient->draw_cy_ = percent((b - t)/2. + 50.);
+	gradient->draw_cx_ = percent((r - l)/2. + 50.);
 }
 void odf_drawing_context::set_gradient_center(double cx, double cy)
 {

ASCOfficeOdfFileW/source/OdfFormat/odf_drawing_context.h

@@ -60,8 +60,8 @@ public:
 	odf_drawing_context		(odf_conversion_context *odf_context);
     ~odf_drawing_context	();
 
-	void			set_presentation (bool bMaster);
-	_CP_OPT(bool)	get_presentation ();
+	void			set_presentation (int type);
+	_CP_OPT(int)	get_presentation ();
 
 	void set_drawings_rect	(_CP_OPT(double) x_pt, _CP_OPT(double) y_pt, _CP_OPT(double) width_pt, _CP_OPT(double) height_pt);
 	void clear				();
@@ -144,6 +144,9 @@ public:
 	void start_object(std::wstring name);
 	void end_object();
 
+	void start_media(std::wstring name);
+	void end_media();
+
 	bool isLineShape();
 	void corrected_line_fill();
 
@@ -260,6 +263,11 @@ public:
 	void set_bitmap_tile_translate_y(double y);
 	void set_bitmap_tile_translate_x(double x);
 
+	void start_action(std::wstring value);
+		void add_sound	(std::wstring href);
+		void add_link	(std::wstring href);
+	void end_action();
+
 	std::map<std::wstring, OOX::Vml::CShapeType*>	m_mapVmlShapeTypes;
 
 private:

ASCOfficeOdfFileW/source/OdfFormat/odf_page_layout_context.cpp

@@ -584,7 +584,8 @@ void odf_page_layout_context::set_pages_mirrored(bool val)
 
 style_page_layout_properties * odf_page_layout_context::get_properties()
 {
-	if (layout_state_list_.size() < 1) return NULL;
+	if (layout_state_list_.empty()) return NULL;
+	
 	style_page_layout_properties * props = layout_state_list_.back().get_properties();
 	if (props == NULL)
 	{

ASCOfficeOdfFileW/source/OdfFormat/odp_conversion_context.cpp

@@ -37,6 +37,8 @@
 #include "odp_conversion_context.h"
 #include "office_presentation.h"
 
+#include "draw_page.h"
+
 #include "styles.h"
 #include "style_table_properties.h"
 
@@ -95,7 +97,7 @@ void odp_conversion_context::start_slide()
 	create_element(L"draw", L"page", root_presentation_->pages_, this);		
 	slide_context_.start_page(root_presentation_->pages_.back());	
 	
-	drawing_context()->set_presentation(false);
+	drawing_context()->set_presentation(0);
 }
 void odp_conversion_context::end_slide()
 {
@@ -108,7 +110,7 @@ void odp_conversion_context::start_master_slide(std::wstring name)
 	page_layout_context()->add_master_page(name);	
 	slide_context_.start_page(page_layout_context()->last_master()->get_root());
 	
-	drawing_context()->set_presentation(true);	
+	drawing_context()->set_presentation(1);	
 }
 void odp_conversion_context::end_master_slide()
 {
@@ -122,7 +124,7 @@ void odp_conversion_context::start_layout_slide()
 	
 	slide_context_.start_page(elm);
 	
-	drawing_context()->set_presentation(true);	
+	drawing_context()->set_presentation(1);	
 }
 void odp_conversion_context::end_layout_slide()
 {
@@ -147,7 +149,7 @@ void odp_conversion_context::end_drawings()
 {
 	current_slide().drawing_context()->clear();
 }
-void odp_conversion_context::start_note()
+void odp_conversion_context::start_note(bool bMaster)
 {
 	office_element_ptr note_elm;
 	create_element(L"presentation", L"notes", note_elm, this);
@@ -156,6 +158,18 @@ void odp_conversion_context::start_note()
 	current_slide().drawing_context()->start_element(note_elm);
 	
 	slide_context_.start_page(note_elm);	
+
+	if (bMaster)
+	{
+		page_layout_context()->create_layout_page();
+
+		odf_writer::presentation_notes* notes = dynamic_cast<odf_writer::presentation_notes*>(note_elm.get());
+		notes->attlist_.style_page_layout_name_ = page_layout_context()->last_layout()->get_name();
+	
+		drawing_context()->set_presentation(2);	
+	}
+	else
+		drawing_context()->set_presentation(0);	
 }
 void odp_conversion_context::start_comment(int oox_comm_id)
 {
@@ -201,5 +215,6 @@ void odp_conversion_context::end_note()
 	current_slide().drawing_context()->end_drawing();
 }
 
+
 }
 }

ASCOfficeOdfFileW/source/OdfFormat/odp_conversion_context.h

@@ -77,7 +77,7 @@ public:
 	void start_comment_content	();
 	void end_comment_content	();
 
-	void start_note();
+	void start_note(bool bMaster = false);
 	void end_note();
 
 private:

ASCOfficeOdfFileW/source/OdfFormat/odp_page_state.cpp

@@ -40,6 +40,7 @@
 #include "odp_conversion_context.h"
 
 #include "draw_page.h"
+#include "anim_elements.h"
 #include "office_annotation.h"
 #include "styles.h"
 
@@ -60,15 +61,18 @@ namespace odf_writer {
 odp_page_state::odp_page_state(odf_conversion_context * Context, office_element_ptr & elm) 
 		 : context_(Context), drawing_context_(Context), comment_context_(Context)
 {     
-	page_elm_ = elm; 
-
+	page_elm_			= elm;
+	page_properties_	= NULL;
+}
+void odp_page_state::set_page_id(int id)
+{
+	page_id_ = id;
 }
-
 void odp_page_state::set_page_name(std::wstring name)
 {
 	if (name.empty()) return;
 
-	office_page_name_ = name;
+	page_name_ = name;
 	
 	draw_page* page = dynamic_cast<draw_page*>(page_elm_.get());
 	if (page) 
@@ -88,7 +92,7 @@ void odp_page_state::set_layout_page(std::wstring name)
 	draw_page* page = dynamic_cast<draw_page*>(page_elm_.get());
 	if (page == NULL)return;
 
-	page->attlist_.page_layout_name_ = name;
+	page->attlist_.presentation_page_layout_name_ = name;
 }
 
 void odp_page_state::set_master_page(std::wstring name)
@@ -98,7 +102,7 @@ void odp_page_state::set_master_page(std::wstring name)
 	draw_page* page = dynamic_cast<draw_page*>(page_elm_.get());
 	if (page == NULL)return;
 
-	page->attlist_.master_page_name_ = name;
+	page->attlist_.draw_master_page_name_ = name;
 }
 
 void odp_page_state::set_page_style(office_element_ptr & elm)
@@ -109,6 +113,8 @@ void odp_page_state::set_page_style(office_element_ptr & elm)
 
 	if (!office_page_style_)return;
 
+	page_properties_ = office_page_style_->content_.get_style_drawing_page_properties();
+
 	draw_page* page = dynamic_cast<draw_page*>(page_elm_.get());
 	if (page)
 		page->attlist_.draw_style_name_ = office_page_style_->style_name_;
@@ -129,6 +135,216 @@ void odp_page_state::add_child_element( const office_element_ptr & child_element
 {
 	page_elm_->add_child_element(child_element);
 }
+void odp_page_state::set_anim_id (int val)
+{
+	if (anim_levels.empty())		return;
+	if (!anim_levels.back().attlist)return;
+
+	anim_levels.back().id = val;
+
+	//anim_levels.back().attlist->smil_begin_ = L"id" + std::to_wstring(val) + L".begin";
+}
+void odp_page_state::finalize_page()
+{
+	if (transactions.empty() == false)
+	{
+		start_timing();
+			start_timing_par();
+				set_anim_duration(-1);
+				set_anim_restart(L"never");
+				set_anim_type(L"tmRoot");
+			end_timing_par();
+		end_timing();
+	}
+}
+void odp_page_state::set_anim_type(std::wstring val)
+{
+	if (anim_levels.empty())		return;
+	if (!anim_levels.back().attlist)return;
+	
+	if (val == L"tmRoot")
+	{
+		anim_levels.back().attlist->presentation_node_type_ = L"timing-root";
+		if (transactions.empty() == false)
+		{
+			std::wstring slide_id = L"slide_id" + std::to_wstring(page_id_);
+
+			draw_page* page = dynamic_cast<draw_page*>(page_elm_.get());
+			if (page) 
+			{
+				page->attlist_.draw_id_ = slide_id;
+				
+				start_timing_par();
+					anim_levels.back().attlist->smil_begin_ = slide_id + L".begin";
+					while(!transactions.empty())
+					{
+						anim_levels.back().elm->add_child_element(	transactions[0] );
+						transactions.erase(transactions.begin());
+					}
+				end_timing_par();
+			}
+		}
+	}
+}
+void odp_page_state::set_anim_duration(int val)
+{
+	if (anim_levels.empty())		return;
+	if (!anim_levels.back().attlist)return;
+
+	anim_levels.back().attlist->smil_dur_ = odf_types::clockvalue(val);
 
+}
+void odp_page_state::set_anim_restart(std::wstring val)
+{
+	if (anim_levels.empty())		return;
+	if (!anim_levels.back().attlist)return;
+	
+	anim_levels.back().attlist->smil_restart_ = val;
+}
+void odp_page_state::start_transition()
+{
+	office_element_ptr elm;
+	create_element(L"anim", L"transitionFilter", elm, context_);
+	
+	transactions.push_back(elm);
+}
+void odp_page_state::set_transition_type(int val)
+{
+	if (transactions.empty()) return;
+
+	anim_transitionFilter *trans = dynamic_cast<anim_transitionFilter*>(transactions.back().get());
+	if (trans)
+		trans->filter_attlist_.smil_type_ = odf_types::smil_transition_type((odf_types::smil_transition_type::type)val);
+}
+void odp_page_state::set_transition_subtype(std::wstring val)
+{
+	if (transactions.empty()) return;
+	
+	anim_transitionFilter *trans = dynamic_cast<anim_transitionFilter*>(transactions.back().get());
+	if (trans)
+		trans->filter_attlist_.smil_subtype_ = val;
+}
+void odp_page_state::set_transition_speed(int val)
+{
+	if (transactions.empty()) return;
+
+	anim_transitionFilter *trans = dynamic_cast<anim_transitionFilter*>(transactions.back().get());
+	if (trans)
+	{
+		if (val == 0)
+		{
+			if (page_properties_)
+				page_properties_->content_.presentation_transition_speed_ = L"fast";
+			trans->common_attlist_.smil_dur_ = odf_types::clockvalue(2000);
+		}
+		if (val == 1)
+		{
+			if (page_properties_)
+				page_properties_->content_.presentation_transition_speed_ = L"medium";
+			trans->common_attlist_.smil_dur_ = odf_types::clockvalue(3000);
+		}
+		if (val == 2)
+		{
+			if (page_properties_)
+				page_properties_->content_.presentation_transition_speed_ = L"slow";
+			trans->common_attlist_.smil_dur_ = odf_types::clockvalue(4000);
+		}
+	}
+}
+void odp_page_state::set_transition_duration(int val)
+{
+	if (transactions.empty()) return;
+
+	anim_transitionFilter *trans = dynamic_cast<anim_transitionFilter*>(transactions.back().get());
+	if (trans)
+		trans->common_attlist_.smil_dur_ = odf_types::clockvalue(val);
+}
+
+void odp_page_state::set_transition_sound(std::wstring ref, bool loop)
+{
+	if (transactions.empty())	return;
+	if (ref.empty())			return;
+	
+	office_element_ptr elm;
+	create_element(L"anim", L"audio", elm, context_);
+
+	anim_audio *audio = dynamic_cast<anim_audio*>(elm.get());
+	if (audio) 
+	{
+		audio->audio_attlist_.xlink_href_ = ref;
+	}
+	
+	transactions.push_back(elm);
+
+	if (page_properties_)
+	{
+		create_element(L"presentation", L"sound", page_properties_->content_.presentation_sound_, context_);
+		presentation_sound *sound = dynamic_cast<presentation_sound*>(page_properties_->content_.presentation_sound_.get());
+		if (sound) 
+		{
+			sound->common_xlink_attlist_.href_		= ref;
+			sound->common_xlink_attlist_.type_		= xlink_type::Simple;
+			sound->common_xlink_attlist_.show_		= xlink_show::New;
+			sound->common_xlink_attlist_.actuate_	= xlink_actuate::OnRequest;
+		}
+	}
+}
+
+void odp_page_state::start_timing_seq()
+{
+	if (anim_levels.empty()) return;
+
+	anim_state anim;
+	create_element(L"anim", L"seq", anim.elm, context_);
+	if (!anim.elm) return;
+	
+	anim_seq *seq = dynamic_cast<anim_seq*>(anim.elm.get());
+	if (seq) anim.attlist = &seq->attlist_;
+
+	anim_levels.back().empty = false;
+	anim_levels.back().elm->add_child_element(anim.elm);
+	
+	anim_levels.push_back(anim);
+}
+void odp_page_state::start_timing()
+{
+	if (!anim_levels.empty()) return;
+	
+	anim_state anim;
+	anim.elm = page_elm_;
+	
+	anim_levels.push_back(anim);
+}
+void odp_page_state::end_timing()
+{
+	if (anim_levels.empty()) return;
+	anim_levels.pop_back();	
+}
+void odp_page_state::end_timing_seq()
+{
+	if (anim_levels.empty()) return;
+	anim_levels.pop_back();	
+}
+void odp_page_state::start_timing_par()
+{
+	if (anim_levels.empty()) return;
+
+	anim_state anim;
+	create_element(L"anim", L"par", anim.elm, context_);
+	if (!anim.elm) return;
+
+	anim_par *par = dynamic_cast<anim_par*>(anim.elm.get());
+	if (par) anim.attlist = &par->attlist_;
+
+	anim_levels.back().empty = false;
+	anim_levels.back().elm->add_child_element(anim.elm);
+
+	anim_levels.push_back(anim);
+}
+void odp_page_state::end_timing_par()
+{
+	if (anim_levels.empty())		return;
+	anim_levels.pop_back();	
+}
 }
 }

ASCOfficeOdfFileW/source/OdfFormat/odp_page_state.h

@@ -31,19 +31,13 @@
  */
 #pragma once
 
-#include <string>
 #include <vector>
 
-#include <boost/regex.hpp>
-#include <boost/lexical_cast.hpp>
-
 #include"../../../Common/DocxFormat/Source/XML/Utils.h"
 
 #include "odf_drawing_context.h"
 #include "odf_comment_context.h"
-
-#include "office_elements_create.h"
-
+#include "style_presentation.h"
 
 namespace cpdoccore {
 
@@ -60,13 +54,15 @@ class odf_text_context;
 class style;
 
 
-struct odp_element_state
+struct anim_state
 {
-	office_element_ptr	elm;
+	anim_state() : empty(true),  attlist(NULL), id(-1) {}
 	
-    short				repeated;
-	std::wstring		style_name;
-	office_element_ptr	style_elm;
+	int										id;
+	office_element_ptr						elm;	
+	odf_types::common_anim_smil_attlist*	attlist;
+
+	bool empty;
 };
 
 
@@ -74,27 +70,55 @@ class odp_page_state
 {
 public:
 	odp_page_state(odf_conversion_context * Context, office_element_ptr & elm);
-		void set_page_name(std::wstring name);
-		void set_page_style(office_element_ptr & _style);
+		void set_page_name	(std::wstring name);
+		void set_page_id	(int id);
+		void set_page_style	(office_element_ptr & _style);
 		
 		void set_master_page(std::wstring name);
 		void set_layout_page(std::wstring name);
 	
 	void add_child_element( const office_element_ptr & child_element);
-
+	void finalize_page();
 ///////////////////////////////
 	odf_drawing_context   *	drawing_context(){return  &drawing_context_;}
 	odf_comment_context   *	comment_context(){return  &comment_context_;}
 
-	std::wstring		office_page_name_;
-	office_element_ptr	page_elm_;
-	office_element_ptr	page_style_elm_;
+	std::wstring			page_name_;
+	int						page_id_;
+	office_element_ptr		page_elm_;
+	office_element_ptr		page_style_elm_;
+
+	std::vector<anim_state>			anim_levels;
+	std::vector<office_element_ptr>	transactions;
+
+	void start_timing();
+		void start_timing_par();
+		void end_timing_par();
+
+		void start_timing_seq();
+		void end_timing_seq();
+
+		void set_anim_id		(int val);
+		void set_anim_type		(std::wstring val);
+		void set_anim_duration	(int val);
+		void set_anim_restart	(std::wstring val);
+	void end_timing();
+
+	void start_transition();
+		void set_transition_type	(int val);
+		void set_transition_subtype	(std::wstring val);
+		void set_transition_speed	(int val);
+		void set_transition_duration(int val);
+		void set_transition_sound	(std::wstring ref, bool loop);
+	void end_transition(){}
 private:
 
-    odf_conversion_context * context_;   
+    odf_conversion_context *		context_;   
 	
-	odf_drawing_context		drawing_context_;	
-	odf_comment_context		comment_context_;	
+	odf_drawing_context				drawing_context_;	
+	odf_comment_context				comment_context_;	
+	
+	style_drawing_page_properties*	page_properties_;
 
 	friend class odp_slide_context;
 

ASCOfficeOdfFileW/source/OdfFormat/odp_slide_context.cpp

@@ -73,6 +73,7 @@ void odp_slide_context::start_page(office_element_ptr & elm)
 	office_element_ptr & style = styles_context_->add_or_find(style_name_new, style_family::DrawingPage, true);
 	style->create_child_element(L"style", L"drawing-page-properties");
 
+	state().set_page_id(count_slides_);
 	state().set_page_style(style);
 	state().drawing_context()->set_styles_context(styles_context_);
 }
@@ -80,6 +81,7 @@ void odp_slide_context::start_page(office_element_ptr & elm)
 void odp_slide_context::end_page()
 {
 	state().drawing_context()->finalize(state().page_elm_);
+	state().finalize_page();
 }
 
 void odp_slide_context::remove_page()

ASCOfficeOdfFileW/source/OdfFormat/odp_slide_context.h

@@ -31,6 +31,7 @@
  */
 #pragma once
 
+#include <list>
 #include "odp_page_state.h"
 
 #include "odf_table_context.h"

ASCOfficeOdfFileW/source/OdfFormat/office_annotation.cpp

@@ -124,6 +124,8 @@ void office_annotation::create_child_element(const std::wstring & Ns, const std:
 }
 void office_annotation::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeDcCreator)
@@ -186,6 +188,8 @@ void officeooo_annotation::create_child_element( const std::wstring & Ns, const
 }
 void officeooo_annotation::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeDcCreator)

ASCOfficeOdfFileW/source/OdfFormat/office_elements_type.h

@@ -153,6 +153,7 @@ enum ElementType
     typeStyleFooterStyle,
 	typeStyleHeaderFooterProperties,
 
+	typeStylePresentationSound,
 	typeStylePresentationPageLayout,
 	typeStylePresentationPlaceholder,
 	typeStyleDrawingPageProperties,
@@ -235,6 +236,7 @@ enum ElementType
     typeDrawObject,
     typeDrawObjectOle,
  	typeDrawChart,
+	typeDrawPlugin,
 
 	typeDrawBase,
 	typeDrawShape,
@@ -267,6 +269,9 @@ enum ElementType
 	typeAnimPar,
 	typeAnimSeq,
 	typeAnimTransitionFilter,
+	typeAnimAudio,
+	typeAnimCommand,
+	typeAnimIterator,
 
 	typeStyleGraphicPropertis,
 	typeStyleDrawGradient,

ASCOfficeOdfFileW/source/OdfFormat/office_event_listeners.cpp

@@ -0,0 +1,158 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2017
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
+ * EU, LV-1021.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+
+#include "office_event_listeners.h"
+
+#include <cpdoccore/xml/xmlchar.h>
+#include <cpdoccore/xml/attributes.h>
+
+#include "office_elements_create.h"
+
+#include <cpdoccore/xml/simple_xml_writer.h>
+
+
+namespace cpdoccore { 
+
+namespace odf_writer {
+
+//---------------------------------------------------------------------------------------------------------------
+const wchar_t * office_event_listeners::ns		= L"office";
+const wchar_t * office_event_listeners::name	= L"event-listeners";
+
+void office_event_listeners::create_child_element(const std::wstring & Ns, const std::wstring & Name)
+{
+	if	CP_CHECK_NAME (L"presentation", L"event-listener")
+        CP_CREATE_ELEMENT (presentation_event_listeners_);
+	else if CP_CHECK_NAME (L"script", L"event-listener")
+        CP_CREATE_ELEMENT (script_event_listeners_);
+}
+void office_event_listeners::add_child_element( const office_element_ptr & child_element)
+{
+	if (!child_element) return;
+
+	ElementType type = child_element->get_type();
+
+    if (type == typePresentationEventListener)
+	{
+		presentation_event_listeners_.push_back(child_element);
+	}
+	else if (type == typeScriptEventListener)
+	{
+		script_event_listeners_.push_back(child_element);
+	}
+}
+
+void office_event_listeners::serialize(std::wostream & _Wostream)
+{
+    CP_XML_WRITER(_Wostream)
+    {
+		CP_XML_NODE_SIMPLE()
+        {
+			for (size_t i = 0; i < presentation_event_listeners_.size(); i++)
+			{
+				presentation_event_listeners_[i]->serialize(CP_XML_STREAM());
+			}
+			for (size_t i = 0; i < script_event_listeners_.size(); i++)
+			{
+				script_event_listeners_[i]->serialize(CP_XML_STREAM());
+			}
+		}
+	}
+}
+
+//---------------------------------------------------------------------------------------------------------------
+void presentation_event_listener_attlist::serialize(CP_ATTR_NODE)
+{
+	CP_XML_ATTR_OPT(L"script:event-name", script_event_name_);
+	CP_XML_ATTR_OPT(L"presentation:action", presentation_action_);
+
+	common_xlink_attlist_.serialize(CP_GET_XML_NODE());
+}
+//---------------------------------------------------------------------------------------------------------------
+const wchar_t * presentation_event_listener::ns = L"presentation";
+const wchar_t * presentation_event_listener::name = L"event-listener";
+
+void presentation_event_listener::create_child_element(const std::wstring & Ns, const std::wstring & Name)
+{
+	if CP_CHECK_NAME(L"presentation", L"sound")
+        CP_CREATE_ELEMENT(presentation_sound_);
+    else
+        CP_NOT_APPLICABLE_ELM();
+}
+void presentation_event_listener::add_child_element( const office_element_ptr & child_element)
+{
+	if (!child_element) return;
+
+	ElementType type = child_element->get_type();
+
+    if (type == typeStylePresentationSound)
+	{
+		presentation_sound_ = child_element;
+	}
+}
+void presentation_event_listener::serialize(std::wostream & _Wostream)
+{
+    CP_XML_WRITER(_Wostream)
+    {
+		CP_XML_NODE_SIMPLE()
+        {
+			attlist_.serialize(CP_GET_XML_NODE());
+			if (presentation_sound_)
+				presentation_sound_->serialize(CP_XML_STREAM());
+		}
+	}
+}
+
+// script:event-listener
+//////////////////////////////////////////////////////////////////////////////////////////////////
+const wchar_t * script_event_listener::ns	= L"script";
+const wchar_t * script_event_listener::name = L"event-listener";
+
+void script_event_listener::create_child_element(const std::wstring & Ns, const std::wstring & Name)
+{
+    CP_CREATE_ELEMENT(content_);
+}
+void script_event_listener::add_child_element( const office_element_ptr & child_element)
+{
+	content_.push_back(child_element);
+}
+void script_event_listener::serialize(std::wostream & _Wostream)
+{
+    CP_XML_WRITER(_Wostream)
+    {
+		CP_XML_NODE_SIMPLE()
+        {
+		}
+	}
+}
+}
+}

ASCOfficeOdfFileW/source/OdfFormat/office_event_listeners.h

@@ -0,0 +1,125 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2017
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
+ * EU, LV-1021.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+#pragma once
+
+#include <iosfwd>
+#include <cpdoccore/CPOptional.h>
+#include <cpdoccore/xml/xmlelement.h>
+#include <cpdoccore/xml/nodetype.h>
+#include "office_elements.h"
+#include "office_elements_create.h"
+
+#include "common_attlists.h"
+
+namespace cpdoccore { 
+namespace odf_writer {
+
+class office_event_listeners : public office_element_impl<office_event_listeners>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeOfficeEventListeners;
+    CPDOCCORE_DEFINE_VISITABLE();
+   
+	virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
+    virtual void add_child_element( const office_element_ptr & child_element);
+
+    virtual void serialize(std::wostream & _Wostream);
+
+    office_element_ptr_array	presentation_event_listeners_;
+    office_element_ptr_array	script_event_listeners_;
+  
+};
+CP_REGISTER_OFFICE_ELEMENT2(office_event_listeners);
+
+//-------------------------------------------------------------------------------------
+class presentation_event_listener_attlist
+{
+public:
+    void serialize(CP_ATTR_NODE);
+
+	odf_types::common_xlink_attlist common_xlink_attlist_;
+	_CP_OPT(std::wstring)			script_event_name_;
+	_CP_OPT(std::wstring)			presentation_action_;
+	//presentation:verb
+	//presentation:start-scale
+	//presentation:speed
+	//presentation:direction
+	//presentation:effect
+};
+
+class presentation_event_listener : public office_element_impl<presentation_event_listener>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typePresentationEventListener;
+    CPDOCCORE_DEFINE_VISITABLE();
+    
+	virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
+    virtual void add_child_element( const office_element_ptr & child_element);
+
+    virtual void serialize(std::wostream & _Wostream);
+
+    //office_element_ptr_array				content_;
+	office_element_ptr						presentation_sound_;
+	presentation_event_listener_attlist		attlist_;
+   
+};
+CP_REGISTER_OFFICE_ELEMENT2(presentation_event_listener);
+
+
+//  script:event-listeners_
+class script_event_listener : public office_element_impl<presentation_event_listener>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeScriptEventListener;
+    CPDOCCORE_DEFINE_VISITABLE();
+
+	virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
+    virtual void add_child_element( const office_element_ptr & child_element);
+
+    virtual void serialize(std::wostream & _Wostream);
+
+    office_element_ptr_array content_;    
+};
+CP_REGISTER_OFFICE_ELEMENT2(script_event_listener);
+
+
+}
+}

ASCOfficeOdfFileW/source/OdfFormat/office_presentation.cpp

@@ -61,6 +61,8 @@ void office_presentation::create_child_element(const std::wstring & Ns, const st
 
 void office_presentation::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typePresentationDateTimeDecl)
@@ -83,7 +85,7 @@ void office_presentation::serialize(std::wostream & _Wostream)
     {
 		CP_XML_NODE_SIMPLE()
         {
-			for (int i = 0; i < pages_.size(); i++)
+			for (size_t i = 0; i < pages_.size(); i++)
 			{
 				pages_[i]->serialize(CP_XML_STREAM());
 			}

ASCOfficeOdfFileW/source/OdfFormat/office_presentation.h

@@ -56,8 +56,6 @@ public:
 
     virtual void serialize(std::wostream & _Wostream);
 
-public:
-
     office_element_ptr_array	date_time_decls_;
     office_element_ptr_array	footer_decls_;
   

ASCOfficeOdfFileW/source/OdfFormat/office_scripts.cpp

@@ -0,0 +1,105 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2017
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
+ * EU, LV-1021.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+
+#include "office_scripts.h"
+
+#include <cpdoccore/xml/xmlchar.h>
+#include <cpdoccore/xml/attributes.h>
+
+#include "office_elements_create.h"
+
+#include <cpdoccore/xml/simple_xml_writer.h>
+
+
+namespace cpdoccore { 
+namespace odf_writer {
+
+const wchar_t * office_scripts::ns		= L"office";
+const wchar_t * office_scripts::name	= L"scripts";
+
+
+void office_scripts::create_child_element(const std::wstring & Ns, const std::wstring & Name)
+{
+	CP_CREATE_ELEMENT(content_);
+}
+void office_scripts::add_child_element( const office_element_ptr & child_element)
+{
+	if (!child_element) return;
+
+	content_.push_back(child_element);
+}
+void office_scripts::serialize(std::wostream & _Wostream)
+{
+    CP_XML_WRITER(_Wostream)
+    {
+		CP_XML_NODE_SIMPLE()
+        {
+			for (size_t i = 0; i < content_.size(); i++)
+			{
+				content_[i]->serialize(CP_XML_STREAM());
+			}
+		}
+	}
+}
+//-------------------------------------------------------------------------------------------
+const wchar_t * office_script::ns	= L"office";
+const wchar_t * office_script::name = L"script";
+
+
+void office_script::create_child_element(const std::wstring & Ns, const std::wstring & Name)
+{
+    CP_CREATE_ELEMENT(content_);
+}
+void office_script::add_child_element( const office_element_ptr & child_element)
+{
+	if (!child_element) return;
+
+	content_.push_back(child_element);
+}
+void office_script::serialize(std::wostream & _Wostream)
+{
+    CP_XML_WRITER(_Wostream)
+    {
+		CP_XML_NODE_SIMPLE()
+        {
+			CP_XML_ATTR_OPT(L"script:language", script_language_);
+
+			for (size_t i = 0; i < content_.size(); i++)
+			{
+				content_[i]->serialize(CP_XML_STREAM());
+			}
+		}
+	}
+}
+
+}
+}

ASCOfficeOdfFileW/source/OdfFormat/office_scripts.h

@@ -0,0 +1,91 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2017
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
+ * EU, LV-1021.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+#pragma once
+
+#include <iosfwd>
+#include <cpdoccore/CPOptional.h>
+#include <cpdoccore/xml/xmlelement.h>
+#include <cpdoccore/xml/nodetype.h>
+#include "office_elements.h"
+#include "office_elements_create.h"
+
+namespace cpdoccore { 
+namespace odf_writer {
+
+class office_scripts : public office_element_impl<office_scripts>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeOfficeScripts;
+    CPDOCCORE_DEFINE_VISITABLE();
+
+	virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
+    virtual void add_child_element( const office_element_ptr & child_element);
+
+    virtual void serialize(std::wostream & _Wostream);
+
+    office_element_ptr_array	content_;
+
+    // office-event-listeners ?
+    
+};
+
+CP_REGISTER_OFFICE_ELEMENT2(office_scripts);
+
+class office_script : public office_element_impl<office_script>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeOfficeScript;
+    CPDOCCORE_DEFINE_VISITABLE();
+
+	virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name);
+    virtual void add_child_element( const office_element_ptr & child_element);
+
+    virtual void serialize(std::wostream & _Wostream);
+    
+	_CP_OPT(std::wstring)		script_language_;
+    office_element_ptr_array	content_;
+
+    
+};
+
+CP_REGISTER_OFFICE_ELEMENT2(office_script);
+
+
+
+}
+}

ASCOfficeOdfFileW/source/OdfFormat/office_text.cpp

@@ -161,6 +161,8 @@ void office_change_info::create_child_element( const std::wstring & Ns, const st
 }
 void office_change_info::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeDcCreator)

ASCOfficeOdfFileW/source/OdfFormat/paragraph_elements.cpp

@@ -435,6 +435,8 @@ void text_note::create_child_element(  const std::wstring & Ns, const std::wstri
 }
 void text_note::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTextNoteCitation)
@@ -487,6 +489,8 @@ void text_ruby::create_child_element( const std::wstring & Ns, const std::wstrin
 }
 void text_ruby::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTextRubyBase)

ASCOfficeOdfFileW/source/OdfFormat/style_paragraph_properties.cpp

@@ -162,6 +162,8 @@ void paragraph_format_properties::create_child_element(const std::wstring & Ns,
 }
 void paragraph_format_properties::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeStyleTabStops)

ASCOfficeOdfFileW/source/OdfFormat/style_presentation.cpp

@@ -42,7 +42,7 @@ namespace cpdoccore {
 
 namespace odf_writer {
 
-//////////////////////////////////////////////////////////////////////////////////////////////////
+//----------------------------------------------------------------------------------
 const wchar_t * presentation_placeholder::ns = L"presentation";
 const wchar_t * presentation_placeholder::name = L"placeholder";
 
@@ -62,6 +62,20 @@ void presentation_placeholder::serialize(std::wostream & strm)
 		}
 	}
 }
+//----------------------------------------------------------------------------------
+const wchar_t * presentation_sound::ns = L"presentation";
+const wchar_t * presentation_sound::name = L"sound";
+
+void presentation_sound::serialize(std::wostream & strm)
+{
+	CP_XML_WRITER(strm)
+    {
+		CP_XML_NODE_SIMPLE()
+        {
+			common_xlink_attlist_.serialize(CP_GET_XML_NODE());
+		}
+	}
+}
 //-----------------------------------------------------------------------------------------------------------------------
 
 void drawing_page_properties::serialize(std::wostream & strm, const wchar_t * ns, const wchar_t * name )
@@ -85,17 +99,20 @@ void drawing_page_properties::serialize(std::wostream & strm, const wchar_t * ns
 			CP_XML_ATTR_OPT(L"presentation:display-page-number",presentation_display_page_number_);
 			CP_XML_ATTR_OPT(L"presentation:display-date-time",	presentation_display_date_time_);
 			CP_XML_ATTR_OPT(L"presentation:display-header",		presentation_display_header_);
+
+			if (presentation_sound_)
+				presentation_sound_->serialize(CP_XML_STREAM());
 		}
 	}
 }
 
 //-----------------------------------------------------------------------------------------------------------------------
-const wchar_t * style_drawing_page_properties::ns = L"style";
+const wchar_t * style_drawing_page_properties::ns	= L"style";
 const wchar_t * style_drawing_page_properties::name = L"drawing-page-properties";
 
 void style_drawing_page_properties::serialize(std::wostream & strm)
 {
-	content_.serialize(strm,ns,name);
+	content_.serialize(strm, ns, name);
 }
 
 }

ASCOfficeOdfFileW/source/OdfFormat/style_presentation.h

@@ -74,11 +74,33 @@ public:
 
 CP_REGISTER_OFFICE_ELEMENT2(presentation_placeholder);
 
-//////////////////////////////////////////////
+//----------------------------------------------------------------------------------
+class presentation_sound : public office_element_impl<presentation_sound>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeStylePresentationSound;
+
+    CPDOCCORE_DEFINE_VISITABLE();
+
+	virtual void create_child_element(const std::wstring & Ns, const std::wstring & Name){}
+	virtual void add_child_element( const office_element_ptr & child){}
+
+	virtual void serialize(std::wostream & strm);
+ 
+    odf_types::common_xlink_attlist common_xlink_attlist_;
+};
+
+CP_REGISTER_OFFICE_ELEMENT2(presentation_sound);
+
+//----------------------------------------------------------------------------------
 class drawing_page_properties
 {
 public:
     void apply_from(const drawing_page_properties & Other);
+	
 	void serialize(std::wostream & strm, const wchar_t * ns, const wchar_t * name );
 
 	odf_types::common_draw_fill_attlist		common_draw_fill_attlist_;
@@ -87,23 +109,24 @@ public:
 	_CP_OPT(odf_types::length_or_percent)	draw_fill_image_height_;
 	_CP_OPT(odf_types::length_or_percent)	draw_fill_image_width_;
 	
-	_CP_OPT(std::wstring)					draw_background_size_;//"border" or "full"
+	_CP_OPT(std::wstring)					draw_background_size_;	//"border" or "full"
 
-	_CP_OPT(std::wstring)					presentation_transition_type_;//manual, automatic, semi-automatic (переход отделен от эффектов кликом)
-	_CP_OPT(std::wstring)					presentation_transition_style_;//none, fade, move, uncover,clockwise, .... игнор если smil
-	_CP_OPT(std::wstring)					presentation_transition_speed_;//slow, medium, fast
+	_CP_OPT(std::wstring)					presentation_transition_type_;	//manual, automatic, semi-automatic (переход отделен от эффектов кликом)
+	_CP_OPT(std::wstring)					presentation_transition_style_;	//none, fade, move, uncover,clockwise, .... игнор если smil
+	_CP_OPT(std::wstring)					presentation_transition_speed_;	//slow, medium, fast
 	
 	_CP_OPT(bool)							presentation_display_footer_;
 	_CP_OPT(bool)							presentation_display_page_number_;
 	_CP_OPT(bool)							presentation_display_date_time_;
 	_CP_OPT(bool)							presentation_display_header_;
+	_CP_OPT(std::wstring)					presentation_page_duration_;
 
+	office_element_ptr						presentation_sound_;
+	
 	//presentation:background-objects-visible
 	//presentation:background-visible
 	//style:repeat
-	//presentation:page-duration
-	//presentation:visibility.
-	//presentation:sound.
+	//presentation:visibility
 	//draw:background-size
 
 };

ASCOfficeOdfFileW/source/OdfFormat/table.cpp

@@ -184,6 +184,8 @@ void table_table::create_child_element(const std::wstring & Ns, const std::wstri
 
 void table_table::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTableTableSource)
@@ -277,6 +279,8 @@ void table_table_columns::create_child_element(const std::wstring & Ns, const st
 }
 void table_table_columns::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTableTableColumn) 
@@ -312,6 +316,8 @@ void table_table_header_columns::create_child_element( const std::wstring & Ns,
 }
 void table_table_header_columns::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTableTableColumn) 
@@ -348,6 +354,8 @@ void table_columns::create_child_element( const std::wstring & Ns, const std::ws
 }
 void table_columns::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTableTableColumns) 
@@ -400,6 +408,8 @@ void table_columns_no_group::create_child_element(  const std::wstring & Ns, con
 }
 void table_columns_no_group::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTableTableColumns || type == typeTableTableColumn) 
@@ -489,6 +499,8 @@ void table_columns_and_groups::create_child_element(const std::wstring & Ns, con
 }
 void table_columns_and_groups::add_child_element( const office_element_ptr & child_element, odf_conversion_context * Context)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTableTableColumnGroup) 
@@ -608,6 +620,8 @@ void table_table_row::create_child_element( const std::wstring & Ns, const std::
 }
 void table_table_row::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTableTableCell || type == typeTableCoveredTableCell )
@@ -672,6 +686,8 @@ void table_table_header_rows::create_child_element( const std::wstring & Ns, con
 }
 void table_table_header_rows::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTableTableRow)
@@ -709,6 +725,8 @@ void table_rows::create_child_element(const std::wstring & Ns, const std::wstrin
 }
 void table_rows::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTableTableRows)
@@ -761,6 +779,8 @@ void table_rows_no_group::create_child_element( const std::wstring & Ns, const s
 }
 void table_rows_no_group::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTableTableRows || type == typeTableTableRow)
@@ -816,6 +836,8 @@ void table_rows_and_groups::create_child_element( const std::wstring & Ns, const
 }
 void table_rows_and_groups::add_child_element( const office_element_ptr & child_element, odf_conversion_context * Context)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
 	if (type == typeTableTableRowGroup)

ASCOfficeOdfFileW/source/OdfFormat/table_database_ranges.cpp

@@ -64,7 +64,9 @@ void table_database_ranges::create_child_element(const std::wstring & Ns, const
 
 void table_database_ranges::add_child_element( const office_element_ptr & child_element)
 {
- 	ElementType type = child_element->get_type();
+ 	if (!child_element) return;
+
+	ElementType type = child_element->get_type();
 
     if (type == typeTableDatabaseRange)
 	{

ASCOfficeOdfFileW/source/OdfFormat/table_named_expressions.cpp

@@ -66,7 +66,9 @@ void table_named_expressions::create_child_element(const std::wstring & Ns, cons
 
 void table_named_expressions::add_child_element( const office_element_ptr & child_element)
 {
- 	ElementType type = child_element->get_type();
+ 	if (!child_element) return;
+
+	ElementType type = child_element->get_type();
 
     if (type == typeTableNamedRange)
 	{

ASCOfficeOdfFileW/source/OdfFormat/text_elements.cpp

@@ -255,6 +255,8 @@ void text_section::create_child_element( const std::wstring & Ns, const std::wst
 
 void text_section::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeTextSectionSource)
@@ -510,6 +512,8 @@ void text_unknown_change::create_child_element(const std::wstring & Ns, const st
 
 void text_unknown_change::add_child_element( const office_element_ptr & child_element)
 {
+	if (!child_element) return;
+
 	ElementType type = child_element->get_type();
 
     if (type == typeOfficeChangeInfo)

ASCOfficeOdfFileW/source/Oox2OdfConverter/ConvertDrawing.cpp

@@ -171,7 +171,6 @@ void OoxConverter::convert(PPTX::Logic::Pic *oox_picture)
 {
 	if (!oox_picture)return;
 
-	bool bImage = true;
 	if (oox_picture->spPr.Geometry.is_init())
 	{
 		int type = SimpleTypes::shapetypeRect;
@@ -203,7 +202,33 @@ void OoxConverter::convert(PPTX::Logic::Pic *oox_picture)
 			return;
 		}
 	}
+//--------------------------------------------------------------------------------------
+	if (oox_picture->nvPicPr.nvPr.media.is_init())
+	{
+		if (oox_picture->nvPicPr.nvPr.media.is<PPTX::Logic::MediaFile>())
+		{
+			PPTX::Logic::MediaFile & media = oox_picture->nvPicPr.nvPr.media.as<PPTX::Logic::MediaFile>();
 
+			std::wstring sID		= media.link.get();
+			std::wstring pathMedia	= find_link_by_id(sID, 3);
+			
+			std::wstring odf_ref	= odf_context()->add_media(pathMedia);
+
+			if (!odf_ref.empty())
+			{
+				odf_context()->drawing_context()->start_media(odf_ref);
+				//... params
+				
+				OoxConverter::convert(&oox_picture->nvPicPr.cNvPr);		
+				OoxConverter::convert(&oox_picture->spPr, oox_picture->style.GetPointer());
+				
+				odf_context()->drawing_context()->end_media();
+
+				return;
+			}			
+		}
+	}
+//--------------------------------------------------------------------------------------
 	std::wstring odf_ref;
 	std::wstring pathImage;
 	if (oox_picture->blipFill.blip.IsInit())
@@ -222,7 +247,6 @@ void OoxConverter::convert(PPTX::Logic::Pic *oox_picture)
 			bEmbedded = false;
 		}
 	}
-
 	odf_context()->drawing_context()->start_image(odf_ref);
 	{
 		double Width = 0, Height = 0;
@@ -437,8 +461,6 @@ void OoxConverter::convert(PPTX::Logic::Shape *oox_shape)
 {
 	if (oox_shape == NULL) return;
 
-	_CP_OPT(bool) bMasterPresentation = odf_context()->drawing_context()->get_presentation();
-	
 	if (oox_shape->txXfrm.IsInit())
 	{
 		odf_context()->drawing_context()->start_group();
@@ -856,10 +878,10 @@ void OoxConverter::convert(PPTX::Logic::GradFill *oox_grad_fill, DWORD nARGB)
 			}	
 			if (oox_grad_fill->path->rect.IsInit())
 			{
-				odf_context()->drawing_context()->set_gradient_rect( XmlUtils::GetInteger(oox_grad_fill->path->rect->l.get_value_or(L"")),
-																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->t.get_value_or(L"")),
-																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->r.get_value_or(L"")),
-																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->b.get_value_or(L"")));			
+				odf_context()->drawing_context()->set_gradient_rect( XmlUtils::GetInteger(oox_grad_fill->path->rect->l.get_value_or(L"")) / 1000.,
+																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->t.get_value_or(L"")) / 1000.,
+																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->r.get_value_or(L"")) / 1000.,
+																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->b.get_value_or(L"")) / 1000.);			
 			}
 		}	
 		odf_context()->drawing_context()->set_gradient_type(grad_style);
@@ -1122,6 +1144,22 @@ void OoxConverter::convert(PPTX::Logic::CNvPr *oox_cnvPr)
 	}
 	if (oox_cnvPr->hlinkClick.IsInit())
 	{
+		odf_context()->drawing_context()->start_action(oox_cnvPr->hlinkClick->action.get_value_or(L""));
+
+			if (oox_cnvPr->hlinkClick->snd.IsInit())
+			{
+				std::wstring sound = find_link_by_id(oox_cnvPr->hlinkClick->snd->embed.get(), 3);
+
+				std::wstring href = odf_context()->add_media(sound);				
+				odf_context()->drawing_context()->add_sound(href);	
+			}
+			if (oox_cnvPr->hlinkClick->id.IsInit())
+			{
+				std::wstring hlink = find_link_by_id(oox_cnvPr->hlinkClick->id.get(), 2);
+				
+				odf_context()->drawing_context()->add_link(hlink);	
+			}
+		odf_context()->drawing_context()->end_action();
 	}
 	//nullable_string		title;
 	//nullable<Hyperlink>	hlinkHover;
@@ -1148,8 +1186,11 @@ void OoxConverter::convert(PPTX::Logic::NvCxnSpPr *oox_nvSpPr)
 void OoxConverter::convert(PPTX::Logic::NvPr *oox_nvPr)
 {
 	if (!oox_nvPr) return;
+	
+
 
 //ph уровнем выше
+
 }
 
 void OoxConverter::convert_list_level(PPTX::Logic::TextParagraphPr	*oox_para_props, int level)
@@ -1424,9 +1465,9 @@ void OoxConverter::convert(PPTX::Logic::Paragraph *oox_paragraph, PPTX::Logic::T
 
 		if (list_local)
 		{
-			_CP_OPT(bool) inStyles = odf_context()->drawing_context()->get_presentation();
+			_CP_OPT(int) inStyles = odf_context()->drawing_context()->get_presentation();
 
-			odf_context()->styles_context()->lists_styles().start_style(inStyles && *inStyles);
+			odf_context()->styles_context()->lists_styles().start_style(inStyles && *inStyles > 0);
 				convert_list_level(oox_paragraph->pPr.GetPointer(), list_level /*- 1*/);
 			odf_context()->styles_context()->lists_styles().end_style();
 	
@@ -1926,9 +1967,9 @@ void OoxConverter::convert(PPTX::Logic::TextListStyle *oox_list_style)
 	if (!oox_list_style) return;
 	if (oox_list_style->IsListStyleEmpty()) return;
 
-	_CP_OPT(bool) inStyles = odf_context()->drawing_context()->get_presentation();
+	_CP_OPT(int) inStyles = odf_context()->drawing_context()->get_presentation();
 
-	odf_context()->styles_context()->lists_styles().start_style(inStyles && *inStyles);
+	odf_context()->styles_context()->lists_styles().start_style(inStyles && *inStyles > 0); // masters 
 	for (int i = 0; i < 9; i++)
 	{
 		OoxConverter::convert_list_level(oox_list_style->levels[i].GetPointer(), i);

ASCOfficeOdfFileW/source/Oox2OdfConverter/Converter.cpp

@@ -304,28 +304,31 @@ void OoxConverter::convert(OOX::WritingElement  *oox_unknown)
         _CP_LOG << L"[error] :  no convert element(" << (oox_unknown ? oox_unknown->getType() : -1 ) << L")\n";
 	}
 }
+std::wstring OoxConverter::find_link_by (smart_ptr<OOX::File> & oFile, int type)
+{
+	if (!oFile.IsInit()) return L"";
+	
+    std::wstring ref;
+	if (type == 1 && OOX::FileTypes::Image == oFile->type())
+	{
+		OOX::Image* pImage = (OOX::Image*)oFile.operator->();
 
-//void OoxConverter::convert(OOX::Drawing::CLockedCanvas  *oox_canvas)
-//{
-//	if (oox_canvas == NULL)return;
-//
-//	odf_context()->drawing_context()->start_group();
-//		if (oox_canvas->m_oNvGroupSpPr.IsInit() && oox_canvas->m_oNvGroupSpPr->m_oCNvPr.IsInit())
-//		{	
-//			if (oox_canvas->m_oNvGroupSpPr->m_oCNvPr->m_sName.IsInit())
-//				odf_context()->drawing_context()->set_group_name(*oox_canvas->m_oNvGroupSpPr->m_oCNvPr->m_sName);
-//			if (oox_canvas->m_oNvGroupSpPr->m_oCNvPr->m_oId.IsInit())
-//				odf_context()->drawing_context()->set_group_z_order(oox_canvas->m_oNvGroupSpPr->m_oCNvPr->m_oId->GetValue());
-//		}
-//		convert(oox_canvas->m_oGroupSpPr.GetPointer());
-//		convert(oox_canvas->m_oSpPr.GetPointer());
-//
-//		for (size_t i = 0; i < oox_canvas->m_arrItems.size(); i++)
-//		{
-//			convert(oox_canvas->m_arrItems[i]);
-//		}
-//	odf_context()->drawing_context()->end_group();
-//}
+		ref = pImage->filename().GetPath();
+	}
+	if (type == 2 && OOX::FileTypes::HyperLink == oFile->type())
+	{
+		OOX::HyperLink* pHyperlink = (OOX::HyperLink*)oFile.operator->();
+		if (pHyperlink->bHyperlink)
+			ref = pHyperlink->Uri().GetPath();
+	}
+	if (type == 3)
+	{
+		OOX::Media* pMedia = (OOX::Media*)oFile.operator->();
+
+		ref = pMedia->filename().GetPath();
+	}
+	return ref;
+}
 
 bool OoxConverter::convert(std::wstring sSchemeColor, DWORD & argb)
 {

ASCOfficeOdfFileW/source/Oox2OdfConverter/Converter.h

@@ -360,6 +360,7 @@ public:
 		virtual PPTX::Theme										*oox_theme()	= 0;
 		virtual PPTX::Logic::ClrMap								*oox_clrMap()	{return NULL;}
        
+				std::wstring								find_link_by (NSCommon::smart_ptr<OOX::File> & oFile, int type);
 		virtual std::wstring								find_link_by_id(std::wstring sId, int t) = 0;
 		virtual NSCommon::smart_ptr<OOX::File>				find_file_by_id(std::wstring sId) = 0;
 		

ASCOfficeOdfFileW/source/Oox2OdfConverter/DocxConverter.cpp

@@ -131,48 +131,23 @@ NSCommon::smart_ptr<OOX::File> DocxConverter::find_file_by_id(std::wstring sId)
 
 std::wstring DocxConverter::find_link_by_id (std::wstring sId, int type)
 {
+	if (!docx_document) return L"";
+
+    std::wstring			ref;
+	smart_ptr<OOX::File>	oFile;
+
+    if (oox_current_child_document)
+	{
+		oFile	= oox_current_child_document->Find(sId);
+		ref		= OoxConverter::find_link_by(oFile, type);
+	}
+	if (!ref.empty()) return ref;
+
 	OOX::CDocument  *oox_doc = docx_document->GetDocument();
-
-	if (oox_doc == NULL)return L"";
-		
-    std::wstring ref;
-
-    if (ref.empty() && oox_current_child_document)
-	{
-		smart_ptr<OOX::File> oFile = oox_current_child_document->Find(sId);
-		if (oFile.IsInit())
-		{		
-			if (type==1 && OOX::FileTypes::Image == oFile->type())
-			{
-				OOX::Image* pImage = (OOX::Image*)oFile.operator->();
-
-				ref = pImage->filename().GetPath();
-			}
-			if (type==2 && oFile.IsInit() && OOX::FileTypes::HyperLink == oFile->type())
-			{
-				OOX::HyperLink* pHyperlink = (OOX::HyperLink*)oFile.operator->();
-
-				ref = pHyperlink->Uri().GetPath();
-			}
-		}
-	}
-
-	smart_ptr<OOX::File> oFile = docx_document->GetDocument()->Find(sId);
-    if (ref.empty() && oFile.IsInit())
-	{
-		if (type==1 && OOX::FileTypes::Image == oFile->type())
-		{
-			OOX::Image* pImage = (OOX::Image*)oFile.operator->();
-
-			ref = pImage->filename().GetPath();
-		}
-		if (type == 2 && OOX::FileTypes::HyperLink == oFile->type())
-		{
-			OOX::HyperLink* pHyperlink = (OOX::HyperLink*)oFile.operator->();
-
-			ref = pHyperlink->Uri().GetPath();
-		}
-	}
+	if (oox_doc == NULL) return L"";
+	
+	oFile	= oox_doc->Find(sId);
+	ref		= OoxConverter::find_link_by(oFile, type);
 
 	return ref;
 }
@@ -253,116 +228,88 @@ void DocxConverter::convert(OOX::WritingElement  *oox_unknown)
 	{
 		case OOX::et_w_ptab:
 		{
-			OOX::Logic::CPTab* pT= dynamic_cast<OOX::Logic::CPTab*>(oox_unknown);
-			convert(pT);
+			convert(dynamic_cast<OOX::Logic::CPTab*>(oox_unknown));
 		}break;
 		case OOX::et_w_sdt:
 		{
-			OOX::Logic::CSdt* pP= dynamic_cast<OOX::Logic::CSdt*>(oox_unknown);
-			convert(pP);
+			convert(dynamic_cast<OOX::Logic::CSdt*>(oox_unknown));
 		}break;
 		case OOX::et_w_fldSimple:	
 		{
-			OOX::Logic::CFldSimple* pFldS= dynamic_cast<OOX::Logic::CFldSimple*>(oox_unknown);
-			convert(pFldS);
+			convert(dynamic_cast<OOX::Logic::CFldSimple*>(oox_unknown));
 		}break;
 		case OOX::et_w_r:
 		{
-			OOX::Logic::CRun* pRun= dynamic_cast<OOX::Logic::CRun*>(oox_unknown);
-			convert(pRun);
+			convert(dynamic_cast<OOX::Logic::CRun*>(oox_unknown));
 		}break;
 		case OOX::et_w_p:
 		{
-			OOX::Logic::CParagraph* pP= dynamic_cast<OOX::Logic::CParagraph*>(oox_unknown);
-			convert(pP);
+			convert(dynamic_cast<OOX::Logic::CParagraph*>(oox_unknown));
 		}break;
 		case OOX::et_w_ins:
 		{
-			OOX::Logic::CIns* pIns= dynamic_cast<OOX::Logic::CIns*>(oox_unknown);
-			convert(pIns);
+			convert(dynamic_cast<OOX::Logic::CIns*>(oox_unknown));
 		}break;
 		case OOX::et_w_del:
 		{
-			OOX::Logic::CDel* pDel= dynamic_cast<OOX::Logic::CDel*>(oox_unknown);
-			convert(pDel);
+			convert(dynamic_cast<OOX::Logic::CDel*>(oox_unknown));
 		}break;
 		case OOX::et_w_smartTag:
 		{
-			OOX::Logic::CSmartTag* pTag= dynamic_cast<OOX::Logic::CSmartTag*>(oox_unknown);
-			convert(pTag);
+			convert(dynamic_cast<OOX::Logic::CSmartTag*>(oox_unknown));
 		}break;
 		case OOX::et_w_pPr:
 		{
-			OOX::Logic::CParagraphProperty* pPProp= dynamic_cast<OOX::Logic::CParagraphProperty*>(oox_unknown);
-			convert(pPProp);
+			convert(dynamic_cast<OOX::Logic::CParagraphProperty*>(oox_unknown));
 		}break;
 		case OOX::et_w_hyperlink:
 		{
-			OOX::Logic::CHyperlink* pH= dynamic_cast<OOX::Logic::CHyperlink*>(oox_unknown);
-			convert(pH);
+			convert(dynamic_cast<OOX::Logic::CHyperlink*>(oox_unknown));
 		}break;
 		case OOX::et_w_rPr:
 		{
-			OOX::Logic::CRunProperty* pRProp= dynamic_cast<OOX::Logic::CRunProperty*>(oox_unknown);
-			convert(pRProp);
+			convert(dynamic_cast<OOX::Logic::CRunProperty*>(oox_unknown));
 		}break;
 		case OOX::et_mc_alternateContent:
 		{
-			OOX::Logic::CAlternateContent* pAltCont= dynamic_cast<OOX::Logic::CAlternateContent*>(oox_unknown);
-			convert(pAltCont);
+			convert(dynamic_cast<OOX::Logic::CAlternateContent*>(oox_unknown));
 		}break;
 		case OOX::et_w_drawing:
 		{
-			OOX::Logic::CDrawing* pDrawing= dynamic_cast<OOX::Logic::CDrawing*>(oox_unknown);
-			convert(pDrawing);
+			convert(dynamic_cast<OOX::Logic::CDrawing*>(oox_unknown));
 		}break;
-		//case OOX::et_c_chart:
-		//{
-		//	PPTX::Logic::ChartRec* pChart = dynamic_cast<PPTX::Logic::ChartRec*>(oox_unknown);
-		//	convert(pChart);
-		//}break;
-		//case OOX::et_w_Shape:
-		//{
-		//	OOX::Logic::CShape* pShape = dynamic_cast<OOX::Logic::CShape*>(oox_unknown);
-		//	convert(pShape);
-		//}break;
 		case OOX::et_w_pict:
 		{
-			OOX::Logic::CPicture* pPic = dynamic_cast<OOX::Logic::CPicture*>(oox_unknown);
-			convert(pPic);
+			convert(dynamic_cast<OOX::Logic::CPicture*>(oox_unknown));
 		}break;
 		case OOX::et_w_object:
 		{
-			OOX::Logic::CObject* pObj = dynamic_cast<OOX::Logic::CObject*>(oox_unknown);
-			convert(pObj);
+			convert(dynamic_cast<OOX::Logic::CObject*>(oox_unknown));
 		}break;
 		case OOX::et_pic_pic:
 		case OOX::et_pic:
 		case OOX::et_p_pic:
 		{
-			PPTX::Logic::Pic* pPic = dynamic_cast<PPTX::Logic::Pic*>(oox_unknown);
-			convert(pPic);
+			convert(dynamic_cast<PPTX::Logic::Pic*>(oox_unknown));
 		}break;
 		case OOX::et_w_GroupShape:
 		case OOX::et_p_ShapeTree:
 		{
-			PPTX::Logic::SpTree* pGroupShape= dynamic_cast<PPTX::Logic::SpTree*>(oox_unknown);
-			convert(pGroupShape);
+			convert(dynamic_cast<PPTX::Logic::SpTree*>(oox_unknown));
 		}break;
 
 		case OOX::et_w_commentRangeEnd:
 		{
-			OOX::Logic::CCommentRangeEnd* pCommEnd = dynamic_cast<OOX::Logic::CCommentRangeEnd*>(oox_unknown);
-			convert(pCommEnd);
+			convert(dynamic_cast<OOX::Logic::CCommentRangeEnd*>(oox_unknown));
 		}break;
 		case OOX::et_w_commentRangeStart:
 		{
-			OOX::Logic::CCommentRangeStart* pCommStart = dynamic_cast<OOX::Logic::CCommentRangeStart*>(oox_unknown);
-			convert(pCommStart);
+			convert(dynamic_cast<OOX::Logic::CCommentRangeStart*>(oox_unknown));
 		}break;
 		case OOX::et_w_commentReference:
 		{
-			convert(dynamic_cast<OOX::Logic::CCommentReference*>(oox_unknown));		//если нет Start - означает начало с предыдущего Run
+			convert(dynamic_cast<OOX::Logic::CCommentReference*>(oox_unknown));		
+					//если нет Start - означает начало с предыдущего Run
 		}break;
 		case OOX::et_w_footnoteReference:
 		{
@@ -386,13 +333,11 @@ void DocxConverter::convert(OOX::WritingElement  *oox_unknown)
 		}break;
 		case OOX::et_w_tr:
 		{
-			OOX::Logic::CTr* pRow= dynamic_cast<OOX::Logic::CTr*>(oox_unknown);
-			convert(pRow);
+			convert(dynamic_cast<OOX::Logic::CTr*>(oox_unknown));
 		}break;
 		case OOX::et_w_tc:
 		{
-			OOX::Logic::CTc* pCell= dynamic_cast<OOX::Logic::CTc*>(oox_unknown);
-			convert(pCell);
+			convert(dynamic_cast<OOX::Logic::CTc*>(oox_unknown));
 		}break;
 		case OOX::et_w_bookmarkStart:
 		{

ASCOfficeOdfFileW/source/Oox2OdfConverter/PptxConverter.cpp

@@ -35,8 +35,22 @@
 #include "../../../ASCOfficePPTXFile/PPTXFormat/Folder.h"
 #include "../../../ASCOfficePPTXFile/PPTXFormat/Presentation.h"
 #include "../../../ASCOfficePPTXFile/PPTXFormat/Slide.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/NotesMaster.h"
 
 #include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Table/Table.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Timing/Par.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Timing/Seq.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Timing/CTn.h"
+
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Transitions/EmptyTransition.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Transitions/OrientationTransition.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Transitions/EightDirectionTransition.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Transitions/OptionalBlackTransition.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Transitions/SideDirectionTransition.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Transitions/CornerDirectionTransition.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Transitions/WheelTransition.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Transitions/SplitTransition.h"
+#include "../../../ASCOfficePPTXFile/PPTXFormat/Logic/Transitions/ZoomTransition.h"
 
 #include <boost/lexical_cast.hpp>
 
@@ -154,43 +168,20 @@ NSCommon::smart_ptr<OOX::File> PptxConverter::find_file_by_id(std::wstring sId)
 
 std::wstring PptxConverter::find_link_by_id (std::wstring sId, int type)
 {
-    std::wstring ref;
+	if(!pptx_document) return L"";
 
-    if (ref.empty() && oox_current_child_document)
+    std::wstring			ref;
+	smart_ptr<OOX::File>	oFile;
+
+	if (oox_current_child_document)
 	{
-		smart_ptr<OOX::File> oFile = oox_current_child_document->Find(sId);
-		if (oFile.IsInit())
-		{		
-			if (type==1 && OOX::FileTypes::Image == oFile->type())
-			{
-				OOX::Image* pImage = (OOX::Image*)oFile.operator->();
-
-				ref = pImage->filename().GetPath();
-			}
-			if (type==2 && oFile.IsInit() && OOX::FileTypes::HyperLink == oFile->type())
-			{
-				OOX::HyperLink* pHyperlink = (OOX::HyperLink*)oFile.operator->();
-
-				ref = pHyperlink->Uri().GetPath();
-			}
-		}
+		oFile	= oox_current_child_document->Find(sId);
+		ref		= OoxConverter::find_link_by(oFile, type);
 	}
-	smart_ptr<OOX::File> oFile = current_slide ? current_slide->Find(sId) : pptx_document->Find(sId);
-    if (ref.empty() && oFile.IsInit())
-	{
-		if (type==1 && OOX::FileTypes::Image == oFile->type())
-		{
-			OOX::Image* pImage = (OOX::Image*)oFile.operator->();
+	if (!ref.empty()) return ref;
 
-			ref = pImage->filename().GetPath();
-		}
-		if (type == 2 && OOX::FileTypes::HyperLink == oFile->type())
-		{
-			OOX::HyperLink* pHyperlink = (OOX::HyperLink*)oFile.operator->();
-
-			ref = pHyperlink->Uri().GetPath();
-		}
-	}
+	oFile	= current_slide ? current_slide->Find(sId) : pptx_document->Find(sId);
+	ref		= OoxConverter::find_link_by(oFile, type);
 
 	return ref;
 }
@@ -351,7 +342,7 @@ void PptxConverter::convert_slides()
 					current_slide = slide->Master.operator->();
 					
 					if (bShowLayoutMasterSp && bShowMasterSp)
-						convert_slide(&slide->Master->cSld, current_txStyles, false, true);
+						convert_slide(&slide->Master->cSld, current_txStyles, false, true, 2);
 					else
 						convert(slide->Master->cSld.bg.GetPointer());
 
@@ -359,8 +350,20 @@ void PptxConverter::convert_slides()
 						current_clrMap	= slide->Layout->clrMapOvr->overrideClrMapping.GetPointer();
 					current_slide = slide->Layout.operator->();
 					
-					convert_slide(&slide->Layout->cSld, current_txStyles, true, bShowLayoutMasterSp);		
-					//add note master
+					convert_slide(&slide->Layout->cSld, current_txStyles, true, bShowLayoutMasterSp, 3);	
+
+					if (slide->Layout->transition.IsInit())	convert	(slide->Layout->transition.GetPointer());
+					else									convert	(slide->Master->transition.GetPointer());
+					
+					//if (slide->Layout->timing.IsInit())	convert	(slide->Layout->timing.GetPointer());
+					//else									convert	(slide->Master->timing.GetPointer());
+
+					if (!presentation->notesMasterIdLst.empty())
+					{
+						rId = presentation->notesMasterIdLst[0].rid.get();
+						smart_ptr<PPTX::NotesMaster> notes_master = ((*presentation)[rId]).smart_dynamic_cast<PPTX::NotesMaster>();
+						convert(notes_master.operator->());
+					}
 				odp_context->end_master_slide();
 				
 				m_mapMasters.insert(std::make_pair(master_name, master_style_name));
@@ -399,31 +402,78 @@ void PptxConverter::convert_slides()
 		odp_context->current_slide().set_master_page (master_style_name);
 		odp_context->current_slide().set_layout_page (layout_style_name);
 		
-		convert_slide	(slide->cSld.GetPointer(), current_txStyles, true, bShowMasterSp);
+		convert_slide	(slide->cSld.GetPointer(), current_txStyles, true, bShowMasterSp, 1);
 		convert			(slide->comments.operator->());
 		convert			(slide->Note.operator->());
 		
-		convert			(slide->timing.GetPointer(), slide->transition.GetPointer());
+		convert			(slide->transition.GetPointer());
+		//convert		(slide->timing.GetPointer());
 
 
 		odp_context->end_slide();
 	}
 }
-void PptxConverter::convert(PPTX::NotesSlide *oox_note)
+void PptxConverter::convert(PPTX::NotesMaster *oox_notes)
 {
-	if (!oox_note) return;
+	if (!oox_notes) return;
 	
-	odp_context->start_note();
+	odp_context->start_note(true);
 	
-	current_slide = dynamic_cast<OOX::IFileContainer*>(oox_note);
+	PPTX::Theme*			old_theme	= current_theme;
+	PPTX::Logic::ClrMap*	old_clrMap	= current_clrMap;
 
-	if (oox_note->clrMapOvr.IsInit() && oox_note->clrMapOvr->overrideClrMapping.IsInit())
-		current_clrMap	= oox_note->clrMapOvr->overrideClrMapping.GetPointer();
-	//current_txStyles	= oox_note->Master->txStyles.GetPointer();
+	current_theme	= oox_notes->theme_.operator->();
+	current_clrMap	= &oox_notes->clrMap;
 	
-	convert_slide(&oox_note->cSld, NULL, true, true);
+	current_slide	= dynamic_cast<OOX::IFileContainer*>(oox_notes);
+	//PPTX::Logic::TxStyles* current_txStyles = oox_notes->notesStyle.GetPointer();
+	
+	if (presentation->notesSz.IsInit())
+	{
+		_CP_OPT(odf_types::length) width	= odf_types::length(presentation->notesSz->cx / 12700., odf_types::length::pt);
+		_CP_OPT(odf_types::length) height	= odf_types::length(presentation->notesSz->cy / 12700., odf_types::length::pt);
+		
+		odf_context()->page_layout_context()->set_page_size(width, height);
+	}
+	convert_slide(&oox_notes->cSld, NULL, true, true, 2);
 	
 	odp_context->end_note();
+
+	current_clrMap	= old_clrMap;
+	current_theme	= old_theme;
+}
+void PptxConverter::convert(PPTX::NotesSlide *oox_notes)
+{
+	if (!oox_notes) return;
+
+	PPTX::Theme*			old_theme	= current_theme;
+	PPTX::Logic::ClrMap*	old_clrMap	= current_clrMap;
+
+	smart_ptr<PPTX::NotesMaster> notes_master;
+	if (!presentation->notesMasterIdLst.empty())
+	{
+		std::wstring rId = presentation->notesMasterIdLst[0].rid.get();
+		notes_master = ((*presentation)[rId]).smart_dynamic_cast<PPTX::NotesMaster>();
+	}	
+	odp_context->start_note();
+	
+	if (notes_master.IsInit())
+	{
+		current_theme	= notes_master->theme_.operator->();
+		current_clrMap	= &notes_master->clrMap;
+	}
+
+	current_slide	= dynamic_cast<OOX::IFileContainer*>(oox_notes);
+
+	if (oox_notes->clrMapOvr.IsInit() && oox_notes->clrMapOvr->overrideClrMapping.IsInit())
+		current_clrMap	= oox_notes->clrMapOvr->overrideClrMapping.GetPointer();
+	
+	convert_slide(&oox_notes->cSld, NULL, true, true, 1);
+	
+	odp_context->end_note();
+	
+	current_clrMap	= old_clrMap;
+	current_theme	= old_theme;
 }
 
 void PptxConverter::convert(OOX::WritingElement  *oox_unknown)
@@ -432,6 +482,24 @@ void PptxConverter::convert(OOX::WritingElement  *oox_unknown)
 
 	switch(oox_unknown->getType())
 	{
+		case OOX::et_p_EmptyTransition:
+			convert(dynamic_cast<PPTX::Logic::EmptyTransition*>(oox_unknown)); break;
+		case OOX::et_p_OrientationTransition:
+			convert(dynamic_cast<PPTX::Logic::OrientationTransition*>(oox_unknown)); break;
+		case OOX::et_p_EightDirectionTransition:
+			convert(dynamic_cast<PPTX::Logic::EightDirectionTransition*>(oox_unknown)); break;
+		case OOX::et_p_OptionalBlackTransition:
+			convert(dynamic_cast<PPTX::Logic::OptionalBlackTransition*>(oox_unknown)); break;
+		case OOX::et_p_CornerDirectionTransition:
+			convert(dynamic_cast<PPTX::Logic::CornerDirectionTransition*>(oox_unknown)); break;
+		case OOX::et_p_SideDirectionTransition:
+			convert(dynamic_cast<PPTX::Logic::SideDirectionTransition*>(oox_unknown)); break;
+		case OOX::et_p_WheelTransition:
+			convert(dynamic_cast<PPTX::Logic::WheelTransition*>(oox_unknown)); break;
+		case OOX::et_p_SplitTransition:
+			convert(dynamic_cast<PPTX::Logic::SplitTransition*>(oox_unknown)); break;
+		case OOX::et_p_ZoomTransition:
+			convert(dynamic_cast<PPTX::Logic::ZoomTransition*>(oox_unknown)); break;
 		default:
 		{
 			OoxConverter::convert(oox_unknown);
@@ -473,15 +541,262 @@ void PptxConverter::convert(PPTX::Comments *oox_comments)
 		odp_context->end_comment();
 	}
 }
-void PptxConverter::convert(PPTX::Logic::Timing *oox_timing, PPTX::Logic::Transition *oox_transition)
+void PptxConverter::convert( PPTX::Logic::Transition *oox_transition )
+{
+	if (!oox_transition) return;
+	if (oox_transition->base.is_init() == false) return;
+
+	odp_context->current_slide().start_transition();
+	if (oox_transition->spd.is_init())
+		odp_context->current_slide().set_transition_speed(oox_transition->spd->GetBYTECode());
+	if (oox_transition->dur.is_init())
+		odp_context->current_slide().set_transition_duration(*oox_transition->dur);
+	
+	convert(oox_transition->base.base.operator->());
+	
+	if (oox_transition->sndAc.is_init() && oox_transition->sndAc->stSnd.is_init())
+	{
+		std::wstring sID		= oox_transition->sndAc->stSnd->embed.get();
+		std::wstring pathAudio	= find_link_by_id(sID, 3);
+		
+		std::wstring odf_ref	= odf_context()->add_media(pathAudio);
+
+		odp_context->current_slide().set_transition_sound(odf_ref, oox_transition->sndAc->stSnd->loop.get_value_or(false));
+	}
+
+	odp_context->current_slide().end_transition();
+}
+void PptxConverter::convert(PPTX::Logic::Timing *oox_timing)
 {
 	if (!oox_timing) return;
 	if (!oox_timing->tnLst.IsInit()) return;
 	
+	odp_context->current_slide().start_timing();
 	for (size_t i = 0; i < oox_timing->tnLst->list.size(); i++)
 	{
-		//oox_timing->tnLst[0]
+		if (oox_timing->tnLst->list[i].is_init() == false) continue;
+
+		convert(&oox_timing->tnLst->list[i]);
 	}
+	odp_context->current_slide().end_timing();
+}
+void PptxConverter::convert(PPTX::Logic::TimeNodeBase *oox_time_base)
+{
+	if (!oox_time_base) return;
+
+	if (oox_time_base->is<PPTX::Logic::Par>()) //Parallel Time
+	{
+		PPTX::Logic::Par & par = oox_time_base->as<PPTX::Logic::Par>();
+
+		odp_context->current_slide().start_timing_par();
+			convert(&par.cTn);
+		odp_context->current_slide().end_timing_par();
+	}
+	else if (oox_time_base->is<PPTX::Logic::Seq>()) //Sequence Time
+	{
+		PPTX::Logic::Seq & seq = oox_time_base->as<PPTX::Logic::Seq>();
+		odp_context->current_slide().start_timing_seq();
+			convert(&seq.cTn);
+		odp_context->current_slide().end_timing_seq();
+	}	
+}
+void PptxConverter::convert(PPTX::Logic::EmptyTransition *oox_transition)
+{
+	if (!oox_transition) return;
+	
+	if (oox_transition->name == L"random")
+		odp_context->current_slide().set_transition_type(40);
+	if (oox_transition->name == L"circle")
+	{
+		odp_context->current_slide().set_transition_type(16);
+		odp_context->current_slide().set_transition_subtype(L"circle");
+	}
+	if (oox_transition->name == L"dissolve")
+		odp_context->current_slide().set_transition_type(39);
+	if (oox_transition->name == L"diamond")
+	{
+		odp_context->current_slide().set_transition_type(11);
+		odp_context->current_slide().set_transition_subtype(L"diamond");
+	}
+	if (oox_transition->name == L"newsflash")
+		odp_context->current_slide().set_transition_type(24);
+	if (oox_transition->name == L"plus")
+	{
+		odp_context->current_slide().set_transition_type(19);
+		odp_context->current_slide().set_transition_subtype(L"fourPoint");
+	}
+	if (oox_transition->name == L"wedge")
+		odp_context->current_slide().set_transition_type(24);
+}
+void PptxConverter::convert(PPTX::Logic::OrientationTransition *oox_transition)
+{
+	if (!oox_transition) return;
+
+	if (oox_transition->name == L"comb")
+	{
+		odp_context->current_slide().set_transition_type(34);
+
+		if (oox_transition->dir.IsInit())
+		{
+			if (oox_transition->dir->get() == L"horz")
+				odp_context->current_slide().set_transition_subtype(L"combHorizontal");
+			if (oox_transition->dir->get() == L"vert")
+				odp_context->current_slide().set_transition_subtype(L"combVertical");
+		}
+	}
+	else
+	{
+		if (oox_transition->name == L"blinds")
+			odp_context->current_slide().set_transition_type(38);
+		else if (oox_transition->name == L"checker")
+			odp_context->current_slide().set_transition_type(37);
+		else if (oox_transition->name == L"randomBar")
+			odp_context->current_slide().set_transition_type(40);
+		
+		//if (oox_transition->dir.IsInit())
+		//{
+		//	if (oox_transition->dir->get() == L"horz")
+		//		odp_context->current_slide().set_transition_subtype(L"combHorizontal");
+		//	if (oox_transition->dir->get() == L"vert")
+		//		odp_context->current_slide().set_transition_subtype(L"combVertical");
+		//}
+	}
+}
+void PptxConverter::convert(PPTX::Logic::EightDirectionTransition	*oox_transition)
+{
+	if (!oox_transition) return;
+
+	if (oox_transition->name == L"cover")
+		odp_context->current_slide().set_transition_type(1);
+	if (oox_transition->name == L"pull")
+		odp_context->current_slide().set_transition_type(35);
+
+	if (oox_transition->dir.IsInit())
+	{
+			 if (oox_transition->dir->get() == L"d")	odp_context->current_slide().set_transition_subtype(L"fromTop");
+		else if (oox_transition->dir->get() == L"l")	odp_context->current_slide().set_transition_subtype(L"fromRight");
+		else if (oox_transition->dir->get() == L"r")	odp_context->current_slide().set_transition_subtype(L"fromLeft");
+		else if (oox_transition->dir->get() == L"u")	odp_context->current_slide().set_transition_subtype(L"fromBottom");
+
+		else if (oox_transition->dir->get() == L"rd")	odp_context->current_slide().set_transition_subtype(L"horizontalLeft");
+		else if (oox_transition->dir->get() == L"lu")	odp_context->current_slide().set_transition_subtype(L"horizontalRight");
+		else if (oox_transition->dir->get() == L"ld")	odp_context->current_slide().set_transition_subtype(L"verticalRight");
+		else if (oox_transition->dir->get() == L"ru")	odp_context->current_slide().set_transition_subtype(L"verticalLeft");
+	}
+}
+void PptxConverter::convert(PPTX::Logic::OptionalBlackTransition *oox_transition)
+{
+	if (!oox_transition) return;
+
+	if (oox_transition->name == L"cut")
+		odp_context->current_slide().set_transition_type(36);
+	if (oox_transition->name == L"fade")
+		odp_context->current_slide().set_transition_type(36);
+}
+void PptxConverter::convert(PPTX::Logic::SideDirectionTransition *oox_transition)
+{
+	if (!oox_transition) return;
+
+	if (oox_transition->name == L"push")
+		odp_context->current_slide().set_transition_type(34);
+	if (oox_transition->name == L"wipe")
+		odp_context->current_slide().set_transition_type(0);
+	
+	if (oox_transition->dir.IsInit())
+	{
+			 if (oox_transition->dir->get() == L"d")	odp_context->current_slide().set_transition_subtype(L"fromTop");
+		else if (oox_transition->dir->get() == L"l")	odp_context->current_slide().set_transition_subtype(L"fromRight");
+		else if (oox_transition->dir->get() == L"r")	odp_context->current_slide().set_transition_subtype(L"fromLeft");
+		else if (oox_transition->dir->get() == L"u")	odp_context->current_slide().set_transition_subtype(L"fromBottom");
+	}
+}
+void PptxConverter::convert(PPTX::Logic::CornerDirectionTransition	*oox_transition)
+{
+	if (!oox_transition) return;
+	//name == strips
+	odp_context->current_slide().set_transition_type(4);
+
+	if (oox_transition->dir.IsInit())
+	{
+			 if (oox_transition->dir->get() == L"rd") odp_context->current_slide().set_transition_subtype(L"horizontalLeft");
+		else if (oox_transition->dir->get() == L"lu") odp_context->current_slide().set_transition_subtype(L"horizontalRight");
+		else if (oox_transition->dir->get() == L"ld") odp_context->current_slide().set_transition_subtype(L"verticalRight");
+		else if (oox_transition->dir->get() == L"ru") odp_context->current_slide().set_transition_subtype(L"verticalLeft");
+	}
+}
+void PptxConverter::convert(PPTX::Logic::WheelTransition *oox_transition)
+{
+	if (!oox_transition) return;
+	//name == wheel
+	odp_context->current_slide().set_transition_type(22);
+
+	switch (oox_transition->spokes.get_value_or(0))
+	{
+	case 1: odp_context->current_slide().set_transition_subtype(L"oneBlade");	break;
+	case 3: odp_context->current_slide().set_transition_subtype(L"threeBlade");	break;
+	case 4: odp_context->current_slide().set_transition_subtype(L"fourBlade");	break;
+	case 8: odp_context->current_slide().set_transition_subtype(L"eightBlade");	break;
+	}
+}
+void PptxConverter::convert(PPTX::Logic::SplitTransition *oox_transition)
+{
+	if (!oox_transition) return;
+	//name == split
+	odp_context->current_slide().set_transition_type(8);
+}
+void PptxConverter::convert(PPTX::Logic::ZoomTransition *oox_transition)
+{
+	if (!oox_transition) return;
+	//name == zoom
+	odp_context->current_slide().set_transition_type(11);
+}
+
+void PptxConverter::convert(PPTX::Logic::CTn *oox_time_common)
+{
+	if (!oox_time_common) return;
+
+	if (oox_time_common->id.IsInit())
+	{
+		odp_context->current_slide().set_anim_id(*oox_time_common->id);
+	}
+	if (oox_time_common->nodeType.IsInit())
+	{
+		odp_context->current_slide().set_anim_type(oox_time_common->nodeType->get());
+	}
+	if (oox_time_common->dur.IsInit())
+	{
+		if (*oox_time_common->dur == L"indefinite")
+			odp_context->current_slide().set_anim_duration(-1);
+		else
+			odp_context->current_slide().set_anim_duration(XmlUtils::GetInteger(*oox_time_common->dur));
+	}
+	if (oox_time_common->restart.IsInit())
+	{
+		odp_context->current_slide().set_anim_restart(oox_time_common->restart->get());
+	}	
+
+	//nullable<CondLst>			stCondLst;
+	//nullable<CondLst>			endCondLst;
+	//nullable<Cond>			endSync;
+	//nullable<Iterate>			iterate;
+	if (oox_time_common->childTnLst.IsInit())
+	{
+		for (size_t i = 0; i < oox_time_common->childTnLst->list.size(); i++)
+		{
+			if (oox_time_common->childTnLst->list[i].is_init() == false) continue;
+
+			convert(&oox_time_common->childTnLst->list[i]);
+		}
+	}
+	//if (oox_time_common->subTnLst.IsInit())
+	//{
+	//	for (size_t i = 0; i < oox_time_common->subTnLst->list.size(); i++)
+	//	{
+	//		if (oox_time_common->subTnLst->list[i].is_init() == false) continue;
+
+	//		convert(&oox_time_common->subTnLst->list[i]);
+	//	}
+	//}
 }
 void PptxConverter::convert(PPTX::Logic::TableProperties *oox_table_pr)
 {
@@ -967,7 +1282,7 @@ void PptxConverter::convert(PPTX::Logic::Bg *oox_background)
 	odp_context->end_drawings();
 }
 
-void PptxConverter::convert_slide(PPTX::Logic::CSld *oox_slide, PPTX::Logic::TxStyles* txStyles, bool bPlaceholders, bool bFillUp)
+void PptxConverter::convert_slide(PPTX::Logic::CSld *oox_slide, PPTX::Logic::TxStyles* txStyles, bool bPlaceholders, bool bFillUp, int type)
 {
 	if (oox_slide == NULL) return;
 
@@ -979,8 +1294,6 @@ void PptxConverter::convert_slide(PPTX::Logic::CSld *oox_slide, PPTX::Logic::TxS
 
 	convert(oox_slide->bg.GetPointer());
 		
-	bool bMaster = *odf_context()->drawing_context()->get_presentation();
-
 	for (size_t i = 0 ; i < oox_slide->spTree.SpTreeElems.size(); i++)
 	{
 		smart_ptr<PPTX::WrapperWritingElement>	pElem = oox_slide->spTree.SpTreeElems[i].GetElem();
@@ -999,8 +1312,8 @@ void PptxConverter::convert_slide(PPTX::Logic::CSld *oox_slide, PPTX::Logic::TxS
 				{
 					int ph_type = pShape->nvSpPr.nvPr.ph->type->GetBYTECode();
 
-					//if (!bMaster && (ph_type == 5 || ph_type == 6 || ph_type == 7 || ph_type == 12))
-					//	continue;
+					if (type == 3 && (ph_type == 5 || ph_type == 6 || ph_type == 7 || ph_type == 12))
+						continue;
 
 					odf_context()->drawing_context()->set_placeholder_type(ph_type);
 				}

ASCOfficeOdfFileW/source/Oox2OdfConverter/PptxConverter.h

@@ -48,6 +48,7 @@ namespace PPTX
 {
 	class TableStyles;
 	class NotesSlide;
+	class NotesMaster;
 	class Presentation;
 	class Comments;
 	class Folder;
@@ -66,6 +67,17 @@ namespace PPTX
 		class TableCellProperties;
 		class TcBdr;
 		class TxStyles;
+		class TimeNodeBase;
+		class CTn;
+		class EmptyTransition;
+		class OrientationTransition;
+		class EightDirectionTransition;
+		class OptionalBlackTransition;
+		class CornerDirectionTransition;
+		class SideDirectionTransition;
+		class WheelTransition;
+		class SplitTransition;
+		class ZoomTransition;
 	}
 }
 
@@ -107,13 +119,17 @@ namespace Oox2Odf
 
 		void convert(OOX::WritingElement *oox_unknown);
  		
-		void convert_slide	(PPTX::Logic::CSld			*oox_slide, PPTX::Logic::TxStyles* txStyles, bool bPlaceholders, bool bFillUp);
+		void convert_slide	(PPTX::Logic::CSld			*oox_slide, PPTX::Logic::TxStyles* txStyles, bool bPlaceholders, bool bFillUp, int type);
 		void convert_layout	(PPTX::Logic::CSld			*oox_slide);
 		void convert		(PPTX::Comments				*oox_comments);
-		void convert		(PPTX::NotesSlide			*oox_note);
+		void convert		(PPTX::NotesSlide			*oox_notes);
+		void convert		(PPTX::NotesMaster			*oox_notes);
 
 		void convert(PPTX::Logic::Bg					*oox_background);
-		void convert(PPTX::Logic::Timing				*oox_timing, PPTX::Logic::Transition *oox_transition);
+		void convert(PPTX::Logic::Timing				*oox_timing);
+		void convert(PPTX::Logic::Transition			*oox_transition);
+		void convert(PPTX::Logic::TimeNodeBase			*oox_base_time);
+		void convert(PPTX::Logic::CTn					*oox_common_time);
 		
 		void convert(PPTX::Logic::Table					*oox_table);
 		void convert(PPTX::Logic::TableRow				*oox_table_row);
@@ -128,6 +144,16 @@ namespace Oox2Odf
 
 		void convert(PPTX::Logic::Ln *oox_ln_border, std::wstring & odf_border);
 private:
+		void convert(PPTX::Logic::EmptyTransition			*oox_transition);
+		void convert(PPTX::Logic::OrientationTransition		*oox_transition);
+		void convert(PPTX::Logic::EightDirectionTransition	*oox_transition);
+		void convert(PPTX::Logic::OptionalBlackTransition	*oox_transition);
+		void convert(PPTX::Logic::CornerDirectionTransition	*oox_transition);
+		void convert(PPTX::Logic::SideDirectionTransition	*oox_transition);
+		void convert(PPTX::Logic::WheelTransition			*oox_transition);
+		void convert(PPTX::Logic::SplitTransition			*oox_transition);
+		void convert(PPTX::Logic::ZoomTransition			*oox_transition);
+
 		PPTX::Folder									*pptx_document;
 		PPTX::Presentation								*presentation;
 		cpdoccore::odf_writer::package::odf_document	*output_document;

ASCOfficeOdfFileW/source/Oox2OdfConverter/XlsxConverter.cpp

@@ -115,30 +115,20 @@ smart_ptr<OOX::File> XlsxConverter::find_file_by_id(std::wstring sId)
 }
 std::wstring XlsxConverter::find_link_by_id (std::wstring sId, int type)
 {
-    std::wstring ref;
+    smart_ptr<OOX::File>	oFile;
+	std::wstring			ref;
 
-	if (type == 1)
+	if (xlsx_current_container)
 	{
-		if (ref.empty() && xlsx_current_container)
-		{
-			smart_ptr<OOX::File> oFile = xlsx_current_container->Find(sId);
-			if (oFile.IsInit() && OOX::FileTypes::Image == oFile->type())
-			{
-				OOX::Image* pImage = (OOX::Image*)oFile.operator->();
+		oFile	= xlsx_current_container->Find(sId);
+		ref		= OoxConverter::find_link_by(oFile, type);
+	}
+	if (!ref.empty()) return ref;
 
-				ref = pImage->filename().GetPath();
-			}
-		}
-        if (ref.empty() && oox_current_child_document)
-		{
-			smart_ptr<OOX::File> oFile = oox_current_child_document->Find(sId);
-			if (oFile.IsInit() && OOX::FileTypes::Image == oFile->type())
-			{
-				OOX::Image* pImage = (OOX::Image*)oFile.operator->();
-
-				ref = pImage->filename().GetPath();
-			}
-		}
+	if (oox_current_child_document)
+	{
+		oFile	= oox_current_child_document->Find(sId);
+		ref		= OoxConverter::find_link_by(oFile, type);
 	}
 	return ref;
 }

ASCOfficeOdfFileW/source/win32/OdfFormat.vcproj

@@ -401,6 +401,14 @@
 				RelativePath="..\OdfFormat\office_chart.h"
 				>
 			</File>
+			<File
+				RelativePath="..\OdfFormat\office_event_listeners.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\OdfFormat\office_event_listeners.h"
+				>
+			</File>
 			<File
 				RelativePath="..\OdfFormat\office_presentation.cpp"
 				>
@@ -409,6 +417,14 @@
 				RelativePath="..\OdfFormat\office_presentation.h"
 				>
 			</File>
+			<File
+				RelativePath="..\OdfFormat\office_scripts.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\OdfFormat\office_scripts.h"
+				>
+			</File>
 			<File
 				RelativePath="..\OdfFormat\office_settings.cpp"
 				>

ASCOfficeOdfFileW/source/win32/Oox2OdfConverter.vcproj

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="windows-1251"?>
 <VisualStudioProject
 	ProjectType="Visual C++"
-	Version="8,00"
+	Version="8.00"
 	Name="Oox2OdfConverter"
 	ProjectGUID="{BEE01B53-244A-44E6-8947-ED9342D9247E}"
 	RootNamespace="Oox2OdfConverter"

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/Converter.cpp

@@ -208,40 +208,48 @@ void NSPresentationEditor::CPPTXWriter::WriteContentTypes()
 <Override PartName=\"/docProps/core.xml\" ContentType=\"application/vnd.openxmlformats-package.core-properties+xml\" />\
 <Override PartName=\"/docProps/app.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.extended-properties+xml\" />");
 
-	int nThemes = (int)m_pDocument->m_arThemes.size();
-	int nIndexLayout = 0;
-	for (int nT = 0; nT < nThemes; ++nT)
+	int nIndexLayout = 1, nIndexTheme = 1;
+	
+	for (size_t nT = 0; nT < m_pDocument->m_arThemes.size(); nT++, nIndexTheme++)
 	{
-        strContentTypes += L"<Override PartName=\"/ppt/theme/theme" + std::to_wstring(nT + 1) +
-                L".xml\" ContentType=\"application/vnd.openxmlformats-officedocument.theme+xml\" />\
-<Override PartName=\"/ppt/slideMasters/slideMaster" + std::to_wstring(nT + 1) +
+        strContentTypes += L"<Override PartName=\"/ppt/theme/theme" + std::to_wstring(nIndexTheme) + \
+                L".xml\" ContentType=\"application/vnd.openxmlformats-officedocument.theme+xml\" />";
+		
+		strContentTypes += L"<Override PartName=\"/ppt/slideMasters/slideMaster" + std::to_wstring(nIndexTheme) + \
                 L".xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml\"/>";
 
 
-		int nCountL = (int)m_pDocument->m_arThemes[nT].m_arLayouts.size();
-		for (int nL = 0; nL < nCountL; ++nL, ++nIndexLayout)
+		for (size_t nL = 0; nL < m_pDocument->m_arThemes[nT].m_arLayouts.size(); nL++, nIndexLayout++)
 		{
-            strContentTypes += L"<Override PartName=\"/ppt/slideLayouts/slideLayout" + std::to_wstring(nIndexLayout + 1) +
+            strContentTypes += L"<Override PartName=\"/ppt/slideLayouts/slideLayout" + std::to_wstring(nIndexLayout) +
                 L".xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml\"/>";
 		}
 	}
-    std::wstring strNotesTheme = L"<Override PartName=\"/ppt/theme/theme" + std::to_wstring(nThemes + 1) + L".xml\" \
-ContentType=\"application/vnd.openxmlformats-officedocument.theme+xml\"/>";
 
+	if (m_pDocument->m_pNotesMaster)
+	{
+		strContentTypes += L"<Override PartName=\"/ppt/theme/theme" + std::to_wstring(nIndexTheme++) + L".xml\" \
+	ContentType=\"application/vnd.openxmlformats-officedocument.theme+xml\"/>";
+		strContentTypes += L"<Override PartName=\"/ppt/notesMasters/notesMaster1.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml\"/>";
+	}
+	if (m_pDocument->m_pHandoutMaster)
+	{
+		strContentTypes += L"<Override PartName=\"/ppt/theme/theme" + std::to_wstring(nIndexTheme++) + L".xml\" \
+	ContentType=\"application/vnd.openxmlformats-officedocument.theme+xml\"/>";
+		strContentTypes += L"<Override PartName=\"/ppt/handoutMasters/handoutMaster1.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml\"/>";
+	}
 
-	strContentTypes += strNotesTheme;
-	strContentTypes += _T("<Override PartName=\"/ppt/notesMasters/notesMaster1.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml\"/>");
-
-	int nCountS = (int)m_pDocument->m_arSlides.size();
-	for (int nS = 0; nS < nCountS; ++nS)
+	for (size_t nS = 0; nS < m_pDocument->m_arSlides.size(); ++nS)
 	{
         strContentTypes += L"<Override PartName=\"/ppt/slides/slide" + std::to_wstring( nS + 1)
                 + L".xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.slide+xml\"/>";
+	}
 
+	for (size_t nS = 0; nS < m_pDocument->m_arNotes.size(); ++nS)
+	{
         strContentTypes += L"<Override PartName=\"/ppt/notesSlides/notesSlide" + std::to_wstring( nS + 1)
                     + L".xml\" ContentType=\"application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml\"/>";
 	}
-
 	strContentTypes += _T("</Types>");
 
 	CFile oFile;
@@ -264,9 +272,9 @@ void NSPresentationEditor::CPPTXWriter::WriteApp(CFile& oFile)
 	oFile.WriteStringUTF8(str1);
 
     oFile.WriteStringUTF8(L"<Slides>" + std::to_wstring(m_pDocument->m_arSlides.size()) + L"</Slides>");
+    oFile.WriteStringUTF8(L"<Notes>" + std::to_wstring(m_pDocument->m_arNotes.size()) + L"</Notes>");
 
-    oFile.WriteStringUTF8(L"<Notes>0</Notes>\
-                          <HiddenSlides>0</HiddenSlides>\
+    oFile.WriteStringUTF8(L"<HiddenSlides>0</HiddenSlides>\
                           <MMClips>2</MMClips>\
                           <ScaleCrop>false</ScaleCrop>\
                           <HeadingPairs>\
@@ -301,7 +309,7 @@ void NSPresentationEditor::CPPTXWriter::WriteApp(CFile& oFile)
 <LinksUpToDate>false</LinksUpToDate>\
 <SharedDoc>false</SharedDoc>\
 <HyperlinksChanged>false</HyperlinksChanged>\
-<AppVersion>1.0000</AppVersion>\
+<AppVersion>4.4000</AppVersion>\
 </Properties>");
 
 	strMemory += str5;
@@ -344,12 +352,14 @@ void NSPresentationEditor::CPPTXWriter::WritePresInfo()
 	// presentation.xml + _rels/presentation.xml.rels
     std::wstring strPresRels;
 
-    std::wstring strPresMasters	= _T("");
-    std::wstring strPresSlides	= _T("");
+    std::wstring strPresMasters;
+    std::wstring strPresSlides;
+	std::wstring strNotesIDs;
+    std::wstring strHandoutIDs;
 
 	size_t nCountLayouts = 0;
-	size_t nCountThemes = m_pDocument->m_arThemes.size();
-	for (size_t nIndexTheme = 0; nIndexTheme < nCountThemes; ++nIndexTheme)
+
+	for (size_t nIndexTheme = 0; nIndexTheme < m_pDocument->m_arThemes.size(); ++nIndexTheme)
 	{
         strPresRels += L"<Relationship Id=\"rId" + std::to_wstring(2 * nIndexTheme + 1) +
                 L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster\" Target=\"slideMasters/slideMaster" +
@@ -365,9 +375,21 @@ void NSPresentationEditor::CPPTXWriter::WritePresInfo()
 		nCountLayouts += 1;
 	}
 
-	int nCurrentRels = (int)(2 * nCountThemes + 1);
-	size_t nCountSlides = m_pDocument->m_arSlides.size();
-	for (size_t nIndexSlide = 0; nIndexSlide < nCountSlides; ++nIndexSlide, ++nCurrentRels)
+	int nCurrentRels = (int)(2 * m_pDocument->m_arThemes.size() + 1);
+    	
+	if (m_pDocument->m_pNotesMaster)
+	{
+		strNotesIDs = L"<p:notesMasterIdLst><p:notesMasterId r:id=\"rId" + std::to_wstring(nCurrentRels) + L"\"/></p:notesMasterIdLst>";
+		strPresRels += L"<Relationship Id=\"rId" + std::to_wstring(nCurrentRels) + L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster\" Target=\"notesMasters/notesMaster1.xml\"/>";
+		++nCurrentRels;
+	}
+	if (m_pDocument->m_pHandoutMaster)
+	{
+		strHandoutIDs = L"<p:handoutMasterIdLst><p:handoutMasterId r:id=\"rId" + std::to_wstring(nCurrentRels) + L"\"/></p:handoutMasterIdLst>";
+		strPresRels += L"<Relationship Id=\"rId" + std::to_wstring(nCurrentRels) + L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/handoutMaster\" Target=\"handoutMasters/handoutMaster1.xml\"/>";
+		++nCurrentRels;
+	}	
+	for (size_t nIndexSlide = 0; nIndexSlide < m_pDocument->m_arSlides.size(); ++nIndexSlide, ++nCurrentRels)
 	{
         strPresRels += L"<Relationship Id=\"rId" + std::to_wstring(nCurrentRels) +
                        L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide\" Target=\"slides/slide" +
@@ -376,17 +398,12 @@ void NSPresentationEditor::CPPTXWriter::WritePresInfo()
         strPresSlides += L"<p:sldId id=\"" + std::to_wstring(256 + nIndexSlide) + L"\" r:id=\"rId" + std::to_wstring(nCurrentRels) + L"\"/>";
 	}
 
-    std::wstring strNotesIDs = L"<p:notesMasterIdLst><p:notesMasterId r:id=\"rId" + std::to_wstring(nCurrentRels) + L"\"/></p:notesMasterIdLst>";
+    strPresRels += L"<Relationship Id=\"rId" + std::to_wstring(nCurrentRels++) + L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/presProps\" Target=\"presProps.xml\"/>";
+    strPresRels += L"<Relationship Id=\"rId" + std::to_wstring(nCurrentRels++) + L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/tableStyles\" Target=\"tableStyles.xml\"/>";
+    strPresRels += L"<Relationship Id=\"rId" + std::to_wstring(nCurrentRels++) + L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/viewProps\" Target=\"viewProps.xml\"/>";
 
-    std::wstring strRels0 = L"<Relationship Id=\"rId" + std::to_wstring(nCurrentRels) + L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster\" Target=\"notesMasters/notesMaster1.xml\"/>";
-
-	++nCurrentRels;
-
-    std::wstring strRels1 = L"<Relationship Id=\"rId" + std::to_wstring(nCurrentRels++) + L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/presProps\" Target=\"presProps.xml\"/>";
-    std::wstring strRels2 = L"<Relationship Id=\"rId" + std::to_wstring(nCurrentRels++) + L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/tableStyles\" Target=\"tableStyles.xml\"/>";
-    std::wstring strRels3 = L"<Relationship Id=\"rId" + std::to_wstring(nCurrentRels++) + L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/viewProps\" Target=\"viewProps.xml\"/>";
-
-	strPresRels = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">") + strPresRels + strRels0 + strRels1 + strRels2 + strRels3 + _T("</Relationships>");
+	strPresRels = L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">" 
+		+ strPresRels + L"</Relationships>";
 
     std::wstring strPptRels = m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("_rels");
 
@@ -401,7 +418,8 @@ void NSPresentationEditor::CPPTXWriter::WritePresInfo()
             L"\" cy=\"" + std::to_wstring(m_pDocument->m_oInfo.m_lUnitsHor) + L"\"/>";
 
     std::wstring strDefaultTextStyle = _T("<p:defaultTextStyle>");
-    if (m_pDocument->m_arThemes.size() > 0)
+   
+	if (m_pDocument->m_arThemes.size() > 0)
 	{
 		strDefaultTextStyle += CStylesWriter::ConvertStyles(m_pDocument->m_arThemes[0].m_pStyles[0], m_pDocument->m_oInfo, 9);
 	}
@@ -416,6 +434,7 @@ void NSPresentationEditor::CPPTXWriter::WritePresInfo()
 		strPres += _T(">");
 		strPres += _T("<p:sldMasterIdLst>") + strPresMasters + _T("</p:sldMasterIdLst>");
 		strPres += strNotesIDs ;
+		strPres += strHandoutIDs ;
 		strPres +=_T("<p:sldIdLst>") + strPresSlides + _T("</p:sldIdLst>");
 		strPres += strSizePres;
 		strPres += strDefaultTextStyle;
@@ -437,79 +456,73 @@ void NSPresentationEditor::CPPTXWriter::WriteAll()
     NSDirectory::CreateDirectory(strPptDirectory + _T("slideLayouts"));
     NSDirectory::CreateDirectory(strPptDirectory + _T("slideLayouts")		+ FILE_SEPARATOR_STR + _T("_rels"));
     NSDirectory::CreateDirectory(strPptDirectory + _T("slides"));
-    NSDirectory::CreateDirectory(strPptDirectory + _T("slides")			+ FILE_SEPARATOR_STR + _T("_rels"));
-    NSDirectory::CreateDirectory(strPptDirectory + _T("notesMasters"));
-    NSDirectory::CreateDirectory(strPptDirectory + _T("notesMasters")		+ FILE_SEPARATOR_STR + _T("_rels"));
-    NSDirectory::CreateDirectory(strPptDirectory + _T("notesSlides"));
-    NSDirectory::CreateDirectory(strPptDirectory + _T("notesSlides")		+ FILE_SEPARATOR_STR + _T("_rels"));
-	
-    std::wstring strNotesTheme = L"theme" + std::to_wstring((int)m_pDocument->m_arThemes.size() + 1) + L".xml";
-	strNotesTheme = strPptDirectory + _T("theme") + FILE_SEPARATOR_STR + strNotesTheme;
-
-	Writers::DefaultNotesThemeWriter writerNotesTheme;
-	writerNotesTheme.Write( strNotesTheme);
-
-    std::wstring strNotesMaster	= strPptDirectory + _T("notesMasters") + FILE_SEPARATOR_STR + _T("notesMaster1.xml");
-	Writers::DefaultNotesMasterWriter writerNotesMaster;
-	writerNotesMaster.Write(strNotesMaster);
-
-    std::wstring strNotesMasterRels = strPptDirectory + _T("notesMasters") + FILE_SEPARATOR_STR +_T("_rels");
-    NSDirectory::CreateDirectory(strNotesMasterRels);
-
-    std::wstring strThemeNotesNum = std::to_wstring((int)m_pDocument->m_arThemes.size() + 1);
-	
-    std::wstring strVal = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
-<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
-<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme\" Target=\"../theme/theme") + strThemeNotesNum + _T(".xml\"/></Relationships>");
-	
-    std::wstring strNotesMasterRelsFile = strNotesMasterRels+ FILE_SEPARATOR_STR + _T("notesMaster1.xml.rels");
-	CFile oFileRels;
-	oFileRels.CreateFile(strNotesMasterRelsFile);
-	oFileRels.WriteStringUTF8(strVal);
-	oFileRels.CloseFile();
-	// -----------------------------------------------------
-
+    NSDirectory::CreateDirectory(strPptDirectory + _T("slides")				+ FILE_SEPARATOR_STR + _T("_rels"));
+    
+	if (m_pDocument->m_pHandoutMaster)
+	{
+		NSDirectory::CreateDirectory(strPptDirectory + _T("handoutMasters"));
+		NSDirectory::CreateDirectory(strPptDirectory + _T("handoutMasters")	+ FILE_SEPARATOR_STR + _T("_rels"));
+	}
+	if (m_pDocument->m_pNotesMaster)
+	{
+		NSDirectory::CreateDirectory(strPptDirectory + _T("notesMasters"));
+		NSDirectory::CreateDirectory(strPptDirectory + _T("notesMasters")	+ FILE_SEPARATOR_STR + _T("_rels"));
+	}
+	if (!m_pDocument->m_arNotes.empty())
+	{
+		NSDirectory::CreateDirectory(strPptDirectory + _T("notesSlides"));
+		NSDirectory::CreateDirectory(strPptDirectory + _T("notesSlides")	+ FILE_SEPARATOR_STR + _T("_rels"));
+	}
 	WriteThemes();
 	
 	WriteSlides();
+	WriteNotes();
 }
 
 void NSPresentationEditor::CPPTXWriter::WriteThemes()
 {
-    std::wstring strPptDirectory = m_strTempDirectory + FILE_SEPARATOR_STR  + _T("ppt") + FILE_SEPARATOR_STR ;
+	int nStartLayout = 0, nIndexTheme = 0;
 
-	int nCount = (int)m_pDocument->m_arThemes.size();
-	int nStartLayout = 0;
-
-	for (int nIndexTheme = 0; nIndexTheme < nCount; ++nIndexTheme)
+	for (size_t i = 0; i < m_pDocument->m_arThemes.size(); i++)
 	{
-		CTheme* pTheme = &m_pDocument->m_arThemes[nIndexTheme];
-		
-        std::wstring strThemeFile = L"theme" + std::to_wstring(nIndexTheme + 1) + L".xml";
-		strThemeFile = strPptDirectory + _T("theme") + FILE_SEPARATOR_STR + strThemeFile;
-		
-		CFile oFile;
-		oFile.CreateFile(strThemeFile);
+		WriteTheme(&m_pDocument->m_arThemes[i], nIndexTheme, nStartLayout, 1);
+	}
 
-		NSPresentationEditor::CStringWriter oStringWriter;
+	WriteTheme(m_pDocument->m_pNotesMaster, nIndexTheme, nStartLayout, 2);
+	WriteTheme(m_pDocument->m_pHandoutMaster, nIndexTheme, nStartLayout, 3);
+}
 
-		oStringWriter.WriteString(std::wstring(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><a:theme xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" name=\""));
-		oStringWriter.WriteStringXML(pTheme->m_sThemeName);
-		oStringWriter.WriteString(std::wstring(L"\"><a:themeElements>"));
+void NSPresentationEditor::CPPTXWriter::WriteTheme(CTheme* pTheme, int & nIndexTheme, int & nStartLayout, int Type)
+{		
+	if (!pTheme) return;
+
+	std::wstring strPptDirectory = m_strTempDirectory + FILE_SEPARATOR_STR  + _T("ppt") + FILE_SEPARATOR_STR ;
 	
-		WriteColorScheme(oStringWriter, L"Default", pTheme->m_arColorScheme);
+	std::wstring strThemeFile = L"theme" + std::to_wstring(nIndexTheme + 1) + L".xml";
+	strThemeFile = strPptDirectory + _T("theme") + FILE_SEPARATOR_STR + strThemeFile;
+	
+	CFile oFile;
+	oFile.CreateFile(strThemeFile);
 
-		oStringWriter.WriteString(std::wstring(L"<a:fontScheme name=\"default\"><a:majorFont><a:latin typeface=\""));
-		oStringWriter.WriteStringXML(pTheme->m_arFonts[0].Name);
-		oStringWriter.WriteString(std::wstring(L"\"/><a:ea typeface=\"\"/><a:cs typeface=\"\"/></a:majorFont>"));
+	NSPresentationEditor::CStringWriter oStringWriter;
 
-		oStringWriter.WriteString(std::wstring(L"<a:minorFont><a:latin typeface=\""));
-		
-		if (pTheme->m_arFonts.size() >1 )	oStringWriter.WriteString(pTheme->m_arFonts[1].Name);
-		else oStringWriter.WriteStringXML(pTheme->m_arFonts[0].Name);
+	oStringWriter.WriteString(std::wstring(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?><a:theme xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" name=\""));
+	oStringWriter.WriteStringXML(pTheme->m_sThemeName);
+	oStringWriter.WriteString(std::wstring(L"\"><a:themeElements>"));
 
-		oStringWriter.WriteString(std::wstring(L"\"/><a:ea typeface=\"\"/><a:cs typeface=\"\"/></a:minorFont>"));
-		oStringWriter.WriteString(std::wstring(L"</a:fontScheme>"));
+	WriteColorScheme(oStringWriter, L"Default", pTheme->m_arColorScheme);
+
+	oStringWriter.WriteString(std::wstring(L"<a:fontScheme name=\"default\"><a:majorFont><a:latin typeface=\""));
+	oStringWriter.WriteStringXML(pTheme->m_arFonts[0].Name);
+	oStringWriter.WriteString(std::wstring(L"\"/><a:ea typeface=\"\"/><a:cs typeface=\"\"/></a:majorFont>"));
+
+	oStringWriter.WriteString(std::wstring(L"<a:minorFont><a:latin typeface=\""));
+	
+	if (pTheme->m_arFonts.size() > 1 )	oStringWriter.WriteString	(pTheme->m_arFonts[1].Name);
+	else								oStringWriter.WriteStringXML(pTheme->m_arFonts[0].Name);
+
+	oStringWriter.WriteString(std::wstring(L"\"/><a:ea typeface=\"\"/><a:cs typeface=\"\"/></a:minorFont>"));
+	oStringWriter.WriteString(std::wstring(L"</a:fontScheme>"));
  
 		oStringWriter.WriteString(std::wstring(L"<a:fmtScheme name=\"Default\">\
 <a:fillStyleLst><a:solidFill><a:schemeClr val=\"phClr\"/></a:solidFill><a:gradFill rotWithShape=\"1\"><a:gsLst><a:gs pos=\"0\"><a:schemeClr val=\"phClr\">\
@@ -538,58 +551,67 @@ void NSPresentationEditor::CPPTXWriter::WriteThemes()
 <a:shade val=\"30000\"/><a:satMod val=\"200000\"/></a:schemeClr></a:gs></a:gsLst><a:path path=\"circle\">\
 <a:fillToRect l=\"50000\" t=\"50000\" r=\"50000\" b=\"50000\"/></a:path></a:gradFill></a:bgFillStyleLst></a:fmtScheme>"));
 
-		oStringWriter.WriteString(std::wstring(L"</a:themeElements><a:objectDefaults/>"));
-		oStringWriter.WriteString(std::wstring(L"<a:extraClrSchemeLst>"));
+	oStringWriter.WriteString(std::wstring(L"</a:themeElements><a:objectDefaults/>"));
+	oStringWriter.WriteString(std::wstring(L"<a:extraClrSchemeLst>"));
+	
+	for (size_t i = 0 ; i < pTheme->m_arExtraColorScheme.size(); i++)
+	{
+		std::wstring str = L" " + std::to_wstring(i + 1);
+		WriteColorScheme(oStringWriter, pTheme->m_sThemeName + str, pTheme->m_arExtraColorScheme[i], true); //extra
+	}
+	
+	oStringWriter.WriteString(std::wstring(L"</a:extraClrSchemeLst>"));
+	oStringWriter.WriteString(std::wstring(L"</a:theme>"));
+
+	oFile.WriteStringUTF8(oStringWriter.GetData());
+	oFile.CloseFile();
+
+	CRelsGenerator oRels(&m_oManager);
+	int nCountLayouts = (int)pTheme->m_arLayouts.size();
+	oRels.StartMaster(nIndexTheme, nStartLayout, nCountLayouts);
 		
-		for (int i = 0 ; i < pTheme->m_arExtraColorScheme.size(); i++)
-		{
-			std::wstring str = L" " + std::to_wstring(i + 1);
-			WriteColorScheme(oStringWriter, pTheme->m_sThemeName + str, pTheme->m_arExtraColorScheme[i], true); //extra
-		}
-		
-		oStringWriter.WriteString(std::wstring(L"</a:extraClrSchemeLst>"));
-		oStringWriter.WriteString(std::wstring(L"</a:theme>"));
+	CStringWriter oWriter;
+	oWriter.WriteString(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>");
+	
+	if (Type == 1)
+	{
+		oWriter.WriteString(L"<p:sldMaster xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\">");
+	}
+	else if (Type == 2)
+	{
+		oWriter.WriteString(L"<p:notesMaster xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\">");
+	}
+	else if (Type == 3)
+	{
+		oWriter.WriteString(L"<p:handoutMaster xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\">");
+	}
+	oWriter.WriteString(L"<p:cSld>");
 
-		oFile.WriteStringUTF8(oStringWriter.GetData());
-		oFile.CloseFile();
-
-	// теперь masterslide
-		CRelsGenerator oRels(&m_oManager);
-		int nCountLayouts = (int)pTheme->m_arLayouts.size();
-		
-		oRels.StartMaster(nIndexTheme, nStartLayout, nCountLayouts);
-
-		CStringWriter oWriter;
-        std::wstring str1 = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
-<p:sldMaster xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\">\
-<p:cSld>");
-		oWriter.WriteString(str1);
-
-		if (pTheme->m_bIsBackground)
-		{
-			WriteBackground(oWriter, oRels, pTheme->m_oBackground);
-		}
-        std::wstring strElems = _T("<p:spTree><p:nvGrpSpPr><p:cNvPr id=\"1\" name=\"\"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr>\
+	if (pTheme->m_bIsBackground)
+	{
+		WriteBackground(oWriter, oRels, pTheme->m_oBackground);
+	}
+    oWriter.WriteString(L"<p:spTree><p:nvGrpSpPr><p:cNvPr id=\"1\" name=\"\"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr>\
 <a:xfrm><a:off x=\"0\" y=\"0\"/><a:ext cx=\"0\" cy=\"0\"/><a:chOff x=\"0\" y=\"0\"/><a:chExt cx=\"0\" cy=\"0\"/></a:xfrm></p:grpSpPr>");
-		oWriter.WriteString(strElems);
 
-		size_t nElements = pTheme->m_arElements.size();
-		for (size_t nEl = 0; nEl < nElements; ++nEl)
-		{
-			if (isBodyPlaceholder(pTheme->m_arElements[nEl]->m_lPlaceholderType))
-				pTheme->m_arElements[nEl]->m_lPlaceholderType =100; //body тип прописывать !!
+	for (size_t nEl = 0; nEl < pTheme->m_arElements.size(); ++nEl)
+	{
+		if (isBodyPlaceholder(pTheme->m_arElements[nEl]->m_lPlaceholderType))
+			pTheme->m_arElements[nEl]->m_lPlaceholderType =100; //body тип прописывать !!
 
-			if (pTheme->m_arElements[nEl]->m_bBoundsEnabled == false)
-				continue;
-			
-			WriteElement(oWriter, oRels, pTheme->m_arElements[nEl]);
-		}
+		if (pTheme->m_arElements[nEl]->m_bBoundsEnabled == false)
+			continue;
+		
+		WriteElement(oWriter, oRels, pTheme->m_arElements[nEl]);
+	}
 
-		oWriter.WriteString(std::wstring(L"</p:spTree></p:cSld>"));
+	oWriter.WriteString(std::wstring(L"</p:spTree></p:cSld>"));
 
-        std::wstring strOverrideColorScheme = _T("<p:clrMap bg1=\"lt1\" tx1=\"dk1\" bg2=\"lt2\" tx2=\"dk2\" accent1=\"accent1\" accent2=\"accent2\" accent3=\"accent3\" accent4=\"accent4\" accent5=\"accent5\" accent6=\"accent6\" hlink=\"hlink\" folHlink=\"folHlink\"/>");
-		oWriter.WriteString(strOverrideColorScheme);
+    std::wstring strOverrideColorScheme = _T("<p:clrMap bg1=\"lt1\" tx1=\"dk1\" bg2=\"lt2\" tx2=\"dk2\" accent1=\"accent1\" accent2=\"accent2\" accent3=\"accent3\" accent4=\"accent4\" accent5=\"accent5\" accent6=\"accent6\" hlink=\"hlink\" folHlink=\"folHlink\"/>");
+	oWriter.WriteString(strOverrideColorScheme);
 
+	if (Type == 1)
+	{	
 		oWriter.WriteString(std::wstring(L"<p:sldLayoutIdLst>"));
 
 		size_t __nCountLayouts = 0;
@@ -601,17 +623,19 @@ void NSPresentationEditor::CPPTXWriter::WriteThemes()
 		}
 
 		oWriter.WriteString(std::wstring(L"</p:sldLayoutIdLst>"));
+	}
 
-		if (pTheme->m_bHasDate || pTheme->m_bHasFooter || pTheme->m_bHasSlideNumber)
-		{
-			oWriter.WriteString(std::wstring(L"<p:hf"));
-			if (!pTheme->m_bHasDate)		oWriter.WriteString(std::wstring(L" dt=\"0\""));
-			if (!pTheme->m_bHasSlideNumber) oWriter.WriteString(std::wstring(L" sldNum=\"0\""));
-											oWriter.WriteString(std::wstring(L" hdr=\"0\""));
-			if (!pTheme->m_bHasFooter)		oWriter.WriteString(std::wstring(L" ftr=\"0\""));
-			oWriter.WriteString(std::wstring(L"/>"));
-		}
-
+	if (pTheme->m_bHasDate || pTheme->m_bHasFooter || pTheme->m_bHasSlideNumber)
+	{
+		oWriter.WriteString(std::wstring(L"<p:hf"));
+		if (!pTheme->m_bHasDate)		oWriter.WriteString(std::wstring(L" dt=\"0\""));
+		if (!pTheme->m_bHasSlideNumber) oWriter.WriteString(std::wstring(L" sldNum=\"0\""));
+										oWriter.WriteString(std::wstring(L" hdr=\"0\""));
+		if (!pTheme->m_bHasFooter)		oWriter.WriteString(std::wstring(L" ftr=\"0\""));
+		oWriter.WriteString(std::wstring(L"/>"));
+	}
+	if (Type == 1)
+	{	
 		oWriter.WriteString(std::wstring(L"<p:txStyles>"));
 
 		oWriter.WriteString(std::wstring(L"<p:titleStyle>"));
@@ -626,25 +650,57 @@ void NSPresentationEditor::CPPTXWriter::WriteThemes()
 		CStylesWriter::ConvertStyles(pTheme->m_pStyles[3], pTheme->m_oInfo, oWriter, 9);
 		oWriter.WriteString(std::wstring(L"</p:otherStyle>"));
 		
-		oWriter.WriteString(std::wstring(L"</p:txStyles></p:sldMaster>"));
-
-        std::wstring strSlideMasterFile = L"slideMaster" + std::to_wstring(nIndexTheme + 1) + L".xml";
-		strSlideMasterFile = strPptDirectory + _T("slideMasters") + FILE_SEPARATOR_STR + strSlideMasterFile;
-
-		oFile.CreateFile(strSlideMasterFile);
-        std::wstring strMaster = oWriter.GetData();
-		oFile.WriteStringUTF8(strMaster);
-		oFile.CloseFile();
-
-		oRels.CloseRels();
-
-        std::wstring strSlideMasterRelsFile = L"slideMaster" + std::to_wstring(nIndexTheme + 1) + L".xml.rels";
-		strSlideMasterRelsFile = strPptDirectory + _T("slideMasters") + FILE_SEPARATOR_STR + _T("_rels") + FILE_SEPARATOR_STR + strSlideMasterRelsFile;
-
-		oRels.SaveRels(strSlideMasterRelsFile);				
-
-		nStartLayout += nCountLayouts;
+		oWriter.WriteString(std::wstring(L"</p:txStyles>"));
 	}
+	else if (Type == 2)
+	{	
+		oWriter.WriteString(std::wstring(L"<p:notesStyle>"));
+		CStylesWriter::ConvertStyles(pTheme->m_pStyles[1], pTheme->m_oInfo, oWriter, 9);
+		oWriter.WriteString(std::wstring(L"</p:notesStyle>"));
+	}
+
+	std::wstring strSlideMasterFile;
+	std::wstring strSlideMasterRelsFile;
+	if (Type == 1)
+	{
+		oWriter.WriteString(std::wstring(L"</p:sldMaster>"));
+		
+		strSlideMasterFile = L"slideMaster" + std::to_wstring(nIndexTheme + 1) + L".xml";
+		strSlideMasterFile = strPptDirectory + _T("slideMasters") + FILE_SEPARATOR_STR + strSlideMasterFile;
+		
+		strSlideMasterRelsFile = L"slideMaster" + std::to_wstring(nIndexTheme + 1) + L".xml.rels";
+		strSlideMasterRelsFile = strPptDirectory + _T("slideMasters") + FILE_SEPARATOR_STR + _T("_rels") + FILE_SEPARATOR_STR + strSlideMasterRelsFile;
+	}
+	else if (Type == 2)
+	{
+		oWriter.WriteString(std::wstring(L"</p:notesMaster>"));
+	
+		strSlideMasterFile = L"notesMaster1.xml";
+		strSlideMasterFile = strPptDirectory + _T("notesMasters") + FILE_SEPARATOR_STR + strSlideMasterFile;
+		
+		strSlideMasterRelsFile = L"notesMaster1.xml.rels";
+		strSlideMasterRelsFile = strPptDirectory + _T("notesMasters") + FILE_SEPARATOR_STR + _T("_rels") + FILE_SEPARATOR_STR + strSlideMasterRelsFile;
+	}
+	else if (Type == 3)
+	{
+		oWriter.WriteString(std::wstring(L"</p:handoutMaster>"));
+	
+		strSlideMasterFile = L"handoutMaster1.xml";
+		strSlideMasterFile = strPptDirectory + _T("handoutMasters") + FILE_SEPARATOR_STR + strSlideMasterFile;
+		
+		strSlideMasterRelsFile = L"handoutMaster1.xml.rels";
+		strSlideMasterRelsFile = strPptDirectory + _T("handoutMasters") + FILE_SEPARATOR_STR + _T("_rels") + FILE_SEPARATOR_STR + strSlideMasterRelsFile;
+	}
+	oFile.CreateFile(strSlideMasterFile);
+		std::wstring strMaster = oWriter.GetData();
+		oFile.WriteStringUTF8(strMaster);
+	oFile.CloseFile();
+
+	oRels.CloseRels();
+	oRels.SaveRels(strSlideMasterRelsFile);				
+
+	nStartLayout += nCountLayouts;
+	nIndexTheme++;
 }
 
 void NSPresentationEditor::CPPTXWriter::WriteColorScheme(CStringWriter& oStringWriter, const std::wstring & name, const std::vector<CColor> & colors, bool extra)
@@ -826,14 +882,14 @@ void NSPresentationEditor::CPPTXWriter::WriteSlide(int nIndexSlide)
 	CSlide* pSlide = m_pDocument->m_arSlides[nIndexSlide];
 	
 	if (0 == pSlide->m_lThemeID)
-		oRels.StartSlide(pSlide->m_lLayoutID, nIndexSlide);
+		oRels.StartSlide(pSlide->m_lLayoutID, pSlide->m_lNotesID);
 	else
 	{
 		int nLayout = pSlide->m_lLayoutID;
 		for (int i = 0; i < pSlide->m_lThemeID; ++i)
 			nLayout += (int)m_pDocument->m_arThemes[i].m_arLayouts.size();
 
-		oRels.StartSlide(nLayout, nIndexSlide);
+		oRels.StartSlide(nLayout, pSlide->m_lNotesID);
 	}
 
 	oWriter.WriteString(std::wstring(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"));
@@ -881,15 +937,66 @@ void NSPresentationEditor::CPPTXWriter::WriteSlide(int nIndexSlide)
     strFile = L"slide" + std::to_wstring(nIndexSlide + 1) + L".xml.rels";
 	oRels.SaveRels(strFileSlidePath + _T("_rels") + FILE_SEPARATOR_STR + strFile);
 }
+void NSPresentationEditor::CPPTXWriter::WriteNotes(int nIndexNotes)
+{
+	CStringWriter oWriter;
+	CRelsGenerator oRels(&m_oManager);
+	
+	CSlide* pNotes = m_pDocument->m_arNotes[nIndexNotes];
+	
+	oRels.StartNotes(pNotes->m_lSlideID, m_pDocument->m_pNotesMaster != NULL);
 
+	oWriter.WriteString(std::wstring(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"));
+	oWriter.WriteString(std::wstring(L"<p:notes xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\""));
+	if (!pNotes->m_bShowMasterShapes)
+		oWriter.WriteString(std::wstring(L" showMasterSp=\"0\""));
+	oWriter.WriteString(std::wstring(L">"));
+	
+	oWriter.WriteString(std::wstring(L"<p:cSld>"));
+
+	if (pNotes->m_bIsBackground)
+	{
+		WriteBackground(oWriter, oRels, pNotes->m_oBackground);
+	}
+
+	oWriter.WriteString(std::wstring(L"<p:spTree><p:nvGrpSpPr><p:cNvPr id=\"1\" name=\"\"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr>\
+<a:xfrm><a:off x=\"0\" y=\"0\"/><a:ext cx=\"0\" cy=\"0\"/><a:chOff x=\"0\" y=\"0\"/><a:chExt cx=\"0\" cy=\"0\"/></a:xfrm></p:grpSpPr>"));
+
+	for (size_t nEl = 0; nEl < pNotes->m_arElements.size(); ++nEl)
+	{
+		WriteElement(oWriter, oRels,  pNotes->m_arElements[nEl], NULL);
+	}
+	oWriter.WriteString(std::wstring(L"</p:spTree></p:cSld>"));
+
+	oWriter.WriteString(std::wstring(L"<p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>"));
+	oWriter.WriteString(std::wstring(L"</p:notes>"));
+
+	oRels.CloseRels();
+
+    std::wstring strXml = oWriter.GetData();
+    std::wstring strFile = L"notesSlide" + std::to_wstring(nIndexNotes + 1) + L".xml";
+    std::wstring strFileSlidePath = m_strTempDirectory + FILE_SEPARATOR_STR + _T("ppt") + FILE_SEPARATOR_STR + _T("notesSlides")  + FILE_SEPARATOR_STR;
+
+	CFile oFile;
+	oFile.CreateFile(strFileSlidePath + strFile);
+	oFile.WriteStringUTF8(strXml);
+	oFile.CloseFile();
+
+    strFile = L"notesSlide" + std::to_wstring(nIndexNotes + 1) + L".xml.rels";
+	oRels.SaveRels(strFileSlidePath + _T("_rels") + FILE_SEPARATOR_STR + strFile);
+}
 
 void NSPresentationEditor::CPPTXWriter::WriteSlides()
 {
-	size_t nCountSlides = m_pDocument->m_arSlides.size();
-
-	for (size_t nIndexS = 0; nIndexS < nCountSlides; ++nIndexS)
+	for (size_t nIndexS = 0; nIndexS < m_pDocument->m_arSlides.size(); ++nIndexS)
 	{
-		CRelsGenerator::StartNotes((int)nIndexS, m_strTempDirectory, m_pDocument->m_arSlides[nIndexS]->m_strComment);
 		WriteSlide((int)nIndexS);
 	}
 }
+void NSPresentationEditor::CPPTXWriter::WriteNotes()
+{
+	for (size_t nIndexS = 0; nIndexS < m_pDocument->m_arNotes.size(); ++nIndexS)
+	{
+		WriteNotes((int)nIndexS);
+	}
+}

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/Converter.h

@@ -54,8 +54,6 @@ namespace NSPresentationEditor
 
 		CShapeWriter*	m_pShapeWriter;
 
-
-	public:
 		CPPTXWriter();
 		~CPPTXWriter();
 
@@ -74,9 +72,12 @@ namespace NSPresentationEditor
 		void WritePresInfo		();
 		void WriteAll			();
 		void WriteThemes		();
+		void WriteTheme			(CTheme* pTheme, int & nIndexTheme, int & nStartLayout, int Type = 1);
 		void WriteSlides		();
+		void WriteNotes			();
 		void WriteLayout		(CLayout& oLayout, int nIndexLayout, int nStartLayout, int nIndexTheme);
 		void WriteSlide			(int nIndexSlide);
+		void WriteNotes			(int nIndexNotes);
 		
 		void WriteColorScheme	(CStringWriter& oWriter, const std::wstring & name, const std::vector<CColor> & colors, bool extra = false);
 		void WriteBackground	(CStringWriter& oWriter, CRelsGenerator& oRels, CBrush& oBackground);

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/ImageManager.h

@@ -170,12 +170,11 @@ namespace NSPresentationEditor
 
 			m_oWriter.WriteString(str1);
 
-			int nCurrent = nStartLayoutIndex;
 			for (int i = 0; i < nCountLayouts; ++i)
 			{
                 std::wstring str = L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) + L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout\" Target=\"../slideLayouts/slideLayout"
-                        + std::to_wstring(nCurrent + 1) + L".xml\"/>";
-				++nCurrent;
+                        + std::to_wstring(nStartLayoutIndex + 1) + L".xml\"/>";
+				nStartLayoutIndex++;
 				m_oWriter.WriteString(str);
 			}
 
@@ -196,7 +195,23 @@ namespace NSPresentationEditor
 
 			m_oWriter.WriteString(str);
 		}
-        inline void StartSlide(int nIndexLayout, int nIndexSlide)
+         inline void StartNotes(int nIndexSlide, bool bMaster)
+		{
+			m_oWriter.WriteString(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
+							<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
+			if (bMaster)
+			{
+				m_oWriter.WriteString(L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
+						L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster\" Target=\"../notesMasters/notesMaster1.xml\"/>");
+			}
+			if (nIndexSlide >= 0)
+			{
+				m_oWriter.WriteString(L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
+							L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide\" Target=\"../slides/slide"
+							+ std::to_wstring(nIndexSlide + 1) + L".xml\"/>");
+			}
+		}
+		 inline void StartSlide(int nIndexLayout, int nIndexNotes)
 		{
             m_oWriter.WriteString(L"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
                                   <Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
@@ -204,51 +219,14 @@ namespace NSPresentationEditor
             m_oWriter.WriteString(L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) + L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideLayout\" Target=\"../slideLayouts/slideLayout"
                                   + std::to_wstring(nIndexLayout + 1) + L".xml\"/>");
 
-            m_oWriter.WriteString(L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
-                                  L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide\" Target=\"../notesSlides/notesSlide"
-                                  + std::to_wstring(nIndexSlide + 1) + L".xml\"/>");
+			if (nIndexNotes >= 0)
+			{
+				m_oWriter.WriteString(L"<Relationship Id=\"rId" + std::to_wstring(m_lNextRelsID++) +
+									  L"\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide\" Target=\"../notesSlides/notesSlide"
+									  + std::to_wstring(nIndexNotes + 1) + L".xml\"/>");
+			}
 		}
-        static inline void StartNotes(int nIndexSlide, std::wstring strDirectory, std::wstring strComment)
-		{
-            std::wstring sNum = std::to_wstring( nIndexSlide + 1);
-
-            std::wstring strNoteSlideRels = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\
-<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\
-<Relationship Id=\"rId2\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide\" Target=\"../slides/slide") + sNum + _T(".xml\"/>\
-<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesMaster\" Target=\"../notesMasters/notesMaster1.xml\"/>\
-</Relationships>");
-
-            std::wstring strNoteRels = strDirectory	+ FILE_SEPARATOR_STR + _T("ppt") +
-												+ FILE_SEPARATOR_STR + _T("notesSlides")
-												+ FILE_SEPARATOR_STR + _T("_rels")
-												+ FILE_SEPARATOR_STR + _T("notesSlide") + sNum + _T(".xml.rels");
-			CFile oFile;
-			oFile.CreateFile(strNoteRels);
-			oFile.WriteStringUTF8(strNoteSlideRels);
-			oFile.CloseFile();
-
-            std::wstring strNoteSlide = strDirectory + FILE_SEPARATOR_STR + _T("ppt") +
-												+ FILE_SEPARATOR_STR + _T("notesSlides")
-												+ FILE_SEPARATOR_STR + _T("notesSlide") + sNum + _T(".xml");
-			oFile.CreateFile(strNoteSlide);
-
-            std::wstring strW1 = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\
-<p:notes xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\">\
-<p:cSld><p:spTree><p:nvGrpSpPr><p:cNvPr id=\"1\" name=\"\"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x=\"0\" y=\"0\"/>\
-<a:ext cx=\"0\" cy=\"0\"/><a:chOff x=\"0\" y=\"0\"/><a:chExt cx=\"0\" cy=\"0\"/></a:xfrm></p:grpSpPr><p:sp><p:nvSpPr><p:cNvPr id=\"100000\" name=\"\"/>\
-<p:cNvSpPr><a:spLocks noGrp=\"1\" noChangeArrowheads=\"1\"/></p:cNvSpPr><p:nvPr><p:ph type=\"body\" idx=\"1\"/></p:nvPr></p:nvSpPr><p:spPr/>\
-<p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:r><a:rPr smtClean=\"0\"/><a:t>");
-            std::wstring strW2 = _T("</a:t></a:r><a:endParaRPr/></a:p></p:txBody></p:sp></p:spTree></p:cSld><p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr></p:notes>");
-
-			CorrectXmlString(strComment);
-
-			oFile.WriteStringUTF8(strW1);
-			oFile.WriteStringUTF8(strComment);
-			oFile.WriteStringUTF8(strW2);
-
-			oFile.CloseFile();
-		}
-        inline void CloseRels()
+         inline void CloseRels()
 		{
             std::wstring str = _T("</Relationships>");
 			m_oWriter.WriteString(str);

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/ShapeWriter.cpp

@@ -68,9 +68,6 @@ void CStylesWriter::ConvertStyleLevel(NSPresentationEditor::CTextStyleLevel& oLe
 	{
 		std::wstring strProp = std::to_wstring(pPF->leftMargin.get());
 		oWriter.WriteString(L" marL=\"" + strProp + L"\"");
-
-		if (pPF->indent.is_init() == false)
-            pPF->indent = (LONG)0;
 	}
 	if (pPF->indent.is_init())
 	{
@@ -296,21 +293,79 @@ NSPresentationEditor::CShapeWriter::CShapeWriter()
 	m_pImageElement = NULL;
 	m_pShapeElement = NULL;
 }
-std::wstring	NSPresentationEditor::CShapeWriter::ConvertLine(CPen & pen)
+std::wstring NSPresentationEditor::CShapeWriter::ConvertLine(CPen & pen)
 {
 	NSPresentationEditor::CStringWriter line_writer;
 
-	std::wstring str = std::to_wstring(	(int)(pen.Size * 36000));
-	line_writer.WriteString(L"<a:ln w=\"" + str + L"\">");
+	std::wstring strL;
+	switch(pen.LineStyle)
+	{
+		case 1: strL = L"  cmpd=\"dbl\"";		break;
+		case 2: strL = L"  cmpd=\"thickThin\""; break;
+		case 3: strL = L"  cmpd=\"thinThick\"";	break;
+		case 4: strL = L"  cmpd=\"tri\"";		break;
+	}
+	line_writer.WriteString(L"<a:ln w=\"" + std::to_wstring((int)(pen.Size * 36000)) + L"\"" + strL + L">");
 
 	line_writer.WriteString(L"<a:solidFill>");
 		line_writer.WriteString(ConvertColor(pen.Color, pen.Alpha));
 	line_writer.WriteString(L"</a:solidFill>");
 
-	line_writer.WriteString(L"<a:round/><a:headEnd/><a:tailEnd/></a:ln>");
+	switch(pen.DashStyle)
+	{
+		case 1:	line_writer.WriteString(L"<a:prstDash val=\"sysDash\"/>");			break;
+		case 2:	line_writer.WriteString(L"<a:prstDash val=\"sysDot\"/>");			break;
+		case 3:	line_writer.WriteString(L"<a:prstDash val=\"sysDashDot\"/>");		break;
+		case 4:	line_writer.WriteString(L"<a:prstDash val=\"sysDashDotDot\"/>");	break;
+		case 5:	line_writer.WriteString(L"<a:prstDash val=\"dot\"/>");				break;
+		case 6:	line_writer.WriteString(L"<a:prstDash val=\"dash\"/>");				break;
+		case 7:	line_writer.WriteString(L"<a:prstDash val=\"lgDash\"/>");			break;
+		case 8:	line_writer.WriteString(L"<a:prstDash val=\"dashDot\"/>");			break;
+		case 9:	line_writer.WriteString(L"<a:prstDash val=\"lgDashDot\"/>");		break;
+		case 10:line_writer.WriteString(L"<a:prstDash val=\"lgDashDotDot\"/>");		break;
+	}
+	switch(pen.LineJoin)
+	{
+		case 0:	line_writer.WriteString(L"<a:bevel/>");	break;
+		case 1:	line_writer.WriteString(L"<a:miter/>");	break;
+		case 2:	line_writer.WriteString(L"<a:round/>");	break;
+	}
+
+	line_writer.WriteString(L"<a:headEnd" + ConvertLineEnd(pen.LineStartCap, pen.LineStartLength, pen.LineStartWidth)	+ L"/>");
+	line_writer.WriteString(L"<a:tailEnd" + ConvertLineEnd(pen.LineEndCap, pen.LineEndLength, pen.LineEndWidth)			+ L"/>");
+		
+	line_writer.WriteString(L"</a:ln>");
 
 	return line_writer.GetData();
 }
+std::wstring NSPresentationEditor::CShapeWriter::ConvertLineEnd(unsigned char cap, unsigned char length, unsigned char width)
+{
+	if (cap < 1) return L"";
+
+	std::wstring sResult;
+
+	switch(cap)
+	{
+		case 1: sResult += L" type=\"triangle\"";	break;
+		case 2: sResult += L" type=\"stealth\"";	break;
+		case 3: sResult += L" type=\"diamond\"";	break;
+		case 4: sResult += L" type=\"oval\"";		break;
+		case 5: sResult += L" type=\"arrow\"";		break;
+	}
+	switch(length)
+	{
+		case 0: sResult += L" len=\"sm\"";	break;
+		case 1: sResult += L" len=\"med\"";	break;
+		case 2: sResult += L" len=\"lg\"";	break;
+	}
+	switch(width)
+	{
+		case 0: sResult += L" w=\"sm\"";	break;
+		case 1: sResult += L" w=\"med\"";	break;
+		case 2: sResult += L" w=\"lg\"";	break;
+	}
+	return sResult;
+}
 std::wstring	NSPresentationEditor::CShapeWriter::ConvertBrush(CBrush & brush)
 {
 	NSPresentationEditor::CStringWriter brush_writer;
@@ -798,11 +853,7 @@ void NSPresentationEditor::CShapeWriter::WriteTextInfo()
 		if (pPF->leftMargin.is_init())
 		{
             std::wstring strProp = std::to_wstring( pPF->leftMargin.get() );
-			m_oWriter.WriteString(L" marL=\"" + strProp + L"\"");
-			
-			if (pPF->indent.is_init() == false)
-				pPF->indent = (LONG)0;
-
+			m_oWriter.WriteString(L" marL=\"" + strProp + L"\"");			
 		}
 		if (pPF->indent.is_init())
 		{
@@ -1175,7 +1226,8 @@ std::wstring NSPresentationEditor::CShapeWriter::ConvertShape()
 			}
 		m_oWriter.WriteString(std::wstring(L">"));
 
-        m_oWriter.WriteString(L"<a:off x=\"" + std::to_wstring((int)m_pShapeElement->m_rcBoundsOriginal.left) + L"\" y=\"" + std::to_wstring((int)m_pShapeElement->m_rcBoundsOriginal.top) + L"\"/>");
+        m_oWriter.WriteString(L"<a:off x=\"" + std::to_wstring((int)m_pShapeElement->m_rcBoundsOriginal.left) + 
+								L"\" y=\"" + std::to_wstring((int)m_pShapeElement->m_rcBoundsOriginal.top) + L"\"/>");
 
 		int width	= m_pShapeElement->m_rcBoundsOriginal.right - m_pShapeElement->m_rcBoundsOriginal.left;
 		int height	= m_pShapeElement->m_rcBoundsOriginal.bottom - m_pShapeElement->m_rcBoundsOriginal.top;

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/ShapeWriter.h

@@ -213,6 +213,7 @@ namespace NSPresentationEditor
             std::wstring	ConvertShadow	(CShadow	& shadow);
             std::wstring	ConvertBrush	(CBrush		& brush);
     static	std::wstring	ConvertColor	(CColor		& color, long alpha);
+			std::wstring ConvertLineEnd(unsigned char cap, unsigned char length, unsigned char width);
 // тип рендерера-----------------------------------------------------------------------------
     virtual HRESULT get_Type(LONG* lType)	;
 //-------- Функции для работы со страницей --------------------------------------------------

ASCOfficePPTFile/PPTFormatLib/Reader/PPTDocumentInfoOneUser.cpp

@@ -52,8 +52,11 @@ CPPTUserInfo::CPPTUserInfo() :	CDocument(),
 	m_pDocumentInfo			= NULL;
 	m_lIndexThisUser		= -1;
 
-	m_nWriteSlideTimeOffset		=	0.0;
-	m_nWriteSlideTime			=	0.0;
+	m_pNotesMasterWrapper	= NULL;
+	m_pHandoutMasterWrapper	= NULL;
+	
+	m_nWriteSlideTimeOffset	=	0.0;
+	m_nWriteSlideTime		=	0.0;
 
 	m_strFileDirectory		= _T("");
     m_bIsSetupEmpty			= false;
@@ -90,6 +93,21 @@ void CPPTUserInfo::Clear()
 	m_mapMasters.clear();
 	m_arrMastersOrder.clear();
 
+	for (std::map<DWORD, CRecordSlide*>::iterator pPair = m_mapNotesMasters.begin(); pPair != m_mapNotesMasters.end(); ++pPair)
+	{
+		RELEASEINTERFACE(pPair->second);
+	}
+	m_mapNotesMasters.clear();
+
+	for (std::map<DWORD, CRecordSlide*>::iterator pPair = m_mapHandoutMasters.begin(); pPair != m_mapHandoutMasters.end(); ++pPair)
+	{
+		RELEASEINTERFACE(pPair->second);
+	}
+	m_mapHandoutMasters.clear();
+
+	RELEASEOBJECT(m_pNotesMasterWrapper);
+	RELEASEOBJECT(m_pHandoutMasterWrapper);
+
 	for (std::map<DWORD, CRecordSlide*>::iterator pPair = m_mapNotes.begin(); pPair != m_mapNotes.end(); ++pPair)
 	{
 		RELEASEINTERFACE(pPair->second);
@@ -97,11 +115,10 @@ void CPPTUserInfo::Clear()
 	m_mapNotes.clear();
 	m_arrNotesOrder.clear();
 
-
 	m_oExMedia.Clear();
 	m_arrFonts.clear();
 
-	for (int nIndex = 0; nIndex < m_mapAnimations.size(); ++nIndex)
+	for (size_t nIndex = 0; nIndex < m_mapAnimations.size(); ++nIndex)
 	{
 		RELEASEOBJECT ( m_mapAnimations[nIndex]);
 	}
@@ -148,13 +165,15 @@ bool CPPTUserInfo::ReadFromStream(CRecordUserEditAtom* pUser, POLE::Stream* pStr
 
 	Clear();
 
+	std::map<DWORD, DWORD>::iterator nIndexPsrRef;
+
 	for (size_t index = 0; index < m_oDocument.m_arMasterPersists.size(); ++index)
 	{
-		std::map<DWORD, DWORD>::iterator nPsrRef = m_mapOffsetInPIDs.find(m_oDocument.m_arMasterPersists[index].m_nPsrRef);
+		nIndexPsrRef = m_mapOffsetInPIDs.find(m_oDocument.m_arMasterPersists[index].m_nPsrRef);
 		
-		if (nPsrRef != m_mapOffsetInPIDs.end())
+		if (nIndexPsrRef != m_mapOffsetInPIDs.end())
 		{
-			long offset = (long)nPsrRef->second;
+			long offset = (long)nIndexPsrRef->second;
 
 			StreamUtils::StreamSeek(offset, pStream);
 
@@ -173,10 +192,9 @@ bool CPPTUserInfo::ReadFromStream(CRecordUserEditAtom* pUser, POLE::Stream* pStr
 		}
 		m_arrMastersOrder.push_back(m_oDocument.m_arMasterPersists[index].m_nSlideID);
 	}
-
 	for (size_t index = 0; index < m_oDocument.m_arNotePersists.size(); ++index)
 	{
-		std::map<DWORD, DWORD>::iterator nIndexPsrRef = m_mapOffsetInPIDs.find(m_oDocument.m_arNotePersists[index].m_nPsrRef);
+		nIndexPsrRef = m_mapOffsetInPIDs.find(m_oDocument.m_arNotePersists[index].m_nPsrRef);
 		
 		if (m_mapOffsetInPIDs.end() != nIndexPsrRef)
 		{
@@ -201,7 +219,7 @@ bool CPPTUserInfo::ReadFromStream(CRecordUserEditAtom* pUser, POLE::Stream* pStr
 
 	for (size_t index = 0; index < m_oDocument.m_arSlidePersists.size(); ++index)
 	{
-		std::map<DWORD, DWORD>::iterator nIndexPsrRef = m_mapOffsetInPIDs.find(m_oDocument.m_arSlidePersists[index].m_nPsrRef);
+		nIndexPsrRef = m_mapOffsetInPIDs.find(m_oDocument.m_arSlidePersists[index].m_nPsrRef);
 		
 		if (m_mapOffsetInPIDs.end() != nIndexPsrRef)
 		{
@@ -239,7 +257,47 @@ bool CPPTUserInfo::ReadFromStream(CRecordUserEditAtom* pUser, POLE::Stream* pStr
 		}
 		m_arrSlidesOrder.push_back(m_oDocument.m_arSlidePersists[index].m_nSlideID);
 	}
+	std::vector<CRecordDocumentAtom*> oArrayDoc;
+	m_oDocument.GetRecordsByType(&oArrayDoc, true, true);
 
+	if (!oArrayDoc.empty())
+	{
+		nIndexPsrRef = m_mapOffsetInPIDs.find(oArrayDoc[0]->m_nNotesMasterPersistIDRef);
+		
+		if (m_mapOffsetInPIDs.end() != nIndexPsrRef)
+		{
+			long offset = (long)nIndexPsrRef->second;
+			
+			StreamUtils::StreamSeek(offset, pStream);
+
+			oHeader.ReadFromStream(pStream);
+
+			CRecordSlide* pSlide = new CRecordSlide();
+			pSlide->ReadFromStream(oHeader, pStream);
+			pSlide->m_oPersist.m_nPsrRef = oArrayDoc[0]->m_nNotesMasterPersistIDRef;
+			pSlide->m_Index		= 0;			
+			
+			m_mapNotesMasters.insert( std::pair<DWORD, CRecordSlide*>(0, pSlide ));		
+		}
+		nIndexPsrRef = m_mapOffsetInPIDs.find(oArrayDoc[0]->m_nHandoutMasterPersistIDRef);
+		
+		if (m_mapOffsetInPIDs.end() != nIndexPsrRef)
+		{
+			long offset = (long)nIndexPsrRef->second;
+			
+			StreamUtils::StreamSeek(offset, pStream);
+
+			oHeader.ReadFromStream(pStream);
+
+			CRecordSlide* pSlide = new CRecordSlide();
+			pSlide->ReadFromStream(oHeader, pStream);
+			pSlide->m_oPersist.m_nPsrRef = oArrayDoc[0]->m_nHandoutMasterPersistIDRef;
+			pSlide->m_Index		= 0;			
+			
+			m_mapHandoutMasters.insert( std::pair<DWORD, CRecordSlide*>(0, pSlide ));		
+		}
+	}
+//--------------------------------------------------------------------------------------------
 	// так... теперь берем всю инфу о ExObject -----------------------------
 	m_oExMedia.m_strPresentationDirectory	= strFolderMem;
 	m_oExMedia.m_strSourceDirectory			= m_strFileDirectory;
@@ -271,7 +329,7 @@ bool CPPTUserInfo::ReadFromStream(CRecordUserEditAtom* pUser, POLE::Stream* pStr
 	std::vector<CRecordFontEntityAtom*> oArrayFonts;
 	m_oDocument.GetRecordsByType(&oArrayFonts, true);
 
-	for (int nIndex = 0; nIndex < oArrayFonts.size(); ++nIndex)
+	for (size_t nIndex = 0; nIndex < oArrayFonts.size(); ++nIndex)
 	{
 		CFont oFont;
 		oFont.Name = oArrayFonts[nIndex]->m_strFaceName;
@@ -371,7 +429,7 @@ void CPPTUserInfo::FromDocument()
 	double DurationSlide	=	PPT_DEFAULT_SLIDE_DURATION;
 
 	m_arSlides.reserve(m_arrSlidesOrder.size());
-	for (int i=0; i< m_arrSlidesOrder.size(); i++)
+	for (size_t i = 0; i < m_arrSlidesOrder.size(); i++)
 	{
 		std::map<DWORD, CRecordSlide*>::iterator pPair = m_mapSlides.find(m_arrSlidesOrder[i]);
 		
@@ -382,12 +440,10 @@ void CPPTUserInfo::FromDocument()
 
 		DurationSlide	=	PPT_DEFAULT_SLIDE_DURATION;
 
-		CSlide *elm = new CSlide();
-		m_arSlides.push_back(elm);
-		// тут его заполняем...
+		m_arSlides.push_back(new CSlide());
 
 		// если на слайде есть анимации
-		std::map <DWORD, Animations::CSlideTimeLine*>::iterator pTimeLine		=	m_mapAnimations.find( pPair->first);
+		std::map <DWORD, Animations::CSlideTimeLine*>::iterator pTimeLine =	m_mapAnimations.find( pPair->first);
 
 		if ( m_mapAnimations.end() != pTimeLine )
 		{
@@ -409,12 +465,196 @@ void CPPTUserInfo::FromDocument()
 		pSlide->m_lWidth			= (LONG)(c_dMasterUnitsToMillimetreKoef * lOriginWidth);
 		pSlide->m_lHeight			= (LONG)(c_dMasterUnitsToMillimetreKoef * lOriginHeight);
 
-		LoadSlide ( pPair->first, m_arSlides.back());
+		LoadSlide ( pPair->first, pSlide);
 	}
 
+	m_arNotes.reserve(m_arrNotesOrder.size());
+	for (size_t i = 0; i< m_arrNotesOrder.size(); i++)
+	{
+		std::map<DWORD, CRecordSlide*>::iterator pPair = m_mapNotes.find(m_arrNotesOrder[i]);
+		
+		if (pPair ==  m_mapNotes.end()) 
+			continue;
+
+		LoadNotesFromPrevUsers	( pPair->first );
+
+		DurationSlide	=	PPT_DEFAULT_SLIDE_DURATION;
+
+		m_arNotes.push_back(new CSlide());
+
+		CSlide* pSlide = m_arNotes.back();
+
+		pSlide->m_lOriginalWidth	= lOriginWidth;
+		pSlide->m_lOriginalHeight	= lOriginHeight;
+
+		pSlide->m_lWidth			= (LONG)(c_dMasterUnitsToMillimetreKoef * lOriginWidth);
+		pSlide->m_lHeight			= (LONG)(c_dMasterUnitsToMillimetreKoef * lOriginHeight);
+
+		LoadNotes ( pPair->first, pSlide);
+	}
+	
 	CalculateEditor(m_oInfo);
 }
 
+void CPPTUserInfo::LoadNotes(DWORD dwNoteID, CSlide* pNotes)
+{
+	std::map<DWORD, CRecordSlide*>::iterator pPairNotes = m_mapNotes.find(dwNoteID);
+
+	if (pPairNotes == m_mapNotes.end()) return;
+	
+	CRecordSlide* pRecordSlide = pPairNotes->second;
+
+	if (NULL == pRecordSlide) return;
+
+	pNotes->m_bUseLayoutColorScheme = true;
+
+	CSlideInfo slide_info;
+	m_arNotesWrapper.push_back(slide_info);
+	
+	CSlideInfo* pNotesWrapper = &m_arNotesWrapper.back();
+
+	int indexUser						= pRecordSlide->m_IndexUser;
+
+	pNotesWrapper->m_parEmptyPictures	= &m_pDocumentInfo->m_arUsers[indexUser]->m_arOffsetPictures;
+	pNotesWrapper->m_mapFilePictures	= &m_pDocumentInfo->m_mapStoreImageFile;
+
+	//грузим placeholder
+	pNotesWrapper->m_arTextPlaceHolders = pRecordSlide->m_oPersist.m_arTextAttrs;
+
+	std::vector<CRecordNotesAtom*> oArrayNotesAtoms;
+	pRecordSlide->GetRecordsByType(&oArrayNotesAtoms, false, true);
+	if (0 == oArrayNotesAtoms.size())
+	{
+		// ошибка!!!
+		return;
+	}
+    bool bMasterColorScheme = oArrayNotesAtoms[0]->m_bMasterScheme;
+    bool bMasterBackGround	= oArrayNotesAtoms[0]->m_bMasterBackground;
+    bool bMasterObjects		= oArrayNotesAtoms[0]->m_bMasterObjects;
+
+	std::map<DWORD, CRecordSlide*>::iterator pPairSlide = m_mapSlides.find(oArrayNotesAtoms[0]->m_nSlideIDRef);
+
+	if (pPairSlide == m_mapSlides.end())
+	{
+		//????? у заметок нет слайда !!!
+	}
+//-----------------------------------------------------
+	CSlide* pSlide		= m_arSlides[pPairSlide->second->m_Index];
+
+	pNotes->m_lSlideID	= pPairSlide->second->m_Index;
+	pSlide->m_lNotesID	= m_arNotes.size() - 1;
+//-----------------------------------------------------
+
+	CTheme		* pTheme		= m_pNotesMaster;
+	CSlideInfo	* pThemeWrapper	= m_pNotesMasterWrapper;
+
+	CLayout* pLayout	= NULL;
+//-----------------------------------------------------
+	std::vector<NSPresentationEditor::CColor>* pArrayColorScheme = pTheme ? &pTheme->m_arColorScheme : NULL;
+
+// читаем цветовую схему -----------------------------------------------------------
+	pNotes->m_bUseLayoutColorScheme = true;
+	if (!bMasterColorScheme)
+	{
+		std::vector<CRecordColorSchemeAtom*> oArrayColors;
+		pRecordSlide->GetRecordsByType(&oArrayColors, false);
+
+		for (size_t i = 0; i < oArrayColors.size(); ++i)
+		{
+			if (0x01 == oArrayColors[i]->m_oHeader.RecInstance)
+			{
+				pNotes->m_bUseLayoutColorScheme = false;
+				oArrayColors[i]->ToArray(&pNotes->m_arColorScheme);
+				CorrectColorScheme(pNotes->m_arColorScheme);
+
+				// проверим на совпадение
+				size_t nCountC = pNotes->m_arColorScheme.size();
+				size_t nIndexC = 0;
+				if (pArrayColorScheme && nCountC == pArrayColorScheme->size())
+				{
+					for (; nIndexC < nCountC; ++nIndexC)
+					{
+						if (pNotes->m_arColorScheme[i].IsEqual(pArrayColorScheme->at(i)))
+							break;
+					}
+				}
+
+				if (nIndexC == nCountC)
+				{
+					pNotes->m_bUseLayoutColorScheme = true;
+					pNotes->m_arColorScheme.clear();
+				}
+
+				break;
+			}
+		}
+	}
+//------------------------------------------------------------------------------------
+	bool	bHasDate		= false;
+	bool	bHasSlideNumber = false;
+	bool	bHasFooter		= false;
+	int		nFormatDate		= 1;	
+	
+	std::vector<CRecordHeadersFootersContainer*> oArrayHeadersFootersInfo;
+	pRecordSlide->GetRecordsByType(&oArrayHeadersFootersInfo, true, false);
+
+	if (!oArrayHeadersFootersInfo.empty())
+	{
+		if (oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom)
+		{
+			bHasDate		=	oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasDate ||
+								oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasTodayDate || 
+								oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasUserDate;
+			bHasFooter		=	oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasFooter;
+			bHasSlideNumber	=	oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasSlideNumber;
+
+			if (oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasUserDate)	nFormatDate = 2;
+		}
+		for (int i = 0 ; i < 3; i++) 
+			pNotes->m_PlaceholdersReplaceString[i] = oArrayHeadersFootersInfo[0]->m_HeadersFootersString[i];
+	}
+//------------- читаем все элементы ------------------------------------------------------------------------------------------
+	pNotes->m_bIsBackground		= false;
+	
+	std::vector<CRecordShapeContainer*> oArrayShapes;
+	pRecordSlide->GetRecordsByType(&oArrayShapes, true);
+
+	for (size_t nShape = 0; nShape < oArrayShapes.size(); ++nShape)
+	{
+		IElement* pElement = NULL;
+		
+		oArrayShapes[nShape]->GetElement(&pElement, &m_oExMedia, pNotes->m_lOriginalWidth, pNotes->m_lOriginalHeight,
+												pTheme, pLayout, pThemeWrapper, pNotesWrapper, pNotes);
+		
+		if (NULL != pElement)
+		{
+			if (pElement->m_bIsBackground && !pElement->m_bHaveAnchor && !bMasterBackGround)
+			{
+				CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement);
+				if (NULL != pShape)
+				{
+					pShape->SetupProperties(pNotes, pTheme, pLayout);
+
+					pNotes->m_bIsBackground = true;
+					pNotes->m_oBackground	= pShape->m_oBrush;
+				}
+				RELEASEOBJECT(pElement);
+				continue;			
+
+			}
+
+			if (pElement->m_bHaveAnchor)
+			{
+				pNotes->m_arElements.push_back(pElement);
+			}
+			if ( pElement->m_lPlaceholderType >0)
+			{
+				pNotes->m_mapPlaceholders.insert(std::pair<int, int>(pElement->m_lPlaceholderType, pNotes->m_arElements.size()-1)); 
+			}
+		}
+	}
+}
+
 
 void CPPTUserInfo::LoadSlide(DWORD dwSlideID, CSlide* pSlide)
 {
@@ -562,7 +802,7 @@ void CPPTUserInfo::LoadSlide(DWORD dwSlideID, CSlide* pSlide)
 		std::vector<CRecordColorSchemeAtom*> oArrayColors;
 		pRecordSlide->GetRecordsByType(&oArrayColors, false);
 
-		for (int i = 0; i < oArrayColors.size(); ++i)
+		for (size_t i = 0; i < oArrayColors.size(); ++i)
 		{
 			if (0x01 == oArrayColors[i]->m_oHeader.RecInstance)
 			{
@@ -573,7 +813,7 @@ void CPPTUserInfo::LoadSlide(DWORD dwSlideID, CSlide* pSlide)
 				// проверим на совпадение
 				size_t nCountC = pSlide->m_arColorScheme.size();
 				size_t nIndexC = 0;
-				if (nCountC == pArrayColorScheme->size())
+				if (pArrayColorScheme && nCountC == pArrayColorScheme->size())
 				{
 					for (; nIndexC < nCountC; ++nIndexC)
 					{
@@ -628,7 +868,7 @@ void CPPTUserInfo::LoadSlide(DWORD dwSlideID, CSlide* pSlide)
 	std::vector<CRecordCString*> oArrayStrings;
 	pRecordSlide->GetRecordsByType(&oArrayStrings, false, false);
 	
-	for (int i=0; i < oArrayStrings.size(); i++)
+	for (size_t i = 0; i < oArrayStrings.size(); i++)
 	{
 		if (oArrayStrings[i]->m_oHeader.RecType == 0x0fba)
 		{
@@ -642,7 +882,7 @@ void CPPTUserInfo::LoadSlide(DWORD dwSlideID, CSlide* pSlide)
 
 	pSlide->m_bIsBackground		= false;
 
-	for (int nShape = 0; nShape < oArrayShapes.size(); ++nShape)
+	for (size_t nShape = 0; nShape < oArrayShapes.size(); ++nShape)
 	{
 		IElement* pElement = NULL;
 		
@@ -1029,7 +1269,8 @@ void CPPTUserInfo::LoadMainMaster(DWORD dwMasterID, const LONG& lOriginWidth, co
 	}
 	std::vector<CRecordCString*> oArrayStrings;
 	pMaster->GetRecordsByType(&oArrayStrings, false, false);
-	for (int i=0; i < oArrayStrings.size(); i++)
+	
+	for (size_t i = 0; i < oArrayStrings.size(); i++)
 	{
 		if (oArrayStrings[i]->m_oHeader.RecType == 0x0fba)
 		{
@@ -1100,7 +1341,7 @@ void CPPTUserInfo::LoadMainMaster(DWORD dwMasterID, const LONG& lOriginWidth, co
 	std::vector<CRecordTextMasterStyleAtom*> oArrayTextMasters;
 	pMaster->GetRecordsByType(&oArrayTextMasters, true, false);
 
-	for (int i = 0; i < oArrayTextMasters.size(); ++i)
+	for (size_t i = 0; i < oArrayTextMasters.size(); ++i)
 	{
 		LONG lType = (LONG)oArrayTextMasters[i]->m_oHeader.RecInstance; 
 		if ((0 > lType) || (lType > 8))
@@ -1142,7 +1383,7 @@ void CPPTUserInfo::LoadMainMaster(DWORD dwMasterID, const LONG& lOriginWidth, co
 	
 	CLayout* pLayout = NULL; // ну нету тут разметок ...!!
 
-	for (int nShape = 0; nShape < oArrayShapes.size(); ++nShape)
+	for (size_t nShape = 0; nShape < oArrayShapes.size(); ++nShape)
 	{
 		NSPresentationEditor::IElement* pElement = NULL;
 		oArrayShapes[nShape]->GetElement(&pElement, &m_oExMedia, lOriginWidth, lOriginHeight, pTheme, pLayout, pMasterWrapper, pMasterWrapper);
@@ -1177,7 +1418,7 @@ void CPPTUserInfo::LoadMainMaster(DWORD dwMasterID, const LONG& lOriginWidth, co
 
 void CPPTUserInfo::LoadMasters(const LONG& lOriginWidth, const LONG& lOriginHeight)
 {
-	for (long i=0; i< m_arrMastersOrder.size(); i++)
+	for (size_t i = 0; i< m_arrMastersOrder.size(); i++)
 	{
 		std::map<DWORD, CRecordSlide*>::iterator pPair = m_mapMasters.find(m_arrMastersOrder[i]);
 		if (pPair == m_mapMasters.end())continue;			
@@ -1185,15 +1426,244 @@ void CPPTUserInfo::LoadMasters(const LONG& lOriginWidth, const LONG& lOriginHeig
 		LoadMainMaster(pPair->first, lOriginWidth, lOriginHeight);
 	}
 
-	for (long i=0; i< m_arrMastersOrder.size(); i++)
+	for (size_t i = 0; i< m_arrMastersOrder.size(); i++)
 	{
 		std::map<DWORD, CRecordSlide*>::iterator pPair = m_mapMasters.find(m_arrMastersOrder[i]);
 		if (pPair == m_mapMasters.end())continue;			
 	
 		LoadNoMainMaster(pPair->first, lOriginWidth, lOriginHeight);
 	}
-}
 
+	LoadNotesMasterFromPrevUsers(0);
+	if (!m_mapNotesMasters.empty())
+	{
+		std::map<DWORD, CRecordSlide*>::iterator pPair = m_mapNotesMasters.begin();
+	
+		LoadMaster(pPair->second, m_pNotesMasterWrapper, m_pNotesMaster);
+	}
+
+	LoadHandoutMasterFromPrevUsers(0);
+	if (!m_mapHandoutMasters.empty())
+	{
+		std::map<DWORD, CRecordSlide*>::iterator pPair = m_mapHandoutMasters.begin();
+	
+		LoadMaster(pPair->second, m_pHandoutMasterWrapper, m_pHandoutMaster);
+	}
+}
+void CPPTUserInfo::LoadMaster(CRecordSlide* pMaster, CSlideInfo *& pMasterWrapper, CTheme *& pTheme)
+{
+    if (pMaster == NULL)
+        return; 
+	
+	LONG lOriginWidth = 0, lOriginHeight = 0;
+
+	bool bMasterColorScheme = false;
+    bool bMasterBackGround	= false;
+    bool bMasterObjects		= false;
+
+	DWORD dwID = 0;
+
+	std::vector<CRecordSlideAtom*> oArraySlideAtoms;
+	pMaster->GetRecordsByType(&oArraySlideAtoms, true);
+	
+	if (!oArraySlideAtoms.empty())
+	{
+		dwID = (DWORD)oArraySlideAtoms[0]->m_nMasterIDRef;
+
+		bMasterColorScheme	= oArraySlideAtoms[0]->m_bMasterScheme;
+		bMasterBackGround	= oArraySlideAtoms[0]->m_bMasterBackground;
+		bMasterObjects		= oArraySlideAtoms[0]->m_bMasterObjects;
+	}
+	else
+	{
+		std::vector<CRecordNotesAtom*> oArrayNotesAtoms;
+		pMaster->GetRecordsByType(&oArrayNotesAtoms, true);
+		
+		if (!oArrayNotesAtoms.empty())
+		{
+			dwID = (DWORD)oArrayNotesAtoms[0]->m_nSlideIDRef;
+
+			bMasterColorScheme	= oArrayNotesAtoms[0]->m_bMasterScheme;
+			bMasterBackGround	= oArrayNotesAtoms[0]->m_bMasterBackground;
+			bMasterObjects		= oArrayNotesAtoms[0]->m_bMasterObjects;
+		}
+	}
+
+	pTheme = new CTheme();
+
+	pTheme->m_lOriginalWidth	= lOriginWidth;
+	pTheme->m_lOriginalHeight	= lOriginHeight;
+
+	std::vector<CRecordHeadersFootersContainer*> oArrayHeadersFootersInfo;
+	pMaster->GetRecordsByType(&oArrayHeadersFootersInfo, true, false);
+
+	if (0 != oArrayHeadersFootersInfo.size())
+	{
+		if (oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom)
+		{
+			pTheme->m_bHasDate			=	oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasDate ||
+											oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasTodayDate || 
+											oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasUserDate;
+			pTheme->m_bHasFooter		=	oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasFooter;
+			pTheme->m_bHasSlideNumber	=	oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasSlideNumber;
+			
+			if (oArrayHeadersFootersInfo[0]->m_oHeadersFootersAtom->m_bHasUserDate ) 	pTheme->m_nFormatDate = 2;
+		}
+		for(int i = 0 ; i< 3; i++) pTheme->m_PlaceholdersReplaceString[i] = oArrayHeadersFootersInfo[0]->m_HeadersFootersString[i];
+	}
+	else
+	{
+		pTheme->m_bHasDate			=	m_bHasDate;
+		pTheme->m_bHasFooter		=	m_bHasFooter;
+		pTheme->m_bHasSlideNumber	=	m_bHasSlideNumber;		
+		pTheme->m_nFormatDate		=	m_nFormatDate;
+		for (int i = 0 ; i < 3; i++) pTheme->m_PlaceholdersReplaceString[i] = m_PlaceholdersReplaceString[i];
+	}
+	std::vector<CRecordCString*> oArrayStrings;
+	pMaster->GetRecordsByType(&oArrayStrings, false, false);
+	
+	for (size_t i = 0; i < oArrayStrings.size(); i++)
+	{
+		if (oArrayStrings[i]->m_oHeader.RecType == 0x0fba)
+		{
+			pTheme->m_sThemeName = oArrayStrings[i]->m_strText;
+		}
+	}
+
+	pMasterWrapper = new CSlideInfo();
+
+	// записываем шрифты ---------------------------------------------------------------
+	int nCountFonts = m_arrFonts.size();
+	for (int i = 0; i < nCountFonts; ++i)
+	{
+		pTheme->m_arFonts.push_back(m_arrFonts[i]);
+	}
+	// ---------------------------------------------------------------------------------
+
+	// читаем цветовую схему -----------------------------------------------------------
+	std::vector<CRecordColorSchemeAtom*> oArrayColors;
+	pMaster->GetRecordsByType(&oArrayColors, false);
+
+	int nColorCount = oArrayColors.size();
+	for (int i = 0; i < nColorCount; ++i)
+	{
+		if (0x01 == oArrayColors[i]->m_oHeader.RecInstance)
+		{
+			if ( m_oSchemeColors.empty())	
+			{
+				oArrayColors[i]->ToArray(&m_oSchemeColors);
+				CorrectColorScheme(m_oSchemeColors);//??
+			}
+			if ( pTheme->m_arColorScheme.empty())
+			{
+				oArrayColors[i]->ToArray(&pTheme->m_arColorScheme);
+				CorrectColorScheme(pTheme->m_arColorScheme);
+			}
+		}
+
+		if (0x06 == oArrayColors[i]->m_oHeader.RecInstance)
+		{
+			std::vector<CColor> extra;
+			oArrayColors[i]->ToArray(&extra);
+
+			CorrectColorScheme(extra);
+			pTheme->m_arExtraColorScheme.push_back(extra);
+		}
+	}
+	if (pTheme->m_arColorScheme.empty() && !pTheme->m_arExtraColorScheme.empty())
+	{
+		pTheme->m_arColorScheme = pTheme->m_arExtraColorScheme[0];
+	}
+
+// ---------------------------------------------------------------------------------
+	int indexUser = 0;
+	//std::map<DWORD, CRecordSlide*>::iterator pPairMaster1 = m_mapMasters.find(dwMasterID);
+	//if (pPairMaster1 != m_mapMasters.end())
+	//{
+	//	indexUser = pPairMaster1->second->m_IndexUser;
+	//	pMasterWrapper->m_arTextPlaceHolders = pPairMaster1->second->m_oPersist.m_arTextAttrs;
+	//}
+	pMasterWrapper->m_parEmptyPictures	= &m_pDocumentInfo->m_arUsers[indexUser]->m_arOffsetPictures;
+	pMasterWrapper->m_mapFilePictures	= &m_pDocumentInfo->m_mapStoreImageFile;
+
+	// читаем настройки текстовых стилей -----------------------------------------------
+	std::vector<CRecordTextMasterStyleAtom*> oArrayTextMasters;
+	pMaster->GetRecordsByType(&oArrayTextMasters, true, false);
+
+	for (size_t i = 0; i < oArrayTextMasters.size(); ++i)
+	{
+		LONG lType = (LONG)oArrayTextMasters[i]->m_oHeader.RecInstance; 
+		if ((0 > lType) || (lType > 8))
+			continue;
+
+		pMasterWrapper->m_pStyles[lType] = new NSPresentationEditor::CTextStyles();
+		pMasterWrapper->m_pStyles[lType]->SetStyles((NSPresentationEditor::CTextStyles*)oArrayTextMasters[i]);
+
+		CTheme::CalculateStyle(pTheme, pMasterWrapper->m_pStyles[lType].get());
+	}
+	if (pMasterWrapper->m_pStyles[3].is_init())
+		pMasterWrapper->m_pStyles[3]->ApplyBefore(m_oDefaultTextStyle);
+	else
+		pMasterWrapper->m_pStyles[3] = m_oDefaultTextStyle;
+
+	CTextStyles oPPTDefaultStyle;
+	CreateDefaultStyle(oPPTDefaultStyle, pTheme);
+	oPPTDefaultStyle.ApplyAfter(m_oDefaultTextStyle);
+
+	// выставим стили теме
+	pTheme->m_pStyles[0] = oPPTDefaultStyle;
+	pTheme->m_pStyles[1] = oPPTDefaultStyle;
+	pTheme->m_pStyles[2] = oPPTDefaultStyle;
+	pTheme->m_pStyles[3] = oPPTDefaultStyle;
+
+	if (pMasterWrapper->m_pStyles[0].is_init())
+		pTheme->m_pStyles[1].ApplyAfter(pMasterWrapper->m_pStyles[0].get());
+	if (pMasterWrapper->m_pStyles[1].is_init())
+		pTheme->m_pStyles[2].ApplyAfter(pMasterWrapper->m_pStyles[1].get());
+	if (pMasterWrapper->m_pStyles[2].is_init())
+		pTheme->m_pStyles[3].ApplyAfter(pMasterWrapper->m_pStyles[3].get());
+
+	// ---------------------------------------------------------------------------------
+	// читаем все элементы...-----------------------------------------------------------
+	std::vector<CRecordShapeContainer*> oArrayShapes;
+	pMaster->GetRecordsByType(&oArrayShapes, true);
+
+	pTheme->CalculateStyles();
+	
+	CLayout* pLayout = NULL; // ну нету тут разметок ...!!
+
+	for (size_t nShape = 0; nShape < oArrayShapes.size(); ++nShape)
+	{
+		NSPresentationEditor::IElement* pElement = NULL;
+		oArrayShapes[nShape]->GetElement(&pElement, &m_oExMedia, lOriginWidth, lOriginHeight, pTheme, pLayout, pMasterWrapper, pMasterWrapper);
+
+		if (NULL != pElement)
+		{
+			//AddAnimation ( dwMasterID, lOriginWidth, lOriginHeight, pElement );
+			
+			if (pElement->m_bIsBackground && !pElement->m_bHaveAnchor)
+			{
+				CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement);
+				if (NULL != pShape)
+				{
+					pShape->SetupProperties(NULL, pTheme, pLayout);
+
+					pTheme->m_bIsBackground = true;
+					pTheme->m_oBackground = pShape->m_oBrush;
+				}
+
+				RELEASEINTERFACE(pElement);
+				continue;
+			}
+			pTheme->m_arElements.push_back(pElement);
+			
+			if ( pElement->m_lPlaceholderType > 0)
+			{
+				pTheme->m_mapPlaceholders.insert(std::pair<int, int>(pElement->m_lPlaceholderType, pTheme->m_arElements.size()-1)); 
+			}
+		}
+	}
+}
 void CPPTUserInfo::LoadNoMainMaster(DWORD dwMasterID, const LONG& lOriginWidth, const LONG& lOriginHeight)
 {
 	std::map<DWORD, CRecordSlide*>::iterator pPair = m_mapMasters.find(dwMasterID);
@@ -1266,10 +1736,10 @@ void CPPTUserInfo::LoadNoMainMaster(DWORD dwMasterID, const LONG& lOriginWidth,
 	
 	CLayout* pLayout = NULL;
 
-	int lLayoutID	= AddNewLayout(pTheme, pCurMaster, false, false);
+	int lLayoutID = AddNewLayout(pTheme, pCurMaster, false, false);
 	
 	pLayout							= &pTheme->m_arLayouts[lLayoutID];
-	pLayout->m_bShowMasterShapes	=	false;
+	pLayout->m_bShowMasterShapes	= false;
 
 	pTheme->m_mapTitleLayout[dwMasterID] = lLayoutID;
 
@@ -1281,7 +1751,7 @@ void CPPTUserInfo::LoadNoMainMaster(DWORD dwMasterID, const LONG& lOriginWidth,
 		pCurMaster->GetRecordsByType(&oArrayColors, false);
 
 		pLayout->m_arColorScheme.clear();
-		for (int i = 0; i < oArrayColors.size(); ++i)
+		for (size_t i = 0; i < oArrayColors.size(); ++i)
 		{
 			if (0x01 == oArrayColors[i]->m_oHeader.RecInstance)
 			{
@@ -1292,7 +1762,7 @@ void CPPTUserInfo::LoadNoMainMaster(DWORD dwMasterID, const LONG& lOriginWidth,
 				// проверим на совпадение
 				size_t nCountC = pLayout->m_arColorScheme.size();
 				size_t nIndexC = 0;
-				if (nCountC == pArrayColorScheme->size())
+				if (pArrayColorScheme && nCountC == pArrayColorScheme->size())
 				{
 					for (; nIndexC < nCountC; ++nIndexC)
 					{
@@ -1341,7 +1811,7 @@ void CPPTUserInfo::LoadNoMainMaster(DWORD dwMasterID, const LONG& lOriginWidth,
 	std::vector<CRecordCString*> oArrayStrings;
 	pCurMaster->GetRecordsByType(&oArrayStrings, false, false);
 	
-	for (int i=0; i < oArrayStrings.size(); i++)
+	for (size_t i = 0; i < oArrayStrings.size(); i++)
 	{
 		if (oArrayStrings[i]->m_oHeader.RecType == 0x0fba)
 		{
@@ -1352,7 +1822,7 @@ void CPPTUserInfo::LoadNoMainMaster(DWORD dwMasterID, const LONG& lOriginWidth,
 	std::vector<CRecordShapeContainer*> oArrayShapes;
 	pCurMaster->GetRecordsByType(&oArrayShapes, true);
 
-	for (int nShape = 0; nShape < oArrayShapes.size(); ++nShape)
+	for (size_t nShape = 0; nShape < oArrayShapes.size(); ++nShape)
 	{
 		IElement* pElement = NULL;
 		oArrayShapes[nShape]->GetElement(&pElement, &m_oExMedia, lOriginWidth, lOriginHeight, pTheme, pLayout, pThemeWrapper, pMasterWrapper);
@@ -1467,7 +1937,7 @@ void CPPTUserInfo::LoadMasterFromPrevUsers(DWORD dwMasterID)
 
 	size_t lUsersCount = m_pDocumentInfo->m_arUsers.size();
 	
-	for (int lIndexUser = m_lIndexThisUser + 1; lIndexUser < lUsersCount; ++lIndexUser)
+	for (size_t lIndexUser = m_lIndexThisUser + 1; lIndexUser < lUsersCount; ++lIndexUser)
 	{
 		std::map<DWORD, CRecordSlide*>::iterator pPair = m_pDocumentInfo->m_arUsers[lIndexUser]->m_mapMasters.find(dwMasterID);
 
@@ -1496,23 +1966,21 @@ void CPPTUserInfo::LoadMasterFromPrevUsers(DWORD dwMasterID)
 		}
 	}
 }
-void CPPTUserInfo::LoadNoteFromPrevUsers(DWORD dwSlideID)
+void CPPTUserInfo::LoadNotesFromPrevUsers(DWORD dwSlideID)
 {
 	if ((NULL == m_pDocumentInfo) || (-1 == m_lIndexThisUser))
 		return;
 
-	std::map<DWORD, CRecordSlide*>::iterator pPair = m_mapNotes.find(dwSlideID);
-	if (pPair != m_mapNotes.end())
+	std::map<DWORD, CRecordSlide*>::iterator pPairSlide = m_mapNotes.find(dwSlideID);
+	
+	if (pPairSlide != m_mapNotes.end() && pPairSlide->second)
 		return; //есть
-	
+
 	size_t lUsersCount = m_pDocumentInfo->m_arUsers.size();
-	
-	// у нас чем раньше - тем больше индекс
-	for (size_t lIndexUser = m_lIndexThisUser + 1; lIndexUser < lUsersCount; lIndexUser++)
-	//for (size_t lIndexUser = lUsersCount - 1; lIndexUser > m_lIndexThisUser; lIndexUser--)
-	{
-		pPair = m_pDocumentInfo->m_arUsers[lIndexUser]->m_mapNotes.find(dwSlideID);
 		
+	for (size_t lIndexUser = m_lIndexThisUser + 1; lIndexUser < lUsersCount; ++lIndexUser)
+	{
+		std::map<DWORD, CRecordSlide*>::iterator pPair = m_pDocumentInfo->m_arUsers[lIndexUser]->m_mapNotes.find(dwSlideID);
 		if (pPair == m_pDocumentInfo->m_arUsers[lIndexUser]->m_mapNotes.end())
 			continue;
 
@@ -1520,13 +1988,103 @@ void CPPTUserInfo::LoadNoteFromPrevUsers(DWORD dwSlideID)
 		if (NULL != pSlideCur)
 		{
 			pSlideCur->AddRef();
-			m_mapNotes.insert(std::pair<DWORD, CRecordSlide*>(dwSlideID, pSlideCur));
-			m_arrNotesOrder.push_back(dwSlideID);
+
+			pSlideCur->m_IndexUser = lIndexUser;
+
+			if (pPairSlide != m_mapNotes.end())
+			{
+				pPairSlide->second = pSlideCur;
+			}
+			else
+			{
+				m_mapNotes.insert(m_mapSlides.end(), std::pair<DWORD, CRecordSlide*>(dwSlideID, pSlideCur));
+				m_arrNotesOrder.push_back(dwSlideID);
+			}
 			return;
 		}
 	}
 }
 
+void CPPTUserInfo::LoadNotesMasterFromPrevUsers(DWORD dwMasterID)
+{
+	if ((NULL == m_pDocumentInfo) || (-1 == m_lIndexThisUser))
+		return;
+
+	std::map<DWORD, CRecordSlide*>::iterator pPairMaster = m_mapNotesMasters.find(dwMasterID);
+
+	if (pPairMaster != m_mapNotesMasters.end() && pPairMaster->second)
+		return;//есть
+
+	size_t lUsersCount = m_pDocumentInfo->m_arUsers.size();
+	
+	for (size_t lIndexUser = m_lIndexThisUser + 1; lIndexUser < lUsersCount; ++lIndexUser)
+	{
+		std::map<DWORD, CRecordSlide*>::iterator pPair = m_pDocumentInfo->m_arUsers[lIndexUser]->m_mapNotesMasters.find(dwMasterID);
+
+		if (pPair == m_pDocumentInfo->m_arUsers[lIndexUser]->m_mapNotesMasters.end())
+			continue;
+		
+		CRecordSlide* pSlideCur = pPair->second;
+		if (NULL != pSlideCur)
+		{
+			pSlideCur->AddRef();
+
+			//для каждого пользователя СВОИ активные картинки !!!
+			pSlideCur->m_IndexUser = lIndexUser;
+
+			if (pPairMaster != m_mapNotesMasters.end())
+			{
+				//был найден ранее нулевым
+				pPairMaster->second = pSlideCur;
+			}
+			else
+			{
+				m_mapNotesMasters.insert(m_mapNotesMasters.end(), std::pair<DWORD, CRecordSlide*>(dwMasterID, pSlideCur));
+			}
+			return;
+		}
+	}
+}
+void CPPTUserInfo::LoadHandoutMasterFromPrevUsers(DWORD dwMasterID)
+{
+	if ((NULL == m_pDocumentInfo) || (-1 == m_lIndexThisUser))
+		return;
+
+	std::map<DWORD, CRecordSlide*>::iterator pPairMaster = m_mapHandoutMasters.find(dwMasterID);
+
+	if (pPairMaster != m_mapHandoutMasters.end() && pPairMaster->second)
+		return;//есть
+
+	size_t lUsersCount = m_pDocumentInfo->m_arUsers.size();
+	
+	for (size_t lIndexUser = m_lIndexThisUser + 1; lIndexUser < lUsersCount; ++lIndexUser)
+	{
+		std::map<DWORD, CRecordSlide*>::iterator pPair = m_pDocumentInfo->m_arUsers[lIndexUser]->m_mapHandoutMasters.find(dwMasterID);
+
+		if (pPair == m_pDocumentInfo->m_arUsers[lIndexUser]->m_mapHandoutMasters.end())
+			continue;
+		
+		CRecordSlide* pSlideCur = pPair->second;
+		if (NULL != pSlideCur)
+		{
+			pSlideCur->AddRef();
+
+			//для каждого пользователя СВОИ активные картинки !!!
+			pSlideCur->m_IndexUser = lIndexUser;
+
+			if (pPairMaster != m_mapHandoutMasters.end())
+			{
+				//был найден ранее нулевым
+				pPairMaster->second = pSlideCur;
+			}
+			else
+			{
+				m_mapHandoutMasters.insert(m_mapHandoutMasters.end(), std::pair<DWORD, CRecordSlide*>(dwMasterID, pSlideCur));
+			}
+			return;
+		}
+	}
+}
 void CPPTUserInfo::LoadExternal(CRecordExObjListContainer* pExObjects)
 {
 	// читаем SoundCollection
@@ -1569,7 +2127,7 @@ void CPPTUserInfo::LoadExternal(CRecordExObjListContainer* pExObjects)
 	std::vector<CRecordExVideoContainer*> oArray;
 	pExObjects->GetRecordsByType(&oArray, true);
 
-	for (int nIndex = 0; nIndex < oArray.size(); ++nIndex)
+	for (size_t nIndex = 0; nIndex < oArray.size(); ++nIndex)
 	{
 		LoadExVideo(oArray[nIndex]);
 	}
@@ -1588,15 +2146,15 @@ void CPPTUserInfo::LoadExternal(CRecordExObjListContainer* pExObjects)
 	pExObjects->GetRecordsByType(&oArrayWAVLink			, true);
 	pExObjects->GetRecordsByType(&oArrayAudioEmbedded	, true);
 
-	for (int nIndex = 0; nIndex < oArrayAudioMIDI.size(); ++nIndex)
+	for (size_t nIndex = 0; nIndex < oArrayAudioMIDI.size(); ++nIndex)
 	{
 		LoadExAudio(oArrayAudioMIDI[nIndex]);
 	}
-	for (int nIndex = 0; nIndex < oArrayWAVLink.size(); ++nIndex)
+	for (size_t nIndex = 0; nIndex < oArrayWAVLink.size(); ++nIndex)
 	{
 		LoadExAudio(oArrayWAVLink[nIndex]);
 	}
-	for (int nIndex = 0; nIndex < oArrayAudioEmbedded.size(); ++nIndex)
+	for (size_t nIndex = 0; nIndex < oArrayAudioEmbedded.size(); ++nIndex)
 	{
 		DWORD dwKeySound	= oArrayAudioEmbedded[nIndex]->m_nSoundID;
 		DWORD dwKeyObj		= oArrayAudioEmbedded[nIndex]->m_oMedia.m_nExObjID;
@@ -1613,7 +2171,7 @@ void CPPTUserInfo::LoadExternal(CRecordExObjListContainer* pExObjects)
 			m_oExMedia.m_arAudios.push_back(oAudio);
 		}
 	}
-	for (int nIndex = 0; nIndex < oArrayAudioCD.size(); ++nIndex)
+	for (size_t nIndex = 0; nIndex < oArrayAudioCD.size(); ++nIndex)
 	{
 		DWORD dwKeyObj			= oArrayAudioCD[nIndex]->m_oMedia.m_nExObjID;
 
@@ -1633,7 +2191,7 @@ void CPPTUserInfo::LoadExternal(CRecordExObjListContainer* pExObjects)
 
 	pExObjects->GetRecordsByType(&oArrayHyperlinkContainer		, true);
 	
-	for (int nIndex = 0; nIndex < oArrayHyperlinkContainer.size(); ++nIndex)
+	for (size_t nIndex = 0; nIndex < oArrayHyperlinkContainer.size(); ++nIndex)
 	{
 		std::vector<CRecordExHyperlinkAtom*>	oArrayHyperlink;		
 		std::vector<CRecordCString*>			oArrayCString;		
@@ -1645,8 +2203,8 @@ void CPPTUserInfo::LoadExternal(CRecordExObjListContainer* pExObjects)
 		{
 			NSPresentationEditor::CExFilesInfo oInfo;
 
-			oInfo.m_dwID			= oArrayHyperlink[0]->m_nHyperlinkID;
-			for (int i = 0 ; i < oArrayCString.size(); i++)
+			oInfo.m_dwID = oArrayHyperlink[0]->m_nHyperlinkID;
+			for (size_t i = 0 ; i < oArrayCString.size(); i++)
 			{
 				if (oArrayCString[i]->m_oHeader.RecInstance == 1)
 					oInfo.m_strFilePath		= oArrayCString[i]->m_strText;

ASCOfficePPTFile/PPTFormatLib/Reader/PPTDocumentInfoOneUser.h

@@ -47,12 +47,13 @@ public:
 	std::map<DWORD, DWORD>							m_mapOffsetInPIDs;
 	CRecordDocument									m_oDocument;
 
-	//todooo при переходе на C++11 использовать НУЖНЫЙ здесь unsorted_map - m_arr .. Order уберутся
-
 	std::map<DWORD, CRecordSlide*>					m_mapSlides;
 	std::map<DWORD, CRecordSlide*>					m_mapMasters;
 	std::map<DWORD, CRecordSlide*>					m_mapNotes;
 
+	std::map<DWORD, CRecordSlide*>					m_mapNotesMasters;
+	std::map<DWORD, CRecordSlide*>					m_mapHandoutMasters;
+
 	std::vector<DWORD>								m_arrSlidesOrder;
 	std::vector<DWORD>								m_arrMastersOrder;
 	std::vector<DWORD>								m_arrNotesOrder;
@@ -66,6 +67,10 @@ public:
 	// это как бы ППT-шная обертка над слайдом
 	std::vector<CSlideInfo>							m_arSlideWrapper;
 	std::vector<CSlideInfo>							m_arMasterWrapper;
+	std::vector<CSlideInfo>							m_arNotesWrapper;
+
+	CSlideInfo*										m_pNotesMasterWrapper;
+	CSlideInfo*										m_pHandoutMasterWrapper;
 
 	// эти параметры - одни на весь документ. 
 	// чтобы поддержать нашу схему (пптх) - копируем их в темы
@@ -106,8 +111,8 @@ public:
 	nullable<WORD>									m_wLanguage;	// язык пользователя (редактора)
 	bool											m_bRtl;
 	bool											m_bShowComments;
-public:
 
+//-----------------------------------------------------------------------------------------------------
 	CPPTUserInfo();
 	~CPPTUserInfo();
 
@@ -119,15 +124,20 @@ public:
 	void NormalizeCoords(long lWidth, long lHeight);
 
 	void LoadSlide(DWORD dwSlideID, CSlide* pSlide);
+	void LoadNotes(DWORD dwNotesID, CSlide* pSlide);
 	
 	void LoadMasters(const LONG& lOriginWidth, const LONG& lOriginHeight);
 	
 	void LoadNoMainMaster	(DWORD dwMasterID, const LONG& lOriginWidth, const LONG& lOriginHeight);
 	void LoadMainMaster		(DWORD dwMasterID, const LONG& lOriginWidth, const LONG& lOriginHeight);
+	
+    void LoadMaster(CRecordSlide* pMaster, CSlideInfo *& pMasterWrapper, CTheme *& pTheme);
 
-	void LoadSlideFromPrevUsers	(DWORD dwSlideID);
-	void LoadMasterFromPrevUsers(DWORD dwSlideID);
-	void LoadNoteFromPrevUsers	(DWORD dwSlideID);
+	void LoadSlideFromPrevUsers			(DWORD dwSlideID);
+	void LoadMasterFromPrevUsers		(DWORD dwSlideID);
+	void LoadNotesFromPrevUsers			(DWORD dwSlideID);
+	void LoadNotesMasterFromPrevUsers	(DWORD dwSlideID);
+	void LoadHandoutMasterFromPrevUsers	(DWORD dwSlideID);
 
 	void LoadExternal(CRecordExObjListContainer* pExObjects);
 
@@ -169,7 +179,6 @@ public:
 
 		oScheme  = oArrayMem;
 	}
-
 	
 	std::wstring ConvertLayoutType(INT nGeom, BYTE* pPlaceholders)
 	{
@@ -287,6 +296,7 @@ public:
 		return _T("blank");
 	}
 
+	
 	void AddAnimation		(DWORD dwSlideID, double Width, double Height, IElement* pElement);
 	void AddAudioTransition (DWORD dwSlideID, CTransition* pTransition, const std::wstring& strFilePath);
 

ASCOfficePPTFile/PPTFormatLib/Reader/PPTFileDefines.h

@@ -73,10 +73,26 @@ typedef BYTE BOOL1;
 #define		RECORD_TYPE_EXOBJLIST_ATOM						1034
 #define		RECORD_TYPE_PPDRAWING_GROUP						1035
 #define		RECORD_TYPE_PPDRAWING							1036
+#define		RT_RoundTripTheme12Atom							1038
+#define		RT_RoundTripColorMapping12Atom					1039
 #define		RECORD_TYPE_NAMEDSHOWS							1040
 #define		RECORD_TYPE_NAMEDSHOW							1041
 #define		RECORD_TYPE_NAMEDSHOW_SLIDES					1042
 #define		RECORD_TYPE_SHEET_PROPERTIES					1044
+
+#define		RECORD_TYPE_ORIGINALMAINMASTERID							1052
+#define		RECORD_TYPE_COMPOSITEMASTERID								1053
+#define		RECORD_TYPE_ROUNDTRIPCONTENTMASTERINFO12					1054
+#define		RECORD_TYPE_ROUNDTRIPSHAPEID12								1055
+#define		RECORD_TYPE_ROUNDTRIPHFPLACEHOLDER12						1056
+#define		RECORD_TYPE_ROUNDTRIPCONTENTMASTERID						1058
+#define		RECORD_TYPE_ROUNDTRIPOARTTEXTSTYLES12						1059
+#define     RECORD_TYPE_ROUNDTRIPHEADERFOOTERDEFAULTS12ATOM				1060
+#define     RECORD_TYPE_ROUNDTRIPDOCFLAGS12								1061
+#define		RECORD_TYPE_ROUNDTRIPSHAPECHECKSUMFORCUSTOMLAYOUTS12		1062
+#define		RECORD_TYPE_ROUNDTRIPNOTESMASTERTEXTSTYLES12				1063
+#define		RECORD_TYPE_ROUNDTRIPCUSTOMTABLESTYLES12					1064
+
 #define		RECORD_TYPE_LIST								2000
 #define		RECORD_TYPE_FONTCOLLECTION						2005
 #define		RECORD_TYPE_BOOKMARKCOLLECTION					2019
@@ -182,19 +198,6 @@ typedef BYTE BOOL1;
 // Records ~12050 seem to be related to Document Encryption
 #define		RECORD_TYPE_DOCUMENT_ENCRYPTION_ATOM			12052
 
-#define		RECORD_TYPE_ORIGINALMAINMASTERID							1052
-#define		RECORD_TYPE_COMPOSITEMASTERID								1053
-#define		RECORD_TYPE_ROUNDTRIPCONTENTMASTERINFO12					1054
-#define		RECORD_TYPE_ROUNDTRIPSHAPEID12								1055
-#define		RECORD_TYPE_ROUNDTRIPHFPLACEHOLDER12						1056
-#define		RECORD_TYPE_ROUNDTRIPCONTENTMASTERID						1058
-#define		RECORD_TYPE_ROUNDTRIPOARTTEXTSTYLES12						1059
-#define     RECORD_TYPE_ROUNDTRIPHEADERFOOTERDEFAULTS12ATOM				1060
-#define     RECORD_TYPE_ROUNDTRIPDOCFLAGS12								1061
-#define		RECORD_TYPE_ROUNDTRIPSHAPECHECKSUMFORCUSTOMLAYOUTS12		1062
-#define		RECORD_TYPE_ROUNDTRIPNOTESMASTERTEXTSTYLES12				1063
-#define		RECORD_TYPE_ROUNDTRIPCUSTOMTABLESTYLES12					1064
-
 //records greater then 0xF000 belong to with Microsoft Office Drawing format also known as Escher
 #define		RECORD_TYPE_ESCHER_DGG_CONTAINER							0xF000
 #define		RECORD_TYPE_ESCHER_DGG										0xF006
@@ -398,48 +401,47 @@ static std::string GetRecordName(DWORD dwType)
 	case RECORD_TYPE_ROUNDTRIPNOTESMASTERTEXTSTYLES12				: { strName = ("RoundTripNotesMasterTextStyles12"); break; }
 	case RECORD_TYPE_ROUNDTRIPCUSTOMTABLESTYLES12					: { strName = ("RoundTripCustomTableStyles12"); break; }
 
-	//records greater then 0xF000 belong to with Microsoft Office Drawing format also known as Escher
-	case RECORD_TYPE_ESCHER_DGG_CONTAINER							: { strName = ("Escher_DrawingGroupContainer"); break; }
-	case RECORD_TYPE_ESCHER_DGG										: { strName = ("Escher_DrawingGroupRecord"); break; }
-	case RECORD_TYPE_ESCHER_CLSID									: { strName = ("Escher_CLSID_Record"); break; }
-	case RECORD_TYPE_ESCHER_OPT										: { strName = ("Escher_OPT"); break; }
-	case RECORD_TYPE_ESCHER_BSTORE_CONTAINER						: { strName = ("Escher_BlipStoreContainer"); break; }
-	case RECORD_TYPE_ESCHER_BSE										: { strName = ("Escher_BlipStoreEntry"); break; }
-	case RECORD_TYPE_ESCHER_BLIP_START								: { strName = ("Escher_BlipStart"); break; }
-	case RECORD_TYPE_ESCHER_BLIP_END								: { strName = ("Escher_BlipEnd"); break; }
-	case RECORD_TYPE_ESCHER_DG_CONTAINER							: { strName = ("Escher_DrawingContainer"); break; }
-	case RECORD_TYPE_ESCHER_DG										: { strName = ("Escher_DrawingRecord"); break; }
-	case RECORD_TYPE_ESCHER_REGROUPITEMS							: { strName = ("Escher_RegGroupItems"); break; }
-	case RECORD_TYPE_ESCHER_COLORSCHEME								: { strName = ("Escher_ColorSheme"); break; }
-	case RECORD_TYPE_ESCHER_SPGR_CONTAINER							: { strName = ("Escher_GroupShapeContainer"); break; }
-	case RECORD_TYPE_ESCHER_SP_CONTAINER							: { strName = ("Escher_ShapeContainer"); break; }
-	case RECORD_TYPE_ESCHER_SPGR									: { strName = ("Escher_GroupShapeRecord"); break; }
-	case RECORD_TYPE_ESCHER_SP										: { strName = ("Escher_ShapeRecord"); break; }
-	case RECORD_TYPE_ESCHER_TEXTBOX									: { strName = ("Escher_TextBox"); break; }
-	case RECORD_TYPE_ESCHER_CLIENTTEXTBOX							: { strName = ("Escher_ClientTextBox"); break; }
-	case RECORD_TYPE_ESCHER_ANCHOR									: { strName = ("Escher_Anchor"); break; }
-	case RECORD_TYPE_ESCHER_CHILDANCHOR								: { strName = ("Escher_ChildAnchor"); break; }
-	case RECORD_TYPE_ESCHER_CLIENTANCHOR							: { strName = ("Escher_ClientAnchor"); break; }
-	case RECORD_TYPE_ESCHER_CLIENTDATA								: { strName = ("Escher_ClientData"); break; }
-	case RECORD_TYPE_ESCHER_SOLVERCONTAINER							: { strName = ("Escher_SolverContainer"); break; }
-	case RECORD_TYPE_ESCHER_CONNECTORRULE							: { strName = ("Escher_ConnectorRule"); break; }
-	case RECORD_TYPE_ESCHER_ALIGNRULE								: { strName = ("Escher_AlignRule"); break; }
-	case RECORD_TYPE_ESCHER_ARCRULE									: { strName = ("Escher_ArcRule"); break; }
-	case RECORD_TYPE_ESCHER_CLIENTRULE								: { strName = ("Escher_ClientRule"); break; }
-	case RECORD_TYPE_ESCHER_CALLOUTRULE								: { strName = ("Escher_CallOutRule"); break; }
-	case RECORD_TYPE_ESCHER_SELECTION								: { strName = ("Escher_Selection"); break; }
-	case RECORD_TYPE_ESCHER_COLORMRU								: { strName = ("Escher_ColorMRU"); break; }
-	case RECORD_TYPE_ESCHER_DELETEDPSPL								: { strName = ("Escher_DeletedPSPL"); break; }
-	case RECORD_TYPE_ESCHER_SPLITMENUCOLORS							: { strName = ("Escher_SplitMenuColors"); break; }
-	case RECORD_TYPE_ESCHER_OLEOBJECT								: { strName = ("Escher_OleObject"); break; }
-	case RECORD_TYPE_ESCHER_SECONDARY_OPT							: { strName = ("Escher_SecondaryOPT"); break; }
-	case RECORD_TYPE_ESCHER_TETRIARY_OPT							: { strName = ("Escher_TetriaryOPT"); break; }
+	case RECORD_TYPE_ESCHER_DGG_CONTAINER							: { strName = ("DrawingGroupContainer"); break; }
+	case RECORD_TYPE_ESCHER_DGG										: { strName = ("DrawingGroupRecord"); break; }
+	case RECORD_TYPE_ESCHER_CLSID									: { strName = ("CLSID_Record"); break; }
+	case RECORD_TYPE_ESCHER_OPT										: { strName = ("OPT"); break; }
+	case RECORD_TYPE_ESCHER_BSTORE_CONTAINER						: { strName = ("BlipStoreContainer"); break; }
+	case RECORD_TYPE_ESCHER_BSE										: { strName = ("BlipStoreEntry"); break; }
+	case RECORD_TYPE_ESCHER_BLIP_START								: { strName = ("BlipStart"); break; }
+	case RECORD_TYPE_ESCHER_BLIP_END								: { strName = ("BlipEnd"); break; }
+	case RECORD_TYPE_ESCHER_DG_CONTAINER							: { strName = ("DrawingContainer"); break; }
+	case RECORD_TYPE_ESCHER_DG										: { strName = ("DrawingRecord"); break; }
+	case RECORD_TYPE_ESCHER_REGROUPITEMS							: { strName = ("RegGroupItems"); break; }
+	case RECORD_TYPE_ESCHER_COLORSCHEME								: { strName = ("ColorSheme"); break; }
+	case RECORD_TYPE_ESCHER_SPGR_CONTAINER							: { strName = ("GroupShapeContainer"); break; }
+	case RECORD_TYPE_ESCHER_SP_CONTAINER							: { strName = ("ShapeContainer"); break; }
+	case RECORD_TYPE_ESCHER_SPGR									: { strName = ("GroupShapeRecord"); break; }
+	case RECORD_TYPE_ESCHER_SP										: { strName = ("ShapeRecord"); break; }
+	case RECORD_TYPE_ESCHER_TEXTBOX									: { strName = ("TextBox"); break; }
+	case RECORD_TYPE_ESCHER_CLIENTTEXTBOX							: { strName = ("ClientTextBox"); break; }
+	case RECORD_TYPE_ESCHER_ANCHOR									: { strName = ("Anchor"); break; }
+	case RECORD_TYPE_ESCHER_CHILDANCHOR								: { strName = ("ChildAnchor"); break; }
+	case RECORD_TYPE_ESCHER_CLIENTANCHOR							: { strName = ("ClientAnchor"); break; }
+	case RECORD_TYPE_ESCHER_CLIENTDATA								: { strName = ("ClientData"); break; }
+	case RECORD_TYPE_ESCHER_SOLVERCONTAINER							: { strName = ("SolverContainer"); break; }
+	case RECORD_TYPE_ESCHER_CONNECTORRULE							: { strName = ("ConnectorRule"); break; }
+	case RECORD_TYPE_ESCHER_ALIGNRULE								: { strName = ("AlignRule"); break; }
+	case RECORD_TYPE_ESCHER_ARCRULE									: { strName = ("ArcRule"); break; }
+	case RECORD_TYPE_ESCHER_CLIENTRULE								: { strName = ("ClientRule"); break; }
+	case RECORD_TYPE_ESCHER_CALLOUTRULE								: { strName = ("CallOutRule"); break; }
+	case RECORD_TYPE_ESCHER_SELECTION								: { strName = ("Selection"); break; }
+	case RECORD_TYPE_ESCHER_COLORMRU								: { strName = ("ColorMRU"); break; }
+	case RECORD_TYPE_ESCHER_DELETEDPSPL								: { strName = ("DeletedPSPL"); break; }
+	case RECORD_TYPE_ESCHER_SPLITMENUCOLORS							: { strName = ("SplitMenuColors"); break; }
+	case RECORD_TYPE_ESCHER_OLEOBJECT								: { strName = ("OleObject"); break; }
+	case RECORD_TYPE_ESCHER_SECONDARY_OPT							: { strName = ("SecondaryOPT"); break; }
+	case RECORD_TYPE_ESCHER_TETRIARY_OPT							: { strName = ("TetriaryOPT"); break; }
 	default: break;
 	};
 
 	if ((dwType > RECORD_TYPE_ESCHER_BLIP_START) && (dwType < RECORD_TYPE_ESCHER_BLIP_END))
 	{
-		strName = ("Escher_Blip");
+		strName = ("Blip");
 	}
 
 	return strName;

ASCOfficePPTFile/PPTFormatLib/Reader/Records.cpp

@@ -95,8 +95,8 @@ IRecord* CreateByType(SRecordHeader oHeader)
 	//CREATE_BY_TYPE(RECORD_TYPE_DOC_ROUTING_SLIP			, CRecordDocRoutingSlipAtom)
 	//CREATE_BY_TYPE(RECORD_TYPE_EXOBJLIST_ATOM				, CRecordExObjListAtom)
 	//CREATE_BY_TYPE(RECORD_TYPE_UNKNOWN					, CRecordGridSpacing10Atom)
-	//CREATE_BY_TYPE(RECORD_TYPE_UNKNOWN					, CRecordRoundTripThemeAtom)
-	//CREATE_BY_TYPE(RECORD_TYPE_UNKNOWN					, CRecordRoundTripColorMappingAtom)
+	CREATE_BY_TYPE(RT_RoundTripTheme12Atom					, CRecordRoundTripThemeAtom)
+	CREATE_BY_TYPE(RT_RoundTripColorMapping12Atom			, CRecordRoundTripColorMappingAtom)
 	//CREATE_BY_TYPE(RECORD_TYPE_NAMEDSHOW_SLIDES			, CRecordNamedShowSlidesAtom)
 	//CREATE_BY_TYPE(RECORD_TYPE_SHEET_PROPERTIES			, CRecordNormalViewSetInfoAtom)
 
@@ -109,10 +109,10 @@ IRecord* CreateByType(SRecordHeader oHeader)
 	CREATE_BY_TYPE(RECORD_TYPE_ROUNDTRIPHFPLACEHOLDER12		, CRecordRoundTripHFPlaceholder12Atom)
 	//CREATE_BY_TYPE(RECORD_TYPE_ROUNDTRIPCONTENTMASTERID	, CRecordRoundTripContentMasterId12Atom)
 	//CREATE_BY_TYPE(RECORD_TYPE_ROUNDTRIPOARTTEXTSTYLES12	, CRecordRoundTripOArtTextStyles12Atom)
-	CREATE_BY_TYPE(RECORD_TYPE_ROUNDTRIPHEADERFOOTERDEFAULTS12ATOM		, CRecordRoundTripHeaderFooterDefaults12Atom)
+	CREATE_BY_TYPE(RECORD_TYPE_ROUNDTRIPHEADERFOOTERDEFAULTS12ATOM	, CRecordRoundTripHeaderFooterDefaults12Atom)
+	CREATE_BY_TYPE(RECORD_TYPE_ROUNDTRIPNOTESMASTERTEXTSTYLES12		, CRecordRoundTripNotesMasterTextStyles12Atom)
 	//CREATE_BY_TYPE(RECORD_TYPE_ROUNDTRIPDOCFLAGS12						, CRecordRoundTripDocFlags12Atom)
 	//CREATE_BY_TYPE(RECORD_TYPE_ROUNDTRIPSHAPECHECKSUMFORCUSTOMLAYOUTS12	, CRecordRoundTripShapeCheckSumForCustomLayouts12Atom)
-	//CREATE_BY_TYPE(RECORD_TYPE_ROUNDTRIPNOTESMASTERTEXTSTYLES12			, CRecordRoundTripNotesMasterTextStyles12Atom)
 	//CREATE_BY_TYPE(RECORD_TYPE_ROUNDTRIPCUSTOMTABLESTYLES12				, CRecordRoundTripCustomTableStyles12Atom)
 	
 	//CREATE_BY_TYPE(RECORD_TYPE_BOOKMARK_SEED_ATOM			, CRecordBookmarkSeedAtom)

ASCOfficePPTFile/PPTFormatLib/Reader/Records.h

@@ -182,7 +182,7 @@ public:
 			return;
 
 		// возвращаем указатели, их не удалять наверху!!!!
-		for (int nIndex = 0; nIndex < m_arRecords.size(); ++nIndex)
+		for (size_t nIndex = 0; nIndex < m_arRecords.size(); ++nIndex)
 		{
 			T pRec = dynamic_cast<T>(m_arRecords[nIndex]);
 			if (NULL != pRec)

ASCOfficePPTFile/PPTFormatLib/Reader/SlideInfo.h

@@ -85,7 +85,6 @@ public:
 	std::map<int, std::wstring>*						m_mapFilePictures;
 	nullable_base<NSPresentationEditor::CTextStyles>	m_pStyles[9];
 
-public:
 	CSlideInfo()
 	{
 	}

ASCOfficePPTFile/PPTFormatLib/Records/Animations/AnimationTypes.h

@@ -206,7 +206,7 @@ namespace Animations
             std::vector<std::wstring> arMovePath;
             boost::algorithm::split(arMovePath, MovePath, boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
 
-            for (int i = 0 ; i < arMovePath.size(); i++)
+            for (size_t i = 0 ; i < arMovePath.size(); i++)
 			{
 				ActionPoint	aPoint;
                 aPoint.TYPE		=	arMovePath[i++][0];
@@ -245,7 +245,7 @@ namespace Animations
 		{
             std::wstring	MovePath;
 
-			for ( int i = 0; i < m_Points.size(); ++i )
+			for ( size_t i = 0; i < m_Points.size(); ++i )
 			{
                 std::wstring NextPoint;
 

ASCOfficePPTFile/PPTFormatLib/Records/DocumentRecords.h

@@ -39,9 +39,7 @@ public:
 	std::vector<SSlidePersist> m_arNotePersists;
 	std::vector<SSlidePersist> m_arSlidePersists;
 
-public:
-	
-	CRecordDocument() : m_arMasterPersists(), m_arNotePersists(), m_arSlidePersists()
+	CRecordDocument() 
 	{
 	}
 
@@ -52,84 +50,6 @@ public:
 		m_arSlidePersists.clear();
 	}
 
-	/*virtual void ReadFromStream(SRecordHeader & oHeader, POLE::Stream* pStream)
-	{
-		m_oHeader = oHeader;
-
-		m_arMasterPersists.clear();
-		m_arNotePersists.clear();
-		m_arSlidePersists.clear();		
-		
-		m_arRecords.clear();
-
-		UINT lCurLen = 0;
-		ULONG lReadLen = 0;
-		SRecordHeader oRec;
-		while (lCurLen < m_oHeader.RecLen)
-		{
-			pStream->Read(&oRec, sizeof(oRec), &lReadLen);
-			if (0 >= lReadLen)
-			{
-				break;
-			}
-
-			if (RECORD_TYPE_SLIDELISTWITHTEXT == oRec.RecType)
-			{
-				CRecordSlideListWithText* pAtom = new CRecordSlideListWithText();
-				pAtom->ReadFromStream(oRec, pStream);
-				std::vector<SSlidePersist>* pArray = NULL;
-
-				switch (pAtom->m_Type)
-                {
-				case CRecordSlideListWithText::CollectionOfMasterSlides:
-					{
-						pArray = &m_arMasterPersists;
-                        break;
-					}
-
-				case CRecordSlideListWithText::CollectionOfNotesSlides:
-					{
-						pArray = &m_arNotePersists;
-                        break;
-					}
-
-				case CRecordSlideListWithText::CollectionOfSlides:
-					{
-						pArray = &m_arSlidePersists;
-                        break;
-					}
-				default:
-					{
-						// этого не может быть...
-						lCurLen += (8 + oRec.RecLen);
-						continue;
-					}
-                };
-				
-				size_t nCountItems = pAtom->m_arSlides.size();
-				for (size_t index = 0; index < nCountItems; ++index)
-				{
-					SSlidePersist oPersist;
-					oPersist.m_nPsrRef = pAtom->m_arSlides[index]->m_nPsrRef;
-					oPersist.m_nSlideID = pAtom->m_arSlides[index]->m_nSlideID;
-
-                    oPersist.m_arTextAttrs += pAtom->m_arTextPlaceHolders[index];
-
-					pArray->Add(oPersist);
-				}
-
-				delete pAtom;
-			}
-			else
-			{
-				IRecord* pRecord = CreateByType(oRec);
-				pRecord->ReadFromStream(oRec, pStream);
-				m_arRecords.Add(pRecord);
-			}
-			lCurLen += (8 + oRec.RecLen);
-		}
-	}*/
-
 	virtual void ReadFromStream(SRecordHeader & oHeader, POLE::Stream* pStream)
 	{
 		m_oHeader = oHeader;
@@ -145,31 +65,26 @@ public:
 		std::vector<CRecordSlideListWithText*> oArraySlideWithText;
 		this->GetRecordsByType(&oArraySlideWithText, true, false);
 
-		for (int nIndexList = 0; nIndexList < oArraySlideWithText.size(); ++nIndexList)
+		for (size_t nIndexList = 0; nIndexList < oArraySlideWithText.size(); ++nIndexList)
 		{
 			CRecordSlideListWithText* pAtom = oArraySlideWithText[nIndexList];
 			std::vector<SSlidePersist>* pArray = NULL;
 
 			switch (pAtom->m_Type)
             {
-			case CRecordSlideListWithText::CollectionOfMasterSlides:
+				case CRecordSlideListWithText::CollectionOfMasterSlides:
 				{
-					pArray = &m_arMasterPersists;
-                    break;
-				}
-
-			case CRecordSlideListWithText::CollectionOfNotesSlides:
+					pArray = &m_arMasterPersists;                    
+				}break;
+				case CRecordSlideListWithText::CollectionOfNotesSlides:
 				{
-					pArray = &m_arNotePersists;
-                    break;
-				}
-
-			case CRecordSlideListWithText::CollectionOfSlides:
+					pArray = &m_arNotePersists;                
+				}break;
+				case CRecordSlideListWithText::CollectionOfSlides:
 				{
-					pArray = &m_arSlidePersists;
-                    break;
-				}
-			default:
+					pArray = &m_arSlidePersists;                
+				}break;
+				default:
 				{
 					// этого не может быть...
 					continue;

ASCOfficePPTFile/PPTFormatLib/Records/Drawing/BlipStoreContainer.h

@@ -53,7 +53,7 @@ public:
 		pArray->clear();
 
 		std::map<DWORD, int> image_map;
-		for (int nIndex = 0; nIndex < m_arRecords.size(); ++nIndex)
+		for (size_t nIndex = 0; nIndex < m_arRecords.size(); ++nIndex)
 		{
 			CRecordBlipStoreEntry* pEntry = dynamic_cast<CRecordBlipStoreEntry*>(m_arRecords[nIndex]);
 			if (NULL != pEntry)

ASCOfficePPTFile/PPTFormatLib/Records/Drawing/GroupShapeContainer.h

@@ -71,7 +71,7 @@ public:
 			oArrayShapes[0]->bGroupShape = true;//тут описание самой группы
 
 		int nIndexBreak = -1;
-		for (int nIndex = 0; nIndex < oArrayShapes.size(); ++nIndex)
+		for (size_t nIndex = 0; nIndex < oArrayShapes.size(); ++nIndex)
 		{
 			std::vector<CRecordGroupShape*> oArrayGroupShapes;
 			oArrayShapes[nIndex]->GetRecordsByType(&oArrayGroupShapes, false, true);
@@ -120,7 +120,7 @@ public:
         bool bIsRecalc = ((lW1 > 0) && (lH1 > 0) && (lW2 > 0) && (lH2 > 0));
 		if (bIsRecalc)
 		{
-			for (int nIndex = 0; nIndex < oArrayShapes.size(); ++nIndex)
+			for (size_t nIndex = 0; nIndex < oArrayShapes.size(); ++nIndex)
 			{
 				if (nIndex != nIndexBreak)
 				{

ASCOfficePPTFile/PPTFormatLib/Records/Drawing/ShapeContainer.h

@@ -575,212 +575,134 @@ public:
 			}
 // line --------------------------------------------------------
 		case lineBoolean: //Line Style Boolean Properties
-			{
-				bool bNoLineDrawDash		= GETBIT(pProperty->m_lValue, 0);
-				bool bLineFillShape			= GETBIT(pProperty->m_lValue, 1);
-				bool bHitTestLine			= GETBIT(pProperty->m_lValue, 2);
-				bool bLine					= GETBIT(pProperty->m_lValue, 3);
-				bool bArrowheadsOK			= GETBIT(pProperty->m_lValue, 4);
-				bool bInsetPenOK			= GETBIT(pProperty->m_lValue, 5);
-				bool bInsetPen				= GETBIT(pProperty->m_lValue, 6);
-				bool bLineOpaqueBackColor	= GETBIT(pProperty->m_lValue, 9);
+		{
+			bool bNoLineDrawDash		= GETBIT(pProperty->m_lValue, 0);
+			bool bLineFillShape			= GETBIT(pProperty->m_lValue, 1);
+			bool bHitTestLine			= GETBIT(pProperty->m_lValue, 2);
+			bool bLine					= GETBIT(pProperty->m_lValue, 3);
+			bool bArrowheadsOK			= GETBIT(pProperty->m_lValue, 4);
+			bool bInsetPenOK			= GETBIT(pProperty->m_lValue, 5);
+			bool bInsetPen				= GETBIT(pProperty->m_lValue, 6);
+			bool bLineOpaqueBackColor	= GETBIT(pProperty->m_lValue, 9);
 
-				bool bUsefNoLineDrawDash	= GETBIT(pProperty->m_lValue, 16);
-				bool bUsefLineFillShape		= GETBIT(pProperty->m_lValue, 17);
-				bool bUsefHitTestLine		= GETBIT(pProperty->m_lValue, 18);
-				bool bUsefLine				= GETBIT(pProperty->m_lValue, 19);
-				bool bUsefArrowheadsOK		= GETBIT(pProperty->m_lValue, 20);
-				bool bUsefInsetPenOK		= GETBIT(pProperty->m_lValue, 21);
-				bool bUsefInsetPen			= GETBIT(pProperty->m_lValue, 22);
-				bool bUsefLineOpaqueBackColor = GETBIT(pProperty->m_lValue, 25);
+			bool bUsefNoLineDrawDash	= GETBIT(pProperty->m_lValue, 16);
+			bool bUsefLineFillShape		= GETBIT(pProperty->m_lValue, 17);
+			bool bUsefHitTestLine		= GETBIT(pProperty->m_lValue, 18);
+			bool bUsefLine				= GETBIT(pProperty->m_lValue, 19);
+			bool bUsefArrowheadsOK		= GETBIT(pProperty->m_lValue, 20);
+			bool bUsefInsetPenOK		= GETBIT(pProperty->m_lValue, 21);
+			bool bUsefInsetPen			= GETBIT(pProperty->m_lValue, 22);
+			bool bUsefLineOpaqueBackColor = GETBIT(pProperty->m_lValue, 25);
 
-				if (bUsefLine)
-					pElement->m_bLine = bLine;				
-			}break;
-		case lineStyle:
+			if (bUsefLine)
+				pElement->m_bLine = bLine;				
+		}break;
 		case lineDashStyle://from Complex
-			{
-				pElement->m_bLine = true;	
-			}break;
+		{
+			pElement->m_bLine = true;	
+		}break;
 		case lineColor:
-			{
-				SColorAtom oAtom;
-				oAtom.FromValue(pProperty->m_lValue);
-				
-				if (oAtom.bSysIndex)
-					pElement->m_oPen.Color = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
-				else
-					oAtom.ToColor(&pElement->m_oPen.Color);
-				break;
-			}
+		{
+			SColorAtom oAtom;
+			oAtom.FromValue(pProperty->m_lValue);
+			
+			if (oAtom.bSysIndex)
+				pElement->m_oPen.Color = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
+			else
+				oAtom.ToColor(&pElement->m_oPen.Color);			
+		}break;
 		case lineOpacity:
-			{
-                pElement->m_oPen.Alpha = (BYTE)(std::min)(255, (int)CDirectory::NormFixedPoint(pProperty->m_lValue, 255));
-				break;
-			}
+		{
+            pElement->m_oPen.Alpha = (BYTE)(std::min)(255, (int)CDirectory::NormFixedPoint(pProperty->m_lValue, 255));				
+		}break;
 		case lineBackColor:
-			{
-				SColorAtom oAtom;
-				oAtom.FromValue(pProperty->m_lValue);
-				
-				if (oAtom.bSysIndex)
-					pElement->m_oPen.Color2 = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
-				else 
-					oAtom.ToColor(&pElement->m_oPen.Color2);
+		{
+			SColorAtom oAtom;
+			oAtom.FromValue(pProperty->m_lValue);
+			
+			if (oAtom.bSysIndex)
+				pElement->m_oPen.Color2 = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
+			else 
+				oAtom.ToColor(&pElement->m_oPen.Color2);
 
-			}break;
+		}break;
 		case lineWidth:
-			{
-				pElement->m_oPen.Size	= (double)pProperty->m_lValue / EMU_MM;
-				pElement->m_bLine		= true;
-				break;
-			}
+		{
+			pElement->m_oPen.Size	= (double)pProperty->m_lValue / EMU_MM;
+			pElement->m_bLine		= true;				
+		}break;
+		case lineStyle:
+		{
+			pElement->m_bLine			= true;
+			pElement->m_oPen.LineStyle	= pProperty->m_lValue;				
+		}break;
 		case lineDashing:
-			{
-				BYTE nDashStyle = 0;
-				switch (pProperty->m_lValue)
-				{
-				case 0: 
-					{ 
-						nDashStyle = 0; // solid 						 
-					}break;
-				case 1: 
-				case 6:
-				case 7:
-					{ 
-						nDashStyle = 1; // dash 						
-					}break; 
-				case 2:
-				case 5:
-					{ 
-						nDashStyle = 2; // dot 						 
-					}break;
-				case 3:
-				case 8:
-				case 9:
-					{ 
-						nDashStyle = 3; // dashdot 						
-					}break; 
-				case 4:
-				case 10:
-					{ 
-						nDashStyle = 4;// dashdotdot 						
-					}break; 
-				default:
-						break; 
-				};
-				pElement->m_bLine				= true;
-				pElement->m_oPen.DashStyle	= nDashStyle;
-				break;
-			}
+		{
+			pElement->m_bLine			= true;
+			pElement->m_oPen.DashStyle	= pProperty->m_lValue;				
+		}break;
 		case lineJoinStyle:
-			{
-				BYTE nLineJoin = 2;
-				switch (pProperty->m_lValue)
-				{
-				case 0: 
-					{ 
-						nLineJoin = 1; // bevel 						 
-					}break;
-				case 1: 
-					{ 
-						nLineJoin = 1; // Miter 						 
-					}break;
-				case 2:
-					{ 
-						nLineJoin = 2; // round 						 
-					}break;	
-				default:
-						break; 
-				};
-
-				pElement->m_oPen.LineJoin = nLineJoin;
-				break;
-			}
+		{
+			pElement->m_oPen.LineJoin = pProperty->m_lValue;				
+		}break;
+		case lineStartArrowLength:
+		{
+			pElement->m_oPen.LineStartLength = pProperty->m_lValue;				
+		}break;
+		case lineEndArrowLength:
+		{
+			pElement->m_oPen.LineEndLength = pProperty->m_lValue;				
+		}break;
+		case lineStartArrowWidth:
+		{
+			pElement->m_oPen.LineStartWidth = pProperty->m_lValue;				
+		}break;
+		case lineEndArrowWidth:
+		{
+			pElement->m_oPen.LineEndWidth = pProperty->m_lValue;				
+		}break;
 		case lineStartArrowhead:
-			{
-				BYTE nStartCap = 0;
-				switch (pProperty->m_lValue)
-				{
-				case 1: 
-				case 2:
-				case 5:
-					{ 
-						nStartCap = 0x14; 
-					}break;
-				case 3:
-				case 4:
-
-					{ 
-						nStartCap = 2; 
-					}break; 
-				default:
-						break; 
-				};
-
-				pElement->m_oPen.LineStartCap = nStartCap;
-
-				break;
-			}
+		{
+			pElement->m_oPen.LineStartCap = pProperty->m_lValue;				
+		}break;
 		case lineEndArrowhead:
-			{
-				BYTE nEndCap = 0;
-				switch (pProperty->m_lValue)
-				{
-				case 1: 
-				case 2:
-				case 5:
-					{ 
-						nEndCap = 0x14; 						
-					}break; 
-				case 3:
-				case 4:
-
-					{ 
-						nEndCap = 2; 
-					}break; 
-				default:
-					break; 
-				};
-
-				pElement->m_oPen.LineEndCap = nEndCap;
-				break;
-			}
+		{
+			pElement->m_oPen.LineEndCap = pProperty->m_lValue;			
+		}break;
 		case shadowType:
-			{
-				pElement->m_oShadow.Type = pProperty->m_lValue;
-
-			}break;
+		{
+			pElement->m_oShadow.Type = pProperty->m_lValue;
+		}break;
 		case shadowOriginX://in emu, relative from center shape
-			{
-				pElement->m_oShadow.OriginX = FixedPointToDouble(pProperty->m_lValue);
-			}break;
+		{
+			pElement->m_oShadow.OriginX = FixedPointToDouble(pProperty->m_lValue);
+		}break;
 		case shadowOriginY:
-			{
-				pElement->m_oShadow.OriginY = FixedPointToDouble(pProperty->m_lValue);
-			}break;
+		{
+			pElement->m_oShadow.OriginY = FixedPointToDouble(pProperty->m_lValue);
+		}break;
 		case shadowColor:
-			{
-				SColorAtom oAtom;
-				oAtom.FromValue(pProperty->m_lValue);
+		{
+			SColorAtom oAtom;
+			oAtom.FromValue(pProperty->m_lValue);
 
-				if (oAtom.bSysIndex)
-					pElement->m_oShadow.Color = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
-				else
-					oAtom.ToColor(&pElement->m_oShadow.Color);
+			if (oAtom.bSysIndex)
+				pElement->m_oShadow.Color = CorrectSysColor(pProperty->m_lValue, pElement, pTheme);
+			else
+				oAtom.ToColor(&pElement->m_oShadow.Color);
 
-			}break;
+		}break;
 		case shadowWeight:
 			{
 			}break;
 		case shadowOpacity:
-			{
-                pElement->m_oShadow.Alpha = (BYTE)(std::min)(255, (int)CDirectory::NormFixedPoint(pProperty->m_lValue, 255));
-			}break;
+		{
+            pElement->m_oShadow.Alpha = (BYTE)(std::min)(255, (int)CDirectory::NormFixedPoint(pProperty->m_lValue, 255));
+		}break;
 		case shadowHighlight:
-			{
-				//оттенок двойной тени
-			}break;
+		{
+			//оттенок двойной тени
+		}break;
 		case shadowOffsetX:
 			{
 				pElement->m_oShadow.DistanceX = ((int)pProperty->m_lValue) / EMU_MM;
@@ -949,65 +871,80 @@ public:
 
 		switch (pProperty->m_ePID)
 		{
-			// здесь просто применяем проперти...
-			// geometry ----------------------------------------------------
-			// top, left, right, bottom logic
 		case NSOfficeDrawing::metroBlob:
-			{
-				//альтернатива в формате oox
-				//NSFile::CFileBinary f;
-				//f.CreateFileW(L"d:\\test.zip");
-				//f.WriteFile(pProperty->m_pOptions, pProperty->m_lValue);
-				//f.CloseFile();
-			}break;
+		{
+			//альтернатива в формате oox
+			//NSFile::CFileBinary f;
+			//f.CreateFileW(L"d:\\test.zip");
+			//f.WriteFile(pProperty->m_pOptions, pProperty->m_lValue);
+			//f.CloseFile();
+		}break;
 		case NSOfficeDrawing::geoRight:
-			{
-				if (0 < pProperty->m_lValue)
-					pParentShape->m_dWidthLogic = (double)(pProperty->m_lValue);				
-			}break;
+		{
+			if (0 < pProperty->m_lValue)
+				pParentShape->m_dWidthLogic = (double)(pProperty->m_lValue);				
+		}break;
 		case NSOfficeDrawing::geoBottom:
-			{
-				if (0 < pProperty->m_lValue)
-					pParentShape->m_dHeightLogic = (double)(pProperty->m_lValue);				
-			}break;
-			// shapePath
+		{
+			if (0 < pProperty->m_lValue)
+				pParentShape->m_dHeightLogic = (double)(pProperty->m_lValue);				
+		}break;
 		case NSOfficeDrawing::shapePath:
-			{
-				pShape->m_oCustomVML.SetPath((RulesType)pProperty->m_lValue);				
-				pShape->m_bCustomShape = true;
-			}break;
-			// segmentsInfo
+		{
+			pShape->m_oCustomVML.SetPath((RulesType)pProperty->m_lValue);				
+			pShape->m_bCustomShape = true;
+		}break;
 		case NSOfficeDrawing::pSegmentInfo:
+		{
+			if (pProperty->m_bComplex)
 			{
-				if (pProperty->m_bComplex)
-				{
-					pShape->m_oCustomVML.LoadSegments(pProperty);
-					pShape->m_bCustomShape = true;
-				}				
-			}break;
-			// verticesInfo
+				pShape->m_oCustomVML.LoadSegments(pProperty);
+				pShape->m_bCustomShape = true;
+			}				
+		}break;
 		case NSOfficeDrawing::pVertices:
+		{
+			if (pProperty->m_bComplex)
 			{
-				if (pProperty->m_bComplex)
-				{
-					pShape->m_oCustomVML.LoadVertices(pProperty);
-					pShape->m_bCustomShape = true;
-				}				
-			}break;
+				pShape->m_oCustomVML.LoadVertices(pProperty);
+				pShape->m_bCustomShape = true;
+			}				
+		}break;
+		case NSOfficeDrawing::pConnectionSites:
+		{
+			if (pProperty->m_bComplex)
+			{
+				pShape->m_oCustomVML.LoadConnectionSites(pProperty);
+			}				
+		}break;
+		case NSOfficeDrawing::pConnectionSitesDir:
+		{
+			if (pProperty->m_bComplex)
+			{
+				pShape->m_oCustomVML.LoadConnectionSitesDir(pProperty);
+			}				
+		}break;
 		case NSOfficeDrawing::pGuides:
+		{
+			if (pProperty->m_bComplex/* && pShape->m_eType != sptNotchedCircularArrow*/)
+			{//Тікбұрышты үшбұрыштарды.ppt - slide 25
+				pShape->m_oCustomVML.LoadGuides(pProperty);
+			}				
+		}break;
+		case NSOfficeDrawing::pInscribe:
+		{
+			if (pProperty->m_bComplex)
 			{
-				if (pProperty->m_bComplex && pShape->m_eType != sptNotchedCircularArrow)
-				{//Тікбұрышты үшбұрыштарды.ppt - slide 25
-					pShape->m_oCustomVML.LoadGuides(pProperty);
-				}				
-			}break;
+				pShape->m_oCustomVML.LoadInscribe(pProperty);
+			}
+		}break;
 		case NSOfficeDrawing::pAdjustHandles:
+		{
+			if (pProperty->m_bComplex)
 			{
-				if (pProperty->m_bComplex)
-				{
-					pShape->m_oCustomVML.LoadAHs(pProperty);
-				}				
-			}break;
+				pShape->m_oCustomVML.LoadAHs(pProperty);
+			}				
+		}break;
 		case NSOfficeDrawing::adjustValue:
 		case NSOfficeDrawing::adjust2Value:
 		case NSOfficeDrawing::adjust3Value:
@@ -1890,7 +1827,7 @@ protected:
 		
 		if (master_levels)
 		{
-			for (int i = 0; i < pText->m_arParagraphs.size(); i++)
+			for (size_t i = 0; i < pText->m_arParagraphs.size(); i++)
 			{
 				if (i >= master_levels->m_arrProps.size()) break;
 				
@@ -2198,7 +2135,7 @@ protected:
 						pTextSettings->m_oStyles.ApplyAfter(pThemeWrapper->m_pStyles[nIndexType].get());
 				}
 			}
-			if (eTypeOwn != NSOfficePPT::NoPresent && eTypeOwn != NSOfficePPT::Other && eTypeOwn != eTypePersist && eTypeOwn != eTypeMaster)
+			if (eTypeOwn != NSOfficePPT::NoPresent/* && eTypeOwn != NSOfficePPT::Other*/ && eTypeOwn != eTypePersist && eTypeOwn != eTypeMaster)
 			{
 				int nIndexType = (int)eTypeOwn;