#pragma once
#include "McDbEntity.h"
#include "Mdesk.h"
class McDbHatchImp;
class McDbDwgFiler;
// -------------------------------------------------------------------------
// Summary:
// 		图案填充类，实现实心颜色填充和各种图案填充效果
// Remarks:
// 		例如:mxdrawx.ocx中的图案填充代码
// 		<code>
// 			// .h
// 			class CDrawHatch
// 			{
// 			public:
// 				// 图案填充数据
// 				struct stuFillLine
// 				{
// 					mxreal dAngle;
// 					mxreal dXOrigin;
// 					mxreal dYOrigin;
// 					mxreal dXDelta;
// 					mxreal dYDelta;
// 					McGeDoubleArray aryDash;
// 					stuFillLine()
// 					{
// 						dAngle   = 0;
// 						dXOrigin = 0;
// 						dYOrigin = 0;
// 						dXDelta  = 0;
// 						dYDelta  = 1;
// 					}
// 				};
// 				typedef std::vector<stuFillLine> VecFillLineData;
// 
// 				// 填充的闭合区端点数据
// 				struct stuVertex
// 				{
// 					McGePoint2d pt;
// 					mxreal dStartWidth;
// 					mxreal dEndWidth;
// 					mxreal dBulge;
// 
// 					stuVertex()
// 					{
// 						dBulge		= 0.0;
// 						dStartWidth = -1.0;
// 						dEndWidth   = -1.0;
// 					}
// 				};
// 
// 				CDrawHatch(void);
// 				virtual ~CDrawHatch(void);
// 
// 				// 增加一个填充定义
// 				bool AddPatternDefinition(const MxString& sName,
// 					const MxString& sDefinitionData);
// 
// 
// 				McDbHatch*  MakeHatch(MxString sHatchName,
// 					mxreal dScale,
// 					std::vector<stuVertex>& vecData,
// 					std::vector<std::pair<bool,std::vector<stuVertex>* > >& vecExcelude
// 					);
// 
// 			private:
// 				std::map<MxString,VecFillLineData*> m_mapFillData;
// 			};
// 
// 			// .cpp
// 			#include "MxHead.h"
// 			#include "DrawHatch.h"
// 
// 			CDrawHatch::CDrawHatch(void)
// 			{
// 			}
// 
// 			CDrawHatch::~CDrawHatch(void)
// 			{
// 				std::map<MxString,VecFillLineData*>::iterator iter = m_mapFillData.begin();
// 				for(;iter != m_mapFillData.end();++iter)
// 				{
// 					delete iter->second;
// 				}
// 				m_mapFillData.clear();
// 			}
// 
// 
// 			McDbHatch*  CDrawHatch::MakeHatch(MxString sHatchName,
// 											  mxreal dScale,
// 											  std::vector<stuVertex>& vecData,
// 											  std::vector<std::pair<bool,std::vector<stuVertex>* > >& vecExcelude
// 												 )
// 			{
// 				if(vecData.size() < 3
// 					&& vecExcelude.empty()
// 					)
// 				{
// 					return NULL;
// 				}
// 
// 				if(dScale < 0.00001)
// 					dScale = 1.0;
// 
// 				VecFillLineData* pFillLineData = NULL;
// 				std::map<MxString,VecFillLineData*>::iterator iter 
// 					=  m_mapFillData.find(sHatchName);
// 
// 				if(sHatchName.CompareNoCase(_MXT("SOLID")) != 0)
// 				{
// 					if(iter != m_mapFillData.end())
// 					{
// 						pFillLineData = iter->second;
// 					}
// 					else
// 					{
// 						sHatchName = _MXT("SOLID");
// 					}
// 				}
// 
// 
// 				McDbHatch* pH = new McDbHatch;
// 				pH->setHatchStyle(McDbHatch::kNormal);
// 				pH->setHatchObjectType(McDbHatch::kHatchObject);
// 				pH->setPatternScale(1.0);
// 
// 				pH->setPattern(McDbHatch::kPreDefined,sHatchName);
// 
// 				// 设置填充对象的Loop数据；
// 				if(vecData.size() > 2)
// 				{
// 					McGePoint2dArray vecVertices;
// 					McGeDoubleArray  vecBulges;
// 
// 					for(unsigned int i = 0; i < vecData.size();i++)
// 					{
// 						stuVertex& tmp = vecData[i];
// 						vecVertices.append(tmp.pt);
// 						vecBulges.append(tmp.dBulge);
// 					}
// 					pH->appendLoop(McDbHatch::kPolyline,vecVertices,vecBulges);
// 				}
// 
// 
// 				for(unsigned int i = 0; i < vecExcelude.size();i++)
// 				{
// 					std::vector<stuVertex>* pVecData = vecExcelude[i].second;
// 					int iloopType = McDbHatch::kPolyline;
// 					if( vecExcelude[i].first)
// 					{
// 						iloopType = iloopType | McDbHatch::kOutermost;
// 					}
// 
// 					McGePoint2dArray vecVertices;
// 					McGeDoubleArray  vecBulges;
// 
// 					for(unsigned int j = 0; j < pVecData->size();j++)
// 					{
// 						stuVertex& tmp = (*pVecData)[j];
// 						vecVertices.append(tmp.pt);
// 						vecBulges.append(tmp.dBulge);
// 					}
// 					pH->appendLoop(iloopType,vecVertices,vecBulges);
// 				}
// 
// 				// 设置填充线条数据。
// 				if(pFillLineData != NULL)
// 				{
// 					// 
// 					for(unsigned int i = 0; i < pFillLineData->size();i++)
// 					{
// 						stuFillLine& fillLine = (*pFillLineData)[i];
// 
// 						McGeDoubleArray aryDash;
// 						for(int j = 0; j < fillLine.aryDash.length();j++)
// 						{
// 							aryDash.append(fillLine.aryDash[j] * dScale);
// 						}
// 
// 						// illLine.dXDelta,fillLine.dYDelta的值是相对于，坐标系旋转了fillLine.dAngle后
// 						// 的坐标系的值。这里需要把它变成 没有旋转的坐标系的值。
// 						McGePoint2d ptTmp;
// 						ptTmp.x = fillLine.dXDelta;
// 						ptTmp.y = fillLine.dYDelta;
// 
// 						McGeMatrix2d tmpMat = McGeMatrix2d::rotation(fillLine.dAngle);
// 						ptTmp.transformBy(tmpMat);
// 
// 						ptTmp.x *= dScale;
// 						ptTmp.y *= dScale;
// 
// 						pH->addPatternDefinition(fillLine.dAngle,
// 							fillLine.dXOrigin * dScale,
// 							fillLine.dYOrigin * dScale,
// 							ptTmp.x,ptTmp.y ,
// 							aryDash);
// 					}
// 				}
// 
// 				return pH;
// 			}
// 
// 			bool CDrawHatch::AddPatternDefinition(const MxString& sName,
// 												  const MxString& sDefinitionData)
// 			{
// 				if(sName.IsEmpty() )
// 					return false;
// 
// 				std::map<MxString,VecFillLineData*>::iterator iter 
// 					= m_mapFillData.find(sName);
// 				if(iter != m_mapFillData.end())
// 				{
// 					// 已经有这个图案定义.
// 					return false;
// 				}
// 
// 				if(sDefinitionData.IsEmpty() )
// 					return false;
// 
// 				MxStrList lst(sDefinitionData);
// 				VecFillLineData* pFillLineData = new VecFillLineData;
// 
// 				int iCount = lst.GetCount();
// 				for(int i = 0; i < iCount;i++)
// 				{
// 					MxString sItem = lst.GetStrAt(i);
// 					if(sItem.IsEmpty() )
// 						continue;
// 
// 					stuFillLine tmpFillLine;
// 
// 					MxStrList lstItem(sItem);
// 
// 					int iItemCount = lstItem.GetCount();
// 					int j = 0;
// 					for(; j < iItemCount;j++)
// 					{
// 						mxreal dV = lstItem.GetDoubleAt(j);
// 
// 						if(j == 0)
// 						{
// 							// angle,把度变成弧度。
// 							tmpFillLine.dAngle = dV * 3.14159265 / 180.0;
// 						}
// 						else if(j == 1)
// 						{
// 							// x-origin
// 							tmpFillLine.dXOrigin = dV;
// 						}
// 						else if(j == 2)
// 						{
// 							// y-origin
// 							tmpFillLine.dYOrigin  = dV;
// 						}
// 						else if(j == 3)
// 						{
// 							// delta-x
// 							tmpFillLine.dXDelta = dV;
// 						}
// 						else if(j == 4)
// 						{
// 							// delta-y
// 							tmpFillLine.dYDelta  = dV;
// 						}
// 						else
// 						{
// 							tmpFillLine.aryDash.append(dV);
// 						}
// 					}
// 
// 					if(j < 5)
// 					{
// 						// 数据不够。
// 						continue;
// 					}
// 					pFillLineData->push_back(tmpFillLine);
// 				}
// 
// 				if(pFillLineData->empty() )
// 				{
// 					delete pFillLineData;
// 					pFillLineData = NULL;
// 				}
// 				else
// 				{
// 					m_mapFillData.insert(std::make_pair(sName,pFillLineData));
// 				}
// 				return true;
// 			}
// 
// 			// 使用
// 			#include "DrawHatch.h"
// 
// 			void CTestCommands::DrawHatch()
// 			{
// 
// 				{
// 					// SOLID
// 					CDrawHatch drawHatch;
// 
// 					std::vector<CDrawHatch::stuVertex> vecData;
// 					std::vector<std::pair<bool,std::vector<CDrawHatch::stuVertex>* > > vecExcelude;
// 
// 					CDrawHatch::stuVertex tmp;
// 					tmp.pt = McGePoint2d(0,0);
// 					vecData.push_back(tmp);
// 
// 					tmp.pt = McGePoint2d(100,100);
// 					vecData.push_back(tmp);
// 
// 					tmp.pt = McGePoint2d(100,0);
// 					vecData.push_back(tmp);
// 
// 					tmp.pt = McGePoint2d(0,0);
// 					vecData.push_back(tmp);
// 
// 
// 					McDbHatch* pHatch = drawHatch.MakeHatch(_MXT("SOLID"),1.0,vecData,vecExcelude);
// 					MxDraw::SetEnityDrawOrder(pHatch,2);
// 
// 					if(pHatch != NULL)
// 					{
// 						AddToModelSpace(pHatch,acdbCurDwg());
// 					}
// 
// 				}
// 				{
// 					// 图案填充
// 					CDrawHatch drawHatch;
// 					std::vector<CDrawHatch::stuVertex> vecData;
// 					std::vector<std::pair<bool,std::vector<CDrawHatch::stuVertex>* > > vecExcelude;
// 
// 					CDrawHatch::stuVertex tmp;
// 					tmp.pt = McGePoint2d(0,0);
// 					vecData.push_back(tmp);
// 
// 					tmp.pt = McGePoint2d(100,200);
// 					vecData.push_back(tmp);
// 
// 					tmp.pt = McGePoint2d(200,0);
// 					vecData.push_back(tmp);
// 
// 					tmp.pt = McGePoint2d(0,0);
// 					vecData.push_back(tmp);
// 
// 					//绘制一个有图案的填充
// 					//angle, x-origin,y-origin, delta-x,delta-y,dash-1,dash-2, …
// 					//45 = angle 是图案线角度.
// 					//0 = x-origin 是第一个填充线经过的点位置X坐标
// 					//0 = y-origin 是第一个填充线经过的点位置Y坐标
// 					//0 = delta-x   是下一个填充线相对前一个线的X方向偏移
// 					//0.125 = delta-y   是下一个填充线相对前一个线的Y方向偏移
// 					drawHatch.AddPatternDefinition(_MXT("MyPattern"),_MXT("((45, 0,0, 0,0.125))"));
// 					//drawHatch.AddPatternDefinition(_MXT("MyPattern"),_MXT("((0,0,0,0,8)(90,0,0,8,8,8,-8))"));
// 
// 					McDbHatch* pHatch = drawHatch.MakeHatch(_MXT("MyPattern"),4.0,vecData,vecExcelude);
// 
// 					if(pHatch != NULL)
// 					{
// 
// 						pHatch->setColorIndex(MrxDbgUtils::kRed);
// 						MxDraw::SetEnityDrawOrder(pHatch,1);
// 
// 						AddToModelSpace(pHatch,acdbCurDwg());
// 					}
// 				}
// 				return;
// 			}
// 		</code>
// Remarks:	
// 		例如: 演示图案填充代码2.
// 		<code>
// 			struct stuFillLine
// 			{
// 				mxreal dAngle;
// 				mxreal dXOrigin;
// 				mxreal dYOrigin;
// 				mxreal dXDelta;
// 				mxreal dYDelta;
// 				McGeDoubleArray aryDash;
// 				stuFillLine()
// 				{
// 					dAngle   = 0;
// 					dXOrigin = 0;
// 					dYOrigin = 0;
// 					dXDelta  = 0;
// 					dYDelta  = 1;
// 				}
// 			};
// 
// 
// 			bool GetPatternDefinition(
// 									  IN  const MxString& sDefinitionData,
// 									  OUT std::vector<stuFillLine>& vecFillData
// 									  )
// 			{
// 
// 				MxStrList lst(sDefinitionData);
// 
// 				int iCount = lst.GetCount();
// 				for(int i = 0; i < iCount;i++)
// 				{
// 					MxString sItem = lst.GetStrAt(i);
// 					if(sItem.IsEmpty() )
// 						continue;
// 
// 					stuFillLine tmpFillLine;
// 
// 					MxStrList lstItem(sItem);
// 
// 					int iItemCount = lstItem.GetCount();
// 					int j = 0;
// 					for(; j < iItemCount;j++)
// 					{
// 						mxreal dV = lstItem.GetDoubleAt(j);
// 
// 						if(j == 0)
// 						{
// 							// angle,把度变成弧度。
// 							tmpFillLine.dAngle = dV * MxPI / 180.0;
// 						}
// 						else if(j == 1)
// 						{
// 							// x-origin
// 							tmpFillLine.dXOrigin = dV;
// 						}
// 						else if(j == 2)
// 						{
// 							// y-origin
// 							tmpFillLine.dYOrigin  = dV;
// 						}
// 						else if(j == 3)
// 						{
// 							// delta-x
// 							tmpFillLine.dXDelta = dV;
// 						}
// 						else if(j == 4)
// 						{
// 							// delta-y
// 							tmpFillLine.dYDelta  = dV;
// 						}
// 						else
// 						{
// 							tmpFillLine.aryDash.append(dV);
// 						}
// 					}
// 
// 					if(j < 5)
// 					{
// 						// 数据不够。
// 						continue;
// 					}
// 					vecFillData.push_back(tmpFillLine);
// 				}
// 
// 				if(vecFillData.empty() )
// 				{
// 					return false;
// 				}
// 				else
// 				{
// 					return true;
// 				}
// 			}
// 
// 			void DrawHatch()
// 			{
// 
// 				MxString sPatternDefine = _MXT("((0, 0,0, 0,.275, .2,-.075) (90, 0,0, 0,.275, .2,-.075))");
// 
// 				std::vector<stuFillLine> vecFillData;
// 
// 				if(!GetPatternDefinition(
// 					sPatternDefine,
// 					vecFillData
// 					) )
// 				{
// 					return;
// 				}
// 
// 				mxreal dPatternScale = 10.0;
// 
// 				AcDbHatch* pHatch = new AcDbHatch();
// 
// 				AcGeVector3d normal(0.0, 0.0, 1.0);
// 				pHatch->setNormal(normal);
// 				pHatch->setElevation(0.0);
// 
// 				pHatch->setPattern(AcDbHatch::kPreDefined, _MXT("ANGLE"));
// 
// 				pHatch->setHatchStyle(AcDbHatch::kNormal);
// 
// 				pHatch->setPatternScale(1);
// 
// 				AcGePoint2dArray vertexPts;
// 				AcGeDoubleArray vertexBulges;
// 				vertexPts.setPhysicalLength(0).setLogicalLength(5);
// 				vertexPts[0].set(20.0, 20.0);
// 				vertexPts[1].set(80.0, 20.0);
// 				vertexPts[2].set(80.0, 80.0);
// 				vertexPts[3].set(20.0, 80.0);
// 				vertexPts[4].set(20.0, 20.0);
// 				vertexBulges.setPhysicalLength(0).setLogicalLength(5);
// 				for (int i = 0; i < 5; i++)
// 					vertexBulges[i] = 0.0;	
// 
// 				pHatch->appendLoop(AcDbHatch::kExternal, vertexPts, vertexBulges); 
// 
// 				AcDbPolyline* pLine = new AcDbPolyline();
// 				for (int i = 0; i < 5; i++)
// 				{
// 					pLine->addVertexAt(i, vertexPts[i]);
// 				}
// 
// 				for(unsigned int i = 0; i < vecFillData.size();i++)
// 				{
// 					stuFillLine& fillLine = vecFillData[i];
// 
// 					McGeDoubleArray aryDash;
// 					for(int j = 0; j < fillLine.aryDash.length();j++)
// 					{
// 						aryDash.append(fillLine.aryDash[j] * dPatternScale);
// 					}
// 
// 					// illLine.dXDelta,fillLine.dYDelta的值是相对于，坐标系旋转了fillLine.dAngle后
// 					// 的坐标系的值。这里需要把它变成 没有旋转的坐标系的值。
// 					McGePoint2d ptTmp;
// 					ptTmp.x = fillLine.dXDelta;
// 					ptTmp.y = fillLine.dYDelta;
// 
// 					McGeMatrix2d tmpMat = McGeMatrix2d::rotation(fillLine.dAngle);
// 					ptTmp.transformBy(tmpMat);
// 
// 					ptTmp.x *= dPatternScale;
// 					ptTmp.y *= dPatternScale;
// 
// 					pHatch->addPatternDefinition(fillLine.dAngle,
// 						fillLine.dXOrigin * dPatternScale,
// 						fillLine.dYOrigin * dPatternScale,
// 						ptTmp.x,ptTmp.y ,
// 						aryDash);
// 				}
// 
// 
// 				AcDbObjectId newId;
// 
// 				MrxDbgUtils::addToCurrentSpaceAndClose(pHatch, acdbCurDwg());
// 				MrxDbgUtils::addToCurrentSpaceAndClose(pLine, acdbCurDwg());
// 
// 
// 				Mx::ZoomE();
// 			}
// 		</code>
// -------------------------------------------------------------------------
class ARXDLL McDbHatch : public McDbEntity
{ 
	// -------------------------------------------------------------------------
	// Summary:
	// 		申明类型信息
	// -------------------------------------------------------------------------
	MCDB_DECLARE_MEMBERS(McDbHatch);
public:
	// -------------------------------------------------------------------------
	// Summary:
	// 		填充用的闭合区域的类型
	// -------------------------------------------------------------------------
	enum HatchLoopType {
		kDefault          = 0,
		kExternal         = 1,
		kPolyline         = 2,
		kDerived          = 4,
		kTextbox          = 8,
		kOutermost        = 0x10,
		kNotClosed        = 0x20,
		kSelfIntersecting = 0x40,
		kTextIsland       = 0x80
	};

