fix vsdx binary

OOXML/Binary/Document/BinReader/BinaryReaderD.cpp

@@ -1570,7 +1570,7 @@ int Binary_pPrReader::Read_SecPr(BYTE type, long length, void* poResult)
 		pSectPr->m_oDocGrid.Init();
 		READ1_DEF(length, res, this->ReadDocGrid, pSectPr->m_oDocGrid.GetPointer());
 	}
-	else if (c_oSerProp_secPrType::docGrid == type)
+	else if (c_oSerProp_secPrType::bidi == type)
 	{
 		pSectPr->m_oBidi.Init();
 		pSectPr->m_oBidi->m_oVal.FromBool(m_oBufferedStream.GetBool());

OOXML/DocxFormat/WritingElement.h

@@ -1597,8 +1597,16 @@ namespace OOX
 		et_dr_PrimaryKey,
 		et_dr_RowKeyValue,
 		et_dr_RowMap,
+		et_dr_RefreshConflict,
+		et_dr_AutoLinkComparison,
+		et_dr_ADOData,
 		et_dr_Windows,
 		et_dr_Window,
+		et_dr_SnapAngles,
+		et_dr_SnapAngle,
+		et_dr_PublishSettings,
+		et_dr_PublishedPage,
+		et_dr_RefreshableData,
 		et_dr_Solutions,
 		et_dr_Solution,
 		et_dr_Issues,

OOXML/Projects/Windows/DocxFormatLib/DocxFormatLib.vcxproj.filters

@@ -582,6 +582,7 @@
     </ClInclude>
     <ClInclude Include="..\..\..\VsdxFormat\VisioOthers.h">
       <Filter>VsdxFormat</Filter>
+	</ClInclude>
     <ClInclude Include="..\..\..\XlsxFormat\Workbook\CustomsXml.h">
       <Filter>XlsxFormat\Workbook</Filter>
     </ClInclude>
@@ -1007,7 +1008,6 @@
     <ClCompile Include="..\..\..\XlsxFormat\Pivot\PivotHierarchies.cpp">
       <Filter>XlsxFormat\Pivots</Filter>
     </ClCompile>
-<<<<<<< HEAD
     <ClCompile Include="..\..\..\VsdxFormat\FileFactory_Draw.cpp">
       <Filter>VsdxFormat</Filter>
     </ClCompile>
@@ -1034,10 +1034,9 @@
     </ClCompile>
     <ClCompile Include="..\..\..\VsdxFormat\VisioOthers.cpp">
       <Filter>VsdxFormat</Filter>
-=======
+    </ClCompile>
     <ClCompile Include="..\..\..\XlsxFormat\Workbook\CustomsXml.cpp">
       <Filter>XlsxFormat\Workbook</Filter>
->>>>>>> origin/release/v9.0.0
     </ClCompile>
   </ItemGroup>
 </Project>

OOXML/VsdxFormat/Shapes.cpp

@@ -1039,9 +1039,12 @@ namespace OOX
 		void CCell::fromXML(XmlUtils::CXmlLiteReader& oReader)
 		{
 			ReadAttributes(oReader);
+			
 			if (oReader.IsEmptyNode())
 				return;
 
+			content = oReader.GetText2();
+
 			int nParentDepth = oReader.GetDepth();
 			while (oReader.ReadNextSiblingNode(nParentDepth))
 			{
@@ -1064,6 +1067,13 @@ namespace OOX
 			pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
 
 			pWriter->WriteRecord2(0, RefBy);
+			
+			if (false == content.empty())
+			{
+				pWriter->StartRecord(1);
+				pWriter->WriteString(content);
+				pWriter->EndRecord();
+			}
 		}
 		void CCell::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
 		{
@@ -1108,6 +1118,10 @@ namespace OOX
 					RefBy.Init();
 					RefBy->fromPPTY(pReader);
 				}break;
+				case 1:
+				{
+					content = pReader->GetString2();
+				}break;
 				default:
 				{
 					pReader->SkipRecord();
@@ -1130,6 +1144,11 @@ namespace OOX
 			if (RefBy.IsInit())
 				RefBy->toXmlWriter(pWriter);
 
+			if (false == content.empty())
+			{
+				pWriter->WriteStringXML(content);
+			}
+
 			pWriter->WriteNodeEnd(L"Cell");
 		}
 		EElementType CTrigger::getType() const

OOXML/VsdxFormat/Shapes.h

@@ -360,6 +360,8 @@ namespace OOX
 			nullable_string V;
 
 			nullable<CRefBy> RefBy;
+			
+			std::wstring content;
 		};
 		class CTrigger : public WritingElement
 		{

OOXML/VsdxFormat/VisioConnections.cpp

@@ -550,8 +550,13 @@ namespace Draw
 			}
 			else if (strcmp("RefreshConflict", sName) == 0) //unbounded
 			{
+				pItem = new CRefreshConflict();
 			}
 			else if (strcmp("AutoLinkComparison", sName) == 0) //unbounded
+			{
+				pItem = new CAutoLinkComparison();
+			}
+			else if (strcmp("ADOData", sName) == 0) //unbounded ???
 			{
 			}
 			if (pItem)
@@ -588,6 +593,8 @@ namespace Draw
 			{
 			case et_dr_PrimaryKey: type = 1; break;
 			case et_dr_RowMap: type = 2; break;
+			case et_dr_RefreshConflict: type = 3; break;
+			case et_dr_AutoLinkComparison: type = 4; break;
 			}
 			if (type != 0xff)
 				pWriter->WriteRecord2(type, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
@@ -689,6 +696,16 @@ namespace Draw
 				m_arrItems.push_back(new CRowMap());
 				m_arrItems.back()->fromPPTY(pReader);
 			}break;
+			case 3:
+			{
+				m_arrItems.push_back(new CRefreshConflict());
+				m_arrItems.back()->fromPPTY(pReader);
+			}break;
+			case 4:
+			{
+				m_arrItems.push_back(new CAutoLinkComparison());
+				m_arrItems.back()->fromPPTY(pReader);
+			}break;
 			case 5:
 			{
 				CRecordsetFile* pRecordset = new CRecordsetFile(NULL);
@@ -1291,5 +1308,131 @@ namespace Draw
 		pWriter->EndAttributes();
 		pWriter->WriteNodeEnd(L"RowMap");
 	}
+	EElementType CRefreshConflict::getType() const
+	{
+		return et_dr_RefreshConflict;
+	}
+	void CRefreshConflict::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+	{
+		WritingElement_ReadAttributes_StartChar_No_NS(oReader)
+			WritingElement_ReadAttributes_Read_ifChar(oReader, "RowID", RowID)
+			WritingElement_ReadAttributes_Read_else_ifChar(oReader, "PageID", PageID)
+			WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ShapeID", ShapeID)
+		WritingElement_ReadAttributes_EndChar_No_NS(oReader)
+	}
+	void CRefreshConflict::fromXML(XmlUtils::CXmlLiteReader& oReader)
+	{
+		ReadAttributes(oReader);
+		if (oReader.IsEmptyNode())
+			return;
+	}
+	void CRefreshConflict::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
+	{
+		pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
+		pWriter->WriteUInt2(0, RowID);
+		pWriter->WriteUInt2(1, PageID);
+		pWriter->WriteUInt2(2, ShapeID);
+		pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
+	}
+	void CRefreshConflict::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
+	{
+		LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
+		pReader->Skip(1); // start attributes
+		while (true)
+		{
+			BYTE _at = pReader->GetUChar_TypeNode();
+			if (_at == NSBinPptxRW::g_nodeAttributeEnd)
+				break;
+			switch (_at)
+			{
+			case 0:
+			{
+				RowID = pReader->GetULong();
+			}break;
+			case 1:
+			{
+				PageID = pReader->GetULong();
+			}break;
+			case 2:
+			{
+				ShapeID = pReader->GetULong();
+			}break;
+			}
+		}
+		pReader->Seek(_end_rec);
+	}
+	void CRefreshConflict::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
+	{
+		pWriter->StartNode(L"RefreshConflict");
+		pWriter->StartAttributes();
+		pWriter->WriteAttribute2(L"RowID", RowID);
+		pWriter->WriteAttribute2(L"PageID", PageID);
+		pWriter->WriteAttribute2(L"ShapeID", ShapeID);
+		pWriter->EndAttributes();
+		pWriter->WriteNodeEnd(L"RefreshConflict");
+	}
+	EElementType CAutoLinkComparison::getType() const
+	{
+		return et_dr_AutoLinkComparison;
+	}
+	void CAutoLinkComparison::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+	{
+		WritingElement_ReadAttributes_StartChar_No_NS(oReader)
+			WritingElement_ReadAttributes_Read_ifChar(oReader, "ColumnName", ColumnName)
+			WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ContextType", ContextType)
+			WritingElement_ReadAttributes_Read_else_ifChar(oReader, "ContextTypeLabel", ContextTypeLabel)
+		WritingElement_ReadAttributes_EndChar_No_NS(oReader)
+	}
+	void CAutoLinkComparison::fromXML(XmlUtils::CXmlLiteReader& oReader)
+	{
+		ReadAttributes(oReader);
+		if (oReader.IsEmptyNode())
+			return;
+	}
+	void CAutoLinkComparison::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
+	{
+		pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
+		pWriter->WriteString2(0, ColumnName);
+		pWriter->WriteUInt2(1, ContextType);
+		pWriter->WriteString2(2, ContextTypeLabel);
+		pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
+	}
+	void CAutoLinkComparison::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
+	{
+		LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
+		pReader->Skip(1); // start attributes
+		while (true)
+		{
+			BYTE _at = pReader->GetUChar_TypeNode();
+			if (_at == NSBinPptxRW::g_nodeAttributeEnd)
+				break;
+			switch (_at)
+			{
+			case 0:
+			{
+				ColumnName = pReader->GetString2();
+			}break;
+			case 1:
+			{
+				ContextType = pReader->GetULong();
+			}break;
+			case 2:
+			{
+				ContextTypeLabel = pReader->GetString2();
+			}break;
+			}
+		}
+		pReader->Seek(_end_rec);
+	}
+	void CAutoLinkComparison::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
+	{
+		pWriter->StartNode(L"AutoLinkComparison");
+		pWriter->StartAttributes();
+		pWriter->WriteAttribute2(L"ColumnName", ColumnName);
+		pWriter->WriteAttribute2(L"ContextType", ContextType);
+		pWriter->WriteAttribute2(L"ContextTypeLabel", ContextTypeLabel);
+		pWriter->EndAttributes();
+		pWriter->WriteNodeEnd(L"AutoLinkComparison");
+	}
 }
 } // namespace OOX

