XlsFormat - кастомные автофигуры + группировки из автофигур

git-svn-id: svn://fileserver/activex/AVS/Sources/TeamlabOffice/trunk/ServerComponents@68264 954022d7-b5bf-4e40-9824-e11837661b57

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/ODRAW/OfficeArtClientAnchorSheet.cpp

@@ -12,7 +12,7 @@ namespace ODRAW
 OfficeArtClientAnchorSheet::OfficeArtClientAnchorSheet()
 :	OfficeArtRecord(0x00, ClientAnchor)
 {
-
+	_x = _y = _cx = _cy = 0;
 }
 
 
@@ -118,6 +118,47 @@ void OfficeArtClientAnchorSheet::loadFields(XLS::CFRecord& record)
 	}
 	else 
 		_dyB = dyB * kfRow * global_info->defaultRowHeight;	
+
+//----------------------------------------------------------------------------------------------------
+	for (int i = 1 ; i < colL; i++)
+	{
+		if (global_info->customColumnsWidth.find(i) != global_info->customColumnsWidth.end())
+			_x +=  256 * kfCol * global_info->customColumnsWidth[i];	
+		else 
+			_x +=  256 * kfCol * global_info->defaultColumnWidth;
+	}
+	_x += _dxL;
+
+	for (int i = colL ; i < colR; i++)
+	{
+		if (global_info->customColumnsWidth.find(i) != global_info->customColumnsWidth.end())
+			_cx += 256 * kfCol * global_info->customColumnsWidth[i];	
+		else 
+			_cx += 256 * kfCol * global_info->defaultColumnWidth;
+	}
+	_cx += _dxR;
+
+	for (int i = 1 ; i < rwT; i++)
+	{
+		if (global_info->customRowsHeight.find(i) != global_info->customRowsHeight.end())
+		{
+			_y += 256 * kfRow * global_info->customRowsHeight[i];	
+		}
+		else 
+			_y += 256 * kfRow * global_info->defaultRowHeight;	
+	}
+	_y += _dyT;
+
+	for (int i = rwT ; i < rwB; i++)
+	{
+		if (global_info->customRowsHeight.find(i) != global_info->customRowsHeight.end())
+		{
+			_cy += 256 * kfRow * global_info->customRowsHeight[i];	
+		}
+		else 
+			_cy += 256 * kfRow * global_info->defaultRowHeight;	
+	}
+	_cy += _dyT;
 }
 
 
@@ -128,7 +169,7 @@ void OfficeArtClientAnchorSheet::loadFields(XLS::CFRecord& record)
 OfficeArtChildAnchor::OfficeArtChildAnchor()
 :	OfficeArtRecord(0x00, ChildAnchor)
 {
-
+	_x = _y = _cx = _cy = 0;
 }
 
 
@@ -170,18 +211,7 @@ void OfficeArtChildAnchor::loadFields(XLS::CFRecord& record)
 	_y	= (std::min)(dyT, dyB) ;	
 	_cy = (std::max)(dyT, dyB) - _y;	
 
-	if (_x < 0) _x = 0;
-	if (_y < 0) _y = 0;
-
-	double kfCol	= 17640 / 256.;
-	double kfRow	= ( 360000 * 2.54 / 72) / 256. ;
-
 
-	_x	*=  326;
-	_cx *=  326;
-	_y	*=  kfRow;//326;
-	_cy *=  kfRow;//326;
-	//todooo     . ... flip?
 }
 
 } // namespace XLS

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/ODRAW/OfficeArtClientAnchorSheet.h

@@ -42,6 +42,11 @@ public:
 	_UINT32		_dyT;
 	_UINT32		_dxR;
 	_UINT32		_dyB;
+
+	int _x;
+	int _y;
+	int _cx;
+	int _cy;
 };
 
 typedef boost::shared_ptr<OfficeArtClientAnchorSheet> OfficeArtClientAnchorSheetPtr;
@@ -60,10 +65,10 @@ public:
 
 	int serialize(std::wostream & stream);
 
-	short dxL;
-	short dyT;
-	short dxR;
-	short dyB;
+	_INT32 dxL;
+	_INT32 dyT;
+	_INT32 dxR;
+	_INT32 dyB;
 
 	int _x;
 	int _y;

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/ODRAW/OfficeArtFOPTE.cpp

