up

v4.3.6 v4.3.6

.gitignore

@@ -20,6 +20,7 @@ Common/3dParty/v8/win_32
 Common/3dParty/v8/linux_64
 Common/3dParty/v8/linux_32
 Common/3dParty/v8/mac_64
+Common/3dParty/openssl/openssl
 **/core_build
 **/Release
 **/Debug
@@ -43,3 +44,4 @@ OfficeUtils/win32/OfficeUtilsLib/OfficeUtilsLib/ReadMe.txt
 *.pdb
 *.tlb
 *.idb
+**/.hg

.travis.yml

@@ -1 +1,14 @@
-language: cpp
+language: cpp
+compiler: gcc
+dist: trusty
+addons:
+  apt:
+    packages:
+      - p7zip-full
+script:
+  - exit 0
+# Build fails anyway. See explanation in
+# https://github.com/ONLYOFFICE/core/pull/29#issuecomment-306773327
+  - cd Common/3dParty && ./make.sh
+  - cd ../../
+  - make

ASCOfficeDocFile/DocDocxConverter/DocumentMapping.cpp

@@ -811,10 +811,10 @@ namespace DocFileFormat
 			{
 				Symbol s = getSymbol( chpx );
 
-                m_pXmlWriter->WriteNodeBegin(L"w:sym", true);
-                m_pXmlWriter->WriteAttribute(L"w:font", FormatUtils::XmlEncode(s.FontName));
-                m_pXmlWriter->WriteAttribute(L"w:char", FormatUtils::XmlEncode(s.HexValue));
-                m_pXmlWriter->WriteNodeEnd(L"", true);
+                //m_pXmlWriter->WriteNodeBegin(L"w:sym", true);
+                //m_pXmlWriter->WriteAttribute(L"w:font", FormatUtils::XmlEncode(s.FontName));
+                //m_pXmlWriter->WriteAttribute(L"w:char", FormatUtils::XmlEncode(s.HexValue));
+                //m_pXmlWriter->WriteNodeEnd(L"", true);
 			}
 			else if ((TextMark::DrawnObject == code) && fSpec)
 			{
@@ -1663,12 +1663,17 @@ namespace DocFileFormat
 				FontFamilyName* ffn = static_cast<FontFamilyName*>( m_document->FontTable->operator [] ( fontIndex ) );
 
 				ret.FontName = ffn->xszFtn;
-                ret.HexValue = L"f0" + FormatUtils::IntToFormattedWideString( code, L"%02x" );
+                ret.HexValue = L"f0" + FormatUtils::IntToFormattedWideString( code, L"%02x" );//-123 - ShortToFormattedWideString
 
 				break;
 			}		
 		}
 
+		if (ret.HexValue.length() > 4)
+		{
+			ret.HexValue = ret.HexValue.substr(ret.HexValue.length() - 4, 4);
+		}
+
 		return ret;
 	}
 

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);
 				}
 			}
 		}
@@ -163,104 +184,100 @@ namespace DocFileFormat
 			std::vector<PathSegment>::const_iterator end = m_arSegments.end();
 			for (std::vector<PathSegment>::const_iterator iter = m_arSegments.begin(); iter != end; ++iter, cc++)
 			{
-				try
+				switch (iter->Type)
 				{
-					switch (iter->Type)
+				case PathSegment::msopathLineTo:
 					{
-					case PathSegment::msopathLineTo:
+						for (int i = 0; i < iter->Count; ++i)
 						{
-							for (int i = 0; i < iter->Count; ++i)
+							if (valuePointer + 1 > (int)m_arPoints.size())
 							{
-								if (valuePointer >= (int)m_arPoints.size())
-								{
-									break;
+								break;
 
-                                    strVmlPath += L"l";
-									strVmlPath += FormatUtils::IntToWideString(m_arPoints[0].x);
-                                    strVmlPath += L",";
-									strVmlPath += FormatUtils::IntToWideString(m_arPoints[0].y);
-									
-									++valuePointer;
-									
-									//break;
-								}
-								else
-								{
-                                    strVmlPath += L"l";
-									strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer].x );
-                                    strVmlPath += L",";
-									strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer].y );
-									
-									++valuePointer;
-								}
+                                strVmlPath += L"l";
+								strVmlPath += FormatUtils::IntToWideString(m_arPoints[0].x);
+                                strVmlPath += L",";
+								strVmlPath += FormatUtils::IntToWideString(m_arPoints[0].y);
+								
+								++valuePointer;
+								
+								//break;
 							}
-						}
-						break;
-
-					case PathSegment::msopathCurveTo:
-						{
-							for (int i = 0; i < iter->Count; ++i)
+							else
 							{
-                                strVmlPath += L"c";
+                                strVmlPath += L"l";
 								strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer].x );
                                 strVmlPath += L",";
 								strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer].y );
-                                strVmlPath += L",";
-								strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer + 1].x );
-                                strVmlPath += L",";
-								strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer + 1].y );
-                                strVmlPath += L",";
-								strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer + 2].x );
-                                strVmlPath += L",";
-								strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer + 2].y );
-								valuePointer += 3;
+								
+								++valuePointer;
 							}
 						}
-						break;
+					}
+					break;
 
-					case PathSegment::msopathMoveTo:
+				case PathSegment::msopathCurveTo:
+					{
+						for (int i = 0; i < iter->Count; ++i)
 						{
-                            strVmlPath += L"m";
+							if (valuePointer + 3 > (int)m_arPoints.size()) 
+								break;
+                            strVmlPath += L"c";
 							strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer].x );
                             strVmlPath += L",";
 							strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer].y );
+                            strVmlPath += L",";
+							strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer + 1].x );
+                            strVmlPath += L",";
+							strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer + 1].y );
+                            strVmlPath += L",";
+							strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer + 2].x );
+                            strVmlPath += L",";
+							strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer + 2].y );
+							valuePointer += 3;
+						}
+					}
+					break;
+
+				case PathSegment::msopathMoveTo:
+					{
+						if (valuePointer < (int)m_arPoints.size()) 
+						{
+							strVmlPath += L"m";
+							strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer].x );
+							strVmlPath += L",";
+							strVmlPath += FormatUtils::IntToWideString(m_arPoints[valuePointer].y );
 							
 							++valuePointer;
 						}
-						break;
-
-					case PathSegment::msopathClose:
-						{
-                            strVmlPath += L"x";
-						}
-						break;
-
-					case PathSegment::msopathEnd:
-						{
-                            strVmlPath += L"e";
-						}
-						break;
-
-					case PathSegment::msopathEscape:
-						{
-							if (PathSegment::msopathEscapeNoFill == iter->EscapeCode)
-                                strVmlPath += L"nf";
-							
-							if (PathSegment::msopathEscapeNoLine == iter->EscapeCode)
-                                strVmlPath += L"ns";
-						}
-					case PathSegment::msopathClientEscape:
-					case PathSegment::msopathInvalid:
-						{
-							//ignore escape segments and invalid segments
-						}
-						break;
 					}
-				}
-				catch (...)
-				{
-					// Sometimes there are more Segments than available m_arPoints.
-					// Accordingly to the spec this should never happen :)
+					break;
+
+				case PathSegment::msopathClose:
+					{
+                        strVmlPath += L"x";
+					}
+					break;
+
+				case PathSegment::msopathEnd:
+					{
+                        strVmlPath += L"e";
+					}
+					break;
+
+				case PathSegment::msopathEscape:
+					{
+						if (PathSegment::msopathEscapeNoFill == iter->EscapeCode)
+                            strVmlPath += L"nf";
+						
+						if (PathSegment::msopathEscapeNoLine == iter->EscapeCode)
+                            strVmlPath += L"ns";
+					}
+				case PathSegment::msopathClientEscape:
+				case PathSegment::msopathInvalid:
+					{
+						//ignore escape segments and invalid segments
+					}
 					break;
 				}
 			}

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

@@ -136,14 +136,18 @@ namespace DocFileFormat
 		}
 		return btWin32;
 	}
-	bool ParseEmbeddedEquation( const std::string & xmlString, std::wstring & newXmlString)
+	bool VMLPictureMapping::ParseEmbeddedEquation( const std::string & xmlString, std::wstring & newXmlString)
 	{
 		newXmlString.clear();
-        std::wstring sTempXmlFile = NSDirectory::CreateTempFileWithUniqueName(
-                                                    NSDirectory::GetTempPath(), L"emb");
 
-		sTempXmlFile += L".xml";
-		
+		std::wstring sTempFolder = m_ctx->_doc->m_sTempFolder;
+		if (sTempFolder.empty())
+		{
+            sTempFolder = NSFile::CFileBinary::GetTempPath();
+		}
+
+		std::wstring sTempXmlFile = NSDirectory::CreateTempFileWithUniqueName(sTempFolder, L"emb");
+
 		NSFile::CFileBinary file; 
 		file.CreateFileW(sTempXmlFile);
 		file.WriteFile((BYTE*)xmlString.c_str(), xmlString.size());
@@ -186,6 +190,7 @@ namespace DocFileFormat
 				if (res) break;
 			}
 		}
+		NSFile::CFileBinary::Remove(sTempXmlFile);
 		return res;
 	}
 //---------------------------------------------------------------
@@ -236,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)
@@ -277,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:
@@ -287,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))
 					{
@@ -297,8 +302,13 @@ namespace DocFileFormat
 			case metroBlob:
 				{
 					//встроенная неведомая хуйня
-					m_isEmbedded = true;
-					m_embeddedData = std::string((char*)iter->opComplex, iter->op);
+					m_isEmbedded	= true;
+					m_embeddedData	= std::string((char*)iter->opComplex.get(), iter->op);
+					
+					//if (ParseEmbeddedBlob( m_embeddedData, m_blobXml)) // todoooo
+					//{
+					//	m_isEmbedded = false;
+					//}
 				}break;
 //BORDERS
 			case borderBottomColor:

ASCOfficeDocFile/DocDocxConverter/VMLPictureMapping.h

@@ -46,7 +46,6 @@ namespace DocFileFormat
 {
 	class OleObject;
 
-	bool ParseEmbeddedEquation( const std::string & xmlString, std::wstring & newXmlString );
 
 	class VMLPictureMapping: public PropertiesMapping, public IMapping
 	{
@@ -58,6 +57,7 @@ namespace DocFileFormat
 		/// Writes a border element
 		void writePictureBorder (const std::wstring & name, const BorderCode* brc);
 		void appendStyleProperty( std::wstring* b, const std::wstring& propName, const std::wstring& propValue ) const;
+		bool ParseEmbeddedEquation( const std::string & xmlString, std::wstring & newXmlString );
 	protected:
 		/// Copies the picture from the binary stream to the zip archive 
 		/// and creates the relationships for the image.

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;

ASCOfficeDocFile/DocDocxConverter/WordDocument.h

@@ -86,6 +86,7 @@ namespace DocFileFormat
 		friend class Table;
 		friend class TableRow;
 		friend class VMLShapeMapping;
+		friend class VMLPictureMapping;
 		friend class OpenXmlPackage;
 		friend class TextboxMapping;
 

ASCOfficeDocxFile2/BinReader/Readers.h

@@ -61,6 +61,26 @@ enum ETblStyleOverrideType
 	tblstyleoverridetypeSwCell     = 11,
 	tblstyleoverridetypeWholeTable = 12
 };
+class SdtWraper
+{
+public:
+
+	OOX::Logic::CSdt m_oSdt;
+	rPr* m_oEndPr;
+	rPr* m_oRPr;
+	int m_nType;
+	SdtWraper(int nType)
+	{
+		m_nType = nType;
+		m_oEndPr = NULL;
+		m_oRPr = NULL;
+	}
+	~SdtWraper()
+	{
+		RELEASEOBJECT(m_oEndPr)
+		RELEASEOBJECT(m_oRPr)
+	}
+};
 
 #define READ1_DEF(stLen, fReadFunction, arg, res) {\
 	res = c_oSerConstants::ReadOk;\
@@ -3635,6 +3655,11 @@ public:
 		//сбрасываем Shd
             oBinary_tblPrReader.m_sCurTableShd.clear();
 		}
+		else if(c_oSerParType::Sdt == type)
+		{
+			SdtWraper oSdt(0);
+			res = Read1(length, &Binary_DocumentTableReader::ReadSdt, this, &oSdt);
+		}
 		else if ( c_oSerParType::sectPr == type )
 		{
 			SectPr oSectPr;
@@ -3746,6 +3771,11 @@ public:
 			res = Read1(length, &Binary_DocumentTableReader::ReadDelIns, this, &oTrackRevision);
 			oTrackRevision.Write(&GetRunStringWriter(), _T("w:del"));
 		}
+		else if(c_oSerParType::Sdt == type)
+		{
+			SdtWraper oSdt(1);
+			res = Read1(length, &Binary_DocumentTableReader::ReadSdt, this, &oSdt);
+		}
 		else
 			res = c_oSerConstants::ReadUnknown;
 		return res;
@@ -3771,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;
@@ -6412,6 +6651,11 @@ public:
 			res = Read1(length, &Binary_DocumentTableReader::Read_Row, this, poResult);
             pCStringWriter->WriteString(std::wstring(_T("</w:tr>")));
 		}
+		else if(c_oSerDocTableType::Sdt == type)
+		{
+			SdtWraper oSdt(2);
+			res = Read1(length, &Binary_DocumentTableReader::ReadSdt, this, &oSdt);
+		}
 		else
 			res = c_oSerConstants::ReadUnknown;
 		return res;
@@ -6444,6 +6688,11 @@ public:
 			res = Read1(length, &Binary_DocumentTableReader::ReadCell, this, poResult);
             pCStringWriter->WriteString(std::wstring(_T("</w:tc>")));
 		}
+		else if(c_oSerDocTableType::Sdt == type)
+		{
+			SdtWraper oSdt(3);
+			res = Read1(length, &Binary_DocumentTableReader::ReadSdt, this, &oSdt);
+		}
 		else
 			res = c_oSerConstants::ReadUnknown;
 		return res;
@@ -7147,6 +7396,309 @@ public:
 	{
 		return oBinary_pPrReader.Read_SecPr(type, length, poResult);
 	}
