.

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"

ASCOfficeOdfFileW/OdfFileWTest/OdfFileWTest.sln

@@ -1,10 +1,19 @@
 
 Microsoft Visual Studio Solution File, Format Version 9.00
 # Visual Studio 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "OdfFormatWriterLib", "..\source\win32\OdfFormat.vcproj", "{E5A67556-44DA-4481-8F87-0A3AEDBD20DD}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C739151F-5384-41DF-A1A6-F089E2C1AD56} = {C739151F-5384-41DF-A1A6-F089E2C1AD56}
+		{609ED938-3CA8-4BED-B363-25096D4C4812} = {609ED938-3CA8-4BED-B363-25096D4C4812}
+		{9CAA294E-58C3-4CEB-ABA0-CB9786CA5540} = {9CAA294E-58C3-4CEB-ABA0-CB9786CA5540}
+		{94954A67-A853-43B1-A727-6EF2774C5A6A} = {94954A67-A853-43B1-A727-6EF2774C5A6A}
+	EndProjectSection
+EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Oox2OdfConverter", "..\source\win32\Oox2OdfConverter.vcproj", "{BEE01B53-244A-44E6-8947-ED9342D9247E}"
 	ProjectSection(ProjectDependencies) = postProject
 		{21663823-DE45-479B-91D0-B4FEF4916EF0} = {21663823-DE45-479B-91D0-B4FEF4916EF0}
 		{A100103A-353E-45E8-A9B8-90B87CC5C0B0} = {A100103A-353E-45E8-A9B8-90B87CC5C0B0}
+		{E5A67556-44DA-4481-8F87-0A3AEDBD20DD} = {E5A67556-44DA-4481-8F87-0A3AEDBD20DD}
 		{94954A67-A853-43B1-A727-6EF2774C5A6A} = {94954A67-A853-43B1-A727-6EF2774C5A6A}
 		{36636678-AE25-4BE6-9A34-2561D1BCF302} = {36636678-AE25-4BE6-9A34-2561D1BCF302}
 	EndProjectSection
@@ -89,6 +98,14 @@ Global
 		Release|x64 = Release|x64
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{E5A67556-44DA-4481-8F87-0A3AEDBD20DD}.Debug|Win32.ActiveCfg = Debug|Win32
+		{E5A67556-44DA-4481-8F87-0A3AEDBD20DD}.Debug|Win32.Build.0 = Debug|Win32
+		{E5A67556-44DA-4481-8F87-0A3AEDBD20DD}.Debug|x64.ActiveCfg = Debug|x64
+		{E5A67556-44DA-4481-8F87-0A3AEDBD20DD}.Debug|x64.Build.0 = Debug|x64
+		{E5A67556-44DA-4481-8F87-0A3AEDBD20DD}.Release|Win32.ActiveCfg = Release|Win32
+		{E5A67556-44DA-4481-8F87-0A3AEDBD20DD}.Release|Win32.Build.0 = Release|Win32
+		{E5A67556-44DA-4481-8F87-0A3AEDBD20DD}.Release|x64.ActiveCfg = Release|x64
+		{E5A67556-44DA-4481-8F87-0A3AEDBD20DD}.Release|x64.Build.0 = Release|x64
 		{BEE01B53-244A-44E6-8947-ED9342D9247E}.Debug|Win32.ActiveCfg = Debug|Win32
 		{BEE01B53-244A-44E6-8947-ED9342D9247E}.Debug|Win32.Build.0 = Debug|Win32
 		{BEE01B53-244A-44E6-8947-ED9342D9247E}.Debug|x64.ActiveCfg = Debug|x64

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/Converter.cpp

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

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/Converter.h

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

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/ImageManager.h

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

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/ShapeWriter.cpp

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

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/ShapeWriter.h

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

ASCOfficePPTFile/PPTFormatLib/Reader/PPTDocumentInfoOneUser.cpp

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

ASCOfficePPTFile/PPTFormatLib/Reader/PPTDocumentInfoOneUser.h

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

ASCOfficePPTFile/PPTFormatLib/Reader/PPTFileDefines.h

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

ASCOfficePPTFile/PPTFormatLib/Reader/Records.cpp

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

ASCOfficePPTFile/PPTFormatLib/Reader/Records.h

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

ASCOfficePPTFile/PPTFormatLib/Reader/SlideInfo.h

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

ASCOfficePPTFile/PPTFormatLib/Records/Animations/AnimationTypes.h

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

ASCOfficePPTFile/PPTFormatLib/Records/DocumentRecords.h

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

ASCOfficePPTFile/PPTFormatLib/Records/Drawing/BlipStoreContainer.h

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

ASCOfficePPTFile/PPTFormatLib/Records/Drawing/GroupShapeContainer.h

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

ASCOfficePPTFile/PPTFormatLib/Records/Drawing/ShapeContainer.h

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

ASCOfficePPTFile/PPTFormatLib/Records/HeadersFootersAtom.h

