XlsFormat - ...

# Conflicts:
#	X2tConverter/src/cextracttools.h

ASCOfficeDocFile/DocDocxConverter/IVisitable.h

@@ -33,6 +33,8 @@
 
 #include "IMapping.h"
 
+#define GETBITS(from, numL, numH) ((from & (((1 << (numH - numL + 1)) - 1) << numL)) >> numL)
+
 namespace DocFileFormat
 {
     class IVisitable

ASCOfficeDocFile/DocDocxConverter/NumberingMapping.cpp

@@ -582,7 +582,7 @@ namespace DocFileFormat
 // The style id is used for a reverse reference. 
 // It can happen that the reference points to the wrong style.
 
-		if (styleIndex != ListData::ISTD_NIL)
+		if (styleIndex != ListData::ISTD_NIL && styleIndex < m_document->Styles->Styles->size())
 		{
             m_pXmlWriter->WriteNodeBegin( L"w:pStyle", TRUE );
             m_pXmlWriter->WriteAttribute( L"w:val", FormatUtils::XmlEncode(StyleSheetMapping::MakeStyleId(m_document->Styles->Styles->at(styleIndex))));

ASCOfficeDocFile/DocDocxConverter/PropertiesMapping.cpp

@@ -462,57 +462,60 @@ namespace DocFileFormat
 
     void PropertiesMapping::appendShading( XMLTools::XMLElement* parent, const ShadingDescriptor& desc )
 	{
+		std::wstring pattern = getShadingPattern( desc );
         if ( ( parent != NULL ) && ( desc.shadingSpecialValue == shadingSpecialValueNormal ))
 		{
             XMLTools::XMLElement shd( L"w:shd" );
 
-			//fill color
-            XMLTools::XMLAttribute fill( L"w:fill" );
-
-			if ( desc.shadingType == shadingTypeShd )
-			{
-				if ( desc.cvBackAuto )
-				{
-                    fill.SetValue( L"auto" );
-				}
-				else
-				{
-                    fill.SetValue( RGBColor( (int)desc.cvBack, RedLast ).SixDigitHexCode);
-				}
-			}
-			else
-			{
-                fill.SetValue( FormatUtils::MapValueToWideString( desc.icoBack, &Global::ColorIdentifier[0][0], 17, 12 ));
-			}
-
-			shd.AppendAttribute( fill );
-
-			//foreground color
-            XMLTools::XMLAttribute color( L"w:color" );
-
-			if ( desc.shadingType == shadingTypeShd )
-			{
-				if ( desc.cvForeAuto )
-				{
-                    color.SetValue( L"auto" );
-				}
-				else
-				{
-                    color.SetValue( RGBColor( (int)desc.cvFore, RedLast ).SixDigitHexCode);
-				}
-			}
-			else
-			{
-                color.SetValue( FormatUtils::MapValueToWideString( desc.icoFore, &Global::ColorIdentifier[0][0], 17, 12 ));
-			}
-
-			shd.AppendAttribute( color );
-
 			//pattern
             XMLTools::XMLAttribute val( L"w:val" );
-            val.SetValue( getShadingPattern( desc ));
+            val.SetValue( pattern);
 			shd.AppendAttribute( val );
 
+			if (pattern != L"nil")
+			{
+				//fill color
+				XMLTools::XMLAttribute fill( L"w:fill" );
+
+				if ( desc.shadingType == shadingTypeShd )
+				{
+					if ( desc.cvBackAuto )
+					{
+						fill.SetValue( L"auto" );
+					}
+					else
+					{
+						fill.SetValue( RGBColor( (int)desc.cvBack, RedLast ).SixDigitHexCode);
+					}
+				}
+				else
+				{
+					fill.SetValue( FormatUtils::MapValueToWideString( desc.icoBack, &Global::ColorIdentifier[0][0], 17, 12 ));
+				}
+
+				shd.AppendAttribute( fill );
+
+				//foreground color
+				XMLTools::XMLAttribute color( L"w:color" );
+
+				if ( desc.shadingType == shadingTypeShd )
+				{
+					if ( desc.cvForeAuto )
+					{
+						color.SetValue( L"auto" );
+					}
+					else
+					{
+						color.SetValue( RGBColor( (int)desc.cvFore, RedLast ).SixDigitHexCode);
+					}
+				}
+				else
+				{
+					color.SetValue( FormatUtils::MapValueToWideString( desc.icoFore, &Global::ColorIdentifier[0][0], 17, 12 ));
+				}
+
+				shd.AppendAttribute( color );
+			}
             parent->RemoveChildByName( L"w:shd" );
 			parent->AppendChild( shd );
 		}

ASCOfficeDocFile/DocDocxConverter/ShadingDescriptor.h

@@ -174,9 +174,9 @@ namespace DocFileFormat
 					//it's a Word 97 SPRM
 					short val	=	FormatUtils::BytesToInt16(bytes, 0, size);
 
-					icoFore		=	(val & 0x1F);						
-					icoBack		=	((val >> 5) & 0x1F);					
-					ipat		=	(ShadingPattern) ((val >> 10) & 0x3F);
+					icoFore		=	GETBITS(val, 0, 4);						
+					icoBack		=	GETBITS(val, 5, 9);						
+					ipat		=	(ShadingPattern) GETBITS(val, 10, 15);	
 
 					shadingType	=	shadingTypeShd80;
 
@@ -209,7 +209,7 @@ namespace DocFileFormat
 						else if (0x0F == icoFore) { cvFore = RGB2 (0x80, 0x80, 0x80); }
 						else if (0x10 == icoFore) { cvFore = RGB2 (0xC0, 0xC0, 0xC0); }
 
-						if (0x00 == icoBack)	{ cvBack = RGB2 (0x00, 0x00, 0x00); cvBackAuto = true; }
+						if (0x00 == icoBack)	{ cvBack = RGB2 (0xFF, 0xFF, 0xFF); cvBackAuto = true; }
 						else if (0x01 == icoBack) { cvBack = RGB2 (0x00, 0x00, 0x00); }
 						else if (0x02 == icoBack) { cvBack = RGB2 (0x00, 0x00, 0xFF); }
 						else if (0x03 == icoBack) { cvBack = RGB2 (0x00, 0xFF, 0xFF); }

ASCOfficeDocFile/DocDocxConverter/TableCellPropertiesMapping.cpp

@@ -354,7 +354,7 @@ namespace DocFileFormat
 
 	void TableCellPropertiesMapping::apppendCellShading (unsigned char* sprmArg, int size, int cellIndex)
 	{
-		if (sprmArg)
+		if (sprmArg && cellIndex >= 0)
 		{
 			//shading descriptor can have 10 bytes (Word 2000) or 2 bytes (Word 97)
 			int shdLength = 2;

ASCOfficeDocFile/DocFormatTest/DocFormatTest.cpp

@@ -49,6 +49,8 @@
 	#pragma comment(lib, "../../build/bin/icu/win_32/icuuc.lib")
 #endif
 
+#pragma comment(lib, "Rpcrt4.lib")
+
 HRESULT convert_single(std::wstring sSrcDoc)
 {
 	HRESULT hr = S_OK;

ASCOfficeDocxFile2/BinReader/HeaderFooterWriter.h

@@ -100,10 +100,10 @@ xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\"
 mc:Ignorable=\"w14 wp14\">");
     static  std::wstring g_string_ftr_End = _T("</w:ftr>");
 
-    static  std::wstring g_string_footnotes_Start = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><w:footnotes xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" mc:Ignorable=\"w14 wp14\">");
+    static  std::wstring g_string_footnotes_Start = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><w:footnotes xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" mc:Ignorable=\"w14 wp14\">");
     static  std::wstring g_string_footnotes_End = _T("</w:footnotes>");
 
-    static  std::wstring g_string_endnotes_Start = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><w:endnotes xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" mc:Ignorable=\"w14 wp14\">");
+    static  std::wstring g_string_endnotes_Start = _T("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?><w:endnotes xmlns:wpc=\"http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas\" xmlns:mc=\"http://schemas.openxmlformats.org/markup-compatibility/2006\" xmlns:o=\"urn:schemas-microsoft-com:office:office\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\" xmlns:v=\"urn:schemas-microsoft-com:vml\" xmlns:wp14=\"http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing\" xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\" xmlns:w10=\"urn:schemas-microsoft-com:office:word\" xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" xmlns:wpg=\"http://schemas.microsoft.com/office/word/2010/wordprocessingGroup\" xmlns:wpi=\"http://schemas.microsoft.com/office/word/2010/wordprocessingInk\" xmlns:wne=\"http://schemas.microsoft.com/office/word/2006/wordml\" xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\" xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" mc:Ignorable=\"w14 wp14\">");
     static  std::wstring g_string_endnotes_End = _T("</w:endnotes>");
 
 	class HeaderFooterWriter 

ASCOfficeDocxFile2/BinReader/Readers.h

@@ -3734,6 +3734,18 @@ public:
             res = Read2(length, &Binary_DocumentTableReader::Read_Background, this, &oBackground);
             m_oDocumentWriter.m_oBackground.WriteString(oBackground.Write());
         }
+		else if ( c_oSerParType::BookmarkStart == type )
+		{
+			OOX::Logic::CBookmarkStart oBookmarkStart;
+			res = Read1(length, &Binary_DocumentTableReader::ReadBookmarkStart, this, &oBookmarkStart);
+			m_oDocumentWriter.m_oContent.WriteString(oBookmarkStart.toXML());
+		}
+		else if ( c_oSerParType::BookmarkEnd == type )
+		{
+			OOX::Logic::CBookmarkEnd oBookmarkEnd;
+			res = Read1(length, &Binary_DocumentTableReader::ReadBookmarkEnd, this, &oBookmarkEnd);
+			m_oDocumentWriter.m_oContent.WriteString(oBookmarkEnd.toXML());
+		}
 		else
 			res = c_oSerConstants::ReadUnknown;
 		return res;
@@ -3872,6 +3884,18 @@ public:
 			SdtWraper oSdt(1);
 			res = Read1(length, &Binary_DocumentTableReader::ReadSdt, this, &oSdt);
 		}
+		else if ( c_oSerParType::BookmarkStart == type )
+		{
+			OOX::Logic::CBookmarkStart oBookmarkStart;
+			res = Read1(length, &Binary_DocumentTableReader::ReadBookmarkStart, this, &oBookmarkStart);
+			m_oDocumentWriter.m_oContent.WriteString(oBookmarkStart.toXML());
+		}
+		else if ( c_oSerParType::BookmarkEnd == type )
+		{
+			OOX::Logic::CBookmarkEnd oBookmarkEnd;
+			res = Read1(length, &Binary_DocumentTableReader::ReadBookmarkEnd, this, &oBookmarkEnd);
+			m_oDocumentWriter.m_oContent.WriteString(oBookmarkEnd.toXML());
+		}
 		else
 			res = c_oSerConstants::ReadUnknown;
 		return res;
@@ -4267,6 +4291,57 @@ public:
 			res = c_oSerConstants::ReadUnknown;
 		return res;
 	}
+	int ReadBookmarkStart(BYTE type, long length, void* poResult)
+	{
+		int res = c_oSerConstants::ReadOk;
+		OOX::Logic::CBookmarkStart* pBookmarkStart = static_cast<OOX::Logic::CBookmarkStart*>(poResult);
+		if ( c_oSerBookmark::Id == type )
+		{
+			pBookmarkStart->m_oId.Init();
+			pBookmarkStart->m_oId->SetValue(m_oBufferedStream.GetLong());
+		}
+		else if ( c_oSerBookmark::Name == type )
+		{
+			pBookmarkStart->m_sName.Init();
+			pBookmarkStart->m_sName->append(m_oBufferedStream.GetString3(length));
+		}
+		else if ( c_oSerBookmark::DisplacedByCustomXml == type )
+		{
+			pBookmarkStart->m_oDisplacedByCustomXml.Init();
+			pBookmarkStart->m_oDisplacedByCustomXml->SetValue((SimpleTypes::EDisplacedByCustomXml)m_oBufferedStream.GetUChar());
+		}
+		else if ( c_oSerBookmark::ColFirst == type )
+		{
+			pBookmarkStart->m_oColFirst.Init();
+			pBookmarkStart->m_oColFirst->SetValue(m_oBufferedStream.GetLong());
+		}
+		else if ( c_oSerBookmark::ColLast == type )
+		{
+			pBookmarkStart->m_oColLast.Init();
+			pBookmarkStart->m_oColLast->SetValue(m_oBufferedStream.GetLong());
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
+	int ReadBookmarkEnd(BYTE type, long length, void* poResult)
+	{
+		int res = c_oSerConstants::ReadOk;
+		OOX::Logic::CBookmarkEnd* pBookmarkEnd = static_cast<OOX::Logic::CBookmarkEnd*>(poResult);
+		if ( c_oSerBookmark::Id == type )
+		{
+			pBookmarkEnd->m_oId.Init();
+			pBookmarkEnd->m_oId->SetValue(m_oBufferedStream.GetLong());
+		}
+		else if ( c_oSerBookmark::DisplacedByCustomXml == type )
+		{
+			pBookmarkEnd->m_oDisplacedByCustomXml.Init();
+			pBookmarkEnd->m_oDisplacedByCustomXml->SetValue((SimpleTypes::EDisplacedByCustomXml)m_oBufferedStream.GetUChar());
+		}
+		else
+			res = c_oSerConstants::ReadUnknown;
+		return res;
+	}
 
 	int ReadHyperlink(BYTE type, long length, void* poResult)
 	{		
@@ -4460,6 +4535,18 @@ public:
 			res = Read1(length, &Binary_DocumentTableReader::ReadMathSSup, this, poResult);
             GetRunStringWriter().WriteString(std::wstring(_T("</m:sSup>")));
 		}
+		else if ( c_oSer_OMathContentType::BookmarkStart == type )
+		{
+			OOX::Logic::CBookmarkStart oBookmarkStart;
+			res = Read1(length, &Binary_DocumentTableReader::ReadBookmarkStart, this, &oBookmarkStart);
+			GetRunStringWriter().WriteString(oBookmarkStart.toXML());
+		}
+		else if ( c_oSer_OMathContentType::BookmarkEnd == type )
+		{
+			OOX::Logic::CBookmarkEnd oBookmarkEnd;
+			res = Read1(length, &Binary_DocumentTableReader::ReadBookmarkEnd, this, &oBookmarkEnd);
+			GetRunStringWriter().WriteString(oBookmarkEnd.toXML());
+		}
 		else
 			res = c_oSerConstants::ReadUnknown;
 		return res;
@@ -6923,6 +7010,18 @@ public:
 			SdtWraper oSdt(2);
 			res = Read1(length, &Binary_DocumentTableReader::ReadSdt, this, &oSdt);
 		}
+		else if (c_oSerDocTableType::BookmarkStart == type)
+		{
+			OOX::Logic::CBookmarkStart oBookmarkStart;
+			res = Read1(length, &Binary_DocumentTableReader::ReadBookmarkStart, this, &oBookmarkStart);
+			pCStringWriter->WriteString(oBookmarkStart.toXML());
+		}
+		else if (c_oSerDocTableType::BookmarkEnd == type)
+		{
+			OOX::Logic::CBookmarkEnd oBookmarkEnd;
+			res = Read1(length, &Binary_DocumentTableReader::ReadBookmarkEnd, this, &oBookmarkEnd);
+			pCStringWriter->WriteString(oBookmarkEnd.toXML());
+		}
 		else
 			res = c_oSerConstants::ReadUnknown;
 		return res;
@@ -6960,6 +7059,18 @@ public:
 			SdtWraper oSdt(3);
 			res = Read1(length, &Binary_DocumentTableReader::ReadSdt, this, &oSdt);
 		}
+		else if (c_oSerDocTableType::BookmarkStart == type)
+		{
+			OOX::Logic::CBookmarkStart oBookmarkStart;
+			res = Read1(length, &Binary_DocumentTableReader::ReadBookmarkStart, this, &oBookmarkStart);
+			pCStringWriter->WriteString(oBookmarkStart.toXML());
+		}
+		else if (c_oSerDocTableType::BookmarkEnd == type)
+		{
+			OOX::Logic::CBookmarkEnd oBookmarkEnd;
+			res = Read1(length, &Binary_DocumentTableReader::ReadBookmarkEnd, this, &oBookmarkEnd);
+			pCStringWriter->WriteString(oBookmarkEnd.toXML());
+		}
 		else
 			res = c_oSerConstants::ReadUnknown;
 		return res;

ASCOfficeDocxFile2/BinWriter/BinEquationWriter.h

@@ -144,9 +144,13 @@ namespace MathEquation
 			void AddAccent (MEMBELTYPE eType)
 			{
 				LONG lPos = GetSize() - 1;
+
+				if (lPos < 0) return;
+				
 				EquationRun oRun;
 				oRun = arrRun[lPos];
 				RemoveElem(lPos);
+				
 				oRun.bAccent = true;
 				oRun.eType = eType;
 				Add(oRun);
@@ -1675,7 +1679,7 @@ namespace MathEquation
 
 			void WriteEndNode(BinaryEquationWriter* pWriter)
 			{
-				int nCurPos;
+				int nCurPos = -1;
 				if (!m_aBaseStack.empty())
 				{
 					nCurPos = m_aBaseStack.top();
@@ -1687,14 +1691,20 @@ namespace MathEquation
 				}
 
 				if (bPile && bEqArrayStart)
+				{
 					pWriter->WriteItemEnd(nCurPos);
+				}
 				else if (!bPile && !bEqArrayStart)
+				{
 					pWriter->WriteItemEnd(nCurPos);
+				}
 				else if (!bPile && bEqArrayStart)
 				{					
 					pWriter->m_aRowsCounter.push(nRows);
 					bEqArrayStart = false;
-					pWriter->WriteItemEnd(nCurPos);//eqArr
+					
+					if (nCurPos > 0)
+						pWriter->WriteItemEnd(nCurPos);//eqArr
 
 					if (!m_aBaseStack.empty())
 					{

ASCOfficeDocxFile2/BinWriter/BinReaderWriterDefines.h

@@ -476,7 +476,9 @@ extern int g_nCurFormatVersion;
 		MoveFromRangeStart = 18,
 		MoveFromRangeEnd = 19,
 		MoveToRangeStart = 20,
-		MoveToRangeEnd = 21
+		MoveToRangeEnd = 21,
+		BookmarkStart = 22,
+		BookmarkEnd = 23
 	};}
 	namespace c_oSerDocTableType{enum c_oSerDocTableType
 	{
@@ -491,7 +493,9 @@ extern int g_nCurFormatVersion;
 		Cell_Pr =  7,
 		Cell_Content =  8,
 		tblGridChange = 9,
-		Sdt = 10
+		Sdt = 10,
+		BookmarkStart = 11,
+		BookmarkEnd = 12
 	};}
 	namespace c_oSerRunType{enum c_oSerRunType
 	{
@@ -900,7 +904,9 @@ extern int g_nCurFormatVersion;
 		Ins = 62,
 		Del = 63,
 		columnbreak = 64,
-		ARPr = 65
+		ARPr = 65,
+		BookmarkStart = 66,
+		BookmarkEnd = 67
 	};}
 	namespace c_oSer_FramePrType{ enum c_oSer_FramePrType
 	{		
@@ -1105,6 +1111,14 @@ extern int g_nCurFormatVersion;
 		Name = 6,
 		UserId = 7
 	};}
+	namespace c_oSerBookmark{enum c_oSerBookmark
+	{
+		Id = 0,
+		Name = 1,
+		DisplacedByCustomXml = 2,
+		ColFirst = 3,
+		ColLast = 4
+	};}
 }
 
 #endif	// #ifndef DOCX_BIN_READER_WRITER_DEFINES

ASCOfficeDocxFile2/BinWriter/BinWriters.h

@@ -3076,6 +3076,20 @@ namespace BinDocxRW
 						OOX::Logic::CBdo* pBdo = static_cast<OOX::Logic::CBdo*>(item);
 						WriteDocumentContent(pBdo->m_arrItems);
 					}break;
+					case OOX::et_w_bookmarkStart:
+					{
+						OOX::Logic::CBookmarkStart* pBookmarkStart = static_cast<OOX::Logic::CBookmarkStart*>(item);
+						nCurPos = m_oBcw.WriteItemStart(c_oSerParType::BookmarkStart);
+						WriteBookmarkStart(*pBookmarkStart);
+						m_oBcw.WriteItemWithLengthEnd(nCurPos);
+					}break;
+					case OOX::et_w_bookmarkEnd:
+					{
+						OOX::Logic::CBookmarkEnd* pBookmarkEnd = static_cast<OOX::Logic::CBookmarkEnd*>(item);
+						nCurPos = m_oBcw.WriteItemStart(c_oSerParType::BookmarkEnd);
+						WriteBookmarkEnd(*pBookmarkEnd);
+						m_oBcw.WriteItemWithLengthEnd(nCurPos);
+					}break;
                 default:
                     break;
 				}
@@ -3249,6 +3263,22 @@ namespace BinDocxRW
 						WriteComment(OOX::et_w_commentRangeEnd, pCommentRangeEnd->m_oId);
 						break;
 					}
+				case OOX::et_w_bookmarkStart:
+					{
+						OOX::Logic::CBookmarkStart* pBookmarkStart = static_cast<OOX::Logic::CBookmarkStart*>(item);
+						nCurPos = m_oBcw.WriteItemStart(c_oSerParType::BookmarkStart);
+						WriteBookmarkStart(*pBookmarkStart);
+						m_oBcw.WriteItemEnd(nCurPos);
+						break;
+					}
+				case OOX::et_w_bookmarkEnd:
+					{
+						OOX::Logic::CBookmarkEnd* pBookmarkEnd = static_cast<OOX::Logic::CBookmarkEnd*>(item);
+						nCurPos = m_oBcw.WriteItemStart(c_oSerParType::BookmarkEnd);
+						WriteBookmarkEnd(*pBookmarkEnd);
+						m_oBcw.WriteItemEnd(nCurPos);
+						break;
+					}
 				//todo moveRange on all levels(body, p ...)
 //				case OOX::et_w_moveFromRangeStart:
 //					{
@@ -3660,6 +3690,56 @@ namespace BinDocxRW
 				m_oBcw.WriteItemWithLengthEnd(nCurPos);
 			}
 		}
+		void WriteBookmarkStart(const OOX::Logic::CBookmarkStart& oBookmarkStart)
+		{
+			int nCurPos = 0;
+			if (oBookmarkStart.m_oId.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerBookmark::Id);
+				m_oBcw.m_oStream.WriteLONG(oBookmarkStart.m_oId->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if (oBookmarkStart.m_sName.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerBookmark::Name);
+				m_oBcw.m_oStream.WriteStringW3(oBookmarkStart.m_sName.get());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if (oBookmarkStart.m_oDisplacedByCustomXml.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerBookmark::DisplacedByCustomXml);
+				m_oBcw.m_oStream.WriteBYTE((BYTE)oBookmarkStart.m_oDisplacedByCustomXml->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if (oBookmarkStart.m_oColFirst.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerBookmark::ColFirst);
+				m_oBcw.m_oStream.WriteLONG(oBookmarkStart.m_oColFirst->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if (oBookmarkStart.m_oColLast.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerBookmark::ColLast);
+				m_oBcw.m_oStream.WriteLONG(oBookmarkStart.m_oColLast->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+		}
+		void WriteBookmarkEnd(const OOX::Logic::CBookmarkEnd& oBookmarkEnd)
+		{
+			int nCurPos = 0;
+			if (oBookmarkEnd.m_oId.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerBookmark::Id);
+				m_oBcw.m_oStream.WriteLONG(oBookmarkEnd.m_oId->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+			if (oBookmarkEnd.m_oDisplacedByCustomXml.IsInit())
+			{
+				nCurPos = m_oBcw.WriteItemStart(c_oSerBookmark::DisplacedByCustomXml);
+				m_oBcw.m_oStream.WriteBYTE((BYTE)oBookmarkEnd.m_oDisplacedByCustomXml->GetValue());
+				m_oBcw.WriteItemWithLengthEnd(nCurPos);
+			}
+		}
 		
 		void WriteHyperlink(OOX::Logic::CHyperlink* pHyperlink)
 		{
@@ -4097,6 +4177,22 @@ namespace BinDocxRW
 						m_oBcw.WriteItemEnd(nCurPos);
 						break;
 					}
+				case OOX::et_w_bookmarkStart:
+					{
+						OOX::Logic::CBookmarkStart* pBookmarkStart = static_cast<OOX::Logic::CBookmarkStart*>(item);
+						nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::BookmarkStart);
+						WriteBookmarkStart(*pBookmarkStart);
+						m_oBcw.WriteItemEnd(nCurPos);
+						break;
+					}
+				case OOX::et_w_bookmarkEnd:
+					{
+						OOX::Logic::CBookmarkEnd* pBookmarkEnd = static_cast<OOX::Logic::CBookmarkEnd*>(item);
+						nCurPos = m_oBcw.WriteItemStart(c_oSer_OMathContentType::BookmarkEnd);
+						WriteBookmarkEnd(*pBookmarkEnd);
+						m_oBcw.WriteItemEnd(nCurPos);
+						break;
+					}
                 default:
                     break;
 				}
@@ -6638,6 +6734,20 @@ namespace BinDocxRW
 					OOX::Logic::CBdo* pBdo = static_cast<OOX::Logic::CBdo*>(item);
 					WriteTableContent(pBdo->m_arrItems, pTblPr, nRows, nCols);
 				}
+				else if(OOX::et_w_bookmarkStart == item->getType())
+				{
+					OOX::Logic::CBookmarkStart* pBookmarkStart = static_cast<OOX::Logic::CBookmarkStart*>(item);
+					nCurPos = m_oBcw.WriteItemStart(c_oSerDocTableType::BookmarkStart);
+					WriteBookmarkStart(*pBookmarkStart);
+					m_oBcw.WriteItemWithLengthEnd(nCurPos);
+				}
+				else if(OOX::et_w_bookmarkEnd == item->getType())
+				{
+					OOX::Logic::CBookmarkEnd* pBookmarkEnd = static_cast<OOX::Logic::CBookmarkEnd*>(item);
+					nCurPos = m_oBcw.WriteItemStart(c_oSerDocTableType::BookmarkEnd);
+					WriteBookmarkEnd(*pBookmarkEnd);
+					m_oBcw.WriteItemWithLengthEnd(nCurPos);
+				}
 			}
 		}
 		void WriteRow(const OOX::Logic::CTr& Row, OOX::Logic::CTableProperty* pTblPr, int nCurRowIndex, int nRows, int nCols)
@@ -6698,6 +6808,20 @@ namespace BinDocxRW
 					OOX::Logic::CBdo* pBdo = static_cast<OOX::Logic::CBdo*>(item);
 					WriteRowContent(pBdo->m_arrItems, pTblPr, nCurRowIndex, nRows, nCols);
 				}
+				else if(OOX::et_w_bookmarkStart == item->getType())
+				{
+					OOX::Logic::CBookmarkStart* pBookmarkStart = static_cast<OOX::Logic::CBookmarkStart*>(item);
+					nCurPos = m_oBcw.WriteItemStart(c_oSerDocTableType::BookmarkStart);
+					WriteBookmarkStart(*pBookmarkStart);
+					m_oBcw.WriteItemWithLengthEnd(nCurPos);
+				}
+				else if(OOX::et_w_bookmarkEnd == item->getType())
+				{
+					OOX::Logic::CBookmarkEnd* pBookmarkEnd = static_cast<OOX::Logic::CBookmarkEnd*>(item);
+					nCurPos = m_oBcw.WriteItemStart(c_oSerDocTableType::BookmarkEnd);
+					WriteBookmarkEnd(*pBookmarkEnd);
+					m_oBcw.WriteItemWithLengthEnd(nCurPos);
+				}
 			}
 		}
 		void WriteCell(OOX::Logic::CTc& tc, OOX::Logic::CTableProperty* pTblPr, int nCurRowIndex, int nCurColIndex, int nRows, int nCols)

ASCOfficeOdfFile/OdfFileTest/OdfFileTest.vcproj

@@ -356,6 +356,10 @@
 					/>
 				</FileConfiguration>
 			</File>
+			<File
+				RelativePath="..\..\Common\DocxFormat\Source\Base\unicode_util.cpp"
+				>
+			</File>
 			<File
 				RelativePath="..\..\UnicodeConverter\UnicodeConverter.cpp"
 				>

ASCOfficeOdfFile/src/docx/xlsx_table_state.cpp

