fix bug #31878

ASCOfficeOdfFile/src/docx/drawing_object_description.h

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

ASCOfficeOdfFile/src/docx/pptx_conversion_context.cpp

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

ASCOfficeOdfFile/src/docx/pptx_conversion_context.h

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

ASCOfficeOdfFile/src/docx/pptx_output_xml.cpp

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

ASCOfficeOdfFile/src/docx/pptx_output_xml.h

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

ASCOfficeOdfFile/src/docx/pptx_package.cpp

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

ASCOfficeOdfFile/src/docx/pptx_package.h

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

ASCOfficeOdfFile/src/docx/pptx_slide_context.cpp

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

ASCOfficeOdfFile/src/docx/pptx_slide_context.h

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

ASCOfficeOdfFile/src/odf/draw_page.cpp

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

ASCOfficeOdfFile/src/odf/draw_page.h

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

ASCOfficeOdfFile/src/odf/odfcontext.cpp

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

ASCOfficeOdfFile/src/odf/odfcontext.h

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

ASCOfficeOdfFile/src/odf/styles.cpp

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

ASCOfficeOdfFile/src/odf/styles.h

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

ASCOfficeOdfFileW/source/OdfFormat/odf_drawing_context.cpp

@@ -2627,15 +2627,15 @@ void odf_drawing_context::set_gradient_angle(double angle)
 	draw_gradient * gradient = dynamic_cast<draw_gradient *>(impl_->styles_context_->last_state(style_family::Gradient)->get_office_element().get());
 	if (!gradient) return;
 
-	gradient->draw_angle_ = (270-  angle) * 10;//(int)((360 - angle)/180. * 3.14159265358979323846);
+	gradient->draw_angle_ = (270 - angle) * 10;//(int)((360 - angle)/180. * 3.14159265358979323846);
 }
-void odf_drawing_context::set_gradient_rect(double l, double t, double r,double b)
+void odf_drawing_context::set_gradient_rect(double l, double t, double r, double b)
 {
 	draw_gradient * gradient = dynamic_cast<draw_gradient *>(impl_->styles_context_->last_state(style_family::Gradient)->get_office_element().get());
 	if (!gradient) return;
 	
-	gradient->draw_cy_ = percent((b-t)/2. + 50.);
-	gradient->draw_cx_ = percent((r-l)/2. + 50.);
+	gradient->draw_cy_ = percent((b - t)/2. + 50.);
+	gradient->draw_cx_ = percent((r - l)/2. + 50.);
 }
 void odf_drawing_context::set_gradient_center(double cx, double cy)
 {

ASCOfficeOdfFileW/source/Oox2OdfConverter/ConvertDrawing.cpp

@@ -854,10 +854,10 @@ void OoxConverter::convert(PPTX::Logic::GradFill *oox_grad_fill, DWORD nARGB)
 			}	
 			if (oox_grad_fill->path->rect.IsInit())
 			{
-				odf_context()->drawing_context()->set_gradient_rect( XmlUtils::GetInteger(oox_grad_fill->path->rect->l.get_value_or(L"")),
-																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->t.get_value_or(L"")),
-																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->r.get_value_or(L"")),
-																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->b.get_value_or(L"")));			
+				odf_context()->drawing_context()->set_gradient_rect( XmlUtils::GetInteger(oox_grad_fill->path->rect->l.get_value_or(L"")) / 1000.,
+																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->t.get_value_or(L"")) / 1000.,
+																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->r.get_value_or(L"")) / 1000.,
+																	 XmlUtils::GetInteger(oox_grad_fill->path->rect->b.get_value_or(L"")) / 1000.);			
 			}
 		}	
 		odf_context()->drawing_context()->set_gradient_type(grad_style);

ASCOfficeOdfFileW/source/Oox2OdfConverter/PptxConverter.cpp

@@ -423,8 +423,13 @@ void PptxConverter::convert(PPTX::NotesMaster *oox_notes)
 	
 	odp_context->start_note(true);
 	
-	current_slide	= dynamic_cast<OOX::IFileContainer*>(oox_notes);
+	PPTX::Theme*			old_theme	= current_theme;
+	PPTX::Logic::ClrMap*	old_clrMap	= current_clrMap;
+
+	current_theme	= oox_notes->theme_.operator->();
 	current_clrMap	= &oox_notes->clrMap;
+	
+	current_slide	= dynamic_cast<OOX::IFileContainer*>(oox_notes);
 	//PPTX::Logic::TxStyles* current_txStyles = oox_notes->notesStyle.GetPointer();
 	
 	if (presentation->notesSz.IsInit())