@@ -7,6 +7,55 @@
 
 namespace ODRAW
 {
+	static int GetCountPoints2(NSGuidesVML::RulesType eRuler, int lRepeatCount)
+	{
+		switch (eRuler)
+		{
+		case NSGuidesVML::rtMoveTo:				
+		case NSGuidesVML::rtRMoveTo:
+			{ return 1; }
+		
+		case NSGuidesVML::rtLineTo:		
+		case NSGuidesVML::rtRLineTo:
+			{ return lRepeatCount; }
+		
+		case NSGuidesVML::rtCurveTo:		
+		case NSGuidesVML::rtRCurveTo:
+			{ return 3 * lRepeatCount; }
+		
+		case NSGuidesVML::rtNoFill:
+		case NSGuidesVML::rtNoStroke:
+		case NSGuidesVML::rtClose:
+		case NSGuidesVML::rtEnd:	
+			{ return 0; }
+		
+		case NSGuidesVML::rtAngleEllipseTo:
+		case NSGuidesVML::rtAngleEllipse:
+			{ return lRepeatCount; }
+		
+		case NSGuidesVML::rtArc:
+		case NSGuidesVML::rtArcTo:
+
+		case NSGuidesVML::rtClockwiseArcTo:
+		case NSGuidesVML::rtClockwiseArc:
+			{ return lRepeatCount; }
+
+		case NSGuidesVML::rtEllipticalQuadrX:
+		case NSGuidesVML::rtEllipticalQuadrY:
+			{ return 1 * lRepeatCount; }
+
+		case NSGuidesVML::rtQuadrBesier:			
+			{ return /*2 * */lRepeatCount; }
+		case NSGuidesVML::rtFillColor:
+		case NSGuidesVML::rtLineColor:
+			{
+				return 1;
+			}
+		default: return 3 * lRepeatCount;
+		};
+
+		return 0;
+	}
 	static int BitmaskToInt( int value, int mask )
 	{
 		int ret = value & mask;
@@ -152,11 +201,13 @@ OfficeArtFOPTEPtr OfficeArtFOPTE::load_and_create(XLS::CFRecord& record)
 		case 0x0151:
 			fopte = OfficeArtFOPTEPtr(new pAdjustHandles);
 			break;
+		case 0x0156:
+			fopte = OfficeArtFOPTEPtr(new pGuides);
+			break;
 		case 0x0152:
 		case 0x0153:
 		case 0x0154:
 		case 0x0155:
-		case 0x0156:
 		case 0x0157:
 		case 0x0158:
 			fopte = OfficeArtFOPTEPtr(new OfficeArtFOPTE);
@@ -565,7 +616,7 @@ void pihlShape::ReadComplexData(XLS::CFRecord& record)
 {
 	record >> IHlink_complex;
 }
-
+//---------------------------------------------------------------------------------------------
 MSOPOINT::MSOPOINT()
 {
 	cbElement = 4;
@@ -594,14 +645,14 @@ void MSOPOINT::load(XLS::CFRecord& record)
 	}
 	else
 	{
-		unsigned char x_;
-		record >> x_;
+		unsigned short x_, y_;
+		record >> x_ >> y_;
 		
-		x = GETBITS(x_,0 , 3) << 8;
-		y = GETBITS(x_,4 , 8) << 8;
+		x = x_;
+		y = y_;
 	}
 }
-
+//---------------------------------------------------------------------------------------------
 MSOPATHINFO::MSOPATHINFO()
 {
 	cbElement = 4;
@@ -621,35 +672,214 @@ XLS::BiffStructurePtr MSOPATHINFO::clone()
 
 void MSOPATHINFO::load(XLS::CFRecord& record)
 {
-	unsigned short val;
-	record >> val;
+	_UINT16 mem = 0;
+	
+	record >> mem;
 
-	typeSegment			=	(MSOPATHTYPE)BitmaskToInt (val, 0xE000);
+	unsigned char type = (mem >> 13 & 0x07);
+	
+	if (type <= 4)
+	{
+		m_eRuler	= (NSGuidesVML::RulesType)type;
+		m_nCount	= (mem & 0x1FFF);
+		m_nCount	= (_UINT16)GetCountPoints2(m_eRuler, m_nCount);
+		return;
+	}
 
-	EscapeCode	= msopathEscapeExtension;
-	VertexCount	= 0;
-	Segments	= 0;
+	type = (mem >> 8) & 0x1F;
+	mem = mem & 0xFF;
 
-	if (msopathEscape == typeSegment || msopathClientEscape == typeSegment)
+	switch (type)
 	{
-		EscapeCode	=	(MSOPATHESCAPE)	BitmaskToInt (val, 0x1F00);
-		VertexCount =					BitmaskToInt (val, 0x00FF);
-	}
-	else
+	case 0x00:
+		{
+			m_eRuler = NSGuidesVML::rtLineTo;
+			break;
+		}
+	case 0x01:
+		{
+			m_eRuler = NSGuidesVML::rtAngleEllipseTo;
+			break;
+		}
+	case 0x02:
+		{
+			m_eRuler = NSGuidesVML::rtAngleEllipse;
+			break;
+		}
+	case 0x03:
+		{
+			m_eRuler = NSGuidesVML::rtArcTo;
+			break;
+		}
+	case 0x04:
+		{
+			m_eRuler = NSGuidesVML::rtArc;
+			break;
+		}
+	case 0x05:
+		{
+			m_eRuler = NSGuidesVML::rtClockwiseArcTo;
+			break;
+		}
+	case 0x06:
+		{
+			m_eRuler = NSGuidesVML::rtClockwiseArc;
+			break;
+		}
+	case 0x07:
+		{
+			m_eRuler = NSGuidesVML::rtEllipticalQuadrX;
+			break;
+		}
+	case 0x08:
+		{
+			m_eRuler = NSGuidesVML::rtEllipticalQuadrY;
+			break;
+		}
+	case 0x09:
+		{
+			m_eRuler = NSGuidesVML::rtQuadrBesier;
+			break;
+		}
+	case 0x0A:
+		{
+			m_eRuler = NSGuidesVML::rtNoFill;
+			break;
+		}
+	case 0x0B:
+		{
+			m_eRuler = NSGuidesVML::rtNoStroke;
+			break;
+		}
+	case 0x0C:
+	case 0x10:
+		{
+			m_eRuler = NSGuidesVML::rtLineTo;
+			break;
+		}
+	case 0x0D:
+	case 0x0E:
+	case 0x0F:
+	case 0x11:
+	case 0x12:
+	case 0x13:
+	case 0x14:
+		{
+			m_eRuler = NSGuidesVML::rtCurveTo;
+			break;
+		}
+	case 0x15:
+		{
+			m_eRuler = NSGuidesVML::rtFillColor;
+			break;
+		}
+	case 0x16:
+		{
+			m_eRuler = NSGuidesVML::rtLineColor;
+			break;
+		}
+	default:
+		{
+			m_eRuler = NSGuidesVML::rtCurveTo;
+		}
+	};
+
+	m_nCount = (_UINT16)mem;
+	m_nCount = (_UINT16)GetCountPoints2(m_eRuler, m_nCount);
+}
+//---------------------------------------------------------------------------------------------
+MSOSG::MSOSG()
+{
+	cbElement = 4;
+}
+MSOSG::MSOSG(unsigned short cbElement_)
+{
+	cbElement = 4;
+
+	if (cbElement_ == 0xfff0)
+		cbElement = 2;
+}
+
+XLS::BiffStructurePtr MSOSG::clone()
+{
+	return XLS::BiffStructurePtr(new MSOSG(*this));
+}
+
+void MSOSG::load(XLS::CFRecord& record)
+{
+	_UINT16 ftType;
+	record >> ftType;
+
+	m_eType = NSGuidesVML::FormulaType(ftType & 0x1FFF);
+
+	m_param_type1 = (unsigned char)(ftType & 0x04);
+	m_param_type2 = (unsigned char)(ftType & 0x02);
+	m_param_type3 = (unsigned char)(ftType & 0x01);
+
+	record >> m_param_value1 >> m_param_value2 >> m_param_value3;
+}
+//---------------------------------------------------------------------------------------------
+ADJH::ADJH()
+{
+	cbElement = 4;
+}
+
+ADJH::ADJH(unsigned short cbElement_)
+{
+	cbElement = 4;
+
+	if (cbElement_ == 0xfff0)
 	{
-		Segments	=	BitmaskToInt (val, 0x1FFF);
+		cbElement = 2;
 	}
 }
 
-void PVertices::ReadComplexData(XLS::CFRecord& record)
+XLS::BiffStructurePtr ADJH::clone() 
 {
+	return XLS::BiffStructurePtr(new ADJH(*this));
+}
+
+void ADJH::load(XLS::CFRecord& record)
+{
+	_UINT32 flag;
+	record >> flag;
+
+	fahInverseX			= GETBIT(flag, 31);
+	fahInverseY			= GETBIT(flag, 30);
+	fahSwitchPosition	= GETBIT(flag, 29);
+	fahPolar			= GETBIT(flag, 28);
+	fahPin				= GETBIT(flag, 27);
+	fahUnused			= GETBIT(flag, 26);
+	fahxMin				= GETBIT(flag, 25);
+	fahxMax				= GETBIT(flag, 24);
+	fahyMin				= GETBIT(flag, 23);
+	fahyMax				= GETBIT(flag, 22);
+	fahxRange			= GETBIT(flag, 21);
+	fahyRange			= GETBIT(flag, 20);
+	fahPolarPin			= GETBIT(flag, 19);
+	
+	record >> apX >> apY >> xRange >> yRange;
+	record >> xMin >> xMax >> yMin >> yMax;
+
 
-	record >> path_complex;
+}
+//---------------------------------------------------------------------------------------------
+void PVertices::ReadComplexData(XLS::CFRecord& record)
+{
+	record >> complex;
 }
 
 void PSegmentInfo::ReadComplexData(XLS::CFRecord& record)
 {
-	record >> path_complex;
+	record >> complex;
 }
 
+void pGuides::ReadComplexData(XLS::CFRecord& record)
+{
+	record >> complex;
+}
+void pAdjustHandles::ReadComplexData(XLS::CFRecord& record)
+{
+	record >> complex;
+}
 } 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/ODRAW/OfficeArtFOPTE.h

@@ -10,6 +10,8 @@
 #include <Logic/Biff_structures/HyperlinkObject.h>
 
 #include "../../../ASCOfficePPTXFile/Editor/Drawing/Shapes/BaseShape/PPTShape/Enums.h"