@@ -133,7 +133,8 @@ xlsx_table_state::xlsx_table_state(xlsx_conversion_context * Context, std::wstri
     xlsx_drawing_context_	(Context->get_drawing_context_handle()),
     xlsx_comments_context_	(Context->get_comments_context_handle()),
     table_column_last_width_(0.0),
-	in_cell(false)
+	in_cell(false),
+	bEndTable(false)
 
 {        
 	memset(&group_row_,0,sizeof(_group_row));

ASCOfficeOdfFile/src/docx/xlsx_table_state.h

@@ -91,6 +91,9 @@ public:
     void end_row		();
 
 	void add_empty_row(int count);
+
+	void set_end_table(){ bEndTable = true; }
+	bool get_end_table(){ return bEndTable; }
     
 	std::wstring current_row_style			() const;
     std::wstring default_row_cell_style		() const;
@@ -153,6 +156,7 @@ public:
 	friend class xlsx_table_context;
 
 private:	
+	bool								bEndTable;
     xlsx_conversion_context *			context_;    
 
     std::wstring						tableName_;

ASCOfficeOdfFile/src/docx/xlsx_utils.cpp

@@ -195,7 +195,14 @@ std::wstring cellType2Str(XlsxCellType::type type)
 
 boost::int64_t convertDate(int Year, int Month, int Day)
 {
-    boost::int64_t daysFrom1900  =  boost::gregorian::date_duration(boost::gregorian::date(Year, Month, Day) - boost::gregorian::date(1900, 1, 1)).days() + 1;
+	if (Year < 1400 || Year >10000)
+		return - 1;
+ 	if (Month < 1 || Month > 12)
+		return - 1;
+	if (Day < 1 || Day > 31)
+		return - 1;
+	
+	boost::int64_t daysFrom1900  =  boost::gregorian::date_duration(boost::gregorian::date(Year, Month, Day) - boost::gregorian::date(1900, 1, 1)).days() + 1;
 
     if (Year <= 1900 && 
         Month <= 2 &&

ASCOfficeOdfFile/src/odf/table_xlsx.cpp

@@ -78,13 +78,16 @@ int table_table_cell_content::xlsx_convert(oox::xlsx_conversion_context & Contex
 
 void table_table_row::xlsx_convert(oox::xlsx_conversion_context & Context)
 {
+	bool bEndTable = Context.get_table_context().state()->get_end_table();
+	
 	if (attlist_.table_number_rows_repeated_ > 1 && empty())
 	{
 		Context.get_table_context().state()->add_empty_row(attlist_.table_number_rows_repeated_);
 		return;
 	}
-	if (attlist_.table_number_rows_repeated_ > 0xf000 && empty_content_cells())
+	if (attlist_.table_number_rows_repeated_ > 0x0f00 && empty_content_cells() || bEndTable)//0xf000 - conv_KDZO3J3xLIbZ5fC0HR0__xlsx.ods
 	{
+		Context.get_table_context().state()->set_end_table();
 		Context.get_table_context().state()->add_empty_row(attlist_.table_number_rows_repeated_);
 		return;		//conv_hSX8n3lVbhALjt0aafg__xlsx.ods, conv_MA2CauoNfX_7ejKS5eg__xlsx.ods
 	}
@@ -731,7 +734,15 @@ void table_table_cell::xlsx_convert(oox::xlsx_conversion_context & Context)
             int y, m, d;
             if (oox::parseDate(attr.office_date_value_.get(), y, m, d))
             {
-                number_val = boost::lexical_cast<std::wstring>(oox::convertDate(y, m, d));
+				boost::int64_t intDate = oox::convertDate(y, m, d);
+				if (intDate > 0)
+				{
+					number_val = boost::lexical_cast<std::wstring>(intDate);
+				}
+				else
+				{
+					str_val = attr.office_date_value_.get();
+				}
             }
         }
     }
@@ -742,11 +753,19 @@ void table_table_cell::xlsx_convert(oox::xlsx_conversion_context & Context)
         if (attr.office_time_value_)
         {
             const std::wstring tv = attr.office_time_value_.get();
-            int h,m;
+            int h, m;
             double s;
             if (oox::parseTime(tv, h, m, s))
             {
-                number_val = boost::lexical_cast<std::wstring>(oox::convertTime(h, m, s));
+				boost::int64_t intTime = oox::convertTime(h, m, s);
+				if (intTime > 0)
+				{
+					number_val = boost::lexical_cast<std::wstring>(intTime);
+				}
+				else
+				{
+					str_val = tv;
+				}
             }                
         }
     }
@@ -899,34 +918,262 @@ void table_table_cell::xlsx_convert(oox::xlsx_conversion_context & Context)
 void table_covered_table_cell::xlsx_convert(oox::xlsx_conversion_context & Context)
 {
     std::wostream & strm = Context.current_sheet().sheetData();
-
-	const int sharedStringId = content_.xlsx_convert(Context, NULL);
     
+	const common_value_and_type_attlist & attr	= attlist_.common_value_and_type_attlist_;
+
+ 	office_value_type::type	odf_value_type	= office_value_type::Custom;
+	oox::XlsxCellType::type	t_val			= oox::XlsxCellType::s;
+	std::wstring formula					= attlist_.table_formula_.get_value_or(L"");
+    
+	std::wstring			number_val;
+    _CP_OPT(bool)			bool_val;
+	_CP_OPT(std::wstring)	str_val;
+   
+	std::wstring			num_format;
+
+	size_t	xfId_last_set		= 0;
+	int		empty_cell_count	= 0;
+	bool	skip_next_cell		= false;
+	bool	is_style_visible	= true;
+	bool	is_data_visible		= false;
+// вычислить стиль для ячейки
+
+    std::wstring cellStyleName		= attlist_.table_style_name_.get_value_or(L"");
+	std::wstring columnStyleName	= Context.get_table_context().default_column_cell_style();
+	std::wstring rowStyleName		= Context.get_table_context().default_row_cell_style();
+
+	if (attlist_.table_number_columns_repeated_ > 1)
+		columnStyleName.clear(); // могут быть разные стили колонок Book 24.ods
+
+	odf_read_context & odfContext = Context.root()->odf_context();   
+
+	style_instance *defaultCellStyle=NULL, *defaultColumnCellStyle = NULL,  *defaultRowCellStyle =NULL, *cellStyle = NULL;
+	try
+	{
+		defaultCellStyle		= odfContext.styleContainer().style_default_by_type(style_family::TableCell);
+
+		defaultColumnCellStyle	= odfContext.styleContainer().style_by_name(columnStyleName,	style_family::TableCell, false);
+		defaultRowCellStyle		= odfContext.styleContainer().style_by_name(rowStyleName,		style_family::TableCell, false);        
+		cellStyle				= odfContext.styleContainer().style_by_name(cellStyleName,		style_family::TableCell, false);
+	}
+	catch(...)
+	{
+        _CP_LOG << L"[error]: style wrong\n";
+	}
+
+    std::wstring data_style = CalcCellDataStyle(Context, columnStyleName, rowStyleName, cellStyleName);
+
+    // стили не наследуются
+    std::vector<const style_instance *> instances;
+    instances.push_back(defaultCellStyle);
+
+    if (defaultColumnCellStyle)
+        instances.push_back(defaultColumnCellStyle);
+
+    if (defaultRowCellStyle)
+    {
+        if (instances.size() > 1)
+            instances[1] = defaultRowCellStyle;
+        else
+            instances.push_back(defaultRowCellStyle);
+    }
+
+    if (cellStyle)
+    {
+        if (instances.size() > 1)
+            instances[1] = cellStyle;
+        else
+            instances.push_back(cellStyle);
+    }
+
+    text_format_properties_content		textFormatProperties	= calc_text_properties_content		(instances);          
+	paragraph_format_properties			parFormatProperties		= calc_paragraph_properties_content	(instances);
+    style_table_cell_properties_attlist cellFormatProperties	= calc_table_cell_properties		(instances);
+
+	if (attr.office_value_type_)
+		odf_value_type = attr.office_value_type_->get_type();
+	
+	if ((odf_value_type == office_value_type::Float) || 
+		(odf_value_type == office_value_type::Custom && attr.office_value_))
+    {
+        t_val = oox::XlsxCellType::n;
+        number_val = attr.office_value_.get_value_or(L"");
+    }
+    else if (odf_value_type == office_value_type::Percentage)
+    {
+        t_val		= oox::XlsxCellType::n;
+        number_val	= attr.office_value_.get_value_or(L"");
+    }
+    else if (odf_value_type == office_value_type::Currency)
+    {
+        t_val		= oox::XlsxCellType::n;
+        number_val	= attr.office_value_.get_value_or(L"");
+    }
+    else if ((odf_value_type == office_value_type::Date) || 
+			 (odf_value_type == office_value_type::Custom && attr.office_date_value_))
+    { 
+        t_val = oox::XlsxCellType::n;              
+        if (attr.office_date_value_)
+        {
+            int y, m, d;
+            if (oox::parseDate(attr.office_date_value_.get(), y, m, d))
+            {
+				boost::int64_t intDate = oox::convertDate(y, m, d);
+				if (intDate > 0)
+				{
+					number_val = boost::lexical_cast<std::wstring>(intDate);
+				}
+				else
+				{
+					str_val = attr.office_date_value_.get();
+				}
+            }
+        }
+    }
+    else if ((odf_value_type == office_value_type::Time) ||
+			 (odf_value_type == office_value_type::Custom && attr.office_time_value_))
+    {
+        t_val = oox::XlsxCellType::n;
+        if (attr.office_time_value_)
+        {
+            const std::wstring tv = attr.office_time_value_.get();
+            int h,m;
+            double s;
+            if (oox::parseTime(tv, h, m, s))
+            {
+                number_val = boost::lexical_cast<std::wstring>(oox::convertTime(h, m, s));
+            }                
+        }
+    }
+    else if ((odf_value_type == office_value_type::Boolean) ||
+			 (odf_value_type == office_value_type::Custom && attr.office_boolean_value_))
+    {
+        t_val = oox::XlsxCellType::b;
+        if (attr.office_boolean_value_)	bool_val = oox::parseBoolVal(attr.office_boolean_value_.get());
+    }
+    else if ((odf_value_type == office_value_type::String) ||
+			 (odf_value_type == office_value_type::Custom && attr.office_string_value_))
+    {
+        t_val = oox::XlsxCellType::str;
+		if (attr.office_string_value_)	str_val = attr.office_string_value_.get();
+    }
+
+    if (!data_style.empty())
+    {
+        office_element_ptr elm			= odfContext.numberStyles().find_by_style_name(data_style);
+		number_style_base *num_style	= dynamic_cast<number_style_base*>(elm.get());
+      
+		if (num_style)
+		{
+            Context.get_num_format_context().start_complex_format();
+				num_style->oox_convert(Context.get_num_format_context());
+            Context.get_num_format_context().end_complex_format();
+            
+			num_format = Context.get_num_format_context().get_last_format();
+        }
+    }
+
+    oox::xlsx_cell_format cellFormat;
+    
+	cellFormat.set_cell_type(t_val);
+    cellFormat.set_num_format(oox::odf_string_to_build_in(odf_value_type));
+    
+	is_style_visible = (!cellStyleName.empty() || defaultColumnCellStyle) ? true : false;
+
+	if ( content_.elements_.size() > 0	|| 
+		!formula.empty()	||
+		(	t_val == oox::XlsxCellType::n										&& !number_val.empty()) || 
+		(	t_val == oox::XlsxCellType::b										&& bool_val) ||
+		((	t_val == oox::XlsxCellType::str || oox::XlsxCellType::inlineStr)	&& str_val))	is_data_visible = true;
+
+	if (attlist_.table_number_columns_repeated_ < 199 && last_cell_)	last_cell_ = false;
+	
+	int cell_repeated_max = Context.current_table_column() + attlist_.table_number_columns_repeated_ + 1;
+
+	if (cell_repeated_max >= 1024 && cellStyleName.empty() && last_cell_ && !is_data_visible)
+	{//Book 24.ods
+		return;
+	}
+    
+	if (is_style_visible)
+	{
+		xfId_last_set = Context.get_style_manager().xfId(&textFormatProperties, &parFormatProperties, &cellFormatProperties, &cellFormat, num_format, false, is_style_visible);
+	}
+
 	for (unsigned int r = 0; r < attlist_.table_number_columns_repeated_; ++r)
     {
-        Context.start_table_covered_cell();
-        const int xfId = Context.get_current_cell_style_id();
+        Context.start_table_covered_cell ();
+		
+		if (is_style_visible)
+			Context.set_current_cell_style_id(xfId_last_set);
+		
+		const int sharedStringId = content_.xlsx_convert(Context, &textFormatProperties);
 
+		if (t_val == oox::XlsxCellType::str && sharedStringId >=0)
+			t_val = oox::XlsxCellType::s;//в случае текста, если он есть берем кэшированное значение
+			
+		if (skip_next_cell)break;
 
-        CP_XML_WRITER(strm)
+        // пустые ячейки пропускаем.
+        if ( is_data_visible || ((cellStyle || defaultColumnCellStyle) && is_style_visible))
         {
-            CP_XML_NODE(L"c")
+            CP_XML_WRITER(strm)
             {
-                CP_XML_ATTR(L"r", Context.current_cell_address());
-                
-                if (xfId >= 0)
-				{
-                    CP_XML_ATTR(L"s", xfId);  
-				}
+                CP_XML_NODE(L"c")
+                {
+                    CP_XML_ATTR(L"r", oox::getCellAddress(Context.current_table_column(), Context.current_table_row()));
+                    CP_XML_ATTR(L"t", oox::cellType2Str(t_val));
+                    CP_XML_ATTR(L"s", xfId_last_set);
 
-				if (sharedStringId >=0) 
-				{
-                    CP_XML_NODE(L"v")
+                    if (!formula.empty())
                     {
-						CP_XML_CONTENT(sharedStringId);
+                        const std::wstring xlsxFormula = formulas_converter.convert(formula);
+                        if (!xlsxFormula.empty())
+                        {
+                            CP_XML_NODE(L"f")
+                            {
+                                CP_XML_CONTENT(xlsxFormula);
+                            }
+                        }
                     }
-				}
-            } // c
+
+					if (sharedStringId >= 0 && t_val == oox::XlsxCellType::s)
+                    {
+                        CP_XML_NODE(L"v")	{ CP_XML_CONTENT(sharedStringId); }
+                    }
+					else if ((t_val == oox::XlsxCellType::str || t_val == oox::XlsxCellType::inlineStr)  && str_val) 
+                    {    
+						CP_XML_NODE(L"v")	{ CP_XML_CONTENT(str_val.get()); }
+					}
+                    else if (t_val == oox::XlsxCellType::n && !number_val.empty())
+                    {
+                        CP_XML_NODE(L"v")	{ CP_XML_CONTENT(number_val);}
+					}
+                    else if (t_val == oox::XlsxCellType::b && bool_val)
+                    {
+                        CP_XML_NODE(L"v")   { CP_XML_CONTENT((int)(bool_val.get())); }
+                    }
+                }
+				if ( is_data_visible || (cellStyle && is_style_visible && !last_cell_))
+				{
+					Context.non_empty_row();
+					empty_cell_count = 0 ;					
+				} 
+				else
+				{
+					empty_cell_count++;
+					//Уведомление_о_вручении.ods - 13 повторов пустых с cellStyle=NULL - нужные !!!
+					if (empty_cell_count > 19 && last_cell_&& (attlist_.table_number_columns_repeated_> 299 || cellStyle == NULL)) 
+					{//пишем простыню только если задан стиль тока для этих ячеек
+						skip_next_cell = true;
+					}
+				}				
+			}
+		}
+        else
+        {
+            if (last_cell_) // Vehicle log book.ods (row = 24 and more)
+				skip_next_cell = true;
         }
 
         Context.end_table_covered_cell();

ASCOfficeOdfFileW/source/Oox2OdfConverter/DocxConverter.cpp

@@ -2057,11 +2057,12 @@ void DocxConverter::convert(OOX::Logic::CRunProperty *oox_run_pr, odf_writer::st
 		   convert(oox_run_pr->m_oColor.GetPointer(),text_properties->content_.fo_color_);
 	}
 
-    text_properties->content_.style_text_underline_type_= odf_types::line_type(odf_types::line_type::None);
+    //text_properties->content_.style_text_underline_type_= odf_types::line_type(odf_types::line_type::None); //нельзя..если будет выше наследуемого то подчеркивания не будет
 	if (oox_run_pr->m_oU.IsInit())
 	{
 		text_properties->content_.style_text_underline_style_	= odf_types::line_style(odf_types::line_style::Solid);
 		text_properties->content_.style_text_underline_type_	= odf_types::line_type(odf_types::line_type::Single);
+		text_properties->content_.style_text_underline_width_	= odf_types::line_width(odf_types::line_width::Auto);
 
 		_CP_OPT(odf_types::color) color;
 		convert(oox_run_pr->m_oU->m_oColor.GetPointer(), oox_run_pr->m_oU->m_oThemeColor.GetPointer(),
@@ -3187,9 +3188,9 @@ void DocxConverter::convert_table_style(OOX::CStyle *oox_style)
 {
 	if (oox_style == NULL)return;
 
-	std::wstring oox_name = oox_style->m_sStyleId.IsInit() ? *oox_style->m_sStyleId : L"";
+	std::wstring oox_name_id = oox_style->m_sStyleId.IsInit() ? *oox_style->m_sStyleId : L"";
 
-	odt_context->styles_context()->table_styles().start_style(oox_name);
+	odt_context->styles_context()->table_styles().start_style(oox_name_id);
 //общие
 
 	if (oox_style->m_oTblPr.IsInit())
@@ -3303,17 +3304,21 @@ void DocxConverter::convert(OOX::CStyle	*oox_style)
 			return;
 	}
 
-	std::wstring oox_name = oox_style->m_sStyleId.IsInit() ? *oox_style->m_sStyleId : L"";
-
-	odt_context->styles_context()->create_style(oox_name, family, false, true, -1); 
+	std::wstring oox_name_id = oox_style->m_sStyleId.IsInit() ? *oox_style->m_sStyleId : L"";
 
+	odt_context->styles_context()->create_style(oox_name_id, family, false, true, -1); 
 
+	std::wstring style_name;
 	if (oox_style->m_oName.IsInit() && oox_style->m_oName->m_sVal.IsInit()) 
-		odt_context->styles_context()->last_state()->set_display_name(*oox_style->m_oName->m_sVal);
+	{
+		style_name = *oox_style->m_oName->m_sVal;
+		odt_context->styles_context()->last_state()->set_display_name(style_name);
+	}
 
+	odf_writer::style_text_properties* text_properties = NULL;
 	if (oox_style->m_oRunPr.IsInit())
 	{
-		odf_writer::style_text_properties* text_properties = odt_context->styles_context()->last_state()->get_text_properties();
+		text_properties = odt_context->styles_context()->last_state()->get_text_properties();
 	
 		if (oox_style->m_oDefault.IsInit() && oox_style->m_oDefault->ToBool())
 		{
@@ -3330,14 +3335,14 @@ void DocxConverter::convert(OOX::CStyle	*oox_style)
 	}
 	if (oox_style->m_oParPr.IsInit())
 	{
-		odf_writer::style_paragraph_properties	* paragraph_properties = odt_context->styles_context()->last_state()->get_paragraph_properties();
+		odf_writer::style_paragraph_properties	*paragraph_properties = odt_context->styles_context()->last_state()->get_paragraph_properties();
 		if (oox_style->m_oDefault.IsInit() && oox_style->m_oDefault->ToBool())
 		{
 			//основан на дефолтовом - накатить
 			odf_writer::odf_style_state_ptr def_style_state;
 			if (odt_context->styles_context()->find_odf_default_style_state(odf_types::style_family::Paragraph, def_style_state) && def_style_state)
 			{
-				odf_writer::style_paragraph_properties * props = def_style_state->get_paragraph_properties();
+				odf_writer::style_paragraph_properties *props = def_style_state->get_paragraph_properties();
 				paragraph_properties->apply_from(props);
 			}
 		}
@@ -3367,9 +3372,19 @@ void DocxConverter::convert(OOX::CStyle	*oox_style)
 	if (oox_style->m_oBasedOn.IsInit() && oox_style->m_oBasedOn->m_sVal.IsInit())
 		odt_context->styles_context()->last_state()->set_parent_style_name(*oox_style->m_oBasedOn->m_sVal);
 
-		//nullable<ComplexTypes::Word::COnOff2<SimpleTypes::onoffTrue>> m_oQFormat;
-        //nullable<ComplexTypes::Word::std::wstring_>					m_oAliases;
-
+	//nullable<ComplexTypes::Word::COnOff2<SimpleTypes::onoffTrue>> m_oQFormat;
+	//nullable<ComplexTypes::Word::std::wstring_>					m_oAliases;
+//-------------------------------------------------------------------------------------------------------------------------
+	if (style_name == L"Hyperlink")
+	{
+		odt_context->styles_context()->create_style(L"Internet_20_link", family, false, true, -1); 
+		//odt_context->styles_context()->last_state()->set_parent_style_name(oox_name_id);
+		odt_context->styles_context()->last_state()->set_display_name(L"Internet link");
+		
+		odf_writer::style_text_properties* hyperlink_text_props = odt_context->styles_context()->last_state()->get_text_properties();
+		hyperlink_text_props->apply_from(text_properties);
+		
+	}
 }
 
 void DocxConverter::convert(OOX::Logic::CCommentRangeStart* oox_comm_start)

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/Converter.cpp

@@ -794,7 +794,7 @@ void NSPresentationEditor::CPPTXWriter::WriteBackground(CStringWriter& oWriter,
 	oWriter.WriteString(std::wstring(L"</p:bgPr></p:bg>"));
 }
 
-void NSPresentationEditor::CPPTXWriter::WriteElement(CStringWriter& oWriter, CRelsGenerator& oRels, IElement* pElement, CLayout* pLayout)
+void NSPresentationEditor::CPPTXWriter::WriteElement(CStringWriter& oWriter, CRelsGenerator& oRels, CElementPtr pElement, CLayout* pLayout)
 {
 	if (!pElement) return;
 
@@ -817,7 +817,7 @@ void NSPresentationEditor::CPPTXWriter::WriteElement(CStringWriter& oWriter, CRe
 					if ((pElement->m_lPlaceholderType == pLayout->m_arElements[nIndex]->m_lPlaceholderType) &&
 						(pElement->m_lPlaceholderID == pLayout->m_arElements[nIndex]->m_lPlaceholderID))
 					{
-						IElement* pElLayout = pLayout->m_arElements[nIndex];
+						CElementPtr pElLayout = pLayout->m_arElements[nIndex];
 						
 						bool bIsEqualTransform = ((pElement->m_dRotate == pElLayout->m_dRotate) 
 							&& (pElement->m_bFlipH == pElLayout->m_bFlipH) && (pElement->m_bFlipV == pElLayout->m_bFlipV));

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/Converter.h

@@ -82,7 +82,7 @@ namespace NSPresentationEditor
 		void WriteTransition	(CStringWriter& oWriter, CTransition& transition);		
 		void WriteColorScheme	(CStringWriter& oWriter, const std::wstring & name, const std::vector<CColor> & colors, bool extra = false);
 		void WriteBackground	(CStringWriter& oWriter, CRelsGenerator& oRels, CBrush& oBackground);
-		void WriteElement		(CStringWriter& oWriter, CRelsGenerator& oRels, IElement* pElement, CLayout* pLayout = NULL);
+		void WriteElement		(CStringWriter& oWriter, CRelsGenerator& oRels, CElementPtr pElement, CLayout* pLayout = NULL);
 		
 
 	};

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/ShapeWriter.cpp

@@ -293,10 +293,10 @@ NSPresentationEditor::CShapeWriter::CShapeWriter()
 	m_pImageElement = NULL;
 	m_pShapeElement = NULL;
 }
-bool NSPresentationEditor::CShapeWriter::SetElement(IElement* pElem)
+bool NSPresentationEditor::CShapeWriter::SetElement(CElementPtr pElem)
 {
-    m_pShapeElement = dynamic_cast<CShapeElement*>(pElem);
-    m_pImageElement = dynamic_cast<CImageElement*>(pElem);
+    m_pShapeElement = dynamic_cast<CShapeElement*>(pElem.get());
+    m_pImageElement = dynamic_cast<CImageElement*>(pElem.get());
 	
 	m_pSimpleGraphicsConverter->PathCommandEnd();
 
@@ -309,7 +309,7 @@ bool NSPresentationEditor::CShapeWriter::SetElement(IElement* pElem)
 
 	if (m_pShapeElement)
 	{
-		m_pShapeElement->m_oShape.GetTextRect(m_oTextRect);
+		m_pShapeElement->m_pShape->GetTextRect(m_oTextRect);
 	}
 
 	m_oWriter.ClearNoAttack();
@@ -809,7 +809,7 @@ void NSPresentationEditor::CShapeWriter::WriteShapeInfo()
 }
 void NSPresentationEditor::CShapeWriter::WriteTextInfo()
 {
-	size_t nCount = m_pShapeElement->m_oShape.m_oText.m_arParagraphs.size();
+	size_t nCount = m_pShapeElement->m_pShape->m_oText.m_arParagraphs.size();
 
 	m_oWriter.WriteString(std::wstring(L"<p:txBody>"));
 
@@ -826,21 +826,21 @@ void NSPresentationEditor::CShapeWriter::WriteTextInfo()
 	
 //	m_oWriter.WriteString(std::wstring(L" lIns=\"0\" tIns=\"0\" rIns=\"0\" bIns=\"0\""));
 
-	if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_nTextAlignVertical == 0 )			
+	if (m_pShapeElement->m_pShape->m_oText.m_oAttributes.m_nTextAlignVertical == 0 )			
 		m_oWriter.WriteString(L" anchor=\"t\"");
-	else if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_nTextAlignVertical == 2 )	
+	else if (m_pShapeElement->m_pShape->m_oText.m_oAttributes.m_nTextAlignVertical == 2 )	
 		m_oWriter.WriteString(L" anchor=\"b\"");
-	else if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_nTextAlignVertical == 1 )	
+	else if (m_pShapeElement->m_pShape->m_oText.m_oAttributes.m_nTextAlignVertical == 1 )	
 	{
 		m_oWriter.WriteString(L" anchor=\"ctr\"");
 		m_oWriter.WriteString(L" anchorCtr=\"0\"");
 	}
-	if (m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_dTextRotate > 0)
+	if (m_pShapeElement->m_pShape->m_oText.m_oAttributes.m_dTextRotate > 0)
 	{
-		std::wstring strProp = std::to_wstring((int)(m_pShapeElement->m_oShape.m_oText.m_oAttributes.m_dTextRotate * 60000));
+		std::wstring strProp = std::to_wstring((int)(m_pShapeElement->m_pShape->m_oText.m_oAttributes.m_dTextRotate * 60000));
 		m_oWriter.WriteString(L" rot=\"" + strProp + L"\"");
 	}
-	if (m_pShapeElement->m_oShape.m_oText.m_bVertical)
+	if (m_pShapeElement->m_pShape->m_oText.m_bVertical)
 	{
 		m_oWriter.WriteString(L" vert=\"eaVert\"");
 	}
@@ -853,7 +853,7 @@ void NSPresentationEditor::CShapeWriter::WriteTextInfo()
 			m_oWriter.WriteString(std::wstring(L" prst=\"") + prstTxWarp + _T("\">"));
 			m_oWriter.WriteString(std::wstring(L"<a:avLst>"));//модификаторы
 
-			CPPTShape *pPPTShape = dynamic_cast<CPPTShape *>(m_pShapeElement->m_oShape.getBaseShape());
+			CPPTShape *pPPTShape = dynamic_cast<CPPTShape *>(m_pShapeElement->m_pShape->getBaseShape().get());
             std::wstring strVal;
 
 			for (int i = 0 ; (pPPTShape) && (i < pPPTShape->m_arAdjustments.size()); i++)
@@ -875,7 +875,7 @@ void NSPresentationEditor::CShapeWriter::WriteTextInfo()
 			m_oWriter.WriteString(L"</a:avLst>");
 		m_oWriter.WriteString(L"</a:prstTxWarp>");
 	}
-	if (m_pShapeElement->m_oShape.m_oText.m_bAutoFit)
+	if (m_pShapeElement->m_pShape->m_oText.m_bAutoFit)
 	{
 		m_oWriter.WriteString(L"<a:spAutoFit/>");
 	}
@@ -890,14 +890,14 @@ void NSPresentationEditor::CShapeWriter::WriteTextInfo()
 
 	if (!m_bWordArt)
 	{
-		CStylesWriter::ConvertStyles(m_pShapeElement->m_oShape.m_oText.m_oStyles, m_oMetricInfo, m_oWriter);
+		CStylesWriter::ConvertStyles(m_pShapeElement->m_pShape->m_oText.m_oStyles, m_oMetricInfo, m_oWriter);
 	}
 
 	m_oWriter.WriteString(std::wstring(L"</a:lstStyle>"));
 
 	for (size_t nIndexPar = 0; nIndexPar < nCount; ++nIndexPar)
 	{
-		NSPresentationEditor::CParagraph* pParagraph = &m_pShapeElement->m_oShape.m_oText.m_arParagraphs[nIndexPar];
+		NSPresentationEditor::CParagraph* pParagraph = &m_pShapeElement->m_pShape->m_oText.m_arParagraphs[nIndexPar];
 
 		//if (m_bWordArt && nIndexPar == nCount-1)
 		//{
@@ -1308,11 +1308,11 @@ std::wstring NSPresentationEditor::CShapeWriter::ConvertShape()
 		m_oWriter.WriteString(std::wstring(L"</a:xfrm>"));
 	}
 
-	CBaseShape *shape = m_pShapeElement->m_oShape.getBaseShape();
+    CBaseShapePtr shape = m_pShapeElement->m_pShape->getBaseShape();
 
-	if (m_pShapeElement->m_oShape.m_lDrawType & c_ShapeDrawType_Graphic || shape->m_bCustomShape)
+	if (m_pShapeElement->m_pShape->m_lDrawType & c_ShapeDrawType_Graphic || shape->m_bCustomShape)
 	{
-		m_pShapeElement->m_oShape.ToRenderer(dynamic_cast<IRenderer*>(this), oInfo, m_oMetricInfo, 0.0, 1.0);
+		m_pShapeElement->m_pShape->ToRenderer(dynamic_cast<IRenderer*>(this), oInfo, m_oMetricInfo, 0.0, 1.0);
 	}
 
 	if ((prstGeom.empty() == false || m_pShapeElement->m_bShapePreset) && prstTxWarp.empty() && !shape->m_bCustomShape)

ASCOfficePPTFile/PPTFormatLib/PPTXWriter/ShapeWriter.h

@@ -170,7 +170,7 @@ namespace NSPresentationEditor
 			m_lNextShapeID = 1000;
 		}
 
-		bool SetElement(IElement* pElem);
+		bool SetElement(CElementPtr pElem);
 //--------------------------------------------------------------------
             std::wstring	ConvertShape	();
             std::wstring	ConvertImage	();

ASCOfficePPTFile/PPTFormatLib/Reader/PPTDocumentInfo.h

@@ -93,7 +93,8 @@ public:
            
 			bool bResult = pInfo->ReadFromStream(&oUserAtom, pStream);
 
-			offsetToEdit = pInfo->m_oUser.m_nOffsetLastEdit;
+			m_bMacros					= pInfo->m_bMacros;
+			offsetToEdit				= pInfo->m_oUser.m_nOffsetLastEdit;
 			m_oCurrentUser.m_bIsEncrypt = pInfo->m_bEncrypt;
 			
 			if (bResult == false)

ASCOfficePPTFile/PPTFormatLib/Reader/PPTDocumentInfoOneUser.cpp

@@ -757,16 +757,14 @@ void CPPTUserInfo::LoadNotes(DWORD dwNoteID, CSlide* pNotes)
 
 	for (size_t nShape = 0; nShape < oArrayShapes.size(); ++nShape)
 	{
-		IElement* pElement = NULL;
-		
-		oArrayShapes[nShape]->GetElement(&pElement, &m_oExMedia, pNotes->m_lOriginalWidth, pNotes->m_lOriginalHeight,
+		CElementPtr pElement = oArrayShapes[nShape]->GetElement(&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);
+				CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement.get());
 				if (NULL != pShape)
 				{
 					pShape->SetupProperties(pNotes, pTheme, pLayout);
@@ -774,7 +772,6 @@ void CPPTUserInfo::LoadNotes(DWORD dwNoteID, CSlide* pNotes)
 					pNotes->m_bIsBackground = true;
 					pNotes->m_oBackground	= pShape->m_oBrush;
 				}
-				RELEASEOBJECT(pElement);
 				continue;			
 
 			}
@@ -1002,16 +999,14 @@ void CPPTUserInfo::LoadSlide(DWORD dwSlideID, CSlide* pSlide)
 
 	for (size_t nShape = 0; nShape < oArrayShapes.size(); ++nShape)
 	{
-		IElement* pElement = NULL;
-		
-		oArrayShapes[nShape]->GetElement(&pElement, &m_oExMedia, pSlide->m_lOriginalWidth, pSlide->m_lOriginalHeight,
+		CElementPtr pElement = oArrayShapes[nShape]->GetElement(&m_oExMedia, pSlide->m_lOriginalWidth, pSlide->m_lOriginalHeight,
 												pTheme, pLayout, pThemeWrapper, pSlideWrapper, pSlide);
 		
 		if (NULL != pElement)
 		{
 			if (pElement->m_bIsBackground && !pElement->m_bHaveAnchor && !bMasterBackGround)
 			{
-				CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement);
+				CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement.get());
 				if (NULL != pShape)
 				{
 					pShape->SetupProperties(pSlide, pTheme, pLayout);
@@ -1019,7 +1014,6 @@ void CPPTUserInfo::LoadSlide(DWORD dwSlideID, CSlide* pSlide)
 					pSlide->m_bIsBackground = true;
 					pSlide->m_oBackground	= pShape->m_oBrush;
 				}
-				RELEASEOBJECT(pElement);
 				continue;			
 
 			}else
@@ -1044,13 +1038,12 @@ void CPPTUserInfo::LoadSlide(DWORD dwSlideID, CSlide* pSlide)
 	
 	//-------------элементы колонтитулов
 	std::multimap<int, int>::iterator it;
-	IElement* pElement = NULL;
-	
+		
 	if (bHasSlideNumber)	AddLayoutSlidePlaceholder(pSlide, MasterSlideNumber, pLayout, true);	
 	
 	if (bHasDate)
 	{
-		IElement *pElement = AddLayoutSlidePlaceholder(pSlide, MasterDate, pLayout, true);
+		CElementPtr pElement = AddLayoutSlidePlaceholder(pSlide, MasterDate, pLayout, true);
 	
 		if (pElement) pElement->m_nFormatDate = nFormatDate;
 	}
@@ -1058,9 +1051,9 @@ void CPPTUserInfo::LoadSlide(DWORD dwSlideID, CSlide* pSlide)
 	if (bHasFooter)	AddLayoutSlidePlaceholder(pSlide, MasterFooter, pLayout, true);
 }
 
-IElement* CPPTUserInfo::AddLayoutSlidePlaceholder (CSlide *pSlide, int placeholderType, CLayout *pLayout, bool idx_only)
+CElementPtr CPPTUserInfo::AddLayoutSlidePlaceholder (CSlide *pSlide, int placeholderType, CLayout *pLayout, bool idx_only)
 {
-	IElement* pElement  = NULL;
+	CElementPtr pElement;
 
 	for (std::multimap<int, int>::iterator it = pLayout->m_mapPlaceholders.begin(); it != pLayout->m_mapPlaceholders.end(); it++)
 	{
@@ -1073,7 +1066,7 @@ IElement* CPPTUserInfo::AddLayoutSlidePlaceholder (CSlide *pSlide, int placehold
 
 				pElement = pLayout->m_arElements[it->second]->CreateDublicate();
 				
-				pSlide->m_arElements.push_back(dynamic_cast<IElement*>(pElement));
+				pSlide->m_arElements.push_back(pElement);
 				pSlide->m_mapPlaceholders.insert(std::pair<int, int>(placeholderType, pSlide->m_arElements.size()-1)); 
 			}
 			else
@@ -1092,7 +1085,7 @@ IElement* CPPTUserInfo::AddLayoutSlidePlaceholder (CSlide *pSlide, int placehold
 				{
 					pElement = pLayout->m_arElements[it->second]->CreateDublicate();
 
-					pSlide->m_arElements.push_back(dynamic_cast<IElement*>(pElement));
+					pSlide->m_arElements.push_back(pElement);
 					pSlide->m_mapPlaceholders.insert(std::pair<int, int>(placeholderType, pSlide->m_arElements.size()-1)); 
 				}
 			}
@@ -1102,9 +1095,9 @@ IElement* CPPTUserInfo::AddLayoutSlidePlaceholder (CSlide *pSlide, int placehold
 	return pElement; 
 }
 	
-IElement* CPPTUserInfo::AddThemeLayoutPlaceholder (CLayout *pLayout, int placeholderType, CTheme* pTheme, bool idx_only)
+CElementPtr  CPPTUserInfo::AddThemeLayoutPlaceholder (CLayout *pLayout, int placeholderType, CTheme* pTheme, bool idx_only)
 {
-	IElement* pElement  = NULL;
+	CElementPtr pElement;
 
 	for (std::multimap<int, int>::iterator it = pTheme->m_mapPlaceholders.begin(); it != pTheme->m_mapPlaceholders.end(); it++)
 	{
@@ -1116,7 +1109,7 @@ IElement* CPPTUserInfo::AddThemeLayoutPlaceholder (CLayout *pLayout, int placeho
 
 			pElement->m_bPlaceholderSet = true;
 			
-			pLayout->m_arElements.push_back(dynamic_cast<IElement*>(pElement));
+			pLayout->m_arElements.push_back(pElement);
 			pLayout->m_mapPlaceholders.insert(std::pair<int, int>(placeholderType, pLayout->m_arElements.size()-1)); 
 		}
 	}
@@ -1124,9 +1117,9 @@ IElement* CPPTUserInfo::AddThemeLayoutPlaceholder (CLayout *pLayout, int placeho
 	return pElement; //last added
 }
 
-IElement* CPPTUserInfo::AddNewLayoutPlaceholder (CLayout *pLayout, int placeholderType, int placeholderSizePreset)
+CElementPtr CPPTUserInfo::AddNewLayoutPlaceholder (CLayout *pLayout, int placeholderType, int placeholderSizePreset)
 {
-	if (placeholderType < 1) return NULL;
+	if (placeholderType < 1) return CElementPtr();
 
 	CShapeElement* pShape = new CShapeElement(NSBaseShape::ppt, PPTShapes::sptCRect);
 
@@ -1139,10 +1132,12 @@ IElement* CPPTUserInfo::AddNewLayoutPlaceholder (CLayout *pLayout, int placehold
 
 	CorrectPlaceholderType(pShape->m_lPlaceholderType);
 
-	pLayout->m_arElements.push_back(dynamic_cast<IElement*>(pShape));
+	CElementPtr pElement = CElementPtr(pShape);
+
+	pLayout->m_arElements.push_back(pElement);
 	pLayout->m_mapPlaceholders.insert(std::pair<int, int>(pShape->m_lPlaceholderType, pLayout->m_arElements.size()-1)); 
 
-	return pShape;
+	return pElement;
 }
 
 int CPPTUserInfo::AddNewLayout(CTheme* pTheme, CRecordSlide* pRecordSlide, bool addShapes, bool bMasterObjects)
@@ -1244,7 +1239,7 @@ int CPPTUserInfo::AddNewLayout(CTheme* pTheme, CRecordSlide* pRecordSlide, bool
 		{
 			if (it1->first == it->first)
 			{
-				IElement* pElemLayout = pLayout->m_arElements[it1->second];
+				CElementPtr pElemLayout = pLayout->m_arElements[it1->second];
 				if (pElemLayout->m_lPlaceholderID == pTheme->m_arElements[it->second]->m_lPlaceholderID)
 				{
 					found = true;
@@ -1254,9 +1249,9 @@ int CPPTUserInfo::AddNewLayout(CTheme* pTheme, CRecordSlide* pRecordSlide, bool
 		}
 		if (found == false)
 		{
-			IElement *pElemTheme = pTheme->m_arElements[it->second]->CreateDublicate();
+			CElementPtr pElemTheme = pTheme->m_arElements[it->second]->CreateDublicate();
 		
-			pLayout->m_arElements.push_back(dynamic_cast<IElement*>(pElemTheme));
+			pLayout->m_arElements.push_back(pElemTheme);
 			pLayout->m_mapPlaceholders.insert(std::pair<int, int>(it->first, pLayout->m_arElements.size()-1)); 
 		}
 	}
@@ -1275,9 +1270,9 @@ int CPPTUserInfo::AddNewLayout(CTheme* pTheme, CRecordSlide* pRecordSlide, bool
 	return ind;
 }
 
-IElement* CPPTUserInfo::AddNewThemePlaceholder (CTheme* pTheme, int placeholderType, int placeholderSizePreset)
+CElementPtr CPPTUserInfo::AddNewThemePlaceholder (CTheme* pTheme, int placeholderType, int placeholderSizePreset)
 {
-	if (placeholderType < 1) return NULL;
+	if (placeholderType < 1) return CElementPtr();
 
 	CShapeElement* pShape = new CShapeElement(NSBaseShape::ppt, PPTShapes::sptCRect);
 
@@ -1290,10 +1285,12 @@ IElement* CPPTUserInfo::AddNewThemePlaceholder (CTheme* pTheme, int placeholderT
 
 	CorrectPlaceholderType(pShape->m_lPlaceholderType);
 
-	pTheme->m_arElements.push_back(dynamic_cast<IElement*>(pShape));
+	CElementPtr pElement = CElementPtr(pShape);
+
+	pTheme->m_arElements.push_back(pElement);
 	pTheme->m_mapPlaceholders.insert(std::pair<int, int>(pShape->m_lPlaceholderType, pTheme->m_arElements.size()-1)); 
 
-	return pShape;
+	return pElement;
 }
 void CPPTUserInfo::LoadMainMaster(DWORD dwMasterID, const LONG& lOriginWidth, const LONG& lOriginHeight)
 {
@@ -1507,16 +1504,15 @@ void CPPTUserInfo::LoadMainMaster(DWORD dwMasterID, const LONG& lOriginWidth, co
 
 	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);
+		NSPresentationEditor::CElementPtr pElement = oArrayShapes[nShape]->GetElement(&m_oExMedia, lOriginWidth, lOriginHeight, pTheme, pLayout, pMasterWrapper, pMasterWrapper);
 
-		if (NULL != pElement)
+		if (pElement)
 		{
 			AddAnimation ( dwMasterID, lOriginWidth, lOriginHeight, pElement );
 			
 			if (pElement->m_bIsBackground && !pElement->m_bHaveAnchor)
 			{
-				CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement);
+				CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement.get());
 				if (NULL != pShape)
 				{
 					pShape->SetupProperties(NULL, pTheme, pLayout);
@@ -1524,8 +1520,6 @@ void CPPTUserInfo::LoadMainMaster(DWORD dwMasterID, const LONG& lOriginWidth, co
 					pTheme->m_bIsBackground = true;
 					pTheme->m_oBackground = pShape->m_oBrush;
 				}
-
-				RELEASEINTERFACE(pElement);
 				continue;
 			}
 			pTheme->m_arElements.push_back(pElement);
@@ -1756,16 +1750,15 @@ void CPPTUserInfo::LoadMaster(CRecordSlide* pMaster, CSlideInfo *& pMasterWrappe
 
 	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);
+		NSPresentationEditor::CElementPtr pElement = oArrayShapes[nShape]->GetElement(&m_oExMedia, lOriginWidth, lOriginHeight, pTheme, pLayout, pMasterWrapper, pMasterWrapper);
 
-		if (NULL != pElement)
+		if (pElement)
 		{
 			//AddAnimation ( dwMasterID, lOriginWidth, lOriginHeight, pElement );
 			
 			if (pElement->m_bIsBackground && !pElement->m_bHaveAnchor)
 			{
-				CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement);
+				CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement.get());
 				if (NULL != pShape)
 				{
 					pShape->SetupProperties(NULL, pTheme, pLayout);
@@ -1773,8 +1766,6 @@ void CPPTUserInfo::LoadMaster(CRecordSlide* pMaster, CSlideInfo *& pMasterWrappe
 					pTheme->m_bIsBackground = true;
 					pTheme->m_oBackground = pShape->m_oBrush;
 				}
-
-				RELEASEINTERFACE(pElement);
 				continue;
 			}
 			pTheme->m_arElements.push_back(pElement);
@@ -1948,16 +1939,15 @@ void CPPTUserInfo::LoadNoMainMaster(DWORD dwMasterID, const LONG& lOriginWidth,
 
 	for (size_t nShape = 0; nShape < oArrayShapes.size(); ++nShape)
 	{
-		IElement* pElement = NULL;
-		oArrayShapes[nShape]->GetElement(&pElement, &m_oExMedia, lOriginWidth, lOriginHeight, pTheme, pLayout, pThemeWrapper, pMasterWrapper);
+		CElementPtr pElement =oArrayShapes[nShape]->GetElement(&m_oExMedia, lOriginWidth, lOriginHeight, pTheme, pLayout, pThemeWrapper, pMasterWrapper);
 
-		if (NULL != pElement)
+		if (pElement)
 		{
 			AddAnimation ( dwMasterID, lOriginWidth, lOriginHeight, pElement );
 
 			if (pElement->m_bIsBackground && !pElement->m_bHaveAnchor)
 			{
-				CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement);
+				CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement.get());
 
 				if (NULL != pShape)
 				{
@@ -1966,7 +1956,6 @@ void CPPTUserInfo::LoadNoMainMaster(DWORD dwMasterID, const LONG& lOriginWidth,
 					pLayout->m_bIsBackground = true;
 					pLayout->m_oBackground	= pShape->m_oBrush;
 				}
-				RELEASEINTERFACE(pElement);
 				continue;
 			}
 
@@ -2385,7 +2374,7 @@ void CPPTUserInfo::LoadExAudio(CRecordsContainer* pExObject)
 	oArrayCString.clear();
 }
 
-void CPPTUserInfo::AddAnimation ( DWORD dwSlideID, double Width, double Height, IElement* pElement )
+void CPPTUserInfo::AddAnimation ( DWORD dwSlideID, double Width, double Height, CElementPtr pElement )
 {
 	std::map <DWORD, Animations::CSlideTimeLine*>::iterator pPair =	m_mapAnimations.find( dwSlideID );
 
@@ -2439,7 +2428,7 @@ void CPPTUserInfo::AddAudioTransition (DWORD dwSlideID, CTransition* pTransition
 	}
 	// ??? недоделка ???
 
-	pAudio->Release();
+	delete pAudio;
 }
 
 void CPPTUserInfo::CreateDefaultStyle(NSPresentationEditor::CTextStyles& pStyle, NSPresentationEditor::CTheme* pTheme)

ASCOfficePPTFile/PPTFormatLib/Reader/PPTDocumentInfoOneUser.h

@@ -310,15 +310,15 @@ public:
 		return _T("blank");
 	}
 	
-	void AddAnimation		(DWORD dwSlideID, double Width, double Height, IElement* pElement);
+	void AddAnimation		(DWORD dwSlideID, double Width, double Height, CElementPtr pElement);
 	void AddAudioTransition (DWORD dwSlideID, CTransition* pTransition, const std::wstring& strFilePath);
 
 	int			AddNewLayout(NSPresentationEditor::CTheme* pTheme, CRecordSlide* pRecordSlide, bool addShapes, bool bMasterObjects);
 	
-	IElement*	AddNewLayoutPlaceholder		(CLayout *pLayout,	int placeholderType, int placeholderSizePreset = -1);
+	CElementPtr	AddNewLayoutPlaceholder		(CLayout *pLayout,	int placeholderType, int placeholderSizePreset = -1);
 
-	IElement*	AddNewThemePlaceholder		(CTheme* pTheme,	int placeholderType, int placeholderSizePreset = -1);
+	CElementPtr	AddNewThemePlaceholder		(CTheme* pTheme,	int placeholderType, int placeholderSizePreset = -1);
 	
-	IElement*	AddThemeLayoutPlaceholder	(CLayout *pLayout,	int placeholderType, CTheme* pTheme, bool idx_only = false);
-	IElement*	AddLayoutSlidePlaceholder	(CSlide *pSlide,	int placeholderType, CLayout *pLayout, bool idx_only = false);
+	CElementPtr	AddThemeLayoutPlaceholder	(CLayout *pLayout,	int placeholderType, CTheme* pTheme, bool idx_only = false);
+	CElementPtr	AddLayoutSlidePlaceholder	(CSlide *pSlide,	int placeholderType, CLayout *pLayout, bool idx_only = false);
 };

ASCOfficePPTFile/PPTFormatLib/Records/Drawing/ShapeContainer.h

@@ -113,9 +113,9 @@ public:
 		}
 		return false;
 	}
-	CColor CorrectSysColor(int nColorCode, IElement* pElement, CTheme* pTheme)
+	CColor CorrectSysColor(int nColorCode, CElementPtr pElement, CTheme* pTheme)
 	{
-		if (pElement == NULL) return CColor();
+		if (!pElement) return CColor();
 
 		CColor  color;
 
@@ -229,7 +229,7 @@ public:
 
 		return color;
 	}
-	inline void SetUpProperties(IElement* pElement, CTheme* pTheme, CSlideInfo* pWrapper, CSlide* pSlide, CProperties* pProperties)
+	inline void SetUpProperties(CElementPtr pElement, CTheme* pTheme, CSlideInfo* pWrapper, CSlide* pSlide, CProperties* pProperties)
 	{
 		long lCount = pProperties->m_lCount;
 		switch (pElement->m_etType)
@@ -239,7 +239,7 @@ public:
 				pElement->m_bLine = false;
 				for (long i = 0; i < lCount; ++i)
 				{
-					SetUpPropertyVideo((CVideoElement*)pElement, pTheme, pWrapper, pSlide, &pProperties->m_arProperties[i]);
+					SetUpPropertyVideo(pElement, pTheme, pWrapper, pSlide, &pProperties->m_arProperties[i]);
 				}
 				break;
 			}
@@ -249,7 +249,7 @@ public:
 				pElement->m_bLine = false;
 				for (long i = 0; i < lCount; ++i)
 				{
-					SetUpPropertyImage((CImageElement*)pElement, pTheme, pWrapper, pSlide, &pProperties->m_arProperties[i]);
+					SetUpPropertyImage(pElement, pTheme, pWrapper, pSlide, &pProperties->m_arProperties[i]);
 				}
 				break;
 			}
@@ -258,14 +258,14 @@ public:
 				pElement->m_bLine = false;
 				for (long i = 0; i < lCount; ++i)
 				{
-					SetUpPropertyAudio((CAudioElement*)pElement, pTheme, pWrapper, pSlide, &pProperties->m_arProperties[i]);
+					SetUpPropertyAudio(pElement, pTheme, pWrapper, pSlide, &pProperties->m_arProperties[i]);
 				}
 				break;
 			}
 		case NSPresentationEditor::etShape:
 			{
-				CShapeElement* pShapeElem = (CShapeElement*)pElement;
-				CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(pShapeElem->m_oShape.getBaseShape());
+				CShapeElement* pShapeElem = dynamic_cast<CShapeElement*>(pElement.get());
+				CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(pShapeElem->m_pShape->getBaseShape().get());
 
 				if (NULL != pPPTShape)
 				{
@@ -274,7 +274,7 @@ public:
 
 				for (long i = 0; i < lCount; ++i)
 				{
-					SetUpPropertyShape(pShapeElem, pTheme, pWrapper, pSlide, &pProperties->m_arProperties[i]);
+					SetUpPropertyShape(pElement, pTheme, pWrapper, pSlide, &pProperties->m_arProperties[i]);
 				}
 
 				if (NULL != pPPTShape)
@@ -289,7 +289,7 @@ public:
 		}
 	}
 
-	inline void SetUpProperty(IElement* pElement, CTheme* pTheme, CSlideInfo* pInfo, CSlide* pSlide, CProperty* pProperty)
+	inline void SetUpProperty(CElementPtr pElement, CTheme* pTheme, CSlideInfo* pInfo, CSlide* pSlide, CProperty* pProperty)
 	{
 		bool bIsFilled	= true;
 
@@ -797,17 +797,19 @@ public:
 		}
 	}
 
-	inline void SetUpPropertyVideo(CVideoElement* pElement, CTheme* pTheme, CSlideInfo* pInfo, CSlide* pSlide, CProperty* pProperty)
+	inline void SetUpPropertyVideo(CElementPtr pElement, CTheme* pTheme, CSlideInfo* pInfo, CSlide* pSlide, CProperty* pProperty)
 	{
-		SetUpPropertyImage((CImageElement*)pElement, pTheme, pInfo, pSlide, pProperty);
+		SetUpPropertyImage(pElement, pTheme, pInfo, pSlide, pProperty);
 	}
-	inline void SetUpPropertyAudio(CAudioElement* pElement, CTheme* pTheme, CSlideInfo* pInfo, CSlide* pSlide, CProperty* pProperty)
+	inline void SetUpPropertyAudio(CElementPtr pElement, CTheme* pTheme, CSlideInfo* pInfo, CSlide* pSlide, CProperty* pProperty)
 	{
-		SetUpPropertyImage((CImageElement*)pElement, pTheme, pInfo, pSlide, pProperty);
+		SetUpPropertyImage(pElement, pTheme, pInfo, pSlide, pProperty);
 	}
-	inline void SetUpPropertyImage(CImageElement* pElement, CTheme* pTheme, CSlideInfo* pInfo, CSlide* pSlide, CProperty* pProperty)
+	inline void SetUpPropertyImage(CElementPtr pElement, CTheme* pTheme, CSlideInfo* pInfo, CSlide* pSlide, CProperty* pProperty)
 	{
-		SetUpProperty((IElement*)pElement, pTheme, pInfo, pSlide, pProperty);
+		SetUpProperty(pElement, pTheme, pInfo, pSlide, pProperty);
+
+		CImageElement* image_element = dynamic_cast<CImageElement*>(pElement.get());
 
 		switch(pProperty->m_ePID)
 		{
@@ -816,50 +818,55 @@ public:
 				int dwOffset = pInfo->GetIndexPicture(pProperty->m_lValue);
 				if (dwOffset >=0)
 				{
-					pElement->m_strImageFileName	+=  pInfo->GetFileNamePicture(dwOffset);
-					pElement->m_bImagePresent		= true;
+					image_element->m_strImageFileName	+=  pInfo->GetFileNamePicture(dwOffset);
+					image_element->m_bImagePresent		= true;
 				}
 			}break;
 		case pictureId://OLE identifier of the picture.
 			{
-				pElement->m_bOLE	= true;
+				image_element->m_bOLE	= true;
 			}break;
 		case pibName:
 			{
-				pElement->m_sImageName = NSFile::CUtf8Converter::GetWStringFromUTF16((unsigned short*)pProperty->m_pOptions, pProperty->m_lValue /2-1);
+				image_element->m_sImageName = NSFile::CUtf8Converter::GetWStringFromUTF16((unsigned short*)pProperty->m_pOptions, pProperty->m_lValue /2-1);
 				// TextMining05.ppt, слайд 20  - некорректное имя ( - todooo потом подчистить его
 			}break;
 		case cropFromTop:
 			{
-				pElement->m_lcropFromTop = pProperty->m_lValue; 
-				pElement->m_bCropEnabled = true;
+				image_element->m_lcropFromTop = pProperty->m_lValue; 
+				image_element->m_bCropEnabled = true;
 			}break;
 		case cropFromBottom:
 			{
-				pElement->m_lcropFromBottom = pProperty->m_lValue; 
-				pElement->m_bCropEnabled = true;
+				image_element->m_lcropFromBottom = pProperty->m_lValue; 
+				image_element->m_bCropEnabled = true;
 			}break;
 		case cropFromLeft:
 			{
-				pElement->m_lcropFromLeft = pProperty->m_lValue; 
-				pElement->m_bCropEnabled = true;
+				image_element->m_lcropFromLeft = pProperty->m_lValue; 
+				image_element->m_bCropEnabled = true;
 			}break;
 		case cropFromRight:
 			{
-				pElement->m_lcropFromRight = pProperty->m_lValue; 
-				pElement->m_bCropEnabled = true;
+				image_element->m_lcropFromRight = pProperty->m_lValue; 
+				image_element->m_bCropEnabled = true;
 			}break;
 		case pibFlags:
 			{
 			}break;
 		}
 	}
-	inline void SetUpPropertyShape(CShapeElement* pElement, CTheme* pTheme, CSlideInfo* pInfo, CSlide* pSlide, CProperty* pProperty)
+	inline void SetUpPropertyShape(CElementPtr pElement, CTheme* pTheme, CSlideInfo* pInfo, CSlide* pSlide, CProperty* pProperty)
 	{
-		SetUpProperty((IElement*)pElement, pTheme, pInfo, pSlide, pProperty);
+		SetUpProperty(pElement, pTheme, pInfo, pSlide, pProperty);
 
-		CShape* pParentShape	= &pElement->m_oShape;
-		CPPTShape* pShape		= dynamic_cast<CPPTShape*>(pParentShape->getBaseShape());
+		CShapeElement* shape_element = dynamic_cast<CShapeElement*>(pElement.get());
+
+		CShapePtr pParentShape = shape_element->m_pShape;
+		if (NULL == pParentShape)
+			return;
+
+		CPPTShape* pShape = dynamic_cast<CPPTShape*>(pParentShape->getBaseShape().get());
 
 		if (NULL == pShape)
 			return;
@@ -1238,22 +1245,19 @@ public:
 	}
 
 
-	virtual void GetElement (IElement** ppElement, CExMedia* pMapIDs,
+	CElementPtr GetElement (CExMedia* pMapIDs,
 							long lSlideWidth, long lSlideHeight, CTheme* pTheme, CLayout* pLayout, 
 							CSlideInfo* pThemeWrapper, CSlideInfo* pSlideWrapper, CSlide* pSlide = NULL)
 	{
-		if (NULL == ppElement)	
-			return;
+		if (bGroupShape) return CElementPtr();
 
-		if (bGroupShape) return;
-
-		*ppElement = NULL;
+		CElementPtr pElement;
 
 		std::vector<CRecordShape*> oArrayShape;
 		GetRecordsByType(&oArrayShape, true, true);
 
 		if (0 == oArrayShape.size())
-			return;
+			return pElement;
 
 		std::vector<CRecordPlaceHolderAtom*> oArrayPlaceHolder;
 		GetRecordsByType(&oArrayPlaceHolder, true, true);
@@ -1266,7 +1270,7 @@ public:
 
 		int lMasterID = -1;
 
-		IElement * pElementLayout = NULL;
+		CElementPtr pElementLayout;
 		
 		if (NULL != pSlide)
 		{
@@ -1301,13 +1305,13 @@ public:
 											pLayout->m_arElements[nIndex]->m_lPlaceholderID = placeholder_id;
 									}  
 
-									*ppElement = pLayout->m_arElements[nIndex]->CreateDublicate();								
+									pElement = pLayout->m_arElements[nIndex]->CreateDublicate();								
 
 									if (elType == etShape)
 									{
-										CShapeElement* pShape = dynamic_cast<CShapeElement*>(*ppElement);
+										CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement.get());
 										if (NULL != pShape)
-											pShape->m_oShape.m_oText.m_arParagraphs.clear();
+											pShape->m_pShape->m_oText.m_arParagraphs.clear();
 									}
               
 									break;
@@ -1321,9 +1325,7 @@ public:
 		}
 		// раньше искался шейп - и делался дубликат. Теперь думаю это не нужно
 		// нужно ориентироваться на placeholder (type & id)						
-		IElement* pElem = *ppElement;
-
-		if (NULL == pElem)
+		if (!pElement)
 		{
 			switch (eType)
 			{
@@ -1362,11 +1364,12 @@ public:
 						pVideoElem->m_strVideoFileName	= oInfo.m_strFilePath ;
 						pVideoElem->m_strImageFileName	= oInfoDefault.m_strFilePath + FILE_SEPARATOR_STR;
 
-						pElem							= (IElement*)pVideoElem;
+						pElement = CElementPtr(pVideoElem);
 					}
 					else if (CExFilesInfo::eftAudio == exType)
 					{
 						CAudioElement* pAudioElem		= new CAudioElement();
+						pElement = CElementPtr(pAudioElem);
 						
 						pAudioElem->m_strAudioFileName	= oInfo.m_strFilePath;
 						pAudioElem->m_strImageFileName	= oInfoDefault.m_strFilePath + FILE_SEPARATOR_STR;
@@ -1385,39 +1388,38 @@ public:
 						else
                         {
                             if (pLayout)
-                                pLayout->m_arElements.push_back(pAudioElem);
+                                pLayout->m_arElements.push_back(pElement);
                         }
 
-						pElem = (IElement*)pAudioElem;
 					}
 					else 
 					{
 						CImageElement* pImageElem		= new CImageElement();
 						pImageElem->m_strImageFileName	= oInfo.m_strFilePath + FILE_SEPARATOR_STR;
 
-						pElem = (IElement*)pImageElem;
+						pElement = CElementPtr(pImageElem);
 					}					
 				}break;
 			default:
 				{
 					// shape
 					CShapeElement* pShape = new CShapeElement(NSBaseShape::ppt, eType);
-					CPPTShape *ppt_shape = dynamic_cast<CPPTShape *>(pShape->m_oShape.getBaseShape());
+					CPPTShape *ppt_shape = dynamic_cast<CPPTShape *>(pShape->m_pShape->getBaseShape().get());
 
 					if ( (ppt_shape) && (OOXMLShapes::sptCustom == ppt_shape->m_eType))
 					{
 						pShape->m_bShapePreset = true;
 					}
-					pElem = (IElement*)pShape;					
+					pElement = CElementPtr(pShape);					
 				}break;
 			}
 		}
 
-		if (NULL == pElem)
-			return;
+		if (!pElement)
+			return pElement;
 
-		pElem->m_lID		= oArrayShape[0]->m_nID;
-		pElem->m_lLayoutID	= lMasterID;
+		pElement->m_lID		= oArrayShape[0]->m_nID;
+		pElement->m_lLayoutID	= lMasterID;
 
 //---------внешние ссылки 
 		{
@@ -1426,7 +1428,7 @@ public:
 
 			if (NULL != pTextureInfo)
 			{
-				pElem->m_oBrush.TexturePath = pTextureInfo->m_strFilePath + FILE_SEPARATOR_STR;
+				pElement->m_oBrush.TexturePath = pTextureInfo->m_strFilePath + FILE_SEPARATOR_STR;
 			}
 
 			std::vector<CRecordExObjRefAtom*> oArrayEx;
@@ -1437,7 +1439,7 @@ public:
 
 				if (CExFilesInfo::eftHyperlink == exType && pInfo)
 				{
-					pElem->m_sHyperlink = pInfo->m_strFilePath;
+					pElement->m_sHyperlink = pInfo->m_strFilePath;
 				}
 			}
 		}
@@ -1446,30 +1448,30 @@ public:
 		// placeholders
 		if (0 < oArrayPlaceHolder.size())
 		{
-			pElem->m_bLine					= false; //по умолчанию у них нет линий
-			pElem->m_lPlaceholderID			= oArrayPlaceHolder[0]->m_nPosition;
-			pElem->m_lPlaceholderType		= oArrayPlaceHolder[0]->m_nPlacementID;
-			pElem->m_lPlaceholderSizePreset	= oArrayPlaceHolder[0]->m_nSize;
+			pElement->m_bLine					= false; //по умолчанию у них нет линий
+			pElement->m_lPlaceholderID			= oArrayPlaceHolder[0]->m_nPosition;
+			pElement->m_lPlaceholderType		= oArrayPlaceHolder[0]->m_nPlacementID;
+			pElement->m_lPlaceholderSizePreset	= oArrayPlaceHolder[0]->m_nSize;
 
 			if (pElementLayout) 
 				pElementLayout->m_lPlaceholderSizePreset	= oArrayPlaceHolder[0]->m_nSize;
 
-			CorrectPlaceholderType(pElem->m_lPlaceholderType);
+			CorrectPlaceholderType(pElement->m_lPlaceholderType);
 		}
 
 		std::vector<CRecordRoundTripHFPlaceholder12Atom*> oArrayHFPlaceholder;
 		GetRecordsByType(&oArrayHFPlaceholder, true, true);
 		if (0 < oArrayHFPlaceholder.size())
 		{
-			pElem->m_lPlaceholderType	= oArrayHFPlaceholder[0]->m_nPlacementID;//PT_MasterDate, PT_MasterSlideNumber, PT_MasterFooter, or PT_MasterHeader
-			CorrectPlaceholderType(pElem->m_lPlaceholderType);
+			pElement->m_lPlaceholderType	= oArrayHFPlaceholder[0]->m_nPlacementID;//PT_MasterDate, PT_MasterSlideNumber, PT_MasterFooter, or PT_MasterHeader
+			CorrectPlaceholderType(pElement->m_lPlaceholderType);
 			
 			if (pLayout)
 			{
-				std::multimap<int, int>::iterator it = pLayout->m_mapPlaceholders.find(pElem->m_lPlaceholderType);
+				std::multimap<int, int>::iterator it = pLayout->m_mapPlaceholders.find(pElement->m_lPlaceholderType);
 				if (it != pLayout->m_mapPlaceholders.end())
 				{
-					pElem->m_lPlaceholderID = pLayout->m_arElements[it->second]->m_lPlaceholderID;
+					pElement->m_lPlaceholderID = pLayout->m_arElements[it->second]->m_lPlaceholderID;
 				}
 			}
 		}
@@ -1479,31 +1481,31 @@ public:
 		GetRecordsByType(&oArrayFooterMeta, true, true);
 		if (0 < oArrayFooterMeta.size())
 		{
-			pElem->m_lPlaceholderType		= PT_MasterFooter;
-			pElem->m_lPlaceholderUserStr	= oArrayFooterMeta[0]->m_nPosition;
+			pElement->m_lPlaceholderType		= PT_MasterFooter;
+			pElement->m_lPlaceholderUserStr	= oArrayFooterMeta[0]->m_nPosition;
 		}
 		std::vector<CRecordSlideNumberMetaAtom*> oArraySlideNumberMeta;
 		GetRecordsByType(&oArraySlideNumberMeta, true, true);
 		if (0 < oArraySlideNumberMeta.size())
 		{
-			pElem->m_lPlaceholderType = PT_MasterSlideNumber;
+			pElement->m_lPlaceholderType = PT_MasterSlideNumber;
 		}
 		std::vector<CRecordGenericDateMetaAtom*> oArrayDateMeta;
 		GetRecordsByType(&oArrayDateMeta, true, true);
 		if (0 < oArrayDateMeta.size())
 		{
-			pElem->m_lPlaceholderType		= PT_MasterDate;
+			pElement->m_lPlaceholderType		= PT_MasterDate;
 			
 			CRecordDateTimeMetaAtom* format_data = dynamic_cast<CRecordDateTimeMetaAtom*>(oArrayDateMeta[0]);
 			if (format_data)
 			{
-				pElem->m_nFormatDate			= 1;
+				pElement->m_nFormatDate			= 1;
 				//todooo сделать форматированый вывод 
 			}
 			else
 			{
-				pElem->m_lPlaceholderUserStr	= oArrayDateMeta[0]->m_nPosition;
-				pElem->m_nFormatDate			= 2;
+				pElement->m_lPlaceholderUserStr	= oArrayDateMeta[0]->m_nPosition;
+				pElement->m_nFormatDate			= 2;
 			}
 		}
 //------------- привязки ---------------------------------------------------------------------------------
@@ -1514,12 +1516,12 @@ public:
 
 		if (0 != oArrayAnchor.size())
 		{
-			pElem->m_rcBoundsOriginal.left		= (LONG)oArrayAnchor[0]->m_oBounds.Left;
-			pElem->m_rcBoundsOriginal.top		= (LONG)oArrayAnchor[0]->m_oBounds.Top;
-			pElem->m_rcBoundsOriginal.right		= (LONG)oArrayAnchor[0]->m_oBounds.Right;
-			pElem->m_rcBoundsOriginal.bottom	= (LONG)oArrayAnchor[0]->m_oBounds.Bottom;
+			pElement->m_rcBoundsOriginal.left		= (LONG)oArrayAnchor[0]->m_oBounds.Left;
+			pElement->m_rcBoundsOriginal.top		= (LONG)oArrayAnchor[0]->m_oBounds.Top;
+			pElement->m_rcBoundsOriginal.right		= (LONG)oArrayAnchor[0]->m_oBounds.Right;
+			pElement->m_rcBoundsOriginal.bottom	= (LONG)oArrayAnchor[0]->m_oBounds.Bottom;
 			
-			pElem->m_bBoundsEnabled	= true;
+			pElement->m_bBoundsEnabled	= true;
 			bAnchor = true;
 		}
 		else
@@ -1529,14 +1531,14 @@ public:
 
 			if (0 != oArrayChildAnchor.size())
 			{
-				pElem->m_rcBoundsOriginal.left		= oArrayChildAnchor[0]->m_oBounds.left;
-				pElem->m_rcBoundsOriginal.top		= oArrayChildAnchor[0]->m_oBounds.top;
-				pElem->m_rcBoundsOriginal.right		= oArrayChildAnchor[0]->m_oBounds.right;
-				pElem->m_rcBoundsOriginal.bottom	= oArrayChildAnchor[0]->m_oBounds.bottom;
+				pElement->m_rcBoundsOriginal.left		= oArrayChildAnchor[0]->m_oBounds.left;
+				pElement->m_rcBoundsOriginal.top		= oArrayChildAnchor[0]->m_oBounds.top;
+				pElement->m_rcBoundsOriginal.right		= oArrayChildAnchor[0]->m_oBounds.right;
+				pElement->m_rcBoundsOriginal.bottom	= oArrayChildAnchor[0]->m_oBounds.bottom;
 
-				RecalcGroupShapeAnchor(pElem->m_rcBoundsOriginal);
+				RecalcGroupShapeAnchor(pElement->m_rcBoundsOriginal);
 			
-				pElem->m_bBoundsEnabled	= true;
+				pElement->m_bBoundsEnabled	= true;
 				bAnchor = true;
 			}
 			else
@@ -1544,18 +1546,18 @@ public:
 				if (oArrayShape[0]->m_bBackground)
 				{
 					// здесь background
-					pElem->m_rcBoundsOriginal.left		= 0;
-					pElem->m_rcBoundsOriginal.top		= 0;
-					pElem->m_rcBoundsOriginal.right		= lSlideWidth;
-					pElem->m_rcBoundsOriginal.bottom	= lSlideHeight;
+					pElement->m_rcBoundsOriginal.left		= 0;
+					pElement->m_rcBoundsOriginal.top		= 0;
+					pElement->m_rcBoundsOriginal.right		= lSlideWidth;
+					pElement->m_rcBoundsOriginal.bottom	= lSlideHeight;
 				}
 				else
 				{
 					// не понятно...			
-					pElem->m_rcBoundsOriginal.left		= 0;
-					pElem->m_rcBoundsOriginal.top		= 0;
-					pElem->m_rcBoundsOriginal.right		= 0;
-					pElem->m_rcBoundsOriginal.bottom	= 0;
+					pElement->m_rcBoundsOriginal.left		= 0;
+					pElement->m_rcBoundsOriginal.top		= 0;
+					pElement->m_rcBoundsOriginal.right		= 0;
+					pElement->m_rcBoundsOriginal.bottom	= 0;
 				}
 			}
 		}
@@ -1563,30 +1565,30 @@ public:
 		double dScaleX = c_dMasterUnitsToMillimetreKoef;
 		double dScaleY = c_dMasterUnitsToMillimetreKoef;
 
-		pElem->NormalizeCoords(dScaleX, dScaleY);
+		pElement->NormalizeCoords(dScaleX, dScaleY);
 
-		pElem->m_bFlipH = oArrayShape[0]->m_bFlipH;
-		pElem->m_bFlipV = oArrayShape[0]->m_bFlipV;
+		pElement->m_bFlipH = oArrayShape[0]->m_bFlipH;
+		pElement->m_bFlipV = oArrayShape[0]->m_bFlipV;
 
 
 		if (pElementLayout && bAnchor)
 		{
-			pElementLayout->m_rcBoundsOriginal	= pElem->m_rcBoundsOriginal;
-			pElementLayout->m_rcBounds			= pElem->m_rcBounds;
+			pElementLayout->m_rcBoundsOriginal	= pElement->m_rcBoundsOriginal;
+			pElementLayout->m_rcBounds			= pElement->m_rcBounds;
 
 			pElementLayout->m_bPlaceholderSet	= true;
 			pElementLayout->m_bBoundsEnabled	= true;
 		}
 //--------- наличие текста --------------------------------------------------------------------------
-		CShapeElement* pShapeElem = dynamic_cast<CShapeElement*>(pElem);
+		CShapeElement* pShapeElem = dynamic_cast<CShapeElement*>(pElement.get());
 		if (NULL != pShapeElem)
 		{
 			CElementInfo oElementInfo;
 
-			oElementInfo.m_lMasterPlaceholderType = pElem->m_lPlaceholderType;
+			oElementInfo.m_lMasterPlaceholderType = pElement->m_lPlaceholderType;
 
-			pShapeElem->m_oShape.m_dWidthLogic  = ShapeSizeVML;
-			pShapeElem->m_oShape.m_dHeightLogic = ShapeSizeVML;
+			pShapeElem->m_pShape->m_dWidthLogic  = ShapeSizeVML;
+			pShapeElem->m_pShape->m_dHeightLogic = ShapeSizeVML;
 
 			// проверка на textheader present
 			std::vector<CRecordTextHeaderAtom*> oArrayTextHeader;
@@ -1594,14 +1596,14 @@ public:
 			
 			if (0 < oArrayTextHeader.size())
 			{
-				pShapeElem->m_oShape.m_oText.m_lTextType		= oArrayTextHeader[0]->m_nTextType;
-				pShapeElem->m_oShape.m_oText.m_lTextMasterType	= oArrayTextHeader[0]->m_nTextType;
+				pShapeElem->m_pShape->m_oText.m_lTextType		= oArrayTextHeader[0]->m_nTextType;
+				pShapeElem->m_pShape->m_oText.m_lTextMasterType	= oArrayTextHeader[0]->m_nTextType;
 				oElementInfo.m_lMasterTextType					= oArrayTextHeader[0]->m_nTextType;
 			}
 			else
 			{
-				pShapeElem->m_oShape.m_oText.m_lTextType		= NSOfficePPT::NoPresent;
-				pShapeElem->m_oShape.m_oText.m_lTextMasterType	= NSOfficePPT::NoPresent;
+				pShapeElem->m_pShape->m_oText.m_lTextType		= NSOfficePPT::NoPresent;
+				pShapeElem->m_pShape->m_oText.m_lTextMasterType	= NSOfficePPT::NoPresent;
 				oElementInfo.m_lMasterTextType					= NSOfficePPT::NoPresent;
 			}
 
@@ -1630,17 +1632,17 @@ public:
 				strShapeText = oArrayTextChars[0]->m_strText;
 			}
 
-			if (pElem->m_lPlaceholderType == PT_MasterSlideNumber && strShapeText.length() > 5)
+			if (pElement->m_lPlaceholderType == PT_MasterSlideNumber && strShapeText.length() > 5)
 			{
 				int pos = strShapeText.find(L"*"); 
-				if (pos < 0) pElem->m_lPlaceholderType = PT_MasterFooter; ///???? 1-(33).ppt
+				if (pos < 0) pElement->m_lPlaceholderType = PT_MasterFooter; ///???? 1-(33).ppt
 			}
 
 //------ shape properties ----------------------------------------------------------------------------------------
 			for (int nIndexProp = 0; nIndexProp < oArrayOptions.size(); ++nIndexProp)
 			{
 				CPPTElement oElement;
-				oElement.SetUpProperties(pElem, pTheme, pSlideWrapper, pSlide, &oArrayOptions[nIndexProp]->m_oProperties);
+				oElement.SetUpProperties(pElement, pTheme, pSlideWrapper, pSlide, &oArrayOptions[nIndexProp]->m_oProperties);
 			}
 
 			std::vector<CRecordStyleTextPropAtom*> oArrayTextStyle;
@@ -1663,7 +1665,7 @@ public:
 			this->GetRecordsByType(&oArrayTextRuler, true, true);
 			if (0 != oArrayTextRuler.size())
 			{
-				pShapeElem->m_oShape.m_oText.m_oRuler = oArrayTextRuler[0]->m_oTextRuler;
+				pShapeElem->m_pShape->m_oText.m_oRuler = oArrayTextRuler[0]->m_oTextRuler;
 			}
 
 			std::vector<CRecordInteractiveInfoAtom*> oArrayInteractive;
@@ -1750,38 +1752,38 @@ public:
 
 			pSlideWrapper->m_mapElements.insert(std::pair<LONG, CElementInfo>(pShapeElem->m_lID, oElementInfo));
 			
-			SetUpTextStyle(strShapeText, pTheme, pLayout, pElem, pThemeWrapper, pSlideWrapper, pSlide, master_level);
+			SetUpTextStyle(strShapeText, pTheme, pLayout, pElement, pThemeWrapper, pSlideWrapper, pSlide, master_level);
 		}
 		else
 		{//image, audio, video ....
 			for (int nIndexProp = 0; nIndexProp < oArrayOptions.size(); ++nIndexProp)
 			{
 				CPPTElement oElement;
-				oElement.SetUpProperties(pElem, pTheme, pSlideWrapper, pSlide, &oArrayOptions[nIndexProp]->m_oProperties);
+				oElement.SetUpProperties(pElement, pTheme, pSlideWrapper, pSlide, &oArrayOptions[nIndexProp]->m_oProperties);
 			}
 
-			pElem->m_lLayoutID = lMasterID;
+			pElement->m_lLayoutID = lMasterID;
 		}
 //----------------------------------------------------------------------------------------------------
 		if (NULL != pSlide)
 		{
-			pElem->m_dStartTime		= pSlide->m_dStartTime;
-			pElem->m_dEndTime		= pSlide->m_dEndTime;
+			pElement->m_dStartTime		= pSlide->m_dStartTime;
+			pElement->m_dEndTime		= pSlide->m_dEndTime;
 
-			pElem->m_oMetric.SetUnitsContainerSize(pSlide->m_lOriginalWidth, pSlide->m_lOriginalHeight);
+			pElement->m_oMetric.SetUnitsContainerSize(pSlide->m_lOriginalWidth, pSlide->m_lOriginalHeight);
 		}
 		else
 		{
-			pElem->m_dStartTime		= 0;
-			pElem->m_dEndTime		= 0;
+			pElement->m_dStartTime		= 0;
+			pElement->m_dEndTime		= 0;
 
-			pElem->m_oMetric.SetUnitsContainerSize(lSlideWidth, lSlideHeight);
+			pElement->m_oMetric.SetUnitsContainerSize(lSlideWidth, lSlideHeight);
 		}
 