	// -------------------------------------------------------------------------
	// Summary:
	// 		填充用的闭合区域中的边的曲线类型
	// -------------------------------------------------------------------------
	enum HatchEdgeType {
		kLine             = 1,
		kCirArc           = 2,
		kEllArc           = 3,
		kSpline           = 4 
	};

	// -------------------------------------------------------------------------
	// Summary:
	// 		填充图案来源类型
	// -------------------------------------------------------------------------
	enum HatchPatternType {
		kUserDefined      = 0,
		kPreDefined       = 1,
		kCustomDefined    = 2 
	};

//:Ignore

	enum HatchStyle {
		kNormal           = 0,
		kOuter            = 1,
		kIgnore           = 2 
	};

	enum HatchObjectType {
		kHatchObject      = 0,
		kGradientObject   = 1,
		kMaterialObject   = 2
	};

	enum GradientPatternType {
		kPreDefinedGradient     = 0,
		kUserDefinedGradient    = 1
	};

//:End Ignore

	// -------------------------------------------------------------------------
	// Summary:
	// 		构造函数
	// -------------------------------------------------------------------------
	McDbHatch(void);

	// -------------------------------------------------------------------------
	// Summary:
	// 		析构函数
	// -------------------------------------------------------------------------
	virtual ~McDbHatch(void);

	
	// -------------------------------------------------------------------------
	// Summary:
	// 		返回图案填充中的闭合边界个数
	// -------------------------------------------------------------------------
	int numLoops() const;