+#include "../../../../XlsXlsxConverter/ConvertShapes/GraphicsPath.h"
+#include "../../../../XlsXlsxConverter/ConvertShapes/FormulaShape.h"
 
 namespace XLS
 {
@@ -18,44 +20,7 @@ namespace XLS
 
 namespace ODRAW
 {
-		enum MSOPATHTYPE
-		{
-			msopathLineTo,
-			msopathCurveTo,
-			msopathMoveTo,
-			msopathClose,
-			msopathEnd,
-			msopathEscape,
-			msopathClientEscape,
-			msopathInvalid
-		};
-
-		enum MSOPATHESCAPE
-		{
-			msopathEscapeExtension 				=	0x00000000,	
-			msopathEscapeAngleEllipseTo  		=	0x00000001,
-			msopathEscapeAngleEllipse 	 		=	0x00000002,
-			msopathEscapeArcTo  				=	0x00000003,
-			msopathEscapeArc  					=	0x00000004,
-			msopathEscapeClockwiseArcTo  		=	0x00000005,
-			msopathEscapeClockwiseArc 	 		=	0x00000006,
-			msopathEscapeEllipticalQuadrantX  	=	0x00000007,
-			msopathEscapeEllipticalQuadrantY 	=	0x00000008,
-			msopathEscapeQuadraticBezier 	 	=	0x00000009,
-			msopathEscapeNoFill  				=	0x0000000A,
-			msopathEscapeNoLine  				=	0x0000000B,
-			msopathEscapeAutoLine  				=	0x0000000C,
-			msopathEscapeAutoCurve  			=	0x0000000D,
-			msopathEscapeCornerLine  			=	0x0000000E,
-			msopathEscapeCornerCurve 			=	0x0000000F,
-			msopathEscapeSmoothLine  			=	0x00000010,
-			msopathEscapeSmoothCurve  			=	0x00000011,
-			msopathEscapeSymmetricLine 			=	0x00000012,
-			msopathEscapeSymmetricCurve 		=	0x00000013,
-			msopathEscapeFreeform 				=	0x00000014,
-			msopathEscapeFillColor 				=	0x00000015,
-			msopathEscapeLineColor 				=	0x00000016
-		};
+
 class OfficeArtFOPTE;
 typedef boost::shared_ptr<OfficeArtFOPTE> OfficeArtFOPTEPtr;
 
@@ -593,24 +558,77 @@ class MSOPATHINFO : public XLS::BiffStructure
 
 	static const XLS::ElementType	type = XLS::typeOfficeArtRecord;
 
-	//enum msoPathSegmentType
-	//{
-	//	msopathLineTo = 0,
-	//	msopathCurveTo,
-	//	msopathMoveTo,
-	//	msopathClose,
-	//	msopathEnd,
-	//	msopathEscape,
-	//	msopathClientEscape
-	//};
-	unsigned short		cbElement;
+	NSGuidesVML::RulesType	m_eRuler;
+	_UINT16					m_nCount;
+	
+	int cbElement;
+};
+class MSOSG : public XLS::BiffStructure 
+{
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(MSOSG)
+
+	MSOSG();
+	MSOSG(unsigned short cbElement_);
+
+	XLS::BiffStructurePtr clone();
 
-	MSOPATHTYPE			typeSegment;
-	short				Segments;
-	short				VertexCount;
-	MSOPATHESCAPE		EscapeCode;
+	virtual void load(XLS::CFRecord& record);
+	virtual void store(XLS::CFRecord& record){}
+
+	static const XLS::ElementType	type = XLS::typeOfficeArtRecord;
+
+	NSGuidesVML::FormulaType	m_eType;
+
+	unsigned char				m_param_type1;
+	unsigned char				m_param_type2;
+	unsigned char				m_param_type3;
+
+	_UINT16						m_param_value1;
+	_UINT16						m_param_value2;
+	_UINT16						m_param_value3;
+	
+	int cbElement;
 };
+class ADJH : public XLS::BiffStructure 
+{
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(ADJH)
 
+	ADJH();
+	ADJH(unsigned short cbElement_);
+
+	XLS::BiffStructurePtr clone();
+
+	virtual void load(XLS::CFRecord& record);
+	virtual void store(XLS::CFRecord& record){}
+
+	static const XLS::ElementType	type = XLS::typeOfficeArtRecord;
+
+	int cbElement;
+
+	_UINT32 apX;
+	_UINT32 apY;
+	_INT32	xRange;
+	_INT32	yRange;
+	_INT32	xMin;
+	_INT32	xMax;
+	_INT32	yMin;
+	_INT32	yMax;
+
+//-------------------------
+	bool fahInverseX;
+	bool fahInverseY;
+	bool fahSwitchPosition;
+	bool fahPolar;
+	bool fahPin;
+	bool fahUnused;
+	bool fahxMin;
+	bool fahxMax;
+	bool fahyMin;
+	bool fahyMax;
+	bool fahxRange;
+	bool fahyRange;
+	bool fahPolarPin;
+};
 class ShapePath : public OfficeArtFOPTE 
 {
 	BASE_STRUCTURE_DEFINE_CLASS_NAME(ShapePath)
@@ -631,7 +649,7 @@ class PVertices : public OfficeArtFOPTE
 
 	virtual void ReadComplexData(XLS::CFRecord& record);
 
-	IMsoArray<MSOPOINT> path_complex;
+	IMsoArray<MSOPOINT> complex;
 };
 
 class PSegmentInfo : public OfficeArtFOPTE 
@@ -640,7 +658,15 @@ class PSegmentInfo : public OfficeArtFOPTE
 
 	virtual void ReadComplexData(XLS::CFRecord& record);
 
-	IMsoArray<MSOPATHINFO> path_complex;
+	IMsoArray<MSOPATHINFO> complex;
+};
+class pGuides : public OfficeArtFOPTE 
+{
+	BASE_STRUCTURE_DEFINE_CLASS_NAME(pGuides)
+
+	virtual void ReadComplexData(XLS::CFRecord& record);
+
+	IMsoArray<MSOSG> complex;
 };
 
 class AdjustValue : public OfficeArtFOPTE 
@@ -651,6 +677,10 @@ class AdjustValue : public OfficeArtFOPTE
 class pAdjustHandles : public OfficeArtFOPTE 
 {
 	BASE_STRUCTURE_DEFINE_CLASS_NAME(pAdjustHandles)
+	
+	virtual void ReadComplexData(XLS::CFRecord& record);
+
+	IMsoArray<ADJH> complex;
 };
 
 class lineOpacity : public OfficeArtFOPTE 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/ODRAW/OfficeArtFSPGR.cpp

@@ -27,6 +27,12 @@ void OfficeArtFSPGR::storeFields(XLS::CFRecord& record)
 void OfficeArtFSPGR::loadFields(XLS::CFRecord& record)
 {
 	record >> xLeft >> yTop >> xRight >> yBottom;
+
+	_x	= (std::min)(xLeft, xRight);
+	_cx = (std::max)(xLeft, xRight) - _x;
+	
+	_y	= (std::min)(yTop, yBottom) ;	
+	_cy = (std::max)(yTop, yBottom) - _y;	
 }
 
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/Biff_structures/ODRAW/OfficeArtFSPGR.h

@@ -27,6 +27,11 @@ public:
     _INT32 yTop;
     _INT32 xRight;
     _INT32 yBottom;
+
+	int _x;
+	int _y;
+	int _cx;
+	int _cy;
 };
 
 typedef boost::shared_ptr<OfficeArtFSPGR> OfficeArtFSPGRPtr;

ASCOfficeXlsFile2/source/XlsFormat/Logic/ChartSheetSubstream.cpp

@@ -279,7 +279,14 @@ int ChartSheetSubstream::serialize (std::wostream & _stream)
 			chart_frame->serialize(_stream);
 		else
 		{
-			//default spPr ???
+			CP_XML_NODE(L"c:spPr")
+			{
+				CP_XML_NODE(L"a:noFill");
+				CP_XML_NODE(L"a:ln")
+				{
+					CP_XML_NODE(L"a:noFill");
+				}
+			}
 		}
 	}
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/SummaryInformationStream/Structures/PropertyFactory.cpp