-		pElem->m_bIsBackground	=	(true == oArrayShape[0]->m_bBackground);
-		pElem->m_bHaveAnchor	=	(true == oArrayShape[0]->m_bHaveAnchor);
+		pElement->m_bIsBackground	=	(true == oArrayShape[0]->m_bBackground);
+		pElement->m_bHaveAnchor		=	(true == oArrayShape[0]->m_bHaveAnchor);
 
-		*ppElement = pElem;
+		return pElement;
 	}
 
 	void RecalcGroupShapeAnchor(CDoubleRect& rcChildAnchor)
@@ -1847,13 +1849,13 @@ public:
 
 protected:
 
-	void ApplyThemeStyle(IElement* pElem, CTheme* pTheme, CRecordMasterTextPropAtom* master_levels)
+	void ApplyThemeStyle(CElementPtr pElem, CTheme* pTheme, CRecordMasterTextPropAtom* master_levels)
 	{
-		CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElem);
+		CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElem.get());
 		if (NULL == pShape)
 			return;
 		
-		CTextAttributesEx* pText = &(pShape->m_oShape.m_oText);
+		CTextAttributesEx* pText = &(pShape->m_pShape->m_oText);
 
 		
 		if (master_levels)
@@ -1871,7 +1873,7 @@ protected:
 		pText->ApplyThemeStyle(pTheme);
 
 	}