@@ -433,35 +438,46 @@ void PptxConverter::convert(PPTX::NotesMaster *oox_notes)
 		_CP_OPT(odf_types::length) height	= odf_types::length(presentation->notesSz->cy / 12700., odf_types::length::pt);
 		
 		odf_context()->page_layout_context()->set_page_size(width, height);
-		//if (presentation->notesSz->type.IsInit())
-		//{
-		//	switch(presentation->notesSz->type->GetBYTECode())
-		//	{
-		//	default:
-		//		break;
-		//	}
-		//	odf_context()->page_layout_context()->set_page_orientation
-		//}
 	}
 	convert_slide(&oox_notes->cSld, NULL, true, true);
 	
 	odp_context->end_note();
+
+	current_clrMap	= old_clrMap;
+	current_theme	= old_theme;
 }
 void PptxConverter::convert(PPTX::NotesSlide *oox_notes)
 {
 	if (!oox_notes) return;
-	
+
+	PPTX::Theme*			old_theme	= current_theme;
+	PPTX::Logic::ClrMap*	old_clrMap	= current_clrMap;
+
+	smart_ptr<PPTX::NotesMaster> notes_master;
+	if (!presentation->notesMasterIdLst.empty())
+	{
+		std::wstring rId = presentation->notesMasterIdLst[0].rid.get();
+		notes_master = ((*presentation)[rId]).smart_dynamic_cast<PPTX::NotesMaster>();
+	}	
 	odp_context->start_note();
 	
-	current_slide = dynamic_cast<OOX::IFileContainer*>(oox_notes);
+	if (notes_master.IsInit())
+	{
+		current_theme	= notes_master->theme_.operator->();
+		current_clrMap	= &notes_master->clrMap;
+	}
+
+	current_slide	= dynamic_cast<OOX::IFileContainer*>(oox_notes);
 
 	if (oox_notes->clrMapOvr.IsInit() && oox_notes->clrMapOvr->overrideClrMapping.IsInit())
 		current_clrMap	= oox_notes->clrMapOvr->overrideClrMapping.GetPointer();
-	//current_txStyles	= oox_notes->Master->txStyles.GetPointer();
 	
 	convert_slide(&oox_notes->cSld, NULL, true, true);
 	
 	odp_context->end_note();
+	
+	current_clrMap	= old_clrMap;
+	current_theme	= old_theme;
 }
 
 void PptxConverter::convert(OOX::WritingElement  *oox_unknown)

ASCOfficeOdfFileW/source/win32/Oox2OdfConverter.vcproj

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

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/ShapeWriter.cpp