OOXML/VsdxFormat/VisioConnections.h

@@ -42,6 +42,58 @@ namespace OOX
 	{
 		class CRel;
 
+		class CAutoLinkComparison : public WritingElement
+		{
+		public:
+			WritingElement_AdditionMethods(CAutoLinkComparison)
+			CAutoLinkComparison() {}
+			virtual ~CAutoLinkComparison() {}
+
+			virtual std::wstring toXML() const { return L""; }
+
+			virtual void fromXML(XmlUtils::CXmlNode& node) {}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+
+			virtual EElementType getType() const;
+
+			virtual void fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader);
+			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const;
+			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const;
+
+		private:
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+
+		public:
+			nullable_string ColumnName;
+			nullable_uint ContextType;
+			nullable_string ContextTypeLabel;
+		};
+		class CRefreshConflict : public WritingElement
+		{
+		public:
+			WritingElement_AdditionMethods(CRefreshConflict)
+			CRefreshConflict() {}
+			virtual ~CRefreshConflict() {}
+
+			virtual std::wstring toXML() const { return L""; }
+
+			virtual void fromXML(XmlUtils::CXmlNode& node) {}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+
+			virtual EElementType getType() const;
+
+			virtual void fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader);
+			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const;
+			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const;
+
+		private:
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+
+		public:
+			nullable_uint RowID;
+			nullable_uint PageID;
+			nullable_uint ShapeID;
+		};
 		class CRowMap : public WritingElement
 		{
 		public:

OOXML/VsdxFormat/VisioDocument.cpp

@@ -43,6 +43,185 @@ namespace OOX
 {
 namespace Draw
 {
+	EElementType CPublishedPage::getType() const
+	{
+		return et_dr_PublishedPage;
+	}
+	void CPublishedPage::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+	{
+		WritingElement_ReadAttributes_StartChar_No_NS(oReader)
+			WritingElement_ReadAttributes_Read_ifChar(oReader, "ID", ID)
+		WritingElement_ReadAttributes_EndChar_No_NS(oReader)
+	}
+	void CPublishedPage::fromXML(XmlUtils::CXmlLiteReader& oReader)
+	{
+		ReadAttributes(oReader);
+		if (oReader.IsEmptyNode())
+			return;
+	}
+	void CPublishedPage::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
+	{
+		pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
+		pWriter->WriteUInt2(0, ID);
+		pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
+	}
+	void CPublishedPage::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
+	{
+		LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
+		pReader->Skip(1); // start attributes
+		while (true)
+		{
+			BYTE _at = pReader->GetUChar_TypeNode();
+			if (_at == NSBinPptxRW::g_nodeAttributeEnd)
+				break;
+			switch (_at)
+			{
+			case 0:
+			{
+				ID = pReader->GetULong();
+			}break;
+			}
+		}
+		pReader->Seek(_end_rec);
+	}
+	void CPublishedPage::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
+	{
+		pWriter->StartNode(L"PublishedPage");
+		pWriter->StartAttributes();
+		pWriter->WriteAttribute2(L"ID", ID);
+		pWriter->EndAttributes();
+		pWriter->WriteNodeEnd(L"PublishedPage");
+	}
+	EElementType CRefreshableData::getType() const
+	{
+		return et_dr_RefreshableData;
+	}
+	void CRefreshableData::ReadAttributes(XmlUtils::CXmlLiteReader& oReader)
+	{
+		WritingElement_ReadAttributes_StartChar_No_NS(oReader)
+			WritingElement_ReadAttributes_Read_ifChar(oReader, "ID", ID)
+		WritingElement_ReadAttributes_EndChar_No_NS(oReader)
+	}
+	void CRefreshableData::fromXML(XmlUtils::CXmlLiteReader& oReader)
+	{
+		ReadAttributes(oReader);
+		if (oReader.IsEmptyNode())
+			return;
+	}
+	void CRefreshableData::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
+	{
+		pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
+		pWriter->WriteUInt2(0, ID);
+		pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
+	}
+	void CRefreshableData::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
+	{
+		LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
+		pReader->Skip(1); // start attributes
+		while (true)
+		{
+			BYTE _at = pReader->GetUChar_TypeNode();
+			if (_at == NSBinPptxRW::g_nodeAttributeEnd)
+				break;
+			switch (_at)
+			{
+			case 0:
+			{
+				ID = pReader->GetULong();
+			}break;
+			}
+		}
+		pReader->Seek(_end_rec);
+	}
+	void CRefreshableData::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
+	{
+		pWriter->StartNode(L"RefreshableData");
+		pWriter->StartAttributes();
+		pWriter->WriteAttribute2(L"ID", ID);
+		pWriter->EndAttributes();
+		pWriter->WriteNodeEnd(L"RefreshableData");
+	}
+	EElementType CPublishSettings::getType() const
+	{
+		return et_dr_PublishSettings;
+	}
+	void CPublishSettings::fromXML(XmlUtils::CXmlLiteReader& oReader)
+	{
+		if (oReader.IsEmptyNode())
+			return;
+
+		int nParentDepth = oReader.GetDepth();
+		while (oReader.ReadNextSiblingNode(nParentDepth))
+		{
+			std::wstring sName = oReader.GetName();
+
+			WritingElement* pItem = NULL;
+			if (L"PublishedPage" == sName)
+			{
+				pItem = new CPublishedPage();
+			}
+			else if (L"RefreshableData" == sName)
+			{
+				pItem = new CRefreshableData();
+			}
+			if (pItem)
+			{
+				pItem->fromXML(oReader);
+				m_arrItems.push_back(pItem);
+			}
+		}
+	}
+	void CPublishSettings::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
+	{
+		for (size_t i = 0; i < m_arrItems.size(); ++i)
+		{
+			int type = 0xff;					 //todooo predefine type for ???
+			switch (m_arrItems[i]->getType())
+			{
+			case et_dr_PublishedPage: type = 0; break;
+			case et_dr_RefreshableData: type = 1; break;
+			}
+			if (type != 0xff)
+				pWriter->WriteRecord2(type, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
+		}
+	}
+	void CPublishSettings::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
+	{
+		LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
+		while (pReader->GetPos() < _end_rec)
+		{
+			BYTE _rec = pReader->GetUChar();
+			switch (_rec)
+			{
+			case 0:
+			{
+				m_arrItems.push_back(new CPublishedPage());
+				m_arrItems.back()->fromPPTY(pReader);
+			}break;
+			case 1:
+			{
+				m_arrItems.push_back(new CRefreshableData());
+				m_arrItems.back()->fromPPTY(pReader);
+			}break;
+			default:
+			{
+				pReader->SkipRecord();
+			}break;
+			}
+		}
+		pReader->Seek(_end_rec);
+	}
+	void CPublishSettings::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
+	{
+		pWriter->StartNode(L"PublishSettings");
+		pWriter->EndAttributes();
+
+		for (size_t i = 0; i < m_arrItems.size(); ++i)
+			m_arrItems[i]->toXmlWriter(pWriter);
+
+		pWriter->WriteNodeEnd(L"PublishSettings");
+	}
+//----------------------------------------------------------------------------------------------------------------
 	EElementType CHeaderFooter::getType() const
 	{
 		return et_dr_HeaderFooter;
@@ -1573,6 +1752,107 @@ namespace Draw
 
 		pWriter->WriteNodeEnd(L"VisioDocument");
 	}
+	//-----------------------------------------------------------------------------------------------------------------------------
+	EElementType CSnapAngle::getType() const
+	{
+		return et_dr_SnapAngle;
+	}
+	void CSnapAngle::fromXML(XmlUtils::CXmlLiteReader& oReader)
+	{
+		if (oReader.IsEmptyNode())
+			return;
+
+		content = oReader.GetText2();
+	}
+	void CSnapAngle::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
+	{
+		pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeStart);
+		pWriter->WriteDoubleReal2(0, content);
+		pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
+	}
+	void CSnapAngle::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
+	{
+		LONG _end_rec = pReader->GetPos() + pReader->GetRecordSize() + 4;
+		pReader->Skip(1); // start attributes
+		while (true)
+		{
+			BYTE _at = pReader->GetUChar_TypeNode();
+			if (_at == NSBinPptxRW::g_nodeAttributeEnd)
+				break;
+			switch (_at)
+			{
+			case 0:
+			{
+				content = pReader->GetDoubleReal();
+			}break;
+			}
+		}
+		pReader->Seek(_end_rec);
+	}
+	void CSnapAngle::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
+	{
+		pWriter->WriteNodeValue(L"SnapAngle", content);
+	}
+//-----------------------------------------------------------------------------------------------------------------------------
+	void CSnapAngles::fromXML(XmlUtils::CXmlLiteReader& oReader)
+	{
+		if (oReader.IsEmptyNode())
+			return;
+		int nParentDepth = oReader.GetDepth();
+		while (oReader.ReadNextSiblingNode(nParentDepth))
+		{
+			std::wstring sName = oReader.GetName();
+
+			if (L"SnapAngle" == sName)
+			{
+				CSnapAngle* pItem = new CSnapAngle();
+				*pItem = oReader;
+
+				if (pItem)
+					m_arrItems.push_back(pItem);
+			}
+		}
+	}
+	EElementType CSnapAngles::getType() const
+	{
+		return et_dr_SnapAngles;
+	}
+	void CSnapAngles::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
+	{
+		LONG end = pReader->GetPos() + pReader->GetRecordSize() + 4;
+		while (pReader->GetPos() < end)
+		{
+			BYTE _rec = pReader->GetUChar();
+			switch (_rec)
+			{
+			case 0:
+			{
+				m_arrItems.push_back(new CSnapAngle());
+				m_arrItems.back()->fromPPTY(pReader);
+			}break;
+			default:
+			{
+				pReader->SkipRecord();
+			}break;
+			}
+		}
+		pReader->Seek(end);
+	}
+	void CSnapAngles::toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const
+	{
+		for (size_t i = 0; i < m_arrItems.size(); ++i)
+			pWriter->WriteRecord2(0, dynamic_cast<OOX::WritingElement*>(m_arrItems[i]));
+	}
+	void CSnapAngles::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
+	{
+		pWriter->StartNode(L"SnapAngles");
+		pWriter->EndAttributes();
+
+		for (size_t i = 0; i < m_arrItems.size(); ++i)
+			m_arrItems[i]->toXmlWriter(pWriter);
+
+		pWriter->WriteNodeEnd(L"SnapAngles");
+	}
 //-----------------------------------------------------------------------------------------------------------------------------
 	EElementType CWindow::getType() const
 	{
@@ -1645,7 +1925,7 @@ namespace Draw
 			}
 			else if (L"SnapAngles" == sName)
 			{
-				SnapAngles = oReader.GetText2();
+				SnapAngles = oReader;
 			}
 			else if (L"DynamicGridEnabled" == sName)
 			{
@@ -1694,12 +1974,13 @@ namespace Draw
 		pWriter->WriteUInt2(22, GlueSettings);
 		pWriter->WriteUInt2(23, SnapSettings);
 		pWriter->WriteUInt2(24, SnapExtensions);
-		pWriter->WriteBool2(25, SnapAngles);
 		pWriter->WriteBool2(26, DynamicGridEnabled);
 		pWriter->WriteDoubleReal2(27, TabSplitterPos);
 		pWriter->WriteUInt2(28, StencilGroup);
 		pWriter->WriteUInt2(29, StencilGroupPos);
 		pWriter->WriteBYTE(NSBinPptxRW::g_nodeAttributeEnd);
+		
+		pWriter->WriteRecord2(0, SnapAngles);
 	}
 
 	void CWindow::fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader)
@@ -1727,11 +2008,11 @@ namespace Draw
 			}break;
 			case 3:
 			{
-				WindowLeft = pReader->GetULong();
+				WindowLeft = pReader->GetLong();
 			}break;
 			case 4:
 			{
-				WindowTop = pReader->GetULong();
+				WindowTop = pReader->GetLong();
 			}break;
 			case 5:
 			{
@@ -1813,10 +2094,6 @@ namespace Draw
 			{
 				SnapExtensions = pReader->GetULong();
 			}break;
-			case 25:
-			{
-				SnapAngles = pReader->GetBool();
-			}break;
 			case 26:
 			{
 				DynamicGridEnabled = pReader->GetBool();
@@ -1835,6 +2112,23 @@ namespace Draw
 			}break;
 			}
 		}