@@ -198,7 +198,7 @@ public:
 	{
 		CRecordsContainer::ReadFromStream(oHeader, pStream);
 
-		for (int i = 0 ; i < m_arRecords.size(); i++)
+		for (size_t i = 0 ; i < m_arRecords.size(); i++)
 		{
 			switch(m_arRecords[i]->m_oHeader.RecType)
 			{

ASCOfficePPTFile/PPTFormatLib/Records/NotesAtom.h

@@ -34,13 +34,12 @@
 
 class CRecordNotesAtom : public CUnknownRecord
 {
+public:
 	UINT m_nSlideIDRef;
 	
 	bool m_bMasterObjects;
 	bool m_bMasterScheme;
 	bool m_bMasterBackground;
-
-public:
 	
 	CRecordNotesAtom()
 	{
@@ -54,11 +53,11 @@ public:
 	{
 		m_oHeader = oHeader;
 
-		m_nSlideIDRef = (UINT)StreamUtils::ReadDWORD(pStream);
+		m_nSlideIDRef	= (UINT)StreamUtils::ReadDWORD(pStream);
 
-		USHORT nFlag = StreamUtils::ReadWORD(pStream);
-		m_bMasterObjects = ((nFlag & 0x01) == 0x01);
-		m_bMasterScheme = ((nFlag & 0x02) == 0x02);
+		USHORT nFlag		= StreamUtils::ReadWORD(pStream);
+		m_bMasterObjects	= ((nFlag & 0x01) == 0x01);
+		m_bMasterScheme		= ((nFlag & 0x02) == 0x02);
 		m_bMasterBackground = ((nFlag & 0x04) == 0x04);
 
 		StreamUtils::StreamSkip(2, pStream);

ASCOfficePPTFile/PPTFormatLib/Records/RecordsIncluder.h

@@ -91,6 +91,7 @@
 #include "RoundTripColorMappingAtom.h"
 #include "RoundTripNewPlaceholderId12Atom.h"
 #include "RoundTripThemeAtom.h"
+#include "RoundTripNotesMasterTextStyles12Atom.h"
 #include "TextRulerAtom.h"
 #include "ShapeFlags10Atom.h"
 #include "ShapeFlagsAtom.h"

ASCOfficePPTFile/PPTFormatLib/Records/RoundTripColorMappingAtom.h

@@ -34,9 +34,8 @@
 
 class CRecordRoundTripColorMappingAtom : public CUnknownRecord
 {
-    std::wstring m_pString;
-
 public:
+    std::string m_strData;
 	
 	CRecordRoundTripColorMappingAtom()
 	{
@@ -48,6 +47,7 @@ public:
 
 	virtual void ReadFromStream(SRecordHeader & oHeader, POLE::Stream* pStream)
 	{
-		return CUnknownRecord::ReadFromStream(oHeader, pStream);
+		m_oHeader = oHeader;
+		m_strData = StreamUtils::ReadStringA(pStream, (long)m_oHeader.RecLen);
 	}
 };

ASCOfficePPTFile/PPTFormatLib/Records/RoundTripNotesMasterTextStyles12Atom.h

@@ -0,0 +1,53 @@
+/*
+ * (c) Copyright Ascensio System SIA 2010-2017
+ *
+ * This program is a free software product. You can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License (AGPL)
+ * version 3 as published by the Free Software Foundation. In accordance with
+ * Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
+ * that Ascensio System SIA expressly excludes the warranty of non-infringement
+ * of any third-party rights.
+ *
+ * This program is distributed WITHOUT ANY WARRANTY; without even the implied
+ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR  PURPOSE. For
+ * details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
+ *
+ * You can contact Ascensio System SIA at Lubanas st. 125a-25, Riga, Latvia,
+ * EU, LV-1021.
+ *
+ * The  interactive user interfaces in modified source and object code versions
+ * of the Program must display Appropriate Legal Notices, as required under
+ * Section 5 of the GNU AGPL version 3.
+ *
+ * Pursuant to Section 7(b) of the License you must retain the original Product
+ * logo when distributing the program. Pursuant to Section 7(e) we decline to
+ * grant you any rights under trademark law for use of our trademarks.
+ *
+ * All the Product's GUI elements, including illustrations and icon sets, as
+ * well as technical writing content are licensed under the terms of the
+ * Creative Commons Attribution-ShareAlike 4.0 International. See the License
+ * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
+ *
+ */
+#pragma once
+#include "../Reader/Records.h"
+
+class CRecordRoundTripNotesMasterTextStyles12Atom : public CUnknownRecord
+{
+public:
+    std::string m_strData;
+	
+	CRecordRoundTripNotesMasterTextStyles12Atom()
+	{
+	}
+
+	~CRecordRoundTripNotesMasterTextStyles12Atom()
+	{
+	}
+
+	virtual void ReadFromStream(SRecordHeader & oHeader, POLE::Stream* pStream)
+	{
+		m_oHeader = oHeader;
+		m_strData = StreamUtils::ReadStringA(pStream, (long)m_oHeader.RecLen);
+	}
+};

ASCOfficePPTFile/PPTFormatLib/Records/RoundTripThemeAtom.h

@@ -34,9 +34,8 @@
 
 class CRecordRoundTripThemeAtom : public CUnknownRecord
 {
-    std::wstring m_strData;
-
 public:
+    std::string m_strData;
 	
 	CRecordRoundTripThemeAtom()
 	{
@@ -48,6 +47,7 @@ public:
 
 	virtual void ReadFromStream(SRecordHeader & oHeader, POLE::Stream* pStream)
 	{
-		return CUnknownRecord::ReadFromStream(oHeader, pStream);
+		m_oHeader = oHeader;
+		m_strData = StreamUtils::ReadStringA(pStream, (long)m_oHeader.RecLen);
 	}
 };

ASCOfficePPTFile/PPTFormatLib/Records/SlideContainer.h

@@ -129,7 +129,7 @@ public:
 
     bool IsSlide()
 	{
-		for (int nIndex = 0; nIndex < m_arRecords.size(); ++nIndex)
+		for (size_t nIndex = 0; nIndex < m_arRecords.size(); ++nIndex)
 		{
 			if ((RECORD_TYPE_SLIDE			== m_arRecords[nIndex]->m_oHeader.RecType) ||
 				(RECORD_TYPE_MAINMASTER		== m_arRecords[nIndex]->m_oHeader.RecType) ||

ASCOfficePPTFile/PPTFormatLib/Records/TextBytesAtom.h

@@ -59,7 +59,7 @@ public:
 		{
 			pStream->read(pUTF16_low, m_oHeader.RecLen);
 
-			for (int i = 0 ; i < m_oHeader.RecLen; i++)
+			for (UINT i = 0 ; i < m_oHeader.RecLen; i++)
 			{
 				pUTF16[i] = pUTF16_low[i];
 			}

ASCOfficePPTFile/PPTFormatLib/Records/TextSpecInfoAtom.h

@@ -86,11 +86,12 @@ public:
 
 		int pos_text = 0, pos_si = 0;
 		int ind = 0;
-		for (int i = 0; i < pText->m_arParagraphs.size(); i++)
+		
+		for (size_t i = 0; i < pText->m_arParagraphs.size(); i++)
 		{
 			if (ind >= m_arrSIs.size()) break;
 			
-			for (int j = 0 ; j < pText->m_arParagraphs[i].m_arSpans.size(); j++)
+			for (size_t j = 0 ; j < pText->m_arParagraphs[i].m_arSpans.size(); j++)
 			{
 				if (pos_text + pText->m_arParagraphs[i].m_arSpans[j].m_strText.length() > pos_si + m_arrSIs[ind].lCount )
 				{

ASCOfficePPTFile/PPTFormatLib/Win32/PPTFormatLib.vcproj

@@ -462,10 +462,6 @@
 				RelativePath="..\Reader\ClassesAtom.h"
 				>
 			</File>
-			<File
-				RelativePath="..\..\..\ASCPresentationEditor\OfficeDrawing\Document.h"
-				>
-			</File>
 			<File
 				RelativePath="..\Reader\PPTDocumentInfo.h"
 				>
@@ -1030,6 +1026,26 @@
 				RelativePath="..\..\..\ASCOfficePPTXFile\Editor\Drawing\XmlWriter.h"
 				>
 			</File>
+			<Filter
+				Name="ppt shapes"
+				>
+				<File
+					RelativePath="..\..\..\ASCOfficePPTXFile\Editor\Drawing\Shapes\BaseShape\PPTShape\customgeomshape.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\ASCOfficePPTXFile\Editor\Drawing\Shapes\BaseShape\PPTShape\elementsettings.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\ASCOfficePPTXFile\Editor\Drawing\Shapes\BaseShape\PPTShape\formula.h"
+					>
+				</File>
+				<File
+					RelativePath="..\..\..\ASCOfficePPTXFile\Editor\Drawing\Shapes\BaseShape\PPTShape\PPTShape.h"
+					>
+				</File>
+			</Filter>
 		</Filter>
 		<Filter
 			Name="OOXWriter"

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

ASCOfficePPTXFile/Editor/Drawing/Attributes.h

@@ -478,10 +478,17 @@ namespace NSPresentationEditor
         long Alpha;
         double Size;
 
-        BYTE DashStyle;
-        BYTE LineStartCap;
-        BYTE LineEndCap;
-        BYTE LineJoin;
+		unsigned char DashStyle;
+		unsigned char LineStyle;
+		unsigned char LineJoin;
+		
+		unsigned char LineEndCap;
+		unsigned char LineEndLength;
+		unsigned char LineEndWidth;
+
+		unsigned char LineStartCap;
+		unsigned char LineStartLength;
+		unsigned char LineStartWidth;
 
         double* DashPattern;
         long Count;
@@ -492,9 +499,8 @@ namespace NSPresentationEditor
         double MiterLimit;
 
         CColor Color2;	//backLine
-    public:
 
-        void GetDashPattern(double* arrDashPattern, long& nCount) const
+		void GetDashPattern(double* arrDashPattern, long& nCount) const
         {
             if (nCount == Count)
             {
@@ -579,10 +585,16 @@ namespace NSPresentationEditor
             Alpha = 255;
             Size  = 0.26458;
 
-            DashStyle    = 0;
-            LineStartCap = 0;
-            LineEndCap   = 0;
-            LineJoin     = 0;
+			LineStyle	= 0; //single(Simple)
+			DashStyle	= 0; //Solid
+			LineJoin	= 2; //round
+
+			LineStartCap	= 0;
+			LineEndCap		= 0;
+			LineEndLength	= 1; //med
+			LineStartLength	= 1;
+			LineEndWidth	= 1;
+			LineStartWidth	= 1;
 
             DashPattern = NULL;
             Count       = 0;

ASCOfficePPTXFile/Editor/Drawing/Document.h

@@ -41,82 +41,59 @@ namespace NSPresentationEditor
 	public:
 		std::vector<CTheme>		m_arThemes;
 		std::vector<CSlide*>	m_arSlides;
+		std::vector<CSlide*>	m_arNotes;
+
+		CTheme*					m_pNotesMaster;
+		CTheme*					m_pHandoutMaster;
 
 		CMetricInfo				m_oInfo;
 
-	public:
-
 		CDocument() : m_arThemes(), m_arSlides()
 		{
+			m_pHandoutMaster	= NULL;
+			m_pNotesMaster		= NULL;
 		}
 
 		~CDocument()
 		{
+			Clear();
 		}
 
-		CDocument& operator=(const CDocument& oSrc)
-		{
-			m_arThemes = oSrc.m_arThemes;
-			m_arSlides = oSrc.m_arSlides;	
-
-			m_oInfo = oSrc.m_oInfo;
-
-			return *this;
-		}
-
-		CDocument(const CDocument& oSrc)
-		{
-			*this = oSrc;
-		}
-
-	public:
 		inline void Clear()
 		{
-			ClearThemes();
+			m_arThemes.clear();
 			try
 			{
 				ClearSlides();
+				ClearNotes();
+				
+				RELEASEOBJECT(m_pHandoutMaster);				
+				RELEASEOBJECT(m_pNotesMaster);
 			}catch(...)
 			{
 			}
 		}
-
-		// работа с темами
-		inline void ClearThemes()
-		{
-			m_arThemes.clear();
-		}
-		inline void AddTheme(const CTheme& oTheme)
-		{
-			m_arThemes.push_back(oTheme);
-		}
-		inline void UpdateTheme(size_t nIndex, const CTheme& oTheme)
-		{
-			if (nIndex >= m_arThemes.size())
-				return;
-
-			m_arThemes[nIndex] = oTheme;
-		}
-		// работа со слайдом
 		inline void ClearSlides()
 		{
-			for (int i = 0 ; i < m_arSlides.size(); i++)
+			for (size_t i = 0 ; i < m_arSlides.size(); i++)
 			{
 				RELEASEOBJECT(m_arSlides[i]);
 			}
 			m_arSlides.clear();
 		}
-		inline void AddSlide(CSlide* oSlide)
+		inline void ClearNotes()
 		{
-			m_arSlides.push_back(oSlide);
+			for (size_t i = 0 ; i < m_arNotes.size(); i++)
+			{
+				RELEASEOBJECT(m_arNotes[i]);
+			}
+			m_arNotes.clear();
 		}
 
-	public:
-
-		// функция производит расчет по теме и слайдам
-                std::wstring GetXmlSlideTransition ( CSlide& oSlide/*, CAudioOverlay& oAudioOverlay*/ )
+#if defined (_DEBUG)
+		std::wstring GetXmlSlideTransition ( CSlide& oSlide/*, CAudioOverlay& oAudioOverlay*/ )
 		{
-                        std::wstring Source	=	std::wstring ( _T("") );
+			std::wstring Source	=	std::wstring ( _T("") );
 
 			int EffectID	=	1;
 			int lEffectDirection = oSlide.m_oSlideShow.m_oTransition.m_nEffectDirection;
@@ -314,7 +291,7 @@ namespace NSPresentationEditor
 				break;
 			}
 
-                        Source = L"<VideoCompose Time=\"" + std::to_wstring(oSlide.m_oSlideShow.m_oTransition.m_dSpeed) + L"\" effectid=\"" + std::to_wstring(EffectID) + L"\"/>";
+			Source = L"<VideoCompose Time=\"" + std::to_wstring(oSlide.m_oSlideShow.m_oTransition.m_dSpeed) + L"\" effectid=\"" + std::to_wstring(EffectID) + L"\"/>";
 
 			/*
 
@@ -338,7 +315,7 @@ namespace NSPresentationEditor
 			
 			return Source;
 		}
-
+#endif
 		double CalculateTimes(CAudioOverlay& oAudioOverlay)
 		{
 			CaclulateSlideTimes();
@@ -486,7 +463,6 @@ namespace NSPresentationEditor
 			}
 		}
 
-	public:
 		void ResetAutoText(IElement *pElement, vector_string const (&placeholdersReplaceString)[3])
 		{
 			CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement);

ASCOfficePPTXFile/Editor/Drawing/Shapes/BaseShape/PPTShape/CustomGeomShape.h

@@ -488,6 +488,9 @@ namespace NSCustomVML
         std::vector<CSegment>			m_arSegments;
         std::vector<CGuide>				m_arGuides;
         std::vector<LONG>*				m_pAdjustValues;
+        std::vector<Aggplus::POINT>		m_arConnectionSites;
+		std::vector<Aggplus::RECT>		m_arInscribe;
+        std::vector<double>				m_arConnectionSitesDir;
 
         bool m_bIsVerticesPresent;
         bool m_bIsPathPresent;
@@ -496,7 +499,7 @@ namespace NSCustomVML
         CPen	m_oPen;
 
     public:
-        CCustomVML() : m_arVertices(), m_arSegments(), m_arGuides(), m_pAdjustValues(NULL)
+        CCustomVML() : m_pAdjustValues(NULL)
         {
             m_ePath = rtCurveTo/*rtLineTo*/;
 
@@ -579,6 +582,63 @@ namespace NSCustomVML
                 m_arVertices.push_back(oPoint);
             }
         }
+		void LoadConnectionSitesDir(CProperty* pProperty)
+        {
+            NSOfficeDrawing::CBinaryReader oReader(pProperty->m_pOptions, pProperty->m_lValue);
+            m_arConnectionSitesDir.clear();
+           
+			WORD lCount = (WORD)(pProperty->m_lValue / 4);
+            
+			for (WORD lIndex = 0; lIndex < lCount; ++lIndex)
+            {
+                DWORD v = oReader.ReadLONG();
+				double val = (double)((WORD)(v >> 16) + ((WORD)(v) / 65536.0));
+				m_arConnectionSitesDir.push_back(val);
+			}
+		}
+		void LoadConnectionSites(CProperty* pProperty)
+        {
+            NSOfficeDrawing::CBinaryReader oReader(pProperty->m_pOptions, pProperty->m_lValue);
+            m_arConnectionSites.clear();
+
+            WORD lCount = (WORD)(pProperty->m_lValue / 8);
+            if (pProperty->m_bIsTruncated)
+            {
+                lCount = (WORD)(pProperty->m_lValue / 4);
+            }
+
+            for (WORD lIndex = 0; lIndex < lCount; ++lIndex)
+            {
+                Aggplus::POINT oPoint;
+                if (pProperty->m_bIsTruncated)
+                {
+                    oPoint.x = (short)oReader.ReadWORD();
+                    oPoint.y = (short)oReader.ReadWORD();
+                }
+                else
+                {
+                    oPoint.x = oReader.ReadLONG();
+                    oPoint.y = oReader.ReadLONG();
+                }
+
+                LONG lMinF = (LONG)0x80000000;
+                LONG lMaxF = (LONG)0x8000007F;
+                if (lMinF <= oPoint.x)
+                {
+                    int nGuideIndex = (DWORD)oPoint.x - 0x80000000;
+
+                    bool b = false;
+                }
+                if (lMinF <= oPoint.y)
+                {
+                    int nGuideIndex = (DWORD)oPoint.y - 0x80000000;
+
+                    bool b = false;
+                }
+
+                m_arConnectionSites.push_back(oPoint);
+            }
+		}
         void LoadVertices(CProperty* pProperty)
         {
             NSOfficeDrawing::CBinaryReader oReader(pProperty->m_pOptions, pProperty->m_lValue);
@@ -704,8 +764,38 @@ namespace NSCustomVML
                 oInfo.Read(oReader);
                 m_arGuides.push_back(oInfo);
             }
-
         }
+		void LoadInscribe(CProperty* pProperty)
+		{
+            NSOfficeDrawing::CBinaryReader oReader(pProperty->m_pOptions, pProperty->m_lValue);
+            m_arInscribe.clear();
+
+            WORD lCount = (WORD)(pProperty->m_lValue / 16);
+            if (pProperty->m_bIsTruncated)
+            {
+                lCount = (WORD)(pProperty->m_lValue / 8);
+            }
+
+            for (WORD lIndex = 0; lIndex < lCount; ++lIndex)
+            {
+                Aggplus::RECT oRect;
+                if (pProperty->m_bIsTruncated)
+                {
+                    oRect.left		= (short)oReader.ReadWORD();
+                    oRect.right		= (short)oReader.ReadWORD();
+					oRect.top		= (short)oReader.ReadWORD();
+					oRect.bottom	= (short)oReader.ReadWORD();
+               }
+                else
+                {
+                    oRect.left		= (short)oReader.ReadLONG();
+                    oRect.right		= (short)oReader.ReadLONG();
+					oRect.top		= (short)oReader.ReadLONG();
+					oRect.bottom	= (short)oReader.ReadLONG();
+                }
+                m_arInscribe.push_back(oRect);
+            }
+		}
         void LoadAdjusts(LONG lIndex, LONG lValue)
         {
             if (NULL == m_pAdjustValues)

ASCOfficePPTXFile/Editor/Drawing/Shapes/BaseShape/PPTShape/PPTShape.cpp

@@ -47,10 +47,10 @@ CPPTShape* CPPTShape::CreateByType(PPTShapes::ShapeType type)
 	CPPTShape* pShape = NULL;
 	switch (type)
 	{
-// msosptNotchedCircularArrow           0x00000064 A value that SHOULD NOT be used.
+// msosptNotchedCircularArrow	0x00000064 A value that SHOULD NOT be used.
 // msosptHostControl			0x000000C9 A value that SHOULD NOT be used.
 
-	case sptNotchedCircularArrow:
+	//case sptNotchedCircularArrow:
 	case sptHostControl:		
 			{ pShape = new CPPTShape();  pShape->m_eType = type; break; }
 	case 0: { pShape = new CRectangleType(); break; }

ASCOfficePPTXFile/Editor/Drawing/Slide.h

@@ -41,6 +41,9 @@ namespace NSPresentationEditor
 		LONG m_lThemeID;
 		LONG m_lLayoutID;
 
+		LONG m_lSlideID;	//for notes rels
+		LONG m_lNotesID;	//for slide rels
+
 		std::vector<IElement*>	m_arElements;
 		CSlideShowInfo			m_oSlideShow;
 		std::multimap<int,int>	m_mapPlaceholders;
@@ -91,6 +94,8 @@ namespace NSPresentationEditor
 			
 			m_lThemeID			= -1;
 			m_lLayoutID			= -1;
+			m_lSlideID			= -1;
+			m_lNotesID			= -1;
 
 			m_lWidth			= 270;   
 			m_lHeight			= 190; 
@@ -125,6 +130,8 @@ namespace NSPresentationEditor
 
 			m_lThemeID			= oSrc.m_lThemeID;
 			m_lLayoutID			= oSrc.m_lLayoutID;
+			m_lNotesID			= oSrc.m_lNotesID;
+			m_lSlideID			= oSrc.m_lSlideID;
 
 			m_lWidth			= oSrc.m_lWidth;
 			m_lHeight			= oSrc.m_lHeight;

ASCOfficePPTXFile/Editor/Drawing/Theme.h

@@ -32,7 +32,6 @@
 #pragma once
 #include "Structures.h"
 #include "Layout.h"
-//#include "../PPTXWriter/CSS.h"
 
 namespace NSPresentationEditor
 {

ASCOfficeXlsFile2/source/XlsXlsxConverter/ShapeType.h

@@ -251,6 +251,19 @@ namespace oox
         case msosptRectangle : 					return L"rect";
         case msosptEllipse : 					return L"ellipse";
         case msosptLine : 						return L"line";
+        case msosptActionButtonBlank : 			return L"actionButtonBlank";
+        case msosptActionButtonHome : 			return L"actionButtonHome";
+        case msosptActionButtonHelp : 			return L"actionButtonHelp";
+        case msosptActionButtonInformation :	return L"actionButtonInformation";
+        case msosptActionButtonForwardNext :	return L"actionButtonForwardNext";
+        case msosptActionButtonBackPrevious :	return L"actionButtonBackPrevious";
+        case msosptActionButtonEnd : 			return L"actionButtonEnd";
+        case msosptActionButtonBeginning : 		return L"actionButtonBeginning";
+        case msosptActionButtonReturn : 		return L"actionButtonReturn";
+        case msosptActionButtonDocument : 		return L"actionButtonDocument";
+        case msosptActionButtonSound : 			return L"actionButtonSound";
+		case msosptActionButtonMovie : 			return L"actionButtonMovie";
+        case msosptLeftArrow : 					return L"leftArrow";
 		}
         return L"";
 	}

DesktopEditor/common/BigInteger.h

@@ -326,7 +326,7 @@ private:
         if (differenceInLength < 0)
             differenceInLength = -differenceInLength;
 
-        for (int i = number1.size() - 1; i >= 0; --i)
+        for (int i = (int)(number1.size()) - 1; i >= 0; --i)
         {
             add[i] = ((carry-'0')+(number1[i]-'0')+(number2[i]-'0')) + '0';
 
@@ -364,7 +364,7 @@ private:
         if (differenceInLength < 0)
             differenceInLength = -differenceInLength;
 
-        for (int i = number1.length() - 1; i >= 0; --i)
+        for (int i = (int)(number1.length()) - 1; i >= 0; --i)
         {
             if (number1[i] < number2[i])
             {
@@ -386,13 +386,13 @@ private:
             n1.swap(n2);
 
         std::string res = "0";
-        for (int i = n1.length() - 1; i >= 0; --i)
+        for (int i = (int)(n1.length()) - 1; i >= 0; --i)
         {
             std::string temp = n2;
             int currentDigit = n1[i] - '0';
             int carry = 0;
 
-            for (int j = temp.length() - 1; j >= 0; --j)
+            for (int j = (int)(temp.length()) - 1; j >= 0; --j)
             {
                 temp[j] = ((temp[j]-'0') * currentDigit) + carry;
 

DesktopEditor/xml/build/qt/libxml2.pro

@@ -11,6 +11,19 @@ TEMPLATE = lib
 CONFIG += staticlib
 QMAKE_CXXFLAGS += -Wall -g
 
+DEFINES += \
+    LIBXML_READER_ENABLED \
+    LIBXML_PUSH_ENABLED \
+    LIBXML_HTML_ENABLED \
+    LIBXML_XPATH_ENABLED \
+    LIBXML_OUTPUT_ENABLED \
+    LIBXML_C14N_ENABLED \
+    LIBXML_SAX1_ENABLED \
+    LIBXML_TREE_ENABLED \
+    LIBXML_XPTR_ENABLED \
+    IN_LIBXML \
+    LIBXML_STATIC
+
 CORE_ROOT_DIR = $$PWD/../../../..
 PWD_ROOT_DIR = $$PWD
 include(../../../../Common/base.pri)

DesktopEditor/xmlsec/src/OOXMLSigner.h

@@ -3,6 +3,7 @@
 
 #include "./XmlCanonicalizator.h"
 #include "./XmlSignerBase.h"
+#include "./XmlTransform.h"
 
 class COOXMLSigner
 {
@@ -23,167 +24,6 @@ public:
 
     std::wstring                            m_guid;
 
-public:
-    class COOXMLRelationship
-    {
-    public:
-        std::wstring rid;
-        std::wstring type;
-        std::wstring target;
-        std::wstring target_mode;
-
-    public:
-
-        COOXMLRelationship()
-        {
-        }
-
-        COOXMLRelationship(XmlUtils::CXmlNode& node)
-        {
-            rid = node.GetAttribute("Id");
-            type = node.GetAttribute("Type");
-            target = node.GetAttribute("Target");
-
-            CheckTargetMode();
-        }
-
-        std::wstring GetXml()
-        {
-            NSStringUtils::CStringBuilder builder;
-            builder.WriteString(L"<Relationship Id=\"");
-            builder.WriteEncodeXmlString(rid);
-            builder.WriteString(L"\" Type=\"");
-            builder.WriteEncodeXmlString(type);
-            builder.WriteString(L"\" Target=\"");
-            builder.WriteEncodeXmlString(target);
-            builder.WriteString(L"\" TargetMode=\"");
-            builder.WriteEncodeXmlString(target_mode);
-            builder.WriteString(L"\" />");
-            return builder.GetData();
-        }
-
-        static bool Compare(const COOXMLRelationship& i, const COOXMLRelationship& j)
-        {
-            return i.rid < j.rid;
-        }
-
-    protected:
-        void CheckTargetMode()
-        {
-            if (0 == target.find(L"http") || 0 == target.find(L"www") || 0 == target.find(L"ftp"))
-                target_mode = L"External";
-            else
-                target_mode = L"Internal";
-        }
-    };
-
-    class COOXMLRelationships
-    {
-    public:
-        std::vector<COOXMLRelationship> rels;
-
-    public:
-
-        COOXMLRelationships()
-        {
-        }
-
-        COOXMLRelationships(std::wstring& file)
-        {
-            XmlUtils::CXmlNode oNode;
-            if (!oNode.FromXmlFile(file))
-                return;
-
-            XmlUtils::CXmlNodes oNodes;
-            if (!oNode.GetNodes(L"Relationship", oNodes))
-                return;
-
-            int nCount = oNodes.GetCount();
-            for (int i = 0; i < nCount; ++i)
-            {
-                XmlUtils::CXmlNode oRel;
-                oNodes.GetAt(i, oRel);
-                rels.push_back(COOXMLRelationship(oRel));
-            }
-        }
-
-        std::wstring GetXml()
-        {
-            NSStringUtils::CStringBuilder builder;
-
-            builder.WriteString(L"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
-
-            // sort by rId
-            std::sort(rels.begin(), rels.end(), COOXMLRelationship::Compare);
-
-            for (std::vector<COOXMLRelationship>::iterator i = rels.begin(); i != rels.end(); i++)
-                builder.WriteString(i->GetXml());
-
-            builder.WriteString(L"</Relationships>");
-
-            return builder.GetData();
-        }
-
-        std::wstring GetTransforms()
-        {
-            NSStringUtils::CStringBuilder builder;
-
-            builder.WriteString(L"<Transforms><Transform Algorithm=\"http://schemas.openxmlformats.org/package/2006/RelationshipTransform\">");
-
-            for (std::vector<COOXMLRelationship>::iterator i = rels.begin(); i != rels.end(); i++)
-            {
-                builder.WriteString(L"<mdssi:RelationshipReference xmlns:mdssi=\"http://schemas.openxmlformats.org/package/2006/digital-signature\" SourceId=\"");
-                builder.WriteEncodeXmlString(i->rid);
-                builder.WriteString(L"\" />");
-            }
-
-            builder.WriteString(L"</Transform><Transform Algorithm=\"http://www.w3.org/TR/2001/REC-xml-c14n-20010315\"/></Transforms>");
-
-            return builder.GetData();
-        }
-
-        void CheckOriginSigs(std::wstring& file)
-        {
-            int rId = 0;
-            std::vector<COOXMLRelationship>::iterator i = rels.begin();
-            while (i != rels.end())
-            {
-                if (0 == i->target.find(L"_xmlsignatures/"))
-                    return;
-
-                std::wstring rid = i->rid;
-                rid = rid.substr(3);
-
-                int nTemp = std::stoi(rid);
-
-                if (nTemp > rId)
-                    rId = nTemp;
-
-                i++;
-            }
-
-            std::string sXmlA;
-            NSFile::CFileBinary::ReadAllTextUtf8A(file, sXmlA);
-
-            std::string::size_type pos = sXmlA.rfind("</Relationships>");
-            if (pos == std::string::npos)
-                return;
-
-            rId++;
-            std::string sRet = sXmlA.substr(0, pos);
-            sRet += ("<Relationship Id=\"rId" + std::to_string(rId) + "\" \
-Type=\"http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/origin\" Target=\"_xmlsignatures/origin.sigs\"/>\
-</Relationships>");
-
-            NSFile::CFileBinary::Remove(file);
-
-            NSFile::CFileBinary oFile;
-            oFile.CreateFileW(file);
-            oFile.WriteFile((BYTE*)sRet.c_str(), (DWORD)sRet.length());
-            oFile.CloseFile();
-        }
-    };
-
 public:
     COOXMLSigner(const std::wstring& sFolder, ICertificate* pContext)
     {
@@ -259,7 +99,7 @@ public:
 
     std::wstring GetRelsReference(const std::wstring& file)
     {
-        COOXMLRelationships oRels(m_sFolder + file);
+        COOXMLRelationships oRels(m_sFolder + file, true);
 
         if (L"/_rels/.rels" == file)
         {

DesktopEditor/xmlsec/src/OOXMLVerifier.h

@@ -0,0 +1,123 @@
+#ifndef _XML_OOXMLVERIFIER_H_
+#define _XML_OOXMLVERIFIER_H_
+
+#include "./XmlCanonicalizator.h"
+#include "./XmlSignerBase.h"
+#include "./XmlTransform.h"
+
+#define OOXML_SIGNATURE_VALID           0
+#define OOXML_SIGNATURE_INVALID         1
+#define OOXML_SIGNATURE_NOTSUPPORTED    2
+
+class COOXMLSignature
+{
+private:
+    int             m_valid;
+    std::string     m_guid;
+    ICertificate*   m_cert;
+
+    std::string     m_sImageValidBase64;
+    std::string     m_sImageInvalidBase64;
+
+private:
+   XmlUtils::CXmlNode   m_node; // signature file
+
+public:
+    COOXMLSignature()
+    {
+        m_valid = OOXML_SIGNATURE_INVALID;
+        m_guid = "";
+        m_cert = NULL;
+    }
+    ~COOXMLSignature()
+    {
+        RELEASEOBJECT(m_cert);
+    }
+
+public:
+    int GetValid()
+    {
+        return m_valid;
+    }
+    std::string GetGuid()
+    {
+        return m_guid;
+    }
+    ICertificate* GetCertificate()
+    {
+        return m_cert;
+    }
+    std::string GetImageValidBase64()
+    {
+        return m_sImageValidBase64;
+    }
+    std::string GetImageInvalidBase64()
+    {
+        return m_sImageInvalidBase64;
+    }
+
+public:
+    void Check()
+    {
+
+    }
+
+    friend class COOXMLVerifier;
+};
+
+class COOXMLVerifier
+{
+public:
+    std::wstring                            m_sFolder;
+    std::vector<COOXMLSignature*>           m_arSignatures;
+
+public:
+    COOXMLVerifier(const std::wstring& sFolder)
+    {
+        m_sFolder = sFolder;
+
+        if (!NSFile::CFileBinary::Exists(m_sFolder + L"/_xmlsignatures/origin.sigs"))
+            return;
+
+        XmlUtils::CXmlNode oContentTypes;
+        if (!oContentTypes.FromXmlFile(m_sFolder + L"/[Content_Types].xml"))
+            return;
+
+        XmlUtils::CXmlNodes oOverrides = oContentTypes.GetNodes(L"Override");
+        int nCount = oOverrides.GetCount();
+
+        for (int i = 0; i < nCount; i++)
+        {
+            XmlUtils::CXmlNode node;
+            oOverrides.GetAt(i, node);
+
+            if (node.GetAttributeA("ContentType") != "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml")
+                continue;
+
+            std::wstring sFile = m_sFolder + node.GetAttribute("PartName");
+            XmlUtils::CXmlNode nodeSig;
+            if (!nodeSig.FromXmlFile(sFile))
+                continue;
+
+            if (nodeSig.GetName() != L"Signature")
+                continue;
+
+            COOXMLSignature* pSignature = new COOXMLSignature();
+            pSignature->m_node = nodeSig;
+            pSignature->Check();
+
+            m_arSignatures.push_back(pSignature);
+        }
+    }
+    ~COOXMLVerifier()
+    {
+        for (std::vector<COOXMLSignature*>::iterator i = m_arSignatures.begin(); i != m_arSignatures.end(); i++)
+        {
+            COOXMLSignature* v = *i;
+            RELEASEOBJECT(v);
+        }
+        m_arSignatures.clear();
+    }
+};
+
+#endif //_XML_OOXMLVERIFIER_H_

DesktopEditor/xmlsec/src/XmlCanonicalizator.h

@@ -8,6 +8,10 @@
 #include "../../xml/include/xmlutils.h"
 #include "../../xml/libxml2/include/libxml/c14n.h"
 
+#ifndef XML_UNUSED
+#define XML_UNUSED( arg )  ( (arg) = (arg) )
+#endif
+
 class CXmlCanonicalizator
 {
 private:
@@ -33,11 +37,14 @@ private:
 
     static int buffer_xmlBufferIOClose(CXmlBuffer* buf)
     {
+        XML_UNUSED(buf);
         return 0;
     }
 
     static int buffer_xmlC14NIsVisibleCallback(void * user_data, xmlNodePtr node, xmlNodePtr parent)
     {
+        XML_UNUSED(user_data);
+        XML_UNUSED(parent);
         if (node->type == XML_TEXT_NODE)
         {
             const char* cur = (char*)node->content;
@@ -53,7 +60,7 @@ private:
     }
 
 public:
-    static std::string Execute(const std::string& sXml, int mode)
+    static std::string Execute(const std::string& sXml, int mode = XML_C14N_1_0, bool withComments = false)
     {
         xmlDocPtr xmlDoc = xmlParseMemory((char*)sXml.c_str(), (int)sXml.length());
 
@@ -63,21 +70,18 @@ public:
                                                              &bufferC14N,
                                                              NULL);
 
-        xmlC14NExecute(xmlDoc, buffer_xmlC14NIsVisibleCallback, NULL, mode, NULL, 0, _buffer);
+        xmlC14NExecute(xmlDoc, buffer_xmlC14NIsVisibleCallback, NULL, mode, NULL, withComments ? 1 : 0, _buffer);
 
         xmlOutputBufferClose(_buffer);
 
         return bufferC14N.builder.GetData();
     }
 
-    static std::string Execute(const std::wstring& sXmlFile, int mode)
+    static std::string Execute(const std::wstring& sXmlFile, int mode = XML_C14N_1_0, bool withComments = false)
     {
         std::string sXml;
         NSFile::CFileBinary::ReadAllTextUtf8A(sXmlFile, sXml);
-
-        xmlDocPtr xmlDoc = xmlParseMemory((char*)sXml.c_str(), (int)sXml.length());
-
-        return Execute(sXml, mode);
+        return Execute(sXml, mode, withComments);
     }
 };
 

DesktopEditor/xmlsec/src/XmlCertificate.h

@@ -0,0 +1,17 @@
+#ifndef _XMLSIGNER_CERTIFICATE_H_
+#define _XMLSIGNER_CERTIFICATE_H_
+
+#ifdef WIN32
+#include "XmlSigner_mscrypto.h"
+#define CCertificate CCertificate_mscrypto
+#endif
+
+#if defined(_LINUX) && !defined(_MAC)
+
+#endif
+
+#ifdef _MAC
+
+#endif
+
+#endif // _XMLSIGNER_CERTIFICATE_H_

DesktopEditor/xmlsec/src/XmlRels.h

@@ -0,0 +1,199 @@
+#ifndef _XML_RELS_H_
+#define _XML_RELS_H_
+
+#include "./XmlCanonicalizator.h"
+
+class COOXMLRelationship
+{
+public:
+    std::wstring rid;
+    std::wstring type;
+    std::wstring target;
+    std::wstring target_mode;
+
+public:
+
+    COOXMLRelationship()
+    {
+    }
+
+    COOXMLRelationship(XmlUtils::CXmlNode& node)
+    {
+        rid = node.GetAttribute("Id");
+        type = node.GetAttribute("Type");
+        target = node.GetAttribute("Target");
+
+        CheckTargetMode();
+    }
+
+    std::wstring GetXml()
+    {
+        NSStringUtils::CStringBuilder builder;
+        builder.WriteString(L"<Relationship Id=\"");
+        builder.WriteEncodeXmlString(rid);
+        builder.WriteString(L"\" Type=\"");
+        builder.WriteEncodeXmlString(type);
+        builder.WriteString(L"\" Target=\"");
+        builder.WriteEncodeXmlString(target);
+        builder.WriteString(L"\" TargetMode=\"");
+        builder.WriteEncodeXmlString(target_mode);
+        builder.WriteString(L"\" />");
+        return builder.GetData();
+    }
+
+    static bool Compare(const COOXMLRelationship& i, const COOXMLRelationship& j)
+    {
+        return i.rid < j.rid;
+    }
+
+protected:
+    void CheckTargetMode()
+    {
+        if (0 == target.find(L"http") || 0 == target.find(L"www") || 0 == target.find(L"ftp"))
+            target_mode = L"External";
+        else
+            target_mode = L"Internal";
+    }
+};
+
+class COOXMLRelationships
+{
+public:
+    std::vector<COOXMLRelationship> rels;
+
+public:
+
+    COOXMLRelationships()
+    {
+    }
+
+    COOXMLRelationships(const std::string& xml, std::map<std::wstring, bool>* check_need = NULL)
+    {
+        XmlUtils::CXmlNode oNode;
+        if (!oNode.FromXmlStringA(xml))
+            return;
+
+        FromXmlNode(oNode, check_need);
+    }
+
+    COOXMLRelationships(const std::wstring& xml, const bool& is_file, std::map<std::wstring, bool>* check_need = NULL)
+    {
+        XmlUtils::CXmlNode oNode;
+
+        if (!is_file)
+        {
+            if (!oNode.FromXmlString(xml))
+                return;
+        }
+        else
+        {
+            if (!oNode.FromXmlFile(xml))
+                return;
+        }
+
+        FromXmlNode(oNode, check_need);
+    }
+
+    void FromXmlNode(XmlUtils::CXmlNode& oNode, std::map<std::wstring, bool>* check_need = NULL)
+    {
+        XmlUtils::CXmlNodes oNodes;
+        if (!oNode.GetNodes(L"Relationship", oNodes))
+            return;
+
+        int nCount = oNodes.GetCount();
+        for (int i = 0; i < nCount; ++i)
+        {
+            XmlUtils::CXmlNode oRel;
+            oNodes.GetAt(i, oRel);
+
+            if (NULL == check_need)
+            {
+                rels.push_back(COOXMLRelationship(oRel));
+            }
+            else
+            {
+                std::wstring sRid = oRel.GetAttribute("Id");
+                if (check_need->find(sRid) != check_need->end())
+                    rels.push_back(COOXMLRelationship(oRel));
+            }
+        }
+    }
+
+    std::wstring GetXml()
+    {
+        NSStringUtils::CStringBuilder builder;
+
+        builder.WriteString(L"<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">");
+
+        // sort by rId
+        std::sort(rels.begin(), rels.end(), COOXMLRelationship::Compare);
+
+        for (std::vector<COOXMLRelationship>::iterator i = rels.begin(); i != rels.end(); i++)
+            builder.WriteString(i->GetXml());
+
+        builder.WriteString(L"</Relationships>");
+
+        return builder.GetData();
+    }
+
+    std::wstring GetTransforms()
+    {
+        NSStringUtils::CStringBuilder builder;
+
+        builder.WriteString(L"<Transforms><Transform Algorithm=\"http://schemas.openxmlformats.org/package/2006/RelationshipTransform\">");
+
+        for (std::vector<COOXMLRelationship>::iterator i = rels.begin(); i != rels.end(); i++)
+        {
+            builder.WriteString(L"<mdssi:RelationshipReference xmlns:mdssi=\"http://schemas.openxmlformats.org/package/2006/digital-signature\" SourceId=\"");
+            builder.WriteEncodeXmlString(i->rid);
+            builder.WriteString(L"\" />");
+        }
+
+        builder.WriteString(L"</Transform><Transform Algorithm=\"http://www.w3.org/TR/2001/REC-xml-c14n-20010315\"/></Transforms>");
+
+        return builder.GetData();
+    }
+
+    void CheckOriginSigs(std::wstring& file)
+    {
+        int rId = 0;
+        std::vector<COOXMLRelationship>::iterator i = rels.begin();
+        while (i != rels.end())
+        {
+            if (0 == i->target.find(L"_xmlsignatures/"))
+                return;
+
+            std::wstring rid = i->rid;
+            rid = rid.substr(3);
+
+            int nTemp = std::stoi(rid);
+
+            if (nTemp > rId)
+                rId = nTemp;
+
+            i++;
+        }
+
+        std::string sXmlA;
+        NSFile::CFileBinary::ReadAllTextUtf8A(file, sXmlA);
+
+        std::string::size_type pos = sXmlA.rfind("</Relationships>");
+        if (pos == std::string::npos)
+            return;
+
+        rId++;
+        std::string sRet = sXmlA.substr(0, pos);
+        sRet += ("<Relationship Id=\"rId" + std::to_string(rId) + "\" \
+Type=\"http://schemas.openxmlformats.org/package/2006/relationships/digital-signature/origin\" Target=\"_xmlsignatures/origin.sigs\"/>\
+</Relationships>");
+
+        NSFile::CFileBinary::Remove(file);
+
+        NSFile::CFileBinary oFile;
+        oFile.CreateFileW(file);
+        oFile.WriteFile((BYTE*)sRet.c_str(), (DWORD)sRet.length());
+        oFile.CloseFile();
+    }
+};
+
+#endif //_XML_RELS_H_

DesktopEditor/xmlsec/src/XmlSignerBase.h

@@ -33,6 +33,9 @@ public:
     virtual std::string GetHash(std::wstring& sXmlFile)                     = 0;
     virtual bool Verify(std::string& sXml, std::string& sXmlSignature)      = 0;
 
+    virtual bool LoadFromBase64Data(const std::string& data)                = 0;
+    virtual int ShowCertificate()                                           = 0;
+
 public:
     virtual bool ShowSelectDialog()             = 0;
 };

DesktopEditor/xmlsec/src/XmlSigner_mscrypto.h

@@ -14,27 +14,40 @@ public:
     HCERTSTORE     m_store;
     PCCERT_CONTEXT m_context;
 
+protected:
+    BYTE*           m_rawData;
+    int             m_rawDataLen;
+
 public:
     CCertificate_mscrypto() : ICertificate()
     {
         m_store = NULL;
         m_context = NULL;
+
+        m_rawData = NULL;
+        m_rawDataLen = 0;
     }
     CCertificate_mscrypto(PCCERT_CONTEXT ctx) : ICertificate()
     {
         m_store = NULL;
         m_context = ctx;
+
+        m_rawData = NULL;
+        m_rawDataLen = 0;
     }
 
     virtual ~CCertificate_mscrypto()
     {
-        if (m_store != NULL)
+        if (m_store != NULL || m_rawData != NULL)
         {
             if (NULL != m_context)
                 CertFreeCertificateContext(m_context);
 
-            CertCloseStore(m_store, 0);
+            RELEASEARRAYOBJECTS(m_rawData);
         }
+
+        if (m_store != NULL)
+            CertCloseStore(m_store, 0);
     }
 
 public:
@@ -286,6 +299,28 @@ public:
         return bResultRet && bResult;
     }
 
+    virtual bool LoadFromBase64Data(const std::string& data)
+    {
+        RELEASEARRAYOBJECTS(m_rawData);
+        if (!NSFile::CBase64Converter::Decode(data.c_str(), (int)data.length(), m_rawData, m_rawDataLen))
+            return false;
+
+        m_context = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, m_rawData, m_rawDataLen);
+        if (!m_context)
+        {
+            RELEASEARRAYOBJECTS(m_rawData);
+            m_rawDataLen = 0;
+            return false;
+        }
+
+        return true;
+    }
+
+    virtual int ShowCertificate()
+    {
+        return (int)CryptUIDlgViewContext(CERT_STORE_CERTIFICATE_CONTEXT, m_context, NULL, NULL, 0, NULL);
+    }
+
 public:
     virtual bool ShowSelectDialog()
     {

DesktopEditor/xmlsec/src/XmlTransform.h

@@ -0,0 +1,186 @@
+#ifndef _XML_TRANSFORM_H_
+#define _XML_TRANSFORM_H_
+
+#include "./XmlRels.h"
+
+class IXmlTransform
+{
+protected:
+    std::string m_algorithm;
+
+public:
+    IXmlTransform()
+    {
+        m_algorithm = "";
+    }
+    virtual ~IXmlTransform()
+    {
+    }
+
+public:
+    virtual std::string Transform(const std::string& sXml) = 0;
+    virtual void LoadFromXml(XmlUtils::CXmlNode& node) = 0;
+
+    static IXmlTransform* GetFromType(const std::string& alg);
+};
+
+class CXmlTransformRelationship : public IXmlTransform
+{
+protected:
+    std::map<std::wstring, bool> m_arIds;
+
+public:
+    CXmlTransformRelationship() : IXmlTransform()
+    {
+        m_algorithm = "http://schemas.openxmlformats.org/package/2006/RelationshipTransform";
+    }
+
+    virtual std::string Transform(const std::string& xml)
+    {
+        COOXMLRelationships _rels(xml, &m_arIds);
+        return U_TO_UTF8(_rels.GetXml());
+    }
+
+    virtual void LoadFromXml(XmlUtils::CXmlNode& node)
+    {
+        XmlUtils::CXmlNodes oNodesIds;
+        node.GetChilds(oNodesIds);
+
+        int nCount = oNodesIds.GetCount();
+        for (int i = 0; i < nCount; ++i)
+        {
+            XmlUtils::CXmlNode _node;
+            oNodesIds.GetAt(i, _node);
+
+            std::wstring sType = _node.GetAttribute("SourceId");
+            if (!sType.empty())
+                m_arIds.insert(std::pair<std::wstring, bool>(sType, true));
+        }
+    }
+};
+
+class CXmlTransformC14N : public IXmlTransform
+{
+protected:
+    int m_mode;
+    bool m_comments;
+
+public:
+    CXmlTransformC14N() : IXmlTransform()
+    {
+        m_mode = -1;
+        m_comments = false;
+    }
+
+    bool CheckC14NTransform(const std::string& alg)
+    {
+        m_mode = -1;
+        if ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315" == alg)
+        {
+            m_mode = XML_C14N_1_0;
+            m_comments = false;
+        }
+        else if ("http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments" == alg)
+        {
+            m_mode = XML_C14N_1_0;
+            m_comments = true;
+        }
+        else if ("http://www.w3.org/2006/12/xml-c14n11" == alg)
+        {
+            m_mode = XML_C14N_1_1;
+            m_comments = false;
+        }
+        else if ("http://www.w3.org/2006/12/xml-c14n11#WithComments" == alg)
+        {
+            m_mode = XML_C14N_1_1;
+            m_comments = true;
+        }
+        else if ("http://www.w3.org/2001/10/xml-exc-c14n#" == alg)
+        {
+            m_mode = XML_C14N_EXCLUSIVE_1_0;
+            m_comments = false;
+        }
+        else if ("http://www.w3.org/2001/10/xml-exc-c14n#WithComments" == alg)
+        {
+            m_mode = XML_C14N_EXCLUSIVE_1_0;
+            m_comments = true;
+        }
+        return (-1 != m_mode) ? true : false;
+    }
+
+    virtual std::string Transform(const std::string& xml)
+    {
+        // TODO
+        return xml;
+    }
+
+    virtual void LoadFromXml(XmlUtils::CXmlNode& node)
+    {
+        // none
+        XML_UNUSED(node);
+    }
+};
+
+IXmlTransform* IXmlTransform::GetFromType(const std::string& alg)
+{
+    if (true)
+    {
+        CXmlTransformRelationship* transform = new CXmlTransformRelationship();
+        if (transform->m_algorithm == alg)
+            return transform;
+        RELEASEOBJECT(transform);
+    }
+    if (true)
+    {
+        CXmlTransformC14N* transform = new CXmlTransformC14N();
+        if (transform->CheckC14NTransform(alg))
+            return transform;
+        RELEASEOBJECT(transform);
+    }
+
+    return NULL;
+}
+
+class CXmlTransforms
+{
+protected:
+    std::vector<IXmlTransform*> m_transforms;
+    bool m_valid;
+
+public:
+    CXmlTransforms(XmlUtils::CXmlNode& node)
+    {
+        m_valid = true;
+
+        XmlUtils::CXmlNodes oNodes = node.GetNodes(L"Transform");
+        int nCount = oNodes.GetCount();
+        for (int i = 0; i < nCount; ++i)
+        {
+            XmlUtils::CXmlNode nodeTransform;
+            oNodes.GetAt(i, nodeTransform);
+
+            IXmlTransform* pTransform = IXmlTransform::GetFromType(nodeTransform.GetAttributeA("Algorithm"));
+            if (NULL == pTransform)
+            {
+                m_valid = false;
+                return;
+            }
+
+            pTransform->LoadFromXml(nodeTransform);
+            m_transforms.push_back(pTransform);
+        }
+    }
+
+    ~CXmlTransforms()
+    {
+        for (std::vector<IXmlTransform*>::iterator i = m_transforms.begin(); i != m_transforms.end(); i++)
+        {
+            IXmlTransform* t = *i;
+            RELEASEOBJECT(t);
+        }
+        m_transforms.clear();
+    }
+
+};
+
+#endif //_XML_TRANSFORM_H_

DesktopEditor/xmlsec/test/windows/test.pro

@@ -6,7 +6,9 @@ TEMPLATE = app
 CONFIG   += console
 CONFIG   -= app_bundle
 
-DEFINES += UNICODE
+DEFINES -= \
+    UNICODE \
+    _UNICODE
 
 CORE_ROOT_DIR = $$PWD/../../../..
 PWD_ROOT_DIR = $$PWD

DesktopEditor/xmlsec/test/windows_list_serts/main.cpp

@@ -1,6 +1,6 @@
-#include "../../src/XmlCanonicalizator.h"
-#include "../../src/XmlSigner_mscrypto.h"
+#include "../../src/XmlCertificate.h"
 #include "../../src/OOXMLSigner.h"
+#include "../../src/OOXMLVerifier.h"
 
 #pragma comment (lib, "crypt32.lib")
 #pragma comment (lib, "cryptui.lib")
@@ -12,17 +12,33 @@ void main(void)
     //std::wstring sSignId = L"{39B6B9C7-60AD-45A2-9F61-40C74A24042E}";
 
     std::wstring sFolderOOXML = L"D:\\555";
-    std::wstring sSignId = L"{9792D33F-AB37-4E5B-A465-481B9465818B}";
 
-    CCertificate_mscrypto oCertificate;
-    if (!oCertificate.ShowSelectDialog())
-        return;
+    if (false)
+    {
+        std::wstring sSignId = L"{9792D33F-AB37-4E5B-A465-481B9465818B}";
 
-    COOXMLSigner oOOXMLSigner(sFolderOOXML, &oCertificate);
+        CCertificate oCertificate;
+        if (!oCertificate.ShowSelectDialog())
+            return;
 
-    oOOXMLSigner.SetGuid(sSignId);
-    oOOXMLSigner.SetImageValid(NSFile::GetProcessDirectory() + L"/../../../resources/valid.png");
-    oOOXMLSigner.SetImageInvalid(NSFile::GetProcessDirectory() + L"/../../../resources/invalid.png");
+        COOXMLSigner oOOXMLSigner(sFolderOOXML, &oCertificate);
 
-    oOOXMLSigner.Sign();
+        oOOXMLSigner.SetGuid(sSignId);
+        oOOXMLSigner.SetImageValid(NSFile::GetProcessDirectory() + L"/../../../resources/valid.png");
+        oOOXMLSigner.SetImageInvalid(NSFile::GetProcessDirectory() + L"/../../../resources/invalid.png");
+
+        oOOXMLSigner.Sign();
+    }
+    else
+    {
+        COOXMLVerifier oVerifier(sFolderOOXML);
+
+        size_t nCount = oVerifier.m_arSignatures.size();
+        for (std::vector<COOXMLSignature*>::iterator i = oVerifier.m_arSignatures.begin(); i != oVerifier.m_arSignatures.end(); i++)
+        {
+            COOXMLSignature* pSign = *i;
+        }
+
+        XML_UNUSED(nCount);
+    }
 }

X2tConverter/build/Qt/X2tConverter.pri

@@ -7,7 +7,7 @@
 QT       -= core
 QT       -= gui
 
-VERSION = 2.4.455.0
+VERSION = 2.4.456.0
 DEFINES += INTVER=$$VERSION
 
 TARGET = x2t