+	int ReadSdt(BYTE type, long length, void* poResult)
+	{
+		int res = 0;
+		SdtWraper* pSdt = static_cast<SdtWraper*>(poResult);
+		if (c_oSerSdt::Pr == type)
+		{
+			pSdt->m_oSdt.m_oSdtPr.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadSdtPr, this, pSdt);
+		}
+		else if (c_oSerSdt::EndPr == type)
+		{
+			pSdt->m_oEndPr = new rPr(m_oFontTableWriter.m_mapFonts);
+			res = oBinary_rPrReader.Read(length, pSdt->m_oEndPr);
+		}
+		else if (c_oSerSdt::Content == type)
+		{
+			m_oDocumentWriter.m_oContent.WriteString(L"<w:sdt>");
+			if ( pSdt->m_oSdt.m_oSdtPr.IsInit() )
+			{
+				m_oDocumentWriter.m_oContent.WriteString(pSdt->m_oSdt.m_oSdtPr->toXMLStart());
+				if (NULL != pSdt->m_oRPr)
+				{
+					pSdt->m_oRPr->Write(&m_oDocumentWriter.m_oContent);
+				}
+				m_oDocumentWriter.m_oContent.WriteString(pSdt->m_oSdt.m_oSdtPr->toXMLEnd());
+			}
+			if (NULL != pSdt->m_oEndPr)
+			{
+				m_oDocumentWriter.m_oContent.WriteString(L"<w:sdtEndPr>");
+				pSdt->m_oEndPr->Write(&m_oDocumentWriter.m_oContent);
+				m_oDocumentWriter.m_oContent.WriteString(L"</w:sdtEndPr>");
+			}
+
+			m_oDocumentWriter.m_oContent.WriteString(L"<w:sdtContent>");
+			switch(pSdt->m_nType)
+			{
+			case 0:
+				res = Read1(length, &Binary_DocumentTableReader::ReadDocumentContent, this, this);
+				break;
+			case 1:
+				res = Read1(length, &Binary_DocumentTableReader::ReadParagraphContent, this, this);
+				break;
+			case 2:
+				res = Read1(length, &Binary_DocumentTableReader::Read_TableContent, this, &m_oDocumentWriter.m_oContent);
+				break;
+			case 3:
+				res = Read1(length, &Binary_DocumentTableReader::ReadRowContent, this, &m_oDocumentWriter.m_oContent);
+				break;
+			}
+			m_oDocumentWriter.m_oContent.WriteString(L"</w:sdtContent>");
+			m_oDocumentWriter.m_oContent.WriteString(L"</w:sdt>");
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadSdtPr(BYTE type, long length, void* poResult)
+	{
+		int res = 0;
+		SdtWraper* pSdtWraper = static_cast<SdtWraper*>(poResult);
+		OOX::Logic::CSdtPr* pSdtPr = pSdtWraper->m_oSdt.m_oSdtPr.GetPointer();
+		if (c_oSerSdt::Type == type)
+		{
+			pSdtPr->m_eType = (OOX::Logic::ESdtType)m_oBufferedStream.GetUChar();
+		}
+		else if (c_oSerSdt::Alias == type)
+		{
+			pSdtPr->m_oAlias.Init();
+			pSdtPr->m_oAlias->m_sVal.Init();
+			pSdtPr->m_oAlias->m_sVal->append(m_oBufferedStream.GetString3(length));
+		}
+		else if (c_oSerSdt::ComboBox == type)
+		{
+			pSdtPr->m_oComboBox.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadSdtComboBox, this, pSdtPr->m_oComboBox.GetPointer());
+		}
+		else if (c_oSerSdt::DataBinding == type)
+		{
+			pSdtPr->m_oDataBinding.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadSdtPrDataBinding, this, pSdtPr->m_oDataBinding.GetPointer());
+		}
+		else if (c_oSerSdt::PrDate == type)
+		{
+			pSdtPr->m_oDate.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadSdtPrDate, this, pSdtPr->m_oDate.GetPointer());
+		}
+		else if (c_oSerSdt::DocPartList == type)
+		{
+			pSdtPr->m_oDocPartList.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadDocPartList, this, pSdtPr->m_oDocPartList.GetPointer());
+		}
+		else if (c_oSerSdt::DocPartObj == type)
+		{
+			pSdtPr->m_oDocPartObj.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadDocPartList, this, pSdtPr->m_oDocPartObj.GetPointer());
+		}
+		else if (c_oSerSdt::DropDownList == type)
+		{
+			pSdtPr->m_oDropDownList.Init();
+			res = Read1(length, &Binary_DocumentTableReader::ReadDropDownList, this, pSdtPr->m_oDropDownList.GetPointer());
+		}
+		else if (c_oSerSdt::Id == type)
+		{
+			pSdtPr->m_oId.Init();
+			pSdtPr->m_oId->m_oVal.Init();
+			pSdtPr->m_oId->m_oVal->SetValue(m_oBufferedStream.GetULong());
+		}
+		else if (c_oSerSdt::Label == type)
+		{
+			pSdtPr->m_oLabel.Init();
+			pSdtPr->m_oLabel->m_oVal.Init();
+			pSdtPr->m_oLabel->m_oVal->SetValue(m_oBufferedStream.GetULong());
+		}
+		else if (c_oSerSdt::Lock == type)
+		{
+			pSdtPr->m_oLock.Init();
+			pSdtPr->m_oLock->m_oVal.SetValue((SimpleTypes::ELock)m_oBufferedStream.GetUChar());
+		}
+		else if (c_oSerSdt::PlaceHolder == type)
+		{
+			pSdtPr->m_oPlaceHolder.Init();
+			pSdtPr->m_oPlaceHolder->m_oDocPart.Init();
+			pSdtPr->m_oPlaceHolder->m_oDocPart->m_sVal.Init();
+			pSdtPr->m_oPlaceHolder->m_oDocPart->m_sVal->append(m_oBufferedStream.GetString3(length));
+		}
+		else if (c_oSerSdt::RPr == type)
+		{
+			pSdtWraper->m_oRPr = new rPr(m_oFontTableWriter.m_mapFonts);
+			res = oBinary_rPrReader.Read(length, pSdtWraper->m_oRPr);
+		}
+		else if (c_oSerSdt::ShowingPlcHdr == type)
+		{
+			pSdtPr->m_oShowingPlcHdr.Init();
+			pSdtPr->m_oShowingPlcHdr->m_oVal.FromBool(m_oBufferedStream.GetBool());
+		}
+		else if (c_oSerSdt::TabIndex == type)
+		{
+			pSdtPr->m_oTabIndex.Init();
+			pSdtPr->m_oTabIndex->m_oVal.Init();
+			pSdtPr->m_oTabIndex->m_oVal->SetValue(m_oBufferedStream.GetULong());
+		}
+		else if (c_oSerSdt::Tag == type)
+		{
+			pSdtPr->m_oTag.Init();
+			pSdtPr->m_oTag->m_sVal.Init();
+			pSdtPr->m_oTag->m_sVal->append(m_oBufferedStream.GetString3(length));
+		}
+		else if (c_oSerSdt::Temporary == type)
+		{
+			pSdtPr->m_oTemporary.Init();
+			pSdtPr->m_oTemporary->m_oVal.FromBool(m_oBufferedStream.GetBool());
+		}
+		else if (c_oSerSdt::MultiLine == type)
+		{
+			pSdtPr->m_oText.Init();
+			pSdtPr->m_oText->m_oMultiLine.Init();
+			pSdtPr->m_oText->m_oMultiLine->FromBool(m_oBufferedStream.GetBool());
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadSdtComboBox(BYTE type, long length, void* poResult)
+	{
+		int res = 0;
+		OOX::Logic::CSdtComboBox* pSdtComboBox = static_cast<OOX::Logic::CSdtComboBox*>(poResult);
+		if (c_oSerSdt::LastValue == type)
+		{
+			pSdtComboBox->m_sLastValue.Init();
+			pSdtComboBox->m_sLastValue->append(m_oBufferedStream.GetString3(length));
+		}
+		else if (c_oSerSdt::SdtListItem == type)
+		{
+			ComplexTypes::Word::CSdtListItem* pSdtListItem = new ComplexTypes::Word::CSdtListItem();
+			res = Read1(length, &Binary_DocumentTableReader::ReadSdtListItem, this, pSdtListItem);
+			pSdtComboBox->m_arrListItem.push_back(pSdtListItem);		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadSdtListItem(BYTE type, long length, void* poResult)
+	{
+		int res = 0;
+		ComplexTypes::Word::CSdtListItem* pSdtListItem = static_cast<ComplexTypes::Word::CSdtListItem*>(poResult);
+		if (c_oSerSdt::DisplayText == type)
+		{
+			pSdtListItem->m_sDisplayText.Init();
+			pSdtListItem->m_sDisplayText->append(m_oBufferedStream.GetString3(length));
+		}
+		else if (c_oSerSdt::Value == type)
+		{
+			pSdtListItem->m_sValue.Init();
+			pSdtListItem->m_sValue->append(m_oBufferedStream.GetString3(length));
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadSdtPrDataBinding(BYTE type, long length, void* poResult)
+	{
+		int res = 0;
+		ComplexTypes::Word::CDataBinding* pDataBinding = static_cast<ComplexTypes::Word::CDataBinding*>(poResult);
+		if (c_oSerSdt::PrefixMappings == type)
+		{
+			pDataBinding->m_sPrefixMappings.Init();
+			pDataBinding->m_sPrefixMappings->append(m_oBufferedStream.GetString3(length));
+		}
+		else if (c_oSerSdt::StoreItemID == type)
+		{
+			pDataBinding->m_sStoreItemID.Init();
+			pDataBinding->m_sStoreItemID->append(m_oBufferedStream.GetString3(length));
+		}
+		else if (c_oSerSdt::XPath == type)
+		{
+			pDataBinding->m_sXPath.Init();
+			pDataBinding->m_sXPath->append(m_oBufferedStream.GetString3(length));
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadSdtPrDate(BYTE type, long length, void* poResult)
+	{
+		int res = 0;
+		OOX::Logic::CDate* pDate = static_cast<OOX::Logic::CDate*>(poResult);
+		if (c_oSerSdt::FullDate == type)
+		{
+            std::wstring sVal = m_oBufferedStream.GetString3(length);
+
+            pDate->m_oFullDate.Init();
+            pDate->m_oFullDate->SetValue(sVal);
+		}
+		else if (c_oSerSdt::Calendar == type)
+		{
+			pDate->m_oCalendar.Init();
+			pDate->m_oCalendar->m_oVal.SetValue((SimpleTypes::ECalendarType)m_oBufferedStream.GetUChar());
+		}
+		else if (c_oSerSdt::DateFormat == type)
+		{
+			pDate->m_oDateFormat.Init();
+			pDate->m_oDateFormat->m_sVal.Init();
+			pDate->m_oDateFormat->m_sVal->append(m_oBufferedStream.GetString3(length));
+		}
+		else if (c_oSerSdt::Lid == type)
+		{
+			pDate->m_oLid.Init();
+			pDate->m_oLid->m_oVal.Init();
+            std::wstring sVal = m_oBufferedStream.GetString3(length);
+            pDate->m_oLid->m_oVal->SetValue(sVal);
+		}
+		else if (c_oSerSdt::StoreMappedDataAs == type)
+		{
+			pDate->m_oStoreMappedDateAs.Init();
+			pDate->m_oStoreMappedDateAs->m_oVal.SetValue((SimpleTypes::ESdtDateMappingType)m_oBufferedStream.GetUChar());
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadDocPartList(BYTE type, long length, void* poResult)
+	{
+		int res = 0;
+		OOX::Logic::CSdtDocPart* pDocPart = static_cast<OOX::Logic::CSdtDocPart*>(poResult);
+		if (c_oSerSdt::DocPartCategory == type)
+		{
+			pDocPart->m_oDocPartCategory.Init();
+			pDocPart->m_oDocPartCategory->m_sVal.Init();
+			pDocPart->m_oDocPartCategory->m_sVal->append(m_oBufferedStream.GetString3(length));
+		}
+		else if (c_oSerSdt::DocPartGallery == type)
+		{
+			pDocPart->m_oDocPartGallery.Init();
+			pDocPart->m_oDocPartGallery->m_sVal.Init();
+			pDocPart->m_oDocPartGallery->m_sVal->append(m_oBufferedStream.GetString3(length));
+		}
+		else if (c_oSerSdt::DocPartUnique == type)
+		{
+			pDocPart->m_oDocPartUnique.Init();
+			pDocPart->m_oDocPartUnique->m_oVal.FromBool(m_oBufferedStream.GetBool());
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadDropDownList(BYTE type, long length, void* poResult)
+	{
+		int res = 0;
+		OOX::Logic::CSdtDropDownList* pDropDownList = static_cast<OOX::Logic::CSdtDropDownList*>(poResult);
+		if (c_oSerSdt::LastValue == type)
+		{
+			pDropDownList->m_sLastValue.Init();
+			pDropDownList->m_sLastValue->append(m_oBufferedStream.GetString3(length));
+		}
+		else if (c_oSerSdt::SdtListItem == type)
+		{
+			ComplexTypes::Word::CSdtListItem* pSdtListItem = new ComplexTypes::Word::CSdtListItem();
+			res = Read1(length, &Binary_DocumentTableReader::ReadSdtListItem, this, pSdtListItem);
+			pDropDownList->m_arrListItem.push_back(pSdtListItem);
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
 };
 class Binary_NotesTableReader : public Binary_CommonReader<Binary_NotesTableReader>
 {

ASCOfficeDocxFile2/BinWriter/BinReaderWriterDefines.h

@@ -463,7 +463,8 @@ extern int g_nCurFormatVersion;
 		FldSimple		= 11,
 		Del				= 12,
 		Ins				= 13,
-		Background		= 14
+		Background		= 14,
+		Sdt				= 15
 	};}
 	namespace c_oSerDocTableType{enum c_oSerDocTableType
 	{
@@ -477,7 +478,8 @@ extern int g_nCurFormatVersion;
 		Cell =  6,
 		Cell_Pr =  7,
 		Cell_Content =  8,
-		tblGridChange = 9
+		tblGridChange = 9,
+		Sdt = 10
 	};}
 	namespace c_oSerRunType{enum c_oSerRunType
 	{
@@ -910,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
 	{
@@ -1003,6 +1006,73 @@ extern int g_nCurFormatVersion;
 		Data = 1,
 		Program = 2
 	};}
+	namespace c_oSerSdt{enum c_oSerSdt
+	{
+		Pr = 0,
+		EndPr = 1,
+		Content = 2,
+		Type = 3,
+		Alias = 4,
+		ComboBox = 5,
+		LastValue = 6,
+		SdtListItem = 7,
+		DisplayText = 8,
+		Value = 9,
+		DataBinding = 10,
+		PrefixMappings = 11,
+		StoreItemID = 12,
+		XPath = 13,
+		PrDate = 14,
+		FullDate = 15,
+		Calendar = 16,
+		DateFormat = 17,
+		Lid = 18,
+		StoreMappedDataAs = 19,
+		DocPartList = 20,
+		DocPartObj = 21,
+		DocPartCategory = 22,
+		DocPartGallery = 23,
+		DocPartUnique = 24,
+		DropDownList = 25,
+		Id = 26,
+		Label = 27,
+		Lock = 28,
+		PlaceHolder = 29,
+		RPr = 30,
+		ShowingPlcHdr = 31,
+		TabIndex = 32,
+		Tag = 33,
+		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

@@ -3047,8 +3047,9 @@ namespace BinDocxRW
 					case OOX::et_w_sdt:
 					{
 						OOX::Logic::CSdt* pStd = static_cast<OOX::Logic::CSdt*>(item);
-						if(pStd->m_oSdtContent.IsInit())
-							WriteDocumentContent(pStd->m_oSdtContent.get().m_arrItems);
+						nCurPos = m_oBcw.WriteItemStart(c_oSerParType::Sdt);
+						WriteSdt(pStd, 0, NULL, 0, 0, 0);
+						m_oBcw.WriteItemWithLengthEnd(nCurPos);
 					}break;
 					case OOX::et_w_smartTag:
 					{
@@ -3189,8 +3190,9 @@ namespace BinDocxRW
 				case OOX::et_w_sdt:
 					{
 						OOX::Logic::CSdt* pStd = static_cast<OOX::Logic::CSdt*>(item);
-						if(pStd->m_oSdtContent.IsInit())
-							WriteParagraphContent(pStd->m_oSdtContent.get().m_arrItems);
+						nCurPos = m_oBcw.WriteItemStart(c_oSerParType::Sdt);
+						WriteSdt(pStd, 1, NULL, 0, 0, 0);
+						m_oBcw.WriteItemWithLengthEnd(nCurPos);
 						break;
 					}
 				case OOX::et_w_smartTag:
@@ -3319,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)
 		{
@@ -6366,8 +6565,9 @@ namespace BinDocxRW
 				else if(OOX::et_w_sdt == item->getType())
 				{
 					OOX::Logic::CSdt* pStd = static_cast<OOX::Logic::CSdt*>(item);
-					if(pStd->m_oSdtContent.IsInit())
-						WriteTableContent(pStd->m_oSdtContent->m_arrItems, pTblPr, nRows, nCols);
+					nCurPos = m_oBcw.WriteItemStart(c_oSerDocTableType::Sdt);
+					WriteSdt(pStd, 2, pTblPr, 0, nRows, nCols);
+					m_oBcw.WriteItemWithLengthEnd(nCurPos);
 				}
 				else if(OOX::et_w_smartTag == item->getType())
 				{
@@ -6425,8 +6625,9 @@ namespace BinDocxRW
 				else if(OOX::et_w_sdt == item->getType())
 				{
 					OOX::Logic::CSdt* pStd = static_cast<OOX::Logic::CSdt*>(item);
-					if(pStd->m_oSdtContent.IsInit())
-						WriteRowContent(pStd->m_oSdtContent.get().m_arrItems, pTblPr, nCurRowIndex, nRows, nCols);
+					nCurPos = m_oBcw.WriteItemStart(c_oSerDocTableType::Sdt);
+					WriteSdt(pStd, 3, pTblPr, nCurRowIndex, nRows, nCols);
+					m_oBcw.WriteItemWithLengthEnd(nCurPos);
 				}
 				else if(OOX::et_w_smartTag == item->getType())
 				{
@@ -6462,6 +6663,287 @@ namespace BinDocxRW
 				oBinaryDocumentTableWriter.WriteDocumentContent(tc.m_arrItems);
 			m_oBcw.WriteItemEnd(nCurPos);
 		}
+		void WriteSdt(OOX::Logic::CSdt* pStd, int type, OOX::Logic::CTableProperty* pTblPr, int nCurRowIndex, int nRows, int nCols)
+		{
+			int nCurPos = 0;
+			if(pStd->m_oSdtPr.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Pr);
+				WriteSdtPr(pStd->m_oSdtPr.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(pStd->m_oSdtEndPr.IsInit() && pStd->m_oSdtEndPr->m_oRPr.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::EndPr);
+				brPrs.Write_rPr(pStd->m_oSdtEndPr->m_oRPr.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(pStd->m_oSdtContent.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Content);
+				switch(type)
+				{
+					case 0:
+					{
+						BinaryDocumentTableWriter oBinaryDocumentTableWriter(m_oParamsWriter, m_oParamsDocumentWriter, m_mapIgnoreComments, bpPrs.m_oBinaryHeaderFooterTableWriter);
+						oBinaryDocumentTableWriter.WriteDocumentContent(pStd->m_oSdtContent.get().m_arrItems);
+						break;
+					}
+					case 1:
+					{
+						WriteParagraphContent(pStd->m_oSdtContent.get().m_arrItems);
+						break;
+					}
+					case 2:
+					{
+						WriteTableContent(pStd->m_oSdtContent->m_arrItems, pTblPr, nRows, nCols);
+						break;
+					}
+					case 3:
+					{
+						WriteRowContent(pStd->m_oSdtContent.get().m_arrItems, pTblPr, nCurRowIndex, nRows, nCols);
+						break;
+					}
+				}
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+		}
+		void WriteSdtPr(const OOX::Logic::CSdtPr& oStdPr)
+		{
+			int nCurPos = 0;
+			nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Type);
+			m_oBcw.m_oStream.WriteBYTE(oStdPr.m_eType);
+			m_oBcw.WriteItemEnd(nCurPos);
+
+			if(oStdPr.m_oAlias.IsInit() && oStdPr.m_oAlias->m_sVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Alias);
+				m_oBcw.m_oStream.WriteStringW3(oStdPr.m_oAlias->m_sVal.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oComboBox.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::ComboBox);
+				WriteSdtComboBox(oStdPr.m_oComboBox.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oDataBinding.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::DataBinding);
+				WriteSdtPrDataBinding(oStdPr.m_oDataBinding.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oDate.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::PrDate);
+				WriteSdtPrDate(oStdPr.m_oDate.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oDocPartList.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::DocPartList);
+				WriteDocPartList(oStdPr.m_oDocPartList.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oDocPartObj.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::DocPartObj);
+				WriteDocPartList(oStdPr.m_oDocPartObj.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oDropDownList.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::DropDownList);
+				WriteDropDownList(oStdPr.m_oDropDownList.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oId.IsInit() && oStdPr.m_oId->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Id);
+				m_oBcw.m_oStream.WriteULONG(oStdPr.m_oId->m_oVal->GetValue());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oLabel.IsInit() && oStdPr.m_oLabel->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Label);
+				m_oBcw.m_oStream.WriteULONG(oStdPr.m_oLabel->m_oVal->GetValue());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oLock.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Lock);
+				m_oBcw.m_oStream.WriteBYTE(oStdPr.m_oLock->m_oVal.GetValue());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oPlaceHolder.IsInit() && oStdPr.m_oPlaceHolder->m_oDocPart.IsInit() && oStdPr.m_oPlaceHolder->m_oDocPart->m_sVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::PlaceHolder);
+				m_oBcw.m_oStream.WriteStringW3(oStdPr.m_oPlaceHolder->m_oDocPart->m_sVal.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oRPr.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::RPr);
+				brPrs.Write_rPr(oStdPr.m_oRPr.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oShowingPlcHdr.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::ShowingPlcHdr);
+				m_oBcw.m_oStream.WriteBOOL(oStdPr.m_oShowingPlcHdr->m_oVal.ToBool());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oTabIndex.IsInit() && oStdPr.m_oTabIndex->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::TabIndex);
+				m_oBcw.m_oStream.WriteULONG(oStdPr.m_oTabIndex->m_oVal->GetValue());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oTag.IsInit() && oStdPr.m_oTag->m_sVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Tag);
+				m_oBcw.m_oStream.WriteStringW3(oStdPr.m_oTag->m_sVal.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oTemporary.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Temporary);
+				m_oBcw.m_oStream.WriteBOOL(oStdPr.m_oTemporary->m_oVal.ToBool());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oStdPr.m_oText.IsInit() && oStdPr.m_oText->m_oMultiLine.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::MultiLine);
+				m_oBcw.m_oStream.WriteBOOL(oStdPr.m_oText->m_oMultiLine->ToBool());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+		}
+		void WriteSdtComboBox(const OOX::Logic::CSdtComboBox& oSdtComboBox)
+		{
+			int nCurPos = 0;
+			if(oSdtComboBox.m_sLastValue.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::LastValue);
+				m_oBcw.m_oStream.WriteStringW3(oSdtComboBox.m_sLastValue.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			for(size_t i = 0; i < oSdtComboBox.m_arrListItem.size(); ++i)
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::SdtListItem);
+				WriteSdtListItem(*oSdtComboBox.m_arrListItem[i]);
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+		}
+		void WriteSdtListItem(const ComplexTypes::Word::CSdtListItem& oSdtListItem)
+		{
+			int nCurPos = 0;
+			if(oSdtListItem.m_sDisplayText.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::DisplayText);
+				m_oBcw.m_oStream.WriteStringW3(oSdtListItem.m_sDisplayText.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oSdtListItem.m_sValue.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Value);
+				m_oBcw.m_oStream.WriteStringW3(oSdtListItem.m_sValue.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+		}
+		void WriteSdtPrDataBinding(const ComplexTypes::Word::CDataBinding& oDataBinding)
+		{
+			int nCurPos = 0;
+			if(oDataBinding.m_sPrefixMappings.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::PrefixMappings);
+				m_oBcw.m_oStream.WriteStringW3(oDataBinding.m_sPrefixMappings.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oDataBinding.m_sStoreItemID.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::StoreItemID);
+				m_oBcw.m_oStream.WriteStringW3(oDataBinding.m_sStoreItemID.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oDataBinding.m_sXPath.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::XPath);
+				m_oBcw.m_oStream.WriteStringW3(oDataBinding.m_sXPath.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+		}
+		void WriteSdtPrDate(const OOX::Logic::CDate& oDate)
+		{
+			int nCurPos = 0;
+			if(oDate.m_oFullDate.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::FullDate);
+				m_oBcw.m_oStream.WriteStringW3(oDate.m_oFullDate->GetValue());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oDate.m_oCalendar.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Calendar);
+				m_oBcw.m_oStream.WriteBYTE(oDate.m_oCalendar->m_oVal.GetValue());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oDate.m_oDateFormat.IsInit() && oDate.m_oDateFormat->m_sVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::DateFormat);
+				m_oBcw.m_oStream.WriteStringW3(oDate.m_oDateFormat->m_sVal.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oDate.m_oLid.IsInit() && oDate.m_oLid->m_oVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::Lid);
+				m_oBcw.m_oStream.WriteStringW3(oDate.m_oLid->m_oVal->GetValue());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oDate.m_oStoreMappedDateAs.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::StoreMappedDataAs);
+				m_oBcw.m_oStream.WriteBYTE(oDate.m_oStoreMappedDateAs->m_oVal.GetValue());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+		}
+		void WriteDocPartList(const OOX::Logic::CSdtDocPart& oSdtDocPart)
+		{
+			int nCurPos = 0;
+			if(oSdtDocPart.m_oDocPartCategory.IsInit() && oSdtDocPart.m_oDocPartCategory->m_sVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::DocPartCategory);
+				m_oBcw.m_oStream.WriteStringW3(oSdtDocPart.m_oDocPartCategory->m_sVal.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oSdtDocPart.m_oDocPartGallery.IsInit() && oSdtDocPart.m_oDocPartGallery->m_sVal.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::DocPartGallery);
+				m_oBcw.m_oStream.WriteStringW3(oSdtDocPart.m_oDocPartGallery->m_sVal.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			if(oSdtDocPart.m_oDocPartUnique.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::DocPartUnique);
+				m_oBcw.m_oStream.WriteBOOL(oSdtDocPart.m_oDocPartUnique->m_oVal.ToBool());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+		}
+		void WriteDropDownList(const OOX::Logic::CSdtDropDownList& oDropDownList)
+		{
+			int nCurPos = 0;
+			if(oDropDownList.m_sLastValue.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::LastValue);
+				m_oBcw.m_oStream.WriteStringW3(oDropDownList.m_sLastValue.get());
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+			for(size_t i = 0; i < oDropDownList.m_arrListItem.size(); ++i)
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerSdt::SdtListItem);
+				WriteSdtListItem(*oDropDownList.m_arrListItem[i]);
+				m_oBcw.WriteItemEnd(nCurPos);
+			}
+		}
 	};
 	class BinaryCommentsTableWriter
 	{
@@ -6909,80 +7391,96 @@ namespace BinDocxRW
                 }
 			}			
 		}
-		void WriteColorSchemeMapping(const OOX::Settings::CColorSchemeMapping& oColorSchemeMapping)
+		void WriteColorSchemeMapping(const PPTX::Logic::ClrMap& oColorSchemeMapping)
 		{
+			int re_index[] = {0, 1, 2, 3, 4, 5, 10, 11, 6, 7, 8, 9, 10, 11, 10, 6, 7};
+			
 			int nCurPos = 0;
-			if(oColorSchemeMapping.m_oAccent1.IsInit())
+			std::map<std::wstring, PPTX::Limit::ColorSchemeIndex>::const_iterator pFind;
+
+			pFind = oColorSchemeMapping.ColorMap.find(L"accent1");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::Accent1);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oAccent1->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
-			if(oColorSchemeMapping.m_oAccent2.IsInit())
+			pFind = oColorSchemeMapping.ColorMap.find(L"accent2");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::Accent2);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oAccent2->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
-			if(oColorSchemeMapping.m_oAccent3.IsInit())
+			pFind = oColorSchemeMapping.ColorMap.find(L"accent3");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::Accent3);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oAccent3->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
-			if(oColorSchemeMapping.m_oAccent4.IsInit())
+			pFind = oColorSchemeMapping.ColorMap.find(L"accent4");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::Accent4);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oAccent4->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
-			if(oColorSchemeMapping.m_oAccent5.IsInit())
+			pFind = oColorSchemeMapping.ColorMap.find(L"accent5");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::Accent5);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oAccent5->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
-			if(oColorSchemeMapping.m_oAccent6.IsInit())
+			pFind = oColorSchemeMapping.ColorMap.find(L"accent6");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::Accent6);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oAccent6->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
-			if(oColorSchemeMapping.m_oBg1.IsInit())
+			pFind = oColorSchemeMapping.ColorMap.find(L"bg1");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::Bg1);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oBg1->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
-			if(oColorSchemeMapping.m_oBg2.IsInit())
+			pFind = oColorSchemeMapping.ColorMap.find(L"bg2");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::Bg2);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oBg2->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
-			if(oColorSchemeMapping.m_oFollowedHyperlink.IsInit())
+			pFind = oColorSchemeMapping.ColorMap.find(L"folHlink");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::FollowedHyperlink);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oFollowedHyperlink->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
-			if(oColorSchemeMapping.m_oHyperlink.IsInit())
+			pFind = oColorSchemeMapping.ColorMap.find(L"hlink");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::Hyperlink);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oHyperlink->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
-			if(oColorSchemeMapping.m_oT1.IsInit())
+			pFind = oColorSchemeMapping.ColorMap.find(L"tx1");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::T1);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oT1->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
-			if(oColorSchemeMapping.m_oT2.IsInit())
+			pFind = oColorSchemeMapping.ColorMap.find(L"tx2");
+			if(pFind != oColorSchemeMapping.ColorMap.end())
 			{
 				m_oBcw.m_oStream.WriteBYTE(c_oSer_ClrSchemeMappingType::T2);
 				m_oBcw.m_oStream.WriteBYTE(c_oSerPropLenType::Byte);
-				m_oBcw.m_oStream.WriteBYTE(oColorSchemeMapping.m_oT2->GetValue());
+				m_oBcw.m_oStream.WriteBYTE(re_index[pFind->second.GetBYTECode()]);
 			}
 		};
 	};

ASCOfficeDocxFile2/DocWrapper/XlsxSerializer.cpp

