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/ShapeType.h

@@ -231,155 +231,155 @@ namespace oox
         case msosptRectangle : 					return L"rect";
         case msosptRoundRectangle : 			return L"roundRect";
         case msosptEllipse : 					return L"ellipse";
-        case msosptDiamond : 					return L"diamond";
+        //case msosptDiamond : 					return L"diamond";
         case msosptIsocelesTriangle :			return L"triangle";
-        case msosptRightTriangle : 				return L"rtTriangle";
-        case msosptParallelogram : 				return L"parallelogram";
-        case msosptTrapezoid : 					return L"trapezoid";
-        case msosptHexagon : 					return L"hexagon";
-        case msosptOctagon : 					return L"octagon";
-        case msosptPlus : 						return L"plus";
-        case msosptStar : 						return L"star5";
-        case msosptArrow : 						return L"rightArrow";    //???
-        case msosptThickArrow : 				return L"thickArrow";
-        case msosptHomePlate : 					return L"homePlate";
-        case msosptCube : 						return L"cube";
-        case msosptBalloon : 					return L"ballon";
-        case msosptSeal : 						return L"irregularSeal1";
-        case msosptArc : 						return L"arc";
+        //case msosptRightTriangle : 			return L"rtTriangle";
+        //case msosptParallelogram : 			return L"parallelogram";
+        //case msosptTrapezoid : 				return L"trapezoid";
+        //case msosptHexagon : 					return L"hexagon";
+        //case msosptOctagon : 					return L"octagon";
+        //case msosptPlus : 					return L"plus";
+        //case msosptStar : 					return L"star5";
+        //case msosptArrow : 					return L"rightArrow";    //???
+        //case msosptThickArrow : 				return L"thickArrow";
+        //case msosptHomePlate : 				return L"homePlate";
+        //case msosptCube : 					return L"cube";
+        //case msosptBalloon : 					return L"ballon";
+        //case msosptSeal : 					return L"irregularSeal1";
+        //case msosptArc : 						return L"arc";
         case msosptLine : 						return L"line";