	// -------------------------------------------------------------------------
	// Summary:
	// 		返回图案填充中的闭合边界类型
	// Parameters:
	// 		loopIndex	-	闭合边界数组中的索引 
	// Returns:
	// 		如果成功返回Mcad::eOk，如果传递的数据非法则返回Mcad::eInvalidInput
	// -------------------------------------------------------------------------
	Mdesk::Int32 loopTypeAt(int loopIndex) const;

	// -------------------------------------------------------------------------
	// Summary:
	// 		返回图案填充中的闭合边界数据
	// Parameters:
	//		loopIndex		-	边界数组的索引，从0开始计数
	//		loopType     	-	返回边界的类型
	//		edgePtrs		-	返回边界中的曲线数组
	//		edgeTypes     	-	返回边界中曲线数组中的曲线类型，edgeTypes的长度与edgePtrs相等
	// Returns:
	// 		如果成功返回Mcad::eOk
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus getLoopAt(int loopIndex,
		Mdesk::Int32& loopType,
		McGeVoidPointerArray& edgePtrs,
		McGeIntArray&  edgeTypes) const;

	// -------------------------------------------------------------------------
	// Summary:
	// 		返回图案填充中的闭合边界数据
	// Parameters:
	// 		loopIndex   	-	边界数组的索引，从0开始计数
	//		loopType     	-	返回边界的类型
	//		vertices		-	返回边界中的点坐数组
	//		bulges     		-	返回边界中点数组中的圆弧凸度，vertices的长度与bulges相等
	// Returns:
	// 		如果成功返回Mcad::eOk
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus getLoopAt(int loopIndex,
		Mdesk::Int32& loopType,
		McGePoint2dArray& vertices,
		McGeDoubleArray& bulges) const;