@@ -68,9 +68,6 @@ void CStylesWriter::ConvertStyleLevel(NSPresentationEditor::CTextStyleLevel& oLe
 	{
 		std::wstring strProp = std::to_wstring(pPF->leftMargin.get());
 		oWriter.WriteString(L" marL=\"" + strProp + L"\"");
-
-		if (pPF->indent.is_init() == false)
-            pPF->indent = (LONG)0;
 	}
 	if (pPF->indent.is_init())
 	{
@@ -798,11 +795,7 @@ void NSPresentationEditor::CShapeWriter::WriteTextInfo()
 		if (pPF->leftMargin.is_init())
 		{
             std::wstring strProp = std::to_wstring( pPF->leftMargin.get() );
-			m_oWriter.WriteString(L" marL=\"" + strProp + L"\"");
-			
-			if (pPF->indent.is_init() == false)
-				pPF->indent = (LONG)0;
-
+			m_oWriter.WriteString(L" marL=\"" + strProp + L"\"");			
 		}
 		if (pPF->indent.is_init())
 		{

ASCOfficePPTFile/PPTFormatLib/Records/Drawing/ShapeContainer.h

@@ -2198,7 +2198,7 @@ protected:
 						pTextSettings->m_oStyles.ApplyAfter(pThemeWrapper->m_pStyles[nIndexType].get());
 				}
 			}
-			if (eTypeOwn != NSOfficePPT::NoPresent && eTypeOwn != NSOfficePPT::Other && eTypeOwn != eTypePersist && eTypeOwn != eTypeMaster)
+			if (eTypeOwn != NSOfficePPT::NoPresent/* && eTypeOwn != NSOfficePPT::Other*/ && eTypeOwn != eTypePersist && eTypeOwn != eTypeMaster)
 			{
 				int nIndexType = (int)eTypeOwn;
 				

ASCOfficePPTFile/PptFormatTest/PptFormatTest.cpp

@@ -31,22 +31,30 @@
  */
 // PptFormatTest.cpp : Defines the entry point for the console application.
 //
-#include "../../PPTFormatLib/PPTFormatLib.h"
-#include "../../../OfficeUtils/src/OfficeUtils.h"
+#include "../PPTFormatLib/PPTFormatLib.h"
+#include "../../OfficeUtils/src/OfficeUtils.h"
 
-#include "../../../Common/DocxFormat/Source/SystemUtility/FileSystem/Directory.h"
+#include "../../DesktopEditor/common/Directory.h"
+
+#include <tchar.h>
+
+#if defined(_WIN64)
+	#pragma comment(lib, "../../build/bin/icu/win_64/icuuc.lib")
+#elif defined (_WIN32)
+	#pragma comment(lib, "../../build/bin/icu/win_32/icuuc.lib")
+#endif
 
 int _tmain(int argc, _TCHAR* argv[])
 {
 	if (argc < 2) return 1;
 
 	std::wstring sSrcPpt	= argv[1];
-    std::wstring sDstPptx	= argc > 2 ? argv[2] : sSrcDoc + L"-my.pptx";
+    std::wstring sDstPptx	= argc > 2 ? argv[2] : sSrcPpt + L"-my.pptx";
 
-	std::wstring outputDir		= FileSystem::Directory::GetFolderPath(sDstPptx);
-	std::wstring dstTempPath	= FileSystem::Directory::CreateDirectoryWithUniqueName(outputDir);
+	std::wstring outputDir		= NSDirectory::GetFolderPath(sDstPptx);
+	std::wstring dstTempPath	= NSDirectory::CreateDirectoryWithUniqueName(outputDir);
 
-	std::wstring tempPath	= FileSystem::Directory::CreateDirectoryWithUniqueName(outputDir);
+	std::wstring tempPath	= NSDirectory::CreateDirectoryWithUniqueName(outputDir);
 
 	COfficePPTFile pptFile;
 	
@@ -60,8 +68,8 @@ int _tmain(int argc, _TCHAR* argv[])
 		hRes = oCOfficeUtils.CompressFileOrDirectory(dstTempPath.c_str(), sDstPptx, -1);
 	}
 		
-	FileSystem::Directory::DeleteDirectory(dstTempPath);
-	FileSystem::Directory::DeleteDirectory(tempPath);
+	NSDirectory::DeleteDirectory(dstTempPath);
+	NSDirectory::DeleteDirectory(tempPath);
 
 	return hRes;
 }

ASCOfficePPTFile/PptFormatTest/PptFormatTest.vcproj

@@ -45,7 +45,7 @@
 				Name="VCCLCompilerTool"
 				Optimization="0"
 				AdditionalIncludeDirectories="..\..\Common\OfficeDrawing;"..\..\DesktopEditor\freetype-2.5.2\include";..\..\Common\OfficeDrawing\Shapes"
-				PreprocessorDefinitions="_DEBUG;_CONSOLE;USE_ATL_CSTRINGS;_USE_MATH_DEFINES;PPTX_DEF;PPT_DEF;ENABLE_PPT_TO_PPTX_CONVERT;PPT_FORMAT;_USE_LIBXML2_READER_;LIBXML_READER_ENABLED;USE_LITE_READER;_USE_XMLLITE_READER_;_PRESENTATION_WRITER_;_SVG_CONVERT_TO_IMAGE_"
+				PreprocessorDefinitions="_DEBUG;_CONSOLE;USE_ATL_CSTRINGS;_USE_MATH_DEFINES;PPTX_DEF;PPT_DEF;ENABLE_PPT_TO_PPTX_CONVERT;PPT_FORMAT;_USE_LIBXML2_READER_;LIBXML_READER_ENABLED;USE_LITE_READER;_USE_XMLLITE_READER_;_PRESENTATION_WRITER_;_SVG_CONVERT_TO_IMAGE_;DONT_WRITE_EMBEDDED_FONTS"
 				MinimalRebuild="false"
 				BasicRuntimeChecks="3"
 				RuntimeLibrary="3"
@@ -340,14 +340,34 @@
 	<References>
 	</References>
 	<Files>
-		<File
-			RelativePath="..\..\ASCOfficeDocxFile2\BinWriter\BinWriters.cpp"
+		<Filter
+			Name="common"
 			>
-		</File>
-		<File
-			RelativePath="..\..\build\bin\icu\win_32\icuuc.lib"
-			>
-		</File>
+			<File
+				RelativePath="..\..\ASCOfficeDocxFile2\BinWriter\BinWriters.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\Common\OfficeFileFormatChecker2.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\ASCOfficeDocxFile2\BinReader\Readers.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\UnicodeConverter\UnicodeConverter.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\DesktopEditor\xml\src\xmldom.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\..\DesktopEditor\xml\src\xmllight.cpp"
+				>
+			</File>
+		</Filter>
 		<File
 			RelativePath="PptFormatTest.cpp"
 			>