-	void SetUpTextStyle(std::wstring& strText, CTheme* pTheme, CLayout* pLayout, IElement* pElem, CSlideInfo* pThemeWrapper, CSlideInfo* pSlideWrapper, CSlide* pSlide, CRecordMasterTextPropAtom* master_levels)
+	void SetUpTextStyle(std::wstring& strText, CTheme* pTheme, CLayout* pLayout, CElementPtr pElem, CSlideInfo* pThemeWrapper, CSlideInfo* pSlideWrapper, CSlide* pSlide, CRecordMasterTextPropAtom* master_levels)
 	{
 		// сначала проверяем на shape
 		// затем применяем все настройки по-очереди
@@ -1891,11 +1893,11 @@ protected:
 		if (etShape != pElem->m_etType)
 			return;
 
-		CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElem);
+		CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElem.get());
 		if (NULL == pShape)
 			return;
 
-		CTextAttributesEx* pTextSettings = &(pShape->m_oShape.m_oText);
+		CTextAttributesEx* pTextSettings = &(pShape->m_pShape->m_oText);
 
 		// сначала применим ссылки на masterstyle (для шаблонного элемента)
 		// как узнать - просто есть ли массивы (т.к. они могли появиться пока только оттуда)
@@ -1924,11 +1926,11 @@ protected:
             {
                 for (size_t i = 0; i < pLayout->m_arElements.size(); ++i)
                 {
-                    IElement* pPh = pLayout->m_arElements[i];
+                    CElementPtr & pPh = pLayout->m_arElements[i];
                     if ((etShape == pPh->m_etType) && (ph_type == pPh->m_lPlaceholderType) && (/*ph_pos == pPh->m_lPlaceholderID*/true))
                     {
-                        pElementLayoutPH = dynamic_cast<CShapeElement*>(pPh);
-                        eTypeMaster = (NSOfficePPT::TextType)pElementLayoutPH->m_oShape.m_oText.m_lTextMasterType;
+                        pElementLayoutPH = dynamic_cast<CShapeElement*>(pPh.get());
+                        eTypeMaster = (NSOfficePPT::TextType)pElementLayoutPH->m_pShape->m_oText.m_lTextMasterType;
                         break;
                     }
                 }
@@ -1985,7 +1987,7 @@ protected:
 
 				pStyle->ReadFromStream(oHeader, oElemInfo.m_pStream);
 
-				NSPresentationEditor::ConvertPPTTextToEditorStructure(pStyle->m_arrPFs, pStyle->m_arrCFs, strText, pShape->m_oShape.m_oText);
+				NSPresentationEditor::ConvertPPTTextToEditorStructure(pStyle->m_arrPFs, pStyle->m_arrCFs, strText, pShape->m_pShape->m_oText);
 
 				bIsOwnPresentSettings = (0 < pStyle->m_lCount);
 
@@ -2113,9 +2115,9 @@ protected:
 			{
 				if (NULL != pElementLayoutPH)
 				{
-					pTextSettings->m_oLayoutStyles		= pElementLayoutPH->m_oShape.m_oText.m_oStyles;
-					pTextSettings->m_lTextType			= pElementLayoutPH->m_oShape.m_oText.m_lTextType;
-					pTextSettings->m_lStyleThemeIndex	= pElementLayoutPH->m_oShape.m_oText.m_lStyleThemeIndex;
+					pTextSettings->m_oLayoutStyles		= pElementLayoutPH->m_pShape->m_oText.m_oStyles;
+					pTextSettings->m_lTextType			= pElementLayoutPH->m_pShape->m_oText.m_lTextType;
+					pTextSettings->m_lStyleThemeIndex	= pElementLayoutPH->m_pShape->m_oText.m_lStyleThemeIndex;
 				}
 				else
 				{	
@@ -2225,13 +2227,13 @@ protected:
 				pSpecInfo->m_lCount = -1;
 
 				pSpecInfo->ReadFromStream(oHeader, oElemInfo.m_pStream);
-				pSpecInfo->ApplyProperties(&(pShape->m_oShape.m_oText));
+				pSpecInfo->ApplyProperties(&(pShape->m_pShape->m_oText));
 
 				RELEASEOBJECT(pSpecInfo);
 			}
 			StreamUtils::StreamSeek(lPosition, oElemInfo.m_pStream);
 		}
-		pShape->m_oShape.m_oText.RecalcParagraphsPPT();
+		pShape->m_pShape->m_oText.RecalcParagraphsPPT();
 		
 		ApplyThemeStyle(pElem, pTheme, master_levels);
 
@@ -2247,7 +2249,7 @@ protected:
 			ApplyHyperlink(pShape, oColor);
 		}
 