+		while (pReader->GetPos() < _end_rec)
+		{
+			BYTE _rec = pReader->GetUChar();
+
+			switch (_rec)
+			{
+			case 0:
+			{
+				SnapAngles.Init();
+				SnapAngles->fromPPTY(pReader);
+			}break;
+			default:
+			{
+				pReader->SkipRecord();
+			}break;
+			}
+		}
 		pReader->Seek(_end_rec);
 	}
 	void CWindow::toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
@@ -1870,12 +2164,14 @@ namespace Draw
 		pWriter->WriteNodeValue(L"GlueSettings", GlueSettings);
 		pWriter->WriteNodeValue(L"SnapSettings", SnapSettings);
 		pWriter->WriteNodeValue(L"SnapExtensions", SnapExtensions);
-		pWriter->WriteNodeValue(L"SnapAngles", SnapAngles);
 		pWriter->WriteNodeValue(L"DynamicGridEnabled", DynamicGridEnabled);
 		pWriter->WriteNodeValue(L"TabSplitterPos", TabSplitterPos);
 		pWriter->WriteNodeValue(L"StencilGroup", StencilGroup);
 		pWriter->WriteNodeValue(L"StencilGroupPos", StencilGroupPos);
 
+		if (SnapAngles.IsInit())
+			SnapAngles->toXmlWriter(pWriter);
+
 		pWriter->WriteNodeEnd(L"Window");
 	}
 //-----------------------------------------------------------------------------------------------------------------------------