@@ -16,6 +16,8 @@ PropertyPtr PropertyFactory::ReadProperty(const unsigned int prop_type, XLS::CFS
 {
 	stream->seekFromBegin(property_offset);
 	unsigned short value_type;
+
+	if (stream->getStreamPointer() +2 > stream->getStreamSize()) return PropertyPtr();
 	*stream >> value_type;
 	stream->seekFromCurForward(2); // Skip 2 reserved unsigned chars
 

ASCOfficeXlsFile2/source/XlsFormat/Logic/SummaryInformationStream/Structures/PropertySet.cpp

@@ -21,13 +21,18 @@ PropertySet::PropertySet(XLS::CFStreamPtr stream, const unsigned int property_se
 	std::vector<PropertyIdentifierAndOffset> prop_offsets;
 	for(unsigned int i = 0; i < NumProperties; ++i)
 	{
+		if (stream->getStreamPointer() + 8 > stream->getStreamSize())
+			break;
 		PropertyIdentifierAndOffset prop_offset;
 		*stream >> prop_offset;
+
+		if (prop_offset.Offset - property_set_offset > Size)
+			break;
 		prop_offsets.push_back(prop_offset);
 	}
 
     code_page = PropertyCodePage::DefaultCodePage;
-	for(unsigned int i = 0; i < NumProperties; ++i)
+	for(unsigned int i = 0; i < prop_offsets.size(); ++i)
 	{
 		if (stream->getStreamPointer() - property_set_offset > Size)
 			break;

ASCOfficeXlsFile2/source/XlsFormat/Logic/WorksheetSubstream.cpp

@@ -267,8 +267,20 @@ const bool WorksheetSubstream::loadContent(BinProcessor& proc)
 		elements_.pop_back();
 	}
 
-	proc.repeated<FEAT>		(0, 0);
-	proc.repeated<FEAT11>	(0, 0);
+	count = proc.repeated<FEAT>		(0, 0);
+	while(count > 0)
+	{
+		m_arFEAT.insert(m_arFEAT.begin(), elements_.back());
+		elements_.pop_back();
+		count--;
+	}
+	count = proc.repeated<FEAT11>	(0, 0);
+	while(count > 0)
+	{
+		m_arFEAT11.insert(m_arFEAT11.begin(), elements_.back());
+		elements_.pop_back();
+		count--;
+	}
 	proc.repeated<RECORD12>	(0, 0);
 
 #pragma message("####################### Some trash records may be skipped here")

ASCOfficeXlsFile2/source/XlsFormat/Logic/WorksheetSubstream.h

@@ -40,7 +40,9 @@ public:
 	BaseObjectPtr				m_CONDFMTS;
 	BaseObjectPtr				m_CodeName;
 	BaseObjectPtr				m_SheetExt;
-
+	
+	std::vector<BaseObjectPtr>	m_arFEAT;
+	std::vector<BaseObjectPtr>	m_arFEAT11;
 	std::vector<BaseObjectPtr>	m_arNote;
 	std::vector<BaseObjectPtr>	m_arHLINK;
 	std::vector<BaseObjectPtr>	m_arSORT;

ASCOfficeXlsFile2/source/XlsXlsxConverter/ConvertShapes/BinaryReader.h

-#pragma once
-#include "../../../../Common/DocxFormat/Source/Base/Types_32.h"
-
-#define BINARY_READER_CHECK_OUT_RANGE(index, count)     \
-if (index > count)										\
-{														\
-	index = count;										\
-	return 0;											\
-}
-
-class CBinaryReader
-{
-private:
-	BYTE* m_pBuffer;
-	DWORD m_lCount;
-
-	DWORD m_lOrigin;
-
-public:
-	CBinaryReader(BYTE* pBuffer, DWORD lCount)
-	{
-		m_pBuffer = pBuffer;
-		m_lCount = lCount;
-
-		m_lOrigin = 0;
-	}
-	~CBinaryReader()
-	{
-		m_pBuffer = NULL;
-		m_lCount = 0;
-	}
-
-public:
-	LONG ReadLONG() // int32 
-	{
-		DWORD lOldOrigin = m_lOrigin;
-		m_lOrigin += 4;
-
-		BINARY_READER_CHECK_OUT_RANGE(m_lOrigin, m_lCount)
-
-		return *(_INT32*)(m_pBuffer + lOldOrigin);
-	}
-	DWORD ReadDWORD()
-	{
-		DWORD lOldOrigin = m_lOrigin;
-		m_lOrigin += 4;
-
-		BINARY_READER_CHECK_OUT_RANGE(m_lOrigin, m_lCount)
-
-		return *(DWORD*)(m_pBuffer + lOldOrigin);
-	}
-	WORD ReadWORD()
-	{
-		DWORD lOldOrigin = m_lOrigin;
-		m_lOrigin += 2;
-
-		BINARY_READER_CHECK_OUT_RANGE(m_lOrigin, m_lCount)
-
-		return *(WORD*)(m_pBuffer + lOldOrigin);
-	}
-	SHORT ReadSHORT()
-	{
-		DWORD lOldOrigin = m_lOrigin;
-		m_lOrigin += 2;
-
-		BINARY_READER_CHECK_OUT_RANGE(m_lOrigin, m_lCount)
-
-		return *(short*)(m_pBuffer + lOldOrigin);
-	}
-	double ReadDOUBLE()
-	{
-		DWORD lOldOrigin = m_lOrigin;
-		m_lOrigin += sizeof(double);
-
-		BINARY_READER_CHECK_OUT_RANGE(m_lOrigin, m_lCount)
-
-		return *(SHORT*)(m_pBuffer + lOldOrigin);
-	}
-};

ASCOfficeXlsFile2/source/XlsXlsxConverter/ConvertShapes/CustomGeomShape.h

 #pragma once
-#include "BinaryReader.h"
-//#include "ElementSettings.h"
+
+
 #include "BaseShape.h"
-//#include "../../../Attributes.h"
+
 #include "FormulaShape.h"
 
 #include "../../../../Common/DocxFormat/Source/SystemUtility/File.h"
@@ -14,10 +14,9 @@ namespace NSCustomVML
 	class CSegment
 	{
 	public:
-		RulesType m_eRuler;
-		WORD m_nCount;
+		RulesType	m_eRuler;
+		WORD		m_nCount;
 
-	public:
 		CSegment(RulesType eType = rtMoveTo, WORD nCount = 2)
 		{
 			m_eRuler = eType;
@@ -41,217 +40,6 @@ namespace NSCustomVML
 		~CSegment()
 		{
 		}
-		void Read(POLE::Stream* pStream)
-		{
-			WORD mem = StreamUtils::ReadWORD(pStream);
-
-			BYTE type = mem & 0x07;
-			if (type <= 4)
-			{
-				m_eRuler	= (RulesType)type;
-				m_nCount	= (mem >> 3) & 0x1FFF;
-				return;
-			}
-
-			mem = (mem >> 3) & 0x1FFF;
-			type = mem & 0x1F;
-
-			switch (type)
-			{
-			case 0x00:
-				{
-					m_eRuler = rtLineTo;
-					break;
-				}
-			case 0x01:
-				{
-					m_eRuler = rtAngleEllipseTo;
-					break;
-				}
-			case 0x02:
-				{
-					m_eRuler = rtAngleEllipse;
-					break;
-				}
-			case 0x03:
-				{
-					m_eRuler = rtArcTo;
-					break;
-				}
-			case 0x04:
-				{
-					m_eRuler = rtArc;
-					break;
-				}
-			case 0x05:
-				{
-					m_eRuler = rtClockwiseArcTo;
-					break;
-				}
-			case 0x06:
-				{
-					m_eRuler = rtClockwiseArc;
-					break;
-				}
-			case 0x07:
-				{
-					m_eRuler = rtEllipticalQuadrX;
-					break;
-				}
-			case 0x08:
-				{
-					m_eRuler = rtEllipticalQuadrY;
-					break;
-				}
-			case 0x09:
-				{
-					m_eRuler = rtQuadrBesier;
-					break;
-				}
-			case 0x0A:
-				{
-					m_eRuler = rtNoFill;
-					break;
-				}
-			case 0x0B:
-				{
-					m_eRuler = rtNoStroke;
-					break;
-				}
-			case 0x15:
-				{
-					m_eRuler = rtFillColor;
-					break;
-				}
-			case 0x16:
-				{
-					m_eRuler = rtLineColor;
-					break;
-				}
-			default:
-				{
-					m_eRuler = rtCurveTo;
-				}
-			};
-
-			m_nCount = (mem >> 5) & 0x00FF;
-		}
-		void Read(CBinaryReader& oReader)
-		{
-			WORD mem = oReader.ReadWORD();
-
-			BYTE type = (mem >> 13 & 0x07);
-			if (type <= 4)
-			{
-				m_eRuler	= (RulesType)type;
-				m_nCount	= (mem & 0x1FFF);
-				//m_nCount = (WORD)GetCountPoints2(m_eRuler);
-				m_nCount = (WORD)GetCountPoints2(m_eRuler, m_nCount);
-				return;
-			}
-
-			type = (mem >> 8) & 0x1F;
-			mem = mem & 0xFF;
-
-			switch (type)
-			{
-			case 0x00:
-				{
-					m_eRuler = rtLineTo;
-					break;
-				}
-			case 0x01:
-				{
-					m_eRuler = rtAngleEllipseTo;
-					break;
-				}
-			case 0x02:
-				{
-					m_eRuler = rtAngleEllipse;
-					break;
-				}
-			case 0x03:
-				{
-					m_eRuler = rtArcTo;
-					break;
-				}
-			case 0x04:
-				{
-					m_eRuler = rtArc;
-					break;
-				}
-			case 0x05:
-				{
-					m_eRuler = rtClockwiseArcTo;
-					break;
-				}
-			case 0x06:
-				{
-					m_eRuler = rtClockwiseArc;
-					break;
-				}
-			case 0x07:
-				{
-					m_eRuler = rtEllipticalQuadrX;
-					break;
-				}
-			case 0x08:
-				{
-					m_eRuler = rtEllipticalQuadrY;
-					break;
-				}
-			case 0x09:
-				{
-					m_eRuler = rtQuadrBesier;
-					break;
-				}
-			case 0x0A:
-				{
-					m_eRuler = rtNoFill;
-					break;
-				}
-			case 0x0B:
-				{
-					m_eRuler = rtNoStroke;
-					break;
-				}
-			case 0x0C:
-			case 0x10:
-				{
-					m_eRuler = rtLineTo;
-					break;
-				}
-			case 0x0D:
-			case 0x0E:
-			case 0x0F:
-			case 0x11:
-			case 0x12:
-			case 0x13:
-			case 0x14:
-				{
-					m_eRuler = rtCurveTo;
-					break;
-				}
-			case 0x15:
-				{
-					m_eRuler = rtFillColor;
-					break;
-				}
-			case 0x16:
-				{
-					m_eRuler = rtLineColor;
-					break;
-				}
-			default:
-				{
-					m_eRuler = rtCurveTo;
-				}
-			};
-
-			m_nCount = (WORD)mem;
-			m_nCount = (WORD)GetCountPoints2(m_eRuler, m_nCount);
-			//m_nCount = (WORD)GetCountPoints2(m_eRuler);
-		}
 	};
 
 	class CGuide
@@ -267,9 +55,8 @@ namespace NSCustomVML
 		WORD m_param_value2;
 		WORD m_param_value3;
 
-		LONG m_lShapeWidth;
-		LONG m_lShapeHeight;
-
+		//LONG m_lShapeWidth;
+		//LONG m_lShapeHeight;
 
 		CGuide()
 		{
@@ -283,8 +70,8 @@ namespace NSCustomVML
 			m_param_value2 = 0;
 			m_param_value3 = 0;
 
-			m_lShapeWidth	= ShapeSizeVML;
-			m_lShapeHeight	= ShapeSizeVML;
+			//m_lShapeWidth	= ShapeSizeVML;
+			//m_lShapeHeight= ShapeSizeVML;
 		}
 
 		CGuide(const CGuide& oSrc)
@@ -304,8 +91,8 @@ namespace NSCustomVML
 			m_param_value2	= oSrc.m_param_value2;
 			m_param_value3	= oSrc.m_param_value3;
 
-			m_lShapeWidth	= oSrc.m_lShapeWidth;
-			m_lShapeHeight	= oSrc.m_lShapeHeight;
+			//m_lShapeWidth	= oSrc.m_lShapeWidth;
+			//m_lShapeHeight	= oSrc.m_lShapeHeight;
 
 			return *this;
 		}
@@ -319,35 +106,6 @@ namespace NSCustomVML
 			SetParam(m_param_type3, m_param_value3, oFormula.m_eType3, oFormula.m_lParam3);
 		}
 
-		void Read(POLE::Stream* pStream)
-		{
-			WORD ftType = StreamUtils::ReadWORD(pStream);
-
-			m_eType = FormulaType(ftType & 0x1FFF);
-
-			m_param_type1 = (BYTE)(ftType & 0x04);
-			m_param_type2 = (BYTE)(ftType & 0x02);
-			m_param_type3 = (BYTE)(ftType & 0x01);
-
-			m_param_value1 = StreamUtils::ReadWORD(pStream);
-			m_param_value2 = StreamUtils::ReadWORD(pStream);
-			m_param_value3 = StreamUtils::ReadWORD(pStream);
-		}
-		void Read(CBinaryReader& oReader)
-		{
-			WORD ftType = oReader.ReadWORD();
-
-			m_eType = FormulaType(ftType & 0x1FFF);
-
-			m_param_type1 = (BYTE)(ftType & 0x04);
-			m_param_type2 = (BYTE)(ftType & 0x02);
-			m_param_type3 = (BYTE)(ftType & 0x01);
-
-			m_param_value1 = oReader.ReadWORD();
-			m_param_value2 = oReader.ReadWORD();
-			m_param_value3 = oReader.ReadWORD();
-		}
-
 	private:
 		void SetParam(BYTE type, WORD param, ParamType& param_type, LONG& param_value)
 		{
@@ -403,7 +161,7 @@ namespace NSCustomVML
 
 	class CCustomVML
 	{
-	private:
+	public:
 		RulesType m_ePath;
 
         std::vector<Aggplus::POINT>		m_arVertices;
@@ -417,7 +175,6 @@ namespace NSCustomVML
 		//CBrush	m_oBrush;
 		//CPen	m_oPen;
 
-	public:
 		CCustomVML() : m_arVertices(), m_arSegments(), m_arGuides(), m_pAdjustValues(NULL)
 		{
 			m_ePath = rtCurveTo/*rtLineTo*/;
@@ -450,7 +207,7 @@ namespace NSCustomVML
 			m_bIsVerticesPresent	= oSrc.m_bIsVerticesPresent;
 
 			//m_oBrush	= oSrc.m_oBrush;
-			//m_oPen		= oSrc.m_oPen;
+			//m_oPen	= oSrc.m_oPen;
 
 			return *this;
 		}
@@ -469,125 +226,31 @@ namespace NSCustomVML
 		void SetPath(RulesType ePath)
 		{
 			m_ePath = ePath;
-                        m_bIsPathPresent = true;
-		}
-		void LoadVertices(int val, unsigned char* buffer, int buffer_size)
-		{
-			CBinaryReader oReader(buffer, buffer_size);
-
-			m_arVertices.clear();
-			
-			WORD lCount = (WORD)(val / 8);
-			
-			//if (pProperty->m_bIsTruncated)todooo
-			{
-				lCount = (WORD)(val / 4);
-			}
-
-			if (lCount > 0)
-			{
-				m_bIsVerticesPresent = true;
-			}
-
-			for (WORD lIndex = 0; lIndex < lCount; ++lIndex)
-			{
-                Aggplus::POINT oPoint;
-				
-				//if (pProperty->m_bIsTruncated)todooo
-				//{
-				//	oPoint.x = (short)oReader.ReadWORD();
-				//	oPoint.y = (short)oReader.ReadWORD();
-				//}
-				//else
-				{
-					oPoint.x = oReader.ReadLONG();
-					oPoint.y = oReader.ReadLONG();
-				}
-
-				LONG lMinF = (LONG)0x80000000;
-				LONG lMaxF = (LONG)0x8000007F;
-				if (lMinF <= (DWORD)oPoint.x)
-				{
-					int nGuideIndex = (DWORD)oPoint.x - 0x80000000;	
-
-					bool b = false;
-				}
-				if (lMinF <= (DWORD)oPoint.y)
-				{
-					int nGuideIndex = (DWORD)oPoint.y - 0x80000000;					
-
-					bool b = false;
-				}
-
-				m_arVertices.push_back(oPoint);
-			}
+			m_bIsPathPresent = true;
 		}
-
 		void LoadAHs(unsigned char* buffer, int buffer_size)
 		{
 		}
-		void LoadSegments(int val, unsigned char* buffer, int buffer_size)
+		void addSegment(RulesType eRuler, _UINT16	nCount)
 		{
-			CBinaryReader oReader(buffer, buffer_size);
-			m_arSegments.clear();
-
-			WORD lCount = (WORD)(val / 2);
-
-			if (lCount > 0)
-			{
-                                m_bIsPathPresent = true;
-			}
-
-			for (WORD lIndex = 0; lIndex < lCount; ++lIndex)
-			{
-				CSegment oInfo;
-				oInfo.Read(oReader);
-
-				if (0 == oInfo.m_nCount)
-				{
-					if ((rtEnd		!= oInfo.m_eRuler) &&
-						(rtNoFill	!= oInfo.m_eRuler) &&
-						(rtNoStroke != oInfo.m_eRuler) &&
-						(rtClose	!= oInfo.m_eRuler))
-					{
-						continue;
-					}
-				}
-
-				//if (rtClose == oInfo.m_eRuler)
-				//{
-				//	//  					
-				//	CSegment oInfo2(rtLineTo, 1);
-				//	m_arSegments.push_back(oInfo2);
-				//}
-
-				m_arSegments.push_back(oInfo);
-			}
+			CSegment oInfo(eRuler, nCount);
+			m_arSegments.push_back(oInfo);
 		}
-		void LoadGuides(int val, unsigned char* buffer, int buffer_size)
+		void addGuide(CGuide & oInfo)
 		{
-			CBinaryReader oReader(buffer, buffer_size);
-			WORD lCount = (WORD)(val / 4);
-
-			for (WORD lIndex = 0; lIndex < lCount; ++lIndex)
-			{
-				CGuide oInfo;
-				oInfo.Read(oReader);
-				m_arGuides.push_back(oInfo);
-			}
-
+			m_arGuides.push_back(oInfo);
 		}
-		void LoadAdjusts(LONG lIndex, LONG lValue)
+		void addAdjust(int lIndex, int lValue)
 		{
 			if (NULL == m_pAdjustValues)
 				return;
 			
-			LONG lCount = (LONG)m_pAdjustValues->size();
+			int lCount = m_pAdjustValues->size();
 			
 			while (lCount <= lIndex)
 			{
 				m_pAdjustValues->push_back(0);
-				lCount = (LONG)m_pAdjustValues->size();
+				lCount = m_pAdjustValues->size();
 			}
 
 			(*m_pAdjustValues)[lIndex] = lValue;

ASCOfficeXlsFile2/source/XlsXlsxConverter/ConvertShapes/CustomShape.h

@@ -8,13 +8,13 @@
 class CCustomShape : public NSGuidesVML::CBaseShape
 {
 public:
-	oox::MSOSPT			m_eType;
+	oox::MSOSPT						m_eType;
 	NSGuidesVML::CFormulasManager	m_oManager;
 
-	NSCustomVML::CCustomVML m_oCustomVML;
+	NSCustomVML::CCustomVML			m_oCustomVML;
 	
-	std::wstring m_strPathLimoX;
-	std::wstring m_strPathLimoY;
+	std::wstring					m_strPathLimoX;
+	std::wstring					m_strPathLimoY;
 
 	std::vector<std::wstring> m_arStringTextRects;
 public:

ASCOfficeXlsFile2/source/XlsXlsxConverter/ConvertShapes/CustomShapeConvert.h

@@ -158,9 +158,6 @@ namespace NSGuidesVML
 	private:
 		int m_lIndexSrc;
 		int m_lIndexDst;
-
-		LONG m_lWidth;
-		LONG m_lHeight;
 	
 		std::vector<LONG>		m_arIndexDst;
 		std::vector<CSlicePath> m_arSlicesPath;
@@ -183,6 +180,10 @@ namespace NSGuidesVML
 		int m_lMaxAdjUse;
 
 	public:
+
+		LONG m_lWidth;
+		LONG m_lHeight;
+
 		CXmlWriter	m_oGuidsRes;
 		CXmlWriter	m_oPathRes;
 		CXmlWriter	m_oHandleRes;

ASCOfficeXlsFile2/source/XlsXlsxConverter/ConvertShapes/ShapeUtils.h

@@ -5,23 +5,13 @@
 #include <vector>
 #include <boost/algorithm/string.hpp>
 
-//#if defined(_WIN32) || defined(_WIN64)
-//	#include <atlbase.h>
-//	#include <atlstr.h>
-//	#include "../../../../Common/atldefine.h"
-//
-//#else
-//    #include "../../../../../Common/DocxFormat/Source/Base/ASCString.h"
-//#endif
 
 #include "../../../../../Common/DocxFormat/Source/Base/Base.h"
 #include "../../../../../DesktopEditor/graphics/GraphicsPath.h"
 
-
-
-const double ShapeSize		= 43200.0;
-const LONG ShapeSizeVML		= 21600;
-const double RadKoef = M_PI/10800000.0;
+const double	ShapeSize		= 43200.0;
+const int		ShapeSizeVML	= 21600;
+const double	RadKoef			= M_PI/10800000.0;
 
 #ifndef		pow2_16
 #define		pow2_16			65536

ASCOfficeXlsFile2/source/XlsXlsxConverter/XlsConverter.cpp

@@ -73,6 +73,14 @@
             _UINT32      biClrUsed;
             _UINT32      biClrImportant;
     } BITMAPINFOHEADER;
+
+typedef struct tagBITMAPCOREHEADER {
+        DWORD   bcSize;                 /* used to get to color table */
+        WORD    bcWidth;
+        WORD    bcHeight;
+        WORD    bcPlanes;
+        WORD    bcBitCount;
+} BITMAPCOREHEADER;
 #endif
 
 XlsConverter::XlsConverter(const std::wstring & xls_file, const std::wstring & _xlsx_path, const ProgressCallback* CallBack) 
@@ -502,6 +510,7 @@ std::wstring XlsConverter::WriteMediaFile(char *data, int size, std::wstring typ
 
 	if (type_ext == L"dib_data")
 	{
+		bool bPNG = false;
 		int offset = 0;
 		CBgraFrame frame;
 
@@ -524,8 +533,10 @@ std::wstring XlsConverter::WriteMediaFile(char *data, int size, std::wstring typ
 				header_core->bcWidth++;
 			
 			frame.put_Stride	(header_core->bcBitCount * header_core->bcWidth /8);
+
+			bPNG = true;
 		}
-		else
+		else if (header->biBitCount >=24)
 		{
 			offset = 40; //sizeof(BITMAPINFOHEADER)
 
@@ -538,14 +549,39 @@ std::wstring XlsConverter::WriteMediaFile(char *data, int size, std::wstring typ
 				header->biWidth++;
 			
 			frame.put_Stride	(header->biBitCount * header->biWidth /8);
-		
+			bPNG = true;
+		}
+		if (bPNG)
+		{
+			frame.put_Data((unsigned char*)data + offset);
+			
+			file_name += std::wstring(L".png");
+			
+			res = frame.SaveFile(xlsx_context->get_mediaitems().media_path() + file_name, 4/*CXIMAGE_FORMAT_PNG*/);
+			frame.put_Data(NULL);
+
+			if (res = false)
+			{
+				//
+			}
+		}
+		else
+		{
+			//тут паттерные картинки
+			file_name += std::wstring(L".bmp");
+			NSFile::CFileBinary file;
+			if (file.CreateFileW(xlsx_context->get_mediaitems().media_path() + file_name))
+			{
+				WORD vtType		= 0x4D42;				file.WriteFile((BYTE*)&vtType,	2);
+				DWORD dwLen		= header->biSizeImage;	file.WriteFile((BYTE*)&dwLen,	4);
+				DWORD dwRes		= 0;					file.WriteFile((BYTE*)&dwRes,	4);
+				DWORD dwOffset	= 2;					file.WriteFile((BYTE*)&dwOffset, 4);
+			
+				file.WriteFile((BYTE*)data, size);
+				file.CloseFile();
+				res = true;
+			}
 		}
-		frame.put_Data((unsigned char*)data + offset);
-		
-		file_name += std::wstring(L".png");
-		
-		res = frame.SaveFile(xlsx_context->get_mediaitems().media_path() + file_name, 4/*CXIMAGE_FORMAT_PNG*/);
-		frame.put_Data(NULL);
 	}
 	else
 	{
@@ -802,20 +838,20 @@ void XlsConverter::convert(ODRAW::OfficeArtRecord * art)
 	case XLS::typeOfficeArtFSPGR:
 		{
 			ODRAW::OfficeArtFSPGR * ch = dynamic_cast<ODRAW::OfficeArtFSPGR *>(art);
-			int l = ch->xLeft;
-			int r = ch->xRight;
-			int t = ch->yTop;
-			int b = ch->yBottom;
+
+			xlsx_context->get_drawing_context().set_group_anchor(ch->_x, ch->_y, ch->_cx, ch->_cy);
 		}break;
 	case XLS::typeOfficeArtChildAnchor:
 		{
-			//art->serialize(strm);
-            //xlsx_context->get_drawing_context().set_child_anchor(strm.str());
 			ODRAW::OfficeArtChildAnchor * ch = dynamic_cast<ODRAW::OfficeArtChildAnchor *>(art);
 			xlsx_context->get_drawing_context().set_child_anchor(ch->_x, ch->_y, ch->_cx, ch->_cy);
 		}break;
 	case XLS::typeOfficeArtClientAnchorSheet:
 		{
+			ODRAW::OfficeArtClientAnchorSheet * ch = dynamic_cast<ODRAW::OfficeArtClientAnchorSheet *>(art);
+			
+			xlsx_context->get_drawing_context().set_child_anchor(ch->_x, ch->_y, ch->_cx, ch->_cy);
+			
 			art->serialize(strm);
             xlsx_context->get_drawing_context().set_sheet_anchor(strm.str());
 		}break;
@@ -989,6 +1025,8 @@ void XlsConverter::convert_fill_style(std::vector<ODRAW::OfficeArtFOPTEPtr> & pr
 }
 void XlsConverter::convert_line_style(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
 {
+	if (props.size() < 1) return;
+
 	for (int i = 0 ; i < props.size() ; i++)
 	{
 		switch(props[i]->opid)
@@ -1043,6 +1081,8 @@ void XlsConverter::convert_line_style(std::vector<ODRAW::OfficeArtFOPTEPtr> & pr
 }
 void XlsConverter::convert_blip(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
 {
+	if (props.size() < 1) return;
+
 	for (int i = 0 ; i < props.size() ; i++)
 	{
 		ODRAW::FixedPoint * fixed_point = static_cast<ODRAW::FixedPoint *>(props[i].get());
@@ -1080,98 +1120,59 @@ void XlsConverter::convert_blip(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
 }
 void XlsConverter::convert_geometry(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
 {
-	std::vector<ODRAW::MSOPOINT>		points;
-	std::vector<ODRAW::MSOPATHINFO>		command;
-	ODRAW::ShapePath::msoShapePathType	shapeType;
-	oox::_rect rect;
+	if (props.size() < 1) return;
+
+	oox::_rect					rect;
+	std::vector<_CP_OPT(int)>	adjustValues(8);
 	
 	for (int i = 0 ; i < props.size() ; i++)
 	{
 		switch(props[i]->opid)
 		{
-		case 0x0140:	rect.left	= props[i]->op; break;
-		case 0x0141:	rect.top	= props[i]->op; break;
-		case 0x0142:	rect.right	= props[i]->op; break;
-		case 0x0143:	rect.bottom = props[i]->op; break;
-		case 0x0144:	shapeType	= (ODRAW::ShapePath::msoShapePathType)props[i]->op; break;
+		case 0x0140:	rect.x	= props[i]->op; break;
+		case 0x0141:	rect.y	= props[i]->op; break;
+		case 0x0142:	rect.cx	= props[i]->op; break;
+		case 0x0143:	rect.cy = props[i]->op; break;
+		case 0x0144:
+			xlsx_context->get_drawing_context().set_custom_path(props[i]->op); break;
 		case 0x0145:
 			{
 				ODRAW::PVertices * v = (ODRAW::PVertices *)(props[i].get());
-				points = v->path_complex.data;
+				xlsx_context->get_drawing_context().set_custom_verticles(v->complex.data);
 			}break;
 		case 0x0146:
 			{
 				ODRAW::PSegmentInfo * s = (ODRAW::PSegmentInfo *)(props[i].get());
-				command = s->path_complex.data;
+				xlsx_context->get_drawing_context().set_custom_segments(s->complex.data);
 			}break;
-		}
-	}
-
-	if (points.size() > 0 || command.size() > 0)
-	{
-		std::wstringstream strm;
-		CP_XML_WRITER(strm)    
-		{
-			if (command.size() == 0)
+		case 0x0147: //adjustValue .... //adjust8Value
+		case 0x0148:
+		case 0x0149:
+		case 0x014A:
+		case 0x014B:
+		case 0x014C:
+		case 0x014D:
+		case 0x014E:
 			{
-				for (int i = 0 ; i < points.size(); i++)
-				{
-					CP_XML_NODE(L"a:lnTo")
-					{
-						CP_XML_NODE(L"a:pt")
-						{
-							CP_XML_ATTR(L"x", points[i].x);
-							CP_XML_ATTR(L"y", points[i].y);
-						}
-					}
-				}
-			}
-			else
+				adjustValues[props[i]->opid - 0x0147] = props[i]->op ;
+			}break;
+		case 0x0156:
 			{
-				int ind_point = 0;
-				std::wstring comm[] = { L"a:lnTo", L"a:cubicBezTo", L"a:moveTo", L"a:close" };
-				int count_point[] = { 1, 3, 1, 0};
-				for (int i = 0 ; i < command.size(); i++)
-				{
-					if (ind_point >= points.size())
-						break;				
-					
-					//if (command[i].typeSegment == ODRAW::msopathEnd) break;
-					if (command[i].typeSegment > 3) continue;
-
-					CP_XML_NODE(comm[command[i].typeSegment])
-					{
-						for (int j=0 ; j < count_point[command[i].typeSegment]; j ++)
-						{
-							if (ind_point < points.size())
-							{
-								CP_XML_NODE(L"a:pt")
-								{
-									CP_XML_ATTR(L"x", points[ind_point].x);
-									CP_XML_ATTR(L"y", points[ind_point].y);
-									ind_point++;
-								}
-							}
-							else
-							{
-								CP_XML_NODE(L"a:pt")
-								{
-									CP_XML_ATTR(L"x", 0);
-									CP_XML_ATTR(L"y", 0);
-								}
-							}
-						}
-					}
-				}
-			}
+				ODRAW::pGuides* s = (ODRAW::pGuides *)(props[i].get());
+				xlsx_context->get_drawing_context().set_custom_guides(s->complex.data);
+			}break;
 		}
-		//xlsx_context->get_drawing_context().set_shapeType
-		xlsx_context->get_drawing_context().set_path_rect(rect);
-		xlsx_context->get_drawing_context().set_path(strm.str());
 	}
+	rect.cy -= rect.y;
+	rect.cx -= rect.x;
+	xlsx_context->get_drawing_context().set_custom_rect(rect);
+	
+	xlsx_context->get_drawing_context().set_custom_adjustValues(adjustValues);
 }
 void XlsConverter::convert_geometry_text(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
 {
+	if (props.size() < 1) return;
+
 	for (int i = 0 ; i < props.size() ; i++)
 	{
 		switch(props[i]->opid)
@@ -1230,18 +1231,17 @@ void XlsConverter::convert_geometry_text(std::vector<ODRAW::OfficeArtFOPTEPtr> &
 }
 void XlsConverter::convert_text(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
 {
+	if (props.size() < 1) return;
+
+	RECT text_margin = {0x00016530, 0x0000b298, 0x00016530, 0x0000b298};
 	for (int i = 0 ; i < props.size() ; i++)
 	{
 		switch(props[i]->opid)
 		{
-		case NSOfficeDrawing::dxTextLeft:	
-			//pParentShape->m_dTextMarginX = (double)pProperty->m_lValue / EMU_MM;		break;
-		case NSOfficeDrawing::dxTextRight:
-			//pParentShape->m_dTextMarginRight = (double)pProperty->m_lValue / EMU_MM;	break;			
-		case NSOfficeDrawing::dyTextTop:
-			//pParentShape->m_dTextMarginY = (double)pProperty->m_lValue / EMU_MM;		break;
-		case NSOfficeDrawing::dyTextBottom:
-			//pParentShape->m_dTextMarginBottom = (double)pProperty->m_lValue / EMU_MM;	break;
+		case NSOfficeDrawing::dxTextLeft:		text_margin.left	= props[i]->op;	break;
+		case NSOfficeDrawing::dxTextRight:		text_margin.right	= props[i]->op;	break;			
+		case NSOfficeDrawing::dyTextTop:		text_margin.top		= props[i]->op;	break;
+		case NSOfficeDrawing::dyTextBottom:		text_margin.bottom	= props[i]->op;	break;
 		case NSOfficeDrawing::WrapText:
 			{
 				xlsx_context->get_drawing_context().set_text_wrap(props[i]->op);				
@@ -1299,6 +1299,7 @@ void XlsConverter::convert_text(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
 			}break;
 		}
 	}
+	xlsx_context->get_drawing_context().set_text_margin(text_margin);
 }
 void XlsConverter::convert_shadow(std::vector<ODRAW::OfficeArtFOPTEPtr> & props)
 {
@@ -1322,7 +1323,7 @@ void XlsConverter::convert_group_shape(std::vector<ODRAW::OfficeArtFOPTEPtr> & p
 		case 0x380:
 			{
 				ODRAW::anyString *str = dynamic_cast<ODRAW::anyString*>(props[i].get());
-				//xlsx_context->get_drawing_context().set_name(str->string_);
+				xlsx_context->get_drawing_context().set_name(str->string_);
 			}break;
 		case 0x381:
 			{

ASCOfficeXlsFile2/source/XlsXlsxConverter/xlsx_drawing_context.h

@@ -4,6 +4,11 @@
 #include <iosfwd>
 #include <string.h>
 
+#include <boost/shared_array.hpp>
+#include "../Common/common.h"
+
+#include <Logic/Biff_structures/ODRAW/OfficeArtFOPTE.h>
+
 #include "xlsx_drawings.h"
 
 #include "ShapeType.h"	
@@ -19,8 +24,8 @@ const std::wstring standart_color[56] = {
 
 namespace oox {
 
-class external_items;
-class xlsx_conversion_context;
+	class external_items;
+	class xlsx_conversion_context;
 
 class xlsx_drawing_context_handle
 {
@@ -55,12 +60,12 @@ struct _color
 
 struct _rect
 {
-	_rect() : left(0), top(0), right(0),bottom(0){}
+	_rect() : x(0), y(0), cx(0), cy(0){}
 
-    int   left;
-    int   top;
-    int   right;
-    int   bottom;
+    int   x;
+    int   y;
+    int   cx;
+    int   cy;
 
 };
 enum _fill_type
@@ -93,13 +98,14 @@ class _drawing_state
 {
 public:
 	_drawing_state() :	shape_id(msosptRectangle),  
-						flipH(false), flipV(false), x(0), y(0), cx(0), cy(0),						
+						flipH(false), flipV(false), 					
 						bTextBox(false)
 	{
 		id			= -1;		
 		rotation	= 0;
 		type_anchor	= 1;
 		parent_drawing_states = NULL;
+		custom_path = -1;
 	}
 
 	int						shape_type;
@@ -115,26 +121,33 @@ public:
 	int						id;
 	MSOSPT					shape_id;
 //----------------------------------------------	
-	int						x;
-	int						y;
-	int						cx;
-	int						cy;
+	_rect					child_anchor;
 	bool					flipV;
 	bool					flipH;
 	int						rotation;
 //-----------------------------------------------
-	std::wstring			path;
-	_rect					path_rect;
+	std::vector<ODRAW::MSOPATHINFO>	custom_segments;
+	std::vector<ODRAW::MSOSG>		custom_guides;
+	std::vector<ODRAW::MSOPOINT>	custom_verticles;
 
-	std::wstring			hyperlink;
+	_rect							custom_rect;
+	std::vector<_CP_OPT(int)>		custom_adjustValues;
+	int								custom_path;
+
+	std::wstring					hyperlink;
 	struct _text
 	{
-		_text() : align(0)/*noset*/, wrap(2)/*none*/, vert_align(0)/*noset*/, vertical(0)/*horiz*/ {}
+		_text() :	align(0)/*noset*/, wrap(2)/*none*/, vert_align(0)/*noset*/, vertical(0)/*horiz*/ 
+		{
+			margins.left = margins.right = 0x00016530;
+			margins.top = margins.bottom = 0x0000b298;
+		}
 		std::wstring	content;	//c 
 		int				wrap;
 		int				align;
 		int				vert_align;
 		int				vertical;
+		RECT			margins;
 	}text;
 	
 	struct _wordart
@@ -199,6 +212,7 @@ public:
 //for group
 	std::vector<_drawing_state_ptr>		drawing_states;
 	std::vector<_drawing_state_ptr>*	parent_drawing_states;
+	_rect								group_anchor;
 };
 struct _hlink_desc
 {
@@ -259,20 +273,20 @@ public:
 
 		void set_absolute_anchor	(double width, double height);
         void set_child_anchor		(int x, int y, int cx, int cy);
+		void set_group_anchor		(int x, int y, int cx, int cy);
         void set_sheet_anchor		(const std::wstring & str);
 		bool is_anchor				();
 
         void set_properties			(const std::wstring & str);
         void set_hyperlink			(const std::wstring & link, const std::wstring & display, bool is_external);
 
-		void set_path_rect			(_rect & rect);
-		void set_path				(const std::wstring & path);
 
 		void set_text				(const std::wstring & text);
 		void set_text_wrap			(int val);
 		void set_text_align			(int val);
 		void set_text_vert_align	(int val);
 		void set_text_vertical		(int val);
+		void set_text_margin		(RECT & val);
 		
 		void set_wordart_text		(const std::wstring & text);
 		void set_wordart_font		(const std::wstring & text);
@@ -283,7 +297,13 @@ public:
 		void set_wordart_strike		(bool val);
 		void set_wordart_vertical	(bool val);
 		void set_wordart_spacing	(double val);
-		
+
+		void set_custom_rect		(_rect							& rect);
+		void set_custom_verticles	(std::vector<ODRAW::MSOPOINT>	& points);
+		void set_custom_segments	(std::vector<ODRAW::MSOPATHINFO>& segments);
+		void set_custom_guides		(std::vector<ODRAW::MSOSG>		& guides);
+		void set_custom_adjustValues(std::vector<_CP_OPT(int)>		& values);
+		void set_custom_path		(int type_path);
 //------------------------------------------------------------------------------	
 		void serialize_group		();
 		void serialize_shape		(_drawing_state_ptr & drawing_state);