-		CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(pShape->m_oShape.getBaseShape());
+		CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(pShape->m_pShape->getBaseShape().get());
 
 		if (NULL != pPPTShape)		// проверка на wordart
 		{
@@ -2294,12 +2296,12 @@ protected:
 			case sptTextCanUp:   
 			case sptTextCanDown:
 				{
-					pShape->m_oShape.m_oText.m_oAttributes.m_oTextBrush = pShape->m_oBrush;
+					pShape->m_pShape->m_oText.m_oAttributes.m_oTextBrush = pShape->m_oBrush;
 
-					pShape->m_oShape.m_oText.m_oAttributes.m_nTextAlignHorizontal	= 1;
-					pShape->m_oShape.m_oText.m_oAttributes.m_nTextAlignVertical		= 1;
+					pShape->m_pShape->m_oText.m_oAttributes.m_nTextAlignHorizontal	= 1;
+					pShape->m_pShape->m_oText.m_oAttributes.m_nTextAlignVertical		= 1;
 
-					pShape->m_oShape.m_lDrawType = c_ShapeDrawType_Text;
+					pShape->m_pShape->m_lDrawType = c_ShapeDrawType_Text;
 					break;
 				}
 			default:
@@ -2311,7 +2313,7 @@ protected:
 	void ApplyHyperlink(CShapeElement* pShape, CColor& oColor)
 	{
 		std::vector<CTextRange>* pRanges	= &pShape->m_oTextActions.m_arRanges;
-		CTextAttributesEx* pTextAttributes	= &pShape->m_oShape.m_oText;
+		CTextAttributesEx* pTextAttributes	= &pShape->m_pShape->m_oText;
 
 		int lCountHyper	= pRanges->size();
 

ASCOfficePPTFile/PptFormatTest/PptFormatTest.cpp

@@ -38,6 +38,8 @@
 
 #include <tchar.h>
 
+#pragma comment(lib, "Rpcrt4.lib")
+
 #if defined(_WIN64)
 	#pragma comment(lib, "../../build/bin/icu/win_64/icuuc.lib")
 #elif defined (_WIN32)
@@ -46,6 +48,10 @@
 
 int _tmain(int argc, _TCHAR* argv[])
 {
+//#ifdef _DEBUG
+//		_CrtDumpMemoryLeaks();
+//#endif
+		
 	if (argc < 2) return 1;
 
 	std::wstring sSrcPpt	= argv[1];

ASCOfficePPTFile/PptFormatTest/PptFormatTest.vcproj

@@ -45,7 +45,7 @@
 				Name="VCCLCompilerTool"
 				Optimization="0"
 				AdditionalIncludeDirectories="../../DesktopEditor/xml/build/vs2005;../../DesktopEditor/xml/libxml2/include"
-				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"
+				PreprocessorDefinitions="_DEBUG;_CONSOLE;_USE_MATH_DEFINES;_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"

ASCOfficePPTXFile/ASCOfficeDrawingConverter.cpp

@@ -982,12 +982,12 @@ HRESULT CDrawingConverter::AddShapeType(const std::wstring& bsXml)
         std::wstring strId = oNodeST.GetAttribute(L"id");
 		pShape->LoadFromXMLShapeType(oNodeST);
 
-		CShape* pS = new CShape(NSBaseShape::unknown, 0);
-		pS->setBaseShape(pShape);
+		CShapePtr pS = CShapePtr(new CShape(NSBaseShape::unknown, 0));
+		pS->setBaseShape(CBaseShapePtr(pShape));
 		
 		LoadCoordSize(oNodeST, pS);
 
-		m_mapShapeTypes.insert(std::pair<std::wstring, CShape*>(strId, pS));			
+		m_mapShapeTypes.insert(std::pair<std::wstring, CShapePtr>(strId, pS));			
     }
 
 	return S_OK;
@@ -1687,6 +1687,7 @@ void CDrawingConverter::doc_LoadShape(PPTX::Logic::SpTreeElem *elem, XmlUtils::C
 
 	NSPresentationEditor::CShapeElement oShapeElem;
 	CPPTShape* pPPTShape = NULL;
+	bool bSetShape = false;
 
     if (L"v:background" == strNameNode)
     {
@@ -1845,12 +1846,16 @@ void CDrawingConverter::doc_LoadShape(PPTX::Logic::SpTreeElem *elem, XmlUtils::C
 		{
 			strType = strType.substr(1);
 
-			std::map<std::wstring, CShape*>::iterator pPair = m_mapShapeTypes.find(strType);
+			std::map<std::wstring, CShapePtr>::iterator pPair = m_mapShapeTypes.find(strType);
 			if (m_mapShapeTypes.end() != pPair)
 			{
+                CBaseShapePtr base_shape_type = pPair->second->getBaseShape();
+				CPPTShape* ppt_shape_type = dynamic_cast<CPPTShape*>(base_shape_type.get());
+				
 				pPPTShape = new CPPTShape();
-				pPair->second->getBaseShape()->SetToDublicate(pPPTShape);
-				pPPTShape->m_eType = ((CPPTShape*)(pPair->second->getBaseShape()))->m_eType;
+				base_shape_type->SetToDublicate(pPPTShape);
+
+				pPPTShape->m_eType = ppt_shape_type->m_eType;
 			}
 		}
 		
@@ -1880,28 +1885,30 @@ void CDrawingConverter::doc_LoadShape(PPTX::Logic::SpTreeElem *elem, XmlUtils::C
 				pPPTShape->m_eType = PPTShapes::sptCustom;
 			}			
 		}
-		oShapeElem.m_oShape.setBaseShape(pPPTShape);
+		oShapeElem.m_pShape->setBaseShape(CBaseShapePtr(pPPTShape));
+		bSetShape = true;
 		
 		if (bIsNeedCoordSizes)
 		{
-			LoadCoordPos(oNodeShape, &oShapeElem.m_oShape); //for path calculate
+			LoadCoordPos(oNodeShape, oShapeElem.m_pShape); //for path calculate
 		}
 		pPPTShape->LoadFromXMLShapeType(oNodeShape);
 	}
 
 	if (pPPTShape != NULL)
 	{	
-		oShapeElem.m_oShape.setBaseShape(pPPTShape);
+		if (!bSetShape)
+			oShapeElem.m_pShape->setBaseShape(CBaseShapePtr(pPPTShape));
 		if (bIsNeedCoordSizes)
 		{
-			LoadCoordSize(oNodeShape, &oShapeElem.m_oShape);
+			LoadCoordSize(oNodeShape, oShapeElem.m_pShape);
 		}
 		else
 		{
-			oShapeElem.m_oShape.m_dWidthLogic  = 21600;
-			oShapeElem.m_oShape.m_dHeightLogic = 21600;
+			oShapeElem.m_pShape->m_dWidthLogic  = 21600;
+			oShapeElem.m_pShape->m_dHeightLogic = 21600;
 
-			oShapeElem.m_oShape.getBaseShape()->m_oPath.SetCoordsize(21600, 21600);			
+			oShapeElem.m_pShape->getBaseShape()->m_oPath.SetCoordsize(21600, 21600);			
 		}
 
         std::wstring strXmlPPTX;
@@ -2812,12 +2819,12 @@ void CDrawingConverter::doc_LoadGroup(PPTX::Logic::SpTreeElem *result, XmlUtils:
 
 						pShape->LoadFromXMLShapeType(oNodeT);
 
-						CShape* pS = new CShape(NSBaseShape::unknown, 0);
-						pS->setBaseShape(pShape);
+						CShapePtr pS = CShapePtr(new CShape(NSBaseShape::unknown, 0));
+						pS->setBaseShape(CBaseShapePtr(pShape));
 						
 						LoadCoordSize(oNodeT, pS);
 
-						m_mapShapeTypes.insert(std::pair<std::wstring, CShape*>(strId, pS));	
+						m_mapShapeTypes.insert(std::pair<std::wstring, CShapePtr>(strId, pS));	
 					}
 				}
 			}
@@ -2989,8 +2996,10 @@ void CDrawingConverter::doc_LoadGroup(PPTX::Logic::SpTreeElem *result, XmlUtils:
 	
 	result->InitElem(pTree);
 }
-void CDrawingConverter::LoadCoordPos(XmlUtils::CXmlNode& oNode, CShape* pShape)
+void CDrawingConverter::LoadCoordPos(XmlUtils::CXmlNode& oNode, CShapePtr pShape)
 {
+	if (!pShape) return;
+
 	pShape->m_dXLogic	= 0;
 	pShape->m_dYLogic	= 0;
 
@@ -3030,8 +3039,10 @@ void CDrawingConverter::LoadCoordPos(XmlUtils::CXmlNode& oNode, CShape* pShape)
 }
 
 
-void CDrawingConverter::LoadCoordSize(XmlUtils::CXmlNode& oNode, CShape* pShape)
+void CDrawingConverter::LoadCoordSize(XmlUtils::CXmlNode& oNode, CShapePtr pShape)
 {
+	if (!pShape) return;
+	
 	pShape->m_dWidthLogic	= ShapeSizeVML;
 	pShape->m_dHeightLogic	= ShapeSizeVML;
 
@@ -5327,16 +5338,10 @@ int CDrawingConverter::GetDocumentChartsCount ()
 OOX::CContentTypes* CDrawingConverter::GetContentTypes()
 {
 	return m_pImageManager->m_pContentTypes;
-    //return m_pReader->mm_strContentTypes;
 }
 
 void CDrawingConverter::Clear()
 {
-	for (std::map<std::wstring, CShape*>::iterator pPair = m_mapShapeTypes.begin(); pPair != m_mapShapeTypes.end(); ++pPair)
-	{
-		CShape* pMem = pPair->second;
-		RELEASEOBJECT(pMem);
-	}
 	m_mapShapeTypes.clear();
 }
 void CDrawingConverter::SetRels(smart_ptr<OOX::IFileContainer> container)

ASCOfficePPTXFile/ASCOfficeDrawingConverter.h

@@ -43,11 +43,14 @@
 #include <map>
 
 class IRenderer;
-class CShape;
-class CPPTShape;
 class CFontManager;
 class COfficeFontPicker;
 
+class CShape;
+typedef boost::shared_ptr<CShape> CShapePtr;
+
+class CPPTShape;
+
 namespace XmlUtils
 {
 	class CXmlNode;
@@ -187,7 +190,7 @@ namespace NSBinPptxRW
 		};
 
 
-        std::map<std::wstring, CShape*>						m_mapShapeTypes;
+        std::map<std::wstring, CShapePtr>					m_mapShapeTypes;
 
         NSBinPptxRW::CBinaryFileWriter*                     m_pBinaryWriter;
         int                                                 m_lNextId;
@@ -276,8 +279,8 @@ namespace NSBinPptxRW
         void CheckBrushShape        (PPTX::Logic::SpTreeElem* oElem, XmlUtils::CXmlNode& oNode, PPTShapes::ShapeType eType, CPPTShape* pPPTShape);
         void CheckPenShape          (PPTX::Logic::SpTreeElem* oElem, XmlUtils::CXmlNode& oNode, PPTShapes::ShapeType eType, CPPTShape* pPPTShape);
 
-        void LoadCoordSize			(XmlUtils::CXmlNode& oNode, ::CShape* pShape);
-		void LoadCoordPos			(XmlUtils::CXmlNode& oNode, ::CShape* pShape);
+        void LoadCoordSize			(XmlUtils::CXmlNode& oNode, ::CShapePtr pShape);
+		void LoadCoordPos			(XmlUtils::CXmlNode& oNode, ::CShapePtr pShape);
        
 		std::wstring GetDrawingMainProps (XmlUtils::CXmlNode& oNode, PPTX::CCSS& oCssStyles, CSpTreeElemProps& oProps);
 

ASCOfficePPTXFile/Editor/Drawing/Document.h

@@ -103,13 +103,13 @@ namespace NSPresentationEditor
 			size_t nCountElems = pSlide->m_arElements.size();
 			for (size_t i = 0; i < nCountElems; ++i)
 			{
-				IElement* pElement = pSlide->m_arElements[i];
+				CElementPtr pElement = pSlide->m_arElements[i];
 
 				switch (pElement->m_etType)
 				{
 				case etAudio:
 					{
-						CAudioElement* pAudioElem = dynamic_cast<CAudioElement*>(pElement);
+						CAudioElement* pAudioElem = dynamic_cast<CAudioElement*>(pElement.get());
 
 						if (NULL != pAudioElem)
 						{
@@ -147,9 +147,9 @@ namespace NSPresentationEditor
 			}
 		}
 
-		void ResetAutoText(IElement *pElement, vector_string const (&placeholdersReplaceString)[3])
+		void ResetAutoText(CElementPtr pElement, vector_string const (&placeholdersReplaceString)[3])
 		{
-			CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement);
+			CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement.get());
 			
 			if (NULL == pShape) return;
 			
@@ -193,7 +193,7 @@ namespace NSPresentationEditor
 				size_t nCountElems = pTheme->m_arElements.size();
 				for (size_t nIndexEl = 0; nIndexEl < nCountElems; ++nIndexEl)
 				{
-					IElement* pElement = pTheme->m_arElements[nIndexEl];
+					CElementPtr pElement = pTheme->m_arElements[nIndexEl];
 
 					if (pElement->m_lPlaceholderType > 0)
 					{
@@ -219,7 +219,7 @@ namespace NSPresentationEditor
 					size_t nCountLayoutElements = pLayout->m_arElements.size();
 					for (size_t nIndexLayoutEl = 0; nIndexLayoutEl < nCountLayoutElements; ++nIndexLayoutEl)
 					{
-						IElement* pElement = pLayout->m_arElements[nIndexLayoutEl];
+						CElementPtr pElement = pLayout->m_arElements[nIndexLayoutEl];
 						
 						if (pElement->m_lPlaceholderType > 0)
 						{
@@ -232,7 +232,7 @@ namespace NSPresentationEditor
 						pElement->m_pTheme = pTheme;
 						pElement->m_pLayout = NULL;
 
-						CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement);
+						CShapeElement* pShape = dynamic_cast<CShapeElement*>(pElement.get());
 						if (!pLayout->m_bUseThemeColorScheme && NULL != pShape)
 						{
 							int lPhType = pElement->m_lPlaceholderType;
@@ -253,20 +253,20 @@ namespace NSPresentationEditor
 								if (pThemeStyles->m_pLevels[nIndexLevel]->m_oCFRun.Color->m_lSchemeIndex == -1)
 									continue;
 
-								if (pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0].is_init())
+								if (pShape->m_pShape->m_oText.m_oStyles.m_pLevels[0].is_init())
 								{
-									if (pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color.is_init())
+									if (pShape->m_pShape->m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color.is_init())
 									{
 
-										if (pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->m_lSchemeIndex != -1)
+										if (pShape->m_pShape->m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->m_lSchemeIndex != -1)
 											continue;
 								
 										LONG lIndexSchemeT = pThemeStyles->m_pLevels[nIndexLevel]->m_oCFRun.Color->m_lSchemeIndex;
 
-										pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->m_lSchemeIndex = -1;
-										pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->R = pLayout->m_arColorScheme[lIndexSchemeT].R;
-										pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->G = pLayout->m_arColorScheme[lIndexSchemeT].G;
-										pShape->m_oShape.m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->B = pLayout->m_arColorScheme[lIndexSchemeT].B;
+										pShape->m_pShape->m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->m_lSchemeIndex = -1;
+										pShape->m_pShape->m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->R = pLayout->m_arColorScheme[lIndexSchemeT].R;
+										pShape->m_pShape->m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->G = pLayout->m_arColorScheme[lIndexSchemeT].G;
+										pShape->m_pShape->m_oText.m_oStyles.m_pLevels[0]->m_oCFRun.Color->B = pLayout->m_arColorScheme[lIndexSchemeT].B;
 										
 										bIsPlaceholderSetUp = true;
 									}
@@ -301,7 +301,7 @@ namespace NSPresentationEditor
 				size_t nCountElems = pSlide->m_arElements.size();
 				for (size_t nIndexEl = 0; nIndexEl < nCountElems; ++nIndexEl)
 				{
-					IElement* pElement = pSlide->m_arElements[nIndexEl];
+					CElementPtr pElement = pSlide->m_arElements[nIndexEl];
 
 					if (pElement->m_lPlaceholderType > 0)
 					{

ASCOfficePPTXFile/Editor/Drawing/Element.h

@@ -124,11 +124,11 @@ namespace NSPresentationEditor
 	class CLayout;
 	class CSlide;
 
-	class IElement
+class CElement;
+typedef boost::shared_ptr<CElement> CElementPtr;
+
+	class CElement
 	{
-	protected:
-		ULONG m_lCountRef;
-	
 	public:
 		ElementType			m_etType;
 		CDoubleRect			m_rcBounds;
@@ -181,23 +181,7 @@ namespace NSPresentationEditor
 
 		std::wstring		m_sHyperlink;
 
-		virtual ULONG AddRef()
-		{
-			++m_lCountRef;
-			return m_lCountRef;
-		}
-		virtual ULONG Release()
-		{
-			--m_lCountRef;
-			if (0 == m_lCountRef)
-			{
-				delete this;
-				return 0;
-			}
-			return m_lCountRef;
-		}
-
-		IElement()
+		CElement()
 		{
 			m_bIsBackground				= false;
 			m_bHaveAnchor				= true;
@@ -237,12 +221,10 @@ namespace NSPresentationEditor
 			m_bFlipV					= false;
 			m_bLine						= true;
 
-			m_lCountRef					= 1;
-
 			m_pTheme					= NULL;
 			m_pLayout					= NULL;
 		}
-		virtual ~IElement()
+		virtual ~CElement()
 		{
 		}
 
@@ -263,12 +245,11 @@ namespace NSPresentationEditor
 			m_rcBoundsOriginal.top		= dScaleY * m_rcBounds.top;
 			m_rcBoundsOriginal.bottom	= dScaleY * m_rcBounds.bottom;
 		}
-		virtual IElement* CreateDublicate() = 0;
+		virtual CElementPtr CreateDublicate() = 0;
 
-	protected:
-		virtual void SetProperiesToDublicate(IElement* pDublicate)
+		virtual void SetProperiesToDublicate(CElementPtr pDublicate)
 		{
-			if (NULL == pDublicate)
+			if (!pDublicate)
 				return;
 
 			pDublicate->m_bBoundsEnabled			= m_bBoundsEnabled;

ASCOfficePPTXFile/Editor/Drawing/Elements.cpp

@@ -63,7 +63,7 @@ void NSPresentationEditor::CShapeElement::CalculateColor(CColor& oColor, CSlide*
 
 void NSPresentationEditor::CShapeElement::SetupTextProperties(CSlide* pSlide, CTheme* pTheme, CLayout* pLayout)
 {
-	NSPresentationEditor::CTextAttributesEx* pAttributes = &m_oShape.m_oText;
+	NSPresentationEditor::CTextAttributesEx* pAttributes = &m_pShape->m_oText;
 	int nCountColors = 0;
 	if (NULL != pTheme)
 		nCountColors = (int)pTheme->m_arColorScheme.size();
@@ -123,7 +123,7 @@ void NSPresentationEditor::CShapeElement::SetupTextProperties(CSlide* pSlide, CT
 bool NSPresentationEditor::CShapeElement::SetUpTextPlaceholder(std::wstring newText)
 {
 	bool result = false;
-	NSPresentationEditor::CTextAttributesEx* pText = &m_oShape.m_oText;
+	NSPresentationEditor::CTextAttributesEx* pText = &m_pShape->m_oText;
 
 	for (size_t p = 0 ; p < pText->m_arParagraphs.size(); p++) //тут по всем -> 1-(33).ppt
 	{

ASCOfficePPTXFile/Editor/Drawing/Elements.h

@@ -284,7 +284,7 @@ namespace PPTX2EditorAdvanced
 
 namespace NSPresentationEditor
 {
-	class CImageElement : public IElement
+	class CImageElement : public CElement
 	{
 	public:
 		std::wstring	m_strImageFileName;
@@ -306,7 +306,7 @@ namespace NSPresentationEditor
 
 		std::wstring	m_sImageName;
 
-		CImageElement() : IElement()
+		CImageElement() : CElement()
 		{
 			m_etType = etPicture;
 			
@@ -328,11 +328,13 @@ namespace NSPresentationEditor
 		virtual ~CImageElement()
 		{
 		}
-		virtual IElement* CreateDublicate()
+		virtual CElementPtr CreateDublicate()
 		{
 			CImageElement* pImageElement = new CImageElement();
+
+			CElementPtr	pElement = CElementPtr(	pImageElement );
 			
-			SetProperiesToDublicate((IElement*)pImageElement);
+			SetProperiesToDublicate(pElement);
 
 			pImageElement->m_strImageFileName		= m_strImageFileName;
 			pImageElement->m_nAlpha					= m_nAlpha;
@@ -349,7 +351,7 @@ namespace NSPresentationEditor
 			pImageElement->m_bImagePresent			= m_bImagePresent;
 			pImageElement->m_bOLE					= m_bOLE;
 
-			return (IElement*)pImageElement;
+			return pElement;
 		}
         AVSINLINE std::wstring ConvertPPTShapeToPPTX(bool bIsNamespace = false)
 		{
@@ -389,79 +391,90 @@ namespace NSPresentationEditor
 		}
 	};
 
-	class CShapeElement : public IElement
+	class CShapeElement : public CElement
 	{
 	public:
 		NSBaseShape::ClassType m_ClassType;
 
 		int			m_lShapeType;
-		CShape		m_oShape;
+		CShapePtr	m_pShape;
 		bool		m_bShapePreset; // or rect (
 		
-		CShapeElement(NSBaseShape::ClassType ClassType, int eType) : IElement(), m_lShapeType(eType), m_oShape(ClassType, eType)
+		CShapeElement(NSBaseShape::ClassType ClassType, int eType) : CElement()
 		{
+			m_lShapeType			= eType;
 			m_ClassType				= ClassType;			
 			m_etType				= etShape;
 
-			m_oShape.m_rcBounds		= m_rcBounds;
+			m_pShape = CShapePtr( new CShape(ClassType, eType));
 
-			m_oShape.m_dStartTime	= m_dStartTime;
-			m_oShape.m_dStartTime	= m_dEndTime;
+			m_pShape->m_rcBounds		= m_rcBounds;
+
+			m_pShape->m_dStartTime	= m_dStartTime;
+			m_pShape->m_dStartTime	= m_dEndTime;
 
 			m_bShapePreset			= false;
+
 		}
 
-		CShapeElement() : m_oShape(NSBaseShape::unknown, 0x1000)
+		CShapeElement() : CElement()
 		{
 			m_lShapeType	= 0x1000;
 			m_etType		= etShape;
 			m_bShapePreset	= false;
+			
+			m_pShape = CShapePtr( new CShape(NSBaseShape::unknown, 0x1000));
 		}
 
-        CShapeElement(const std::wstring& str) : IElement(), m_oShape(NSBaseShape::unknown, 0x1000)
+        CShapeElement(const std::wstring& str) : CElement()
 		{
 			m_lShapeType	= 0x1000;
 			m_bShapePreset	= false;
 
-			m_oShape.LoadFromXML(str);
-			m_ClassType = m_oShape.getBaseShape()->GetClassType();
+			m_pShape = CShapePtr( new CShape(NSBaseShape::unknown, 0x1000));
+			m_pShape->LoadFromXML(str);
+			
+			m_ClassType = m_pShape->getBaseShape()->GetClassType();
 		}
 		virtual void NormalizeCoordsByMetric()
 		{
-			IElement::NormalizeCoordsByMetric();
+			CElement::NormalizeCoordsByMetric();
 
 			double dScaleX				= (double)m_oMetric.m_lUnitsHor / m_oMetric.m_lMillimetresHor;
 			double dScaleY				= (double)m_oMetric.m_lUnitsVer	/ m_oMetric.m_lMillimetresVer;
 
-			m_oShape.m_oText.m_oBounds.left		= (int)(dScaleX * m_oShape.m_oText.m_oBounds.left);
-			m_oShape.m_oText.m_oBounds.right	= (int)(dScaleX * m_oShape.m_oText.m_oBounds.right);
-			m_oShape.m_oText.m_oBounds.top		= (int)(dScaleY * m_oShape.m_oText.m_oBounds.top);
-			m_oShape.m_oText.m_oBounds.bottom	= (int)(dScaleY * m_oShape.m_oText.m_oBounds.bottom);
+			m_pShape->m_oText.m_oBounds.left		= (int)(dScaleX * m_pShape->m_oText.m_oBounds.left);
+			m_pShape->m_oText.m_oBounds.right	= (int)(dScaleX * m_pShape->m_oText.m_oBounds.right);
+			m_pShape->m_oText.m_oBounds.top		= (int)(dScaleY * m_pShape->m_oText.m_oBounds.top);
+			m_pShape->m_oText.m_oBounds.bottom	= (int)(dScaleY * m_pShape->m_oText.m_oBounds.bottom);
 		}
 		virtual ~CShapeElement()
 		{
 		}
 
-		virtual IElement* CreateDublicate()
+		virtual CElementPtr CreateDublicate()
 		{
 			CShapeElement* pShapeElement = new CShapeElement(m_ClassType, m_lShapeType);
 			
-			SetProperiesToDublicate((IElement*)pShapeElement);
+			CElementPtr	pElement = CElementPtr(	pShapeElement );
+			
+			SetProperiesToDublicate(pElement);
 
 			pShapeElement->m_lShapeType		= m_lShapeType;
 			pShapeElement->m_bShapePreset	= m_bShapePreset;
 
-			m_oShape.SetToDublicate(&pShapeElement->m_oShape);
-			return (IElement*)pShapeElement;
+			m_pShape->SetToDublicate(pShapeElement->m_pShape.get());
+			
+			return pElement;
 		}
 		bool SetUpTextPlaceholder(std::wstring newText);
 		
 		virtual void SetupProperties(CSlide* pSlide, CTheme* pTheme, CLayout* pLayout)
 		{
-			m_oShape.m_oText.m_lPlaceholderType = m_lPlaceholderType;
-			m_oShape.m_oText.m_lPlaceholderID	= m_lPlaceholderID;
+			m_pShape->m_oText.m_lPlaceholderType = m_lPlaceholderType;
+			m_pShape->m_oText.m_lPlaceholderID	= m_lPlaceholderID;
 
-			m_oShape.getBaseShape()->ReCalculate();
+			m_pShape->getBaseShape()->ReCalculate();
 
 			SetupTextProperties(pSlide, pTheme, pLayout);
 
@@ -476,7 +489,7 @@ namespace NSPresentationEditor
 
         AVSINLINE std::wstring ConvertPPTShapeToPPTX(bool bIsNamespace = false)
 		{
-			CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(m_oShape.getBaseShape());
+			CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(m_pShape->getBaseShape().get());
 			if (NULL == pPPTShape)
 			{
 				// такого быть не может
@@ -712,11 +725,12 @@ namespace NSPresentationEditor
 		{
 		}
 
-		virtual IElement* CreateDublicate()
+		virtual CElementPtr CreateDublicate()
 		{
 			CAudioElement* pAudioElement = new CAudioElement();
+			CElementPtr	pElement = CElementPtr(	pAudioElement );
 			
-			SetProperiesToDublicate((CImageElement*)pAudioElement);
+			SetProperiesToDublicate(pElement);
 
 			pAudioElement->m_strAudioFileName	= m_strAudioFileName;
 			pAudioElement->m_nAmplify			= m_nAmplify;
@@ -728,7 +742,7 @@ namespace NSPresentationEditor
 			pAudioElement->m_dClipStartTime		= m_dClipStartTime;
 			pAudioElement->m_dClipEndTime		= m_dClipEndTime;
 
-			return (IElement*)pAudioElement;
+			return pElement;
 		}
 	};
 	class CVideoElement : public CImageElement
@@ -759,11 +773,13 @@ namespace NSPresentationEditor
 		{
 		}
 		
-		virtual IElement* CreateDublicate()
+		virtual CElementPtr CreateDublicate()
 		{
 			CVideoElement* pVideoElement = new CVideoElement();
 			
-			SetProperiesToDublicate((CImageElement*)pVideoElement);
+			CElementPtr	pElement = CElementPtr(	pVideoElement );
+			
+			SetProperiesToDublicate(pElement);
 
 			pVideoElement->m_strVideoFileName	=	m_strVideoFileName;
 			pVideoElement->m_nAlpha				=	m_nAlpha;
@@ -774,7 +790,7 @@ namespace NSPresentationEditor
 			pVideoElement->m_dClipEndTime		=	m_dClipEndTime;
 			pVideoElement->m_bLoop				=	m_bLoop;
 
-			return (IElement*)pVideoElement;
+			return pElement;
 		}
 	};
 

ASCOfficePPTXFile/Editor/Drawing/Layout.h

@@ -37,7 +37,7 @@ namespace NSPresentationEditor
 	class CLayout
 	{
 	public:
-		std::vector<IElement*>	m_arElements;
+		std::vector<CElementPtr>m_arElements;
 		std::vector<CColor>		m_arColorScheme;
 		std::multimap<int,int>	m_mapPlaceholders;
 
@@ -66,7 +66,7 @@ namespace NSPresentationEditor
 		std::wstring			m_strLayoutType;
 
 		std::wstring			m_sName;
-	public:
+
 		CLayout() 
 		{
 			Clear();
@@ -81,12 +81,10 @@ namespace NSPresentationEditor
 		{
 			Clear();
 		
-			m_arElements			= oSrc.m_arElements;
-
-			size_t nCount = m_arElements.size();
+			size_t nCount = oSrc.m_arElements.size();
 			for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
 			{
-				ADDREFINTERFACE((m_arElements[nIndex]));
+				m_arElements.push_back(oSrc.m_arElements[nIndex]->CreateDublicate());
 			}
 
 			m_mapPlaceholders		= oSrc.m_mapPlaceholders;
@@ -108,7 +106,8 @@ namespace NSPresentationEditor
 			m_bHasFooter			= oSrc.m_bHasFooter;
 			m_nFormatDate			= oSrc.m_nFormatDate;
 
-			for (int i = 0 ; i < 3 ; i++) m_PlaceholdersReplaceString[i] = oSrc.m_PlaceholdersReplaceString[i];
+			for (int i = 0 ; i < 3 ; i++) 
+				m_PlaceholdersReplaceString[i] = oSrc.m_PlaceholdersReplaceString[i];
 
 			m_bShowMasterShapes		= oSrc.m_bShowMasterShapes;
 			m_strLayoutType			= oSrc.m_strLayoutType;
@@ -127,15 +126,8 @@ namespace NSPresentationEditor
 			m_lOriginalHeight	= m_oInfo.m_lUnitsVer;
 		}
 
-	public:
 		void Clear()
 		{
-			size_t nCount = m_arElements.size();
-			for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
-			{
-				RELEASEINTERFACE((m_arElements[nIndex]));
-			}
-
 			m_arElements.clear();
 			m_mapPlaceholders.clear();
 			
@@ -143,7 +135,9 @@ namespace NSPresentationEditor
 			m_bHasSlideNumber	= false;
 			m_bHasFooter		= false;
 			m_nFormatDate		= 1;
-			for (int i = 0 ; i < 3 ; i++) m_PlaceholdersReplaceString[i].clear();
+			
+			for (int i = 0 ; i < 3 ; i++) 
+				m_PlaceholdersReplaceString[i].clear();
 
 			m_bUseThemeColorScheme	= true;
 			m_bShowMasterShapes		= true;
@@ -159,12 +153,11 @@ namespace NSPresentationEditor
 
 			for (size_t nIndex = 0; nIndex < m_arElements.size(); ++nIndex)
 			{
-				IElement* pElem = m_arElements[nIndex];
+				CElementPtr pElem = m_arElements[nIndex];
 				if (NULL != pElem)
 				{
 					m_arElements[nIndex] = pElem->CreateDublicate();
 				}
-				RELEASEINTERFACE(pElem);
 			}
 		}
 
@@ -175,24 +168,21 @@ namespace NSPresentationEditor
 			return pNew;
 		}
 
-		IElement* GetPlaceholder(LONG lID, bool bIsAddRef)
+		CElementPtr GetPlaceholder(LONG lID)
 		{
 			size_t nCount = m_arElements.size();
 			
 			for (size_t i = 0; i < nCount; ++i)
 			{
-				IElement* pElem = m_arElements[i];
+				CElementPtr pElem = m_arElements[i];
 
 				if (pElem->m_lPlaceholderType == lID)
 				{
-					if (bIsAddRef)
-						ADDREFINTERFACE(pElem);
-
 					return pElem;
 				}
 			}
 			
-			return NULL;
+			return CElementPtr();
 		}
 
 		LONG GetCountPlaceholderWithType(LONG lType)
@@ -209,10 +199,6 @@ namespace NSPresentationEditor
 			
 			return lFound;
 		}
-
-	public:
-
-
 		NSPresentationEditor::CColor GetColor(const LONG& lIndexScheme)
 		{
 			if (lIndexScheme < (LONG)m_arColorScheme.size())

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

@@ -36,8 +36,9 @@
 #include "PPTXShape/PptxShape.h"
 #include "PPTShape/PptShape.h"
 
+using namespace NSPresentationEditor;
 
-NSPresentationEditor::CBaseShape* NSPresentationEditor::CBaseShape::CreateByType(NSPresentationEditor::NSBaseShape::ClassType ClassType, int ShapeType)
+CBaseShapePtr CBaseShape::CreateByType(NSBaseShape::ClassType ClassType, int ShapeType)
 {
 	if(ClassType == pptx)
 	{
@@ -52,7 +53,7 @@ NSPresentationEditor::CBaseShape* NSPresentationEditor::CBaseShape::CreateByType
 	return NULL;
 }
 
-bool NSPresentationEditor::CBaseShape::SetType(NSPresentationEditor::NSBaseShape::ClassType ClassType, int ShapeType)
+bool CBaseShape::SetType(NSBaseShape::ClassType ClassType, int ShapeType)
 {
 	if (ClassType != GetClassType())
 		return false;

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

@@ -30,9 +30,12 @@
  *
  */
 #pragma once
+
 #include "Path.h"
 #include "../../../../../Common/DocxFormat/Source/Common/SimpleTypes_Base.h"
 
+#include <boost/shared_ptr.hpp>
+
 namespace NSPresentationEditor
 {
     using namespace NSBaseShape;
@@ -61,7 +64,10 @@ namespace NSPresentationEditor
             return (*this);
         }
     };
-    //
+
+	class CBaseShape;
+	typedef boost::shared_ptr<CBaseShape> CBaseShapePtr;
+
     class CBaseShape
     {
     public:
@@ -120,7 +126,7 @@ namespace NSPresentationEditor
 
         virtual void AddGuide(const std::wstring& strGuide)	{}
 
-        static CBaseShape* CreateByType(ClassType ClassType, int ShapeType);
+        static CBaseShapePtr CreateByType(ClassType ClassType, int ShapeType);
 
         virtual const ClassType GetClassType()const				= 0;
         bool SetType(ClassType ClassType, int ShapeType);

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

@@ -48,34 +48,40 @@ LONG NSGuidesVML::CFormula::Calculate(NSGuidesVML::CFormulasManager* pManager)
 	LONG lAdjCount		= (LONG)pManager->m_pAdjustments->size();
 	
 	LONG a1 = m_lParam1;
-	if (ptFormula == m_eType1)
+	if (ptFormula == m_eType1 && !pManager->m_bCalc)
 	{
+		pManager->m_bCalc = true;
 		a1 = (m_lParam1 >= lGuidesCount) ? 0 : pManager->m_arFormulas[m_lParam1].Calculate(pManager);
 	}
 	else if (ptAdjust == m_eType1)
 	{
 		a1 = (m_lParam1 >= lAdjCount) ? 0 : (*(pManager->m_pAdjustments))[m_lParam1];
 	}
+	pManager->m_bCalc = false;
 
 	LONG b1 = m_lParam2;
-	if (ptFormula == m_eType2)
+	if (ptFormula == m_eType2 && !pManager->m_bCalc)
 	{
+		pManager->m_bCalc = true;
 		b1 = (m_lParam2 >= lGuidesCount) ? 0 : pManager->m_arFormulas[m_lParam2].Calculate(pManager);
 	}
 	else if (ptAdjust == m_eType2)
 	{
 		b1 = (m_lParam2 >= lAdjCount) ? 0 : (*(pManager->m_pAdjustments))[m_lParam2];
 	}
+	pManager->m_bCalc = false;
 
 	LONG c1 = m_lParam3;
-	if (ptFormula == m_eType3)
+	if (ptFormula == m_eType3 && !pManager->m_bCalc)
 	{
+		pManager->m_bCalc = true;
 		c1 = (m_lParam3 >= lGuidesCount) ? 0 : pManager->m_arFormulas[m_lParam3].Calculate(pManager);
 	}
 	else if (ptAdjust == m_eType3)
 	{
 		c1 = (m_lParam3 >= lAdjCount) ? 0 : (*(pManager->m_pAdjustments))[m_lParam3];
 	}
+	pManager->m_bCalc = false;
 
 	double a = (double)a1;
 	double b = (double)b1;

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

@@ -341,8 +341,9 @@ namespace NSGuidesVML
         long m_lShapeWidth;
         long m_lShapeHeight;
 
-    public:
-        CFormulasManager() : m_arFormulas(), m_arResults()
+		bool m_bCalc; //status
+
+        CFormulasManager() : m_bCalc(false)
         {
             m_pAdjustments	= NULL;
             m_lShapeWidth	= ShapeSizeVML;
@@ -350,6 +351,7 @@ namespace NSGuidesVML
         }
         CFormulasManager& operator =(const CFormulasManager& oSrc)
         {
+			m_bCalc			= oSrc.m_bCalc;
             m_pAdjustments	= oSrc.m_pAdjustments;
             m_lShapeWidth	= oSrc.m_lShapeWidth;
             m_lShapeHeight	= oSrc.m_lShapeHeight;
@@ -370,6 +372,7 @@ namespace NSGuidesVML
 
         void Clear()
         {
+			m_bCalc			= false;
             m_pAdjustments	= NULL;
             m_lShapeWidth	= ShapeSizeVML;
             m_lShapeHeight	= ShapeSizeVML;

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

@@ -42,7 +42,26 @@ const double EMU_MM = 36000;
 //-------------------------------------------------------------------------------
 
 using namespace PPTShapes;
-CPPTShape* CPPTShape::CreateByType(PPTShapes::ShapeType type)
+using namespace NSPresentationEditor;
+
+CPPTShape::CPPTShape() : CBaseShape(), m_arStringTextRects()
+{
+    m_eType = PPTShapes::sptMin;
+
+    m_arStringTextRects.push_back(_T("0,0,21600,21600"));
+
+    m_strPathLimoX = _T("");
+    m_strPathLimoY = _T("");
+    m_bIsShapeType = false;
+
+    m_bIsFilled = true;
+    m_bIsStroked = true;
+}
+CPPTShape::~CPPTShape()
+{
+}
+
+CBaseShapePtr CPPTShape::CreateByType(PPTShapes::ShapeType type)
 {
 	CPPTShape* pShape = NULL;
 	switch (type)
@@ -288,6 +307,143 @@ CPPTShape* CPPTShape::CreateByType(PPTShapes::ShapeType type)
 	if (NULL != pShape)
 		pShape->m_eType = type;
 
-	return pShape;
+	return CBaseShapePtr(pShape);
 }
 
+
+bool CPPTShape::LoadFromXML(const std::wstring& xml)
+{
+    XmlUtils::CXmlNode oNodePict;
+    if (oNodePict.FromXmlString(xml))
+    {
+        return LoadFromXML(oNodePict);
+    }
+    return false;
+}
+
+bool CPPTShape::LoadFromXML(XmlUtils::CXmlNode& oNodePict)
+{
+    std::wstring id = oNodePict.GetAttributeOrValue(_T("type"));
+    bool isPathList = false;
+    if (id != _T(""))
+    {
+        SetShapeType((PPTShapes::ShapeType)XmlUtils::GetInteger(id));
+    }
+    else
+    {
+        XmlUtils::CXmlNode oNodeTemplate;
+        if (oNodePict.GetNode(_T("template"), oNodeTemplate))
+        {
+            std::wstring strAdj = oNodeTemplate.GetAttributeOrValue(_T("adj"));
+            LoadAdjustValuesList(strAdj);
+
+            XmlUtils::CXmlNode oNodeGuides;
+            if (oNodeTemplate.GetNode(_T("v:formulas"), oNodeGuides))
+            {
+                LoadGuidesList(oNodeGuides.GetXml());
+            }
+
+            std::wstring strPath = oNodeTemplate.GetAttributeOrValue(_T("path"));
+            if (strPath != _T(""))
+            {
+                LoadPathList(strPath);
+                isPathList = true;
+            }
+        }
+    }
+
+    XmlUtils::CXmlNode oNodeGuides;
+    if (oNodePict.GetNode(_T("path"), oNodeGuides))
+    {
+        std::wstring strPath = oNodeGuides.GetAttributeOrValue(_T("val"));
+        if (strPath != _T(""))
+        {
+            LoadPathList(strPath);
+            isPathList = true;
+        }
+    }
+
+    if (!isPathList)
+        ReCalculate();
+    return true;
+}
+
+bool CPPTShape::LoadFromXMLShapeType(XmlUtils::CXmlNode& oNodeShapeType) // vml object
+{		// из за особенносей форматирования vmlDrawing могут вылезти пустые текстовые значения - value ..
+    std::wstring sId = oNodeShapeType.GetAttribute(_T("o:spt"));
+
+    bool bIsNeedRecalc = true;
+    if (sId != _T(""))
+    {
+        int id = XmlUtils::GetInteger(sId);
+        if (id > 0)
+        {
+            SetShapeType((PPTShapes::ShapeType)id);
+            //ReCalculate();
+            m_eType = (PPTShapes::ShapeType)id;
+        }
+    }
+    std::wstring strAdj = oNodeShapeType.GetAttribute(_T("adj"));
+    if (strAdj != _T(""))
+        LoadAdjustValuesList(strAdj);
+
+    XmlUtils::CXmlNode oNodeGuides;
+    if (oNodeShapeType.GetNode(_T("v:formulas"), oNodeGuides))
+    {
+        LoadGuidesList(oNodeGuides.GetXml());
+    }
+
+    XmlUtils::CXmlNode oNodePath;
+    if (oNodeShapeType.GetNode(_T("v:path"), oNodePath))
+    {
+        std::wstring strTextR = oNodePath.GetAttribute(_T("textboxrect"));
+        if (strTextR != _T(""))
+            LoadTextRect(strTextR);
+    }
+
+    XmlUtils::CXmlNode oNodeAHs;
+    if (oNodeShapeType.GetNode(_T("v:handles"), oNodeAHs))
+    {
+        LoadAHList(oNodeAHs);
+    }
+
+    std::wstring strPath = oNodeShapeType.GetAttribute(_T("path"));
+    if (strPath != _T(""))
+    {
+        LoadPathList(strPath);
+    }
+
+    XmlUtils::CXmlNode oNodeTextPath;
+    if (oNodeShapeType.GetNode(_T("v:textpath"), oNodeTextPath))
+    {
+        if (m_eType < PPTShapes::ShapeType::sptCTextPlain || m_eType > PPTShapes::ShapeType::sptCTextCanDown)
+            m_eType = PPTShapes::ShapeType::sptCTextPlain;
+    }
+
+    std::wstring strFilled = oNodeShapeType.GetAttribute(_T("filled"));
+    std::wstring strStroked = oNodeShapeType.GetAttribute(_T("stroked"));
+
+    if (strFilled != _T(""))
+    {
+        if (strFilled == _T("false") || strFilled == _T("f"))
+            m_bIsFilled = false;
+        else
+            m_bIsFilled = true;
+    }
+
+    if (strStroked != _T(""))
+    {
+        if (strStroked == _T("false") || strStroked == _T("f"))
+            m_bIsStroked = false;
+        else
+            m_bIsStroked = true;
+    }
+    XmlUtils::CXmlNode oNodeSignature;
+    if (oNodeShapeType.GetNode(_T("o:signatureline"), oNodeSignature))
+    {
+        m_oSignatureLine = oNodeSignature;
+    }
+
+    ReCalculate();
+    return true;
+}

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

@@ -56,240 +56,12 @@ public:
     bool m_bIsStroked;
     nullable<OOX::VmlOffice::CSignatureLine> m_oSignatureLine;
 
-public:
-    CPPTShape() : CBaseShape(), m_arStringTextRects()
-    {
-        m_eType = PPTShapes::sptMin;
-
-        m_arStringTextRects.push_back(_T("0,0,21600,21600"));
-
-        m_strPathLimoX = _T("");
-        m_strPathLimoY = _T("");
-        m_bIsShapeType = false;
-
-        m_bIsFilled = true;
-        m_bIsStroked = true;
-    }
-
-    ~CPPTShape()
-    {
-    }
-    virtual bool LoadFromXML(const std::wstring& xml)
-    {
-        XmlUtils::CXmlNode oNodePict;
-        if (oNodePict.FromXmlString(xml))
-        {
-            return LoadFromXML(oNodePict);
-        }
-        return false;
-    }
-
-    //virtual bool LoadFromXML(const std::wstring& xml)
-    //{
-    //	XmlUtils::CXmlNode oNodePict;
-    //	if (oNodePict.FromXmlString(xml))
-    //	{
-    //		if (_T("shape") == oNodePict.GetName())
-    //		{
-    //			std::wstring id = oNodePict.GetAttributeOrValue(_T("type"));
-    //			if (id != _T(""))
-    //			{
-    //				SetShapeType((PPTShapes::ShapeType)Strings::ToInteger(id));
-    //			}
-    //			else
-    //			{
-    //				XmlUtils::CXmlNode oNodeTemplate;
-    //				if (oNodePict.GetNode(_T("template"), oNodeTemplate))
-    //				{
-    //					std::wstring strAdj = oNodeTemplate.GetAttributeOrValue(_T("adj"));
-    //					LoadAdjustValuesList(strAdj);
-
-    //					XmlUtils::CXmlNode oNodeGuides;
-    //					if (oNodeTemplate.GetNode(_T("v:formulas"), oNodeGuides))
-    //					{
-    //						LoadGuidesList(oNodeGuides.GetXml());
-    //					}
-
-    //					std::wstring strPath = oNodeTemplate.GetAttributeOrValue(_T("path"));
-    //					LoadPathList(strPath);
-    //				}
-    //			}
-
-    //			XmlUtils::CXmlNode oNodeGuides;
-    //			if (oNodePict.GetNode(_T("path"), oNodeGuides))
-    //			{
-    //				std::wstring strPath = oNodeGuides.GetAttributeOrValue(_T("val"));
-    //				LoadPathList(strPath);
-    //			}
-
-    //			/*XmlUtils::CXmlNode oNodeShapeType;
-    //			if (oNodePict.GetNode(_T("v:shapetype"), oNodeShapeType))
-    //			{
-    //				std::wstring strAdj = oNodeShapeType.GetAttributeOrValue(_T("adj"));
-    //				LoadAdjustValuesList(strAdj);
-
-    //				XmlUtils::CXmlNode oNodeGuides;
-    //				if (oNodeShapeType.GetNode(_T("v:formulas"), oNodeGuides))
-    //				{
-    //					LoadGuidesList(oNodeGuides.GetXml());
-    //				}
-
-    //				std::wstring strPath = oNodeShapeType.GetAttributeOrValue(_T("path"));
-    //				LoadAdjustValuesList(strPath);
-    //			}
-    //			else
-    //			{
-    //				XmlUtils::CXmlNode oNodeShape;
-    //				if (oNodePict.GetNode(_T("v:shape"), oNodeShape))
-    //				{
-    //					std::wstring strAdj = oNodeShape.GetAttributeOrValue(_T("adj"));
-    //					LoadAdjustValuesList(strAdj);
-
-    //					XmlUtils::CXmlNode oNodeGuides;
-    //					if (oNodeShape.GetNode(_T("v:formulas"), oNodeGuides))
-    //					{
-    //						LoadGuidesList(oNodeGuides.GetXml());
-    //					}
-
-    //					std::wstring strPath = oNodeShape.GetAttributeOrValue(_T("path"));
-    //					LoadPathList(strPath);
-    //				}
-    //			}*/
-
-    //			return true;
-    //		}
-    //	}
-
-    //	return false;
-    //}
-
-    virtual bool LoadFromXML(XmlUtils::CXmlNode& oNodePict)
-    {
-        std::wstring id = oNodePict.GetAttributeOrValue(_T("type"));
-        bool isPathList = false;
-        if (id != _T(""))
-        {
-            SetShapeType((PPTShapes::ShapeType)XmlUtils::GetInteger(id));
-        }
-        else
-        {
-            XmlUtils::CXmlNode oNodeTemplate;
-            if (oNodePict.GetNode(_T("template"), oNodeTemplate))
-            {
-                std::wstring strAdj = oNodeTemplate.GetAttributeOrValue(_T("adj"));
-                LoadAdjustValuesList(strAdj);
-
-                XmlUtils::CXmlNode oNodeGuides;
-                if (oNodeTemplate.GetNode(_T("v:formulas"), oNodeGuides))
-                {
-                    LoadGuidesList(oNodeGuides.GetXml());
-                }
-
-                std::wstring strPath = oNodeTemplate.GetAttributeOrValue(_T("path"));
-                if (strPath != _T(""))
-                {
-                    LoadPathList(strPath);
-                    isPathList = true;
-                }
-            }
-        }
-
-        XmlUtils::CXmlNode oNodeGuides;
-        if (oNodePict.GetNode(_T("path"), oNodeGuides))
-        {
-            std::wstring strPath = oNodeGuides.GetAttributeOrValue(_T("val"));
-            if (strPath != _T(""))
-            {
-                LoadPathList(strPath);
-                isPathList = true;
-            }
-        }
-
-        if (!isPathList)
-            ReCalculate();
-        return true;
-    }
-
-    virtual bool LoadFromXMLShapeType(XmlUtils::CXmlNode& oNodeShapeType) // vml object
-    {		// из за особенносей форматирования vmlDrawing могут вылезти пустые текстовые значения - value ..
-        std::wstring sId = oNodeShapeType.GetAttribute(_T("o:spt"));
-
-        bool bIsNeedRecalc = true;
-        if (sId != _T(""))
-        {
-            int id = XmlUtils::GetInteger(sId);
-            if (id > 0)
-            {
-                SetShapeType((PPTShapes::ShapeType)id);
-                //ReCalculate();
-                m_eType = (PPTShapes::ShapeType)id;
-            }
-        }
-        std::wstring strAdj = oNodeShapeType.GetAttribute(_T("adj"));
-        if (strAdj != _T(""))
-            LoadAdjustValuesList(strAdj);
-
-        XmlUtils::CXmlNode oNodeGuides;
-        if (oNodeShapeType.GetNode(_T("v:formulas"), oNodeGuides))
-        {
-            LoadGuidesList(oNodeGuides.GetXml());
-        }
-
-        XmlUtils::CXmlNode oNodePath;
-        if (oNodeShapeType.GetNode(_T("v:path"), oNodePath))
-        {
-            std::wstring strTextR = oNodePath.GetAttribute(_T("textboxrect"));
-            if (strTextR != _T(""))
-                LoadTextRect(strTextR);
-        }
-
-        XmlUtils::CXmlNode oNodeAHs;
-        if (oNodeShapeType.GetNode(_T("v:handles"), oNodeAHs))
-        {
-            LoadAHList(oNodeAHs);
-        }
-
-        std::wstring strPath = oNodeShapeType.GetAttribute(_T("path"));
-        if (strPath != _T(""))
-        {
-            LoadPathList(strPath);
-        }
-
-        XmlUtils::CXmlNode oNodeTextPath;
-        if (oNodeShapeType.GetNode(_T("v:textpath"), oNodeTextPath))
-        {
-            if (m_eType < PPTShapes::ShapeType::sptCTextPlain || m_eType > PPTShapes::ShapeType::sptCTextCanDown)
-                m_eType = PPTShapes::ShapeType::sptCTextPlain;
-        }
-
-        std::wstring strFilled = oNodeShapeType.GetAttribute(_T("filled"));
-        std::wstring strStroked = oNodeShapeType.GetAttribute(_T("stroked"));
-
-        if (strFilled != _T(""))
-        {
-            if (strFilled == _T("false") || strFilled == _T("f"))
-                m_bIsFilled = false;
-            else
-                m_bIsFilled = true;
-        }
-
-        if (strStroked != _T(""))
-        {
-            if (strStroked == _T("false") || strStroked == _T("f"))
-                m_bIsStroked = false;
-            else
-                m_bIsStroked = true;
-        }
-        XmlUtils::CXmlNode oNodeSignature;
-        if (oNodeShapeType.GetNode(_T("o:signatureline"), oNodeSignature))
-        {
-            m_oSignatureLine = oNodeSignature;
-        }
-
-        ReCalculate();
-        return true;
-    }
+    CPPTShape();
+    virtual ~CPPTShape();
 
+    virtual bool LoadFromXML(const std::wstring& xml);
+    virtual bool LoadFromXML(XmlUtils::CXmlNode& oNodePict);
+    virtual bool LoadFromXMLShapeType(XmlUtils::CXmlNode& oNodeShapeType);
     virtual bool LoadAdjustValuesList(const std::wstring& xml)
     {
         std::wstring strXml = xml;
@@ -484,8 +256,9 @@ public:
         LoadPathList(m_strPath);
     }
 
-    static CPPTShape* CreateByType(PPTShapes::ShapeType type);
-    virtual const ClassType GetClassType()const
+    static CBaseShapePtr CreateByType(PPTShapes::ShapeType type);
+    
+	virtual const ClassType GetClassType()const
     {
         return NSBaseShape::ppt;
     }
@@ -533,13 +306,13 @@ public:
 
     bool SetShapeType(PPTShapes::ShapeType type)
     {
-        CPPTShape* l_pShape = CreateByType(type);
-        if(l_pShape != NULL)
+        CBaseShapePtr pShape = CreateByType(type);
+       
+		if(pShape)
         {
             m_eType = type;
 
-            SetProperties(l_pShape);
-            delete l_pShape;
+            SetProperties(pShape.get());
             return true;
         }
 

ASCOfficePPTXFile/Editor/Drawing/Shapes/BaseShape/PPTXShape/PptxShape.cpp

@@ -34,8 +34,9 @@
 #include "PptxShape.h"
 //#include "PresetShapesHeader.h"
 
-CPPTXShape* CPPTXShape::CreateByType(OOXMLShapes::ShapeType type)
+CBaseShapePtr CPPTXShape::CreateByType(OOXMLShapes::ShapeType type)
 {
+	CBaseShapePtr shape;
 //    switch(type)
 //	{
 //	case OOXMLShapes::sptCAccentBorderCallout1:		return new OOXMLShapes::CAccentBorderCallout1();
@@ -266,5 +267,5 @@ CPPTXShape* CPPTXShape::CreateByType(OOXMLShapes::ShapeType type)
 //	case OOXMLShapes::sptCWedgeRectCallout:			return new OOXMLShapes::CWedgeRectCallout();
 //	case OOXMLShapes::sptCWedgeRoundRectCallout:	return new OOXMLShapes::CWedgeRoundRectCallout();
 //	}
-	return NULL;
+	return shape;
 }

ASCOfficePPTXFile/Editor/Drawing/Shapes/BaseShape/PPTXShape/PptxShape.h

@@ -280,7 +280,7 @@ public:
     OOXMLShapes::ShapeType m_eType;
 
     NSGuidesOOXML::CFormulaManager FManager;
-public:
+
     CPPTXShape() : CBaseShape(), FManager(m_arAdjustments, m_arGuides)
     {
         m_eType = OOXMLShapes::sptMin;
@@ -507,7 +507,7 @@ public:
         LoadPathList(m_strPath);
     }
 
-    static CPPTXShape* CreateByType(OOXMLShapes::ShapeType type);
+    static CBaseShapePtr CreateByType(OOXMLShapes::ShapeType type);
     
 	virtual const ClassType GetClassType()const
     {
@@ -540,13 +540,12 @@ public:
 
     bool SetShapeType(OOXMLShapes::ShapeType type)
     {
-        CPPTXShape* l_pShape = CreateByType(type);
-        if(l_pShape != NULL)
+        CBaseShapePtr pShape = CreateByType(type);
+        if(pShape)
         {
             m_eType = type;
 
-            SetProperties(l_pShape);
-            delete l_pShape;
+            SetProperties(pShape.get());
             return true;
         }
 

ASCOfficePPTXFile/Editor/Drawing/Shapes/Shape.h

@@ -49,10 +49,13 @@ const LONG c_ShapeDrawType_Graphic	= 0x01;
 const LONG c_ShapeDrawType_Text		= 0x02;
 const LONG c_ShapeDrawType_All		= c_ShapeDrawType_Graphic | c_ShapeDrawType_Text;
 
+class CShape;
+typedef boost::shared_ptr<CShape> CShapePtr;
+
 class CShape
 {
 private:
-	CBaseShape*				m_pShape;
+	CBaseShapePtr			m_pShape;
 public:
 	double					m_dStartTime;
 	double					m_dEndTime;
@@ -103,15 +106,11 @@ public:
 		m_dTextMarginRight	= 0;
 		m_dTextMarginBottom	= 0;
 
-		m_strPPTXShape = _T("");
-
-		m_pShape = NULL;
-
 		m_classType = classType;
 
 		if (m_classType == NSBaseShape::pptx)
 		{
-			m_pShape = new CPPTXShape();
+			m_pShape = CBaseShapePtr(new CPPTXShape());
 			m_pShape->SetType(NSBaseShape::pptx, ShapeType_);
 		}
 		else if (m_classType == NSBaseShape::ppt)
@@ -119,7 +118,7 @@ public:
 			m_pShape = CPPTShape::CreateByType((PPTShapes::ShapeType)ShapeType_ );
 			if (m_pShape == NULL)
 			{
-				m_pShape = new CPPTShape();
+				m_pShape = CBaseShapePtr(new CPPTShape());
 				m_pShape->SetType(NSBaseShape::ppt, ShapeType_);
 			}
 
@@ -135,20 +134,17 @@ public:
 
 	~CShape()
 	{
-		RELEASEOBJECT(m_pShape);
 	}
 
-	CBaseShape* getBaseShape()
+	CBaseShapePtr getBaseShape()
 	{
 		return m_pShape;
 	}
 
-	void setBaseShape(CBaseShape* pShape)
+	void setBaseShape(CBaseShapePtr pShape)
 	{
-		if (pShape == NULL) return;
-
-		CPPTXShape *pptxShape = dynamic_cast<CPPTXShape*>(pShape);
-		CPPTShape *pptShape = dynamic_cast<CPPTShape*>(pShape);
+		CPPTXShape *pptxShape = dynamic_cast<CPPTXShape*>(pShape.get());
+		CPPTShape *pptShape = dynamic_cast<CPPTShape*>(pShape.get());
 
 		if (pptxShape)	m_classType = NSBaseShape::pptx;
 		if (pptShape)	m_classType = NSBaseShape::ppt;
@@ -180,7 +176,7 @@ public:
 			if (NSBaseShape::ppt == m_pShape->GetClassType())
 			{
 				// как будто могло быть иначе
-				CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(m_pShape);
+				CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(m_pShape.get());
 				if (NULL != pPPTShape)
 				{
 					pPPTShape->CalcTextRectOffsets(dPercentLeft, dPercentTop, dPercentRight, dPercentBottom);
@@ -251,7 +247,7 @@ public:
 			if ((m_pShape) && (NSBaseShape::ppt == m_pShape->GetClassType()))
 			{
 				// как будто могло быть иначе
-				CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(m_pShape);
+				CPPTShape* pPPTShape = dynamic_cast<CPPTShape*>(m_pShape.get());
 				if (NULL != pPPTShape)
 				{
 					//pPPTShape->CalcTextRectOffsets(dPercentLeft, dPercentTop, dPercentRight, dPercentBottom);
@@ -338,23 +334,23 @@ public:
 	{
 		if(_T("ooxml-shape") == root.GetName())
 		{
-			if(m_pShape != NULL)
-				delete m_pShape;
-			m_pShape = new CPPTXShape();
-			//return m_pShape->LoadFromXML(xml);
-			return ((CPPTXShape*)m_pShape)->LoadFromXML(root);
+			m_pShape = CBaseShapePtr(new CPPTXShape());
+			
+			CPPTXShape* pptx_shape = dynamic_cast<CPPTXShape*>(m_pShape.get());
+			
+			return pptx_shape ? pptx_shape->LoadFromXML(root) : false;
 		}
 		else if(_T("shape") == root.GetName())
 		{
-			if(m_pShape != NULL)
-				delete m_pShape;
-			m_pShape = new CPPTShape();
+			m_pShape = CBaseShapePtr(new CPPTShape());
 
 			SetCoordSize(root);
 			SetPen		(root);
 			SetBrush	(root);
 			
-			return ((CPPTShape*)m_pShape)->LoadFromXML(root);			
+			CPPTShape* ppt_shape = dynamic_cast<CPPTShape*>(m_pShape.get());
+
+			return ppt_shape ? ppt_shape->LoadFromXML(root) : false;
 		}
 
 		return false;
@@ -386,7 +382,7 @@ public:
 		Shape->m_dTextMarginBottom	= m_dTextMarginBottom;
 
 		if (m_pShape)
-			return m_pShape->SetToDublicate(Shape->m_pShape);
+			return m_pShape->SetToDublicate(Shape->m_pShape.get());
 		return true;
 	}
 

ASCOfficePPTXFile/Editor/Drawing/Slide.h

@@ -44,7 +44,7 @@ namespace NSPresentationEditor
 		LONG m_lSlideID;	//for notes rels
 		LONG m_lNotesID;	//for slide rels
 
-		std::vector<IElement*>	m_arElements;
+		std::vector<CElementPtr>m_arElements;
 		CSlideShowInfo			m_oSlideShow;
 		std::multimap<int,int>	m_mapPlaceholders;
 
@@ -73,7 +73,7 @@ namespace NSPresentationEditor
 		std::wstring			m_strComment;
 		std::wstring			m_sName;
 
-		CSlide() : m_arElements(), m_oSlideShow()
+		CSlide() : m_oSlideShow()
 		{
 			Clear(); 
 		}
@@ -84,11 +84,6 @@ namespace NSPresentationEditor
 
 		void Clear()
 		{
-			for (size_t nIndex = 0; nIndex < m_arElements.size(); ++nIndex)
-			{
-				IElement* pElem = m_arElements[nIndex];
-				RELEASEINTERFACE(pElem);
-			}
 			m_arColorScheme.clear();
 			m_arElements.clear();
 			
@@ -111,7 +106,8 @@ namespace NSPresentationEditor
 			m_strComment.clear();
 			m_sName.clear();
 
-			for (int i = 0 ; i < 3 ; i++) m_PlaceholdersReplaceString[i].clear();
+			for (int i = 0 ; i < 3 ; i++) 
+				m_PlaceholdersReplaceString[i].clear();
 		}
 
 		CSlide(const CSlide& oSrc)
@@ -171,7 +167,7 @@ namespace NSPresentationEditor
 			{
 				if (-1 != m_arElements[nEl]->m_lPlaceholderType && etShape == m_arElements[nEl]->m_etType)
 				{
-					CShapeElement* pSlideElement = dynamic_cast<CShapeElement*>(m_arElements[nEl]);
+					CShapeElement* pSlideElement = dynamic_cast<CShapeElement*>(m_arElements[nEl].get());
 
 					if (NULL != pSlideElement)
 					{
@@ -185,10 +181,10 @@ namespace NSPresentationEditor
 								if ((pLayout->m_arElements[i]->m_lPlaceholderType	== pSlideElement->m_lPlaceholderType) &&
 									(pLayout->m_arElements[i]->m_etType				== etShape))
 								{
-									CShapeElement* pLayoutElement = dynamic_cast<CShapeElement*>(pLayout->m_arElements[i]);
+									CShapeElement* pLayoutElement = dynamic_cast<CShapeElement*>(pLayout->m_arElements[i].get());
 									if (NULL != pLayoutElement)
 									{
-										pSlideElement->m_oShape.m_oText.m_oLayoutStyles		= pLayoutElement->m_oShape.m_oText.m_oStyles;
+										pSlideElement->m_pShape->m_oText.m_oLayoutStyles = pLayoutElement->m_pShape->m_oText.m_oStyles;
 									}
 								}
 							}
@@ -198,10 +194,10 @@ namespace NSPresentationEditor
 									(pLayout->m_arElements[i]->m_lPlaceholderID		== pSlideElement->m_lPlaceholderID) &&
 									(pLayout->m_arElements[i]->m_etType				== etShape))
 								{
-									CShapeElement* pLayoutElement = dynamic_cast<CShapeElement*>(pLayout->m_arElements[i]);
+									CShapeElement* pLayoutElement = dynamic_cast<CShapeElement*>(pLayout->m_arElements[i].get());
 									if (NULL != pLayoutElement)
 									{
-										pSlideElement->m_oShape.m_oText.m_oLayoutStyles		= pLayoutElement->m_oShape.m_oText.m_oStyles;
+										pSlideElement->m_pShape->m_oText.m_oLayoutStyles = pLayoutElement->m_pShape->m_oText.m_oStyles;
 									}
 								}								
 							}

ASCOfficePPTXFile/Editor/Drawing/Theme.h

@@ -57,7 +57,7 @@ namespace NSPresentationEditor
 		bool							m_bIsBackground;
 		CBrush							m_oBackground;
 
-		std::vector<IElement*>			m_arElements;
+		std::vector<CElementPtr>		m_arElements;
 
 		CMetricInfo						m_oInfo;
 
@@ -133,11 +133,6 @@ namespace NSPresentationEditor
 
 			m_arElements = oSrc.m_arElements;
 
-			nCount = m_arElements.size();
-			for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
-			{
-				ADDREFINTERFACE((m_arElements[nIndex]));
-			}
 			CreateDublicateElements();
 
 			for (long nIndexStyle = 0; nIndexStyle < g_ThemeTextStylesCount; ++nIndexStyle)
@@ -154,23 +149,16 @@ namespace NSPresentationEditor
 			size_t nCount = m_arElements.size();
 			for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
 			{
-				IElement* pElem = m_arElements[nIndex];
+				CElementPtr pElem = m_arElements[nIndex];
 				if (NULL != pElem)
 				{
 					m_arElements[nIndex] = pElem->CreateDublicate();
 				}
-				RELEASEINTERFACE(pElem);
 			}
 		}
 
 		void Clear()
 		{
-			size_t nCount = m_arElements.size();
-			for (size_t nIndex = 0; nIndex < nCount; ++nIndex)
-			{
-				RELEASEINTERFACE((m_arElements[nIndex]));
-			}
-
 			m_arElements.clear();
 			m_arLayouts.clear();
 			m_mapTitleLayout.clear();
@@ -186,15 +174,13 @@ namespace NSPresentationEditor
 			m_bHasFooter		= false;
 			m_nFormatDate		= 1;
 		
-			for (int i = 0 ; i < 3 ; i++) m_PlaceholdersReplaceString[i].clear();
+			for (int i = 0 ; i < 3 ; i++) 
+				m_PlaceholdersReplaceString[i].clear();
 		}
 
 		~CTheme()
 		{
 		}
-
-	public:
-
 		NSPresentationEditor::CColor GetColor(const LONG& lIndexScheme)
 		{
 			if (lIndexScheme < (LONG)m_arColorScheme.size())

ASCOfficePPTXFile/PPTXFormat/Logic/CNvGraphicFramePr.h

@@ -112,6 +112,10 @@ namespace PPTX
 
 			virtual std::wstring toXML() const
 			{
+				std::wstring namespaceLocks = L"a";
+				std::wstring namespaceLocksLink = PPTX::g_Namespaces.a.m_strLink;
+				//if (m_namespace == L"wp") namespaceLocks = L"wp";
+
 				XmlUtils::CAttribute oAttr;
 				oAttr.Write(_T("noChangeAspect"),	noChangeAspect);
 				oAttr.Write(_T("noDrilldown"),		noDrilldown);
@@ -120,21 +124,23 @@ namespace PPTX
 				oAttr.Write(_T("noResize"),			noResize);
 				oAttr.Write(_T("noSelect"),			noSelect);
 
-				std::wstring namespaceLocks = L"a";
-				//if (m_namespace == L"wp") namespaceLocks = L"wp";
+				bool isAttrEmpty = oAttr.m_strValue.empty();
+				oAttr.Write(_T("xmlns:") + namespaceLocks, namespaceLocksLink);
 
-				return XmlUtils::CreateNode(m_namespace + L":cNvGraphicFramePr", oAttr.m_strValue.empty() ? L"" : XmlUtils::CreateNode(namespaceLocks + L":graphicFrameLocks", oAttr));
+				return XmlUtils::CreateNode(m_namespace + L":cNvGraphicFramePr", isAttrEmpty ? L"" : XmlUtils::CreateNode(namespaceLocks + L":graphicFrameLocks", oAttr));
 			}
 
 			virtual void toXmlWriter(NSBinPptxRW::CXmlWriter* pWriter) const
 			{
 				std::wstring namespace_		= m_namespace;
 				std::wstring namespaceLock_ = L"a";
+				std::wstring namespaceLockLink_ = PPTX::g_Namespaces.a.m_strLink;
 
 				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_XLSX)	namespace_ = L"xdr";
 				if (pWriter->m_lDocType == XMLWRITER_DOC_TYPE_DOCX)
 				{
 					namespaceLock_	= L"a";
+					namespaceLockLink_ = PPTX::g_Namespaces.a.m_strLink;
 					namespace_		= L"wp";
 				}
 
@@ -145,7 +151,7 @@ namespace PPTX
 				pWriter->StartNode(namespaceLock_ + L":graphicFrameLocks");
 
 				pWriter->StartAttributes();
-
+				pWriter->WriteAttribute(_T("xmlns:") + namespaceLock_, namespaceLockLink_);
 				pWriter->WriteAttribute(_T("noChangeAspect"), noChangeAspect);
 				pWriter->WriteAttribute(_T("noDrilldown"), noDrilldown);
 				pWriter->WriteAttribute(_T("noGrp"), noGrp);

ASCOfficePPTXFile/PPTXFormat/Logic/Geometry.cpp

@@ -54,7 +54,7 @@ namespace PPTX
 				lpShapeElement = new NSPresentationEditor::CShapeElement(NSBaseShape::pptx, (int)_lspt);
 				std::wstring strAdjustValues = lpGeom.GetODString();
 				
-				lpShapeElement->m_oShape.getBaseShape()->LoadAdjustValuesList(strAdjustValues);
+				lpShapeElement->m_pShape->getBaseShape()->LoadAdjustValuesList(strAdjustValues);
 			}
 			else if (this->is<PPTX::Logic::CustGeom>())
 			{
@@ -71,8 +71,8 @@ namespace PPTX
 
 			LONG lCoordSize = 100000;
 
-			lpShapeElement->m_oShape.getBaseShape()->SetWidthHeightLogic(dCoordSizeX, dCoordSizeY);
-			lpShapeElement->m_oShape.getBaseShape()->ReCalculate();
+			lpShapeElement->m_pShape->getBaseShape()->SetWidthHeightLogic(dCoordSizeX, dCoordSizeY);
+			lpShapeElement->m_pShape->getBaseShape()->ReCalculate();
 
 			pOOXToVMLRenderer->put_Width((double)lCoordSize / dCoordSizeX);
 			pOOXToVMLRenderer->put_Height((double)lCoordSize / dCoordSizeY);						
@@ -85,7 +85,7 @@ namespace PPTX
 			oInfo.m_dWidth	= dCoordSizeX;
 			oInfo.m_dHeight	= dCoordSizeY;
 
-			NSPresentationEditor::CPath& oPath = lpShapeElement->m_oShape.getBaseShape()->m_oPath;
+			NSPresentationEditor::CPath& oPath = lpShapeElement->m_pShape->getBaseShape()->m_oPath;
 			
 			COOXToVMLGeometry* pOOXToVMLGeometry = dynamic_cast<COOXToVMLGeometry*>(pOOXToVMLRenderer);
 
@@ -111,19 +111,19 @@ namespace PPTX
 			if(NULL != pOOXToVMLGeometry)
 				pOOXToVMLGeometry->ResultPath(&strPath);
 
-			if (lpShapeElement->m_oShape.getBaseShape()->m_arTextRects.size() <= 0)
+			if (lpShapeElement->m_pShape->getBaseShape()->m_arTextRects.size() <= 0)
 			{
 				strRect = _T("0,0,100000,100000");
 			}
 			else
 			{
-				Aggplus::RECT& txRect = lpShapeElement->m_oShape.getBaseShape()->m_arTextRects[0];
+				Aggplus::RECT& txRect = lpShapeElement->m_pShape->getBaseShape()->m_arTextRects[0];
 				//double dkoefX = (double)lCoordSize / max(1, dCoordSizeX);
 				//double dkoefY = (double)lCoordSize / max(1, dCoordSizeY);
 
 				double _dWidth = ShapeSize;
 				double _dHeight = ShapeSize;
-				lpShapeElement->m_oShape.getBaseShape()->GetWidthHeightLogic(_dWidth, _dHeight);
+				lpShapeElement->m_pShape->getBaseShape()->GetWidthHeightLogic(_dWidth, _dHeight);
 
                 double dkoefX = (double)lCoordSize / (std::max)(1., _dWidth);
                 double dkoefY = (double)lCoordSize / (std::max)(1., _dHeight);

ASCOfficePPTXFile/PPTXFormat/Logic/Pic.cpp

@@ -233,7 +233,7 @@ namespace PPTX
 				}		
 				NSDirectory::DeleteDirectory(oox_unpacked.GetPath());
 			}
-			else if ( L"Equation.3" == sProgID || L"Equation.2" == sProgID )
+			else if ( std::wstring::npos != sProgID.find(L"Equation"))
 			{
 				pWriter->StartRecord(1);
 					pWriter->WriteBYTE(4);
@@ -637,11 +637,18 @@ namespace PPTX
 			{
 				pWriter->StartRecord(SPTREE_TYPE_OLE);
 				
-				if (oleObject->m_sShapeId.IsInit() && (!blipFill.blip->embed.IsInit() && blipFill.blip->oleFilepathImage.empty())  &&
-						parentFileIs<PPTX::Slide>() && parentFileAs<PPTX::Slide>().Vml.IsInit())
+				OOX::CVmlDrawing *pVml = NULL;
+				
+				if (parentFileIs<PPTX::Slide>())
 				{
-					OOX::CVmlDrawing *pVml = parentFileAs<PPTX::Slide>().Vml.operator->();
-					
+					pVml = parentFileAs<PPTX::Slide>().Vml.operator->();
+				}
+				else if (parentFileIs<PPTX::SlideMaster>())
+				{
+					pVml = parentFileAs<PPTX::SlideMaster>().Vml.operator->();
+				}
+				if (oleObject->m_sShapeId.IsInit() && pVml && !blipFill.blip->embed.IsInit() && blipFill.blip->oleFilepathImage.empty())
+				{					
 					std::map<std::wstring, OOX::CVmlDrawing::_vml_shape>::iterator pPair = pVml->m_mapShapes.find(*oleObject->m_sShapeId);
 					if (pVml->m_mapShapes.end() != pPair)
 					{
@@ -743,7 +750,7 @@ namespace PPTX
 				if(oleObject.IsInit() && oleObject->isValid())
 				{
 					bOle = true;
-					pWriter->WriteString(L"<p:graphicFrame><p:nvGraphicFramePr><p:cNvPr id=\"0\" name=\"\"/><p:cNvGraphicFramePr><a:graphicFrameLocks noChangeAspect=\"1\"/></p:cNvGraphicFramePr><p:nvPr><p:extLst><p:ext uri=\"{D42A27DB-BD31-4B8C-83A1-F6EECF244321}\"><p14:modId xmlns:p14=\"http://schemas.microsoft.com/office/powerpoint/2010/main\" val=\"2157879785\"/></p:ext></p:extLst></p:nvPr></p:nvGraphicFramePr>");
+					pWriter->WriteString(L"<p:graphicFrame><p:nvGraphicFramePr><p:cNvPr id=\"0\" name=\"\"/><p:cNvGraphicFramePr><a:graphicFrameLocks xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" noChangeAspect=\"1\"/></p:cNvGraphicFramePr><p:nvPr><p:extLst><p:ext uri=\"{D42A27DB-BD31-4B8C-83A1-F6EECF244321}\"><p14:modId xmlns:p14=\"http://schemas.microsoft.com/office/powerpoint/2010/main\" val=\"2157879785\"/></p:ext></p:extLst></p:nvPr></p:nvGraphicFramePr>");
 					if(spPr.xfrm.IsInit())
 					{
 						std::wstring oldNamespace = spPr.xfrm->m_ns;

ASCOfficeRtfFile/RtfFormatLib/source/RtfShape.cpp

@@ -1116,7 +1116,8 @@ std::wstring RtfShape::RenderToOOXBegin(RenderParameter oRenderParameter)
 //Custom
 	if (!m_aPVerticles.empty() || !m_aPSegmentInfo.empty())
 	{
-		CPPTShape * custom_shape = CPPTShape::CreateByType((PPTShapes::ShapeType)m_nShapeType);
+        CBaseShapePtr base_shape = CPPTShape::CreateByType((PPTShapes::ShapeType)m_nShapeType);
+        CPPTShape *custom_shape = dynamic_cast<CPPTShape*>(base_shape.get());
 		if (custom_shape)
 		{
 			custom_shape->m_bCustomShape = true;

ASCOfficeXlsFile2/source/XlsFormat/Auxiliary/HelpFunc.cpp

@@ -513,7 +513,23 @@ const std::wstring tab2sheet_name(const short tabid, std::vector<std::wstring>&
 	}
 	return L"#REF";
 }
-
+const std::wstring name2sheet_name(std::wstring name, const std::wstring prefix)
+{
+	static boost::wregex correct_sheet_name(L"^\\'.+?\\'$");
+    static boost::wregex test_sheet_name(L"[\\s)(\\'&:-]+"); //.??? 6442946.xls
+	
+	std::wstring sheet_first = prefix + name;
+	
+	if(!boost::regex_search(sheet_first.begin(), sheet_first.end(), correct_sheet_name))
+	{	
+		if(boost::regex_search(sheet_first.begin(), sheet_first.end(), test_sheet_name))
+		{	
+			sheet_first = boost::algorithm::replace_all_copy(sheet_first, L"'", L"''"); 
+			sheet_first = std::wstring(L"'") + sheet_first + std::wstring(L"'");
+		}
+	}
+	return sheet_first;
+}
 const std::wstring xti_indexes2sheet_name(const short tabFirst, const short tabLast, std::vector<std::wstring>& names, const std::wstring prefix)
 {
 	if(-1 == tabFirst)
@@ -538,7 +554,7 @@ const std::wstring xti_indexes2sheet_name(const short tabFirst, const short tabL
 	std::wstring sheet_last;
 	if (tabLast != tabFirst)
 	{
-		sheet_last = prefix + tab2sheet_name(tabLast, names);
+		sheet_last = std::wstring(L":") + prefix + tab2sheet_name(tabLast, names);
 		
 		if(!boost::regex_search(sheet_last.begin(), sheet_last.end(), correct_sheet_name))
 		{	
@@ -548,7 +564,6 @@ const std::wstring xti_indexes2sheet_name(const short tabFirst, const short tabL
 				sheet_last = std::wstring(L"\'") + sheet_last + std::wstring(L"\'");
 			}
 		}
-		sheet_last = std::wstring(L":") + sheet_last;
 	}
 
 	return sheet_first + sheet_last;

ASCOfficeXlsFile2/source/XlsFormat/Auxiliary/HelpFunc.h

@@ -95,6 +95,7 @@ namespace STR
 namespace XMLSTUFF
 {;
 
+const std::wstring name2sheet_name(std::wstring name, const std::wstring prefix);
 const std::wstring xti_indexes2sheet_name(const short tabFirst, const short tabLast, std::vector<std::wstring>& names, const std::wstring prefix = L"");
 
 }

ASCOfficeXlsFile2/source/XlsFormat/Binary/CFStream.cpp

@@ -73,6 +73,47 @@ void CFStream::read(void* buf, const size_t size)
 		return;// EndOfStreamReached
 	}
 }
+void CFStream::copy( std::wstring streamNameCreate, POLE::Storage * storageOut)
+{
+	stream_->seek(0);
+	int size_stream = stream_->size();
+
+	POLE::Stream *streamNew = new POLE::Stream(storageOut, streamNameCreate, true, size_stream);
+	if (!streamNew) return;
+
+	unsigned char buffer[4096];
+	int bytesRead = 0;
+
+	while(true)
+	{
+		int bytesToRead = size_stream - bytesRead;
+		if (bytesToRead <= 0)
+			break;
+		if (bytesToRead > 4096)
+			bytesToRead = 4096;
+	
+		stream_->read(buffer, bytesToRead);
+		streamNew->write(buffer, bytesToRead);
+		
+		bytesRead += bytesToRead;
+	}
+	//unsigned char* data_stream = new unsigned char[size_stream + 64];
+	//memset(data_stream, 0, size_stream + 64);
+	//if (data_stream)
+	//{
+	//	stream->read(data_stream, size_stream);
+
+	//	streamNew->write(data_stream, size_stream);
+
+	//	delete []data_stream;
+	//	data_stream = NULL;
+	//}
+
+	streamNew->flush();
+			
+	delete streamNew;
+}
+
 
 
 // Write 'size' unsigned chars to the stream

ASCOfficeXlsFile2/source/XlsFormat/Binary/CFStream.h

@@ -46,6 +46,8 @@ class CFStream
 public:
 	CFStream(POLE::Stream* stream);
 	~CFStream();
+
+	void copy( std::wstring streamNameCreate, POLE::Storage * storageOut);
 	
 	template<class Type>
 	CFStream& operator>>(Type& val) // Read a simple type or an object (not array)

ASCOfficeXlsFile2/source/XlsFormat/Binary/CFStreamCacheReader.cpp

@@ -49,6 +49,7 @@ global_info_(global_info)
 	skippable_records_names.push_back("StartBlock");
 	skippable_records_names.push_back("EndBlock");
 	skippable_records_names.push_back("ChartFrtInfo");
+	skippable_records_names.push_back("FrtWrapper");
 }
 
 
@@ -100,7 +101,7 @@ CFRecordPtr CFStreamCacheReader::getNextRecord(const CFRecordType::TypeId desira
 		}
 		if(skippable_records_names.end() != std::find(skippable_records_names.begin(), skippable_records_names.end(), rec_name))
 		{
-			Log::warning("The extracted record has been skipped (" + rec_name + ")");
+			//Log::warning("The extracted record has been skipped (" + rec_name + ")");
 			records_cache.pop_front();
 			continue;
 		}

ASCOfficeXlsFile2/source/XlsFormat/Binary/CompoundFile.cpp

@@ -103,7 +103,7 @@ void CompoundFile::copy_stream(std::wstring streamNameOpen, std::wstring streamN
 	if (!stream) return;
 
 	stream->seek(0);
-	int size_stream = stream->size();
+	POLE::uint64 size_stream = stream->size();
 
 	if (bWithRoot == false)
 	{

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Array.cpp

@@ -35,8 +35,7 @@
 namespace XLS
 {
 
-Array::Array(const CellRef& cell_base_ref_init)
-:	formula(false, cell_base_ref_init)
+Array::Array(const CellRef& cell_base_ref_init) :formula(false, cell_base_ref_init)
 {
 }
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Array.h

@@ -32,8 +32,8 @@
 #pragma once
 
 #include "BiffRecord.h"
-#include <Logic/Biff_structures/CellRangeRef.h>
-#include <Logic/Biff_structures/ArrayParsedFormula.h>
+#include "../Biff_structures/CellRangeRef.h"
+#include "../Biff_structures/ArrayParsedFormula.h"
 
 namespace XLS
 {
@@ -49,7 +49,6 @@ public:
 	~Array();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 	

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/AutoFilter.cpp

@@ -46,13 +46,15 @@ static inline void trim(std::wstring &s)
 		if (s[i] != 0) break;
 		else new_size--;
 	}
-	if (new_size < s.length())
+	if (new_size < (int)s.length())
 		s.erase(new_size);
 }
 
 AutoFilter::AutoFilter()
 {
 	wTopN = wJoin = 0;
+	size = -1;
+	bExist = false;
 }
 
 
@@ -68,6 +70,15 @@ BaseObjectPtr AutoFilter::clone()
 
 void AutoFilter::readFields(CFRecord& record)
 {
+	size_t pos_record = record.getRdPtr();
+
+	if (size < 0) size = record.getDataSize() - pos_record;
+
+	if (size > 0)
+	{
+		bExist = true;
+	}
+
 	m_bAutoFilter12 = false;
 
 	unsigned short flags;
@@ -93,13 +104,13 @@ void AutoFilter::readFields(CFRecord& record)
 		record >> doper2;
 	}
 
-	if ((doper1.vt == BIFF_BYTE(0)) && (doper2.vt == BIFF_BYTE(0)))
+	if (doper1.vt == 0 && doper2.vt == 0)
 	{
 		m_bAutoFilter12 = true;	
 		return;
 	}
 
-	if (doper1.vt == BIFF_BYTE(0x06))
+	if (doper1.vt == 0x06)
 	{
 		XLUnicodeStringNoCch s;
 		s.setSize(doper1.vtValueStr.cch);
@@ -109,7 +120,7 @@ void AutoFilter::readFields(CFRecord& record)
 		trim(str1);
 	}
 
-	if (doper2.vt == BIFF_BYTE(0x06))
+	if (doper2.vt == 0x06)
 	{
 		XLUnicodeStringNoCch s;
 		s.setSize(doper2.vtValueStr.cch);
@@ -119,9 +130,9 @@ void AutoFilter::readFields(CFRecord& record)
 		trim(str2);
 	}	
 
-	if (record.getRdPtr()  < record.getDataSize())
+	if (record.getRdPtr() - pos_record < size)
 	{
-		int sz = record.getDataSize() - record.getRdPtr();
+		int sz = size - (record.getRdPtr() - pos_record);
 		char *dd = new char [sz];
 		
 		memcpy(dd, record.getCurData<char>(), sz);

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/AutoFilter.h

@@ -32,13 +32,11 @@
 #pragma once
 
 #include "BiffRecord.h"
-#include <Logic/Biff_structures/AFDOper.h>
+#include "../Biff_structures/AFDOper.h"
 
 namespace XLS
 {
 
-
-// Logical representation of AutoFilter record in BIFF8
 class AutoFilter: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(AutoFilter)
@@ -74,6 +72,10 @@ public:
 	std::wstring str1;
 	std::wstring str2;
 
+//----------------------------------------
+	int		size;
+	bool	bExist;
+
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/AutoFilter12.cpp

@@ -58,14 +58,6 @@ void AutoFilter12::readFields(CFRecord& record)
 	
 	record >> frtRefHeader >> iEntry >> fHideArrow >> ft >> cft >> cCriteria >> cDateGroupings >> flags >> unused2 >> idList;
 
-	_UINT16 _iEntry = iEntry;
-	_UINT32 _fHideArrow = fHideArrow;
-	_UINT32 _ft = ft;
-	_UINT32 _cft = cft;
-	_UINT32 _cCriteria = cCriteria;
-	_UINT32 _cDateGroupings = cDateGroupings;
-	_UINT32 _idList = idList;	
-
 	// TODO доделать
 	record.skipNunBytes(record.getDataSize() - record.getRdPtr());
 
@@ -82,11 +74,12 @@ void AutoFilter12::readFields(CFRecord& record)
 		record >> frtRefHeaderContinue;
 		if (frtRefHeaderContinue.rt == 0x087F)
 		{		
-			if ( (ft == BIFF_DWORD(0)) && (cCriteria > 0) )
+			if ( ft == 0 && cCriteria > 0)
 			{
 				AF12CriteriaPtr item(new AF12Criteria);
 				item->load(record);
-				rgbAF12Criteries.push_back(item);
+				
+				arAF12Criteries.push_back(item);
 			}
 		}		
 	}

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/AutoFilter12.h

@@ -32,17 +32,16 @@
 #pragma once
 
 #include "BiffRecordContinued.h"
-#include <Logic/Biff_structures/FrtRefHeader.h>
-#include <Logic/Biff_structures/BiffString.h>
-#include <Logic/Biff_structures/FrtRefHeader.h>
-#include <Logic/Biff_structures/AFDOper.h>
-#include <Logic/Biff_structures/AF12Criteria.h>
+
+#include "../Biff_structures/FrtRefHeader.h"
+#include "../Biff_structures/BiffString.h"
+#include "../Biff_structures/FrtRefHeader.h"
+#include "../Biff_structures/AFDOper.h"
+#include "../Biff_structures/AF12Criteria.h"
 
 namespace XLS
 {
 
-
-// Logical representation of AutoFilter12 record in BIFF8
 class AutoFilter12: public BiffRecordContinued
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(AutoFilter12)
@@ -53,21 +52,21 @@ public:
 
 	BaseObjectPtr clone();
 
-	
 	void readFields(CFRecord& record);
 
 	static const ElementType	type = typeAutoFilter12;
 
 	FrtRefHeader frtRefHeader;
-	_UINT16		iEntry;
-	BIFF_DWORD	fHideArrow;
-	BIFF_DWORD	ft;
-	BIFF_DWORD	cft;
-	BIFF_DWORD	cCriteria;
-	BIFF_DWORD	cDateGroupings;
-	BIFF_DWORD	idList;
 	
-	BiffStructurePtrVector rgbAF12Criteries;
+	_UINT16		iEntry;
+	_UINT32		fHideArrow;
+	_UINT32		ft;
+	_UINT32		cft;
+	_UINT32		cCriteria;
+	_UINT32		cDateGroupings;
+	_UINT32		idList;
+	
+	BiffStructurePtrVector arAF12Criteries;
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/BRAI.h

@@ -33,8 +33,8 @@
 
 #include "BiffRecord.h"
 
-#include <Logic/Biff_structures/ChartParsedFormula.h>
-#include <Logic/Biff_structures/CellRangeRef.h>
+#include "../Biff_structures/ChartParsedFormula.h"
+#include "../Biff_structures/CellRangeRef.h"
 
 namespace XLS
 {

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/BiffRecord.cpp

@@ -70,7 +70,7 @@ const bool BiffRecord::read(CFStreamCacheReader& reader, BaseObject* parent, con
 		size_t rdPtr = record->getRdPtr();
 		size_t typeId = getTypeId();
 
-		if(record->getDataSize() != record->getRdPtr() && getTypeId() != rt_ANY_TYPE && getTypeId() != rt_MsoDrawing)
+		if(record->getDataSize() != record->getRdPtr() && getTypeId() != rt_ANY_TYPE/* && getTypeId() != rt_MsoDrawing*/)
 		{
 			Log::warning(STR::int2str(record->getDataSize() - record->getRdPtr(), 10) + " unsigned chars were not processed while reading from " + record->getTypeString());
 		}

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/BookBool.h

@@ -36,8 +36,6 @@
 namespace XLS
 {
 
-
-// Logical representation of BookBool record in BIFF8
 class BookBool: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(BookBool)
@@ -47,20 +45,18 @@ public:
 	~BookBool();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
 	static const ElementType	type = typeBookBool;
 
-//-----------------------------
 	bool fNoSaveSup;
 	bool fHasEnvelope;
 	bool fEnvelopeVisible;
 	bool fEnvelopeInitDone;
 	bool fHideBorderUnselLists;
 
-	BIFF_BSTR grUpdateLinks;
+	std::wstring grUpdateLinks;
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/BopPop.cpp

@@ -56,6 +56,7 @@ void BopPop::readFields(CFRecord& record)
 {
 	unsigned short flags;
 	record >> pst >> fAutoSplit >> split >> iSplitPos >> pcSplitPercent >> pcPie2Size >> pcGap >> numSplitValue >> flags;
+	
 	fHasShadow = GETBIT(flags, 0);
 }
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/BopPop.h

@@ -32,12 +32,11 @@
 #pragma once
 
 #include "BiffRecord.h"
+#include "../Biff_structures/Xnum.h"
 
 namespace XLS
 {
 
-
-// Logical representation of BopPop record in BIFF8
 class BopPop: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(BopPop)
@@ -47,7 +46,6 @@ public:
 	~BopPop();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
@@ -63,7 +61,7 @@ public:
 	_INT16			pcSplitPercent;
 	_INT16			pcPie2Size;
 	_INT16			pcGap;
-	BIFF_DOUBLE		numSplitValue;
+	Xnum			numSplitValue;
 	
 	bool			fHasShadow;
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/BottomMargin.h

@@ -32,12 +32,11 @@
 #pragma once
 
 #include "BiffRecord.h"
+#include "../Biff_structures/Xnum.h"
 
 namespace XLS
 {
 
-
-// Logical representation of BottomMargin record in BIFF8
 class BottomMargin: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(BottomMargin)
@@ -54,7 +53,7 @@ public:
 	static const ElementType	type = typeBottomMargin;
 
 //-----------------------------
-	BIFF_DOUBLE num;
+	Xnum num;
 
 };
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/BoundSheet8.cpp

@@ -79,7 +79,7 @@ void BoundSheet8::readFields(CFRecord& record)
 			hsState = std::wstring (L"hidden");
 			break;
 		case 2:
-			hsState = std::wstring (L"hidden");//(L"veryHidden");
+			hsState = std::wstring (L"veryHidden");
 			break;
 	}
 	if (name_.length() > 31)
@@ -91,9 +91,11 @@ void BoundSheet8::readFields(CFRecord& record)
 	{//file(6).xls
 		name_ = L"Sheet_" + boost::lexical_cast<std::wstring>(record.getGlobalWorkbookInfo()->current_sheet + 1);
 	}
-	
-	record.getGlobalWorkbookInfo()->sheets_names.push_back(name_);
-	record.getGlobalWorkbookInfo()->sheets_state.push_back(hsState);
+
+	GlobalWorkbookInfo::_sheet_info sheet_info;
+	sheet_info.state = hsState;
+	sheet_info.name = name_;
+	record.getGlobalWorkbookInfo()->sheets_info.push_back(sheet_info);
 	
 	dt = GETBITS(flags, 8, 15);
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/CalcDelta.h

@@ -32,12 +32,11 @@
 #pragma once
 
 #include "BiffRecord.h"
+#include "../Biff_structures/Xnum.h"
 
 namespace XLS
 {
 
-
-// Logical representation of CalcDelta record in BIFF8
 class CalcDelta: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(CalcDelta)
@@ -54,7 +53,7 @@ public:
 	static const ElementType	type = typeCalcDelta;
 
 //-----------------------------
-	BIFF_DOUBLE numDelta;
+	Xnum numDelta;
 
 };
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/CalcMode.h

@@ -36,8 +36,6 @@
 namespace XLS
 {
 
-
-// Logical representation of CalcMode record in BIFF8
 class CalcMode: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(CalcMode)
@@ -53,8 +51,7 @@ public:
 
 	static const ElementType	type = typeCalcMode;
 
-//-----------------------------
-	BIFF_BSTR fAutoRecalc;
+	std::wstring fAutoRecalc;
 
 };
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/CalcRefMode.h

@@ -36,8 +36,6 @@
 namespace XLS
 {
 
-
-// Logical representation of CalcRefMode record in BIFF8
 class CalcRefMode: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(CalcRefMode)
@@ -47,14 +45,12 @@ public:
 	~CalcRefMode();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
 	static const ElementType	type = typeCalcRefMode;
 
-//-----------------------------
-	BIFF_BSTR fRefA1;
+	std::wstring fRefA1;
 
 };
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/CondFmt.h

@@ -36,9 +36,6 @@
 
 namespace XLS
 {
-
-
-// Logical representation of CondFmt record in BIFF8
 class CondFmt: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(CondFmt)
@@ -48,20 +45,18 @@ public:
 	~CondFmt();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
-	static const ElementType	type = typeCondFmt;
+	static const ElementType type = typeCondFmt;
 
 	const CellRef getLocation() const;
 
-//-----------------------------
-	_UINT16		ccf;
-	bool		fToughRecalc;
-	_UINT16		nID;
-	SqRefU		sqref;
-	BIFF_BSTR	refBound;
+	_UINT16			ccf;
+	bool			fToughRecalc;
+	_UINT16			nID;
+	SqRefU			sqref;
+	std::wstring	refBound;
 };
 
 typedef boost::shared_ptr<CondFmt> CondFmtPtr;

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/CrtLayout12.h

@@ -32,12 +32,10 @@
 #pragma once
 
 #include "BiffRecord.h"
+#include "../Biff_structures/Xnum.h"
 
 namespace XLS
 {
-
-
-// Logical representation of CrtLayout12 record in BIFF8
 class CrtLayout12: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(CrtLayout12)
@@ -47,7 +45,6 @@ public:
 	~CrtLayout12();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
@@ -62,10 +59,10 @@ public:
 	CrtLayout12Mode wWidthMode;
 	CrtLayout12Mode wHeightMode;
 	
-	BIFF_DOUBLE x;
-	BIFF_DOUBLE y;
-	BIFF_DOUBLE dx;
-	BIFF_DOUBLE dy;
+	Xnum x;
+	Xnum y;
+	Xnum dx;
+	Xnum dy;
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/DConRef.cpp

@@ -122,9 +122,9 @@ void DConRef::check_external()
 {
 	bool bFound = false;
 
-	for (size_t i = 0; !bFilePath && i < global_info_->sheets_names.size(); i++)
+	for (size_t i = 0; !bFilePath && i < global_info_->sheets_info.size(); i++)
 	{
-		if (global_info_->sheets_names[i] == sheet_name)
+		if (global_info_->sheets_info[i].name == sheet_name)
 		{
 			bFound = true;
 			break;

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/DefColWidth.cpp

@@ -55,7 +55,10 @@ void DefColWidth::readFields(CFRecord& record)
 	GlobalWorkbookInfoPtr global_info = record.getGlobalWorkbookInfo();
 	record >> cchdefColWidth;
 
-	global_info->sheet_size_info.back().defaultColumnWidth = cchdefColWidth ;
+	if (!global_info->sheets_info.empty())
+	{
+		global_info->sheets_info.back().defaultColumnWidth = cchdefColWidth ;
+	}
 }
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/DefaultRowHeight.cpp

@@ -65,7 +65,10 @@ void DefaultRowHeight::readFields(CFRecord& record)
 	
 	record >> miyRw;
 
-	global_info->sheet_size_info.back().defaultRowHeight = miyRw / 20.;
+	if (!global_info->sheets_info.empty())
+	{
+		global_info->sheets_info.back().defaultRowHeight = miyRw / 20.;
+	}
 
 }
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Feat.cpp

@@ -31,7 +31,7 @@
  */
 
 #include "Feat.h"
-#include <Logic/Biff_structures/FrtHeader.h>
+#include "../Biff_structures/FrtHeader.h"
 
 namespace XLS
 {
@@ -45,43 +45,48 @@ Feat::~Feat()
 {
 }
 
-
 BaseObjectPtr Feat::clone()
 {
 	return BaseObjectPtr(new Feat(*this));
 }
+//		ISFPROTECTION	= 0x0002, // Specifies the enhanced protection type. 
+//		ISFFEC2			= 0x0003, // Specifies the ignored formula errors type.
+//		ISFFACTOID		= 0x0004, // Specifies the smart tag type.
+//		ISFLIST			= 0x0005, // Specifies the list type.
 
 void Feat::readFields(CFRecord& record)
 {
 	FrtHeader frtHeader(rt_Feat);
-	record >> frtHeader;
-	record >> isf;
+	
+	record >> frtHeader >> isf;
 	record.skipNunBytes(5); // reserved
+
 	record >> cref >> cbFeatData;
 	record.skipNunBytes(2); // reserved
-	std::wstring  sqref_str;
+	
 	for (int i = 0; i < cref ; ++i)
 	{
 		Ref8U reff;
 		record >> reff;
 		refs.push_back(BiffStructurePtr(new Ref8U(reff)));
-		sqref_str += std::wstring (reff.toString().c_str()) + ((i == cref - 1) ? L"" : L" ");
+		
+		sqref += reff.toString() + ((i == cref - 1) ? L"" : L" ");
 	}
-	sqref = sqref_str;
 
 	switch(isf)
 	{
-		case SharedFeatureType::ISFPROTECTION:
-			record >> protection;
+		case 0x0002://ISFPROTECTION:
+			is_object = BiffStructurePtr(new FeatProtection);
 			break;
-		case SharedFeatureType::ISFFEC2:
-			record >> formula_err;
+		case 0x0003://ISFFEC2:
+			is_object = BiffStructurePtr(new FeatFormulaErr2);
 			break;
-		case SharedFeatureType::ISFFACTOID:
-			record >> smart_tag;
+		case 0x0004://ISFFACTOID:
+			is_object = BiffStructurePtr(new FeatSmartTag);
 			break;
 	}
-
+	if (is_object)
+		is_object->load(record);
 }
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Feat.h

@@ -32,16 +32,14 @@
 #pragma once
 
 #include "BiffRecordContinued.h"
-#include <Logic/Biff_structures/CellRangeRef.h>
-#include <Logic/Biff_structures/FeatProtection.h>
-#include <Logic/Biff_structures/FeatFormulaErr2.h>
-#include <Logic/Biff_structures/FeatSmartTag.h>
+#include "../Biff_structures/CellRangeRef.h"
+#include "../Biff_structures/FeatProtection.h"
+#include "../Biff_structures/FeatFormulaErr2.h"
+#include "../Biff_structures/FeatSmartTag.h"
 
 namespace XLS
 {
 
-
-// Logical representation of Feat record in BIFF8
 class Feat: public BiffRecordContinued
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(Feat)
@@ -51,23 +49,18 @@ public:
 	~Feat();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
 	static const ElementType	type = typeFeat;
 
-//-----------------------------
-	SharedFeatureType isf;
-	_UINT16 cref;
-	_UINT32	cbFeatData;
+	_UINT16				isf;
+	_UINT16				cref;
+	_UINT32				cbFeatData;
 	BiffStructurePtrVector refs;
-	BIFF_BSTR sqref;
-
-	FeatProtection protection;
-	FeatFormulaErr2 formula_err;
-	FeatSmartTag smart_tag;
+	std::wstring		sqref;
 
+	BiffStructurePtr	is_object;
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/FeatHdr.cpp

@@ -63,10 +63,10 @@ void FeatHdr::readFields(CFRecord& record)
 	{
 		switch(isf)
 		{
-			case SharedFeatureType::ISFPROTECTION:
+			case 0x0002://ISFPROTECTION:
 				record >> protection;
 				break;
-			case SharedFeatureType::ISFFACTOID:
+			case 0x0004://ISFFACTOID:
 				if(is_contained_in_Globals)
 				{
 					record >> prop;

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/FeatHdr.h

@@ -55,12 +55,13 @@ public:
 
 	static const ElementType	type = typeFeatHdr;
 
+	_UINT16						isf;
+	_UINT32						cbHdrData;
+	EnhancedProtection			protection;
+	OSHARED::PropertyBagStore	prop;
+
 //-----------------------------
 	bool is_contained_in_Globals;
-	SharedFeatureType isf;
-	_UINT32	cbHdrData;
-	EnhancedProtection protection;
-	OSHARED::PropertyBagStore prop;
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/FeatHdr11.cpp

@@ -54,6 +54,12 @@ void FeatHdr11::readFields(CFRecord& record)
 {
 	record >> frt;
 	record >> isf;
+
+//		ISFPROTECTION	= 0x0002, // Specifies the enhanced protection type. 
+//		ISFFEC2			= 0x0003, // Specifies the ignored formula errors type.
+//		ISFFACTOID		= 0x0004, // Specifies the smart tag type.
+//		ISFLIST			= 0x0005, // Specifies the list type.
+
 	record.skipNunBytes(1);		// reserved1
 	record.skipNunBytes(4);		// reserved2
 	record.skipNunBytes(4);		// reserved3

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/FeatHdr11.h

@@ -32,13 +32,11 @@
 #pragma once
 
 #include "BiffRecord.h"
-#include <Logic/Biff_structures/FrtHeader.h>
+#include "../Biff_structures/FrtHeader.h"
 
 namespace XLS
 {
 
-
-// Logical representation of FeatHdr11 record in BIFF8
 class FeatHdr11: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(FeatHdr11)
@@ -48,18 +46,14 @@ public:
 	~FeatHdr11();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
 	static const ElementType	type = typeFeatHdr11;
 
-
-
-public:
-	FrtHeader frt;
-	SharedFeatureType isf;
-	_UINT32	idListNext;
+	FrtHeader	frt;
+	_UINT16		isf;
+	_UINT32		idListNext;
 
 };
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Feature11.cpp

@@ -39,12 +39,10 @@ Feature11::Feature11()
 {
 }
 
-
 Feature11::~Feature11()
 {
 }
 
-
 BaseObjectPtr Feature11::clone()
 {
 	return BaseObjectPtr(new Feature11(*this));
@@ -54,25 +52,21 @@ void Feature11::readFields(CFRecord& record)
 {
 	record >> frtRefHeaderU;
 	record >> isf;
+	
 	record.skipNunBytes(1);		// reserved1
 	record.skipNunBytes(4);		// reserved2
+	
 	record >> cref2;
 	record >> cbFeatData;
 	record.skipNunBytes(2);		// reserved3
 
-	unsigned short _isf = isf;
-	unsigned short _cref2 = cref2;
-	unsigned int _cbFeatData = cbFeatData;	
-
-	std::wstring  sqref_str;
 	for (int i = 0; i < cref2 ; ++i)
 	{
 		Ref8U reff;
 		record >> reff;
 		refs2.push_back(BiffStructurePtr(new Ref8U(reff)));
-		sqref_str += std::wstring (reff.toString().c_str()) + ((i == cref2 - 1) ? L"" : L" ");
+		sqref += reff.toString() + ((i == cref2 - 1) ? L"" : L" ");
 	}
-	sqref = sqref_str;	
 
 	record >> rgbFeat;	
 }

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Feature11.h

@@ -32,15 +32,14 @@
 #pragma once
 
 #include "BiffRecord.h"
-#include <Logic/Biff_structures/FrtRefHeaderU.h>
-#include <Logic/Biff_structures/CellRangeRef.h>
-#include <Logic/Biff_structures/TableFeatureType.h>
+
+#include "../Biff_structures/FrtRefHeaderU.h"
+#include "../Biff_structures/CellRangeRef.h"
+#include "../Biff_structures/TableFeatureType.h"
 
 namespace XLS
 {
 
-
-// Logical representation of Feature11 record in BIFF8
 class Feature11: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(Feature11)
@@ -50,23 +49,19 @@ public:
 	~Feature11();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
-	static const ElementType	type = typeFeature11;
+	static const ElementType type = typeFeature11;
 
-
-
-public:
 	FrtRefHeaderU			frtRefHeaderU;
 	_UINT16					isf;
 	_UINT16					cref2;
 	_UINT32					cbFeatData;
 	BiffStructurePtrVector	refs2;
-	BIFF_BSTR				sqref;
+	std::wstring			sqref;
 
-	TableFeatureType rgbFeat;
+	TableFeatureType		rgbFeat;
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Feature12.cpp

@@ -39,12 +39,10 @@ Feature12::Feature12()
 {
 }
 
-
 Feature12::~Feature12()
 {
 }
 
-
 BaseObjectPtr Feature12::clone()
 {
 	return BaseObjectPtr(new Feature12(*this));
@@ -53,6 +51,7 @@ BaseObjectPtr Feature12::clone()
 
 void Feature12::readFields(CFRecord& record)
 {
+	feature11.readFields(record);
 
 }
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Feature12.h

@@ -32,12 +32,12 @@
 #pragma once
 
 #include "BiffRecordContinued.h"
+#include "Feature11.h"
+
 
 namespace XLS
 {
 
-
-// Logical representation of Feature12 record in BIFF8
 class Feature12: public BiffRecordContinued
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(Feature12)
@@ -47,12 +47,12 @@ public:
 	~Feature12();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
-	static const ElementType	type = typeFeature12;
+	static const ElementType type = typeFeature12;
 
+	Feature11 feature11;
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/FileSharing.h

@@ -32,13 +32,11 @@
 #pragma once
 
 #include "BiffRecord.h"
-#include <Logic/Biff_structures/BiffString.h>
+#include "../Biff_structures/BiffString.h"
 
 namespace XLS
 {
 
-
-// Logical representation of FileSharing record in BIFF8
 class FileSharing: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(FileSharing)
@@ -48,16 +46,14 @@ public:
 	~FileSharing();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
 	static const ElementType	type = typeFileSharing;
 
-//-----------------------------
 	Boolean<unsigned short> fReadOnlyRec;
 	unsigned short			wResPassNum;
-	BIFF_BSTR				wResPass;
+	std::wstring			wResPass;
 	_UINT16					iNoResPass;
 	XLUnicodeString			stUNUsername;
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/HLinkTooltip.h

@@ -36,8 +36,6 @@
 namespace XLS
 {
 
-
-// Logical representation of HLinkTooltip record in BIFF8
 class HLinkTooltip: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(HLinkTooltip)
@@ -47,15 +45,13 @@ public:
 	~HLinkTooltip();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
-	static const ElementType	type = typeHLinkTooltip;
+	static const ElementType type = typeHLinkTooltip;
 
-//-----------------------------
-	BIFF_BSTR wzTooltip;
-	BackwardOnlyParam<std::wstring > ref_;
+	std::wstring						wzTooltip;
+	BackwardOnlyParam<std::wstring >	ref_;
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/LabelSst.cpp

@@ -80,12 +80,9 @@ int LabelSst::serialize(std::wostream & stream)
 			
 			CP_XML_ATTR(L"t", L"s");
 			
-			if (isst.value())
+			CP_XML_NODE(L"v")
 			{
-				CP_XML_NODE(L"v")
-				{
-					CP_XML_STREAM() << isst;
-				}
+				CP_XML_STREAM() << isst;
 			}
 		}			
 	}

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/LabelSst.h

@@ -62,7 +62,7 @@ public:
 	
 	CellOffsetResender		resender;
 	Cell					cell;
-	BIFF_DWORD				isst;
+	_UINT32					isst;
 
 };
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Lbl.cpp

@@ -44,8 +44,7 @@ const wchar_t* const AutoFilterDefineNames[] =
 };
 
 
-Lbl::Lbl()
-:	rgce(false), fGrp(0)
+Lbl::Lbl() : rgce(false), fGrp(0)
 {
 }
 
@@ -167,10 +166,6 @@ void Lbl::readFields(CFRecord& record)
 	}
 }
 
-const XLUnicodeStringNoCch Lbl::getName() const
-{
-	return Name_bin;
-}
 
 } // namespace XLS
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Lbl.h

@@ -39,8 +39,6 @@
 namespace XLS
 {
 
-
-// Logical representation of Lbl record in BIFF8
 class Lbl: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(Lbl)
@@ -51,15 +49,10 @@ public:
 
 	BaseObjectPtr clone();
 
-	
 	void readFields(CFRecord& record);
 
 	static const ElementType	type = typeLbl;
 
-
-	const XLUnicodeStringNoCch getName() const;
-
-//-----------------------------
 	bool fHidden;
 	bool fFunc;
 	bool fOB;
@@ -70,11 +63,11 @@ public:
 	bool fPublished;
 	bool fWorkbookParam;
 	
-	unsigned char	chKey;
-	_UINT16 itab;
-	XLUnicodeStringNoCch Name_bin;
-	BIFF_BSTR Name;
-	NameParsedFormula rgce;
+	unsigned char			chKey;
+	_UINT16					itab;
+	XLUnicodeStringNoCch	Name_bin;
+	std::wstring			Name;
+	NameParsedFormula		rgce;
 
 };
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/LeftMargin.h

@@ -32,12 +32,11 @@
 #pragma once
 
 #include "BiffRecord.h"
+#include "../Biff_structures/Xnum.h"
 
 namespace XLS
 {
 
-
-// Logical representation of LeftMargin record in BIFF8
 class LeftMargin: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(LeftMargin)
@@ -50,10 +49,9 @@ public:
 
 	static const ElementType	type = typeLeftMargin;
 
-	
 	void readFields(CFRecord& record);
 //-----------------------------
-	BIFF_DOUBLE num;
+	Xnum num;
 
 };
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/List12.cpp

@@ -32,6 +32,10 @@
 
 #include "List12.h"
 
+#include "../Biff_structures/List12BlockLevel.h"
+#include "../Biff_structures/List12TableStyleClientInfo.h"
+#include "../Biff_structures/List12DisplayName.h"
+
 namespace XLS
 {
 
@@ -39,12 +43,10 @@ List12::List12()
 {
 }
 
-
 List12::~List12()
 {
 }
 
-
 BaseObjectPtr List12::clone()
 {
 	return BaseObjectPtr(new List12(*this));
@@ -56,20 +58,20 @@ void List12::readFields(CFRecord& record)
 	record >> lsd;
 	record >> idList;
 
-	unsigned short _lsd = lsd;
-
 	switch (lsd)
 	{
 		case 0:
-			record >> rgbList12BlockLevel;
+			rgbList12 = BiffStructurePtr(new List12BlockLevel);
 			break;
 		case 1:
-			record >> rgbList12TableStyleClientInfo;
+			rgbList12 = BiffStructurePtr(new List12TableStyleClientInfo);
 			break;
 		case 2:
-			record >> rgbList12DisplayName;
+			rgbList12 = BiffStructurePtr(new List12DisplayName);
 			break;
 	}
+	if (rgbList12)
+		rgbList12->load(record);
 }
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/List12.h

@@ -32,16 +32,12 @@
 #pragma once
 
 #include "BiffRecord.h"
-#include <Logic/Biff_structures/FrtHeader.h>
-#include <Logic/Biff_structures/List12BlockLevel.h>
-#include <Logic/Biff_structures/List12TableStyleClientInfo.h>
-#include <Logic/Biff_structures/List12DisplayName.h>
+#include "../Biff_structures/FrtHeader.h"
+
 
 namespace XLS
 {
 
-
-// Logical representation of List12 record in BIFF8
 class List12: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(List12)
@@ -51,19 +47,16 @@ public:
 	~List12();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
-	static const ElementType	type = typeList12;
+	static const ElementType type = typeList12;
 
 	FrtHeader	frtHeader;
 	_UINT16		lsd;
 	_UINT32		idList;
 
-	List12BlockLevel				rgbList12BlockLevel;
-	List12TableStyleClientInfo		rgbList12TableStyleClientInfo;
-	List12DisplayName				rgbList12DisplayName;
+	BiffStructurePtr rgbList12;
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Number.cpp

@@ -83,12 +83,9 @@ int Number::serialize(std::wostream & stream)
 			{
 				CP_XML_ATTR(L"s", cell.ixfe - global_info_->cellStyleXfs_count);
 			}
-			if (num.value())
+			CP_XML_NODE(L"v")
 			{
-				CP_XML_NODE(L"v")
-				{
-					CP_XML_STREAM() << STR::double2str(num);
-				}
+				CP_XML_STREAM() << std::to_wstring(num.data.value);
 			}
 		}			
 	}

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Number.h

@@ -32,14 +32,13 @@
 #pragma once
 
 #include "BiffRecord.h"
-#include <Logic/Biff_structures/CellOffsetResender.h>
-#include <Logic/Biff_structures/Cell.h>
+#include "../Biff_structures/CellOffsetResender.h"
+#include "../Biff_structures/Cell.h"
+#include "../Biff_structures/Xnum.h"
 
 namespace XLS
 {
 
-
-// Logical representation of Number record in BIFF8
 class Number: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(Number)
@@ -59,13 +58,11 @@ public:
 
 	const CellRef getLocation() const;
 
-//-----------------------------
-	GlobalWorkbookInfoPtr	global_info_;
 	CellOffsetResender		resender;
 	Cell					cell;
-	BIFF_DOUBLE				num;
-
-
+	Xnum					num;
+//-----------------------------
+	GlobalWorkbookInfoPtr	global_info_;
 };
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/ObjProtect.h

@@ -36,8 +36,6 @@
 namespace XLS
 {
 
-
-// Logical representation of ObjProtect record in BIFF8
 class ObjProtect: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(ObjProtect)
@@ -51,7 +49,7 @@ public:
 	
 	void readFields(CFRecord& record);
 
-	static const ElementType	type = typeObjProtect;
+	static const ElementType type = typeObjProtect;
 
 //-----------------------------
 	Boolean<unsigned short> fLockObj;

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_records/Pane.h

@@ -38,8 +38,6 @@
 namespace XLS
 {
 
-
-// Logical representation of Pane record in BIFF8
 class Pane: public BiffRecord
 {
 	BIFF_RECORD_DEFINE_TYPE_INFO(Pane)
@@ -49,20 +47,18 @@ public:
 	~Pane();
 
 	BaseObjectPtr clone();
-
 	
 	void readFields(CFRecord& record);
 
-	static const ElementType	type = typePane;
+	static const ElementType type = typePane;
 
-//-----------------------------
 	_UINT16		x;
 	_UINT16		y;
 	_UINT16		rwTop;
 	_UINT16		colLeft;
 	PaneType	pnnAcct;
 	
-	BIFF_BSTR	topLeftCell;
+	std::wstring	topLeftCell;
 };
 
 } // namespace XLS