OOXML/VsdxFormat/VisioDocument.h

@@ -41,6 +41,75 @@ namespace OOX
 {
 	namespace Draw
 	{
+		class CPublishedPage : public WritingElement
+		{
+		public:
+			WritingElement_AdditionMethods(CPublishedPage)
+
+			CPublishedPage() {}
+			virtual ~CPublishedPage() {}
+
+			virtual std::wstring toXML() const { return L""; }
+
+			virtual void fromXML(XmlUtils::CXmlNode& node) {}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+
+			virtual EElementType getType() const;
+
+			virtual void fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader);
+			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const;
+			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const;
+
+		private:
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+
+		public:
+			nullable_uint ID;
+		};
+		class CRefreshableData : public WritingElement
+		{
+		public:
+			WritingElement_AdditionMethods(CRefreshableData)
+
+			CRefreshableData() {}
+			virtual ~CRefreshableData() {}
+
+			virtual std::wstring toXML() const { return L""; }
+
+			virtual void fromXML(XmlUtils::CXmlNode& node) {}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+
+			virtual EElementType getType() const;
+
+			virtual void fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader);
+			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const;
+			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const;
+
+		private:
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+
+		public:
+			nullable_uint ID;
+		};
+		class CPublishSettings : public WritingElementWithChilds<>
+		{
+		public:
+			WritingElement_AdditionMethods(CPublishSettings)
+			CPublishSettings() {}
+			virtual ~CPublishSettings() {}
+
+			virtual void fromXML(XmlUtils::CXmlNode& node) {}
+			virtual std::wstring toXML() const { return L""; }
+
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const;
+
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+
+			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const;
+			virtual void fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader);
+			virtual EElementType getType() const;
+		};
 		class CDocumentSettings : public WritingElement
 		{
 		public:
@@ -327,6 +396,46 @@ namespace OOX
 			nullable_string HeaderFooterColor;
 
 		};