-        case msosptPlaque : 					return L"plaque";
-        case msosptCan : 						return L"can";
-        case msosptDonut : 						return L"donut";
-        case msosptStraightConnector1 : 		return L"straightConnector1";
-        case msosptBentConnector2 : 			return L"bentConnector2";
-        case msosptBentConnector3 : 			return L"bentConnector3";
-        case msosptBentConnector4 : 			return L"bentConnector4";
-        case msosptBentConnector5 : 			return L"bentConnector5";
-        case msosptCurvedConnector2 : 			return L"curvedConnector2";
-        case msosptCurvedConnector3 : 			return L"curvedConnector3";
-        case msosptCurvedConnector4 : 			return L"curvedConnector4";
-        case msosptCurvedConnector5 : 			return L"curvedConnector5";
-        case msosptCallout1 : 					return L"callout1";
-        case msosptCallout2 : 					return L"callout2";
-        case msosptCallout3 : 					return L"callout3";
-        case msosptAccentCallout1 : 			return L"accentCallout1";
-        case msosptAccentCallout2 : 			return L"accentCallout2";
-        case msosptAccentCallout3 : 			return L"accentCallout3";
-        case msosptBorderCallout1 : 			return L"accentCallout1";
-        case msosptBorderCallout2 : 			return L"accentCallout2";
-        case msosptBorderCallout3 : 			return L"accentCallout3";
-        case msosptAccentBorderCallout1 : 		return L"accentBorderCallout1";
-        case msosptAccentBorderCallout2 : 		return L"accentBorderCallout2";
-        case msosptAccentBorderCallout3 : 		return L"accentBorderCallout3";
-        case msosptRibbon : 					return L"ribbon";
-        case msosptRibbon2 : 					return L"ribbon2";
-        case msosptChevron : 					return L"chevron";
-        case msosptPentagon : 					return L"pentagon";
-        case msosptNoSmoking : 					return L"noSmoking";
-        case msosptSeal8 : 						return L"star8";
-        case msosptSeal16 : 					return L"star16";
-        case msosptSeal32 : 					return L"star32";
-        case msosptWedgeRectCallout : 			return L"wedgeRectCallout";
-        case msosptWedgeRRectCallout : 			return L"wedgeRoundRectCallout";
-        case msosptWedgeEllipseCallout : 		return L"wedgeEllipseCallout";
-        case msosptWave : 						return L"wave";
-        case msosptFoldedCorner : 				return L"foldedCorner";
-        case msosptLeftArrow : 					return L"leftArrow";
-        case msosptDownArrow : 					return L"downArrow";
-        case msosptUpArrow : 					return L"upArrow";
-        case msosptLeftRightArrow : 			return L"leftRightArrow";
-        case msosptUpDownArrow : 				return L"upDownArrow";
-        case msosptIrregularSeal1 : 			return L"irregularSeal1";
-        case msosptIrregularSeal2 : 			return L"irregularSeal2";
-        case msosptLightningBolt : 				return L"lightningBolt";
-        case msosptHeart : 						return L"heart";
-        //case msosptPictureFrame : 			return 3000;//L"shapetypeFrame";   L"shapetypeRect";//
-        case msosptQuadArrow : 					return L"quadArrow";
-        case msosptLeftArrowCallout : 			return L"leftArrowCallout";
-        case msosptRightArrowCallout : 			return L"rightArrowCallout";
-        case msosptUpArrowCallout : 			return L"upArrowCallout";
-        case msosptDownArrowCallout : 			return L"downArrowCallout";
-        case msosptLeftRightArrowCallout : 		return L"leftRightArrowCallout";
-        case msosptUpDownArrowCallout : 		return L"upDownArrowCallout";
-        case msosptQuadArrowCallout : 			return L"quadArrowCallout";
-        case msosptBevel : 						return L"bevel";
-        case msosptLeftBracket : 				return L"leftBracket";
-        case msosptRightBracket : 				return L"rightBracket";
-        case msosptLeftBrace : 					return L"leftBrace";
-        case msosptRightBrace : 				return L"rightBrace";
-        case msosptLeftUpArrow : 				return L"leftUpArrow";
-        case msosptBentUpArrow : 				return L"bentUpArrow";
-        case msosptBentArrow : 					return L"bentArrow";
-        case msosptSeal24 : 					return L"star24";
-        case msosptStripedRightArrow : 			return L"stripedRightArrow";
-        case msosptNotchedRightArrow : 			return L"notchedRightArrow";
-        case msosptBlockArc : 					return L"blockArc";
-        case msosptSmileyFace : 				return L"smileyFace";
-        case msosptVerticalScroll : 			return L"verticalScroll";
-        case msosptHorizontalScroll : 			return L"horizontalScroll";
-        case msosptCircularArrow : 				return L"circularArrow";
-        case msosptNotchedCircularArrow :		return L"flowChartDelay";		//return L"notchedCircularArrow";
-        case msosptUturnArrow : 				return L"uturnArrow";
-        case msosptCurvedRightArrow : 			return L"curvedRightArrow";
-        case msosptCurvedLeftArrow : 			return L"curvedLeftArrow";
-        case msosptCurvedUpArrow : 				return L"curvedUpArrow";
-        case msosptCurvedDownArrow : 			return L"curvedDownArrow";
-        case msosptCloudCallout : 				return L"cloudCallout";
-        case msosptEllipseRibbon : 				return L"ellipseRibbon";
-        case msosptEllipseRibbon2 : 			return L"ellipseRibbon2";
-        case msosptFlowChartProcess : 			return L"flowChartProcess";
-        case msosptFlowChartDecision : 			return L"flowChartDecision";
-        case msosptFlowChartInputOutput : 		return L"flowChartInputOutput";
-        case msosptFlowChartPredefinedProcess:	return L"flowChartPredefinedProcess";
-        case msosptFlowChartInternalStorage :	return L"flowChartInternalStorage";
-        case msosptFlowChartDocument : 			return L"flowChartDocument";
-        case msosptFlowChartMultidocument :		return L"flowChartMultidocument";
-        case msosptFlowChartTerminator : 		return L"flowChartTerminator";
-        case msosptFlowChartPreparation : 		return L"flowChartPreparation";
-        case msosptFlowChartManualInput : 		return L"flowChartManualInput";
-        case msosptFlowChartManualOperation :	return L"flowChartManualOperation";
-        case msosptFlowChartConnector : 		return L"flowChartConnector";
-        case msosptFlowChartPunchedCard : 		return L"flowChartPunchedCard";
-        case msosptFlowChartPunchedTape : 		return L"flowChartPunchedTape";
-        case msosptFlowChartSummingJunction :	return L"flowChartSummingJunction";
-        case msosptFlowChartOr : 				return L"flowChartOr";
-        case msosptFlowChartCollate : 			return L"flowChartCollate";
-        case msosptFlowChartSort : 				return L"flowChartSort";
-        case msosptFlowChartExtract : 			return L"flowChartExtract";
-        case msosptFlowChartMerge : 			return L"flowChartMerge";
-        case msosptFlowChartOfflineStorage : 	return L"flowChartOfflineStorage";
-        case msosptFlowChartOnlineStorage : 	return L"flowChartOnlineStorage";
-        case msosptFlowChartMagneticTape :		return L"flowChartMagneticTape";
-        case msosptFlowChartMagneticDisk :		return L"flowChartMagneticDisk";
-        case msosptFlowChartMagneticDrum :		return L"flowChartMagneticDrum";
-        case msosptFlowChartDisplay : 			return L"flowChartDisplay";
-        case msosptFlowChartDelay : 			return L"flowChartDelay";
-        case msosptFlowChartAlternateProcess :	return L"flowChartAlternateProcess";
-        case msosptFlowChartOffpageConnector :	return L"flowChartOffpageConnector";
-        case msosptCallout90 : 					return L"callout1";
-        case msosptAccentCallout90 : 			return L"accentCallout1";
-        case msosptBorderCallout90 : 			return L"borderCallout1";
-        case msosptAccentBorderCallout90 : 		return L"accentBorderCallout1";
-        case msosptLeftRightUpArrow : 			return L"leftRightUpArrow";
-        case msosptSun : 						return L"sun";
-        case msosptMoon : 						return L"moon";
-        case msosptBracketPair : 				return L"bracketPair";
-        case msosptBracePair : 					return L"bracePair";
-        case msosptSeal4 : 						return L"star4";
-        case msosptDoubleWave : 				return L"doubleWave";
-        case msosptActionButtonBlank : 			return L"actionButtonBlank";
-        case msosptActionButtonHome : 			return L"actionButtonHome";
-        case msosptActionButtonHelp : 			return L"actionButtonHelp";
-        case msosptActionButtonInformation :	return L"actionButtonInformation";
-        case msosptActionButtonForwardNext :	return L"actionButtonForwardNext";
-        case msosptActionButtonBackPrevious :	return L"actionButtonBackPrevious";
-        case msosptActionButtonEnd : 			return L"actionButtonEnd";
-        case msosptActionButtonBeginning : 		return L"actionButtonBeginning";
-        case msosptActionButtonReturn : 		return L"actionButtonReturn";
-        case msosptActionButtonDocument : 		return L"actionButtonDocument";
-        case msosptActionButtonSound : 			return L"actionButtonSound";
-        case msosptActionButtonMovie : 			return L"actionButtonMovie";
+        //case msosptPlaque : 					return L"plaque";
+        //case msosptCan : 						return L"can";
+        //case msosptDonut : 					return L"donut";
+        //case msosptStraightConnector1 : 		return L"straightConnector1";
+        //case msosptBentConnector2 : 			return L"bentConnector2";
+        //case msosptBentConnector3 : 			return L"bentConnector3";
+        //case msosptBentConnector4 : 			return L"bentConnector4";
+        //case msosptBentConnector5 : 			return L"bentConnector5";
+        //case msosptCurvedConnector2 : 		return L"curvedConnector2";
+        //case msosptCurvedConnector3 : 		return L"curvedConnector3";
+        //case msosptCurvedConnector4 : 		return L"curvedConnector4";
+        //case msosptCurvedConnector5 : 		return L"curvedConnector5";
+        //case msosptCallout1 : 				return L"callout1";
+        //case msosptCallout2 : 				return L"callout2";
+        //case msosptCallout3 : 				return L"callout3";
+        //case msosptAccentCallout1 : 			return L"accentCallout1";
+        //case msosptAccentCallout2 : 			return L"accentCallout2";
+        //case msosptAccentCallout3 : 			return L"accentCallout3";
+        //case msosptBorderCallout1 : 			return L"accentCallout1";
+        //case msosptBorderCallout2 : 			return L"accentCallout2";
+        //case msosptBorderCallout3 : 			return L"accentCallout3";
+        //case msosptAccentBorderCallout1 : 	return L"accentBorderCallout1";
+        //case msosptAccentBorderCallout2 : 	return L"accentBorderCallout2";
+        //case msosptAccentBorderCallout3 : 	return L"accentBorderCallout3";
+        //case msosptRibbon : 					return L"ribbon";
+        //case msosptRibbon2 : 					return L"ribbon2";
+        //case msosptChevron : 					return L"chevron";
+        //case msosptPentagon : 				return L"pentagon";
+        //case msosptNoSmoking : 				return L"noSmoking";
+        //case msosptSeal8 : 					return L"star8";
+        //case msosptSeal16 : 					return L"star16";
+        //case msosptSeal32 : 					return L"star32";
+        //case msosptWedgeRectCallout : 		return L"wedgeRectCallout";
+        //case msosptWedgeRRectCallout : 		return L"wedgeRoundRectCallout";
+        //case msosptWedgeEllipseCallout : 		return L"wedgeEllipseCallout";
+        //case msosptWave : 					return L"wave";
+        //case msosptFoldedCorner : 			return L"foldedCorner";
+        //case msosptLeftArrow : 				return L"leftArrow";
+        //case msosptDownArrow : 				return L"downArrow";
+        //case msosptUpArrow : 					return L"upArrow";
+        //case msosptLeftRightArrow : 			return L"leftRightArrow";
+        //case msosptUpDownArrow : 				return L"upDownArrow";
+        //case msosptIrregularSeal1 : 			return L"irregularSeal1";
+        //case msosptIrregularSeal2 : 			return L"irregularSeal2";
+        //case msosptLightningBolt : 			return L"lightningBolt";
+        //case msosptHeart : 					return L"heart";
+        ////case msosptPictureFrame : 			return 3000;//L"shapetypeFrame";   L"shapetypeRect";//
+        //case msosptQuadArrow : 				return L"quadArrow";
+        //case msosptLeftArrowCallout : 		return L"leftArrowCallout";
+        //case msosptRightArrowCallout : 		return L"rightArrowCallout";
+        //case msosptUpArrowCallout : 			return L"upArrowCallout";
+        //case msosptDownArrowCallout : 		return L"downArrowCallout";
+        //case msosptLeftRightArrowCallout : 	return L"leftRightArrowCallout";
+        //case msosptUpDownArrowCallout : 		return L"upDownArrowCallout";
+        //case msosptQuadArrowCallout : 		return L"quadArrowCallout";
+        //case msosptBevel : 					return L"bevel";
+        //case msosptLeftBracket : 				return L"leftBracket";
+        //case msosptRightBracket : 			return L"rightBracket";
+        //case msosptLeftBrace : 				return L"leftBrace";
+        //case msosptRightBrace : 				return L"rightBrace";
+        //case msosptLeftUpArrow : 				return L"leftUpArrow";
+        //case msosptBentUpArrow : 				return L"bentUpArrow";
+        //case msosptBentArrow : 				return L"bentArrow";
+        //case msosptSeal24 : 					return L"star24";
+        //case msosptStripedRightArrow : 		return L"stripedRightArrow";
+        //case msosptNotchedRightArrow : 		return L"notchedRightArrow";
+        //case msosptBlockArc : 				return L"blockArc";
+        //case msosptSmileyFace : 				return L"smileyFace";
+        //case msosptVerticalScroll : 			return L"verticalScroll";
+        //case msosptHorizontalScroll : 		return L"horizontalScroll";
+        //case msosptCircularArrow : 			return L"circularArrow";
+        //case msosptNotchedCircularArrow :		return L"flowChartDelay";		//return L"notchedCircularArrow";
+        //case msosptUturnArrow : 				return L"uturnArrow";
+        //case msosptCurvedRightArrow : 		return L"curvedRightArrow";
+        //case msosptCurvedLeftArrow : 			return L"curvedLeftArrow";
+        //case msosptCurvedUpArrow : 			return L"curvedUpArrow";
+        //case msosptCurvedDownArrow : 			return L"curvedDownArrow";
+        //case msosptCloudCallout : 			return L"cloudCallout";
+        //case msosptEllipseRibbon : 			return L"ellipseRibbon";
+        //case msosptEllipseRibbon2 : 			return L"ellipseRibbon2";
+        //case msosptFlowChartProcess : 		return L"flowChartProcess";
+        //case msosptFlowChartDecision : 		return L"flowChartDecision";
+        //case msosptFlowChartInputOutput : 	return L"flowChartInputOutput";
+        //case msosptFlowChartPredefinedProcess:return L"flowChartPredefinedProcess";
+        //case msosptFlowChartInternalStorage :	return L"flowChartInternalStorage";
+        //case msosptFlowChartDocument : 		return L"flowChartDocument";
+        //case msosptFlowChartMultidocument :	return L"flowChartMultidocument";
+        //case msosptFlowChartTerminator : 		return L"flowChartTerminator";
+        //case msosptFlowChartPreparation : 	return L"flowChartPreparation";
+        //case msosptFlowChartManualInput : 	return L"flowChartManualInput";
+        //case msosptFlowChartManualOperation :	return L"flowChartManualOperation";
+        //case msosptFlowChartConnector : 		return L"flowChartConnector";
+        //case msosptFlowChartPunchedCard : 	return L"flowChartPunchedCard";
+        //case msosptFlowChartPunchedTape : 	return L"flowChartPunchedTape";
+        //case msosptFlowChartSummingJunction :	return L"flowChartSummingJunction";
+        //case msosptFlowChartOr : 				return L"flowChartOr";
+        //case msosptFlowChartCollate : 		return L"flowChartCollate";
+        //case msosptFlowChartSort : 			return L"flowChartSort";
+        //case msosptFlowChartExtract : 		return L"flowChartExtract";
+        //case msosptFlowChartMerge : 			return L"flowChartMerge";
+        //case msosptFlowChartOfflineStorage : 	return L"flowChartOfflineStorage";
+        //case msosptFlowChartOnlineStorage : 	return L"flowChartOnlineStorage";
+        //case msosptFlowChartMagneticTape :	return L"flowChartMagneticTape";
+        //case msosptFlowChartMagneticDisk :	return L"flowChartMagneticDisk";
+        //case msosptFlowChartMagneticDrum :	return L"flowChartMagneticDrum";
+        //case msosptFlowChartDisplay : 		return L"flowChartDisplay";
+        //case msosptFlowChartDelay : 			return L"flowChartDelay";
+        //case msosptFlowChartAlternateProcess :return L"flowChartAlternateProcess";
+        //case msosptFlowChartOffpageConnector :return L"flowChartOffpageConnector";
+        //case msosptCallout90 : 				return L"callout1";
+        //case msosptAccentCallout90 : 			return L"accentCallout1";
+        //case msosptBorderCallout90 : 			return L"borderCallout1";
+        //case msosptAccentBorderCallout90 : 	return L"accentBorderCallout1";
+        //case msosptLeftRightUpArrow : 		return L"leftRightUpArrow";
+        //case msosptSun : 						return L"sun";
+        //case msosptMoon : 					return L"moon";
+        //case msosptBracketPair : 				return L"bracketPair";
+        //case msosptBracePair : 				return L"bracePair";
+        //case msosptSeal4 : 					return L"star4";
+        //case msosptDoubleWave : 				return L"doubleWave";
+        //case msosptActionButtonBlank : 		return L"actionButtonBlank";
+        //case msosptActionButtonHome : 		return L"actionButtonHome";
+        //case msosptActionButtonHelp : 		return L"actionButtonHelp";
+        //case msosptActionButtonInformation :	return L"actionButtonInformation";
+        //case msosptActionButtonForwardNext :	return L"actionButtonForwardNext";
+        //case msosptActionButtonBackPrevious :	return L"actionButtonBackPrevious";
+        //case msosptActionButtonEnd : 			return L"actionButtonEnd";
+        //case msosptActionButtonBeginning : 	return L"actionButtonBeginning";
+        //case msosptActionButtonReturn : 		return L"actionButtonReturn";
+        //case msosptActionButtonDocument : 	return L"actionButtonDocument";
+        //case msosptActionButtonSound : 		return L"actionButtonSound";
+        //case msosptActionButtonMovie : 		return L"actionButtonMovie";
 		}
         return L"";
 	}

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.cpp

@@ -618,7 +618,7 @@ void xlsx_drawing_context::serialize_shape(_drawing_state_ptr & drawing_state)
 
 	std::wstring prstTxWarp;
 	std::wstring prstGeom	= Spt2ShapeType(drawing_state->shape_id);
-	std::wstring customGeom	= convert_custom_shape(drawing_state);
+	std::wstring customGeom;
 
 	if (prstGeom.empty())
 	{
@@ -629,10 +629,9 @@ void xlsx_drawing_context::serialize_shape(_drawing_state_ptr & drawing_state)
 			drawing_state->bTextBox = true;
 			prstGeom = L"rect";
 		}
-		else if (drawing_state->path.empty())
+		else
 		{
-			//error !!!
-			prstGeom = L"rect";
+			customGeom	= convert_custom_shape(drawing_state);
 		}
 	}
 	else
@@ -694,40 +693,7 @@ void xlsx_drawing_context::serialize_shape(_drawing_state_ptr & drawing_state)
 				}
 				else
 				{
-					if (customGeom.empty())
-					{
-						CP_XML_NODE(L"a:custGeom")
-						{        
-							CP_XML_NODE(L"a:avLst");
-							//oox_serialize_aLst(CP_XML_STREAM(),val.additional);
-							CP_XML_NODE(L"a:ahLst");
-							//CP_XML_NODE(L"a:gdLst");
-							CP_XML_NODE(L"a:rect")
-							{
-								CP_XML_ATTR(L"b",L"b");
-								CP_XML_ATTR(L"l",0);
-								CP_XML_ATTR(L"r",L"r");
-								CP_XML_ATTR(L"t",0);
-							}
-							CP_XML_NODE(L"a:pathLst")
-							{ 	
-								int w = drawing_state->path_rect.right - drawing_state->path_rect.left;
-								int h = drawing_state->path_rect.bottom- drawing_state->path_rect.top;
-
-								if (w > 0 && h > 0)
-								{
-									CP_XML_NODE(L"a:path")
-									{
-										CP_XML_ATTR(L"w", w);
-										CP_XML_ATTR(L"h", h);
-										
-										CP_XML_STREAM() << drawing_state->path;
-									}
-								}
-							}
-						}
-					}
-					else
+					CP_XML_NODE(L"a:custGeom")
 					{
 						CP_XML_STREAM() << customGeom;
 					}
@@ -749,20 +715,46 @@ std::wstring xlsx_drawing_context::convert_custom_shape(_drawing_state_ptr & dra
 	CCustomShape * shape = CCustomShape::CreateByType(drawing_state->shape_id);
 	if (shape == NULL) return L"";
 
-	//shape->m_oCustomVML.LoadSegments(pProperty);
-	//shape->m_oCustomVML.LoadVertices(pProperty);
-	//shape->m_oCustomVML.LoadGuides(pProperty);
-	//shape->m_oCustomVML.LoadAHs(pProperty);
+	shape->m_oCustomVML.m_bIsVerticesPresent = drawing_state->custom_verticles.empty() ? false : true;
+	for (int i = 0 ; i < drawing_state->custom_verticles.size(); i++)
+	{
+		 Aggplus::POINT p;
+		
+		 p.x = drawing_state->custom_verticles[i].x;
+		 p.y = drawing_state->custom_verticles[i].y;
+		
+		 shape->m_oCustomVML.m_arVertices.push_back(p);
+	}
+	for (int i = 0 ; i < drawing_state->custom_guides.size(); i++)
+	{//todooo / !!
+		NSCustomVML::CGuide guid;
+		
+		guid.m_eType		= drawing_state->custom_guides[i].m_eType;
+		guid.m_param_type1	= drawing_state->custom_guides[i].m_param_type1;
+		guid.m_param_type2	= drawing_state->custom_guides[i].m_param_type2;
+		guid.m_param_type3	= drawing_state->custom_guides[i].m_param_type3;
+		guid.m_param_value1 = drawing_state->custom_guides[i].m_param_value1;
+		guid.m_param_value2 = drawing_state->custom_guides[i].m_param_value2;
+		guid.m_param_value3 = drawing_state->custom_guides[i].m_param_value3;
+		
+		shape->m_oCustomVML.addGuide(guid);
+	}	
+	for (int i = 0 ; i < drawing_state->custom_segments.size(); i++)
+	{
+		shape->m_oCustomVML.addSegment(drawing_state->custom_segments[i].m_eRuler , drawing_state->custom_segments[i].m_nCount);
+	}	
 
-	//LONG lIndexAdj = pProperty->m_ePID - NSOfficeDrawing::adjustValue;
-	//if (lIndexAdj >= 0 && lIndexAdj < pShape->m_arAdjustments.size())
-	//{
-	//	shape->m_oCustomVML.LoadAdjusts(lIndexAdj, (LONG)pProperty->m_lValue);
-	//}
-	//else
-	//{
-	//	shape->m_oCustomVML.LoadAdjusts(lIndexAdj, (LONG)pProperty->m_lValue);
-	//}
+	for (int i = 0; i < drawing_state->custom_adjustValues.size(); i++)
+	{
+		if (drawing_state->custom_adjustValues[i])
+		{
+			shape->m_oCustomVML.addAdjust(i, *drawing_state->custom_adjustValues[i]);
+		}
+	}
+
+	shape->m_oCustomVML.SetPath((NSGuidesVML::RulesType)drawing_state->custom_path);
+	shape->m_oCustomVML.ToCustomShape(shape, shape->m_oManager);
+	shape->ReCalculate();
 //-------------------------------------------------------------------------------------
 
 	NSGuidesVML::CFormParam pParamCoef;
@@ -772,6 +764,16 @@ std::wstring xlsx_drawing_context::convert_custom_shape(_drawing_state_ptr & dra
 	
 	NSGuidesVML::CFormulaConverter pFormulaConverter;
 
+	if (drawing_state->custom_rect.cx > 0 && drawing_state->custom_rect.cy > 0)
+	{
+		pFormulaConverter.m_lWidth	= drawing_state->custom_rect.cx;
+		pFormulaConverter.m_lHeight = drawing_state->custom_rect.cy;
+	}
+	else
+	{
+		pFormulaConverter.m_lWidth	= 21600;
+		pFormulaConverter.m_lHeight = 21600;
+	}
 	//coeff
 	pFormulaConverter.ConvertCoef(pParamCoef);
 
@@ -1026,13 +1028,27 @@ void xlsx_drawing_context::serialize_xfrm(std::wostream & stream, _drawing_state
 			
 			CP_XML_NODE(L"a:off")
 			{
-				CP_XML_ATTR(L"x", drawing_state->x);
-				CP_XML_ATTR(L"y", drawing_state->y);
+				CP_XML_ATTR(L"x", drawing_state->child_anchor.x);
+				CP_XML_ATTR(L"y", drawing_state->child_anchor.y);
 			}
 			CP_XML_NODE(L"a:ext")
 			{
-				CP_XML_ATTR(L"cx", drawing_state->cx);
-				CP_XML_ATTR(L"cy", drawing_state->cy);
+				CP_XML_ATTR(L"cx", drawing_state->child_anchor.cx);
+				CP_XML_ATTR(L"cy", drawing_state->child_anchor.cy);
+			}
+
+			if (drawing_state->type == external_items::typeGroup)
+			{
+				CP_XML_NODE(L"a:chOff")
+				{
+					CP_XML_ATTR(L"x", drawing_state->group_anchor.x);
+					CP_XML_ATTR(L"y", drawing_state->group_anchor.y);
+				}
+				CP_XML_NODE(L"a:chExt")
+				{
+					CP_XML_ATTR(L"cx", drawing_state->group_anchor.cx);
+					CP_XML_ATTR(L"cy", drawing_state->group_anchor.cy);
+				}				
 			}
 		}
 	}
@@ -1123,6 +1139,11 @@ void xlsx_drawing_context::serialize_text(std::wostream & stream, _drawing_state
 				}
 				else
 				{
+					CP_XML_ATTR(L"lIns", drawing_state->text.margins.left);	
+					CP_XML_ATTR(L"tIns", drawing_state->text.margins.top);	
+					CP_XML_ATTR(L"rIns", drawing_state->text.margins.right);
+					CP_XML_ATTR(L"bIns", drawing_state->text.margins.bottom);
+
 					switch (drawing_state->text.vert_align)
 					{
 						case 1: CP_XML_ATTR(L"anchor", L"t");	break;
@@ -1137,6 +1158,8 @@ void xlsx_drawing_context::serialize_text(std::wostream & stream, _drawing_state
 						case 5: CP_XML_ATTR(L"vert", L"wordArtVert");	break;
 					}
 				}
+				//text margins
+
 			}
 			CP_XML_NODE(L"a:lstStyle");		
 			
@@ -1316,13 +1339,19 @@ void xlsx_drawing_context::set_child_anchor(int x, int y, int cx, int cy)
 {
 	if (current_drawing_states == NULL) return;	
 
-	current_drawing_states->back()->x	= x;
-	current_drawing_states->back()->y	= y;
-	current_drawing_states->back()->cx	= cx;
-	current_drawing_states->back()->cy	= cy;	
-	
-	//current_drawing_states->back()->anchor		= str;
-	//current_drawing_states->back()->type_anchor = 4;
+	current_drawing_states->back()->child_anchor.x	= x;
+	current_drawing_states->back()->child_anchor.y	= y;
+	current_drawing_states->back()->child_anchor.cx	= cx;
+	current_drawing_states->back()->child_anchor.cy	= cy;	
+}
+void xlsx_drawing_context::set_group_anchor(int x, int y, int cx, int cy)
+{
+	if (current_drawing_states == NULL) return;	
+
+	current_drawing_states->back()->group_anchor.x	= x;
+	current_drawing_states->back()->group_anchor.y	= y;
+	current_drawing_states->back()->group_anchor.cx	= cx;
+	current_drawing_states->back()->group_anchor.cy	= cy;	
 }
 void xlsx_drawing_context::set_absolute_anchor(double width, double height)
 {
@@ -1577,13 +1606,6 @@ void xlsx_drawing_context::set_hyperlink(const std::wstring & link, const std::w
 	rels_->add( !is_external, sId , link_correct, external_items::typeHyperlink);
 }
 
-void xlsx_drawing_context::set_path (const std::wstring & path)
-{
-	if (current_drawing_states == NULL) return;	
-
-	current_drawing_states->back()->path = path;
-}
-
 void xlsx_drawing_context::set_wordart_text(const std::wstring & text)
 {
 	if (current_drawing_states == NULL) return;	
@@ -1620,6 +1642,12 @@ void xlsx_drawing_context::set_text_vertical (int val)
 
 	current_drawing_states->back()->text.vertical = val;
 }
+void xlsx_drawing_context::set_text_margin(RECT & val)
+{
+	if (current_drawing_states == NULL) return;	
+
+	current_drawing_states->back()->text.margins = val;
+}
 void xlsx_drawing_context::set_wordart_bold	(bool val)
 {
 	if (current_drawing_states == NULL) return;	
@@ -1669,11 +1697,11 @@ void xlsx_drawing_context::set_text_wrap (int val)
 
 	current_drawing_states->back()->text.wrap = val;
 }
-void xlsx_drawing_context::set_path_rect(_rect & rect)
+void xlsx_drawing_context::set_custom_rect(_rect & rect)
 {
 	if (current_drawing_states == NULL) return;	
 
-	current_drawing_states->back()->path_rect = rect;
+	current_drawing_states->back()->custom_rect = rect;
 }
 void xlsx_drawing_context::set_properties(const std::wstring & str)
 {
@@ -1681,6 +1709,36 @@ void xlsx_drawing_context::set_properties(const std::wstring & str)
 	
 	current_drawing_states->back()->shape = str;
 }
+void xlsx_drawing_context::set_custom_verticles (std::vector<ODRAW::MSOPOINT> & points)
+{
+	if (current_drawing_states == NULL) return;
+
+	current_drawing_states->back()->custom_verticles = points;
+}
+void xlsx_drawing_context::set_custom_guides (std::vector<ODRAW::MSOSG> & guides)
+{
+	if (current_drawing_states == NULL) return;
+	
+	current_drawing_states->back()->custom_guides = guides;
+}
+void xlsx_drawing_context::set_custom_segments (std::vector<ODRAW::MSOPATHINFO> & segments)
+{
+	if (current_drawing_states == NULL) return;
+	
+	current_drawing_states->back()->custom_segments = segments;
+}
+void xlsx_drawing_context::set_custom_adjustValues(std::vector<_CP_OPT(int)> & values)
+{
+	if (current_drawing_states == NULL) return;
+
+	current_drawing_states->back()->custom_adjustValues = values;
+}
+void xlsx_drawing_context::set_custom_path (int type_path)
+{
+	if (current_drawing_states == NULL) return;
+
+	current_drawing_states->back()->custom_path = type_path;
+}
 bool xlsx_drawing_context::empty()
 {
 	return drawing_states.empty();

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);