	// -------------------------------------------------------------------------
	// Summary:
	// 		返回图案填充类型
	// -------------------------------------------------------------------------
	McDbHatch::HatchPatternType patternType() const;

	// -------------------------------------------------------------------------
	// Summary:
	// 		返回图案名称，如果图案名称是SOLID，代表是实心颜色填充
	// -------------------------------------------------------------------------
	LPCMSTR patternName() const;

	// -------------------------------------------------------------------------
	// Summary:
	// 		设置图案名称
	// Parameters:
	// 		patType	-	图案填充类型 
	// 		patName	-	图案填充的名称 
	// Returns:
	// 		如果成功返回Mcad::eOk，如果传递的数据非法则返回Mcad::eInvalidInput
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus  setPattern(McDbHatch::HatchPatternType patType,
		LPCMSTR patName);

	


	// -------------------------------------------------------------------------
	// Summary:
	// 		返回图案的填充角度
	// -------------------------------------------------------------------------
	mxreal patternAngle() const;

	// -------------------------------------------------------------------------
	// Summary:
	// 		设置图案的填充角度
	// Parameters:
	// 		angle	-	填充角度 
	// Returns:
	// 		如果成功返回Mcad::eOk，如果传递的数据非法则返回Mcad::eInvalidInput
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus setPatternAngle(mxreal angle);


	// -------------------------------------------------------------------------
	// Summary:
	// 		返回图案的缩放比例
	// -------------------------------------------------------------------------
	mxreal patternScale() const;

	// -------------------------------------------------------------------------
	// Summary:
	// 		设置图案的缩放比例
	// Parameters:
	// 		scale	-	图案的缩放比例 
	// Returns:
	// 		如果成功返回Mcad::eOk，如果传递的数据非法则返回Mcad::eInvalidInput
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus setPatternScale(mxreal scale);


	mxreal patternSpace() const;
	Mcad::ErrorStatus setPatternSpace(mxreal space);


	bool patternDouble() const;
	Mcad::ErrorStatus setPatternDouble(bool isDouble);

	//:Ignore

	double elevation() const;
	Mcad::ErrorStatus setElevation(double elevation);
	//:End Ignore


	// -------------------------------------------------------------------------
	// Summary:
	// 		返回图案定义数组的长度
	// -------------------------------------------------------------------------
	int numPatternDefinitions() const;


	// -------------------------------------------------------------------------
	// Summary:
	// 		返回图案定义数据
	// Parameters:
	// 		index 			-		图案数组中的索引，从0开始计数
	//		angle           -		图案填充线的角度
	//		baseX           -		 图案填充的起点位置X值，相对于实体坐标系
	//		baseY           -		图案填充的起点位置Y值，相对于实体坐标系
	//		offsetX			-		一个填充线在X方向的偏移，X方向是X轴逆时针旋转angle后的位置
	//		offsetY         -		一个填充线在Y方向的偏移，Y方向是Y轴逆时针旋转angle后的位置
	//		dashes          -		图案的虚线数据数组，正值代表有线，负值代表为空格
	// Returns:
	// 		返回图案定义数据
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus  getPatternDefinitionAt(int index, 
		mxreal& angle,
		mxreal& baseX,
		mxreal& baseY,
		mxreal& offsetX,
		mxreal& offsetY,
		McGeDoubleArray& dashes)
		const;

	// -------------------------------------------------------------------------
	// Summary:
	// 		添加图案定义数据
	// Parameters:
	//		angle			- 		图案填充线的角度
	//		baseX			-		图案填充的起点位置X值，相对于实体坐标系
	//		baseY			-		图案填充的起点位置Y值，相对于实体坐标系
	//		offsetX			-		一个填充线在X方向的偏移，X方向是X轴逆时针旋转angle后的位置
	//		offsetY         -		一个填充线在Y方向的偏移，Y方向是Y轴逆时针旋转angle后的位置
	//		dashes          -		图案的虚线数据数组，正值代表有线，负值代表为空格
	// Returns:
	// 		如果成功返回Mcad::eOk
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus addPatternDefinition(	mxreal angle,
		mxreal baseX,
		mxreal baseY,
		mxreal offsetX,
		mxreal offsetY,
		const McGeDoubleArray& dashes
		);

	// -------------------------------------------------------------------------
	// Summary:
	// 		清除填充图案数据
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus clearPatternDefinition();

	// -------------------------------------------------------------------------
	// Summary:
	// 		返回图案的填充风格
	// -------------------------------------------------------------------------
	McDbHatch::HatchStyle hatchStyle() const;

	// -------------------------------------------------------------------------
	// Summary:
	// 		设置图案的填充风格
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus setHatchStyle(McDbHatch::HatchStyle hstyle);

	// -------------------------------------------------------------------------
	// Summary:
	// 		重新计算图案的填充线条数据
	// -------------------------------------------------------------------------
	//Mcad::ErrorStatus  evaluateHatch(bool bUnderestimateNumLines = false);

	// -------------------------------------------------------------------------
	// Summary:
	// 		添加图案填充边界
	// Parameters:
	//		loopType		-		边界的类型
	//		edgePtrs		-		边界中的曲线数组
	//		edgeTypes		-  		边界中曲线数组中的曲线类型，edgeTypes的长度与edgePtrs相等
	// Returns:
	// 		如果成功返回Mcad::eOk
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus appendLoop(Mdesk::Int32 loopType,
		const McGeVoidPointerArray& edgePtrs,
		const McGeIntArray&  edgeTypes);

	// -------------------------------------------------------------------------
	// Summary:
	// 		添加图案填充边界
	// Parameters:
	//		loopType     	-	边界的类型
	//		vertices		-	边界中的点坐数组
	//		bulges     		-	边界中点数组中的圆弧凸度，vertices的长度与bulges相等
	// Returns:
	// 		如果成功返回Mcad::eOk
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus appendLoop(Mdesk::Int32 loopType,
		const McGePoint2dArray& vertices,
		const McGeDoubleArray& bulges);

	// -------------------------------------------------------------------------
	// Summary:
	// 		删除填充区域
	// Parameters:
	// 		loopIndex - 填充区域索引,从0计数
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus removeLoopAt(int loopIndex);

	// -------------------------------------------------------------------------
	// Summary:
	// 		删除所有填充区域
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus removeAllLoop();


	// -------------------------------------------------------------------------
	// Summary:
	// 		设置填充区域数据
	// Parameters:
	// 		loopIndex - 填充区域索引,从0计数
	//		loopType		-		边界的类型
	//		edgePtrs		-		边界中的曲线数组
	//		edgeTypes		-  		边界中曲线数组中的曲线类型，edgeTypes的长度与edgePtrs相等
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus setLoopAt(int loopIndex,
		Mdesk::Int32 loopType,
		const McGeVoidPointerArray& edgePtrs,
		const McGeIntArray&  edgeTypes);


	// -------------------------------------------------------------------------
	// Summary:
	// 		设置填充区域数据
	// Parameters:
	// 		loopIndex - 填充区域索引,从0计数
	//		loopType     	-	边界的类型
	//		vertices		-	边界中的点坐数组
	//		bulges     		-	边界中点数组中的圆弧凸度，vertices的长度与bulges相等
	// -------------------------------------------------------------------------
	Mcad::ErrorStatus setLoopAt(int loopIndex,
		Mdesk::Int32 loopType,
		const McGePoint2dArray& vertices,
		const McGeDoubleArray& bulges);


	// -------------------------------------------------------------------------
	// Summary:
	// 		是否是SOLID填充
	// -------------------------------------------------------------------------
	bool isSolid() const;

	//:Ignore

	McDbHatch::HatchObjectType hatchObjectType() const;
	Mcad::ErrorStatus setHatchObjectType(McDbHatch::HatchObjectType type);

	Mdesk::Boolean isGradient() const;
	Mdesk::Boolean isHatch() const;

	// Gradient Style Methods
	//
	McDbHatch::GradientPatternType gradientType() const;

	LPCMSTR gradientName() const;

	Mcad::ErrorStatus setGradient(McDbHatch::GradientPatternType gradType,
		LPCMSTR gradName);


	mxreal gradientAngle() const;
	Mcad::ErrorStatus setGradientAngle(mxreal angle);

	Mcad::ErrorStatus getGradientColors( unsigned int& count, 
		McCmColor*& colors,
		mxreal*& values );

	Mcad::ErrorStatus setGradientColors( unsigned int count, 
		McCmColor* colors,
		mxreal* values );

	Mcad::ErrorStatus getGradientColors(McArray<McCmColor>& mxColors,
		McGeDoubleArray&    mxValues);

	Mcad::ErrorStatus setGradientColors(const McArray<McCmColor>& mxColors,
		const McGeDoubleArray&    mxValues);

	
	Mdesk::Boolean getGradientOneColorMode() const;
	Mcad::ErrorStatus setGradientOneColorMode( Mdesk::Boolean oneColorMode );

	mxreal getShadeTintValue() const;
	Mcad::ErrorStatus setShadeTintValue( mxreal value );

	mxreal gradientShift() const;
	Mcad::ErrorStatus setGradientShift( mxreal shiftValue );

	Mcad::ErrorStatus evaluateGradientColorAt( mxreal value,
		McCmColor& color );


	virtual Mcad::ErrorStatus   dwgOutFields(McDbDwgFiler* pFiler) const;
	virtual  Mcad::ErrorStatus  dwgInFields(McDbDwgFiler* pFiler);

	virtual Mdesk::Boolean worldDraw(McGiWorldDraw* mode);

	

	virtual Mcad::ErrorStatus   getGeomExtents(McDbExtents& extents, bool roughCalculation = true) const;

	mxreal pixelSize() const;

	void setPixelSize(
		mxreal pixelSize);


	virtual Mcad::ErrorStatus   transformBy(const McGeMatrix3d& xform);

	void ScalePattern(mxreal dScale);

	void setMaterialFile(LPCMSTR pszFile);

	LPCMSTR materialFile() const;

	virtual Mcad::ErrorStatus moveGripPointsAt(const McGeIntArray& indices,
		const McGeVector3d& offset);

	virtual Mcad::ErrorStatus getGripPoints(McGePoint3dArray& gripPoints,
		McGeIntArray& osnapModes,
		McGeIntArray& geomIds) const;

	McGeMatrix3d getEcs2Wcs(bool& bIdentity) const;

	inline McDbHatchImp* getMcDbHatchImp() const {
		return (McDbHatchImp*)m_pImp;
	}

	virtual Mcad::ErrorStatus   explode(McDbVoidPtrArray& entitySet) const;

private:
	//:End Ignore
};