+		class CSnapAngle : public WritingElement
+		{
+		public:
+			WritingElement_AdditionMethods(CSnapAngle)
+
+			CSnapAngle() {}
+			virtual ~CSnapAngle() {}
+
+			virtual std::wstring toXML() const { return L""; }
+
+			virtual void fromXML(XmlUtils::CXmlNode& node) {}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+
+			virtual EElementType getType() const;
+
+			virtual void fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader);
+			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const;
+			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const;
+		public:
+			nullable_double content;
+		};
+		class CSnapAngles : public WritingElementWithChilds<CSnapAngle>	
+		{
+		public:
+			WritingElement_AdditionMethods(CSnapAngles)
+			CSnapAngles() {}
+			virtual ~CSnapAngles() {}
+
+			virtual std::wstring toXML() const { return L""; }
+			virtual void fromXML(XmlUtils::CXmlNode& node) {}
+			virtual void fromXML(XmlUtils::CXmlLiteReader& oReader);
+			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const;
+
+			void ReadAttributes(XmlUtils::CXmlLiteReader& oReader);
+
+			virtual EElementType getType() const;
+
+			virtual void fromPPTY(NSBinPptxRW::CBinaryFileReader* pReader);
+			virtual void toPPTY(NSBinPptxRW::CBinaryFileWriter* pWriter) const;
+		};
 		class CWindow : public WritingElement
 		{
 		public:
@@ -372,11 +481,12 @@ namespace OOX
 			nullable_uint GlueSettings;
 			nullable_uint SnapSettings;
 			nullable_uint SnapExtensions;
-			nullable_bool SnapAngles;
 			nullable_bool DynamicGridEnabled;
 			nullable_double TabSplitterPos;
 			nullable_uint StencilGroup;
 			nullable_uint StencilGroupPos;
+			
+			nullable<CSnapAngles> SnapAngles;
 		};
 		class CWindows : public WritingElementWithChilds<CWindow>
 		{
@@ -431,7 +541,7 @@ namespace OOX
 			nullable<CDocumentSheet> DocumentSheet;
 			nullable<CEventList> EventList;
 			nullable<CHeaderFooter> HeaderFooter;
-			//nullable<CPublishSettings> PublishSettings;
+			nullable<CPublishSettings> PublishSettings;
 		};
 		class CWindowsFile : public OOX::File
 		{