@@ -178,7 +178,9 @@ namespace BinXlsxRW{
 			{
 				std::wstring sXlsxFilename = L"Microsoft_Excel_Worksheet" + std::to_wstring(lChartNumber) + L".xlsx";
 				std::wstring sXlsxPath = sEmbedingPath + FILE_SEPARATOR_STR + sXlsxFilename;
+				
 				writeChartXlsx(sXlsxPath, oChartSpace);
+				pReader->m_pRels->m_pManager->m_pContentTypes->AddDefault(L"xlsx");
 
 				std::wstring sChartsWorksheetRelsName = L"../embeddings/" + sXlsxFilename;
 				long rId;

ASCOfficeOdfFile/OdfFileTest/OdfFileTest.cpp

@@ -54,7 +54,7 @@ int _tmain(int argc, _TCHAR* argv[])
 	HRESULT hr = S_OK;
 //////////////////////////////////////////////////////////////////////////
 	std::wstring srcFileName	= argv[1];
-	std::wstring dstPath		= argc > 2 ? argv[2] : srcFileName + L"-my.pptx"; //xlsx pptx docx
+	std::wstring dstPath		= argc > 2 ? argv[2] : srcFileName + L"-my.docx"; //xlsx pptx docx
 	
 	std::wstring outputDir		= NSDirectory::GetFolderPath(dstPath);
 	

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/docx_conversion_context.cpp

@@ -188,7 +188,7 @@ std::wstring styles_map::get(const std::wstring & Name, odf_types::style_family:
     }
     else
     {
-        const std::wstring id = std::wstring(L"style") + boost::lexical_cast<std::wstring>(count_++);
+        const std::wstring id = std::wstring(L"style") + std::to_wstring(count_++);
         map_.insert(std::make_pair(n, id));
         return id;        
     }
@@ -1060,7 +1060,7 @@ void docx_conversion_context::start_list_item(bool restart)
     if (restart && !list_style_stack_.empty())
     {
         const std::wstring curStyleName = current_list_style();
-        const std::wstring newStyleName = curStyleName + boost::lexical_cast<std::wstring>(new_list_style_number_++);
+        const std::wstring newStyleName = curStyleName + std::to_wstring(new_list_style_number_++);
         list_style_renames_[curStyleName] = newStyleName;
 
         odf_reader::list_style_container & lists = root()->odf_context().listStyleContainer();
@@ -1195,7 +1195,7 @@ void docx_conversion_context::process_headers_footers()
     // проходим по всем page layout
     BOOST_FOREACH(const odf_reader::style_master_page* page, pageLayouts.master_pages())
     {
-        const std::wstring & styleName = page->style_master_page_attlist_.style_name_.get_value_or( L"" );
+        const std::wstring & styleName = page->attlist_.style_name_.get_value_or( L"" );
         const std::wstring masterPageNameLayout =context.pageLayoutContainer().page_layout_name_by_style(styleName);
         add_page_properties(masterPageNameLayout);
 		
@@ -1240,7 +1240,7 @@ std::wstring notes_context::add(const std::wstring & Content, const std::wstring
 std::wstring notes_context::next_id()
 {
     instances_map & map = (type_ == odf_types::noteclass::Endnote) ? instances_endnotes_ : instances_footnotes_;
-    const std::wstring s = boost::lexical_cast<std::wstring>(map.size() + 1);
+    const std::wstring s = std::to_wstring(map.size() + 1);
     return s;        
 }
 
@@ -1291,14 +1291,14 @@ void docx_conversion_context::start_text_changes (std::wstring id)
 		if (state.type	== 1)
 		{
 
-			output_stream() << L"<w:ins" << format_change << L" w:id=\"" << boost::lexical_cast<std::wstring>(current_id_changes++) <<  L"\">";
+			output_stream() << L"<w:ins" << format_change << L" w:id=\"" << std::to_wstring(current_id_changes++) <<  L"\">";
 		}
 		
 		if (state.type	== 2)
 		{
 			for (size_t i = 0 ; i < state.content.size(); i++)
 			{
-				output_stream() << L"<w:del" << format_change << L" w:id=\"" << boost::lexical_cast<std::wstring>(current_id_changes++) <<  L"\">";
+				output_stream() << L"<w:del" << format_change << L" w:id=\"" << std::to_wstring(current_id_changes++) <<  L"\">";
 
 				output_stream() << state.content[i];
 
@@ -1330,7 +1330,7 @@ void docx_conversion_context::start_changes()
 		std::wstring change_attr;
 		change_attr += L" w:date=\""	+ state.date	+ L"\"";
 		change_attr += L" w:author=\""	+ state.author	+ L"\"";
-		change_attr += L" w:id=\""		+ boost::lexical_cast<std::wstring>(current_id_changes++) + L"\"";
+		change_attr += L" w:id=\""		+ std::to_wstring(current_id_changes++) + L"\"";
 
 		if (state.type	== 1)
 		{

ASCOfficeOdfFile/src/docx/docx_drawing.cpp

@@ -317,7 +317,8 @@ void docx_serialize_common(std::wostream & strm, _docx_drawing & val)
 		{
 			CP_XML_ATTR(L"name",	val.name);
 			CP_XML_ATTR(L"id",		val.id + 1);
-			oox_serialize_hlink(CP_XML_STREAM(), val.hlinks);
+			
+			oox_serialize_action(CP_XML_STREAM(), val.action);
 		}
 
 		CP_XML_NODE(L"wp:cNvGraphicFramePr")
@@ -529,7 +530,7 @@ mso-position-vertical-relative:text;";
 				strStyle += L"margin-top:"  + boost::lexical_cast<std::wstring>(val.y / 12700.) + L"pt;";
 				strStyle += L"width:"		+ boost::lexical_cast<std::wstring>(val.cx / 12700.) + L"pt;"; 
 				strStyle += L"height:"		+ boost::lexical_cast<std::wstring>(val.cy / 12700.) + L"pt;"; 
-				strStyle += L"z-index:"		+ boost::lexical_cast<std::wstring>(0xF000800 - val.id);
+				strStyle += L"z-index:"		+ std::to_wstring(0xF000800 - val.id);
 			
 				CP_XML_ATTR(L"id",				L"Rect"		+ std::to_wstring(val.id));
 				CP_XML_ATTR(L"o:spid",			L"_x0000_s" + std::to_wstring(1024 + val.id));

ASCOfficeOdfFile/src/docx/docx_package.cpp

@@ -223,7 +223,7 @@ void docx_charts_files::write(const std::wstring & RootPath)
         if (item)
         {
             count++;
-            const std::wstring fileName = std::wstring(L"chart") + boost::lexical_cast<std::wstring>(count) + L".xml";
+            const std::wstring fileName = std::wstring(L"chart") + std::to_wstring(count) + L".xml";
 			const std::wstring kWSConType = L"application/vnd.openxmlformats-officedocument.drawingml.chart+xml";
            
 			content_type_content * contentTypes = get_main_document()->get_content_types_file().content();           
@@ -307,6 +307,7 @@ namespace
 			content << L"<w:" << Node <<    L"s \
 								xmlns:o=\"urn:schemas-microsoft-com:office:office\" \
 								xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" \
+								xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" \
 								xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" \
 								xmlns:w10=\"urn:schemas-microsoft-com:office:word\" \
 								xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" \

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_;	
@@ -60,7 +62,9 @@ struct drawing_object_description
     double									anchor_x_;
     double									anchor_y_;
 
+	_action_desc							action_;
 	std::vector<_hlink_desc>				hlinks_;
+
 	std::vector<odf_reader::_property>		additional_;	//shape properties
 	
 	std::wstring							xlink_href_;	//ссылка на внешний объект

ASCOfficeOdfFile/src/docx/headers_footers.cpp

@@ -39,13 +39,13 @@ namespace oox {
 
 std::wstring headers_footers::create_id(size_t i)
 {
-    return std::wstring(L"rHFId") + boost::lexical_cast<std::wstring>(i); 
+    return std::wstring(L"rHFId") + std::to_wstring(i); 
 }
 
 std::wstring headers_footers::create_name(size_t i, headers_footers::Type _Type)
 {
     return ((_Type == header || _Type == headerLeft || _Type == headerFirst) ?  std::wstring(L"header") : std::wstring(L"footer") )
-        + boost::lexical_cast<std::wstring>(i) + L".xml";
+        + std::to_wstring(i) + L".xml";
 }
 
 std::wstring headers_footers::add(const std::wstring & StyleName,
@@ -64,9 +64,10 @@ std::wstring headers_footers::add(const std::wstring & StyleName,
 	}
     instance_ptr inst = instance_ptr( new instance(id, Content, type, name) );
   
-	BOOST_FOREACH(const relationship & r, _rels.relationships())
+	std::vector<relationship> & rels = _rels.relationships();
+	for (size_t i = 0; i < rels.size(); i++)
     {
-		inst->rels_.add(r);
+		inst->rels_.add(rels[i]);
 	}
     instances_[StyleName].push_back(inst);
 	return id;

ASCOfficeOdfFile/src/docx/hyperlinks.cpp

@@ -44,7 +44,8 @@ namespace oox {
 hyperlinks::_ref  hyperlinks::last()
 {
 	_ref r={};
-	if (hrefs_.size()>0)
+	
+	if (!hrefs_.empty())
 		r = hrefs_.back();
 
 	return r;
@@ -52,9 +53,9 @@ hyperlinks::_ref  hyperlinks::last()
 
 std::wstring hyperlinks::add(const std::wstring & href, _type_place type_place, bool drawing)
 {
-	std::wstring id = std::wstring(L"rHpId") + boost::lexical_cast<std::wstring>(hrefs_.size()+1);
+	std::wstring id = std::wstring(L"rHpId") + std::to_wstring(hrefs_.size() + 1);
 	
-	_ref r ={xml::utils::replace_text_to_xml(href), type_place, drawing, id, false};
+	_ref r = {xml::utils::replace_text_to_xml(href), type_place, drawing, id};
 	
 	hrefs_.push_back(r);
 
@@ -65,14 +66,14 @@ std::wstring hyperlinks::add(const std::wstring & href, _type_place type_place,
 void hyperlinks::dump_rels(rels & Rels, _type_place type)
 {
     size_t i = 0;
-    BOOST_FOREACH(_ref & elm, hrefs_)
+    for (size_t i = 0; i < hrefs_.size(); i++)
     {
- 		if (elm.used_rels)continue; // уже использовали этот релс
+ 		if (hrefs_[i].used_rels)continue; // уже использовали этот релс
 
-		if (elm.type_place == type)
+		if (hrefs_[i].type_place == type)
 		{
-			Rels.add( relationship(elm.id, L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", elm.href, L"External" ) );
-			elm.used_rels = true;
+			Rels.add( relationship(hrefs_[i].id, L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", hrefs_[i].href, L"External" ) );
+			hrefs_[i].used_rels = true;
 		}
     }
 }

ASCOfficeOdfFile/src/docx/measuredigits.cpp

@@ -71,7 +71,7 @@ std::pair<float, float> GetMaxDigitSizePixelsImpl(const std::wstring & fontName,
 
    // for (int i = 0; i <= 9; ++i)
     {
-		//if (FALSE == (hr = pFontManager->LoadString2( boost::lexical_cast<std::wstring>(i), 0, 0)))
+		//if (FALSE == (hr = pFontManager->LoadString2( std::to_wstring(i), 0, 0)))
 		//	return std::pair<float, float>(7,8);
 
 		if (FALSE == (hr = pFontManager->LoadString2( L"xxxxx" , 0, 0)))

ASCOfficeOdfFile/src/docx/mediaitems.cpp

@@ -33,9 +33,6 @@
 #include "mediaitems.h"
 
 #include <boost/regex.hpp>
-#include <boost/foreach.hpp>
-#include <boost/algorithm/string/case_conv.hpp>
-#include <boost/lexical_cast.hpp>
 
 #include <cpdoccore/xml/utils.h>
 
@@ -92,12 +89,18 @@ std::wstring static get_default_file_name(RelsType type)
         return L"image";
     case typeChart:
         return L"chart";
-    case typeMedia:
-        return L"media";
     case typeMsObject:
        return L"msObject";
 	case typeOleObject:
        return L"oleObject";
+    case typeMedia:
+        return L"media";
+	case typeSlide:
+        return L"slide";
+	case typeVideo:
+        return L"video"; 
+	case typeAudio:
+        return L"audio";
 	default:
         return L"";
     }
@@ -140,10 +143,9 @@ std::wstring mediaitems::create_file_name(const std::wstring & uri, RelsType typ
 	if (type == typeOleObject && sExt.empty())
 		sExt = L".bin";
    
-	return get_default_file_name(type) + boost::lexical_cast<std::wstring>(Num) + sExt;
+	return get_default_file_name(type) + std::to_wstring(Num) + sExt;
 }
-
-std::wstring mediaitems::detectImageFileExtension(std::wstring &fileName)
+std::wstring mediaitems::detectImageFileExtension(const std::wstring &fileName)
 {
 	CFile file;
 
@@ -187,6 +189,9 @@ std::wstring mediaitems::add_or_find(const std::wstring & href, RelsType type, b
 	else if ( type == typeImage)		number = count_image	+ 1;
 	else if ( type == typeShape)		number = count_shape	+ 1;
 	else if ( type == typeMedia)		number = count_media	+ 1;
+	else if ( type == typeAudio)		number = count_audio	+ 1;
+	else if ( type == typeVideo)		number = count_video	+ 1;
+	else if ( type == typeSlide)		number = count_slide	+ 1;
 	else if ( type == typeMsObject ||
 			  type == typeOleObject)	number = count_object	+ 1;
 	else
@@ -219,7 +224,7 @@ std::wstring mediaitems::add_or_find(const std::wstring & href, RelsType type, b
 	{
 		if ( type == typeChart)
 		{
-			id = std::wstring(L"chId") + boost::lexical_cast<std::wstring>(count_charts + 1);
+			id = std::wstring(L"chId") + std::to_wstring(count_charts + 1);
 			count_charts++;
 		}
 		else if ( type == typeImage)
@@ -232,17 +237,32 @@ std::wstring mediaitems::add_or_find(const std::wstring & href, RelsType type, b
 //------------------------------------------------
 			if (inputFileName.empty()) return L"";
 
-			id = std::wstring(L"picId") + boost::lexical_cast<std::wstring>(count_image + 1);
+			id = std::wstring(L"picId") + std::to_wstring(count_image + 1);
 			count_image++;
 		}
 		else if ( type == typeMsObject || type == typeOleObject)
 		{
-			id = std::wstring(L"objId") + boost::lexical_cast<std::wstring>(count_object + 1);
+			id = std::wstring(L"objId") + std::to_wstring(count_object + 1);
 			count_object++;
 		}
+		else if ( type == typeAudio)
+		{
+			id = std::wstring(L"aId") + std::to_wstring(count_audio + 1);
+			count_audio++;
+		}
+		else if ( type == typeVideo)
+		{
+			id = std::wstring(L"vId") + std::to_wstring(count_video + 1);
+			count_video++;
+		}
+		else if ( type == typeMedia)
+		{
+			id = std::wstring(L"mId") + std::to_wstring(count_media + 1);
+			count_media++;
+		}
 		else
 		{
-			id = std::wstring(L"rId") + boost::lexical_cast<std::wstring>(count_shape + 1);	
+			id = std::wstring(L"rId") + std::to_wstring(count_shape + 1);	
 			count_shape++;
 		}
 		

ASCOfficeOdfFile/src/docx/mediaitems.h

@@ -31,11 +31,10 @@
  */
 #pragma once
 
-#include <vector>
-#include <string>
-
 #include "oox_rels.h"
 
+#include "../../../../Common/DocxFormat/Source/XML/Utils.h"
+
 namespace cpdoccore { 
 namespace oox {
 
@@ -50,6 +49,9 @@ public:
  		count_tables	= 0;
  		count_media		= 0;
 		count_object	= 0;
+ 		count_audio		= 0;
+ 		count_video		= 0;
+ 		count_slide		= 0;
 	}
 
     struct item 
@@ -74,6 +76,9 @@ public:
 	size_t count_charts;
 	size_t count_image;
 	size_t count_media;
+	size_t count_audio;
+	size_t count_video;
+	size_t count_slide;
 	size_t count_shape;
 	size_t count_tables;
 	size_t count_object;
@@ -88,20 +93,47 @@ public:
 	{
 		switch (type)
 		{
-		case typeImage:		return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
-		case typeChart:		return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
-		case typeMsObject:	return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/package";
-		case typeOleObject:	return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/oleObject";
-		case typeHyperlink:	return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
-		default:
-			return L"";
+			case typeImage:		return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/image";
+			case typeChart:		return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
+			case typeMsObject:	return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/package";
+			case typeOleObject:	return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/oleObject";
+			case typeHyperlink:	return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+			case typeMedia:		return L"http://schemas.microsoft.com/office/2007/relationships/media";
+			case typeAudio:		return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/audio";
+			case typeVideo:		return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/video";
+			case typeSlide:		return L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide";
+			default:
+				return L"";
 		}
 	}
+	static RelsType detectMediaType(const std::wstring & fileName)
+	{
+		int pos = fileName.rfind(L".");
 
+		std::wstring sExt = (pos >=0 ? fileName.substr(pos + 1) : L"");
+
+		if (sExt.empty()) return typeMedia;
+
+		sExt = XmlUtils::GetLower(sExt);
+
+		if (sExt == L"wmv") return typeVideo;
+		if (sExt == L"avi") return typeVideo;
+		if (sExt == L"wmv") return typeVideo;
+		if (sExt == L"wma") return typeAudio;
+		if (sExt == L"wav") return typeAudio;
+		
+		if (sExt == L"mp3") return typeAudio;
+		if (sExt == L"m4a") return typeAudio;
+		if (sExt == L"m4v") return typeVideo;
+		if (sExt == L"mp4") return typeVideo;
+		if (sExt == L"mov") return typeVideo;
+
+		return typeMedia;
+	}
 private:
 	std::wstring create_file_name			(const std::wstring & uri, RelsType type, bool & isInternal, size_t Num);
-	std::wstring detectImageFileExtension	(std::wstring &fileName);
-    
+	std::wstring detectImageFileExtension	(const std::wstring &fileName);
+   
 	items_array		items_;
     std::wstring	odf_packet_;
 

ASCOfficeOdfFile/src/docx/oox_conversion_context.cpp

@@ -144,7 +144,8 @@ void styles_context::docx_serialize_table_style(std::wostream & strm, std::wstri
 }
 namespace oox
 {
-math_context::math_context(odf_reader::fonts_container & fonts, bool graphic) :  base_font_size_(12), fonts_container_(fonts)
+math_context::math_context(odf_reader::fonts_container & fonts, bool graphic) :
+base_font_size_(12), fonts_container_(fonts)
 {
 	graphRPR_ = graphic;
 

ASCOfficeOdfFile/src/docx/oox_drawing.cpp

@@ -57,9 +57,25 @@ namespace svg_path
 		{
 			CP_XML_NODE(val.command)
 			{
-				for (size_t i = 0; i < val.points.size(); i++)
-				{	
-					oox_serialize(CP_XML_STREAM(), val.points[i]);
+				if (val.command == L"a:ArcTo")
+				{
+					if (val.points.size() > 0)
+					{
+						CP_XML_ATTR(L"wR", (int)(val.points[0].x.get()));
+						CP_XML_ATTR(L"hR", (int)(val.points[0].y.get()));
+					}	
+					if (val.points.size() > 1)
+					{
+						CP_XML_ATTR(L"stAng", (int)(val.points[1].x.get() * 60000));
+						CP_XML_ATTR(L"swAng", (int)(val.points[1].y.get() * 60000));
+					}
+				}
+				else
+				{
+					for (size_t i = 0; i < val.points.size(); i++)
+					{	
+						oox_serialize(CP_XML_STREAM(), val.points[i]);
+					}
 				}
 			}
 		}
@@ -112,7 +128,7 @@ void oox_serialize_ln(std::wostream & strm, const std::vector<odf_reader::_prope
 	_CP_OPT(std::wstring)	strStrokeColor; 
 	_CP_OPT(int)			iStroke;
 	_CP_OPT(double)			dStrokeWidth;
-	_CP_OPT(double)	dStrokeOpacity; 
+	_CP_OPT(double)			dStrokeOpacity; 
 	_CP_OPT(bool)			bWordArt;
 	
 	odf_reader::GetProperty(prop, L"wordArt", bWordArt);
@@ -151,15 +167,23 @@ void oox_serialize_ln(std::wostream & strm, const std::vector<odf_reader::_prope
 			{ 			
 				if (fill != L"a:noFill")
 				{
-					if		(color.length() < 1 && always_draw)	color = L"000000";
-					else if (color.length() <1 )				color = L"ffffff";
+					if ( color.empty() )
+					{
+						if (always_draw)	color = L"000000";
+						else				color = L"ffffff";
+					}
 					
 					CP_XML_NODE(L"a:srgbClr")
 					{
 						CP_XML_ATTR(L"val",color);
 						
-						if (dStrokeOpacity)	CP_XML_NODE(L"a:alpha"){CP_XML_ATTR(L"val", *dStrokeOpacity);}
-
+						if (dStrokeOpacity)	
+						{
+							CP_XML_NODE(L"a:alpha")
+							{
+								CP_XML_ATTR(L"val", (int)(*dStrokeOpacity * 1000));
+							}
+						}
 					}
 				}
 			}
@@ -187,69 +211,33 @@ void oox_serialize_ln(std::wostream & strm, const std::vector<odf_reader::_prope
 }
 void oox_serialize_aLst(std::wostream & strm, const std::vector<odf_reader::_property> & prop)
 {
-	_CP_OPT(int)	iShapeIndex;
-	_CP_OPT(bool)	bWordArt;
-	
-	odf_reader::GetProperty(prop, L"wordArt"				, bWordArt);
-	odf_reader::GetProperty(prop, L"odf-custom-draw-index"	, iShapeIndex);
-
-	int count_values = 0, min_value = 0, max_value = 0;
-
-	if (!bWordArt && iShapeIndex)
-	{
-		count_values	= _OO_OOX_custom_shapes[*iShapeIndex].count_values;
-		min_value		= _OO_OOX_custom_shapes[*iShapeIndex].min;
-		max_value		= _OO_OOX_custom_shapes[*iShapeIndex].max;
-	}
-	else if (iShapeIndex)
-	{
-		count_values	= _OO_OOX_wordart[*iShapeIndex].count_values;
-		min_value		= _OO_OOX_wordart[*iShapeIndex].min;
-		max_value		= _OO_OOX_wordart[*iShapeIndex].max;
-	}
-
 	CP_XML_WRITER(strm)
     {
 		CP_XML_NODE(L"a:avLst")
 		{
-			_CP_OPT(std::wstring) strVal;
-			if (odf_reader::GetProperty(prop,L"draw-modifiers",strVal) && iShapeIndex)
+			_CP_OPT(bool) bModifiers;
+			_CP_OPT(std::wstring) strModifiers;
+			odf_reader::GetProperty(prop, L"bModifiers",		bModifiers);
+			odf_reader::GetProperty(prop, L"oox-draw-modifiers", strModifiers);
+			if (strModifiers)
 			{
 				std::vector< std::wstring > values;
-				boost::algorithm::split(values, strVal.get(), boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
+				boost::algorithm::split(values, strModifiers.get(), boost::algorithm::is_any_of(L" "), boost::algorithm::token_compress_on);
 
-				if( count_values >0 && values.size()>0 && count_values < 3)//временное ограниечение .. хз как там свойства путаются
-				{//если не заданы доп свойства - нефиг мучится
-					int i=1;
+				if (!values.empty() && values.back().empty()) values.pop_back();
 
-					_CP_OPT(int) iMax,iMin;
-					odf_reader::GetProperty(prop,L"draw-modifiers-min",iMin);
-					odf_reader::GetProperty(prop,L"draw-modifiers-max",iMax);
-					values.resize(count_values);
-
-					BOOST_FOREACH(std::wstring  & v, values)
+				for (size_t i = 0; i < values.size(); i++)
+				{
+					if (values[i].empty()) continue;
+					CP_XML_NODE(L"a:gd")
 					{
-						CP_XML_NODE(L"a:gd")
-						{
-							if (values.size() >1)
-								CP_XML_ATTR(L"name",(L"adj" + boost::lexical_cast<std::wstring>(i++)));
-							else
-								CP_XML_ATTR(L"name",L"adj");
-							double val=0;
-							if (v.length()>0)val= boost::lexical_cast<double>(v);
-							
-							if (iMin && iMax && iShapeIndex)
-							{
-								if (min_value < max_value)
-								{
-									double W = *iMax - *iMin;
-									val = (val- (*iMin))/W * (max_value - min_value) + min_value;
-								}
-							}
-
-
-							CP_XML_ATTR(L"fmla",L"val " + boost::lexical_cast<std::wstring>(static_cast<int>(val)));
-						}
+						if (values.size() > 1 || bModifiers)
+							//весьма странное .. для некоторых модификаторов (напр math...) нужно указывать множественность их
+							CP_XML_ATTR(L"name", L"adj" + std::to_wstring(i+1));
+						else
+							CP_XML_ATTR(L"name", L"adj");
+						
+						CP_XML_ATTR(L"fmla", L"val " + values[i]);
 					}
 				}
 			}
@@ -342,37 +330,39 @@ void _oox_drawing::serialize_bodyPr(std::wostream & strm, const std::wstring & n
 
 void _oox_drawing::serialize_shape(std::wostream & strm)
 {
-	_CP_OPT(std::wstring)	strVal;
-	_CP_OPT(double)			dVal;
+	_CP_OPT(int)			iOoxShapeIndex;
+	_CP_OPT(bool)			bWordArt, bOoxShape;
+	_CP_OPT(std::wstring)	sCustomPath;
+	
+	odf_reader::GetProperty(additional, L"wordArt",			bWordArt);
+	odf_reader::GetProperty(additional, L"oox-geom-index",	iOoxShapeIndex);
+	odf_reader::GetProperty(additional, L"oox-geom",		bOoxShape);
 
- 	std::wstring	shapeType;
-	_CP_OPT(bool)	bWordArt;
-	
-	odf_reader::GetProperty(additional,L"wordArt", bWordArt);
+	odf_reader::GetProperty(additional, L"custom_path", sCustomPath);
 	
+	std::wstring shapeGeomPreset;
+
 	if (sub_type == 7)//custom 
 	{
-		_CP_OPT(int) iVal;
-		odf_reader::GetProperty(additional, L"odf-custom-draw-index",iVal);
-		
-		if (iVal)
-			shapeType = _OO_OOX_custom_shapes[*iVal].oox;	
-		else 
+		if (iOoxShapeIndex)
+			shapeGeomPreset = _OO_OOX_custom_shapes[*iOoxShapeIndex].oox;	
+		else if (sCustomPath)
 			sub_type = 6; //path
 
-		if (shapeType == L"textBox")
+		if (shapeGeomPreset == L"textBox")
 		{
 			sub_type = 1;
-			shapeType = L"rect";
+			shapeGeomPreset = L"rect";
 		}
 	}
 	else if (sub_type < 9 && sub_type >= 0)
 	{
-		shapeType =	_ooxShapeType[sub_type];
+		shapeGeomPreset = _ooxShapeType[sub_type]; //odf -> oox
 	} 
 	
 	if (bWordArt) sub_type = 1;
 
+
 	CP_XML_WRITER(strm)
     {
 		if (sub_type == 6 || sub_type == 8)
@@ -391,36 +381,44 @@ void _oox_drawing::serialize_shape(std::wostream & strm)
 					CP_XML_ATTR(L"t", 0);
 				}
 				//<a:rect b="b" l="0" r="r" t="0"/>
-				if (odf_reader::GetProperty(additional, L"custom_path", strVal))
-				{
-					_CP_OPT(int) w, h;
-					odf_reader::GetProperty(additional, L"custom_path_w", w);
-					odf_reader::GetProperty(additional, L"custom_path_h", h);
+				_CP_OPT(int) w, h;
+				odf_reader::GetProperty(additional, L"custom_path_w", w);
+				odf_reader::GetProperty(additional, L"custom_path_h", h);
 					
-					CP_XML_NODE(L"a:pathLst")
-					{ 	
-						CP_XML_NODE(L"a:path")
-						{
-							CP_XML_ATTR(L"w", w ? *w : cx);
-							CP_XML_ATTR(L"h", h ? *h : cy);
-							
-							CP_XML_STREAM() << strVal.get();
+
+				CP_XML_NODE(L"a:pathLst")
+				{ 	
+					CP_XML_NODE(L"a:path")
+					{
+						CP_XML_ATTR(L"w", w ? *w : cx);
+						CP_XML_ATTR(L"h", h ? *h : cy);
+						
+						if (sCustomPath)
+						{	
+							CP_XML_STREAM() << *sCustomPath;
 						}
 					}
-				}         
+				}       
 			}
 		}
 		else
 		{
-			if (shapeType.length() < 1)
+			if (shapeGeomPreset.empty())
 			{
-				shapeType	 = L"rect";
-				sub_type = 2;
+				shapeGeomPreset	= L"rect";
+				sub_type	= 2;
 			}
 			CP_XML_NODE(L"a:prstGeom")//автофигура
 			{        
-				CP_XML_ATTR(L"prst", shapeType);
-				if (!bWordArt) oox_serialize_aLst(CP_XML_STREAM(), additional);
+				CP_XML_ATTR(L"prst", shapeGeomPreset);
+				if (!bWordArt) 
+				{
+					if (std::wstring::npos != shapeGeomPreset.find(L"mathPlus"))
+					{
+						additional.push_back(odf_reader::_property(L"bModifiers", true));
+					}
+					oox_serialize_aLst(CP_XML_STREAM(), additional);
+				}
 			}					
 		}
 		if (bWordArt)
@@ -518,22 +516,32 @@ void _oox_drawing::serialize_xfrm(std::wostream & strm, const std::wstring & nam
 		}
     }
 }
-void oox_serialize_hlink(std::wostream & strm, std::vector<_hlink_desc> const & val)
+void oox_serialize_action(std::wostream & strm, _action_desc const & val)
 {
+	if (val.enabled == false) return;
+
     CP_XML_WRITER(strm)
     {
-		BOOST_FOREACH(const _hlink_desc & h, val)
+		CP_XML_NODE(L"a:hlinkClick")
 		{
-			if (h.in_object == true)
+			//CP_XML_ATTR(L"xmlns:r", L"http://schemas.openxmlformats.org/officeDocument/2006/relationships");
+			//CP_XML_ATTR(L"xmlns:a", L"http://schemas.openxmlformats.org/drawingml/2006/main");
+
+			if (!val.action.empty())
+				CP_XML_ATTR(L"action", val.action);
+			
+			if (val.highlightClick)
+				CP_XML_ATTR(L"highlightClick", val.highlightClick);
+		
+			CP_XML_ATTR(L"r:id", val.hId);
+			
+			if (!val.hSoundId.empty())
 			{
-				CP_XML_NODE(L"a:hlinkClick")
+				CP_XML_NODE(L"a:snd")
 				{
-					CP_XML_ATTR(L"xmlns:r", L"http://schemas.openxmlformats.org/officeDocument/2006/relationships");
-					CP_XML_ATTR(L"xmlns:a", L"http://schemas.openxmlformats.org/drawingml/2006/main");
-					
-					CP_XML_ATTR(L"r:id", h.hId);
+					CP_XML_ATTR(L"r:embed", val.hSoundId);
+					CP_XML_ATTR(L"name", L"sound");
 				}
-				break;
 			}
 		}
 	}

ASCOfficeOdfFile/src/docx/oox_drawing.h

@@ -51,10 +51,35 @@ namespace oox {
     {
         std::wstring hId;
         std::wstring hRef;
-        
-		bool in_object;
-    };
+   };
+    struct _action_desc
+    {
+		_action_desc() : enabled(false), highlightClick(false) {}
+		void clear()
+		{
+			enabled			= false;
+			highlightClick	= false;
+			
+			hSoundId.clear();
+			hSoundRef.clear();
 
+			hId.clear(); 
+			hRef.clear();
+
+			action.clear();
+		}
+		bool			enabled;
+        std::wstring	action;
+        
+		std::wstring	hSoundId;
+		std::wstring	hSoundRef;
+
+		std::wstring	hId;
+        std::wstring	hRef;
+
+		RelsType		typeRels;
+		bool			highlightClick;
+    };
 	class _oox_drawing
     {
 	public:
@@ -74,10 +99,14 @@ namespace oox {
 
         _oox_fill		fill;
 
-        std::wstring				objectId;
-		std::wstring				objectProgId; 
+        std::wstring	objectId;
+		std::wstring	objectProgId; 
+
+		std::wstring	extId;
+
+		_action_desc				action;
+		std::vector<_hlink_desc>	hlinks;
 
-		std::vector<_hlink_desc>			hlinks;
         std::vector<odf_reader::_property>	additional;
 
 		virtual void serialize	(std::wostream & strm) = 0;
@@ -90,7 +119,7 @@ namespace oox {
 
 	void oox_serialize_ln		(std::wostream & strm, const std::vector<odf_reader::_property> & val, bool always_draw = false);
 	void oox_serialize_aLst		(std::wostream & strm, const std::vector<odf_reader::_property> & val);
-    void oox_serialize_hlink	(std::wostream & strm, const std::vector<_hlink_desc> & val);
+    void oox_serialize_action	(std::wostream & strm, const _action_desc & val);
     
 }
 }

ASCOfficeOdfFile/src/docx/oox_drawing_fills.cpp

@@ -71,7 +71,7 @@ void oox_serialize_srgb(std::wostream & strm,std::wstring color,_CP_OPT(double)
 			{
 				CP_XML_NODE(L"a:alpha")
 				{
-					CP_XML_ATTR(L"val", boost::lexical_cast<std::wstring>((int)(*opacity)*1000));// + L"%");
+					CP_XML_ATTR(L"val", std::to_wstring((int)(*opacity)*1000));// + L"%");
 				}
 			}
 		}
@@ -88,7 +88,7 @@ void oox_serialize_srgb(std::wostream & strm,std::wstring color,_CP_OPT(odf_type
 			{
 				CP_XML_NODE(L"a:alpha")
 				{
-					CP_XML_ATTR(L"val", boost::lexical_cast<std::wstring>((int)opacity->get_value()*1000));// + L"%");
+					CP_XML_ATTR(L"val", std::to_wstring((int)opacity->get_value()*1000));// + L"%");
 				}
 			}
 		}

ASCOfficeOdfFile/src/docx/oox_package.cpp

@@ -71,7 +71,18 @@ static std::wstring get_mime_type(const std::wstring & extension)
    	else if (L"tif" == extension)	return  L"image/x-tiff";
  	else if (L"tiff" == extension)	return  L"image/x-tiff";
 	else if (L"pdf" == extension)	return  L"application/pdf";
+
 	else if (L"wav" == extension)	return  L"audio/wav";
+	else if (L"mp3" == extension)	return  L"audio/mpeg";
+	else if (L"wma" == extension)	return  L"audio/x-ms-wma";
+	else if (L"m4a" == extension)	return  L"audio/unknown";
+
+	else if (L"avi" == extension)	return  L"video/avi";
+	else if (L"wmv" == extension)	return  L"video/x-ms-wmv";
+	else if (L"mov" == extension)	return  L"video/unknown";
+	else if (L"mp4" == extension)	return  L"video/unknown";
+	else if (L"m4v" == extension)	return  L"video/unknown";
+
 	else if (L"bin" == extension)	return  L"application/vnd.openxmlformats-officedocument.oleObject";
 	else if (L"xlsx" == extension)	return  L"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
 	else if (L"docx" == extension)	return  L"application/vnd.openxmlformats-officedocument.wordprocessingml.document";
@@ -130,7 +141,7 @@ bool content_types_file::add_or_find_override(const std::wstring & fileName)
 {
 	std::vector<override_content_type> & override_ = content_type_content_.get_override();
 	
-	for (int i = 0 ; i < override_.size(); i++)
+	for (size_t i = 0 ; i < override_.size(); i++)
 	{
 		if (override_[i].part_name() == fileName)
 			return true;
@@ -158,14 +169,18 @@ bool content_types_file::add_or_find_override(const std::wstring & fileName)
 
 void content_types_file::set_media(mediaitems & _Mediaitems)
 {
-    BOOST_FOREACH( mediaitems::item & item, _Mediaitems.items() )
+	std::vector<mediaitems::item> & items_ = _Mediaitems.items();
+    for (size_t i = 0; i < items_.size(); i++)
     {
-		if ((item.type == typeImage || item.type == typeMedia) && item.mediaInternal)
+		if ((items_[i].type == typeImage || 
+			items_[i].type == typeMedia	||
+			items_[i].type == typeVideo	||
+			items_[i].type == typeAudio) && items_[i].mediaInternal)
 		{
-			int n = item.outputName.rfind(L".");
+			int n = items_[i].outputName.rfind(L".");
 			if (n > 0)
 			{
-				add_or_find_default(item.outputName.substr(n+1, item.outputName.length() - n));
+				add_or_find_default(items_[i].outputName.substr(n + 1, items_[i].outputName.length() - n));
 			}
 		}
 	}
@@ -320,9 +335,12 @@ void media::write(const std::wstring & RootPath)
     NSDirectory::CreateDirectory(path.c_str());
 
 	mediaitems::items_array & items = mediaitems_.items();
-    for (int i = 0; i < items.size(); i++ )
+    for (size_t i = 0; i < items.size(); i++ )
     {
-        if (items[i].mediaInternal && items[i].valid && (items[i].type == typeImage || items[i].type == typeMedia))
+        if (items[i].mediaInternal && items[i].valid && (	items[i].type == typeImage || 
+															items[i].type == typeMedia ||
+															items[i].type == typeAudio ||
+															items[i].type == typeVideo ))
         {
 			std::wstring & file_name	= items[i].href;
 			std::wstring file_name_out	= RootPath + FILE_SEPARATOR_STR + items[i].outputName;
@@ -359,7 +377,7 @@ void embeddings::write(const std::wstring & RootPath)
 	content_types_file & content_types = get_main_document()->get_content_types_file();           
     
 	mediaitems::items_array & items = embeddingsitems_.items();
-    for (int i = 0; i < items.size(); i++ )
+    for (size_t i = 0; i < items.size(); i++ )
     {
         if ( items[i].mediaInternal && items[i].valid &&
 			(items[i].type == typeMsObject || items[i].type == typeOleObject))

ASCOfficeOdfFile/src/docx/oox_rels.cpp

@@ -56,18 +56,6 @@ std::wostream & relationship::xml_to_stream(std::wostream & _Wostream) const
                 CP_XML_ATTR(L"TargetMode", target_mode());
         }    
     }
-
-    //_Wostream << L"<Relationship ";
-    //CP_XML_SERIALIZE_ATTR(L"Id", id());
-    //CP_XML_SERIALIZE_ATTR(L"Type", type());
-    //CP_XML_SERIALIZE_ATTR(L"Target", target());
-    //
-    //if (!target_mode().empty())
-    //{
-    //    CP_XML_SERIALIZE_ATTR(L"TargetMode", target_mode());
-    //}
-
-    //_Wostream << L" />";
     return _Wostream;
 }
 
@@ -82,23 +70,12 @@ std::wostream & rels::xml_to_stream(std::wostream & _Wostream) const
         {
             CP_XML_ATTR(L"xmlns", xmlns::rels.value);
 
-            BOOST_FOREACH(const relationship & r, relationship_)
+            for (size_t i = 0; i < relationship_.size(); i++)
             {
-                r.xml_to_stream(CP_XML_STREAM());
+                relationship_[i].xml_to_stream(CP_XML_STREAM());
             }
-        } // "Relationships"
+        }
     }
-
-    //_Wostream << L"<Relationships ";
-    //CP_XML_SERIALIZE_ATTR(L"xmlns", xmlns::rels.value);
-    //_Wostream << L">";
-
-    //BOOST_FOREACH(const relationship & r, relationship_)
-    //{
-    //    r.xml_to_stream(_Wostream);
-    //}
-
-    //_Wostream << L"</Relationships>";
     return _Wostream;
 }
 

ASCOfficeOdfFile/src/docx/oox_rels.h

@@ -52,7 +52,10 @@ enum RelsType
 	typeMedia, 
 	typeGroupShape, 
 	typeMsObject, 
-	typeOleObject
+	typeOleObject,
+	typeSlide,
+	typeVideo, 
+	typeAudio
 };
 
 struct _rel

ASCOfficeOdfFile/src/docx/pptx_comments_context.cpp

@@ -54,13 +54,13 @@ public:
 
     std::pair<std::wstring, std::wstring> add_comments_xml(std::wstring const & content,pptx_comments_ptr comments)
     {
- 		const std::wstring file_id = boost::lexical_cast<std::wstring>(next_file_id_++);
+ 		const std::wstring file_id = std::to_wstring(next_file_id_++);
       
 		const std::wstring fileName = std::wstring(L"comment") + file_id + L".xml";
         
 		comments_.push_back(pptx_comment_elm(fileName, content, comments));
         
-		const std::wstring id = boost::lexical_cast<std::wstring>(next_comments_id_++);
+		const std::wstring id = std::to_wstring(next_comments_id_++);
 		const std::wstring rId = std::wstring(L"comId") + id; 
         return std::pair<std::wstring, std::wstring>(fileName, rId);
     }

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);
+		name = L"User Theme: " + std::to_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]->style_master_page_attlist_.style_name_))//default
-	{
-		const std::wstring masterStyleName = pageLayouts.master_pages()[0]->style_master_page_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;
 }
@@ -438,7 +489,7 @@ bool pptx_conversion_context::start_layout(int layout_index)
 		root()->odf_context().styleContainer().presentation_masters().add_layout_to(layouts.content[layout_index].master_name,layouts.content[layout_index]);
 
 		current_layout().Rels().add(relationship(L"smId1"/*master_id.second*/, L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/slideMaster",
-			std::wstring(L"../slideMasters/slideMaster")  + boost::lexical_cast<std::wstring>(master_id.first) + L".xml"));
+			std::wstring(L"../slideMasters/slideMaster")  + std::to_wstring(master_id.first) + L".xml"));
 
 		//
 	}
@@ -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,6 +589,59 @@ void pptx_conversion_context::end_page()
 
 	get_slide_context().end_slide();
 }
+bool pptx_conversion_context::start_page_notes()
+{
+	create_new_slideNotes( );
+
+	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"));
+
+	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_page_notes()
+{
+	get_slide_context().serialize_background(current_notes().Background());
+	get_slide_context().serialize_objects(current_notes().Data());
+
+	get_slide_context().dump_rels(current_notes().Rels());//hyperlinks, mediaitems, ...
+
+	get_slide_context().end_slide();
+}
+bool pptx_conversion_context::start_master_notes()
+{
+	create_new_slideNotesMaster( );
+	
+	get_slide_context().start_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()
 {
 	get_slide_context().serialize_objects(current_layout().Data());

ASCOfficeOdfFile/src/docx/pptx_conversion_context.h

@@ -88,6 +88,12 @@ public:
 							const std::wstring & pageMasterName);
 	void end_page();
 	
+    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();
 
@@ -107,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();
@@ -138,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_;    
@@ -152,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

@@ -76,7 +76,7 @@ void pptx_serialize_image(std::wostream & strm, _pptx_drawing & val)
                     CP_XML_ATTR(L"id",		val.id);
                     CP_XML_ATTR(L"name",	val.name);
 
-					oox_serialize_hlink(CP_XML_STREAM(), val.hlinks);
+					oox_serialize_action(CP_XML_STREAM(), val.action);
 
 				}
                 CP_XML_NODE(L"p:cNvPicPr")
@@ -109,6 +109,75 @@ void pptx_serialize_image(std::wostream & strm, _pptx_drawing & val)
         } 
     }  
 }
+void pptx_serialize_media(std::wostream & strm, _pptx_drawing & val)
+{
+    CP_XML_WRITER(strm)    
+    {
+        CP_XML_NODE(L"p:pic")
+        {                  
+            CP_XML_NODE(L"p:nvPicPr")
+            {
+                CP_XML_NODE(L"p:cNvPr")
+                {
+                    CP_XML_ATTR(L"id",		val.id);
+                    CP_XML_ATTR(L"name",	val.name);
+
+					oox_serialize_action(CP_XML_STREAM(), val.action);
+
+				}
+                CP_XML_NODE(L"p:cNvPicPr")
+				{
+				}
+				CP_XML_NODE(L"p:nvPr")
+				{
+					std::wstring strNode; 
+					
+					if		(val.type == typeVideo)	strNode = L"a:videoFile"; 
+					else if (val.type == typeAudio) strNode = L"a:audioFile"; 
+
+					if (strNode.empty() == false)
+					{
+						CP_XML_NODE(strNode)
+						{
+							CP_XML_ATTR(L"r:link",	val.objectId);
+						}
+					}
+					CP_XML_NODE(L"p:extLst")
+					{
+						CP_XML_NODE(L"p:ext")
+						{
+							CP_XML_ATTR(L"uri",	L"{DAA4B4D4-6D71-4841-9C94-3DE7FCFB9230}");
+							CP_XML_NODE(L"p14:media")
+							{	
+								CP_XML_ATTR(L"xmlns:p14", L"http://schemas.microsoft.com/office/powerpoint/2010/main");
+								CP_XML_ATTR(L"r:embed",	val.extId);
+							}
+						}
+					}
+				}
+            } 
+			if (val.fill.bitmap)
+				val.fill.bitmap->name_space = L"p";
+			oox_serialize_fill(CP_XML_STREAM(), val.fill);
+
+            CP_XML_NODE(L"p:spPr")
+            {
+				val.serialize_xfrm(CP_XML_STREAM(), L"a", true);
+
+                CP_XML_NODE(L"a:prstGeom")
+                {                   
+                    CP_XML_ATTR(L"prst", L"rect");
+                    CP_XML_NODE(L"a:avLst");
+                }
+				oox_serialize_ln(CP_XML_STREAM(), val.additional);
+            } 			
+			//_CP_OPT(std::wstring) strTextContent;
+			//odf::GetProperty(properties,L"text-content",strTextContent);
+			//pptx_serialize_text(CP_XML_STREAM(),val.additional);
+			//на картинке тект нельзя... - выше сменили тип на рект с заливкой
+        } 
+    }  
+}
 
 void pptx_serialize_shape(std::wostream & strm, _pptx_drawing & val)
 {
@@ -123,7 +192,7 @@ void pptx_serialize_shape(std::wostream & strm, _pptx_drawing & val)
                     CP_XML_ATTR(L"id", val.id);//числовое значение val.rId
                     CP_XML_ATTR(L"name", val.name); 
 
-					oox_serialize_hlink(CP_XML_STREAM(),val.hlinks);
+					oox_serialize_action(CP_XML_STREAM(),val.action);
                 }
 				CP_XML_NODE(L"p:cNvSpPr")//non visual properies (собственно тока 1 там)
 				{
@@ -155,8 +224,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);
@@ -307,11 +379,14 @@ void _pptx_drawing::serialize(std::wostream & strm)
 	{
 		pptx_serialize_table(strm, *this);
 	}
-	else if (type == typeMsObject || 
-				type == typeOleObject)
+	else if (type == typeMsObject || type == typeOleObject)
 	{
 		pptx_serialize_object(strm, *this);
 	}
+	else if (type == typeMedia || type == typeAudio || type == typeVideo )
+	{
+		pptx_serialize_media(strm, *this);
+	}
 }
 
 

ASCOfficeOdfFile/src/docx/pptx_drawings.cpp

@@ -65,11 +65,16 @@ public:
 		{
 			pptx_drawing_rels_.push_back(_rel(isInternal, rid, ref, type));
 		}
-        for (int i = 0; i < d.hlinks.size(); i++)
+        for (size_t i = 0; i < d.hlinks.size(); i++)
         {
 			pptx_drawing_rels_.push_back(_rel(false, d.hlinks[i].hId, d.hlinks[i].hRef, typeHyperlink));
 		}
-    }
+        if (!d.action.hId.empty())
+        {
+			bool bInternal = (d.action.typeRels != typeHyperlink);
+			pptx_drawing_rels_.push_back(_rel(bInternal, d.action.hId, d.action.hRef, d.action.typeRels));
+		}    
+	}
 
     void add(/**/
         bool isInternal,
@@ -120,10 +125,13 @@ public:
 			}
 			else
 			{
+				std::wstring ref = pptx_drawing_rels_[i].ref;
+				if (pptx_drawing_rels_[i].is_internal && ref != L"NULL")
+				{
+					ref =  L"../" + ref;
+				}
 				Rels.add(relationship( pptx_drawing_rels_[i].rid, 
-							mediaitems::get_rel_type(pptx_drawing_rels_[i].type),
-							(pptx_drawing_rels_[i].is_internal ? std::wstring(L"../") + pptx_drawing_rels_[i].ref : pptx_drawing_rels_[i].ref),
-							(pptx_drawing_rels_[i].is_internal ? L"" : L"External")) );
+							mediaitems::get_rel_type(pptx_drawing_rels_[i].type), ref, (pptx_drawing_rels_[i].is_internal ? L"" : L"External")) );
 			}
 		}
 	}

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,8 +53,8 @@ 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);
-    return boost::make_shared<pptx_xml_slide>(name,rId);
+	const std::wstring rId = std::wstring(L"sId") + std::to_wstring(id);
+    return boost::make_shared<pptx_xml_slide>(name, rId);
 }
 
 pptx_xml_slide::pptx_xml_slide(std::wstring const & name,std::wstring const & id)
@@ -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")
@@ -269,7 +273,7 @@ void pptx_xml_slideMaster::write_to(std::wostream & strm)
 				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"accent3",L"accent3");
 				CP_XML_ATTR(L"accent2",L"accent2");
 				CP_XML_ATTR(L"accent1",L"accent1");
 				CP_XML_ATTR(L"tx2",L"dk2");
@@ -279,7 +283,7 @@ void pptx_xml_slideMaster::write_to(std::wostream & strm)
 			}
 			CP_XML_NODE(L"p:sldLayoutIdLst")
 			{
-				for (int i = 0; i < layoutsId_.size(); i++)
+				for (size_t i = 0; i < layoutsId_.size(); i++)
 				{
 					CP_XML_NODE(L"p:sldLayoutId")
 					{
@@ -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,22 @@ void pptx_xml_presentation::write_to(std::wostream & strm)
             CP_XML_NODE(L"p:sldMasterIdLst")
             {
                 CP_XML_STREAM() << slideMastersData_.str();
-            }            
+            }       
+			std::wstring notesMaster = slideNotesMastersData_.str();
+			if (notesMaster.empty() == false)
+			{
+				CP_XML_NODE(L"p:notesMasterIdLst")
+				{
+					CP_XML_STREAM() << notesMaster;
+				} 
+			}
 			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 +443,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

@@ -100,15 +100,16 @@ void slide_content::add_rels(rels & _r)
 {
 	std::vector<relationship> & r =  _r.relationships();
 	
-	for (int i = 0; i < r.size(); i++)
+	for (size_t i = 0; i < r.size(); i++)
 	{
 		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;
@@ -61,12 +60,13 @@ public:
 
 		_CP_OPT(std::wstring)	Speed;
 		_CP_OPT(int)			Time;
+		_CP_OPT(int)			PageTime;
 		_CP_OPT(std::wstring)	Dir;
 		_CP_OPT(std::wstring)	Param;
 		bool					onClick;
 	};
 
-	Impl(const std::wstring & odfPacket) : mediaitems_(odfPacket),odfPacket_(odfPacket)
+	Impl(const std::wstring & odfPacket) : mediaitems_(odfPacket), odfPacket_(odfPacket)
     {
 		clear();
 	}
@@ -75,24 +75,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 +100,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 +120,6 @@ public:
     {
 		return rId_++;;
     }
-
     pptx_drawings_ptr get_drawings()
     {
         return pptx_drawings_;
@@ -137,22 +129,24 @@ 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);
 	void process_chart	(drawing_object_description& obj, _pptx_drawing & drawing);
 	void process_table	(drawing_object_description& obj, _pptx_drawing & drawing);
 	void process_object	(drawing_object_description& obj, _pptx_drawing & drawing);
+	void process_media	(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();
 
@@ -168,6 +162,7 @@ void pptx_slide_context::Impl::process_drawings()
 			case typeChart:		process_chart(objects_[i], drawing);	break;
 			case typeShape:		process_shape(objects_[i], drawing);	break;
 			case typeTable:		process_table(objects_[i], drawing);	break;
+			case typeMedia:		process_media(objects_[i], drawing);	break;
 			case typeMsObject:	
 			case typeOleObject:	process_object(objects_[i], drawing);	break;
 		}
@@ -175,17 +170,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 +199,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 +212,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,12 +224,15 @@ 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"";
 	impl_->object_description_.svg_rect_	= boost::none;
 
 	impl_->object_description_.hlinks_.clear();
+	impl_->object_description_.action_.clear();
+
 	impl_->object_description_.additional_.clear();
 
 	impl_->object_description_.fill_.clear();
@@ -247,10 +247,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));
 }
@@ -328,15 +328,15 @@ void pptx_slide_context::set_fill(_oox_fill & fill)
 	impl_->object_description_.fill_= fill;
 }
 
-std::wstring pptx_slide_context::add_hyperlink(std::wstring const & href,bool object)
+std::wstring pptx_slide_context::add_hyperlink(std::wstring const & href)
 {
 	++hlinks_size_;
-	std::wstring hId=std::wstring(L"hId") + boost::lexical_cast<std::wstring>(hlinks_size_);
+	std::wstring hId = L"hId" + std::to_wstring(hlinks_size_);
 	
 	std::wstring href_correct = xml::utils::replace_text_to_xml(href);
 	XmlUtils::replace_all( href_correct, L" .", L".");//1 (130).odt
 
-	_hlink_desc desc={hId, href_correct, object};
+	_hlink_desc desc = {hId, href_correct};
 	impl_->object_description_.hlinks_.push_back(desc);
 
 	return hId;
@@ -352,14 +352,12 @@ void pptx_slide_context::add_background(_oox_fill & fill)
 		fill.bitmap->rId = get_mediaitems().add_or_find(fill.bitmap->xlink_href_, typeImage, isMediaInternal, ref);
 		add_rels(isMediaInternal, fill.bitmap->rId, ref, typeImage);
 	}	
-	
 	impl_->background_fill_ = fill;
 }
 
 void pptx_slide_context::set_name(std::wstring const & name)
 {
 	impl_->object_description_.name_ = name;
-
 }
 
 void pptx_slide_context::start_shape(int type)
@@ -367,6 +365,74 @@ void pptx_slide_context::start_shape(int type)
 	impl_->object_description_.type_		= typeShape;
 	impl_->object_description_.shape_type_	= type; //2,3... 
 }
+void pptx_slide_context::start_action(std::wstring action)
+{
+	impl_->object_description_.action_.enabled	= true;
+
+	if (action == L"sound")
+	{
+		impl_->object_description_.action_.action = L"ppaction://noaction";
+		impl_->object_description_.action_.typeRels = typeAudio;
+		impl_->object_description_.action_.highlightClick = true;
+	}
+	else if (action == L"next-page")
+	{
+		impl_->object_description_.action_.action = L"ppaction://hlinkshowjump?jump=nextslide";
+		impl_->object_description_.action_.highlightClick = true;
+	}
+	else if (action == L"previous-page")
+	{
+		impl_->object_description_.action_.action = L"ppaction://hlinkshowjump?jump=previousslide";
+		impl_->object_description_.action_.highlightClick = true;
+	}
+	else if (action == L"first-page")
+	{
+		impl_->object_description_.action_.action = L"ppaction://hlinkshowjump?jump=firstslide";
+		impl_->object_description_.action_.highlightClick = true;
+	}
+	else if (action == L"last-page")
+	{
+		impl_->object_description_.action_.action = L"ppaction://hlinkshowjump?jump=lastslide";
+		impl_->object_description_.action_.highlightClick = true;
+	}
+	//ppaction://hlinkshowjump?jump=endshow
+	else if (action == L"execute")
+	{
+		impl_->object_description_.action_.action	= L"ppaction://program";
+		impl_->object_description_.action_.typeRels = typeHyperlink;
+		impl_->object_description_.action_.highlightClick = true;
+	}
+}
+void pptx_slide_context::set_link(std::wstring link, RelsType typeRels)
+{
+	++hlinks_size_;
+	
+	impl_->object_description_.action_.highlightClick = true;
+
+	if (typeRels == typeAudio)
+	{
+		bool isMediaInternal = true;
+		
+		impl_->object_description_.action_.hSoundId = get_mediaitems().add_or_find(link, typeAudio, isMediaInternal, impl_->object_description_.action_.hSoundRef);		
+		impl_->add_additional_rels(isMediaInternal, impl_->object_description_.action_.hSoundId, impl_->object_description_.action_.hSoundRef, typeAudio);
+	}
+	else
+	{
+		impl_->object_description_.action_.typeRels	= typeRels;
+		
+		std::wstring hId = L"hId" + std::to_wstring(hlinks_size_);
+		link = xml::utils::replace_text_to_xml(link);
+		
+		if (typeRels == typeHyperlink)
+			XmlUtils::replace_all( link, L" .", L".");		//1 (130).odt
+
+		impl_->object_description_.action_.hId	= hId;
+		impl_->object_description_.action_.hRef	= link;
+	}
+}
+void pptx_slide_context::end_action()
+{
+}
 
 void pptx_slide_context::start_table()
 {
@@ -390,6 +456,20 @@ void pptx_slide_context::set_ole_object(const std::wstring & path, const std::ws
 	impl_->object_description_.xlink_href_	= path; 
 	impl_->object_description_.descriptor_	= progId;
 }
+void pptx_slide_context::set_media(const std::wstring & path)
+{
+	if (path.empty()) return;
+
+	impl_->object_description_.type_		= typeMedia;
+	impl_->object_description_.xlink_href_	= path; 
+
+	impl_->object_description_.action_.enabled	= true;
+	impl_->object_description_.action_.action	= L"ppaction://media";
+}
+
+void pptx_slide_context::set_media_param(std::wstring name, std::wstring value)
+{
+}
 
 void pptx_slide_context::set_image(const std::wstring & path)
 {
@@ -445,7 +525,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 +533,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 +556,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 +570,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 +582,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 +595,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);
 	}
 		
@@ -532,7 +617,6 @@ void pptx_slide_context::Impl::process_shape(drawing_object_description & obj, _
 
 	add_drawing(drawing, isMediaInternal, rId, ref, typeShape);
 }
-
 void pptx_slide_context::Impl::process_object(drawing_object_description& obj, _pptx_drawing & drawing)
 {
     std::wstring ref;
@@ -541,41 +625,59 @@ 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);
 	}
 }
+void pptx_slide_context::Impl::process_media(drawing_object_description& obj, _pptx_drawing & drawing)
+{
+    std::wstring ref;
+    bool isMediaInternal = true;
 
+	drawing.type = mediaitems::detectMediaType(obj.xlink_href_); //reset from Media to Audio, Video, ... QuickTime? AudioCD? ...   
+	
+	drawing.objectId = get_mediaitems().add_or_find(obj.xlink_href_, drawing.type, isMediaInternal, ref);    
+	drawing.extId	 = L"ext" + drawing.objectId;
+	
+	add_drawing(drawing, false, drawing.objectId, L"NULL", drawing.type);
+	add_additional_rels( true, drawing.extId, ref, typeMedia);
+
+	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);
+	}
+}
 void pptx_slide_context::Impl::process_common_properties(drawing_object_description & pic, _pptx_drawing & drawing)
 {
 	if (pic.svg_rect_)
 	{
 		//todooo непонятки с отрицательными значениями
 		int val = (int)(0.5 + odf_types::length(pic.svg_rect_->x, odf_types::length::pt).get_value_unit(odf_types::length::emu));
-		if (val >= 0) drawing.x = val;
+		if ( val >= 0) drawing.x = val;
 		
 		val = (int)(0.5 + odf_types::length(pic.svg_rect_->y, odf_types::length::pt).get_value_unit(odf_types::length::emu));
-		if (val >= 0) drawing.y = val;
+		if ( val >= 0 ) drawing.y = val;
 
 		val = (int)(0.5 + odf_types::length(pic.svg_rect_->cx, odf_types::length::pt).get_value_unit(odf_types::length::emu));
-		if (val >=0) drawing.cx = val;
+		if ( val >=0 ) drawing.cx = val;
 		
 		val = (int)(0.5 + odf_types::length(pic.svg_rect_->cy, odf_types::length::pt).get_value_unit(odf_types::length::emu));
-		if (val >=0) drawing.cy = val;
+		if ( val >=0 ) drawing.cy = val;
 	}
 	
-	drawing.additional = pic.additional_;
-
-	drawing.hlinks = pic.hlinks_;
-
-	drawing.fill = pic.fill_;
+	drawing.additional	= pic.additional_;
+	drawing.hlinks		= pic.hlinks_;
+	drawing.action		= pic.action_;
+	drawing.fill		= pic.fill_;
 }
 
-
 void pptx_slide_context::dump_rels(rels & Rels)
 {
 	impl_->get_drawings()->dump_rels(Rels);
@@ -590,6 +692,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 +711,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 +721,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
 				{
@@ -644,8 +747,12 @@ void pptx_slide_context::serialize_animations(std::wostream & strm)
 				}
 				if (impl_->transition_.Time)
 				{
-					CP_XML_ATTR(L"advTm",impl_->transition_.Time.get());
-				}				
+					CP_XML_ATTR(L"p14:dur", impl_->transition_.Time.get());
+				}	
+				if (impl_->transition_.PageTime)
+				{
+					CP_XML_ATTR(L"advTm", impl_->transition_.PageTime.get());
+				}
 				CP_XML_ATTR(L"advClick", impl_->transition_.onClick);
 				
 				CP_XML_NODE(std::wstring(L"p:" + impl_->transition_.Type))
@@ -668,9 +775,22 @@ void pptx_slide_context::serialize_animations(std::wostream & strm)
 				//p:sndAc
 			}
 		}
-		//CP_XML_NODE(L"p:timing")- последовательности p:par
-		//{
-		//}
+		CP_XML_NODE(L"p:timing")
+		{
+			CP_XML_NODE(L"p:tnLst")
+			{
+				CP_XML_NODE(L"p:par")
+				{
+					CP_XML_NODE(L"p:cTn")
+					{
+						CP_XML_ATTR(L"nodeType", L"tmRoot");
+						CP_XML_ATTR(L"id", 1);
+						CP_XML_ATTR(L"dur", L"indefinite");
+						CP_XML_ATTR(L"restart", L"never");
+					}
+				}
+			}
+		}
 	}
 }
 
@@ -689,7 +809,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 +820,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

@@ -75,7 +75,7 @@ public:
 	void set_placeHolder_type	(std::wstring typeHolder);
 	void set_placeHolder_idx	(int idx);
 
-	std::wstring add_hyperlink(std::wstring const & ref, bool object);
+	std::wstring add_hyperlink(std::wstring const & ref);
 
 	void start_frame();
 		void set_image		(const std::wstring & path);
@@ -83,22 +83,31 @@ public:
 		void set_ms_object	(const std::wstring & path, const std::wstring & progId);
 		void set_ole_object	(const std::wstring & path, const std::wstring & progId);
 		void set_text_box	();
+		void set_media		(const std::wstring & path);
+		void set_media_param(std::wstring name, std::wstring value);
 	void end_frame();
 
+	void start_action	(std::wstring action);
+		void set_link	(std::wstring link, RelsType typeRels = typeHyperlink); 
+	void end_action		();
+
  	void start_table();
     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 +115,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/docx/pptx_text_context.cpp

@@ -631,7 +631,7 @@ void pptx_text_context::Impl::start_list_item(bool restart)
     if (restart && !list_style_stack_.empty())
     {
         const std::wstring curStyleName = current_list_style();
-        const std::wstring newStyleName = curStyleName + boost::lexical_cast<std::wstring>(new_list_style_number_++);
+        const std::wstring newStyleName = curStyleName + std::to_wstring(new_list_style_number_++);
         list_style_renames_[curStyleName] = newStyleName;
 
         odf_reader::list_style_container & lists = odf_context_.listStyleContainer();

ASCOfficeOdfFile/src/docx/xlsx_comments.cpp

@@ -143,9 +143,9 @@ public:
 					
 					std::wstring style = std::wstring(L"position:absolute;");
 					
-					style += std::wstring(L"margin-left:")	+ boost::lexical_cast<std::wstring>(c.left_)		+ std::wstring(L"pt;");
+					style += std::wstring(L"margin-left:")	+ boost::lexical_cast<std::wstring>(c.left_)	+ std::wstring(L"pt;");
 					style += std::wstring(L"margin-top:")	+ boost::lexical_cast<std::wstring>(c.top_)		+ std::wstring(L"pt;");
-					style += std::wstring(L"width:")		+ boost::lexical_cast<std::wstring>(c.width_)		+ std::wstring(L"pt;");
+					style += std::wstring(L"width:")		+ boost::lexical_cast<std::wstring>(c.width_)	+ std::wstring(L"pt;");
 					style += std::wstring(L"height:")		+ boost::lexical_cast<std::wstring>(c.height_)	+ std::wstring(L"pt;");
 
 					if (c.visibly_ == false)style += std::wstring(L"visibility:hidden;");
@@ -227,14 +227,14 @@ public:
 			if (c.author_ == author_list_[i])
 			{
 				find=true;
-				c.author_ =  boost::lexical_cast<std::wstring>(i);
+				c.author_ =  std::to_wstring(i);
 				break;
 			}
 		}
 		if (!find)
 		{
 			author_list_.push_back(c.author_);
-			c.author_ = boost::lexical_cast<std::wstring>(author_list_.size()-1);
+			c.author_ = std::to_wstring(author_list_.size()-1);
 		}
 		xlsx_comment_.push_back(c);
 	}

ASCOfficeOdfFile/src/docx/xlsx_comments_context.cpp

@@ -54,21 +54,21 @@ public:
 
     std::pair<std::wstring, std::wstring> add_comments_xml(std::wstring const & content, std::wstring const & vml_content,xlsx_comments_ptr comments)
     {
- 		const std::wstring file_id = boost::lexical_cast<std::wstring>(next_file_id_++);
+ 		const std::wstring file_id = std::to_wstring(next_file_id_++);
       
 		const std::wstring fileName = std::wstring(L"comments") + file_id + L".xml";
         const std::wstring vml_fileName = std::wstring(L"vmlDrawing") + file_id + L".vml";
         
 		comments_.push_back(comment_elm(fileName,vml_fileName, content, vml_content, comments));
         
-		const std::wstring id = boost::lexical_cast<std::wstring>(next_comments_id_++);
+		const std::wstring id = std::to_wstring(next_comments_id_++);
 		const std::wstring rId = std::wstring(L"comId") + id; 
         return std::pair<std::wstring, std::wstring>(fileName, rId);
     }
 
     std::pair<std::wstring, std::wstring> get_vml_drawing_xml()
     {
-        const std::wstring id = boost::lexical_cast<std::wstring>(next_comments_id_++);		
+        const std::wstring id = std::to_wstring(next_comments_id_++);		
  		const std::wstring rId = std::wstring(L"comId") + id; 
 		return std::pair<std::wstring, std::wstring>(comments_.back().vml_filename, rId);
 	}

ASCOfficeOdfFile/src/docx/xlsx_drawing.cpp

@@ -113,7 +113,7 @@ void xlsx_serialize_image(std::wostream & strm, _xlsx_drawing & val)
                     CP_XML_ATTR(L"id", val.id);
                     CP_XML_ATTR(L"name", val.name);
 
-					oox_serialize_hlink(CP_XML_STREAM(),val.hlinks);
+					oox_serialize_action(CP_XML_STREAM(), val.action);
 
 				}
                 CP_XML_NODE(L"xdr:cNvPicPr")
@@ -158,7 +158,7 @@ void xlsx_serialize_shape(std::wostream & strm, _xlsx_drawing & val)
 
                     CP_XML_ATTR(L"name", val.name);
 
-					oox_serialize_hlink(CP_XML_STREAM(),val.hlinks);
+					oox_serialize_action(CP_XML_STREAM(), val.action);
                 }
 				CP_XML_NODE(L"xdr:cNvSpPr")//non visual properies (собственно тока 1 там)
 				{

ASCOfficeOdfFile/src/docx/xlsx_drawing_context.cpp

@@ -68,7 +68,7 @@ public:
 
     std::pair<std::wstring, std::wstring> add_drawing_xml(std::wstring const & content, xlsx_drawings_ptr drawings)
     {
-        const std::wstring id = boost::lexical_cast<std::wstring>(next_drawing_id_++);
+        const std::wstring id = std::to_wstring(next_drawing_id_++);
         const std::wstring fileName = std::wstring(L"drawing") + id + L".xml";
         drawings_.push_back(drawing_elm(fileName, content, drawings));
         const std::wstring rId = std::wstring(L"rId") + id;//rDrId
@@ -173,6 +173,7 @@ void xlsx_drawing_context::clear()
  
 	impl_->object_description_.additional_.clear();
 	impl_->object_description_.hlinks_.clear();
+	impl_->object_description_.action_.clear();
 	impl_->object_description_.additional_.clear();
 
 	impl_->use_image_replacement_					= false;
@@ -399,16 +400,17 @@ void xlsx_drawing_context::set_fill(_oox_fill & fill)
 	impl_->object_description_.fill_= fill;
 }
 
-std::wstring xlsx_drawing_context::add_hyperlink(std::wstring const & href,bool object)
+std::wstring xlsx_drawing_context::add_hyperlink(std::wstring const & href)
 {
 	++hlinks_size_;
-	std::wstring hId=std::wstring(L"hId") + boost::lexical_cast<std::wstring>(hlinks_size_);
+	std::wstring hId = L"hId" + std::to_wstring(hlinks_size_);
 	
 	std::wstring href_correct = xml::utils::replace_text_to_xml(href);
     XmlUtils::replace_all( href_correct, L" .", L".");//1 (130).odt
 
-	_hlink_desc desc = {hId, href_correct, object}; //корректность написания ссылки важна для ms office и не важна для open office ->
-	//todooo 
+	//корректность написания ссылки важна для ms office и не важна для open office ->
+//todooo 
+	_hlink_desc desc = {hId, href_correct};
 	impl_->object_description_.hlinks_.push_back(desc);
 
 	return hId;
@@ -464,6 +466,7 @@ void xlsx_drawing_context::process_common_properties(drawing_object_description
 	
 	drawing.additional	= obj.additional_;
 	drawing.hlinks		= obj.hlinks_;
+	drawing.action		= obj.action_;
 }
 void xlsx_drawing_context::process_position_properties(drawing_object_description & obj, xlsx_table_metrics & table_metrics,xlsx_table_position & from,xlsx_table_position & to)
 {
@@ -662,11 +665,33 @@ void xlsx_drawing_context::serialize(std::wostream & strm)
     impl_->serialize(strm);    
 }
 
-
 xlsx_drawings_ptr xlsx_drawing_context::get_drawings()
 {
     return impl_->get_drawings();
 }
+void xlsx_drawing_context::start_action(std::wstring action)
+{
+	impl_->object_description_.action_.enabled	= true;
+}
+
+void xlsx_drawing_context::set_link(std::wstring link, RelsType typeRels)
+{//hyprelinks only
+	++hlinks_size_;
+	std::wstring hId = L"hId" + std::to_wstring(hlinks_size_);
+	
+	link = xml::utils::replace_text_to_xml(link);
+	
+	if (typeRels == typeHyperlink)
+		XmlUtils::replace_all( link, L" .", L".");		//1 (130).odt
+
+	impl_->object_description_.action_.hId		= hId;
+	impl_->object_description_.action_.hRef		= link;
+	impl_->object_description_.action_.typeRels	= typeRels;
+}
+void xlsx_drawing_context::end_action()
+{
+}
+
 
 }
 }

ASCOfficeOdfFile/src/docx/xlsx_drawing_context.h

@@ -111,7 +111,7 @@ public:
 
 	std::vector<odf_reader::_property> & get_properties();
 
-	std::wstring add_hyperlink(std::wstring const & ref, bool object);
+	std::wstring add_hyperlink(std::wstring const & ref);
 
 	void set_use_image_replacement();
 	
@@ -125,6 +125,10 @@ public:
     
 	void process_objects(xlsx_table_metrics & table_metrics);
 
+	void start_action(std::wstring action);
+		void set_link(std::wstring link, RelsType typeRels = typeHyperlink); 
+	void end_action();
+
 private:
     class Impl;
     _CP_PTR(Impl) impl_;

ASCOfficeOdfFile/src/docx/xlsx_drawings.cpp

@@ -50,10 +50,12 @@ public:
 		
 		add (isInternal, rid, ref, type, sheet_rel);
         
-		for (int i = 0 ; i < d.hlinks.size(); i++)
+        for (size_t i = 0; i < d.hlinks.size(); i++)
         {
 			xlsx_drawing_rels_.push_back(_rel(false, d.hlinks[i].hId, d.hlinks[i].hRef, typeHyperlink));
 		}
+		if (!d.action.hId.empty())
+ 			xlsx_drawing_rels_.push_back(_rel(false, d.action.hId, d.action.hRef, d.action.typeRels));
     }
     void add( bool isInternal, std::wstring const & rid, std::wstring const & ref, RelsType type, bool sheet_rel) //не объект
     {

ASCOfficeOdfFile/src/docx/xlsx_hyperlinks.cpp

@@ -82,7 +82,7 @@ public:
 		record r;
         r.ref = ref;      
 		r.display = display;
-		r.id = std::wstring(L"hId") + boost::lexical_cast<std::wstring>(records_.size()+1);
+		r.id = std::wstring(L"hId") + std::to_wstring(records_.size()+1);
 
 		int pos_target = target.find(L"#");
         if (pos_target == 0)//ссыль на страницу или метку в текущем документе

ASCOfficeOdfFile/src/docx/xlsx_output_xml.cpp

@@ -55,6 +55,7 @@ public:
     std::wstringstream	autofilter_;
 	std::wstringstream	conditionalFormatting_;
 	std::wstringstream	ole_objects_;
+	std::wstringstream	page_props_;
 
 	rels hyperlinks_rels_;
 	rels ole_objects_rels_;
@@ -134,6 +135,11 @@ std::wostream & xlsx_xml_worksheet::ole_objects()
 {
     return impl_->ole_objects_;
 }
+std::wostream & xlsx_xml_worksheet::page_properties()
+{
+    return impl_->page_props_;
+}
+
 //---------------------------------------------------------------------------------------
 rels & xlsx_xml_worksheet::hyperlinks_rels()
 {
@@ -185,6 +191,12 @@ void xlsx_xml_worksheet::write_to(std::wostream & strm)
             }
 
 			CP_XML_STREAM() << impl_->drawing_.str();
+			
+			if (!impl_->page_props_.str().empty())
+            {
+				CP_XML_STREAM() << impl_->page_props_.str();
+			}//props выше legacyDrawing !!
+			
 			if (impl_->commentsId_.length()>0)
 			{
 				CP_XML_NODE(L"legacyDrawing")
@@ -196,9 +208,10 @@ void xlsx_xml_worksheet::write_to(std::wostream & strm)
             {
                 CP_XML_NODE(L"oleObjects")
                 {
-                    CP_XML_STREAM() << impl_->ole_objects_.str();
+					CP_XML_STREAM() << impl_->ole_objects_.str();
                 }
             }
+
 			//CP_XML_NODE(L"headerFooter){}
 
 			//CP_XML_NODE(L"rowBreaks){}

ASCOfficeOdfFile/src/docx/xlsx_output_xml.h

@@ -63,6 +63,7 @@ public:
 	std::wostream & conditionalFormatting();
 	std::wostream & sort();
 	std::wostream & ole_objects();
+	std::wostream & page_properties();
 	
 	rels & hyperlinks_rels();
 	rels & ole_objects_rels();

ASCOfficeOdfFile/src/docx/xlsx_package.cpp

@@ -128,7 +128,7 @@ void sheets_files::write(const std::wstring & RootPath)
         if (item)
         {
             count++;
-            const std::wstring fileName		= std::wstring(L"sheet") + boost::lexical_cast<std::wstring>(count) + L".xml";
+            const std::wstring fileName		= std::wstring(L"sheet") + std::to_wstring(count) + L".xml";
 			const std::wstring kWSConType	= L"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml";
             
 			content_type_content * contentTypes = this->get_main_document()->get_content_types_file().content();
@@ -136,7 +136,7 @@ void sheets_files::write(const std::wstring & RootPath)
 
             if (rels_)
             {
-                const std::wstring id = std::wstring(L"sId") + boost::lexical_cast<std::wstring>(count);
+                const std::wstring id = std::wstring(L"sId") + std::to_wstring(count);
                 static const std::wstring kWSRel = L"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet";
                 const std::wstring fileRef = std::wstring(L"worksheets/") + fileName;
                 rels_->add(id, kWSRel, fileRef);
@@ -286,7 +286,7 @@ void xl_charts_files::write(const std::wstring & RootPath)
         if (item)
         {
             count++;
-            const std::wstring fileName = std::wstring(L"chart") + boost::lexical_cast<std::wstring>(count) + L".xml";
+            const std::wstring fileName = std::wstring(L"chart") + std::to_wstring(count) + L".xml";
             content_type_content * contentTypes = this->get_main_document()->get_content_types_file().content();
            
 			static const std::wstring kWSConType = L"application/vnd.openxmlformats-officedocument.drawingml.chart+xml";

ASCOfficeOdfFile/src/docx/xlsx_table_state.cpp

@@ -341,11 +341,26 @@ double charsToSize(unsigned int charsCount, double maxDigitSize)
 	return 1.0 * int((maxDigitSize * charsCount + 5.0) / maxDigitSize * 256.0) / 256.0;
 }
 
-void xlsx_table_state::serialize_table_format(std::wostream & _Wostream)
+void xlsx_table_state::serialize_page_properties (std::wostream & strm)
+{
+	_CP_OPT(std::wstring) masterPageName = context_->root()->odf_context().styleContainer().master_page_name_by_name(table_style_);
+	if (!masterPageName) return;
+
+	odf_reader::style_master_page* master_style_ = context_->root()->odf_context().pageLayoutContainer().master_page_by_name(*masterPageName);
+	if (!master_style_) return;
+	if (!master_style_->attlist_.style_page_layout_name_) return;
+
+	odf_reader::page_layout_instance * page_layout = context_->root()->odf_context().pageLayoutContainer().page_layout_by_name(*master_style_->attlist_.style_page_layout_name_);
+	if (!page_layout) return;
+
+	page_layout->xlsx_serialize(strm, *context_);
+}
+
+void xlsx_table_state::serialize_table_format (std::wostream & strm)
 {
 	odf_reader::odf_read_context & odfContext = context_->root()->odf_context();
 
-	CP_XML_WRITER(_Wostream)
+	CP_XML_WRITER(strm)
 	{
 		odf_reader::style_table_properties	* table_prop = NULL;
 		odf_reader::style_instance			* tableStyle = odfContext.styleContainer().style_by_name(table_style_, odf_types::style_family::Table, false);
@@ -406,8 +421,8 @@ void xlsx_table_state::serialize_table_format(std::wostream & _Wostream)
 					int col = -1, row = -1;
 					try
 					{
-						col =  boost::lexical_cast<int>(s_col);
-						row =  boost::lexical_cast<int>(s_row);
+						if (!s_col.empty())		col =  boost::lexical_cast<int>(s_col);
+						if (!s_row.empty())		row =  boost::lexical_cast<int>(s_row);
 					}
 					catch(...){}
 
@@ -435,9 +450,9 @@ void xlsx_table_state::serialize_table_format(std::wostream & _Wostream)
 		{
 			const odf_reader::style_table_row_properties * prop = rowDefStyle->content()->get_style_table_row_properties();
 
-			if ( (prop) &&  (prop->style_table_row_properties_attlist_.style_row_height_))
+			if ( (prop) &&  (prop->attlist_.style_row_height_))
 			{
-				default_height = prop->style_table_row_properties_attlist_.style_row_height_->get_value_unit(odf_types::length::pt);
+				default_height = prop->attlist_.style_row_height_->get_value_unit(odf_types::length::pt);
 			}
 			std::wstringstream ht_s;
 			ht_s.precision(1);
@@ -451,21 +466,21 @@ void xlsx_table_state::serialize_table_format(std::wostream & _Wostream)
 	}
 
 }
-void xlsx_table_state::serialize_merge_cells(std::wostream & _Wostream)
+void xlsx_table_state::serialize_merge_cells(std::wostream & strm)
 {
-    return xlsx_merge_cells_.xlsx_serialize(_Wostream);
+    return xlsx_merge_cells_.xlsx_serialize(strm);
 }
-void xlsx_table_state::serialize_ole_objects(std::wostream & _Wostream)
+void xlsx_table_state::serialize_ole_objects(std::wostream & strm)
 {
-    return xlsx_drawing_context_.get_drawings()->serialize_objects(_Wostream);
+    return xlsx_drawing_context_.get_drawings()->serialize_objects(strm);
 }
-void xlsx_table_state::serialize_hyperlinks(std::wostream & _Wostream)
+void xlsx_table_state::serialize_hyperlinks(std::wostream & strm)
 {
-    return xlsx_hyperlinks_.xlsx_serialize(_Wostream);
+    return xlsx_hyperlinks_.xlsx_serialize(strm);
 }
-void xlsx_table_state::serialize_conditionalFormatting(std::wostream & _Wostream)
+void xlsx_table_state::serialize_conditionalFormatting(std::wostream & strm)
 {
-    return xlsx_conditionalFormatting_context_.serialize(_Wostream);
+    return xlsx_conditionalFormatting_context_.serialize(strm);
 }
 void xlsx_table_state::dump_rels_hyperlinks(rels & Rels)
 {

ASCOfficeOdfFile/src/docx/xlsx_table_state.h

@@ -128,7 +128,8 @@ public:
 	void serialize_merge_cells				(std::wostream & _Wostream);
     void serialize_hyperlinks				(std::wostream & _Wostream);
     void serialize_ole_objects				(std::wostream & _Wostream);
-    
+	void serialize_page_properties			(std::wostream & _Wostream);
+
 	void dump_rels_hyperlinks				(rels & Rels);
 	void dump_rels_ole_objects				(rels & Rels);
 

ASCOfficeOdfFile/src/docx/xlsx_tablecontext.cpp

@@ -317,6 +317,10 @@ void xlsx_table_context::serialize_table_format(std::wostream & _Wostream)
 {
     return state()->serialize_table_format(_Wostream);
 }
+void xlsx_table_context::serialize_page_properties(std::wostream & _Wostream)
+{
+    return state()->serialize_page_properties(_Wostream);
+}
 void xlsx_table_context::serialize_hyperlinks(std::wostream & _Wostream)
 {
     return state()->serialize_hyperlinks(_Wostream);

ASCOfficeOdfFile/src/docx/xlsx_tablecontext.h

@@ -90,6 +90,7 @@ public:
 	void serialize_conditionalFormatting(std::wostream & _Wostream);
 	void serialize_hyperlinks			(std::wostream & _Wostream);
 	void serialize_ole_objects			(std::wostream & _Wostream);
+	void serialize_page_properties		(std::wostream & _Wostream);
 
 	xlsx_table_metrics & get_table_metrics();
   

ASCOfficeOdfFile/src/docx/xlsx_textcontext.cpp

@@ -317,77 +317,58 @@ void xlsx_text_context::Impl::write_rPr(std::wostream & strm)
 
 	ApplyTextProperties (span_style_name_, paragraph_style_name_, text_properties_);
 
-	_CP_OPT(double)	dValFontSize;
-	if (text_properties_.fo_font_size_)
-		dValFontSize=text_properties_.fo_font_size_->get_length().get_value();
-	
-	_CP_OPT(std::wstring) sValFontFamily;	
-	if (text_properties_.fo_font_family_)	
+	if (in_draw)
 	{
-		std::wstring val =text_properties_.fo_font_family_.get();
-		//'Arial' глючит
-		removeCharsFromString(val, _T("'"));
-
-		sValFontFamily=text_properties_.fo_font_family_.get();
+		odf_reader::fonts_container fonts;
+		text_properties_.drawing_serialize(strm, L"a:rPr", fonts);
 	}
-	//else if (text_properties_.style_font_name_) - тут может быть отсылка к font_face)decl !!!!
-	//	sValFontFamily=text_properties_.style_font_name_.get();
-
-	_CP_OPT(std::wstring) sValFontColor;
-	if (text_properties_.fo_color_)		
-		sValFontColor=text_properties_.fo_color_->get_hex_value();
-
-	_CP_OPT(int)	iValFontWeight;
-	if (text_properties_.fo_font_weight_)
-		iValFontWeight=text_properties_.fo_font_weight_->get_type();
-
-	_CP_OPT(int)	iValFontStyle;
-	if(text_properties_.fo_font_style_)
-		iValFontStyle=text_properties_.fo_font_style_->get_type();
-
-	CP_XML_WRITER(strm)
-    {
-		if (in_draw)
-		{
-			//oox_serialize_style_text(strm,text_properties_);
-			//oox_serialize_style_text(strm,odf_reader::text_format_properties_content & properties);
-			CP_XML_NODE(L"a:rPr")
-			{
-				//стр 3197
-				if (dValFontSize)									{CP_XML_ATTR(L"sz", (int)(dValFontSize.get()*100));}
-				if ((iValFontStyle) && (iValFontStyle.get() >0))	{CP_XML_ATTR(L"i", "1");} //"true");} Exercícios de Aprendizagem.ods
-				if ((iValFontWeight) && (iValFontWeight.get() >0))	{CP_XML_ATTR(L"b", "1");} //"true");} Exercícios de Aprendizagem.ods				
-				if (sValFontColor)
-				{
-					CP_XML_NODE(L"a:solidFill")	{CP_XML_NODE(L"a:srgbClr"){CP_XML_ATTR(L"val", sValFontColor.get());}}
-				}
-				if (sValFontFamily)									
-				{
-					CP_XML_NODE(L"a:latin"){CP_XML_ATTR(L"typeface", sValFontFamily.get());}
-				} 
-				
-
-				if (hyperlink_hId.length()>0)
-				{
-					CP_XML_NODE(L"a:hlinkClick ")
-					{
-						CP_XML_ATTR(L"xmlns:r", L"http://schemas.openxmlformats.org/officeDocument/2006/relationships");
-						CP_XML_ATTR(L"r:id", hyperlink_hId);
-					}
-				}
-			}
-		}
-		else
+	else
+	{
+		CP_XML_WRITER(strm)
 		{
 			CP_XML_NODE(L"rPr")
 			{
-				if (sValFontFamily)				{CP_XML_NODE(L"rFont")	{CP_XML_ATTR(L"val", sValFontFamily.get());}}
-				if (dValFontSize)				{CP_XML_NODE(L"sz")		{CP_XML_ATTR(L"val", (int)(dValFontSize.get()));}}
-				if (sValFontColor)				{CP_XML_NODE(L"color")	{CP_XML_ATTR(L"rgb", sValFontColor.get());}}
-				if ((iValFontStyle) &&
-					(iValFontStyle.get() >0))	{CP_XML_NODE(L"i")		{CP_XML_ATTR(L"val", "true");}}
-				if ((iValFontWeight) && 
-					(iValFontWeight.get() >0))	{CP_XML_NODE(L"b")		{CP_XML_ATTR(L"val", "true");}}
+				if (text_properties_.fo_font_family_)
+				{
+					CP_XML_NODE(L"rFont")	
+					{
+						CP_XML_ATTR(L"val", text_properties_.fo_font_family_.get());
+					}
+				}
+				if (text_properties_.fo_font_size_)
+				{
+					CP_XML_NODE(L"sz")		
+					{
+						CP_XML_ATTR(L"val", (int)text_properties_.fo_font_size_->get_length().get_value());
+					}
+				}
+				if (text_properties_.fo_color_)
+				{
+					CP_XML_NODE(L"color")	
+					{
+						CP_XML_ATTR(L"rgb", text_properties_.fo_color_->get_hex_value());
+					}
+				}
+				if (text_properties_.fo_font_style_)
+				{
+					CP_XML_NODE(L"i")		
+					{
+						if (text_properties_.fo_font_style_->get_type() > 0)
+							CP_XML_ATTR(L"val", "true");
+						else 
+							CP_XML_ATTR(L"val", "false");
+					}
+				}
+				if (text_properties_.fo_font_weight_)
+				{
+					CP_XML_NODE(L"b")		
+					{
+						if (text_properties_.fo_font_weight_->get_type() > 0)
+							CP_XML_ATTR(L"val", "true");
+						else
+							CP_XML_ATTR(L"val", "false");
+					}
+				}
 			}
 		}
     }

ASCOfficeOdfFile/src/docx/xlsx_textcontext.h

@@ -54,10 +54,9 @@ class xlsx_conversion_context;
 class xlsx_text_context: boost::noncopyable
 {
 public:
-    //xlsx_text_context();
-	xlsx_text_context(odf_reader::styles_container & styles_);
-    ~xlsx_text_context();
-public:
+	xlsx_text_context	(odf_reader::styles_container & styles_);
+    ~xlsx_text_context	();
+
 	void set_local_styles_container	(odf_reader::styles_container *local_styles_);
 	void set_cell_text_properties	(odf_reader::text_format_properties_content *text_properties);    
     

ASCOfficeOdfFile/src/docx/xlsx_utils.cpp

@@ -66,7 +66,7 @@ std::wstring getColAddress(size_t col)
 
 std::wstring getRowAddress(size_t row)
 {
-    return boost::lexical_cast<std::wstring>(row + 1);
+    return std::to_wstring(row + 1);
 }
 
 std::wstring getCellAddress(size_t col, size_t row)

ASCOfficeOdfFile/src/docx/xlsxconversioncontext.cpp

@@ -138,7 +138,7 @@ void xlsx_conversion_context::end_document()
     {
 		xlsx_xml_worksheet_ptr& sheet = sheets_[i];
 		
-		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);
 
         package::sheet_content_ptr content = package::sheet_content::create();
  ////////////////////////////////////////////////////////////////////////////////////////////       
@@ -369,6 +369,7 @@ void xlsx_conversion_context::end_table()
     current_sheet().cols() << L"</cols>";
     
 	get_table_context().serialize_table_format			(current_sheet().sheetFormat());
+	get_table_context().serialize_page_properties		(current_sheet().page_properties());
 	get_table_context().serialize_conditionalFormatting	(current_sheet().conditionalFormatting());
     get_table_context().serialize_autofilter			(current_sheet().autofilter());
     get_table_context().serialize_sort					(current_sheet().sort());
@@ -420,7 +421,7 @@ void xlsx_conversion_context::end_table()
         current_sheet().set_comments_link(commentsName.first, commentsName.second);
         current_sheet().set_vml_drawing_link(vml_drawingName.first, vml_drawingName.second);
     }    
-
+//background picture
     get_table_context().end_table();
 }
 
@@ -633,7 +634,7 @@ void xlsx_conversion_context::end_hyperlink(std::wstring const & href)
 	}
 	else
 	{
-		std::wstring hId = get_drawing_context().add_hyperlink(href,false);
+		std::wstring hId = get_drawing_context().add_hyperlink(href);
 		xlsx_text_context_.end_hyperlink(hId); 
 		
 		xlsx_text_context_.end_span2();

ASCOfficeOdfFile/src/odf/anim_elements.cpp

@@ -32,18 +32,14 @@
 
 #include "anim_elements.h"
 
-#include <boost/make_shared.hpp>
 #include <cpdoccore/xml/xmlchar.h>
 
 #include <cpdoccore/xml/attributes.h>
 
-#include <boost/lexical_cast.hpp>
-
 #include "serialize_elements.h"
 #include "odfcontext.h"
 #include <cpdoccore/odf/odf_document.h>
 
-
 #include "draw_common.h"
 
 #include <cpdoccore/xml/simple_xml_writer.h>
@@ -62,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)
@@ -74,16 +71,16 @@ void anim_par::pptx_convert(oox::pptx_conversion_context & Context)
 	}
 ///////////////////////// последовательности .. (если один элемент - основная последовательность, иное - взаимодействующая анимация)
 	//slide_context().animation_context().start_sequence();
-	BOOST_FOREACH(const office_element_ptr& elm, anim_seq_array_)
+	for (size_t i = 0; i < anim_seq_array_.size(); i++)
     {
-		elm->pptx_convert(Context);
+		anim_seq_array_[i]->pptx_convert(Context);
 	}
 	//slide_context().animation_context().end_sequence();
 /////////////////////////////////////////////////////////////////
 //внутренние эффекты - те что внутри одной последовательности
-	BOOST_FOREACH(const office_element_ptr& elm, content_)
+	for (size_t i = 0; i < content_.size(); i++)
     {
-		elm->pptx_convert(Context);
+		content_[i]->pptx_convert(Context);
 	}
 }
 void anim_par::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
@@ -102,13 +99,14 @@ 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)
 {
-	BOOST_FOREACH(const office_element_ptr& elm, anim_par_array_)
+	for (size_t i = 0; i < anim_par_array_.size(); i++)
     {
-		elm->pptx_convert(Context);
+		anim_par_array_[i]->pptx_convert(Context);
 	}
 }
 void anim_seq::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
@@ -119,22 +117,24 @@ void anim_seq::add_child_element( xml::sax * Reader, const std::wstring & Ns, co
 ////////////////////////////////////////////////////////////////
 void anim_transition_filter_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:fadeColor",	smil_fadeColor_);
 	CP_APPLY_ATTR(L"smil:mode",			smil_mode_);
-	CP_APPLY_ATTR(L"smil:dur",			smil_dur_);
-
+}
+void anim_audio_attlist::add_attributes( const xml::attributes_wc_ptr & Attributes )
+{
+    CP_APPLY_ATTR(L"xlink:href",		xlink_href_);
+    CP_APPLY_ATTR(L"anim:audio-level",	anim_audio_level_);
 }
 
-const wchar_t * anim_transitionFilter::ns = L"anim";
+const wchar_t * anim_transitionFilter::ns	= L"anim";
 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);
+	common_attlist_.add_attributes(Attributes);
+	filter_attlist_.add_attributes(Attributes);
 }
 
 void anim_transitionFilter::pptx_convert(oox::pptx_conversion_context & Context)
@@ -146,20 +146,20 @@ void anim_transitionFilter::pptx_convert(oox::pptx_conversion_context & Context)
 
 	_CP_OPT(std::wstring) param;
 
-	if (anim_transition_filter_attlist_.smil_dur_)
+	if (common_attlist_.smil_dur_)
 	{
-		time = anim_transition_filter_attlist_.smil_dur_->get_value();
+		time = common_attlist_.smil_dur_->get_value();
 	}	
-	if (anim_transition_filter_attlist_.smil_fadeColor_)
+	if (filter_attlist_.smil_fadeColor_)
 	{
-		color =anim_transition_filter_attlist_.smil_fadeColor_->get_hex_value();
+		color = filter_attlist_.smil_fadeColor_->get_hex_value();
 	}
 
 	smil_transition_type::type transition_type;
 
-	if (anim_transition_filter_attlist_.smil_type_)
+	if (filter_attlist_.smil_type_)
 	{
-		transition_type = anim_transition_filter_attlist_.smil_type_->get_type();
+		transition_type = filter_attlist_.smil_type_->get_type();
 	}
 
 	switch(transition_type)
@@ -168,13 +168,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 ((filter_attlist_.smil_subtype_) && (filter_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 ((filter_attlist_.smil_subtype_) && (filter_attlist_.smil_subtype_.get()==L"doubleDiamond"))
 				type = L"diamond";
 			else
 				type = L"zoom";
@@ -201,10 +201,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 ((filter_attlist_.smil_subtype_)  && (filter_attlist_.smil_subtype_.get()==L"oneBlade"))	param = L"1";
+			else if ((filter_attlist_.smil_subtype_)  && (filter_attlist_.smil_subtype_.get()==L"threeBlade"))	param = L"3";
+			else if ((filter_attlist_.smil_subtype_)  && (filter_attlist_.smil_subtype_.get()==L"fourBlade"))	param = L"4";
+			else if ((filter_attlist_.smil_subtype_)  && (filter_attlist_.smil_subtype_.get()==L"eightBlade"))	param = L"8";
 			break; 
 		case smil_transition_type::fanWipe: 
 			type = L"wedge";
@@ -215,22 +215,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 (filter_attlist_.smil_subtype_.get()==L"across")	dir = L"horz";
+			if (filter_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 (filter_attlist_.smil_subtype_.get()==L"vertical")		dir = L"vert";
+			else if (filter_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 (filter_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		(filter_attlist_.smil_subtype_.get() == L"horizontalLeft")		dir = L"rd";	
+				else if (filter_attlist_.smil_subtype_.get() == L"horizontalRight")		dir = L"lu";	
+				else if (filter_attlist_.smil_subtype_.get() == L"verticalRight")		dir = L"ld";
 				else dir = L"ru";	
 			}
 			break;
@@ -239,13 +239,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 (filter_attlist_.smil_subtype_.get() == L"vertical")	dir = L"vert";
+			else if (filter_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 (filter_attlist_.smil_subtype_.get() == L"combVertical")	{type = L"comb"; dir = L"vert";}
+			else if (filter_attlist_.smil_subtype_.get() == L"combHorizontal")	{type = L"comb"; dir = L"horz";}
 			break;	
 		case smil_transition_type::slideWipe: 
 			type = L"pull";
@@ -255,19 +255,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 (filter_attlist_.smil_subtype_.get() == L"vertical")		param = L"vert";
+			if (filter_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 (filter_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 (filter_attlist_.smil_subtype_.get()==L"fromTopLeft")		{type = L"strips"; dir = L"rd";}
+				else if (filter_attlist_.smil_subtype_.get()==L"fromBottomLeft")	{type = L"strips"; dir = L"ru";}
+				else if (filter_attlist_.smil_subtype_.get()==L"fromTopRight")		{type = L"strips"; dir = L"ld";}
+				else if (filter_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";}
+				else if (filter_attlist_.smil_subtype_.get()==L"fadeOverColor")		{type = L"fade"; param = L"0";}
 			}
 			break;
 ///////////////////////////////////////////////////////
@@ -285,44 +285,56 @@ void anim_transitionFilter::pptx_convert(oox::pptx_conversion_context & Context)
 			break;
 //////////////////////////////////////////////////////
 	}
-	if (anim_transition_filter_attlist_.smil_subtype_)
+	if (filter_attlist_.smil_subtype_)
 	{
 		if (!dir)
 		{
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"leftToRight")
+			if (filter_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 ((common_attlist_.smil_direction_) && (common_attlist_.smil_direction_.get()==L"reverse"))dir = L"l";
 				else dir = L"r";
 			}
-			if (anim_transition_filter_attlist_.smil_subtype_.get()==L"topToBottom")
+			if (filter_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 ((common_attlist_.smil_direction_) && (common_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 (filter_attlist_.smil_subtype_.get()==L"fromTop")		dir = L"d";	
+			else if (filter_attlist_.smil_subtype_.get()==L"fromLeft")		dir = L"r";	
+			else if (filter_attlist_.smil_subtype_.get()==L"fromRight")		dir = L"l";			
+			else if (filter_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";	
+			else if (filter_attlist_.smil_subtype_.get()==L"topRight")		dir = L"ld";	
+			else if (filter_attlist_.smil_subtype_.get()==L"bottomLeft")	dir = L"lu";	
+			else if (filter_attlist_.smil_subtype_.get()==L"bottomRight")	dir = L"ru";
+			else if (filter_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";
+			else if (filter_attlist_.smil_subtype_.get()==L"fromTopLeft")	dir = L"rd";
+			else if (filter_attlist_.smil_subtype_.get()==L"fromBottomLeft")dir = L"ru";
+			else if (filter_attlist_.smil_subtype_.get()==L"fromTopRight")	dir = L"ld";
+			else if (filter_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 && (common_attlist_.smil_direction_) && (common_attlist_.smil_direction_.get()==L"reverse"))
 			dir = L"in";
 	}
 
 	Context.get_slide_context().set_transitionFilter(type , dir, param , time);
+}
 
+const wchar_t * anim_audio::ns = L"anim";
+const wchar_t * anim_audio::name = L"audio";
+
+void anim_audio::add_attributes( const xml::attributes_wc_ptr & Attributes )
+{
+	common_attlist_.add_attributes(Attributes);
+	audio_attlist_.add_attributes(Attributes);
+}
+
+void anim_audio::pptx_convert(oox::pptx_conversion_context & Context)
+{
 }
 
 ////////////////////////////////////////////////////////////////

ASCOfficeOdfFile/src/odf/anim_elements.h

@@ -45,7 +45,6 @@ namespace cpdoccore {
 namespace odf_reader {
 
 
-
 //anim:par
 class anim_par : public office_element_impl<anim_par>//Параллельные анимации
 {
@@ -56,9 +55,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 +80,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);
 
@@ -92,26 +94,25 @@ private:
 CP_REGISTER_OFFICE_ELEMENT2(anim_seq);
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //anim:iterate 
-//class anim_iterate : public office_element_impl<anim_iterate>//Итеративные анимации
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//----------------------------------------------------------------------------------------------------------------/
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-//anim-transition-filter-attlist
+//-------------------------------------------------------------------------------
+class anim_audio_attlist
+{
+public:
+    void add_attributes( const xml::attributes_wc_ptr & Attributes );
+	
+	_CP_OPT(std::wstring)						xlink_href_;
+	_CP_OPT(std::wstring)						anim_audio_level_; 
+};
 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_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_;
 };
-
-//anim:transitionFilter
 class anim_transitionFilter : public office_element_impl<anim_transitionFilter>
 {
 public:
@@ -122,11 +123,9 @@ 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_;
-
 
+	odf_types::common_anim_smil_attlist		common_attlist_;
+	anim_transition_filter_attlist			filter_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 );
@@ -135,7 +134,26 @@ private:
 };
 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 pptx_convert(oox::pptx_conversion_context & Context);
+
+	odf_types::common_anim_smil_attlist		common_attlist_;
+	anim_audio_attlist						audio_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 );
+
+
+};
+CP_REGISTER_OFFICE_ELEMENT2(anim_audio);
 //anim:command
 
 }

ASCOfficeOdfFile/src/odf/calcs_styles.cpp

@@ -161,7 +161,7 @@ style_table_cell_properties_attlist calc_table_cell_properties(const std::vector
     BOOST_FOREACH(const style_table_cell_properties* v, props)
     {
         if (v)
-            result.apply_from(v->style_table_cell_properties_attlist_);
+            result.apply_from(v->attlist_);
     }
     return result;
 }

ASCOfficeOdfFile/src/odf/datatypes/clockvalue.cpp

@@ -41,27 +41,65 @@ 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
+	{
+		int ms	= _Val.get_value();
+		int sec = 0;
+		int min = 0;
+		int h	= 0;
+
+		if (ms > 1000)
+		{
+			sec = ms / 1000;
+			ms	-= sec * 1000;
+
+			if (sec > 60)
+			{
+				min = sec / 60;
+				sec -= min * 60;
+
+				if (min > 60)
+				{
+					h = min / 60;
+					min -= h * 60;
+				}			
+			}
+
+		}
+		if ( h > 0)
+			_Wostream <<  h  << "h"; 
+		if ( min > 0)
+			_Wostream <<  min  << "min"; 
+		if ( sec > 0)
+			_Wostream <<  sec  << "s"; 
+		if ( ms > 0)
+			_Wostream <<  ms  << "ms"; 
+
+		if (h == 0 && min == 0 && ms == 0 && sec == 0)
+			_Wostream << "0s"; 
+	}
     return _Wostream;    
 }
 
-static bool parseTime(const std::wstring & Time, double & Hours, double & Minutes, double & Seconds, int & Ms)
+bool parseTime(std::wstring Time, double & Hours, double & Minutes, double & Seconds, int & Ms)
 {
     try 
     {
-		boost::match_results<std::wstring::const_iterator> res;
 
 //Full clock values: 
 //  02:30:03    = 2 hours, 30 minutes and 3 seconds
 //  50:00:10.25 = 50 hours, 10 seconds and 250 milliseconds
 
+		boost::match_results<std::wstring::const_iterator> res1;
 		boost::wregex r1 (L"([\\d]+):([\\d]+):([\\d+(\\.\\d{0,})?]+)");
-        if (boost::regex_match(Time, res, r1))
+        if (boost::regex_match(Time, res1, r1))
         {
-            Hours = boost::lexical_cast<int>(res[1].str());
-            Minutes = boost::lexical_cast<int>(res[2].str());
-            Seconds = boost::lexical_cast<double>(res[3].str());
+            Hours = boost::lexical_cast<int>(res1[1].str());
+            Minutes = boost::lexical_cast<int>(res1[2].str());
+            Seconds = boost::lexical_cast<double>(res1[3].str());
 
             return true;
         }
@@ -69,11 +107,12 @@ static bool parseTime(const std::wstring & Time, double & Hours, double & Minute
 //  02:33   = 2 minutes and 33 seconds
 //  00:10.5 = 10.5 seconds = 10 seconds and 500 milliseconds
 		std::wstring  Time2 = L"00:10.5";
+		boost::match_results<std::wstring::const_iterator> res2;
 		boost::wregex r2 (L"([\\d]+):([\\d+(\\.\\d{0,})?]+)");	
-        if (boost::regex_match(Time, res, r2))
+        if (boost::regex_match(Time, res2, r2))
         {
-            Minutes = boost::lexical_cast<int>(res[1].str());
-            Seconds = boost::lexical_cast<double>(res[2].str());
+            Minutes = boost::lexical_cast<int>(res2[1].str());
+            Seconds = boost::lexical_cast<double>(res2[2].str());
 
             return true;
         }
@@ -83,32 +122,51 @@ static bool parseTime(const std::wstring & Time, double & Hours, double & Minute
 //  30s     = 30 seconds
 //  5ms     = 5 milliseconds
 //  12.467  = 12 seconds and 467 milliseconds
-		boost::wregex r3 (L"([\\d+(\\.\\d{0,})?]+)([A-Za-z]{0,})");
-        if (boost::regex_match(Time, res, r3))
-        {
-			if (!res[2].str().empty())
+		std::vector<std::wstring> values;
+		boost::wregex r3 (L"([\\d+(\\.\\d{0,})?]+)([A-Za-z]+)");
+        if (boost::regex_split(std::back_inserter(values), Time, r3, boost::match_default | boost::format_all))
+        {	
+			int val = -1;
+			for (size_t i = 0; i < values.size() ; i++ )
 			{
-				std::wstring n = res[2].str();
-				std::transform(n.begin(), n.end(), n.begin(), ::tolower);
-				if (n == L"h")
+				if (values[i].empty()) continue;
+
+				if (values[i] == L"h")
 				{
-					Hours  = boost::lexical_cast<double>(res[1].str());
+					if (val >= 0)
+						Hours  = val;
+					val = -1;
 				}
-				else if (n == L"min")
+				else if (values[i] == L"min")
 				{
-					Minutes  = boost::lexical_cast<double>(res[1].str());
+					if (val >= 0)
+						Minutes  = val;
+					val = -1;
 				}
-				else if (n == L"s")
+				else if (values[i] == L"s")
 				{
-					Seconds  = boost::lexical_cast<double>(res[1].str());
+					if (val >= 0)
+						Seconds  = val;
+					val = -1;
 				}
-				else if (n == L"ms")
+				else if (values[i] == L"ms")
 				{
-					Ms = boost::lexical_cast<int>(res[1].str());
+					if (val >= 0)
+						Ms  = val;
+					val = -1;
+				}
+				else
+				{
+					try
+					{
+						val = boost::lexical_cast<double>(values[i]);
+					}
+					catch(...)
+					{
+						continue;
+					}
 				}
 			}
-			else            
-				Seconds = boost::lexical_cast<double>(res[1].str());
 
             return true;
         }
@@ -120,15 +178,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/custom_shape_types_convert.h

@@ -251,7 +251,11 @@ static const _shape_converter _OO_OOX_custom_shapes[]=
 {L""						,L"accentBorderCallout3",0	,0	,0	},
 {L""						,L"accentBorderCallout2",0	,0	,0	},
 {L""						,L"accentBorderCallout1",0	,0	,0	},
-{L""						,L"halfFrame"		,0	,0	,0	}
+{L""						,L"halfFrame"		,0	,0	,0	},
+{L""						,L"leftCircularArrow",0	,0	,0	},
+{L""						,L"leftRightRibbon",0	,0	,0	},
+{L""						,L"pieWedge",0	,0	,0	},
+{L""						,L"swooshArrow",0	,0	,0	}
 
 };
 

ASCOfficeOdfFile/src/odf/datatypes/length.cpp

@@ -200,7 +200,11 @@ double pt_to_cm(double Val)
     return Val / 28.34467120181406;
     
 }
-
+double pt_to_mm(double Val)
+{
+    return Val / 2.834467120181406;
+    
+}
 double to_pt(const length & Val)
 {
     switch(Val.get_unit())
@@ -247,7 +251,11 @@ double length::get_value_unit(unit Unit) const
     {
         return pt_to_cm( to_pt(*this) );
     }
-    else
+    else if (Unit == mm)
+    {
+        return pt_to_mm( to_pt(*this) );
+    }
+	else
     {
         return 0.0;
     }

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_common.cpp

@@ -112,9 +112,10 @@ bool parse_clipping(std::wstring strClipping,std::wstring fileName, double_4 & c
 	std::vector<length>			Points_pt;
 	
 	boost::algorithm::split(Points,strClipping, boost::algorithm::is_any_of(L" ,"), boost::algorithm::token_compress_on);
-	BOOST_FOREACH(std::wstring const & p, Points)
+	
+	for (size_t i = 0; i < Points.size(); i++)
 	{
-		Points_pt.push_back(length::parse(p) );
+		Points_pt.push_back(length::parse(Points[i]) );
 		
 		if (Points_pt.back().get_value() > 0.00001) bEnableCrop = true;
 	}
@@ -125,8 +126,6 @@ bool parse_clipping(std::wstring strClipping,std::wstring fileName, double_4 & c
 
 	if (!_image_file_::GetResolution(fileName.data(), fileWidth, fileHeight, appFonts) || fileWidth<1 || fileHeight<1)	return false;
 
-
-
 	if (Points_pt.size() > 3)//если другое количество точек .. попозже
 	{
 		float dpi_ = 96.;
@@ -561,30 +560,33 @@ void draw_a::add_attributes( const xml::attributes_wc_ptr & Attributes )
 
 void draw_a::xlsx_convert(oox::xlsx_conversion_context & Context)
 {
-    Context.get_drawing_context().add_hyperlink(common_xlink_attlist_.href_.get_value_or(L""),true);
-				//стиль на текст не нужен ..текста то нет - ссылка с объекта
+	Context.get_drawing_context().start_action(L"");
+		Context.get_drawing_context().set_link(common_xlink_attlist_.href_.get_value_or(L""));
+ 	Context.get_drawing_context().end_action();
    
-	BOOST_FOREACH(const office_element_ptr & elm, content_)
+	for (size_t i = 0; i < content_.size(); i++)
     {
-        elm->xlsx_convert(Context);
+        content_[i]->xlsx_convert(Context);
     }
 }
 void draw_a::pptx_convert(oox::pptx_conversion_context & Context)
 {
-   Context.get_slide_context().add_hyperlink(common_xlink_attlist_.href_.get_value_or(L""),true);//стиль на текст не нужен ..текста то нет - ссылка с объекта
-   
-	BOOST_FOREACH(const office_element_ptr & elm, content_)
+	Context.get_slide_context().start_action(L"");
+		Context.get_slide_context().set_link(common_xlink_attlist_.href_.get_value_or(L""));
+ 	Context.get_slide_context().end_action();
+  
+	for (size_t i = 0; i < content_.size(); i++)
     {
-        elm->pptx_convert(Context);
+        content_[i]->pptx_convert(Context);
     }
 }
 void draw_a::docx_convert(oox::docx_conversion_context & Context) 
 {
 	std::wstring rId = Context.add_hyperlink(common_xlink_attlist_.href_.get_value_or(L""), true);//гиперлинк с объекта, а не с текста .. 
 	
-	BOOST_FOREACH(const office_element_ptr & elm, content_)
-    {
-        elm->docx_convert(Context);
+	for (size_t i = 0; i < content_.size(); i++)
+	{
+        content_[i]->docx_convert(Context);
     }
 
 }
@@ -596,9 +598,9 @@ void parse_string_to_points(std::wstring str, std::vector<length> & Points)
 
 	boost::algorithm::split(Points_s,str, boost::algorithm::is_any_of(L" ,"), boost::algorithm::token_compress_on);
 
-	BOOST_FOREACH(std::wstring const & p, Points_s)
+	for (size_t i = 0; i < Points_s.size(); i++)
 	{
-		Points.push_back(length::parse(p) );
+		Points.push_back(length::parse(Points_s[i]) );
 	}
 }
 
@@ -608,12 +610,12 @@ void oox_convert_transforms(std::wstring transformStr,std::vector<odf_reader::_p
 	
 	boost::algorithm::split(transforms,transformStr, boost::algorithm::is_any_of(L")"), boost::algorithm::token_compress_on);
 	
-	BOOST_FOREACH(std::wstring const & t, transforms)
+	for (size_t i = 0; i < transforms.size(); i++)
 	{			
         //_CP_LOG << "[info] : transform = " << t << L"\n";
 		std::vector<std::wstring> transform;
 		
-		boost::algorithm::split(transform,t, boost::algorithm::is_any_of(L"("), boost::algorithm::token_compress_on);
+		boost::algorithm::split(transform, transforms[i], boost::algorithm::is_any_of(L"("), boost::algorithm::token_compress_on);
 		
 		if (transform.size() > 1)//тока с аргументами
 		{
@@ -725,11 +727,11 @@ void pptx_convert_transforms(std::wstring transformStr, oox::pptx_conversion_con
 	
 	boost::algorithm::split(transforms,transformStr, boost::algorithm::is_any_of(L")"), boost::algorithm::token_compress_on);
 	
-	BOOST_FOREACH(std::wstring const & t, transforms)
+	for (size_t i = 0; i < transforms.size(); i++)
 	{			
         //_CP_LOG << "[info] : transform = " << t << L"\n";
 		std::vector<std::wstring> transform;
-		boost::algorithm::split(transform,t, boost::algorithm::is_any_of(L"("), boost::algorithm::token_compress_on);
+		boost::algorithm::split(transform, transforms[i], boost::algorithm::is_any_of(L"("), boost::algorithm::token_compress_on);
 
 		if (transform.size()>1)//тока с аргументами
 		{

ASCOfficeOdfFile/src/odf/draw_frame.cpp

@@ -383,6 +383,38 @@ std::wstring draw_object::office_convert(odf_document * odfDocument, int type)
 	
 	return href_result;
 }
+// draw:param
+//////////////////////////////////////////////////////////////////////////////////////////////////
+const wchar_t * draw_param::ns = L"draw";
+const wchar_t * draw_param::name = L"param";
+
+void draw_param::add_attributes( const xml::attributes_wc_ptr & Attributes )
+{
+	CP_APPLY_ATTR(L"draw:name", draw_name_);
+	CP_APPLY_ATTR(L"draw:value", draw_value_);
+}
+
+void draw_param::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
+{
+    CP_NOT_APPLICABLE_ELM(); 
+}
+// draw:plugin
+//////////////////////////////////////////////////////////////////////////////////////////////////
+const wchar_t * draw_plugin::ns = L"draw";
+const wchar_t * draw_plugin::name = L"plugin";
+
+void draw_plugin::add_attributes( const xml::attributes_wc_ptr & Attributes )
+{
+	CP_APPLY_ATTR(L"draw:mime-type", draw_mime_type_);
+
+    common_xlink_attlist_.add_attributes(Attributes);
+}
+
+void draw_plugin::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
+{
+    CP_CREATE_ELEMENT(content_); 
+}
+
 
 }
 }

ASCOfficeOdfFile/src/odf/draw_frame.h

@@ -332,5 +332,56 @@ private:
 
 CP_REGISTER_OFFICE_ELEMENT2(draw_object_ole);
 
+// draw:param
+class draw_param : public office_element_impl<draw_param>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typeDrawParam;
+    CPDOCCORE_DEFINE_VISITABLE();
+
+	virtual void docx_convert(oox::docx_conversion_context & Context){}
+	virtual void xlsx_convert(oox::xlsx_conversion_context & Context){}
+    virtual void pptx_convert(oox::pptx_conversion_context & Context);
+
+	_CP_OPT(std::wstring)	draw_name_;
+	_CP_OPT(std::wstring)	draw_value_;
+
+private:
+    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);
+};
+
+CP_REGISTER_OFFICE_ELEMENT2(draw_param);
+
+// 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 docx_convert(oox::docx_conversion_context & Context){}
+	virtual void xlsx_convert(oox::xlsx_conversion_context & Context){}
+    virtual void pptx_convert(oox::pptx_conversion_context & Context);
+
+    odf_types::common_xlink_attlist	common_xlink_attlist_;
+	_CP_OPT(std::wstring)			draw_mime_type_;
+    
+	office_element_ptr_array		content_;
+
+private:
+    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);
+};
+
+CP_REGISTER_OFFICE_ELEMENT2(draw_plugin);
+
+
 }
 }

ASCOfficeOdfFile/src/odf/draw_frame_docx.cpp

@@ -153,7 +153,7 @@ length ComputeContextWidth(const style_page_layout_properties			* pageProperties
             if (pagePropertiesNode)
             {
                 if (const style_columns * styleColumns 
-                    = dynamic_cast<const style_columns*>( pagePropertiesNode->style_page_layout_properties_elements_.style_columns_.get()))
+                    = dynamic_cast<const style_columns*>( pagePropertiesNode->elements_.style_columns_.get()))
                 {
                     columnsCount = styleColumns->fo_column_count_.get_value_or(1);
                     if (!columnsCount)
@@ -784,7 +784,7 @@ void common_draw_docx_convert(oox::docx_conversion_context & Context, const unio
     style_page_layout_properties_attlist	emptyPageProperties;
     
 	const style_page_layout_properties_attlist &	pageProperties =
-		pagePropertiesNode ? pagePropertiesNode->style_page_layout_properties_attlist_ : emptyPageProperties;
+		pagePropertiesNode ? pagePropertiesNode->attlist_ : emptyPageProperties;
 
 /////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -831,7 +831,7 @@ void common_draw_docx_convert(oox::docx_conversion_context & Context, const unio
             if (*zIndex < 0) 
                 drawing->relativeHeight = L"0";
             else
-                drawing->relativeHeight = boost::lexical_cast<std::wstring>( 2 + *zIndex );
+				drawing->relativeHeight = std::to_wstring( 2 + *zIndex );
         }
 
         if (drawing->styleWrap && drawing->styleWrap->get_type() == style_wrap::RunThrough 
@@ -1111,10 +1111,13 @@ void draw_image::docx_convert(oox::docx_conversion_context & Context)
 	oox::hyperlinks::_ref hyperlink = Context.last_hyperlink();
 	//нужно еще систему конроля - могут придте уже "использованные" линки с картинок - из колонтитулов (но на них уже использовали релсы)
 	//дыра осталась если картинка в картинке - линк продублируется с внутренней на внешнюю 
+	
 	if (hyperlink.drawing == true && hyperlink.used_rels == false)
-	{
-		oox::_hlink_desc desc = {hyperlink.id, hyperlink.href, true};
-		drawing->hlinks.push_back(desc);
+	{//link from object
+		drawing->action.enabled = true;
+		drawing->action.hId		= hyperlink.id;
+		drawing->action.hRef	= hyperlink.href;
+		drawing->action.typeRels= oox::typeHyperlink;
 	}
 /////////
 	drawing->fill.bitmap = oox::oox_bitmap_fill::create();

ASCOfficeOdfFile/src/odf/draw_frame_pptx.cpp

@@ -92,6 +92,7 @@ void draw_frame::pptx_convert(oox::pptx_conversion_context & Context)
     const std::wstring name				= common_draw_attlist_.draw_name_.get_value_or(L"");
     const std::wstring textStyleName	= common_draw_attlist_.draw_text_style_name_.get_value_or(L"");
 
+	Context.get_slide_context().set_name(name);
 //////////////////////////////////////////////////////////////////////////
 	const _CP_OPT(length) svg_widthVal =  common_draw_attlists_.rel_size_.common_draw_size_attlist_.svg_width_;    
     const _CP_OPT(length) svg_heightVal = common_draw_attlists_.rel_size_.common_draw_size_attlist_.svg_height_;
@@ -248,9 +249,9 @@ void draw_text_box::pptx_convert(oox::pptx_conversion_context & Context)
 	
 	std::wstring text_content_ = Context.get_text_context().end_object();
 
-	if (text_content_.length()>0)
+	if (!text_content_.empty())
 	{
-		Context.get_slide_context().set_property(_property(L"text-content",text_content_));
+		Context.get_slide_context().set_property(_property(L"text-content", text_content_));
 	}
 }
 void draw_object::pptx_convert(oox::pptx_conversion_context & Context)
@@ -358,6 +359,28 @@ void draw_object_ole::pptx_convert(oox::pptx_conversion_context & Context)
 		Context.get_slide_context().set_ole_object(href, detectObject(objectPath));
 }
 
+void draw_param::pptx_convert(oox::pptx_conversion_context & Context)
+{
+	if (!draw_name_ && !draw_value_) return;
+
+	Context.get_slide_context().set_media_param(*draw_name_, *draw_value_);
+}
+
+void draw_plugin::pptx_convert(oox::pptx_conversion_context & Context)
+{
+	Context.get_slide_context().set_use_image_replacement();
+	
+	std::wstring href		= common_xlink_attlist_.href_.get_value_or(L"");
+	std::wstring folderPath = Context.root()->get_folder();
+	std::wstring objectPath = folderPath + FILE_SEPARATOR_STR + href;
+
+	Context.get_slide_context().set_media(href);
+//params	
+	for (size_t i = 0; i < content_.size(); i++)
+    {
+        content_[i]->pptx_convert(Context);
+    }
+}
 }
 }
 

ASCOfficeOdfFile/src/odf/draw_page.cpp

@@ -32,13 +32,9 @@
 
 #include "draw_page.h"
 
-#include <boost/make_shared.hpp>
 #include <cpdoccore/xml/xmlchar.h>
-
 #include <cpdoccore/xml/attributes.h>
 
-#include <boost/lexical_cast.hpp>
-
 #include "serialize_elements.h"
 #include "odfcontext.h"
 #include <cpdoccore/odf/odf_document.h>
@@ -78,13 +74,15 @@ 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_);
 }
 
 void draw_page::add_attributes( const xml::attributes_wc_ptr & Attributes )
 {
-    draw_page_attr_.add_attributes(Attributes);
+    attlist_.add_attributes(Attributes);
 }
 
 void draw_page::pptx_convert_placeHolder(oox::pptx_conversion_context & Context, std::wstring styleName, presentation_class::type PresentationClass)
@@ -96,7 +94,7 @@ void draw_page::pptx_convert_placeHolder(oox::pptx_conversion_context & Context,
 
 	int index=-1;
 
-    const std::wstring masterName = draw_page_attr_.master_page_name_.get_value_or(L"");
+    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)
@@ -129,16 +127,16 @@ void draw_page::pptx_convert_placeHolder(oox::pptx_conversion_context & Context,
 
 void draw_page::pptx_convert(oox::pptx_conversion_context & Context)
 {
-	const std::wstring pageStyleName	= draw_page_attr_.draw_style_name_.get_value_or(L"");
-    const std::wstring pageName			= draw_page_attr_.draw_name_.get_value_or(L"");
-    const std::wstring layoutName		= draw_page_attr_.page_layout_name_.get_value_or(L"");
-    const std::wstring masterName		= draw_page_attr_.master_page_name_.get_value_or(L"");
+	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][xlsx] process page(slide) \"" << pageName /*L"" */<< L"\"" << std::endl;
+    _CP_LOG << L"[info][pptx] process page(slide) \"" << pageName /*L"" */<< L"\"" << std::endl;
 
     Context.start_page(pageName, pageStyleName, layoutName,masterName);
 
-	if (draw_page_attr_.draw_style_name_)
+	if (attlist_.draw_style_name_)
 	{
 		style_instance * style_inst = Context.root()->odf_context().styleContainer().style_by_name(pageStyleName,style_family::DrawingPage,false);
 
@@ -191,23 +189,30 @@ void draw_page::pptx_convert(oox::pptx_conversion_context & Context)
 		animation_->pptx_convert(Context);
 	}
 /////////////////////////
-	BOOST_FOREACH(const office_element_ptr& elm, content_)
+	for (size_t i = 0; i < content_.size(); i++)
     {
-		elm->pptx_convert(Context);
+		content_[i]->pptx_convert(Context);
 	}
 
-	if (draw_page_attr_.use_footer_name_)//from master_page
+	if (attlist_.use_footer_name_)//from master_page
 	{
-		std::wstring name = L"footer:" + *draw_page_attr_.use_footer_name_;
+		std::wstring name = L"footer:" + *attlist_.use_footer_name_;
 		pptx_convert_placeHolder(Context, name, presentation_class::footer);
 	}
-	if (draw_page_attr_.use_date_time_name_)//from master_page
+	if (attlist_.use_date_time_name_)//from master_page
 	{
-		std::wstring name = L"datetime:" + *draw_page_attr_.use_date_time_name_;
+		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";
@@ -243,6 +248,117 @@ void presentation_date_time_decl::pptx_convert(oox::pptx_conversion_context & Co
 {
 	Context.get_text_context().add_text(text_);
 }
+//////////////////////////////////////////////////////////////////////////////////////////////////
+const wchar_t * presentation_notes::ns = L"presentation";
+const wchar_t * presentation_notes::name = L"notes";
+
+void presentation_notes::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
+{
+	CP_CREATE_ELEMENT(content_);
+}
+
+void presentation_notes::add_attributes( const xml::attributes_wc_ptr & Attributes )
+{
+    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(oox::pptx_conversion_context & Context)
+{
+	const std::wstring pageStyleName	= attlist_.draw_style_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;
+
+	if (attlist_.draw_style_name_)
+	{
+		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()))
+		{
+			const style_drawing_page_properties * properties = style_inst->content()->get_style_drawing_page_properties();
+
+			if (properties)
+			{				
+				oox::_oox_fill fill;
+				Compute_GraphicFill(properties->content().common_draw_fill_attlist_, office_element_ptr(), 
+																	Context.root()->odf_context().drawStyles() ,fill);
+				Context.get_slide_context().add_background(fill);
+			
+	////////////////////////////////////////////////
+				if ((properties->content().presentation_display_footer_) && (*properties->content().presentation_display_footer_))
+					Context.get_slide_context().set_footer();
+					
+				if ((properties->content().presentation_display_header_) && (*properties->content().presentation_display_header_))
+					Context.get_slide_context().set_header();			
+				
+				if ((properties->content().presentation_display_page_number_) && (*properties->content().presentation_display_page_number_))
+					Context.get_slide_context().set_page_number();
+				
+				if ((properties->content().presentation_display_date_time_) && (*properties->content().presentation_display_date_time_))
+					Context.get_slide_context().set_date_time();			
+			}
+		}
+	}
+
+/////////////////////////
+	for (size_t i = 0; i < content_.size(); i++)
+    {
+		content_[i]->pptx_convert(Context);
+	}
+
+	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);
+	}
+
+}
 
 }
 }

ASCOfficeOdfFile/src/odf/draw_page.h

@@ -79,11 +79,11 @@ private:
     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);
 
-private:
-    office_element_ptr_array content_;
-	office_element_ptr animation_;
+    office_element_ptr_array	content_;
+	office_element_ptr			animation_;
+	office_element_ptr			presentation_notes_;
 
-	draw_page_attr draw_page_attr_;
+	draw_page_attr				attlist_;
 };
 
 CP_REGISTER_OFFICE_ELEMENT2(draw_page);
@@ -139,5 +139,28 @@ private:
 };
 CP_REGISTER_OFFICE_ELEMENT2(presentation_date_time_decl);
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//presentation:date-time-decl
+class presentation_notes : public office_element_impl<presentation_notes>
+{
+public:
+    static const wchar_t * ns;
+    static const wchar_t * name;
+    static const xml::NodeType xml_type = xml::typeElement;
+    static const ElementType type = typePresentationNotes;
+    CPDOCCORE_DEFINE_VISITABLE();
+
+	virtual void pptx_convert(oox::pptx_conversion_context & Context);
+
+private:
+	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_;
+};
+CP_REGISTER_OFFICE_ELEMENT2(presentation_notes);
 }
 }

ASCOfficeOdfFile/src/odf/draw_shapes.cpp

@@ -163,10 +163,10 @@ void draw_line::add_attributes( const xml::attributes_wc_ptr & Attributes )
 }
 void draw_line::reset_svg_attributes()
 {
-	double x1=draw_line_attlist_.svg_x1_.get_value_or(length(0)).get_value_unit(length::pt);
-	double y1=draw_line_attlist_.svg_y1_.get_value_or(length(0)).get_value_unit(length::pt);
-	double x2=draw_line_attlist_.svg_x2_.get_value_or(length(0)).get_value_unit(length::pt);
-	double y2=draw_line_attlist_.svg_y2_.get_value_or(length(0)).get_value_unit(length::pt);
+	double x1 = draw_line_attlist_.svg_x1_.get_value_or(length(0)).get_value_unit(length::pt);
+	double y1 = draw_line_attlist_.svg_y1_.get_value_or(length(0)).get_value_unit(length::pt);
+	double x2 = draw_line_attlist_.svg_x2_.get_value_or(length(0)).get_value_unit(length::pt);
+	double y2 = draw_line_attlist_.svg_y2_.get_value_or(length(0)).get_value_unit(length::pt);
 	
 	if (x1 > x2)
 	{
@@ -431,8 +431,8 @@ void draw_equation::add_attributes( const xml::attributes_wc_ptr & Attributes )
 }
 int draw_enhanced_geometry::parsing(_CP_OPT(std::wstring) val) 
 {
-	int pos=0, res=-1;
-	if (!val)return res;
+	int pos = 0, res = -1;
+	if (!val) return res;
 
 	BOOST_FOREACH(wchar_t c, val.get())
     {
@@ -453,6 +453,7 @@ void draw_enhanced_geometry_attlist::add_attributes( const xml::attributes_wc_pt
     CP_APPLY_ATTR(L"draw:modifiers"			, draw_modifiers_);
 	CP_APPLY_ATTR(L"draw:text-path"			, draw_text_path_);
 	CP_APPLY_ATTR(L"draw:enhanced-path"		, draw_enhanced_path_);
+	CP_APPLY_ATTR(L"drawooo:enhanced-path"	, drawooo_enhanced_path_);
 	CP_APPLY_ATTR(L"drawooo:sub-view-size"	, drawooo_sub_view_size_);
 }
 // draw:enhanced_geometry
@@ -485,6 +486,9 @@ void draw_enhanced_geometry::add_child_element( xml::sax * Reader, const std::ws
 }
 void draw_enhanced_geometry::find_draw_type_oox()
 {
+	word_art_ = false;
+	bOoxType_ = false;
+	
 	if (draw_enhanced_geometry_attlist_.draw_text_path_ &&
 			*draw_enhanced_geometry_attlist_.draw_text_path_ == true)
 	{
@@ -501,7 +505,7 @@ void draw_enhanced_geometry::find_draw_type_oox()
 		{
 			int count = sizeof(_OO_OOX_wordart) / sizeof(_shape_converter);
 
-			for (long i=0; i< count; i++)
+			for (int i = 0; i < count; i++)
 			{
 				if (_OO_OOX_wordart[i].odf_reader == odf_type)
 				{
@@ -518,7 +522,7 @@ void draw_enhanced_geometry::find_draw_type_oox()
 
 			if (pos < 0)
 			{
-				for (long i=0; i< count; i++)
+				for (long i = 0; i< count; i++)
 				{
 					if (_OO_OOX_custom_shapes[i].odf_reader == odf_type)
 					{
@@ -530,10 +534,11 @@ void draw_enhanced_geometry::find_draw_type_oox()
 			else
 			{
 				std::wstring oox_type = odf_type.substr(pos + 6);
-				for (long i=0; i< count; i++)
+				for (long i = 0; i< count; i++)
 				{
 					if (_OO_OOX_custom_shapes[i].oox == oox_type)
 					{
+						bOoxType_ = true;
 						draw_type_oox_index_ = i;
 						break;
 					}	
@@ -545,38 +550,36 @@ void draw_enhanced_geometry::find_draw_type_oox()
 			}
 		}
 	}
-	std::wstringstream str;
+  //  for (size_t i = 0; i < draw_handle_.size(); i++)
+  //  {
+		//draw_handle * handle = dynamic_cast<draw_handle *>(draw_handle_[i].get());        
+		//if (!handle) continue;
 
-    BOOST_FOREACH(const office_element_ptr & parElement, draw_handle_)
-    {
-		draw_handle * handle = dynamic_cast<draw_handle *>(parElement.get());
-        
-		int min = -1;
-		int max = -1;
-		
-		try
-		{
-			min = parsing(handle->draw_handle_attlist_.draw_handle_range_y_minimum_);//пока статик .. и выдается только цыфровое значение
-			if (min<0)min = parsing(handle->draw_handle_attlist_.draw_handle_range_x_minimum_);
-			if (min<0)min = parsing(handle->draw_handle_attlist_.draw_handle_radius_range_minimum_);
-		}
-		catch(...)
-		{
-		}
-		if (min < 0 ) min=0;
+		//int min = -1, max = -1;
+		//
+		//try
+		//{
+		//	min = parsing(handle->draw_handle_attlist_.draw_handle_range_y_minimum_);//пока статик .. и выдается только цыфровое значение
+		//	if (min < 0) min = parsing(handle->draw_handle_attlist_.draw_handle_range_x_minimum_);
+		//	if (min < 0) min = parsing(handle->draw_handle_attlist_.draw_handle_radius_range_minimum_);
+		//}
+		//catch(...)
+		//{
+		//}
+		//if (min < 0 ) min=0;
 
-		try
-		{	
-			max = parsing(handle->draw_handle_attlist_.draw_handle_range_y_maximum_);
-			if (max < 0) max = parsing(handle->draw_handle_attlist_.draw_handle_range_x_maximum_);
-			if (max < 0) max = parsing(handle->draw_handle_attlist_.draw_handle_radius_range_maximum_);
-		}
-		catch(...)
-		{
-		}		
-		draw_handle_geometry elm={min, max};
-		draw_handle_geometry_.push_back(elm);
-    }
+		//try
+		//{	
+		//	max = parsing(handle->draw_handle_attlist_.draw_handle_range_y_maximum_);
+		//	if (max < 0) max = parsing(handle->draw_handle_attlist_.draw_handle_range_x_maximum_);
+		//	if (max < 0) max = parsing(handle->draw_handle_attlist_.draw_handle_radius_range_maximum_);
+		//}
+		//catch(...)
+		//{
+		//}		
+		//draw_handle_geometry elm = {min, max};
+		//draw_handle_geometry_.push_back(elm);
+  //  }
 }
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 /// draw-caption-attlist

ASCOfficeOdfFile/src/odf/draw_shapes.h

@@ -437,6 +437,7 @@ public:
 	_CP_OPT(std::wstring)	draw_modifiers_;
 	_CP_OPT(bool)			draw_text_path_;
 	_CP_OPT(std::wstring)	draw_enhanced_path_;
+	_CP_OPT(std::wstring)	drawooo_enhanced_path_;
 	_CP_OPT(std::wstring)	drawooo_sub_view_size_;
 };
 /////////////////////////////////////////////////////////////////////////
@@ -464,7 +465,9 @@ public:
 	_CP_OPT(int)			sub_type_;
 	_CP_OPT(int)			draw_type_oox_index_;
 	_CP_OPT(std::wstring)	svg_viewbox_;
+	
 	bool					word_art_;
+	bool					bOoxType_;
 
 	typedef std::pair<std::wstring,std::wstring> pair_string_value;
 

ASCOfficeOdfFile/src/odf/draw_shapes_docx.cpp

@@ -246,20 +246,27 @@ void draw_enhanced_geometry::docx_convert(oox::docx_conversion_context & Context
 
 	if (draw_type_oox_index_)
 	{
-		shape->additional_.push_back(_property(L"odf-custom-draw-index", draw_type_oox_index_.get()));	
+		shape->additional_.push_back(_property(L"oox-geom-index", draw_type_oox_index_.get()));	
+		shape->additional_.push_back(_property(L"oox-geom", bOoxType_));	
 
 		if (shape->word_art_ == true)
 			shape->additional_.push_back(_property(L"wordArt", true));
 
 		set_shape = true;
 	}
+
 	if (sub_type_)
 	{
 		shape->sub_type_ = sub_type_.get();
 		set_shape = true;
 	}
+	std::wstring odf_path; //общая часть - объединить ...
+	if (draw_enhanced_geometry_attlist_.drawooo_enhanced_path_)
+		odf_path = draw_enhanced_geometry_attlist_.drawooo_enhanced_path_.get();
+	else if (draw_enhanced_geometry_attlist_.draw_enhanced_path_)
+		odf_path = draw_enhanced_geometry_attlist_.draw_enhanced_path_.get();
 	
-	if (draw_enhanced_geometry_attlist_.draw_enhanced_path_)
+	if (!odf_path.empty())
 	{
 		std::vector<::svg_path::_polyline> o_Polyline;
 	
@@ -267,14 +274,14 @@ void draw_enhanced_geometry::docx_convert(oox::docx_conversion_context & Context
 		
 		try
 		{
-			res = ::svg_path::parseSvgD(o_Polyline, draw_enhanced_geometry_attlist_.draw_enhanced_path_.get(), true);
+			res = ::svg_path::parseSvgD(o_Polyline, odf_path, true);
 		}
 		catch(...)
 		{
 			res = false; 
 		}
 		
-		if (o_Polyline.size() > 1 && res )
+		if (!o_Polyline.empty() && res )
 		{
 			//сформируем xml-oox сдесь ... а то придется плодить массивы в drawing .. хоть и не красиво..
 			std::wstringstream output_;   
@@ -311,14 +318,10 @@ void draw_enhanced_geometry::docx_convert(oox::docx_conversion_context & Context
 
 	if (draw_enhanced_geometry_attlist_.draw_modifiers_)
 	{
-		shape->additional_.push_back(_property(L"draw-modifiers",draw_enhanced_geometry_attlist_.draw_modifiers_.get()));	
-		if (draw_handle_geometry_.size()>0)
+		if (bOoxType_)
+			shape->additional_.push_back(_property(L"oox-draw-modifiers", draw_enhanced_geometry_attlist_.draw_modifiers_.get()));	
+		else
 		{
-			if (draw_handle_geometry_[0].min < draw_handle_geometry_[0].max)
-			{
-				shape->additional_.push_back(_property(L"draw-modifiers-min",draw_handle_geometry_[0].min));	
-				shape->additional_.push_back(_property(L"draw-modifiers-max",draw_handle_geometry_[0].max));	
-			}
 		}
 	}
 
@@ -326,7 +329,6 @@ void draw_enhanced_geometry::docx_convert(oox::docx_conversion_context & Context
 	{
 		shape->bad_shape_ = true;
 	}
-
 }
 }
 }

ASCOfficeOdfFile/src/odf/draw_shapes_pptx.cpp

@@ -312,8 +312,9 @@ void draw_enhanced_geometry::pptx_convert(oox::pptx_conversion_context & Context
 
 	if (draw_type_oox_index_)
 	{
-		Context.get_slide_context().set_property(_property(L"odf-custom-draw-index", draw_type_oox_index_.get()));	
-
+		Context.get_slide_context().set_property(_property(L"oox-geom-index", draw_type_oox_index_.get()));	
+		Context.get_slide_context().set_property(_property(L"oox-geom", bOoxType_));	
+		
 		if (word_art_ == true)
 			Context.get_slide_context().set_property(_property(L"wordArt", true));	
 
@@ -325,7 +326,13 @@ void draw_enhanced_geometry::pptx_convert(oox::pptx_conversion_context & Context
 		set_shape = true;
 	}
 
-	if (draw_enhanced_geometry_attlist_.draw_enhanced_path_)
+	std::wstring odf_path;
+	if (draw_enhanced_geometry_attlist_.drawooo_enhanced_path_)
+		odf_path = draw_enhanced_geometry_attlist_.drawooo_enhanced_path_.get();
+	else if (draw_enhanced_geometry_attlist_.draw_enhanced_path_)
+		odf_path = draw_enhanced_geometry_attlist_.draw_enhanced_path_.get();
+	
+	if (!odf_path.empty())
 	{
 		std::vector<::svg_path::_polyline> o_Polyline;
 	
@@ -333,7 +340,7 @@ void draw_enhanced_geometry::pptx_convert(oox::pptx_conversion_context & Context
 		
 		try
 		{
-			res = ::svg_path::parseSvgD(o_Polyline, draw_enhanced_geometry_attlist_.draw_enhanced_path_.get(), true);
+			res = ::svg_path::parseSvgD(o_Polyline, odf_path, true);
 		}
 		catch(...)
 		{
@@ -375,16 +382,20 @@ void draw_enhanced_geometry::pptx_convert(oox::pptx_conversion_context & Context
 	}
 	if (draw_enhanced_geometry_attlist_.draw_modifiers_)
 	{
-		Context.get_slide_context().set_property(_property(L"draw-modifiers",draw_enhanced_geometry_attlist_.draw_modifiers_.get()));	
-
-		if (draw_handle_geometry_.size()>0)
+		if (bOoxType_)
+			Context.get_slide_context().set_property(_property(L"oox-draw-modifiers", draw_enhanced_geometry_attlist_.draw_modifiers_.get()));	
+		else
 		{
-			if (draw_handle_geometry_[0].min < draw_handle_geometry_[0].max)
-			{
-				Context.get_slide_context().set_property(_property(L"draw-modifiers-min",draw_handle_geometry_[0].min));	
-				Context.get_slide_context().set_property(_property(L"draw-modifiers-max",draw_handle_geometry_[0].max));	
-			}
 		}
+
+		//if (draw_handle_geometry_.size()>0)
+		//{
+		//	if (draw_handle_geometry_[0].min < draw_handle_geometry_[0].max)
+		//	{
+		//		Context.get_slide_context().set_property(_property(L"draw-modifiers-min",draw_handle_geometry_[0].min));	
+		//		Context.get_slide_context().set_property(_property(L"draw-modifiers-max",draw_handle_geometry_[0].max));	
+		//	}
+		//}
 	}
 	if (!set_shape)
 	{

ASCOfficeOdfFile/src/odf/draw_shapes_xlsx.cpp

@@ -258,7 +258,8 @@ void draw_enhanced_geometry::xlsx_convert(oox::xlsx_conversion_context & Context
 
 	if (draw_type_oox_index_)
 	{
-		Context.get_drawing_context().set_property(_property(L"odf-custom-draw-index", draw_type_oox_index_.get()));	
+		Context.get_drawing_context().set_property(_property(L"oox-geom-index", draw_type_oox_index_.get()));	
+		Context.get_drawing_context().set_property(_property(L"oox-geom", bOoxType_));	
 
 		if (word_art_ == true)
 			Context.get_drawing_context().set_property(_property(L"wordArt", true));	
@@ -269,7 +270,13 @@ void draw_enhanced_geometry::xlsx_convert(oox::xlsx_conversion_context & Context
 		Context.get_drawing_context().start_shape(sub_type_.get());
 	}
 
-	if (draw_enhanced_geometry_attlist_.draw_enhanced_path_)
+	std::wstring odf_path;
+	if (draw_enhanced_geometry_attlist_.drawooo_enhanced_path_)
+		odf_path = draw_enhanced_geometry_attlist_.drawooo_enhanced_path_.get();
+	else if (draw_enhanced_geometry_attlist_.draw_enhanced_path_)
+		odf_path = draw_enhanced_geometry_attlist_.draw_enhanced_path_.get();
+	
+	if (!odf_path.empty())
 	{
 		std::vector<::svg_path::_polyline> o_Polyline;
 	
@@ -277,7 +284,7 @@ void draw_enhanced_geometry::xlsx_convert(oox::xlsx_conversion_context & Context
 		
 		try
 		{
-			res = ::svg_path::parseSvgD(o_Polyline, draw_enhanced_geometry_attlist_.draw_enhanced_path_.get(), true);
+			res = ::svg_path::parseSvgD(o_Polyline, odf_path, true);
 		}
 		catch(...)
 		{
@@ -321,15 +328,10 @@ void draw_enhanced_geometry::xlsx_convert(oox::xlsx_conversion_context & Context
 	}
 	if (draw_enhanced_geometry_attlist_.draw_modifiers_)
 	{
-		Context.get_drawing_context().set_property(_property(L"draw-modifiers",draw_enhanced_geometry_attlist_.draw_modifiers_.get()));	
-
-		if (draw_handle_geometry_.size()>0)
+		if (bOoxType_)
+			Context.get_drawing_context().set_property(_property(L"oox-draw-modifiers", draw_enhanced_geometry_attlist_.draw_modifiers_.get()));	
+		else
 		{
-			if (draw_handle_geometry_[0].min < draw_handle_geometry_[0].max)
-			{
-				Context.get_drawing_context().set_property(_property(L"draw-modifiers-min",draw_handle_geometry_[0].min));	
-				Context.get_drawing_context().set_property(_property(L"draw-modifiers-max",draw_handle_geometry_[0].max));	
-			}
 		}
 	}
 }

ASCOfficeOdfFile/src/odf/math_layout_elements.cpp

@@ -292,7 +292,7 @@ void math_mstyle::oox_convert(oox::math_context & Context)
 		{ 
 			CP_XML_NODE(L"m:ctrlPr")
 			{
-				Context.text_properties_->content().oox_convert(CP_XML_STREAM(), Context.graphRPR_, Context.fonts_container_);
+				Context.text_properties_->content().oox_serialize(CP_XML_STREAM(), Context.graphRPR_, Context.fonts_container_);
 			}
 		}
 	}
@@ -317,7 +317,7 @@ void math_mstyle::oox_convert(oox::math_context & Context)
 		{ 
 			CP_XML_NODE(L"m:ctrlPr")
 			{
-				Context.text_properties_->content().oox_convert(CP_XML_STREAM(), Context.graphRPR_, Context.fonts_container_);
+				Context.text_properties_->content().oox_serialize(CP_XML_STREAM(), Context.graphRPR_, Context.fonts_container_);
 			}
 		}
 	}

ASCOfficeOdfFile/src/odf/math_token_elements.cpp

@@ -114,7 +114,7 @@ void math_mi::oox_convert(oox::math_context & Context)
 				}
 			}
 
-			Context.text_properties_->content().oox_convert(CP_XML_STREAM(), Context.graphRPR_, Context.fonts_container_);
+			Context.text_properties_->content().oox_serialize(CP_XML_STREAM(), Context.graphRPR_, Context.fonts_container_);
 
 			CP_XML_NODE(L"m:t")
 			{
@@ -162,7 +162,7 @@ void math_mo::oox_convert(oox::math_context & Context)
         {
 			// + доп стили текста ... todoooo
 
-			Context.text_properties_->content().oox_convert(CP_XML_STREAM(), Context.graphRPR_, Context.fonts_container_);
+			Context.text_properties_->content().oox_serialize(CP_XML_STREAM(), Context.graphRPR_, Context.fonts_container_);
 			
 			CP_XML_NODE(L"m:t")
 			{
@@ -203,7 +203,7 @@ void math_mn::oox_convert(oox::math_context & Context)
 		{
 			// + доп стили текста ... todoooo
 
-			Context.text_properties_->content().oox_convert(CP_XML_STREAM(), Context.graphRPR_, Context.fonts_container_);
+			Context.text_properties_->content().oox_serialize(CP_XML_STREAM(), Context.graphRPR_, Context.fonts_container_);
 	
 			CP_XML_NODE(L"m:t")
 			{

ASCOfficeOdfFile/src/odf/odf_document_impl.cpp

@@ -462,8 +462,8 @@ void odf_document::Impl::parse_styles()
                     continue;
                 }
 
-                const std::wstring styleName = masterPage->style_master_page_attlist_.style_name_.get_value_or(L"");
-                const std::wstring pageLayoutName = masterPage->style_master_page_attlist_.style_page_layout_name_.get_value_or(L"");
+                const std::wstring styleName = masterPage->attlist_.style_name_.get_value_or(L"");
+                const std::wstring pageLayoutName = masterPage->attlist_.style_page_layout_name_.get_value_or(L"");
 
                 context_->pageLayoutContainer().add_master_page(styleName, pageLayoutName, masterPage);
             }        

ASCOfficeOdfFile/src/odf/odfcontext.cpp

@@ -40,23 +40,24 @@ namespace cpdoccore {
 namespace odf_reader {
 
 style_instance::style_instance(
-    styles_container   *Container,
-    const std::wstring  &Name,
-    style_family::type	Type,
-    style_content      *Content,
-    bool IsAutomatic,
-    bool IsDefault,
-    const std::wstring & ParentStyleName,
-    const std::wstring & NextStyleName,
-    const std::wstring & DataStyleName
-    ) : container_(Container),
-    name_(Name),
-    style_type_(Type),
-    content_(Content),
-    is_automatic_(IsAutomatic),
-    is_default_(IsDefault),
-    next_name_(NextStyleName),
-    next_(Container->style_by_name(NextStyleName, style_type_,false)),
+		styles_container   *Container,
+		const std::wstring  &Name,
+		style_family::type	Type,
+		style_content      *Content,
+		bool IsAutomatic,
+		bool IsDefault,
+		const std::wstring & ParentStyleName,
+		const std::wstring & NextStyleName,
+		const std::wstring & DataStyleName
+		) :
+	container_		(Container),
+    name_			(Name),
+    style_type_		(Type),
+    content_		(Content),
+    is_automatic_	(IsAutomatic),
+    is_default_		(IsDefault),
+    next_name_		(NextStyleName),
+    next_			(Container->style_by_name(NextStyleName, style_type_, false)),
     data_style_name_(DataStyleName)
 {
 	parent_name_ = ParentStyleName;
@@ -64,8 +65,7 @@ style_instance::style_instance(
 	{
 		parent_name_ = L"Standard";
 	}
-    parent_ = Container->style_by_name(parent_name_, style_type_,false);
-
+    parent_ = Container->style_by_name(parent_name_, style_type_, false);
 }
    
 style_instance * styles_container::hyperlink_style()
@@ -239,7 +239,7 @@ std::pair<int,std::wstring> presentation_layouts_instance::add_or_find(const std
 		item.layout_name = layout_name;
 		item.master_name = master_name;
 		item.Id = content.size() +1;
-		item.rId = std::wstring(L"lrId") + boost::lexical_cast<std::wstring>(item.Id);
+		item.rId = std::wstring(L"lrId") + std::to_wstring(item.Id);
 	
 		content.push_back(item);
 		index = content.size()-1;
@@ -265,7 +265,7 @@ std::pair<int,std::wstring> presentation_masters_instance::add_or_find(const std
 		presentation_masters_instance::_master item;
 		item.master_name = master_name;
 		item.Id = content.size() +1;
-		item.rId = std::wstring(L"smId") + boost::lexical_cast<std::wstring>(item.Id);
+		item.rId = std::wstring(L"smId") + std::to_wstring(item.Id);
 	
 		content.push_back(item);
 		index = content.size()-1;
@@ -325,6 +325,13 @@ style_page_layout_properties * page_layout_instance::properties() const
     return dynamic_cast<style_page_layout_properties *>(style_page_layout_->style_page_layout_properties_.get());
 }
 
+void page_layout_instance::xlsx_serialize(std::wostream & strm, oox::xlsx_conversion_context & Context)
+{
+	style_page_layout_properties * props = properties();
+	if (props)
+		props->xlsx_serialize(strm, Context);   
+}
+
 void page_layout_instance::docx_convert_serialize(std::wostream & strm, oox::docx_conversion_context & Context)
 {
     const style_header_style * headerStyle = dynamic_cast<style_header_style *>(style_page_layout_->style_header_style_.get());
@@ -348,14 +355,16 @@ void page_layout_instance::docx_convert_serialize(std::wostream & strm, oox::doc
         _CP_OPT(length) bottom = attr.fo_min_height_ ? attr.fo_min_height_ : attr.svg_height_;
         Context.get_header_footer_context().set_footer(bottom);
     }
-
-    properties()->docx_convert_serialize(strm, Context);   
+	
+	style_page_layout_properties * props = properties();
+    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

@@ -193,8 +193,9 @@ public:
     const std::wstring & name() const;
     style_page_layout_properties * properties() const; 
     
-	void docx_convert_serialize(std::wostream & strm, oox::docx_conversion_context & Context);
- 	void pptx_convert(oox::pptx_conversion_context & Context);
+	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_serialize			(std::wostream & strm, oox::pptx_conversion_context & Context);
    
     const style_page_layout * style_page_layout_;
 

ASCOfficeOdfFile/src/odf/office_body.cpp

@@ -98,7 +98,7 @@ void office_body::docx_convert(oox::docx_conversion_context & Context)
     std::vector<style_master_page*> & masterPages = Context.root()->odf_context().pageLayoutContainer().master_pages();
     if (!masterPages.empty())
     {
-        Context.set_master_page_name(masterPages[0]->style_master_page_attlist_.style_name_.get_value_or(L"Standard"));
+        Context.set_master_page_name(masterPages[0]->attlist_.style_name_.get_value_or(L"Standard"));
     }
 
 	const page_layout_instance * layout = Context.root()->odf_context().pageLayoutContainer().page_layout_first();
@@ -116,15 +116,15 @@ void office_body::docx_convert(oox::docx_conversion_context & Context)
 //background (for all pages) 
     if (page_layout_instance * firtsPageLayout = Context.root()->odf_context().pageLayoutContainer().page_layout_by_name(Context.get_page_properties()))
 	{
-        if (style_page_layout_properties * prop = firtsPageLayout->properties())
+        if (style_page_layout_properties * layout_properties = firtsPageLayout->properties())
 		{
 			oox::_oox_fill fill;
 			
-			Compute_GraphicFill(prop->style_page_layout_properties_attlist_.common_draw_fill_attlist_, 
-								prop->style_page_layout_properties_elements_.style_background_image_, 
+			Compute_GraphicFill(layout_properties->attlist_.common_draw_fill_attlist_, 
+								layout_properties->elements_.style_background_image_, 
 								Context.root()->odf_context().drawStyles(), fill);
 
-			if (prop->style_page_layout_properties_attlist_.common_background_color_attlist_.fo_background_color_ || fill.type != 0)
+			if (layout_properties->attlist_.common_background_color_attlist_.fo_background_color_ || fill.type != 0)
 			{
 				if ((fill.bitmap) && (fill.bitmap->rId.empty()))
 				{
@@ -132,7 +132,7 @@ void office_body::docx_convert(oox::docx_conversion_context & Context)
 					fill.bitmap->rId = Context.add_mediaitem(href, oox::typeImage, fill.bitmap->isInternal, href);
 				}		
 				int id = Context.get_drawing_context().get_current_shape_id();
-				if (prop->docx_background_serialize(Context.output_stream(), Context, fill, id))
+				if (layout_properties->docx_background_serialize(Context.output_stream(), Context, fill, id))
 				{
 					Context.set_settings_property(odf_reader::_property(L"displayBackgroundShape", true));
 				}

ASCOfficeOdfFile/src/odf/office_elements_type.h

@@ -164,6 +164,7 @@ enum ElementType
     typeStyleFooterStyle,
 	typeStyleHeaderFooterProperties,
 
+	typeStylePresentationSound,
 	typeStylePresentationPageLayout,
 	typeStylePresentationPlaceholder,
 	typeStyleDrawingPageProperties,
@@ -290,6 +291,8 @@ enum ElementType
     typeDrawObject,
     typeDrawObjectOle,
  	typeDrawChart,
+ 	typeDrawParam,
+ 	typeDrawPlugin,
 
 	typeDrawShape,
 
@@ -316,10 +319,14 @@ enum ElementType
 	typeDrawPage,    
 	typePresentationFooterDecl,
 	typePresentationDateTimeDecl,
+	typePresentationNotes,
 
 	typeAnimPar,
 	typeAnimSeq,
 	typeAnimTransitionFilter,
+	typeAnimAudio,
+	typeAnimCommand,
+	typeAnimIterate,
 
 	typeStyleGraphicPropertis,
 	typeStyleDrawGradient,

ASCOfficeOdfFile/src/odf/office_event_listeners.cpp

@@ -47,8 +47,8 @@ namespace odf_reader {
 
 // office:event_listeners
 //////////////////////////////////////////////////////////////////////////////////////////////////
-const wchar_t * office_event_listeners::ns = L"office";
-const wchar_t * office_event_listeners::name = L"event-listeners";
+const wchar_t * office_event_listeners::ns		= L"office";
+const wchar_t * office_event_listeners::name	= L"event-listeners";
 
 void office_event_listeners::add_attributes( const xml::attributes_wc_ptr & Attributes )
 {
@@ -56,18 +56,18 @@ void office_event_listeners::add_attributes( const xml::attributes_wc_ptr & Attr
 
 void office_event_listeners::add_child_element( xml::sax * Reader, 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_);
-    else
+	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_);
+	else
         CP_NOT_APPLICABLE_ELM();
 }
 void office_event_listeners::pptx_convert(oox::pptx_conversion_context & Context)
 {
-    BOOST_FOREACH(const office_element_ptr & elm, presentation_event_listeners_)
+    for (size_t i = 0; i < presentation_event_listeners_.size(); i++)
     {
-		elm->pptx_convert(Context);
+		presentation_event_listeners_[i]->pptx_convert(Context);
 	}
 }
 // presentation:event-listener-attlist
@@ -77,7 +77,7 @@ void presentation_event_listener_attlist::add_attributes( const xml::attributes_
 {
 	common_xlink_attlist_.add_attributes(Attributes);
 
-	CP_APPLY_ATTR(L"script:event_name", script_event_name_);
+	CP_APPLY_ATTR(L"script:event-name", script_event_name_);
 	CP_APPLY_ATTR(L"presentation:action", presentation_action_);
 	
 	//...
@@ -89,7 +89,7 @@ const wchar_t * presentation_event_listener::name = L"event-listener";
 
 void presentation_event_listener::add_attributes( const xml::attributes_wc_ptr & Attributes )
 {
-	presentation_event_listener_attlist_.add_attributes(Attributes);
+	attlist_.add_attributes(Attributes);
 }
 
 void presentation_event_listener::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
@@ -101,12 +101,16 @@ void presentation_event_listener::add_child_element( xml::sax * Reader, const st
 }
 void presentation_event_listener::pptx_convert(oox::pptx_conversion_context & Context)
 {
-	common_xlink_attlist & xlink = presentation_event_listener_attlist_.common_xlink_attlist_;
+	Context.get_slide_context().start_action(attlist_.presentation_action_.get_value_or(L""));
+	
+	if (attlist_.common_xlink_attlist_.href_)
+		Context.get_slide_context().set_link(*attlist_.common_xlink_attlist_.href_);
 
-	if (xlink.href_)
+	if (presentation_sound_)
 	{
-		Context.get_slide_context().add_hyperlink(*xlink.href_,true);
+		presentation_sound_->pptx_convert(Context);
 	}
+	Context.get_slide_context().end_action();
 }
 
 // script:event-listener

ASCOfficeOdfFile/src/odf/office_event_listeners.h

@@ -43,7 +43,6 @@
 namespace cpdoccore { 
 namespace odf_reader {
 
-//  office:event-listeners
 class office_event_listeners : public office_element_impl<office_event_listeners>
 {
 public:
@@ -62,20 +61,17 @@ private:
 private:
     office_element_ptr_array presentation_event_listeners_;
     office_element_ptr_array script_event_listeners_;
-
-    
+  
 };
 
 CP_REGISTER_OFFICE_ELEMENT2(office_event_listeners);
 
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// presentation-event-listener-attlist
+//-------------------------------------------------------------------------------------
 class presentation_event_listener_attlist
 {
 public:
     void add_attributes( const xml::attributes_wc_ptr & Attributes );
 
-public:
 	odf_types::common_xlink_attlist common_xlink_attlist_;
 
 	_CP_OPT(std::wstring)	script_event_name_;
@@ -87,7 +83,6 @@ public:
 	//presentation:effect
 };
 
-//  presentation:event-listeners_
 class presentation_event_listener : public office_element_impl<presentation_event_listener>
 {
 public:
@@ -104,9 +99,9 @@ private:
     virtual void add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name);
 
 private:
-    //office_element_ptr_array content_;
-	office_element_ptr presentation_sound_;
-	presentation_event_listener_attlist presentation_event_listener_attlist_;
+    //office_element_ptr_array				content_;
+	office_element_ptr						presentation_sound_;
+	presentation_event_listener_attlist		attlist_;
 
     
 };

ASCOfficeOdfFile/src/odf/office_presentation.cpp

@@ -34,8 +34,6 @@
 #include "office_presentation.h"
 #include "draw_page.h"
 
-#include <boost/foreach.hpp>
-
 #include <cpdoccore/xml/xmlchar.h>
 
 #include <cpdoccore/xml/attributes.h>
@@ -76,9 +74,10 @@ void office_presentation::docx_convert(oox::docx_conversion_context & Context)
 {
     Context.start_office_text();
 	_CP_LOG << L"[info][docx] process pages (" << pages_.size() << L" elmements)" << std::endl;
-	BOOST_FOREACH(const office_element_ptr & elm, pages_)
-    {
-        elm->docx_convert(Context);
+	
+	for (size_t i = 0; i < pages_.size(); i++)
+	{
+        pages_[i]->docx_convert(Context);
     }
     Context.end_office_text();
 }
@@ -87,9 +86,10 @@ void office_presentation::xlsx_convert(oox::xlsx_conversion_context & Context)
 {
     Context.start_office_spreadsheet(this);
     _CP_LOG << L"[info][xlsx] process pages (" << pages_.size() << L" elmements)" << std::endl;
-    BOOST_FOREACH(const office_element_ptr & elm, pages_)
-    {
-        elm->xlsx_convert(Context);
+	
+	for (size_t i = 0; i < pages_.size(); i++)
+	{
+        pages_[i]->xlsx_convert(Context);
     }
     Context.end_office_spreadsheet();
 }
@@ -100,29 +100,29 @@ void office_presentation::pptx_convert(oox::pptx_conversion_context & Context)
 
     _CP_LOG << L"[info][pptx] process pages(" << pages_.size() << L" elmements)" << std::endl;
 	
-    BOOST_FOREACH(const office_element_ptr & elm, footer_decls_)
+	for (size_t i = 0; i < footer_decls_.size(); i++)
     {
-		presentation_footer_decl * style = dynamic_cast<presentation_footer_decl *>(elm.get());
+		presentation_footer_decl * style = dynamic_cast<presentation_footer_decl *>(footer_decls_[i].get());
 
         if (!style)
             continue;
 
 		std::wstring style_name_ = L"footer:" + style->presentation_name_.get_value_or(L"");
-		Context.root()->odf_context().drawStyles().add(style_name_, elm);
+		Context.root()->odf_context().drawStyles().add(style_name_, footer_decls_[i]);
     }
-    BOOST_FOREACH(const office_element_ptr & elm, date_time_decls_)
-    {
-		presentation_date_time_decl * style = dynamic_cast<presentation_date_time_decl *>(elm.get());
+	for (size_t i = 0; i < date_time_decls_.size(); i++)
+	{
+		presentation_date_time_decl * style = dynamic_cast<presentation_date_time_decl *>(date_time_decls_[i].get());
 
         if (!style)
             continue;
 
 		std::wstring style_name_ = L"datetime:" + style->presentation_name_.get_value_or(L"");
-		Context.root()->odf_context().drawStyles().add(style_name_, elm);
+		Context.root()->odf_context().drawStyles().add(style_name_, date_time_decls_[i]);
     }
-    BOOST_FOREACH(const office_element_ptr & elm, pages_)
+    for (size_t i = 0; i < pages_.size(); i++)
     {
-        elm->pptx_convert(Context);
+        pages_[i]->pptx_convert(Context);
     }
     Context.end_office_presentation();
 }

ASCOfficeOdfFile/src/odf/paragraph_elements.cpp

@@ -555,7 +555,7 @@ void a::pptx_convert(oox::pptx_conversion_context & Context)
         elm->pptx_convert(Context);
     }
 	
-	std::wstring hId = Context.get_slide_context().add_hyperlink(common_xlink_attlist_.href_.get_value_or(L""),false);
+	std::wstring hId = Context.get_slide_context().add_hyperlink(common_xlink_attlist_.href_.get_value_or(L""));
 	Context.get_text_context().end_hyperlink(hId);
 
 }

ASCOfficeOdfFile/src/odf/style_paragraph_properties_docx.cpp

@@ -73,11 +73,11 @@ std::wstring process_border(const border_style & borderStyle,
         if (szInt <= 0)
             szInt = 1;
 
-        w_sz	= boost::lexical_cast<std::wstring>( szInt );
+        w_sz	= std::to_wstring( szInt );
         w_color = borderStyle.get_color().get_hex_value();
 
         if (borderPadding)
-            w_space = boost::lexical_cast<std::wstring>((int)(borderPadding->get_value_unit(length::pt) + 0.5) );
+            w_space = std::to_wstring((int)(borderPadding->get_value_unit(length::pt) + 0.5) );
 
         switch(borderStyle.get_style())
         {
@@ -118,7 +118,7 @@ std::wstring docx_process_margin(const _CP_OPT(length_or_percent) & margin, doub
         if (margin->get_type() == length_or_percent::Length)
         {
             int val = (int)(0.5 + Mul * margin->get_length().get_value_unit(length::pt));
-            return boost::lexical_cast<std::wstring>( val );
+            return std::to_wstring( val );
         }
         else
         {
@@ -298,7 +298,7 @@ void paragraph_format_properties::docx_convert(oox::docx_conversion_context & Co
 			{
 				if (fo_line_height_->get_type() == line_width::Percent)
 				{
-					w_line = boost::lexical_cast<std::wstring>( (int)( 0.5 + fo_line_height_->get_percent().get_value() * 240.0 / 100.0 ) );
+					w_line = std::to_wstring( (int)( 0.5 + fo_line_height_->get_percent().get_value() * 240.0 / 100.0 ) );
 					w_lineRule = L"auto";
 				}
 				else if(fo_line_height_->get_type() == line_width::Normal) 
@@ -308,19 +308,19 @@ void paragraph_format_properties::docx_convert(oox::docx_conversion_context & Co
 				}
 				else if (fo_line_height_->get_type() == line_width::PositiveLength)
 				{
-					w_line = boost::lexical_cast<std::wstring>((int)(0.5 + 20.0 * fo_line_height_->get_positive_length().get_value_unit(length::pt)));
+					w_line = std::to_wstring((int)(0.5 + 20.0 * fo_line_height_->get_positive_length().get_value_unit(length::pt)));
 					w_lineRule = L"exact";
 				}
 			}
 			else if (style_line_height_at_least_)
 			{
 				w_lineRule = L"atLeast";
-				w_line = boost::lexical_cast<std::wstring>((int)(0.5 + 20.0 * style_line_height_at_least_->get_value_unit(length::pt)));
+				w_line = std::to_wstring((int)(0.5 + 20.0 * style_line_height_at_least_->get_value_unit(length::pt)));
 			} 
 			else if (style_line_spacing_)
 			{
 				w_lineRule = L"auto";
-				w_line = boost::lexical_cast<std::wstring>( (int)(0.5 + 240.0 + 20.0 * style_line_spacing_->get_value_unit(length::pt)) );
+				w_line = std::to_wstring( (int)(0.5 + 240.0 + 20.0 * style_line_spacing_->get_value_unit(length::pt)) );
 			}
 			CP_XML_NODE(L"w:spacing")
 			{

ASCOfficeOdfFile/src/odf/style_paragraph_properties_pptx.cpp

@@ -70,11 +70,11 @@ std::wstring process_border(border_style	& borderStyle,
         
 		if (szInt <= 0) szInt = 1;
 
-        w_sz	= boost::lexical_cast<std::wstring>( szInt );
+        w_sz	= std::to_wstring( szInt );
         w_color = borderStyle.get_color().get_hex_value();
 
         if (borderPadding)
-            w_space = boost::lexical_cast<std::wstring>((int)(borderPadding->get_value_unit(length::pt)) );
+            w_space = std::to_wstring((int)(borderPadding->get_value_unit(length::pt)) );
 
         switch(borderStyle.get_style())
         {
@@ -113,7 +113,7 @@ std::wstring pptx_process_margin(const _CP_OPT(length_or_percent) & margin, leng
         if (margin->get_type() == length_or_percent::Length)
         {
             int val = (int)(0.5 + Mul * margin->get_length().get_value_unit(unit));
-            return boost::lexical_cast<std::wstring>( val );
+            return std::to_wstring( val );
         }
         else
         {
@@ -190,7 +190,7 @@ void paragraph_format_properties::xlsx_convert(std::wostream & strm, bool in_dra
 					if (fo_line_height_->get_type() == line_width::Percent)
 					{
 						double percent = fo_line_height_->get_percent().get_value();
-						w_line = boost::lexical_cast<std::wstring>( (int)( 0.5 + percent *1000. ) );
+						w_line = std::to_wstring( (int)( 0.5 + percent *1000. ) );
 						w_lineRule = L"a:spcPct";
 					}
 					//else if(fo_line_height_->get_type() == line_width::Normal) 
@@ -198,19 +198,19 @@ void paragraph_format_properties::xlsx_convert(std::wostream & strm, bool in_dra
 					//}
 					else if (fo_line_height_->get_type() == line_width::PositiveLength)
 					{
-						w_line = boost::lexical_cast<std::wstring>((int)(0.5 + 100.0 * fo_line_height_->get_positive_length().get_value_unit(length::pt)));
+						w_line = std::to_wstring((int)(0.5 + 100.0 * fo_line_height_->get_positive_length().get_value_unit(length::pt)));
 						w_lineRule = L"a:spcPts";
 					}
 				}
 				else if (style_line_height_at_least_)
 				{
 					w_lineRule = L"a:spcPts";
-					w_line = boost::lexical_cast<std::wstring>((int)(0.5 + 100.0 * style_line_height_at_least_->get_value_unit(length::pt)));
+					w_line = std::to_wstring((int)(0.5 + 100.0 * style_line_height_at_least_->get_value_unit(length::pt)));
 				} 
 				else if (style_line_spacing_)
 				{
 					w_lineRule = L"a:spcPts";
-					w_line = boost::lexical_cast<std::wstring>( (int)(0.5 + 240.0 + 100.0 * style_line_spacing_->get_value_unit(length::pt)) );
+					w_line = std::to_wstring( (int)(0.5 + 240.0 + 100.0 * style_line_spacing_->get_value_unit(length::pt)) );
 			
 				}
 				CP_XML_NODE(L"a:lnSpc")
@@ -225,7 +225,7 @@ void paragraph_format_properties::xlsx_convert(std::wostream & strm, bool in_dra
 			{
 				CP_XML_NODE(L"a:spcBef")
 				{
-					if (fo_margin_bottom_->get_type() == length_or_percent::Length)
+					if (fo_margin_top_->get_type() == length_or_percent::Length)
 					{
                         std::wstring w_before = pptx_process_margin(fo_margin_top_, length::pt, 100.0);
 						CP_XML_NODE(L"a:spcPts")
@@ -235,11 +235,10 @@ void paragraph_format_properties::xlsx_convert(std::wostream & strm, bool in_dra
 					}
 					else
 					{
-						std::wstringstream s;
-						s << fo_margin_top_;
+						double pct = fo_margin_top_->get_percent().get_value();
 						CP_XML_NODE(L"a:spcPct")
 						{
-							CP_XML_ATTR(L"val", s.str());
+							CP_XML_ATTR(L"val", (int)(pct * 1000));
 						}
 					}
 				}
@@ -258,11 +257,11 @@ void paragraph_format_properties::xlsx_convert(std::wostream & strm, bool in_dra
 					}
 					else
 					{
-						std::wstringstream s;
-						s << fo_margin_bottom_;
+						double pct = fo_margin_bottom_->get_percent().get_value();
+
 						CP_XML_NODE(L"a:spcPct")
 						{
-							CP_XML_ATTR(L"val", s.str());
+							CP_XML_ATTR(L"val", (int)(pct * 1000));
 						}
 					}
 				}
@@ -423,7 +422,7 @@ void paragraph_format_properties::pptx_convert(oox::pptx_conversion_context & Co
 				if (fo_line_height_->get_type() == line_width::Percent)
 				{
 					double percent = fo_line_height_->get_percent().get_value();
-					w_line = boost::lexical_cast<std::wstring>( (int)( 0.5 + percent *1000. ) );
+					w_line = std::to_wstring( (int)( 0.5 + percent *1000. ) );
 					w_lineRule = L"a:spcPct";
 				}
 				//else if(fo_line_height_->get_type() == line_width::Normal) 
@@ -431,19 +430,19 @@ void paragraph_format_properties::pptx_convert(oox::pptx_conversion_context & Co
 				//}
 				else if (fo_line_height_->get_type() == line_width::PositiveLength)
 				{
-					w_line = boost::lexical_cast<std::wstring>((int)(0.5 + 100.0 * fo_line_height_->get_positive_length().get_value_unit(length::pt)));
+					w_line = std::to_wstring((int)(0.5 + 100.0 * fo_line_height_->get_positive_length().get_value_unit(length::pt)));
 					w_lineRule = L"a:spcPts";
 				}
 			}
 			else if (style_line_height_at_least_)
 			{
 				w_lineRule = L"a:spcPts";
-				w_line = boost::lexical_cast<std::wstring>((int)(0.5 + 100.0 * style_line_height_at_least_->get_value_unit(length::pt)));
+				w_line = std::to_wstring((int)(0.5 + 100.0 * style_line_height_at_least_->get_value_unit(length::pt)));
 			} 
 			else if (style_line_spacing_)
 			{
 				w_lineRule = L"a:spcPts";
-				w_line = boost::lexical_cast<std::wstring>( (int)(0.5 + 240.0 + 100.0 * style_line_spacing_->get_value_unit(length::pt)) );
+				w_line = std::to_wstring( (int)(0.5 + 240.0 + 100.0 * style_line_spacing_->get_value_unit(length::pt)) );
 		
 			}
 			CP_XML_NODE(L"a:lnSpc")
@@ -468,11 +467,11 @@ void paragraph_format_properties::pptx_convert(oox::pptx_conversion_context & Co
 				}
 				else
 				{
-					std::wstringstream s;
-					s << fo_margin_top_;
+					double pct = fo_margin_top_->get_percent().get_value();
+
 					CP_XML_NODE(L"a:spcPct")
 					{
-						CP_XML_ATTR(L"val", s.str());
+						CP_XML_ATTR(L"val", (int)(pct * 1000));
 					}
 				}
 			}
@@ -491,11 +490,11 @@ void paragraph_format_properties::pptx_convert(oox::pptx_conversion_context & Co
 				}
 				else
 				{
-					std::wstringstream s;
-					s << fo_margin_bottom_;
+					double pct = fo_margin_bottom_->get_percent().get_value();
+
 					CP_XML_NODE(L"a:spcPct")
 					{
-						CP_XML_ATTR(L"val", s.str());
+						CP_XML_ATTR(L"val", (int)(pct * 1000));
 					}
 				}
 			}

ASCOfficeOdfFile/src/odf/style_presentation.cpp

@@ -42,12 +42,8 @@ namespace cpdoccore {
 
 namespace odf_reader {
 
-// 
-
-// style:chart-properties
-//////////////////////////////////////////////////////////////////////////////////////////////////
-const wchar_t * presentation_placeholder::ns = L"presentation";
-const wchar_t * presentation_placeholder::name = L"placeholder";
+const wchar_t * presentation_placeholder::ns	= L"presentation";
+const wchar_t * presentation_placeholder::name	= L"placeholder";
 
 void presentation_placeholder::add_attributes( const xml::attributes_wc_ptr & Attributes )
 {
@@ -88,9 +84,26 @@ void presentation_placeholder::pptx_convert(oox::pptx_conversion_context & Conte
 
 	Context.get_slide_context().end_shape();
 }
+//-------------------------------------------------------------------------------------------------
+const wchar_t * presentation_sound::ns		= L"presentation";
+const wchar_t * presentation_sound::name	= L"sound";
 
-//////////////////////////////////////////////////////////////////////////////////////////////////
-const wchar_t * style_drawing_page_properties::ns = L"style";
+void presentation_sound::add_attributes( const xml::attributes_wc_ptr & Attributes )
+{
+	common_xlink_attlist_.add_attributes(Attributes);
+}
+
+void presentation_sound::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
+{
+    CP_NOT_APPLICABLE_ELM();
+}
+
+void presentation_sound::pptx_convert(oox::pptx_conversion_context & Context)
+{
+	Context.get_slide_context().set_link(common_xlink_attlist_.href_.get_value_or(L""), oox::typeAudio);
+}
+//-------------------------------------------------------------------------------------------------
+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::add_attributes( const xml::attributes_wc_ptr & Attributes )
@@ -99,7 +112,10 @@ void style_drawing_page_properties::add_attributes( const xml::attributes_wc_ptr
 }
 void style_drawing_page_properties::add_child_element( xml::sax * Reader, const std::wstring & Ns, const std::wstring & Name)
 {
-    CP_NOT_APPLICABLE_ELM();
+	if CP_CHECK_NAME(L"presentation", L"sound")
+        CP_CREATE_ELEMENT(drawing_page_properties_.presentation_sound_);
+    else
+        CP_NOT_APPLICABLE_ELM();
 }
 
 void drawing_page_properties::add_attributes( const xml::attributes_wc_ptr & Attributes )
@@ -119,6 +135,7 @@ void drawing_page_properties::add_attributes( const xml::attributes_wc_ptr & Att
 	CP_APPLY_ATTR(L"presentation:display-page-number",	presentation_display_page_number_);
 	CP_APPLY_ATTR(L"presentation:display-date-time",	presentation_display_date_time_);
 	CP_APPLY_ATTR(L"presentation:display-header",		presentation_display_header_);
+	CP_APPLY_ATTR(L"presentation:page-duration",		presentation_page_duration_);
 }
 void drawing_page_properties::apply_from(const drawing_page_properties & Other)
 {
@@ -137,6 +154,8 @@ void drawing_page_properties::apply_from(const drawing_page_properties & Other)
 	_CP_APPLY_PROP2(presentation_display_page_number_);
 	_CP_APPLY_PROP2(presentation_display_date_time_);
 	_CP_APPLY_PROP2(presentation_display_header_);
+	
+	_CP_APPLY_PROP2(presentation_page_duration_);
 
 }
 }

ASCOfficeOdfFile/src/odf/style_presentation.h

@@ -49,7 +49,6 @@ namespace cpdoccore {
 namespace odf_reader {
 
 
-// presentation:placeholder 
 class presentation_placeholder : public office_element_impl<presentation_placeholder>
 {
 public:
@@ -76,13 +75,34 @@ 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();
+
+    odf_types::common_xlink_attlist common_xlink_attlist_;
+private:
+    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);
+    virtual void pptx_convert(oox::pptx_conversion_context & Context);
+};
+
+CP_REGISTER_OFFICE_ELEMENT2(presentation_sound);
+
+//-------------------------------------------------------------------------------------------
 class drawing_page_properties
 {
 public:
     void add_attributes( const xml::attributes_wc_ptr & Attributes );
-    void apply_from(const drawing_page_properties & Other);
+   
+	void apply_from(const drawing_page_properties & Other);
 
 	odf_types::common_draw_fill_attlist		common_draw_fill_attlist_;
 	anim_transition_filter_attlist			anim_transition_filter_attlist_;
@@ -90,27 +110,28 @@ 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.
 	//draw:background-size
 
 };
-//style:drawing-page-properties
+
 class style_drawing_page_properties : public office_element_impl<style_drawing_page_properties>
 {
 public: