kev/Drawer/Module/GeoSigmaDraw/WellAndSection/ItemSingleWell.cpp

#include "StdAfx.h"
#include "stdio.h"
#include <vector>

#include "WellPoleDoc.h"
#include "WellPoleView.h"

#include "WellPoleLib/WellBaseObj.h"
#include "WellPoleLib/WellClassObjGroup.h"
#include "WellPoleLib/InTrackDepthSegment.h"
#include "WellPoleLib/InTrackTextBase.h"

#include "WellPoleLib\InTrackTextRange.h"
#include "WellPoleLib\InTrackPicture.h"
#include "WellPoleLib\InTrackLith.h"
#include "WellPoleLib\InTrackResult.h"
#include "WellPoleLib\InTrackSymbol.h"

#include "WellPoleLib\TrackObj.h"
#include "WellPoleLib/InclinedTrack.h"
#include "WellPoleLib\TrackGroup.h"
#include "WellPoleLib\TrackCurveBase.h"
#include "WellPoleLib\TrackSample.h"
#include "WellPoleLib\TrackSymbol.h"
#include "WellPoleLib\TrackLith.h"
#include "WellPoleLib\TrackResult.h"
#include "WellPoleLib/TrackDiscrete.h"
#include "WellPoleLib/TrackCurve.h"
#include "WellPoleLib/WellPole.h"
#include "WellPoleLib/InclinedWellPole.h"
#include "WellPoleLib/WellObjExtendInfo.h"
#include "ItemText.h"

#include "ActionAddItem.h"

#include "ItemTrack.h"
#include "ItemTrackIn.h"
#include "ItemSingleWell.h"

//#include "DlgAddTrack.h"
//#include "DataTrackPropertyPage.h"
//#include "PropertyGridItemAdd.h"

//过点(ptx,pty)与向量（x1,y1),(x2,y2)垂线的交点.
CPoint2D GetVPt_Line(double x1,double y1,double x2,double y2, double ptx,double pty)
{
	CPoint2D ptf;

	if(abs(x1-x2)<0.000001 && abs(y1-y2)<0.000001)
	{
		ptf.x0 = x1; ptf.y0 = y1;
	}
	else
	{
		if(abs(y1-y2)<0.000001)
		{//向量(x1,y1),(x2,y2)水平，则其垂线垂直
			ptf.x0 = ptx; ptf.y0 = y1;
		}
		else if(abs(x1-x2)<0.000001)
		{//向量垂直
			ptf.x0 = x1;
			ptf.y0 = pty;
		}
		else
		{
			double k = -(x1-x2)/(y1-y2);

			ptf.x0 =( pty - k*ptx - y1 + x1*(y2-y1)/(x2-x1)) /((y2-y1)/(x2-x1) -k);
			ptf.y0 = k*ptf.x0 + pty - k*ptx;
		}
	}

	return ptf;
}

/*得到一个点，这个点距离点（ox，oy）的距离是l,与向量start点和end点垂直。,oid是方向标志，=1表示顺时针旋转90，=2表示逆时针
距离一个点的距离l且与某向量垂直的位置有两个,因此要用oid表示是哪个*/
CPoint2D GetPtV_Vector(double ox,double oy,double startx,double starty,double endx,double endy,double l,int oid)
{
	CPoint2D retPt;

	if(abs(startx-endx)<0.00001 && abs(starty-endy)<0.00001)
	{
		retPt.x0 = startx ; retPt.y0 = starty;
	}
	else
	{
		double sel = sqrt((endx - startx)*(endx - startx) + (endy - starty)*(endy - starty) );
		if(oid == 1)
		{
			retPt.x0 = ox + l* (starty - endy)/sel;
			retPt.y0 = oy + l*(endx - startx)/sel;
		}
		else
		{
			retPt.x0 = ox - l* (starty - endy )/sel;
			retPt.y0 = oy -  l*(endx - startx)/sel;
		}
	}

	return retPt;
}


namespace NItem
{	
	CItemSingleWell::CItemSingleWell(CSigmaDoc* pDoc)
		: CItemWellBase(pDoc)
	{
		m_pWndOld = pDoc;

		SetType(ITEM_WELLPOLE);

		m_pItemSelected = NULL;
		m_pWell = NULL;
		m_pDragImage = NULL;
		m_bEditTrackInData = FALSE;
		m_nTrackPos = -1;

		m_bDragImage = FALSE;

		m_VCursor = m_HCursor = NULL;
		m_pVCursorBmp = m_pVCursorMaskBmp = m_pHCursorBmp = m_pHCursorMaskBmp = NULL;

		m_PointNum = 0;
		m_pPointBuf = NULL;

		m_bWellFrame  = TRUE;
		//CMapEditFrame *pParentFrame = (CMapEditFrame*)pWnd->GetMapFrame();
		//if(!pParentFrame->IsKindOf(RUNTIME_CLASS(CMapWellFrame)))
		//{
		//	m_bWellFrame = FALSE;
		//}
		//CMapWellFrame *pFrame = (CMapWellFrame*)pWnd->GetMapFrame();
		//for(int ii = 0; ii< pFrame->GetMapFrame2D().m_SplitterWnd.GetSize(); ii++)
		//{
		//	m_DcVec.push_back(pFrame->GetMapFrame2D().m_SplitterWnd[ii].pMapWnd2D->GetDC());

		//	m_WndVec.push_back(pFrame->GetMapFrame2D().m_SplitterWnd[ii].pMapWnd2D);
		//}
		
		strcpy(m_logFont.lfFaceName,"宋体");
		m_logFont.lfHeight = -12;
		m_logFont.lfWidth = 0;
		m_logFont.lfCharSet = 1;//中文字集
		m_logFont.lfUnderline = 0;//无下划线
		m_logFont.lfStrikeOut = 0;//无贯穿线
		m_logFont.lfWeight = 400;//正常//粗 700;
		m_logFont.lfItalic = 0; //正常
		m_logFont.lfCharSet = GB2312_CHARSET;
		m_logFont.lfEscapement = 0;
		m_logFont.lfOrientation = 0;
	}

	CItemSingleWell::~CItemSingleWell(void)
	{
		DestroyVHCursor();
		if(m_pItemSelected != NULL)
		{
			delete m_pItemSelected;
			m_pItemSelected = NULL;
		}
		if(m_pDragImage != NULL)
		{
			delete m_pDragImage;
			m_pDragImage = NULL;
		}
		if (m_pWell != NULL)
		{
			m_pWell->ClearCurveSegmentObj();
		}
		if(m_pPointBuf)
			delete []m_pPointBuf;
	}

	CWellBaseObj* CItemSingleWell::GetDrawObj()
	{
		CWellPoleDoc* pDoc = (CWellPoleDoc*)(GetView()->m_pDoc);
		return pDoc->GetWellPole();
	}

	void CItemSingleWell::OnLButtonDown(CDC *pDC, UINT nFlags, CPoint point, int vk)
	{
		if(m_bEditTrackInData)
		{
			if(m_pItemSelected != NULL)
			{
				m_pItemSelected->OnLButtonDown(pDC,nFlags,point,vk);
				return;
			}
		}

		CWellPoleDoc* pDoc = (CWellPoleDoc*)GetDoc();

 		m_bLDown = TRUE;

		int nHandleSize = HADNLESIZE;// ::GetPreferences().WorkaroundHandle.m_nHandleSize;
		double dHandleSize = GetDC()->GetRealSize(CSize(nHandleSize/2, nHandleSize/2)).cx;
		CPoint2D ptReal = GetDC()->GetReal(point);
		m_downPoint = m_firstPoint = m_lastPoint = point;
		selectMode = CItemNestBase::selnone;
		CWellPole *pWell = GetWellObject();
		CWellBaseObj*  pObj = NULL;
		CTrackObj* pTrackObj = NULL;
		CWellBaseObj* pObjSelected = NULL;
		if(m_WellObjSelectlist.GetCount() > 0)
			pObjSelected = m_WellObjSelectlist.GetHead();
		if (pObjSelected == NULL)
		{
			nDragHandle = pWell->HitTest(ptReal,dHandleSize,TRUE);
			if (nDragHandle!=0)
			{
				selectMode = CItemNestBase::size;
				//GetView()->SetCapture();
				return;
			}
		}
		else
		{
			pObj = pObjSelected;
			nDragHandle = pObj->HitTest(ptReal,dHandleSize,TRUE);

			if (nDragHandle!=0)
			{
				selectMode = CItemNestBase::size;
				//GetView()->SetCapture();
				return;
			}
		}

		//选中道边框拖动道宽
		BeSelectBorderLine(pWell,ptReal,dHandleSize);

		if (selectMode==CItemNestBase::selnone)
		{
			CRect8 r(ptReal.x0,ptReal.y0,ptReal.x0,ptReal.y0);
			CSize8 sz=GetDoc()->GetSelectSize();
			double sx=GetDC()->GetRealWidth(sz.cx);
			double sy=fabs(GetDC()->GetRealHeight(sz.cy));
			r.InflateRect(sx,sy);

			////有当前选中对象 先判断当前对象及其子对象（如果有子对象）,若果为NULL再判断井内其它对象
		    CWellBaseObj *pCurrentObj = NULL;
			if (pObjSelected != NULL)
			{
				pCurrentObj = pObjSelected->ObjectAt(r, dHandleSize, TRUE);
			}
			if (pCurrentObj)
			{
				pObj = pCurrentObj;
			}
			else
			{
				pObj = pWell->ObjectAt(r,dHandleSize,TRUE);
			}

			if (pObjSelected != NULL)
			{
			    /////// 非岩芯归为编辑下清除散点道内链表m_childObjects内的对象
				//if (pObjSelected->GetType() == GDOUBLEFOX_DISCRETESEGMENT && pObj != pObjSelected)
				//{
				//	CTrackDiscreteObj* pTrackDiscrete = (CTrackDiscreteObj*)pObjSelected->GetParentObj();
				//	if(pTrackDiscrete != NULL)
				//		pTrackDiscrete->GetChildObjList().RemoveAll();
				//}
				///////非选中曲线道中深度段则清除曲线道内链表m_childObjects内的对象
				//else if (pObjSelected->GetType() == GDOUBLEFOX_LOGCURVESEGMENT && pObj != pObjSelected)
				//{
				//	CTrackCurveObj* pTrackCurveObj = (CTrackCurveObj*)pObjSelected->GetParentObj();
				//	if(pTrackCurveObj != NULL)
				//		pTrackCurveObj->GetChildObjList().RemoveAll();
				//}
			}

			BOOL bChange = FALSE;

			if(pObj!= NULL && !IsSelected(pObj))
			{
				bChange = TRUE;
				//OnDraw(GetDC());

				Select(pObj);

				m_pItemSelected = CreateItem(pObj);
				((CItemWellBase*)m_pItemSelected)->SetDrawObj(pObj);
				m_pItemSelected->SetPos(GetPos());
			}

			if(pObj!=NULL)
			{	
				//if (!IsSelected(pObj))
				//{
				//	Select(pObj, (nFlags & MK_SHIFT) != 0);
				//}
				selectMode = CItemNestBase::move;

				if (pObj->GetType()== KEP_TRACK)
				{
					CTrackObj* pTrackObj = (CTrackObj*)pObj;

					if(!pTrackObj->IsInTrackHead(ptReal,sx,sy) && pWell->GetWellType() != Well_Incline)
					{
						if (pTrackObj->GetTrackType()==Track_Curve)
						{
							CTrackCurveBase* pCurveTrack = (CTrackCurveBase*)pTrackObj;
							selectMode = CItemNestBase::selnone;

							if(m_pItemSelected != NULL)
								delete m_pItemSelected;
							m_pItemSelected = NULL;
							//清除道内之前的移动曲线对象
							//POSITION pos = pCurveTrack->GetChildObjList().GetHeadPosition();
							//while (pos != NULL)
							//{
							//	CWellBaseObj *pObj = pCurveTrack->GetChildObjList().GetNext(pos);
							//	if (pObj->GetType() == GDOUBLEFOX_LOGCURVESEGMENT)
							//	{
							//		pCurveTrack->RemoveFromObjList(pObj);
							//		m_WellObjSelectlist.RemoveAll();
							//		delete pObj;
							//	}
							//}

							//CItemTrackInCurveSegment *pItemTrackInCurveSegment = new CItemTrackInCurveSegment(GetWnd());
							//pItemTrackInCurveSegment->SetPos(GetPos());
							//pItemTrackInCurveSegment->SetItemWell(this);
							//pItemTrackInCurveSegment->SetTracCurve(pCurveTrack);
							//m_pItemSelected = pItemTrackInCurveSegment;
							//m_pItemSelected->OnLButtonDown(nFlags,point);
							//m_bEditTrackInData = TRUE;

							//GetDoc()->Invalidate(pCurveTrack);
							return;
						}
						else
						{
							if((pTrackObj->GetTrackType() == Track_Depth)  || pWell->GetWellType() == Well_Incline)
							{  //深度道,斜井道不需要添加道内对象s
								if (bChange)
								{
									//绘制十字线时，需要全图绘制可以去掉因为重复绘制导致的十字线错误，当不要十字线时直线 OnDraw效率高
									//if (::GetPreferences().WorkaroundDisplay.m_bViewCrossLine)
									//	GetDoc()->Invalidate();
									//else
										OnDraw(GetDC());
									//GetView()->SetCapture();
								}
								return;
							}

							selectMode = CItemNestBase::selnone;
							if(m_pItemSelected != NULL)
								delete m_pItemSelected;

							CItemTrack *pItemTrack = (CItemTrack *)CreateItem(pTrackObj)/*new CItemTrack(GetDoc())*/;
							m_pItemSelected = pItemTrack;
							pItemTrack->SetDrawObj(pTrackObj);
							pItemTrack->SetItemWell(this);
							m_pItemSelected->OnLButtonDown(pDC,nFlags,point,vk);
									
							m_bEditTrackInData = TRUE;

							return;
						}
					}
				}
				else
				{
					if (pWell->GetWellType()==Well_Section&&
						(pObj->GetType()== KEP_RESULT||
						pObj->GetType()== KEP_LAYERGROUP||
						pObj->GetType()== KEP_STANDARD))
					{
						//CXTPPropertyGrid &grid = GetPropertyGrid(GetDoc()->GetMainFrame());
						//InitPropertyGrid(grid);			

						//CItemAddBend *pAddBend = new CItemAddBend(GetWnd());
						//pAddBend->SetPos(GetPos());
						//pAddBend->SetItemWell(this);
						//pAddBend->SetDrawObj(pObj);
						//POSITION pos = m_WellObjSelectlist.GetHeadPosition();
						//while(pos)
						//{
						//	pAddBend->m_WellObjSelectlist.AddTail(m_WellObjSelectlist.GetNext(pos));
						//}
						//m_pItemSelected = pAddBend;
						//m_pItemSelected->OnLButtonDown(nFlags,point);
						//m_bEditTrackInData = TRUE;
						return;
					}
					else
					{
						//selectMode = CItemSelect::selnone;
						//if(m_pItemSelected != NULL)
						//	delete m_pItemSelected;

						//CItemWellBase *pItem= CreateItem(pObj);
						//m_pItemSelected = pItem;
						//pItem->SetDrawObj(pObj);
						//if (m_pItemSelected!=NULL)
						//{
						//	m_pItemSelected->OnLButtonDown(nFlags,point);
						//	m_bAddObj = TRUE;
						//}
						//return;
					}
				}

				//GetView()->SetCapture();
				CreateDragImage();
			}
			else
			{

				//if(GetType() == ITEM_SECTIONWELL)
				//	selectMode = CItemSelect::move;
				//GetView()->SetCapture();
				m_WellObjSelectlist.RemoveAll();
				if(m_pItemSelected != NULL)
				{
					delete m_pItemSelected;
					m_pItemSelected = NULL;
				}
				
				if (pObj != pObjSelected)
				{
					//OnDraw(GetDC());
					bChange = TRUE;// FALSE;
				}

				DrawHandle(GetDC());
			}

			if(bChange)
			{//绘制十字线时，需要全图绘制可以去掉因为重复绘制导致的十字线错误，当不要十字线时直线 OnDraw效率高
				//if (::GetPreferences().WorkaroundDisplay.m_bViewCrossLine)
				//  GetDoc()->Invalidate();
				//else
					 //OnDraw(GetDC());
					//CWellPoleView *pView = (CWellPoleView*)GetView();
					//pView->m_pWndCallBack(eWellPoleCallbackMsgDef::tInvalidateWnd,0);
			}
		}
		//CXTPPropertyGrid &grid = GetPropertyGrid(GetDoc()->GetMainFrame());
		//InitPropertyGrid(grid);
	}

	void CItemSingleWell::OnLButtonUp(CDC *pDC, UINT nFlags, CPoint point, int vk )
	{
		CWellPole *pWellObj = GetWellObject();		
		m_firstPoint = m_lastPoint = point;
		BOOL bDiscreteNoAdd = FALSE;
		if(m_pItemSelected != NULL&&m_bEditTrackInData)
		{
			CWellPole* pWell = GetWellObject();
			bDiscreteNoAdd = TRUE;
			m_bEditTrackInData = FALSE;
			m_pItemSelected->OnLButtonUp(pDC,nFlags, point,vk);

			if(m_downPoint == point)
			{
				OnDraw(GetDC());
			}

			ReleaseCapture();
			m_bDrag = FALSE;
			m_bLDown = FALSE;
			nDragHandle = 0;
			selectMode = CItemNestBase::selnone;
		}

		CRect oldrect = GetDC()->GetScreen(pWellObj->GetRect());

		CPoint2D downPoint = GetDC()->GetReal(m_downPoint);
		CPoint2D lastPoint = GetDC()->GetReal(m_lastPoint);
		CPoint2D delta(lastPoint.x0-downPoint.x0,lastPoint.y0-downPoint.y0);

		if((m_downPoint.x-m_lastPoint.x)!=0 || (m_downPoint.y-m_lastPoint.y)!=0)
		{
			if (IsCaptureState())
			{ 
				//拖井头、道头纵向边界
				if(selectMode== CItemNestBase::border)
				{
					SetReUnDoAction();
					pWellObj = GetWellObject();
					CPoint2D ptf = pWellObj->GetAnchorPoint();//使用井头的点在斜井时也能用(因为斜井的m_position会变化)
					CPoint2D dpt,lpt;
					dpt = pWellObj->ReCalculatePoint(downPoint);
					lpt = pWellObj->ReCalculatePoint(lastPoint);
					delta.SetPoint(lpt.x0 - dpt.x0,lpt.y0 - dpt.y0);
					if (nDragHandle==6)
					{
						double oldHigh = pWellObj->m_dHeightTrackHead;
						pWellObj->m_dHeightTrackHead += delta.y0;
						//////控制道头最小高度
						if (pWellObj->m_dHeightTrackHead < 5)
						{
							pWellObj->m_dHeightTrackHead = 5;
							delta.y0 = pWellObj->m_dHeightTrackHead - oldHigh;
						}
						ptf.y0 += delta.y0;
					}
					else if (nDragHandle==2)
					{
						double oldHigh = pWellObj->m_dHeightWellHead;
						pWellObj->m_dHeightWellHead += delta.y0;
						if (pWellObj->m_dHeightWellHead <pWellObj->m_font.m_dHeight)
						{
							pWellObj->m_dHeightWellHead =pWellObj->m_font.m_dHeight;
							delta.y0 = pWellObj->m_dHeightWellHead -oldHigh;
						}
						ptf.y0 += delta.y0;
					}
					pWellObj->CalculateSize(ptf);
				}
				else
				{
					CWellBaseObj* pObjSelected = NULL;
					if(m_WellObjSelectlist.GetCount() > 0)
						pObjSelected = m_WellObjSelectlist.GetHead();
					if (pObjSelected == NULL)//拖动井
					{
						if(selectMode==CItemSelect::move&&(GetWellObject()->GetParent()!=NULL&&GetWellObject()->GetParent()->GetType()!= KEP_FENCE))
						{
							CRect8 position = pWellObj->GetPos();
							pWellObj->m_delta = delta;
							position.OffsetRect(delta.x0, delta.y0);
							pWellObj->MoveTo(position);					
						}
						else if(selectMode == CItemSelect::size)//拖动井控制点，整体缩放图道宽度
						{
							SetReUnDoAction();
							pWellObj = GetWellObject();
							CPoint2D lastPoint = GetDC()->GetReal(m_lastPoint);
							pWellObj->MoveHandleTo(nDragHandle, lastPoint);
							//if (pWellObj->GetParentObj()!=NULL)
							//{
							//	CWellSection* pSection = (CWellSection*)pWellObj->GetParentObj();
							//	if (pSection->GetType()==GDOUBLEFOX_FENCE)
							//	{
							//		CWellFence* pFence = (CWellFence*)pSection;
							//		pFence->SortBendList();
							//	}
							//}
						}
					}
					else
					{
						CWellBaseObj*  pObj = pObjSelected;

						if(selectMode == CItemNestBase::move)
						{
							if (pObj->GetType()== KEP_TRACK)
							{
								CTrackObj* pTrackObj = (CTrackObj*)pObj;

								CSize size(m_lastPoint.x - m_downPoint.x, m_lastPoint.y - m_downPoint.y);
								if(size.cx != 0)
								{
									////移动井内图道、组合道后重新排列道的位置
									//if(pTrackObj->GetTrackType() == Track_Group)
									//	pWellObj->SortTrack((CTrackGroupObj*)pTrackObj);
									//else
									//	pWellObj->SortTrack(pTrackObj);
									int ideep = 0;
									SortTrackWhenMoving(pWellObj,pTrackObj, ideep);

									CPoint2D ptf =pWellObj->GetAnchorPoint();//使用井头的点在斜井时也能用(因为斜井的m_position会变化)  pWellObj->GetPos().TopLeft();
									pWellObj->CalculateSize(ptf);

									//重新计算道内子对象
									pWellObj->ResetChildPosition();

									//if (pWellObj->GetWellType()==Well_Section)
									//{
									//	CWellSection* pSection = (CWellSection*)pWellObj->GetParentObj();
									//	if (pSection->GetType()==GDOUBLEFOX_FENCE)
									//	{
									//		CWellFence* pFence = (CWellFence*)pSection;
									//		POSITION pos = pFence->m_BendList.GetHeadPosition();
									//		while (pos!=NULL)
									//		{
									//			CFenceBendObj* pBend = (CFenceBendObj*)pFence->m_BendList.GetNext(pos);
									//			if (pBend->m_pLayerLeft->GetParentObj()->GetParentObj()==pWellObj||(pBend->m_pLayerRight!=NULL&&pBend->m_pLayerRight->GetParentObj()->GetParentObj()==pWellObj))
									//			{
									//				pBend->CreateBendLines();
									//				pBend->CreateBendFills();
									//			}
									//		}
									//	}
									//}
								}
							}
							//else if (pObj->GetType()==GDOUBLEFOX_LOGCURVESEGMENT)//曲线段
							//{
							//	CTrackInCurveSegment* pSegment = (CTrackInCurveSegment*)pObj;
							//	pSegment->m_fSdep = pWellObj->ScreenYToDepth(pSegment->GetPos().top);			// 曲线段的起始深度
							//	pSegment->m_fEdep = pWellObj->ScreenYToDepth(pSegment->GetPos().bottom);			// 曲线段的结束深度
							//}
							//// 岩芯归为时
							//else if (pObj->GetType() == GDOUBLEFOX_DISCRETESEGMENT)
							//{
							//	if (m_WellObjSelectlist.GetCount()==1)
							//	{
							//		MoveDiscreteSegement(pObj,delta.y0);
							//		CRect8 position = pObj->GetRect();
							//		CRect8 RectOld = position;
							//		pObj->SetDelta(CPoint2D(0, delta.y0));
							//		position.OffsetRect(delta.x0, delta.y0);
							//		pObj->MoveTo(position);
							//		CRect8 RectNew = position;
							//		double fTop = max(RectOld.top,RectNew.top);
							//		double fBot = min(RectOld.bottom,RectNew.bottom);
							//		CArray<double> ArrDepth;
							//		CArray<double> ArrValue;
							//		int nStartIndex = 0;
							//		int nEndIndex = 0;
							//		GetDepthAndValueDiscreteSegement(pObj,ArrDepth,ArrValue,fTop,fBot,nStartIndex,nEndIndex);
							//		SortDiscreteSegment(ArrDepth,ArrValue);
							//		SetDiscreteSegment(pObj,ArrDepth,ArrValue,nStartIndex,nEndIndex);
							//		ArrDepth.RemoveAll();
							//		ArrValue.RemoveAll();
							//	}
							//}
							else
							{
								SetReUnDoAction();
								pWellObj = GetWellObject();
								if(pWellObj->GetWellType() != Well_Incline)
								{
									if(delta.y0 > 0)
									{
										POSITION pos = m_WellObjSelectlist.GetHeadPosition();
										while(pos!=NULL)
										{
											CWellBaseObj*  pObj = m_WellObjSelectlist.GetNext(pos);
											CRect8 position = pObj->GetRect();
											pObj->SetDelta(CPoint2D(0, delta.y0));
											position.OffsetRect(delta.x0, delta.y0);
											pObj->MoveTo(position);
										}

									}
									else
									{
										POSITION pos = m_WellObjSelectlist.GetTailPosition();
										while(pos!=NULL)
										{
											CWellBaseObj*  pObj = m_WellObjSelectlist.GetPrev(pos);
											CRect8 position = pObj->GetRect();
											pObj->SetDelta(CPoint2D(0, delta.y0));
											position.OffsetRect(delta.x0, delta.y0);
											pObj->MoveTo(position);
										}
									}
								}
							}
						}
						else if (selectMode==CItemNestBase::size&&nDragHandle!=0)
						{
						    SetReUnDoAction(); pWellObj = GetWellObject();
							if (pObj->GetType()== KEP_TRACK)
							{
								CPoint2D ptf =pWellObj->GetAnchorPoint();//使用井头的点在斜井时也能用(因为斜井的m_position会变化)   pWellObj->GetPos().TopLeft();
								CTrackObj *pCTrackObj = (CTrackObj *) pObj;
								if (nDragHandle==4)
								{
									//交互对象句柄
									CPoint2D lastPoint = GetDC()->GetReal(m_lastPoint);
									
									lastPoint = pWellObj->ReCalculatePoint(lastPoint);

									pObj->MoveHandleTo(nDragHandle,lastPoint);
								}
								pWellObj->CalculateSize(ptf);
							}
							else 
							{
								//内置对象交互句柄
								pObj->MoveHandleTo(nDragHandle, lastPoint);
							}
						}

						//CXTPPropertyGrid &grid = GetPropertyGrid(GetDoc()->GetMainFrame());
						//InitPropertyGrid(grid);
					}
				}
				//刷新整个井
				GetDoc()->Invalidate(/*rect*/);
			}
		}

		/// 鼠标在散点道道体范围之内且非添加岩芯归位深度段时取消散点道选中状态
		if ((m_downPoint.y-m_lastPoint.y)==0)
		{
			CWellBaseObj* pObjSelected = NULL;
			if(m_WellObjSelectlist.GetCount() > 0)
				pObjSelected = m_WellObjSelectlist.GetHead();
			if (pObjSelected != NULL)
			{
				if (pObjSelected->GetType() == KEP_TRACK)
				{
					CTrackObj* pTrack = (CTrackObj*)pObjSelected;
					if (pTrack->GetTrackType() == Track_Discrete)
					{
						CTrackDiscrete* pTrackDiscrete = (CTrackDiscrete*)pTrack;
						if(bDiscreteNoAdd)
						{
							if (pTrackDiscrete->GetChildren().size() == 0)
							{
								if(m_pItemSelected != NULL)
								{
									delete m_pItemSelected;
									m_pItemSelected = NULL;
								}
								m_pItemSelected = CreateItem(pTrack);
								((CItemWellBase*)m_pItemSelected)->SetDrawObj(pTrack);
								m_pItemSelected->SetPos(GetPos());

								//OnDraw(GetDC());

								//CXTPPropertyGrid &grid = GetPropertyGrid(GetDoc()->GetMainFrame());
								//InitPropertyGrid(grid);
							}
						}
					}
					else if(pTrack->GetTrackType() == Track_Curve)
					{
						if(m_pItemSelected != NULL &&m_pItemSelected->GetType() != ITEM_SELECT)
						{//在曲线道中，如果原地点击鼠标，就还选中曲线道
							delete m_pItemSelected;

							m_pItemSelected = CreateItem(pTrack);
							((CItemWellBase*)m_pItemSelected)->SetDrawObj(pTrack);
							m_pItemSelected->SetPos(GetPos());

							//OnDraw(GetDC());
							
							//CXTPPropertyGrid &grid = GetPropertyGrid(GetDoc()->GetMainFrame());
							//InitPropertyGrid(grid);
						}
					}
				}
			}	
		}

		// End dragging image
		if(m_pDragImage != NULL)
		{
			CWnd* pWnd = CWnd::FromHandle(GetView()->GetHWND());
			m_pDragImage->DragLeave(pWnd);
			m_pDragImage->EndDrag();
			delete m_pDragImage;  m_pDragImage=NULL;

			m_bDragImage = FALSE;
		}
		ReleaseCapture();
		m_bDrag = FALSE;
		m_bLDown = FALSE;
		nDragHandle = 0;
	}

	void CItemSingleWell::OnLButtonDblClk(UINT nFlags, CPoint point)
	{

	}

	int CItemSingleWell::OnMouseMove(CDC *pDC, UINT nFlags, CPoint point)
	{
		if(m_pItemSelected != NULL&&m_bEditTrackInData)
		{
			return m_pItemSelected->OnMouseMove(pDC,nFlags, point);
			
		}
		CPoint2D lastPoint = GetDC()->GetReal(point);
		CWellPole *pWellObj = GetWellObject();

		CWellBaseObj* pObjSelected = NULL;
		if(m_WellObjSelectlist.GetCount() == 1)
			pObjSelected = m_WellObjSelectlist.GetHead();
		//设置拖拽开始点

		int nHandleSize = HADNLESIZE;//::GetPreferences().WorkaroundHandle.m_nHandleSize;
		double dHandleSize = GetDC()->GetRealSize(CSize(nHandleSize/2, nHandleSize/2)).cx;
		if(IsCaptureState() && m_bLDown)
		{
			if(m_pDragImage != NULL)
			{
				CPoint scpt = point;
				//BOOL b  = ClientToScreen(GetView()->GetHWND(), &scpt);
				//DWORD error = GetLastError();
				//ClientToScreen(GetView()->GetHWND(), &crClient);
				CPoint pt = scpt;
				pt.x -= m_rectImage.left;
				pt.y -= m_rectImage.top;
				if (pObjSelected != NULL)
				{
					//if (pObjSelected->GetType() == GDOUBLEFOX_DISCRETESEGMENT)
					//{
					//	point.x = m_downPoint.x;
					//}
				}

				if(!m_bDragImage)
				{
					m_pDragImage->BeginDrag(0, pt);

					CWnd* pWnd = CWnd::FromHandle(GetView()->GetHWND());
					//m_pDragImage->DragEnter(pWnd, point);
					m_pDragImage->DragEnter(pWnd, scpt);
					m_bDragImage = TRUE;
				}

				m_pDragImage->DragMove(scpt); //move the drag image to those coordinates
			}

			if (m_pDragImage == NULL)
			{
				//OnDraw(GetDC());
				CWnd* pWnd = CWnd::FromHandle(GetView()->GetHWND());
				DrawSelected(GetDC(), pWnd);
			}
			//刷新
			//OnDraw(GetDC());
			if(m_pDragImage != NULL && pObjSelected != NULL)
			{
				if(pObjSelected->GetType() == KEP_TRACK)
				{
					CTrackObj* pTrack = (CTrackObj*)pObjSelected;
					CPoint2D ptBegin, ptEnd;
					int nPos = pWellObj->FindTrackPosition(pTrack, ptBegin, ptEnd);
					m_nTrackPos = nPos;
					if(nPos >= 0)
					{	
						m_ptBegin = ptBegin;
						m_ptEnd = ptEnd;
					}
				}
			}


			m_bDrag = TRUE;
			m_lastPoint = point;
			if (selectMode==CItemSelect::move && pObjSelected != NULL)// 移动图元（道头、曲线头） 	
			{
				CPoint2D endPoint = GetDC()->GetReal(m_lastPoint);
				CPoint2D startPoint = GetDC()->GetReal(m_firstPoint);

				endPoint = pWellObj->ReCalculatePoint(endPoint);
				startPoint = pWellObj->ReCalculatePoint(startPoint);

				CPoint2D delta(endPoint.x0-startPoint.x0,endPoint.y0-startPoint.y0);

				CWellBaseObj *pDrawObj = pObjSelected;
				pDrawObj->m_delta = delta; ///????
				//m_pObjSelected->m_delta = delta;

				if(pDrawObj->GetType() == KEP_TRACK)
				{
					CTrackObj *pTrackObj = (CTrackObj *) pObjSelected;
					CRect8 activehead = pTrackObj->m_active_head;

					//移动道头交互框
					activehead.OffsetRect(delta.x0, delta.y0);
					pTrackObj->MoveToActiveTrackHead(activehead);
				}				
			}
			//刷新
			//OnDraw(GetDC());
			if (m_pDragImage == NULL)
			{
				CWnd* pWnd = CWnd::FromHandle(GetView()->GetHWND());
				DrawSelected(GetDC(), pWnd);
			}
			m_firstPoint = m_lastPoint;
		}
		else
		{
			m_lastPoint = point;
		}
		return 1;
	}

	void CItemSingleWell::OnRButtonDown(UINT nFlags, CPoint point)
	{
		//OnLButtonDown(nFlags, point);
		m_bLDown = FALSE;
		CItem::OnRButtonDown(nFlags, point);
		//OnLButtonUp(nFlags, point);
	}

	int CItemSingleWell::GetSubMenu()
	{//???????
		// 井
		int iRMenu = 42;
		CWellBaseObj* pObjSelected = NULL;
		if(m_WellObjSelectlist.GetCount() > 0)
			pObjSelected = m_WellObjSelectlist.GetHead();

		if(pObjSelected == NULL)
			return iRMenu;

		if (pObjSelected->GetType()== KEP_TRACK)
		{
			CTrackObj* pTrackObj = (CTrackObj*)pObjSelected;
			// 深度道、组合道
			if(pTrackObj->GetTrackType()==Track_Depth || pTrackObj->GetTrackType()==Track_Group)
			{
				iRMenu = 44;
			}
			else if (pTrackObj->GetTrackType()==Track_Curve || pTrackObj->GetTrackType() == Track_Discrete)
			{
				iRMenu = 43;
			}
			else if(pTrackObj->GetTrackType() == Track_VdlImage 
				|| pTrackObj->GetTrackType() == Track_WaveCurve
				|| pTrackObj->GetTrackType() == Track_SeisSection)
			    iRMenu = 54;
			else
				iRMenu = 43;
			TRACE("select track right menu \r\n");
		}
		else if (GetWellObject()->GetWellType()==Well_Section&&
			(pObjSelected->GetType()== KEP_RESULT||
			pObjSelected->GetType()== KEP_LAYERGROUP||
			pObjSelected->GetType()== KEP_STANDARD))
		{
			iRMenu = 38;
		}
		//else if (pObjSelected->GetType()==GDOUBLEFOX_LOGCURVESEGMENT)
		//{
		//	iRMenu = 51;
		//}
		else if (pObjSelected->GetType()== KEP_MARK)
		{
			iRMenu = 45;
		}
		//else if (pObjSelected->GetType()== KEP_TEXTBOX)
		//{
		//	iRMenu = 41;
		//}
		//else if (pObjSelected->GetType()==GDOUBLEFOX_DISCRETESEGMENT)
		//{
		//	iRMenu = 50;
		//}
		else if(pObjSelected->GetType()!=NULL && pObjSelected->GetParent()->GetType()== KEP_TRACK)
		{
			TRACE("select track in      right menu \r\n");
			iRMenu = 45;
		}
		return iRMenu;
	}

	BOOL CItemSingleWell::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
	{	
		return TRUE;
		if(m_pItemSelected != NULL && m_bEditTrackInData)
		{
			//return m_pItemSelected->OnSetCursor(pWnd, nHitTest, message);
		}

		CWellPole* pWellObj = GetWellObject();
		CWellBaseObj* pObjSelected = NULL;
		if(m_WellObjSelectlist.GetCount() == 1)
			pObjSelected = m_WellObjSelectlist.GetHead();

		int nHandleSize = HADNLESIZE;// ::GetPreferences().WorkaroundHandle.m_nHandleSize;
		double dHandleSize = GetDC()->GetRealSize(CSize(nHandleSize/2, nHandleSize/2)).cx;
		CPoint2D lastPoint = GetDC()->GetReal(m_lastPoint);
		if(pObjSelected == NULL)
		{
			int nHandle = pWellObj->HitTest(lastPoint,dHandleSize,TRUE);
			if(nHandle!=0)
			{
				::SetCursor(GetHandleCursor(nHandle));	
				return TRUE;
			}
		}
		else /*if(pObjSelected != NULL)*/
		{
			//光标移动到非道对象时的状态
			if (pObjSelected->GetType()!= KEP_TRACK)
			{
				//if (pObjSelected->GetType()!=GDOUBLEFOX_STANDARD &&
				//	pObjSelected->GetType()!=GDOUBLEFOX_FAULTPOINT)
				{
					int nHandle = pObjSelected->HitTest(lastPoint,dHandleSize,TRUE);
					if(nHandle!=0)
					{
						SetCursor(GetHandleCursor(nHandle));
						return TRUE; 
					}
				}
			}
		}

		if(SetMoveCursor(pWellObj,lastPoint,dHandleSize,pWellObj))
			return TRUE;
		//else
		//{
		//	GetDoc()->GetCursor().SetCursor(CursorSelect);
		//	return GetDoc()->GetCursor().SetCursor();
		//}
		return TRUE;
	}

	BOOL CItemSingleWell::OnSetCursor(CPoint pt, int& handle)
	{
		handle = -1;
		if (m_pItemSelected != NULL && m_bEditTrackInData)
		{
			return m_pItemSelected->OnSetCursor(pt , handle);
		}
		CWellPole* pWellObj = GetWellObject();
		CWellBaseObj* pObjSelected = NULL;
		if (m_WellObjSelectlist.GetCount() == 1)
			pObjSelected = m_WellObjSelectlist.GetHead();

		int nHandleSize = HADNLESIZE;// ::GetPreferences().WorkaroundHandle.m_nHandleSize;
		double dHandleSize = GetDC()->GetRealSize(CSize(nHandleSize / 2, nHandleSize / 2)).cx;
		CPoint2D lastPoint = GetDC()->GetReal(pt);// m_lastPoint);
		CPoint ptt = m_lastPoint;
		if (pObjSelected == NULL)
		{
			int nHandle = pWellObj->HitTest(lastPoint, dHandleSize, TRUE);
			if (nHandle != 0)
			{
				if (nHandle > 1)
					handle = 3;
				return TRUE;
			}
			//if (nHandle != 0)
			//{
			//	::SetCursor(GetHandleCursor(nHandle));
			//	return TRUE;
			//}
		}
		else /*if(pObjSelected != NULL)*/
		{
			//光标移动到非道对象时的状态
			if (pObjSelected->GetType() != KEP_TRACK)
			{
				//if (pObjSelected->GetType()!=GDOUBLEFOX_STANDARD &&
				//	pObjSelected->GetType()!=GDOUBLEFOX_FAULTPOINT)
				{
					int nHandle = pObjSelected->HitTest(lastPoint, dHandleSize, TRUE);
					if (nHandle != 0)
					{ 
						handle = 2;
						return TRUE;
					}

					//if (nHandle != 0)
					//{
					//	SetCursor(GetHandleCursor(nHandle));
					//	return TRUE;
					//}
				}
			}
		}

		if (SetMoveCursor(pWellObj, lastPoint, dHandleSize, pWellObj,handle))
			return TRUE;
		return TRUE;
	}

	void CItemSingleWell::OnDraw(CXyDC* pXyDC)
	{
		//if(m_bAddObj)
		//{
		//	m_pItemSelected->OnDraw(pXyDC);
		//	return;
		//}
		CWellPoleView *pView = (CWellPoleView*)GetView();
		CWnd* pWnd = CWnd::FromHandle(GetView()->GetHWND());
		if(!m_bWellFrame)
		{
			DrawHandle(pXyDC);
			DrawSelected(pXyDC, pWnd);
		}
		else
		{
			//DrawHandle(pXyDC);
			//DrawSelected(pXyDC, GetView());

			CXyDC xyDC;
			xyDC = *GetDC();
			pView->BeginSelectBmpDC();
			xyDC.Create(&pView->GetSelectDC());
			DrawHandle(&xyDC);

			DrawSelected(&xyDC, pWnd);
			pView->EndItemSelectBmpDC(); // pView->GetMemDC());

			pView->m_pDoc->Invalidate();

		}
	}

	void CItemSingleWell::OnDraw(CXyDC* pXyDC, CDC* pDC)
	{
		//if(m_bAddObj)
			//{
			//	m_pItemSelected->OnDraw(pXyDC);
			//	return;
			//}
		CWellPoleView *pView = (CWellPoleView*)GetView();
		CWnd* pWnd = CWnd::FromHandle(GetView()->GetHWND());
		if (!m_bWellFrame)
		{
			DrawHandle(pXyDC);
			DrawSelected(pXyDC, pWnd);
		}
		else
		{
			//DrawHandle(pXyDC);
			//DrawSelected(pXyDC, GetView());

			CXyDC xyDC;
			xyDC = *GetDC();
			pView->BeginSelectBmpDC();
			xyDC.Create(&pView->GetSelectDC());
			DrawHandle(&xyDC);

			DrawSelected(&xyDC, pWnd);
			pView->EndItemSelectBmpDC(); // pView->GetMemDC());

			pView->m_pDoc->Invalidate();

		}
	}

	void CItemSingleWell::DrawMoveSelected(CXyDC *pXyDC,CWnd *pWnd)
	{
		CSigmaView* pView = GetView();
		CDC *pDC = pView->m_pImgDC;
		if (this->m_bLDown && pView->GetScreenDC() != NULL)
		{
			pDC = pView->GetScreenDC(); // pXyDC->GetDC();
			//TRACE("use screendc  --------------\r\n");
		}
		//else
		//{
		//	TRACE("use imgDC ---  --------------\r\n");
		//}
		CPen pen(PS_DOT, 0, RGB(0, 0, 0));
		CPen *pOldPen = (CPen *)pDC->SelectObject(&pen);
		int old = pDC->SetROP2(R2_NOTXORPEN);

		CWellPoleDoc* pDoc = (CWellPoleDoc *)GetDoc();
		CWellPole *pWell = GetWellObject();
		BOOL bInclineWell = FALSE;
		if(m_pWell->GetWellType() == Well_Incline)
			bInclineWell = TRUE;

		if(m_bDrag && m_lastPoint!=m_downPoint)//画拖拽框（整体、控制点）
		{
			CPoint pt1,pt2;
			if(selectMode==CItemNestBase::border)//拖道头、井头横线
			{
				if(pWell->GetWellType() == Well_Incline)
				{
					CPoint2D tpt1,tpt2,vpt,lastpt,fpt,tpt3,tpt4;
					if(nDragHandle == 6)
					{//道头部向量
						tpt1.x0 = pWell->GetWellHeadCurve().x[3] ; tpt1.y0 = pWell->GetWellHeadCurve().y[3];
						tpt2.x0 = pWell->GetWellHeadCurve().x[2] ; tpt2.y0 = pWell->GetWellHeadCurve().y[2];
					}
					else if(nDragHandle == 2)
					{//井头部向量
						tpt1.x0 = pWell->GetWellHeadCurve().x[0] ; tpt1.y0 = pWell->GetWellHeadCurve().y[0];
						tpt2.x0 = pWell->GetWellHeadCurve().x[1] ; tpt2.y0 = pWell->GetWellHeadCurve().y[1];
					}
					if(nDragHandle == 2 || nDragHandle == 6)
					{
						lastpt = pXyDC->GetReal(m_lastPoint);
						fpt.x0 = lastpt.x0 - (tpt2.x0 - tpt1.x0); fpt.y0 = lastpt.y0 - (tpt2.y0 - tpt1.y0);// fpt,lastpt相当于向量tpt1,tpt2同样的向量(可以看作是向量(tpt1,tpt2)偏移到了(fpt,lastPt)位置)

						vpt = nsWellPoleFunc::GetVPt_Line(tpt1.x0,tpt1.y0,tpt2.x0,tpt2.y0,lastpt.x0,lastpt.y0); //vpt=鼠标点在向量tpt1,tpt2上的投影

						double xx = (tpt2.x0 - vpt.x0);
						double yy = (tpt2.y0 - vpt.y0);
						tpt3.x0 = fpt.x0 +xx; tpt3.y0 = fpt.y0 + yy;// 将向量(fpt,lastpt)偏移xx,yy后就得到(tpt1,tpt2)在过鼠标点lastPt的平行向量上的投影
						tpt4.x0 = lastpt.x0 + xx; tpt4.y0 = lastpt.y0+ yy;

						pt1 = pXyDC->GetScreen(tpt3); pt2 = pXyDC->GetScreen(tpt4);
						pDC->MoveTo(pt1); pDC->LineTo(pt2);
					}
				}
				else
				{
					if(nDragHandle == 6)//拖道头
					{
						pt1.x = pXyDC->GetScreen(pWell->GetPos().TopLeft()).x;
						pt2.x = pXyDC->GetScreen(pWell->GetPos().BottomRight()).x;
						pt1.y = pt2.y = m_lastPoint.y;
						pDC->MoveTo(pt1); pDC->LineTo(pt2);
					}
					else if(nDragHandle == 2)//拖拽井头
					{
						pt1.x = pXyDC->GetScreen(pWell->GetPos().TopLeft()).x;
						pt2.x = pXyDC->GetScreen(pWell->GetPos().BottomRight()).x;
						pt1.y = pt2.y = m_lastPoint.y;
						pDC->MoveTo(pt1); pDC->LineTo(pt2);
					}
				}			
			}
			else
			{
				if(m_WellObjSelectlist.GetCount() == 0)//无选中子对象，画井选中状态
				{
					if(selectMode == CItemNestBase::move)//整体
					{
						CRect position = pXyDC->GetScreen(pWell->GetRect());
						position.NormalizeRect();

						CRect rect = position;
						CPoint delta = CPoint(m_lastPoint.x-m_downPoint.x,m_lastPoint.y-m_downPoint.y);
						rect.OffsetRect(delta.x, delta.y);
						pDC->Rectangle(rect);
					}
					else if (nDragHandle!=0)//控制点
					{
						CRect rect = pXyDC->GetScreen(pWell->GetRect());
						MoveHandle(nDragHandle, m_lastPoint, rect);

						pDC->Rectangle(rect);
					}
				}
				else
				{
					CWellBaseObj* pObjSelected = m_WellObjSelectlist.GetHead();

					BOOL bNoInclineObj = TRUE;
					CWellBaseObj *pParentObj = pObjSelected->GetParent();
					if(pParentObj && bInclineWell)
					{//判断是斜井道内子对象,
						if(pParentObj->GetType() == KEP_TRACK)
							bNoInclineObj = FALSE; //如果是斜井道内对象,就不绘制移动状态
					}
					if(bNoInclineObj)
					{
						if(selectMode== CItemNestBase::move)//整体
						{
							if(pObjSelected->GetType()!=KEP_TRACK /*&& */
/*								pObjSelected->GetType()!=GDOUBLEFOX_LOGCURVESEGMENT 
								&& pObjSelected->GetType()!=GDOUBLEFOX_DISCRETESEGMENT*/)
							{
								CWellPole *pWell = GetWellObject();
								POSITION pos = m_WellObjSelectlist.GetHeadPosition();
								while(pos!=NULL)
								{
									CWellBaseObj *pObj = m_WellObjSelectlist.GetNext(pos);
									CRect position = pXyDC->GetScreen(pObj->GetSelectedRange());
									position.NormalizeRect();
									CRect rect = position;
									CPoint delta = CPoint(0,m_lastPoint.y-m_downPoint.y);
									rect.OffsetRect(delta.x, delta.y);
									if (pObj->GetType() == KEP_STANDARD ||//标准层道内对象拖拽框
										pObj->GetType() == KEP_FAULTPOINT/*||//断点道内对象拖拽框
										pObj->GetType() == GDOUBLEFOX_COREWELL*/)//井壁取芯道内对象拖拽框
									{
										pDC->MoveTo(rect.TopLeft());
										pDC->LineTo(rect.BottomRight());
									} 
									else
									{
										pDC->Rectangle(rect);
									}
								}
							}
						}
						else if (nDragHandle!=0)//控制点
						{
							if (pObjSelected->GetType()== KEP_TRACK)//道对象
							{
								CTrackObj* pTrackObj = (CTrackObj*)pObjSelected;

								if(nDragHandle == 4)//左右拖拽
								{
									if(pWell->GetWellType() == Well_Incline)
									{
										double h  = pWell->GetTrackHeadHigh();
										CPoint2D tpt1,tpt2;  //tpt1,tpt2是道头底部的横线段
										tpt1.x0 = pWell->GetWellHeadCurve().x[2]; tpt1.y0 = pWell->GetWellHeadCurve().y[2];
										tpt2.x0 = pWell->GetWellHeadCurve().x[3]; tpt2.y0 = pWell->GetWellHeadCurve().y[3];

										if(abs(tpt1.x0-tpt2.x0)>0.0001 && abs(tpt1.y0- tpt2.y0)>0.0001)
										{
											CPoint2D tpt3,tpt4,lastpt;
											lastpt = pXyDC->GetReal(m_lastPoint);
											tpt3 = nsWellPoleFunc::GetVPt_Line(tpt1.x0,tpt1.y0,tpt2.x0,tpt2.y0,lastpt.x0,lastpt.y0);  //tpt3过鼠标点与是道头底部横线向量相交的点
											//tpt4 = GetPtAlongVector(tpt3.x0,tpt3.y0,lastpt.x0,lastpt.y0,h,1);//tpt3,tpt4是与道头底部横线垂直的
											tpt4 = nsWellPoleFunc::GetPtV_Vector(tpt3.x0,tpt3.y0,tpt1.x0,tpt1.y0,tpt2.x0,tpt2.y0,h,1);
											pt1 = pXyDC->GetScreen(tpt3);
											pt2 = pXyDC->GetScreen(tpt4);
											pDC->MoveTo(pt1); pDC->LineTo(pt2);
										}
									}
									else
									{
										CRect8 headrect = pWell->m_HeadRect; 
										pt1.y = pXyDC->GetScreen(headrect).bottom;
										pt2.y = pXyDC->GetScreen(pWell->GetPos()).bottom;

										pt1.x = pt2.x = m_lastPoint.x;
										pDC->MoveTo(pt1); pDC->LineTo(pt2);
									}
								}
							}
							else if(pObjSelected->GetType()== KEP_STANDARD ||
								pObjSelected->GetType()== KEP_FAULTPOINT ||
								pObjSelected->GetType()== KEP_COREWELL)
							{
								//if(GetView()->GetCapture() == pWnd)
								{
									CRect rect = pXyDC->GetScreen(pObjSelected->GetRect());
									pDC->MoveTo(CPoint(rect.left, m_lastPoint.y));
									pDC->LineTo(CPoint(rect.right, m_lastPoint.y));
								}
							}
							else
							{
								//if(GetView()->GetCapture() == pWnd)//绘制拖动的道内对象时需要判断是否当前窗口
								{
									CRect rect = pXyDC->GetScreen(pObjSelected->GetRect());

									if (nDragHandle == 2)
									{
										if (m_lastPoint.y > rect.bottom)
										{
											m_lastPoint.y = rect.bottom;
										}
									} 
									else  if (nDragHandle == 6)
									{
										if (m_lastPoint.y < rect.top)
										{
											m_lastPoint.y = rect.top;
										}
									}
									MoveHandle(nDragHandle, m_lastPoint, rect);
									pDC->Rectangle(rect);
								}

							}
						}
					}
				}
			}
		}

		if(!m_bDrag || m_firstPoint==m_downPoint)
		{
			CPoint2D point;
			//画选中状态
			if(m_WellObjSelectlist.GetCount() == 0)//无选中子对象，画井选中状态
			{
				//画控制点
				point = pWell->GetHandle(4);
				DrawHandle(pXyDC, point);

				point = pWell->GetHandle(8);
				DrawHandle(pXyDC, point);
			}
			else
			{
				POSITION pos = m_WellObjSelectlist.GetHeadPosition();

				CBrush brush; brush.CreateSolidBrush(RGB(95,63,0));
				CPen penLine(PS_DOT, 0, RGB(255,0,0));
				CPen *pOldPenLine = NULL;
				CRect rect, oldrect;
				CWellBaseObj*  pObj = NULL;
				while(pos!=NULL)
				{
					pObj = m_WellObjSelectlist.GetNext(pos);
					rect = pXyDC->GetScreen(pObj->GetRect());
					oldrect = CRect(0,0,0,0);

					if(pObj->GetType()== KEP_TRACK)
					{
						CTrackObj* pTrack = (CTrackObj*)pObj;
						rect = pXyDC->GetScreen(pTrack->m_HeadRect);
						//TRACE("  draw tarck select ");
						if(bInclineWell)
						{
							//pTrack->DrawSelectRange(pXyDC);
							std::vector<CPoint2D> PtsVec;

							pTrack->GetSelectRange(PtsVec);
							DrawSelectPolyRange(pXyDC,PtsVec);
							continue;
						}
					}					
					else
					{//画选中框
						TRACE("  draw in obj select \r\n");
						CWellBaseObj *pParentObj = pObj->GetParent();
						if(pParentObj && bInclineWell)
						{//判断是斜井道内子对象,就自绘制选中状态
							if(pParentObj->GetType() == KEP_TRACK)
							{
								CWellBaseObj *pDrawObj = pObj;
								if(pDrawObj->IsTrackChildTopEnd())
								{
									CInTrackDepthSegment *pTopEndObj = (CInTrackDepthSegment*)pDrawObj;
									std::vector<CPoint2D> PtsVec;

									pTopEndObj->GetSelectRange(PtsVec);
									DrawSelectPolyRange(pXyDC,PtsVec);
									continue;
								}
							}
						}

						rect = pXyDC->GetScreen(pObj->GetSelectedRange());

						pOldPenLine = (CPen *)pDC->SelectObject(&penLine);
						pDC->Rectangle(rect);
						pDC->SelectObject(pOldPenLine);

						//画控制点

						if(pObj->GetType() != KEP_COREWELL)  //取芯数据不画控制点
						{
							point = pObj->GetHandle(2);
							DrawHandle(pXyDC, point);

							if(pObj->GetType()!= KEP_STANDARD &&
								pObj->GetType()!= KEP_FAULTPOINT /*&&*/
								/*pObj->GetType()!=GDOUBLEFOX_COREWELL*/)
							{
								point = pObj->GetHandle(6);
								DrawHandle(pXyDC, point);
							}
							
							//if(pObj->GetType() == GDOUBLEFOX_LOGCURVESEGMENT || 
							//pObj->GetType() == GDOUBLEFOX_DISCRETESEGMENT)
							//{
							//	//写名字
							//	CFont font;
							//	font.CreateFontIndirect(&m_logFont);
							//	CFont* oldFont=pDC->SelectObject(&font);
							//	CTrackCurveObjBase* pTrack = (CTrackCurveObjBase*)pObj->GetParentObj();
							//	pDC->TextOut(rect.left, rect.top, pTrack->m_strTrackName);
							//	pDC->SelectObject(oldFont);
							//}
						}
					}
					//选择范围反色

					rect = GetNegativeRect(&rect);
					rect.left = max(0L,rect.left);
					rect.right = max(0L, rect.right);
					rect.top = max(0L, rect.top);
					rect.bottom = max(0L,rect.bottom);
					rect.InflateRect(1,1);

					pDC->DrawDragRect(&rect,CSize(1,1),&oldrect,CSize(1,1),&brush);
				}
			}
		}

		pDC->SelectObject(pOldPen);
		pen.DeleteObject();
		pDC->SetROP2(old);
	}
	void CItemSingleWell::DrawSelected(CXyDC *pXyDC,CWnd *pWnd)
	{
		DrawMoveSelected(pXyDC,pWnd);
	}

	//BOOL CItemSingleWell::InitPropertyGrid(CXTPPropertyGrid& grid)
	//{
	//	if (!this->IsEditState())
	//		return FALSE;

	//	if(grid.GetSafeHwnd() == NULL)
	//		return FALSE;

	//	grid.ResetContent();

	//	CWellBaseObj* pObjSelected = NULL;
	//	if(m_WellObjSelectlist.GetCount() == 1)
	//		pObjSelected = m_WellObjSelectlist.GetHead();
	//	else if(m_WellObjSelectlist.GetCount() > 1)
	//		return FALSE;

	//	if (pObjSelected != NULL)
	//	{	
	//		if(m_pItemSelected != NULL)
	//		{
	//			if(((CItemWellBase*)m_pItemSelected)->GetDrawObj()==pObjSelected && !m_bEditTrackInData)
	//				return m_pItemSelected->InitPropertyGrid(grid);
	//			else
	//			{
	//				delete m_pItemSelected;
	//				m_pItemSelected = NULL;
	//			}
	//		}
	//	}

	//	CWellPole *pWell = GetWellObject();
	//	if(m_pItemSelected != NULL)
	//		delete m_pItemSelected;
	//	m_pItemSelected = NULL;
	//	CPropertyGridItemAdd ItemAdd(NULL);

	//	//基本属性
	//	CXTPPropertyGridItem *pItem= grid.AddCategory(IDS_STR_WELL_BASICPROPERTY);
	//	ItemAdd.SetItem(pItem);

	//	ItemAdd.AddItemString(IDS_STR_WELL_TITLE, pWell->m_strTitle);//标题

	//	ItemAdd.AddItemString(IDS_STR_WELL_NAME, pWell->GetWellName());//井名


	//	//补心海拔
	//	CString Level;
	//	Level.Format("%.3f", pWell->m_fLevel);
	//	ItemAdd.AddItemString(IDS_STR_WELL_LEVEL, Level);

	//	//深度比例
	//	CXTPPropertyGridItem* ComboxEditSc;
	//	double startvalue;
	//	startvalue = pWell->m_fProportion;
	//	ComboxEditSc =pItem->AddChildItem(new CXTPPropertyGridItemDouble(IDS_STR_WELL_DEPTHSCALER,startvalue));
	//	ComboxEditSc->GetConstraints()->AddConstraint("100");
	//	ComboxEditSc->GetConstraints()->AddConstraint("200");
	//	ComboxEditSc->GetConstraints()->AddConstraint("500");
	//	ComboxEditSc->GetConstraints()->AddConstraint("800");
	//	ComboxEditSc->GetConstraints()->AddConstraint("1000");
	//	ComboxEditSc->GetConstraints()->AddConstraint("1500");
	//	ComboxEditSc->GetConstraints()->AddConstraint("2000");
	//	ComboxEditSc->GetConstraints()->AddConstraint("3000");
	//	ComboxEditSc->GetConstraints()->AddConstraint("5000");
	//	ComboxEditSc->GetConstraints()->AddConstraint("8000");
	//	ComboxEditSc->GetConstraints()->AddConstraint("10000");
	//	ComboxEditSc->GetConstraints()->AddConstraint("50000");
	//	ComboxEditSc->GetConstraints()->AddConstraint("80000");
	//	ComboxEditSc->GetConstraints()->AddConstraint("100000");
	//	ComboxEditSc->SetFlags(xtpGridItemHasComboButton | xtpGridItemHasEdit);	

	//	//CWellSection* pWellSection = (CWellSection*)pWell->GetParentObj();

	//	//if(pWell->GetWellType() == Well_Incline && pWellSection == NULL)
	//	//{//水平比例尺(多井剖面时不需要这个,直接是剖面的水平比例)
	//	//	CInclinedWellObj *pIncWell = (CInclinedWellObj *)pWell;

	//	//	startvalue = pIncWell->m_level_proportion;
	//	//	ComboxEditSc =pItem->AddChildItem(new CXTPPropertyGridItemDouble(IDS_HORIZONTAL_SCALE,startvalue));
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("100");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("200");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("500");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("800");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("1000");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("1500");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("2000");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("3000");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("5000");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("8000");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("10000");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("50000");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("80000");
	//	//	ComboxEditSc->GetConstraints()->AddConstraint("100000");
	//	//	ComboxEditSc->SetFlags(xtpGridItemHasComboButton | xtpGridItemHasEdit);	
	//	//}
	//	////起始深度
	//	//if(pWell->GetWellType() == Well_Incline)
	//	{
	//		CString Sdep;
	//		Sdep.Format("%.3f", pWell->m_dSdep);
	//		ItemAdd.AddItemString(IDS_STR_WELL_TOPDEPTH, Sdep);

	//		//结束深度
	//		CString Edep;
	//		Edep.Format("%.3f", pWell->m_dEdep);
	//		ItemAdd.AddItemString(IDS_STR_WELL_ENDDEPTH, Edep);
	//	}

	//	//左右空白间隔
	//	CString MarginLR;
	//	MarginLR.Format("%.3f", pWell->m_fMarginLR);
	//	ItemAdd.AddItemString(IDS_STR_WELL_MARGINLR, MarginLR);

	//	//上下空白间隔
	//	CString MarginTB;
	//	MarginTB.Format("%.3f", pWell->m_fMarginTB);
	//	ItemAdd.AddItemString(IDS_STR_WELL_MARGINTB, MarginTB);
	//	pItem->Expand();

	//	//if(pWell->GetWellType() != Well_Incline)
	//	//{
	//	//	CXTPPropertyGridItem *pParentGridItem = grid.AddCategory(IDS_STR_WELL_INTERVAL_INFO);
	//	//	
	//	//	AddWellIntervals(pParentGridItem);
	//	//	pParentGridItem->Expand();
	//	//}

	//	if(pWell->GetWellType() == Well_Incline)
	//	{
	//		CString str;
	//		CInclinedWellPole *pInclineWell = (CInclinedWellPole *)pWell;
	//		str.Format("%.3f", pInclineWell->GetProjectionAngle());
	//		ItemAdd.AddItemString(IDS_STR_WELL_PROJECTANGLE, str);
	//	}
	//	//刻度间隔
	//	pItem=grid.AddCategory(IDS_STR_WELL_SPACE_SET);
	//	ItemAdd.SetItem(pItem);

	//	//主刻度间隔
	//	CString MajorSpace;
	//	MajorSpace.Format("%.3f", pWell->m_fMajorSpace);
	//	ItemAdd.AddItemString(IDS_STR_WELL_MAJORSPACE,MajorSpace);

	//	//副刻度间隔
	//	CString MinorSpace;
	//	MinorSpace.Format("%.3f", pWell->m_fMinorSpace);
	//	ItemAdd.AddItemString(IDS_STR_WELL_MINORSPACE, MinorSpace);
	//	pItem->Expand();


	//	//字体
	//	pItem=grid.AddCategory(IDS_STR_FONT);
	//	ItemAdd.SetItem(pItem);

	//	ItemAdd.AddItemFont(IDS_STR_WELL_FONT, pWell->m_font.m_logFont, pWell->m_font.m_color);

	//	ItemAdd.AddItemFont(IDS_STR_WELL_FONTTRACK, pWell->m_fontTrack.m_logFont,pWell->m_fontTrack.m_color);

	//	ItemAdd.AddItemFont(IDS_STR_WELL_FONTHEADMARK, pWell->m_fontHeadMark.m_logFont, pWell->m_fontHeadMark.m_color);

	//	ItemAdd.AddItemFont(IDS_STR_WELL_FONTGRIDMARK, pWell->m_fontGridMark.m_logFont , pWell->m_fontGridMark.m_color);

	//	pItem->Expand();

	//	//线属性
	//	pItem= grid.AddCategory(IDS_STR_WELL_LINEPROPERTY);
	//	ItemAdd.SetItem(pItem);

	//	ItemAdd.AddItemLine1(IDS_STR_WELL_LINE, pWell->m_pen, &pWell->m_pen , LineType_Frame);

	//	ItemAdd.AddItemLine1(IDS_STR_WELL_LINETRACK, pWell->m_penTrack, &pWell->m_penTrack , LineType_Curve);

	//	ItemAdd.AddItemLine1(IDS_STR_WELL_LINEMAJORGRID, pWell->m_penGridMajor, &pWell->m_penGridMajor, LineType_Curve);

	//	ItemAdd.AddItemLine1(IDS_STR_WELL_LINEMINORGRID, pWell->m_penGridMinor, &pWell->m_penGridMinor, LineType_Curve);

	//	pItem->Expand();


	//	//CItem::InitPropertyGrid(grid);

	//	return TRUE;
	//}
	//
	//void CItemSingleWell::OnInplaceButtonDown(CXTPPropertyGridItem* pItem)
	//{
	//	//if(pItem == NULL) 
	//	//	return;
	//	//if(pItem->GetID() == IDS_STR_WELLDEPTHSETUP && m_pWell != NULL)
	//	//{
	//	//	CDialogWellIntervalSetup dlg;

	//	//	for(int ii = 0; ii< m_pWell->GetIntervalVec()->size(); ii++)
	//	//	{
	//	//		dlg.m_wellTopVec.push_back(m_pWell->GetIntervalTop(ii));
	//	//		dlg.m_wellBottomVec.push_back(m_pWell->GetIntervalBottom(ii));
	//	//	}

	//	//	if(dlg.DoModal() == IDOK)
	//	//	{
	//	//		if(dlg.m_wellTopVec.size()>0)
	//	//		{
	//	//			m_pWell->GetIntervalVec()->clear();

	//	//			for(int ii =0 ;ii< dlg.m_wellTopVec.size(); ii++)
	//	//			{
	//	//				m_pWell->AddWellInterval(dlg.m_wellTopVec[ii],dlg.m_wellBottomVec[ii]);
	//	//			}

	//	//			m_pWell->m_fSdep = m_pWell->GetIntervalTop(0);
	//	//			m_pWell->m_fEdep = m_pWell->GetIntervalBottom(m_pWell->GetIntervalVec()->size()-1);
	//	//			m_pWell->SetIntervalSpaceDis(0,0);

	//	//			m_pWell->ComputeSize(m_pWell->GetAnchorPoint());
	//	//			m_pWell->ReadCurveData();
	//	//			m_pWell->ResetChildPosition();

	//	//			CXTPPropertyGrid &grid = GetPropertyGrid(GetDoc()->GetActiveFrame()->GetMapCtrl());
	//	//			CXTPPropertyGridItems *pItems = grid.GetCategories();

	//	//			CXTPPropertyGridItem *pItem1;
	//	//			int cateNum = pItems->GetCount();
	//	//			int id ;
	//	//			for(int ii = 0; ii< cateNum; ii++)
	//	//			{
	//	//				pItem1 = pItems->GetAt(ii);
	//	//				id = pItem1->GetID();
	//	//				if(id == IDS_STR_WELL_INTERVAL_INFO)
	//	//				{
	//	//					pItem1->GetChilds()->Clear();

	//	//					AddWellIntervals(pItem1);

	//	//					break;
	//	//				}
	//	//			}

	//	//			重设滚动条
	//	//			SetScrollBarRange();
	//	//			GetDoc()->Invalidate();
	//	//		}
	//	//	}
	//	//}
	//}
	//
	//void CItemSingleWell::SetScrollBarRange()
	//{
	//	//CMapFrame2D& mapFrame2D = GetWnd()->GetMapFrame()->GetMapFrame2D();
	//	//for(int i=mapFrame2D.m_SplitterWnd.GetCount()-1; i>-1; i--)
	//	//{
	//	//	mapFrame2D.m_SplitterWnd[i].pMapWnd2D->SetScrollBarRange();
	//	//}
	//}

	//BOOL CItemSingleWell::OnGridItemChangeValue(CXTPPropertyGridItem* pItem)
	//{
	//	if(m_pItemSelected != NULL)
	//		return m_pItemSelected->OnGridItemChangeValue(pItem);

	//	if(!IsEditState())
	//		return FALSE;

	//	CWellPole *pWell = GetWellObject();
	//	CRect oldrect = GetDC()->GetScreen(pWell->GetRect());
	//	CWellPoleDoc* pWellDoc = (CWellPoleDoc*)GetDoc();

	//	double dOldSdep = pWell->m_dSdep;
	//	double dProp = pWell->m_fProportion;
	//	double dOldProp = pWell->m_fProportion;
	//	double dDelDepth = 0;
	//	switch (pItem->GetID())
	//	{
	//	case IDS_STR_WELL_NAME://井名
	//		{
	//			pWell->SetWellName(pItem->GetValue());
	//			pWell->SetTitle(pWell->GetWellName());
	//			CXTPPropertyGridItem *pItemFind=FindItem(pItem, IDS_STR_WELL_TITLE);
	//			pItemFind->SetValue(pWell->GetWellName());
	//		}
	//		break;

	//	case IDS_STR_WELL_TITLE://标题
	//		{
	//			pWell->SetTitle(pItem->GetValue());
	//		}
	//		break;		

	//	case IDS_STR_WELL_FONT:// 标题字体
	//		{
	//			((CXTPPropertyGridItemFont*)pItem)->GetFont(&pWell->m_font.m_logFont);
	//			pWell->m_font.m_color = ((CXTPPropertyGridItemFont*)pItem)->GetColor();
	//			
	//			pWellDoc->NormalEXTLogFont(pWell->m_font);	

	//			//重新设置道内子对象位置
	//			double dOldWellHead = pWell->m_dHeightWellHead;
	//			pWell->ReSetWellHead();
	//			double dNewWellHead = pWell->m_dHeightWellHead;

	//			if(fabs(dNewWellHead - dOldWellHead) > ZERO)
	//			{
	//				CPoint2D pt = pWell->GetAnchorPoint(); //pWell->GetPos().TopLeft();
	//				pt.y0 += (dNewWellHead-dOldWellHead);
	//				pWell->CalculateSize(pt);
	//			}				
	//		}
	//		break;

	//	case IDS_STR_WELL_FONTTRACK:// 道头字体
	//		{
	//			((CXTPPropertyGridItemFont*)pItem)->GetFont(&pWell->m_fontTrack.m_logFont);
	//			pWell->m_fontTrack.m_color = ((CXTPPropertyGridItemFont*)pItem)->GetColor();
	//			pWellDoc->NormalEXTLogFont(pWell->m_fontTrack);
	//			pWell->SetFontTrack(pWell->m_fontTrack);	
	//		}
	//		break;

	//	case IDS_STR_WELL_FONTHEADMARK:// 道头刻度字体
	//		{
	//			((CXTPPropertyGridItemFont*)pItem)->GetFont(&pWell->m_fontHeadMark.m_logFont);
	//			pWell->m_fontHeadMark.m_color = ((CXTPPropertyGridItemFont*)pItem)->GetColor();
	//			pWellDoc->NormalEXTLogFont(pWell->m_fontHeadMark);
	//			//pWell->SetFontHeadMark(pWell->m_fontHeadMark);
	//		}
	//		break;

	//	case IDS_STR_WELL_FONTGRIDMARK:// 深度刻度字体
	//		{
	//			((CXTPPropertyGridItemFont*)pItem)->GetFont(&pWell->m_fontGridMark.m_logFont);
	//			pWell->m_fontGridMark.m_color = ((CXTPPropertyGridItemFont*)pItem)->GetColor();
	//			pWellDoc->NormalEXTLogFont(pWell->m_fontGridMark);
	//			pWell->SetFontGridMark(pWell->m_fontGridMark);
	//		}
	//		break;

	//	case IDS_STR_WELL_LINETRACK://道框 
	//		{
	//			pWell->SetPenTrack(pWell->m_penTrack);
	//		}
	//		break;

	//	case IDS_STR_WELL_LINEMAJORGRID://主刻格线 
	//		{
	//			pWell->SetPenGrid(pWell->m_penGridMajor, pWell->m_penGridMinor);
	//		}
	//		break;

	//	case IDS_STR_WELL_LINEMINORGRID://次刻格线 
	//		{
	//			pWell->SetPenGrid(pWell->m_penGridMajor, pWell->m_penGridMinor);
	//		}
	//		break;
	//	case IDS_STR_WELL_MAJORSPACE:// 主深度标注间隔
	//		{
	//			pWell->m_fMajorSpace=atof(pItem->GetValue());
	//			pWell->SetSpace(pWell->m_fMajorSpace, pWell->m_fMinorSpace);
	//		}
	//		break;

	//	case IDS_STR_WELL_MINORSPACE:// 副深度标注间隔
	//		{
	//			pWell->m_fMinorSpace=atof(pItem->GetValue());
	//			pWell->SetSpace(pWell->m_fMajorSpace, pWell->m_fMinorSpace);
	//		}
	//		break;
	//	case  IDS_STR_WELL_TOPDEPTH:// 起始深度
	//		{	
	//			double fSdep;
	//			fSdep = atof(pItem->GetValue());
	//			pWell->m_dSdep=fSdep;

	//			if (fSdep>pWell->m_dEdep)
	//			{
	//				pWell->m_dSdep = pWell->m_dEdep;
	//			}
	//			CWellPoleView* pWellView = (CWellPoleView*)GetView();
	//			if (pWellView->m_bLockWellHead)
	//			{
	//				pWellView->ReComputeLockWellHead();
	//			}
	//			else
	//			{
	//				pWell->SetIntervalTop(0, pWell->m_dSdep);
	//				pWell->ReadCurveData();
	//				pWell->CalculateSize(pWell->GetAnchorPoint());
	//				pWell->ResetChildPosition();

	//				CreateVHCursor();  //斜井如果起始深度调整,有可能影响光标变化
	//				//重设滚动条
	//				SetScrollBarRange();
	//			}
	//		}
	//		break;

	//	case  IDS_STR_WELL_ENDDEPTH:// 结束深度
	//		{
	//			double fEdep;
	//			fEdep = atof(pItem->GetValue());
	//			pWell->m_dEdep=fEdep;

	//			if (fEdep<pWell->m_dSdep)
	//			{
	//				pWell->m_dEdep = pWell->m_dSdep;
	//			}

	//			CWellPoleView* pWellView = (CWellPoleView*)GetView();
	//			if (pWellView->m_bLockWellHead)
	//			{
	//				pWellView->ReComputeLockWellHead();
	//			}
	//			else
	//			{
	//				pWell->SetIntervalBottom(pWell->GetIntervalVec()->size() - 1, pWell->m_dEdep);
	//				pWell->ReadCurveData();
	//				pWell->CalculateSize(pWell->GetAnchorPoint());
	//				pWell->ResetChildPosition();
	//				//重设滚动条
	//				SetScrollBarRange();
	//			}
	//		}
	//		break;

	//	case  IDS_STR_WELL_MARGINLR:// 左右空白范围
	//		{					
	//			if (atof(pItem->GetValue())>=0)
	//			{
	//				pWell->m_fMarginLR=atof(pItem->GetValue());
	//				//重设滚动条
	//				SetScrollBarRange();
	//			} 
	//		}
	//		break;

	//	case IDS_STR_WELL_MARGINTB:// 上下空白范围
	//		{
	//			if (atof(pItem->GetValue())>=0)
	//			{
	//				pWell->m_fMarginTB=atof(pItem->GetValue());
	//				//重设滚动条
	//				SetScrollBarRange();
	//			} 					
	//		}
	//		break;

	//	case IDS_STR_WELL_DEPTHSCALER:// 深度比例
	//		{
	//			pWell->m_fProportion=atof(pItem->GetValue());
	//			CWellPoleView* pWellView = (CWellPoleView*)GetView();
	//			if (pWellView->m_bLockWellHead)
	//			{
	//				pWellView->ReComputeLockWellHead();
	//			}
	//			else
	//			{
	//				pWell->CalculateSize(pWell->GetAnchorPoint());
	//				//重设滚动条
	//				SetScrollBarRange();
	//			}
	//		}
	//		break;
	//	case IDS_HORIZONTAL_SCALE:
	//		{
	//			pWell->m_level_proportion=atof(pItem->GetValue());
	//			pWell->CalculateSize(pWell->GetAnchorPoint());				//重设滚动条
	//			SetScrollBarRange();
	//		}
	//		break;
	//	case IDS_STR_WELL_PROJECTANGLE:
	//		{
	//			if(pWell->GetWellType() == Well_Incline)
	//			{
	//				CInclinedWellPole *pIncWell = (CInclinedWellPole*)pWell;
	//				pIncWell->SetProjectionAngle(atof(pItem->GetValue()));
	//				pIncWell->ComputeTrajectory();
	//				pIncWell->CalculateSize(pIncWell->GetAnchorPoint());

	//				//CRaconObj *pRaconObj = ((CMapWellDoc*)GetDoc())->GetWellRaconObj();
	//				//if(pRaconObj)
	//				//	 pRaconObj->m_prejectionang = pIncWell->GetProjectionAngle();
	//			}
	//		}
	//		break;
	//	default:
	//		break;
	//	}
	//	dProp = pWell->m_fProportion;
	//	dDelDepth = pWell->m_dSdep - dOldSdep;

	//	//重新设置道内子对象位置
	//	if(fabs(dOldProp-dProp) > ZERO || fabs(dDelDepth) > ZERO)
	//	{
	//		pWell->ResetChildPosition(dOldProp, dProp, dDelDepth);
	//	}
	//	GetDoc()->Invalidate();

	//	return TRUE;//CItem::OnGridItemChangeValue(pItem);
	//}


	bool CItemSingleWell::AddTrack()
	{
		CWellPole* pWellPole = GetWellObject();
	
		return AddTrackDlg(pWellPole,NULL);
	}

	bool CItemSingleWell::AddTrackDlg(CWellPole* pWellObj, CTrackObj* pSelectTrack)
	{

		//CDlgAddTrack dlg;
		//if (dlg.DoModal() != IDOK)
		//{
		//	return false;
		//}
		//if (dlg.m_SelectTrackTypes.size() == 0)
		//	return false;

		//TRACKLIST trackList;
		//CTrackObj* pTrackObj = NULL;
		//CString strTrack,str;
		//strTrack.LoadString(IDS_STR_TRACK);
		//for (int ii = 0; ii < dlg.m_SelectTrackTypes.size(); ii++)
		//{
		//	pTrackObj = CTrackObj::CreateTrackObj(ETrackType(dlg.m_SelectTrackTypes[ii].type));
		//	str = dlg.m_SelectTrackTypes[ii].trackName;
		//	int pos = str.Find(strTrack);
		//	if (pos > 0)//去掉 “道" 
		//		str = str.Left(pos);

		//	pTrackObj->m_strTrackName = pTrackObj->m_strTitle = str;

		//	trackList.push_back(pTrackObj);
		//}

		//AddTrack(pSelectTrack, trackList);

		return true;
	}


	BOOL CItemSingleWell::AddTrack(CTrackObj* pSelectTrack,int trackType[], int trackNum)
	{
		TRACKLIST trackList;
		CTrackObj* pTrackObj = NULL;
		CString strTrack,str;
		strTrack = "道";
		for (int ii = 0; ii < trackNum; ii++)
		{
			pTrackObj = CTrackObj::CreateTrackObj(ETrackType(trackType[ii]));
			CWellObjExtendInfo objInfo;
			CWellObjExtendInfoMgr::GetInstance()->GetTypeInfo(trackType[ii], objInfo);
			str = objInfo.m_cTypeStr;
			int pos = str.Find(strTrack);
			if (pos > 0)//去掉 “道" 
				str = str.Left(pos);

			pTrackObj->m_strTrackName = pTrackObj->m_strTitle = str;

			trackList.push_back(pTrackObj);
		}

		AddTrack(pSelectTrack, trackList);
		return TRUE;
	}

	CTrackObj* CItemSingleWell::GetSelectedTrack()
	{
		if(m_WellObjSelectlist.GetCount() == 1)
		{
			CWellBaseObj* pObjSelected = m_WellObjSelectlist.GetHead();
			if (pObjSelected->GetType() == KEP_TRACK)
			{
				return (CTrackObj*)pObjSelected;
			}
		}

		return NULL;
	}

	bool CItemSingleWell::AddTrackAfterSelected()
	{
		CTrackObj* pTrackSelected = NULL;
		CWellBaseObj* pObjSelected = NULL;
		if(m_WellObjSelectlist.GetCount() > 0)
			pObjSelected = m_WellObjSelectlist.GetHead();
		if (pObjSelected->GetType() == KEP_TRACK)
		{
			pTrackSelected = (CTrackObj*)pObjSelected;
		}
		if (NULL == pTrackSelected)
		{
			return false;
		}

		AddTrackDlg(GetWellObject(), pTrackSelected);
		return true;
	}

	void CItemSingleWell::AddTrack(CTrackObj* pTrackSelected, TRACKLIST& trackAddList, BOOL bTrackGroup)
	{//增加到道的几种情况，（1、井直接加道，加到井最后）（2、选中了一个井道增加，加到此井道的后面）
		//（3、选中了一组合道中的子道，加入此组合道内选中的井口道）（4、将增加的道与选中的道组合一下，然后将这个组合道加入，这个功能生成多个曲线道时或数据道时可以试用）
		CTrackObj* pTrackObj = NULL;
		BOOL bAddTrackCurve = FALSE;
		TRACKLIST::iterator it = trackAddList.begin();
		for(; it != trackAddList.end(); it++)
		{
			pTrackObj = *it; 
			if(pTrackObj->GetTrackType()==Track_Curve || pTrackObj->GetTrackType()==Track_Discrete)
			{
				bAddTrackCurve = TRUE;
				break;
			}
		}

		//备份
		SetReUnDoAction(!bAddTrackCurve);

		CWellBaseObj*  pObj = NULL;
		CTrackObj* pTrack = NULL;
		CWellPole* pWellObj = (CWellPole*)GetWellObject();
		CTrackGroup* pGroupParent = pWellObj;
		BOOL posSlected = FALSE;
		if(pTrackSelected)
		{
			pGroupParent = (CTrackGroup*)pTrackSelected->GetParent();
			posSlected = pGroupParent->FindTrack(pTrackSelected,true);

			if(pGroupParent->GetTrackType() != Track_Group && posSlected && bTrackGroup)
			{//将trackAddList中的道组合一下，然后加入，并将pTrackSelected也加入其中，
				pGroupParent = new CTrackGroup();
				pGroupParent->SetGroupType(Group_Vertical);
				pGroupParent->m_font = pWellObj->m_font;
				pGroupParent->m_pen = pWellObj->m_pen;
				pGroupParent->m_HeadRect = pTrackSelected->m_HeadRect;
				pGroupParent->SetRange(pTrackSelected->m_HeadRect);
				pGroupParent->m_dTrackWidth = pTrackSelected->m_dTrackWidth;
				pGroupParent->SetParent(pWellObj);
				pGroupParent->SetParentXY(pWellObj->GetParentXY());

				pGroupParent->AddTrack(pTrackSelected);

				TRACKLIST::const_iterator cit = std::find(pWellObj->GetTrackList().begin(), pWellObj->GetTrackList().end(), pTrackSelected);
				pWellObj->GetTrackList().insert(cit, pGroupParent);

				cit = std::find(pWellObj->GetTrackList().begin(), pWellObj->GetTrackList().end(), pTrackSelected);
				pWellObj->GetTrackList().erase(cit);
			}
		}

		TRACKLIST tracklist;
		pWellObj->GetAllTrack(&tracklist);

		//CDataTableConfig  dataConfig;
		CString strTrackType, tableinfo, strcurvename;
		CString str, strRight;
		int nNumber = -1;
		int nIndex = 0;
		CString strNumber;
		
		TRACKLIST::iterator itpos;
		if (pTrackSelected)
		{
			itpos = std::find(pGroupParent->GetTrackList().begin(), pGroupParent->GetTrackList().end(), pTrackSelected); //选中道在新道集中的位置
			if (itpos != pGroupParent->GetTrackList().end())
				itpos++;  //使新道加入选中道的后面
		}
		it = trackAddList.begin();
		for(; it!= trackAddList.end(); it++)
		{ //将传入链表中的道加入到新建立的道组中
			pTrackObj = *it;
			pTrackObj->SetParent(pGroupParent);
			//pTrackObj->SetParentObj(pWellObj);
			pTrackObj->SetParentXY(pWellObj->GetParentXY());
			pTrackObj->SetPenTrack(pWellObj->m_penTrack);
			pTrackObj->SetPenGrid(pWellObj->m_penGridMajor, pWellObj->m_penGridMinor);
			pTrackObj->SetFontTrack(pWellObj->m_fontTrack);
			pTrackObj->SetFontHeadMark(pWellObj->m_fontHeadMark);
			pTrackObj->SetFontGridMark(pWellObj->m_fontGridMark);
			pTrackObj->SetSpace(pWellObj->m_fMajorSpace, pWellObj->m_fMinorSpace);

			/////判断新添加的道与已有道是否重名， 若重名则在添加一个编号
			nNumber = -1;
			str = pTrackObj->m_strTrackName;
			str.MakeUpper();
			TRACKLIST::iterator it1 = tracklist.begin();
			for (; it1 != tracklist.end(); it1++)
			{
				CWellBaseObj*  pObj = *it1; 
				if (pObj->GetType() == KEP_TRACK)
				{
					CTrackObj* pTrack = (CTrackObj*)pObj;
					CString strTrackName = pTrack->m_strTrackName;
					strTrackName.MakeUpper();
					nIndex = strTrackName.Find(str);
					if(nIndex > -1)
					{
						strRight = strTrackName.Right(strTrackName.GetLength()-str.GetLength()-nIndex);
						nNumber = max(nNumber,atoi(strRight));
					}
				}
			}
			if(nNumber > -1)
			{
				str.Format("%d", ++nNumber);
				pTrackObj->m_strTrackName += str;
			}

			//添加道
			if (posSlected)
			{
				pGroupParent->GetTrackList().insert(itpos, pTrackObj); // InsertAfter(posSlected, pTrackObj);
				pTrackObj->m_dTrackWidth = pTrackSelected->GetWidth();
			}
			else
				pGroupParent->GetTrackList().push_back(pTrackObj);

			if (GetWellObject()->GetWellType()==Well_Straight)
			{
				str = pTrackObj->m_strTrackName;
			}
			else
			{
				str = pTrackObj->m_strTrackName+"/"+pWellObj->m_strTrackName;
			}
			pTrackObj->m_strTitle = pTrackObj->m_strTrackName;
			pTrackObj->m_strDataRef = str;


			//tracklist.AddTail(pTrackObj);
		}
		CPoint2D ptf = pWellObj->GetAnchorPoint(); //->GetPos().TopLeft();
		pWellObj->CalculateSize(ptf);

		//this->SetActionAddTrackItem(trackAddList);

		//自动增加道数据配置，并读取数据
		//pos = trackAddList.GetHeadPosition();
		//while(pos != NULL)
		//{
		//	pTrackObj = trackAddList.GetNext(pos);

		//	GetTrackTable(pTrackObj, strTrackType, tableinfo, strcurvename);
		//	dataConfig.SetTableID(strTrackType);
		//	dataConfig.Read();
		//	pTrackObj->m_strConfigTable = dataConfig.GetTableDB();
		//	pTrackObj->m_VecConfigField = dataConfig.GetFieldsDB();
		//	ImportTrackDataFromDB(pTrackObj, pWellObj, AfxGetGeo()->GetSqlStatementManager());
		//	pTrackObj->ReadCurveData();
		//}

		GetDoc()->Invalidate();
	}

	CTrackObj* CItemSingleWell::GetLastTrackFromTrackGroup(CTrackGroup* trackGroupObj)
	{
		CTrackObj* pTrack = NULL;
		TRACKLIST::reverse_iterator rit = trackGroupObj->GetTrackList().rbegin();
		if (rit != trackGroupObj->GetTrackList().rend())
		{
			pTrack = *rit;
			if (pTrack->GetTrackType() == Track_Group)
			{
				pTrack = GetLastTrackFromTrackGroup((CTrackGroup*)pTrack);
			}
			else
			{
				return pTrack;
			}
		}
		return pTrack;
	}

	CItemWellBase* CItemSingleWell::CreateItem(CWellBaseObj*  pObj)
	{
		CItemWellBase* pItem = NULL;
		if(pObj->GetType() == KEP_TRACK)
		{
			pItem = new CItemTrack(GetDoc());
			pItem->SetPos(GetPos());
			pItem->SetDrawObj(pObj);
			pItem->SetItemWell(this);
		}
		else if(pObj->GetParent() != NULL && pObj->GetParent()->GetType() == KEP_TRACK)
		{
			pItem = new CItemTrackIn(GetDoc());
			pItem->SetPos(GetPos());
			((CItemTrackIn*)pItem)->SetDrawObj(pObj);
			pItem->SetItemWell(this);
		}
		//else if (pObj->GetType()==GDOUBLEFOX_LOGCURVESEGMENT)
		//{
		//	pItem = new CItemTrackInCurveSegment(GetWnd());
		//	pItem->SetPos(GetPos());
		//	CTrackInCurveSegment* pTrackInCurveSegment = (CTrackInCurveSegment*)pObj;
		//	((CItemTrackInCurveSegment*)pItem)->SetTracCurve(pTrackInCurveSegment->m_pCurve);
		//	((CItemTrackInCurveSegment*)pItem)->SetDrawObj(pObj);
		//	pItem->SetItemWell(this);
		//}
		//else if(pObj->GetType() == GDOUBLEFOX_MARK)
		//{
		//	//pItem = new CItemWellMark(GetWnd());
		//	//pItem->SetPos(GetPos());
		//	//((CItemWellMark*)pItem)->SetDrawObj(pObj);
		//	//pItem->SetItemWell(this);
		//}
		//else if (pObj->GetType()==GDOUBLEFOX_TEXTBOX)
		//{
		//	//pItem = new CItemTextBox(GetWnd());
		//	//pItem->SetPos(GetPos());
		//	//((CItemTextBox*)pItem)->SetDrawObj(pObj);
		//	//pItem->SetItemWell(this);
		//}
		return pItem;
	}

	void CItemSingleWell::DeleteItem()
	{
		CItemWellBase::DeleteItem();

		CWellPole *pWell = GetWellObject();
		m_WellObjSelectlist.RemoveAll();
	}

	void CItemSingleWell::CreateDragImage()
	{
		CWellBaseObj* pObjSelected = NULL;
		if(m_WellObjSelectlist.GetCount() == 1)
			pObjSelected = m_WellObjSelectlist.GetHead();

		if(pObjSelected == NULL)
			return;

		CRect rect = GetDC()->GetScreen(pObjSelected->GetRect());
		CRect inclineWellRect ;
		BOOL bTrack = FALSE;
		CPoint plgPts[4];
		if(pObjSelected->GetType() == KEP_TRACK)
		{
			CTrackObj *pTrackObj = (CTrackObj *)pObjSelected;
			//rect = GetDC()->GetScreen(pTrackObj->m_HeadRect);
			rect = GetDC()->GetScreen(pTrackObj->GetDragMoveRect()); // (pTrackObj->GetRect()); //绘制大拖动框
			rect.InflateRect(2, 2, 2, 2);
			if(m_pWell->GetWellType() == Well_Incline)
			{
				CPoint topleftPt,botRightPt,tpt;

				if(pTrackObj->GetTrackType() == Track_Group)
				{
				/*	CPoint2D pospts[4];
					pospts[0].x0 = pTrackObj->m_HeadRect.left; pospts[0].y0 = pTrackObj->m_HeadRect.top;
					pospts[1].x0 = pTrackObj->m_HeadRect.right; pospts[1].y0 = pTrackObj->m_HeadRect.top;
					pospts[2].x0 = pTrackObj->m_HeadRect.right; pospts[2].y0 = pTrackObj->m_HeadRect.bottom;
					pospts[3].x0 = pTrackObj->m_HeadRect.left; pospts[3].y0 = pTrackObj->m_HeadRect.bottom;

					for(int ii = 0; ii< 4; ii++)
					{
						pospts[ii].RotatePt(m_pWell->GetTraceStartPt().x0,m_pWell->GetTraceStartPt().y0,m_pWell->GetHeadLineAngle());
					}

					botRightPt = topleftPt = GetDC()->GetScreen(pospts[0].x0,pospts[0].y0);
					plgPts[0] = botRightPt;
					for(int ii =1;ii<4; ii++)
					{
						tpt = GetDC()->GetScreen(pospts[ii].x0,pospts[ii].y0);
						plgPts[ii] = tpt;
						if(tpt.x <topleftPt.x)
							topleftPt.x = tpt.x;
						if(tpt.x>botRightPt.x)
							botRightPt.x = tpt.x;
						if(tpt.y< topleftPt.y)
							topleftPt.y = tpt.y;
						if(tpt.y>botRightPt.y)
							botRightPt.y  = tpt.y;

						inclineWellRect.SetRect(topleftPt,botRightPt);
					}*/
				}
				else
				{
					botRightPt = topleftPt = GetDC()->GetScreen(pTrackObj->m_HeadCurve.x[0],pTrackObj->m_HeadCurve.y[0]);
					plgPts[0] = botRightPt;
					for(int ii =1;ii<4; ii++)
					{
						tpt = GetDC()->GetScreen(pTrackObj->m_HeadCurve.x[ii],pTrackObj->m_HeadCurve.y[ii]);
						plgPts[ii] = tpt;
						if(tpt.x <topleftPt.x)
							topleftPt.x = tpt.x;
						if(tpt.x>botRightPt.x)
							botRightPt.x = tpt.x;
						if(tpt.y< topleftPt.y)
							topleftPt.y = tpt.y;
						if(tpt.y>botRightPt.y)
							botRightPt.y  = tpt.y;

						inclineWellRect.SetRect(topleftPt,botRightPt);
					}
				}

				bTrack = TRUE;
			}
		}		
		//else if (pObjSelected->GetType()==GDOUBLEFOX_LOGCURVESEGMENT)
		//{
		//	CTrackInCurveSegment* pSegment = (CTrackInCurveSegment*)pObjSelected;
		//	rect = GetDC()->GetScreen(pSegment->GetPos());
		//}
		//else if (pObjSelected->GetType()==GDOUBLEFOX_DISCRETESEGMENT)
		//{
		//	CTrackInDiscreteSegment* pDiscreteSegment = (CTrackInDiscreteSegment*)pObjSelected;
		//	rect = GetDC()->GetScreen(pDiscreteSegment->GetPos());
		//}
		else
			return;

		if(m_pWell->GetWellType() == Well_Incline)
			m_rectImage = inclineWellRect;
		else
			m_rectImage = rect;

		CBitmap* pBitmap = GetBitmap(m_pScreenDC/*GetDC()->GetDC()*/, rect, inclineWellRect, bTrack, (CPoint*)plgPts);
		if (pBitmap == NULL)
			return;
		//// Create a drag image
		m_pDragImage = new CImageList;//m_wndList.CreateDragImage(m_nDragIndex, &pt);
		m_pDragImage->Create(m_rectImage.Width(), m_rectImage.Height(), ILC_COLOR24|ILC_MASK,0,0);
		ASSERT(m_pDragImage); //make sure it was created
		//We will call delete later (in LButtonUp) to clean this up
		m_pDragImage->Add(pBitmap, RGB(255,255,255));
		delete pBitmap;
	}

	CBitmap* CItemSingleWell::GetBitmap(CDC* pdc,CRect wellHRect,CRect ilnWellHRect,BOOL bTrack,CPoint *plgPts)
	{
		CWellBaseObj* pObjSelected = NULL;
		if(m_WellObjSelectlist.GetCount() == 1)
			pObjSelected = m_WellObjSelectlist.GetHead();

		CRect rect = wellHRect; //m_rectImage;

		CDC dc;	
		BOOL b = dc.CreateCompatibleDC(pdc);
		if (b == FALSE)
		{
			DWORD error = GetLastError();
			return NULL;
		}
		CXyDC xyDC; 
		xyDC = *GetDC();
		xyDC.Create(&dc);

		CRect rt = CRect(0, 0, rect.Width(), rect.Height());
		int planes = dc.GetDeviceCaps(PLANES);
		int bpp = dc.GetDeviceCaps(BITSPIXEL);

		CBitmap *pBitmap,*pOldBitmap;
		pBitmap=new CBitmap();
		pBitmap->CreateBitmap(rt.Width(),rt.Height(),planes,bpp,NULL);
		pOldBitmap = dc.SelectObject(pBitmap);
		dc.FillSolidRect(0,0,rt.Width(),rt.Height(),RGB(255,255,255));
		if(pObjSelected!=NULL)
		{
			CRect8 rectReal = xyDC.GetReal(rect);
			xyDC.Extend(rectReal,rt,EXTEND_MODE_CENTER);

			if (pObjSelected->GetType()== KEP_TRACK)
			{
				CTrackObj* pTrackObj = (CTrackObj*)pObjSelected;
				pTrackObj->DrawActiveTrackHead(&xyDC);

				GDFLOGPEN pen = pTrackObj->m_pen;
				pen.m_color = RGB(230, 35, 35);
				pen.m_dWidth = 4;
				CRect8 rect = pTrackObj->GetDragMoveRect(); // pTrackObj->GetRect();//绘制大拖动框
				xyDC.DrawRect(rect, pen);
			}
			//else if (pObjSelected->GetType()==GDOUBLEFOX_LOGCURVESEGMENT || 
			//	pObjSelected->GetType() ==GDOUBLEFOX_DISCRETESEGMENT)
			//{
			//	pObjSelected->Draw(xyDC);
			//}
		}
		dc.SelectObject(pOldBitmap);

		if(m_pWell->GetWellType() == Well_Incline && bTrack)
		{
			CRect ilnrt = CRect(0, 0, ilnWellHRect.Width(), ilnWellHRect.Height());

			CBitmap *pplgBitmap,*pplgOldBitmap;
			pplgBitmap=new CBitmap();
			pplgBitmap->CreateBitmap(ilnrt.Width(),ilnrt.Height(),planes,bpp,NULL);
			pplgOldBitmap = dc.SelectObject(pplgBitmap);
			dc.FillSolidRect(0,0,ilnrt.Width(),ilnrt.Height(),RGB(255,255,255));

			CDC memDC;
			memDC.CreateCompatibleDC(&dc);
			CBitmap maskBmp;
			ZeroMemory((void*)(&maskBmp),sizeof(maskBmp));

			memDC.SelectObject(pBitmap);

			CPoint points[3];
			points[0] = plgPts[0]; points[0].Offset(-ilnWellHRect.left,-ilnWellHRect.top);
			points[1] = plgPts[1]; points[1].Offset(-ilnWellHRect.left,-ilnWellHRect.top);
			points[2] = plgPts[3]; points[2].Offset(-ilnWellHRect.left,-ilnWellHRect.top);

			dc.PlgBlt(points,&memDC,0,0,wellHRect.Width(),wellHRect.Height(),maskBmp,0,0);

			dc.SelectObject(&pplgOldBitmap);
			memDC.Detach();
			//maskBmp.DeleteObject();

			delete pBitmap;

			pBitmap = pplgBitmap;
		}
		dc.Detach();

		return pBitmap;
	}

	void CItemSingleWell::TrackLeftGroup()
	{
		CWellPole* pWellObj = GetWellObject();
		CTrackObj* pTrackObj = NULL;
		CWellBaseObj* pObjSelected = NULL;
		if(m_WellObjSelectlist.GetCount() == 1)
			pObjSelected = m_WellObjSelectlist.GetHead();

		if (pObjSelected->GetType()== KEP_TRACK)
		{
			pTrackObj = (CTrackObj*)pObjSelected;
		}

		if(pTrackObj==NULL)
			return;

		CTrackGroup* pParentGroup = (CTrackGroup*)pTrackObj->GetParent(); // GetParentGroup();
		POSITION posFind = NULL;
		POSITION pos =NULL;

		TRACKLIST::iterator it = pParentGroup->GetTrackList().begin();
		if (it == pParentGroup->GetTrackList().end())
			return;
		if (*it == pTrackObj) // 如果当前选中道左侧没有道则返回
			return;

		SetReUnDoAction(); 
		pWellObj = GetWellObject();//调用了undoaction需要重新获得一下井柱对象指针
		TRACKLIST::reverse_iterator rit = std::find(pParentGroup->GetTrackList().rbegin(), pParentGroup->GetTrackList().rend(), pTrackObj);
		rit++;

		CTrackObj* pTrackLeft = *rit; //
		CTrackGroup* pGroupNew = new CTrackGroup;
		pGroupNew->SetGroupType(Group_Horizon);
		pGroupNew->m_font = m_pWell->m_fontTrack;
		pGroupNew->m_pen = m_pWell->m_penTrack;
		pGroupNew->m_dTrackWidth = pTrackLeft->m_dTrackWidth + pTrackObj->m_dTrackWidth;
		pGroupNew->SetParent(pTrackObj->GetParent());
		pGroupNew->SetParentXY(pTrackObj->GetParentXY());
		pGroupNew->AddTrack(pTrackLeft);
		pGroupNew->AddTrack(pTrackObj);

		TRACKLIST::const_iterator cit = std::find(pParentGroup->GetTrackList().begin(), pParentGroup->GetTrackList().end(), pTrackLeft);
		pParentGroup->GetTrackList().insert(cit, pGroupNew); //插入，增加都使用正向迭代器
		pParentGroup->GetTrackList().erase(cit);

		cit = std::find(pParentGroup->GetTrackList().begin(), pParentGroup->GetTrackList().end(), pTrackObj);
		pParentGroup->GetTrackList().erase(cit);

		CPoint2D point = pWellObj->GetAnchorPoint() ;//pWellObj->GetPos().TopLeft();
		pWellObj->CalculateSize(point);
	}

	void CItemSingleWell::TrackRightGroup()
	{
		CWellPole* pWellObj = GetWellObject();
		CTrackObj* pTrackObj = NULL;

		CWellBaseObj* pObjSelected = NULL;
		if(m_WellObjSelectlist.GetCount() == 1)
			pObjSelected = m_WellObjSelectlist.GetHead();

		if (pObjSelected->GetType()== KEP_TRACK)
		{
			pTrackObj = (CTrackObj*)pObjSelected;
		}

		if(pTrackObj==NULL)
			return;

		CTrackGroup* pParentGroup = (CTrackGroup*)pTrackObj->GetParent();
		TRACKLIST::reverse_iterator  rit = pParentGroup->GetTrackList().rbegin();
		if (rit == pParentGroup->GetTrackList().rend())
			return;
		if (*rit == pTrackObj) // 如果当前选中道右侧没有道则返回
			return;

		SetReUnDoAction();
		pWellObj = GetWellObject();
		TRACKLIST::iterator it = std::find(pParentGroup->GetTrackList().begin(), pParentGroup->GetTrackList().end(), pTrackObj);
		TRACKLIST::iterator it1 = it;
		it++;
		CTrackObj* pTrackRight = *it; // pParentGroup->GetTrackList()->GetAt(pos);
		CTrackGroup* pGroupNew = new CTrackGroup;
		pGroupNew->SetGroupType(Group_Horizon);
		pGroupNew->m_font = m_pWell->m_fontTrack;
		pGroupNew->m_pen = m_pWell->m_penTrack;
		pGroupNew->m_dTrackWidth = pTrackRight->m_dTrackWidth + pTrackObj->m_dTrackWidth;
		pGroupNew->SetParent(pTrackObj->GetParent());
		pGroupNew->SetParentXY(pTrackObj->GetParentXY());
		pGroupNew->AddTrack(pTrackObj);
		pGroupNew->AddTrack(pTrackRight);

		pParentGroup->GetTrackList().insert(it1,pGroupNew);
		pParentGroup->GetTrackList().erase(it1);
		pParentGroup->GetTrackList().erase(it);
		
		CPoint2D point = pWellObj->GetAnchorPoint() ;
		pWellObj->CalculateSize(point);
	}

	void CItemSingleWell::Clear()
	{
		if(m_pItemSelected != NULL)
			delete m_pItemSelected;
		m_pItemSelected = NULL;
		m_WellObjSelectlist.RemoveAll();
	}

	int CItemSingleWell::DeleteSelection(void)
	{
		//if(GetDrawObj() == NULL)
		//	return;
		if (m_WellObjSelectlist.GetCount() == 0)
		{
			return 0;
		}

		if (m_pItemSelected!=NULL)
		{
			SetReUnDoAction();
			if (GetWellObject()!=NULL&&m_WellObjSelectlist.GetCount()>0 && m_pItemSelected->GetType() == ITEM_TRACKIN)
			{
				delete m_pItemSelected;
				CItemTrackIn *pItemTrackIn = new CItemTrackIn(GetDoc());
				m_pItemSelected = pItemTrackIn;
				POSITION pos = m_WellObjSelectlist.GetHeadPosition();
				while(pos!=NULL)
				{
					CWellBaseObj*  pObj = m_WellObjSelectlist.GetNext(pos);
					pItemTrackIn->SetDrawObj(pObj);

					pItemTrackIn->DeleteSelection();
				}
			}
			else
				((CItemWellBase*)m_pItemSelected)->DeleteSelection();	

/*			CXTPPropertyGrid &grid = GetPropertyGrid(GetDoc()->GetMainFrame());
			InitPropertyGrid(grid);	*/		
		}
		else
		{
			if(m_WellObjSelectlist.GetCount() == 0)
				delete GetWellObject();
			else
			{
				SetReUnDoAction(FALSE);
				POSITION pos = m_WellObjSelectlist.GetHeadPosition();
				while(pos!=NULL)
				{
					CWellBaseObj*  pObj = m_WellObjSelectlist.GetNext(pos);
					if(pObj->GetType()==KEP_TRACK)
					{
						CItemTrack itemtrack(GetDoc());
						itemtrack.SetDrawObj(pObj);
						itemtrack.DeleteSelection();
					}
				}

				//TRACKLIST trackList;
				//POSITION pos = m_WellObjSelectlist.GetHeadPosition();
				//while(pos!=NULL)
				//{
				//	CWellBaseObj*  pObj = m_WellObjSelectlist.GetNext(pos);
				//	if(pObj->GetType()==KEP_TRACK)
				//	{
				//		trackList.push_back((CTrackObj*)pObj);
				//	}
				//}
				//SetActionDeleteTrackItem(trackList);
			}
		}

		m_WellObjSelectlist.RemoveAll();
		GetDoc()->Invalidate();
		return 1;
	}

	void CItemSingleWell::GetTrackTable(CTrackObj* pTrackObj, CString &strTrackType, CString& table, CString& curve)
	{
		switch(pTrackObj->GetTrackType())
		{
		case Track_Trajectory:
			break;
		case Track_Block:
			break;
		case Track_Facies:
			break;
		case Track_ValidThick:
			break;
		case Track_Bury:
			break;
		case Track_Curve:
			{
				strTrackType = "Curve";
				curve = ((CTrackCurveBase*)pTrackObj)->m_strTrackName;
			}
			break;
		case Track_Discrete:
			{
				strTrackType = "Discrete";
				curve = ((CTrackCurveBase*)pTrackObj)->m_strTrackName;
			}
			break;
		case Track_Stratum:
			{
				strTrackType = "Stratum";
			}
			break;
		case Track_SandLayer:
			{
				strTrackType = "SandLayer";
			}
			break;
		case Track_OilLayerGroup:
			{
				strTrackType = "OilLayerGroup";
			}
			break;
		case Track_ProduceLayer:
			{
				strTrackType = "ProduceLayer"; 
			}
			break;
		case Track_ReserveUnit:
			{
				strTrackType = "ReserveUnit";
			}
			break;
		case Track_StandardLayer:
			{
				strTrackType = "StandardLayer";
			}
			break;
		case Track_Lith:
			{
				strTrackType = "Lith";
			}
			break;
		case Track_CorePosition:
			{
				strTrackType = "CorePosition";
			}
			break;
		case Track_CoreWell:
			{
				strTrackType = "CoreWell";
			}
			break;
		case Track_OilTest:
			{
				strTrackType = "OilTest";
			}
			break;
		case Track_Result:
			{
				strTrackType = "Result";
			}
			break;
		case Track_Picture:
			{
				strTrackType = "Picture";
			}
			break;
		case Track_Text:
			{
				strTrackType = "Text";
			}
			break;
		case Track_Symbol:
			{
				strTrackType = "Symbol";
			}
			break;	
		case Track_Sample:
			{
				strTrackType = "Sample";
			}
			break;
		case Track_Shot:
			{
				strTrackType = "Shot";
			}
			break;
		case Track_TestExtraction:
			{
				strTrackType = "TestExtraction";
			}
			break;
		case Track_CementingQuality:
			{
				strTrackType = "CementingQuality";
			}
			break;
		case Track_CementingQualityCurve:
			{
				strTrackType = "CementingQualityCurve";
			}
			break;
		case Track_ProducedFluidSection:
			{
				strTrackType = "ProducedFluidSection";
			}
			break;
		case Track_WaterAbsorptionSection:
			{
				strTrackType = "WaterAbsorptionSection";
			}
			break;
		case Track_WaveShape:
			{
				strTrackType = "WaveShape";
			}
			break;
		case Track_FaultPoint:
			    strTrackType = "FaultPoint";
			break;
		case Track_VdlImage:
				strTrackType = "well_wavetrace";
			break;
		case Track_WaveCurve:
				strTrackType = "well_wavetrace";
			break;
		default:
			break;
		}
	}

	void CItemSingleWell::AddTrackInObjData()
	{
		if(NULL == m_pItemSelected)
			return;

		//if(m_pItemSelected->GetType() == ITEM_TRACK)
		//{
		//	CItemTrack *pItemTrack = static_cast<CItemTrack *>(m_pItemSelected);
		//	CTrackObj *pTrackObj = static_cast<CTrackObj *>(pItemTrack->GetDrawObj());
		//	if(NULL == pTrackObj)
		//		return;

		//	CString strTitle;
		//	strTitle.LoadString(IDS_STRING_PANE_PROPERTIES);
		//	CString strTrackType;
		//	CString curve;
		//	CString table;
		//	vector<CString>fieldsID;
		//	CDataTableConfig      TempDataConfig;
		//	
		//	GetTrackTable(pTrackObj, strTrackType, table, curve);	

		//	::AfxGetApp()->BeginWaitCursor();
		//	//获取图道的数据表、字段
		//	TempDataConfig.SetTableID(strTrackType);
		//	TempDataConfig.Read();

		//	table = TempDataConfig.GetTableBase();

		//	/// 从文件中读取相关类型道的配置
		//	CPropertySheet sheet("["+table+"] " + strTitle);
		//	sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;
		//	StringVectorSet	datas;
		//	pTrackObj->GetChildDatas(datas);
		//	CDataTrackPropertyPage dataPage(GetWellObject(),pTrackObj, datas, table, curve);
		//	dataPage.SetDataConfig(TempDataConfig);
		//	/////曲线道时,冲库中得到曲线所有的施工号和版本号
		//	//if (strTrackType == "Curve" && AfxGetGeo()->GetSqlStatementManager()->HasDB())
		//	//{
		//	//	CWellPole* pWellObj = static_cast<CWellPole*>(pTrackObj->GetParentObj());
		//	//	CString strWellName = pWellObj->GetWellName();
		//	//	CTrackCurveObjBase* pTrackCurve = (CTrackCurveObjBase*)pTrackObj;
		//	//	CString strCurveName = pTrackCurve->m_strTrackName;
		//	//	GetOperationAndVersion(strWellName, strCurveName, dataPage.m_Vecperation, dataPage.m_VecrVersion);
		//	//	dataPage.m_bCurve = TRUE;
		//	//}

		//	sheet.AddPage(&dataPage);

  //          ////如果是岩样道则添加第二个page页
		//	CDataTableConfig DataConfigTopAndBot;
		//	DataConfigTopAndBot.SetTableID("Text");
		//	DataConfigTopAndBot.Read();
		//	CString tableTopAndBot = DataConfigTopAndBot.GetTableBase();
		//	vector<CString>fieldsIDTopAndBot;
		//	StringVectorSet	datasTopAndBot;
		//	if (strTrackType == "Sample")
		//	{
		//		CTrackSample* pTrackSample = (CTrackSample*)pTrackObj;
		//		pTrackSample->GetChildTopAndBotDatas(datasTopAndBot);
		//	}
		//	CDataTrackPropertyPage dataPageTopAndBot(GetWellObject(),pTrackObj, datasTopAndBot, tableTopAndBot, curve);
		//	dataPageTopAndBot.SetDataConfig(DataConfigTopAndBot);			
		//	if (strTrackType == "Sample")
		//	{
		//		sheet.AddPage(&dataPageTopAndBot);
		//	}

		//	if(sheet.DoModal() ==IDOK && (dataPage.IsChangeData() || dataPageTopAndBot.IsChangeData())) 	
		//	{
		//		if(pTrackObj->GetTrackType()==Track_Curve || pTrackObj->GetTrackType()==Track_Discrete)
		//			SetReUnDoAction(FALSE);
		//		else
		//			SetReUnDoAction();

		//		fieldsID = TempDataConfig.GetFieldsID();
		//		datas = dataPage.GetContent();
		//		fieldsIDTopAndBot = DataConfigTopAndBot.GetFieldsID();
		//		datasTopAndBot = dataPageTopAndBot.GetContent();
		//		BuildTrackInObj(pTrackObj, fieldsID, datas,fieldsIDTopAndBot,datasTopAndBot);
		//		///////记录选择的表名，若果是曲线道则记录选择的施工号和版本号
		//		if (pTrackObj->GetTrackType() == Track_Curve)
		//		{
		//			CTrackCurve *pTrackCurve = (CTrackCurve*)pTrackObj;
		//			//pTrackCurve->m_strOperationNum = dataPage.GetOperationNum();
		//			//pTrackCurve->m_strVersionNum = dataPage.GetVersionNum();
		//		}
		//		else if (pTrackObj->GetTrackType() != Track_Curve && pTrackObj->GetTrackType() !=  Track_Discrete &&
		//			pTrackObj->GetTrackType() != Track_Sample)
		//		{
		//			pTrackObj->m_strConfigTable = dataPage.GetDBTable();
		//			pTrackObj->m_VecConfigField = dataPage.GetDBFields();
		//		}
		//		GetDoc()->Invalidate();
		//	}
		//}	
	}

	void CItemSingleWell::BuildTrackInObj(CTrackObj* pTrackObj, double *pDepth,double *pData,int datanum)
	{
		CWellPole* pWellObj = pTrackObj->GetWell(); //static_cast<CWellPole*>(pTrackObj->GetParent());
		if(NULL == pWellObj)
			return;

		if(datanum == 0)
			return;
		pTrackObj->ClearChildren();
		
		pTrackObj->BuidChildObject(pDepth,pData,datanum);	
	}
	void CItemSingleWell::BuildTrackInObj(CTrackObj* pTrackObj, vector<CString> &fields, StringVectorSet &datas, vector<CString> &fields2,StringVectorSet &vecdatas2)
	{
		CWellPole* pWellObj = pTrackObj->GetWell(); // static_cast<CWellPole*>(pTrackObj->GetParent());
		if(NULL == pWellObj)
			return;

		if (datas.size() == 0 && vecdatas2.size() == 0)
		{
			if (pTrackObj->GetTrackType() == Track_Curve)
			{
				CTrackCurve* pTrackCurve = (CTrackCurve*)pTrackObj;
				pTrackCurve->ClearCurveData();
			}
			else
				pTrackObj->ClearChildren();

			GetDoc()->Invalidate();
			return;
		}
		// 剖面情况下解释结论道和地层道导入数据时删除相关连层
		//if (pTrackObj->GetTrackType() == Track_Result || pTrackObj->GetTrackType() == Track_Stratum)
		//{
		//	CWellSection* pWellSection = (CWellSection*)pWellObj->GetParentObj();
		//	if (NULL != pWellSection)
		//	{
		//		POSITION pos = pWellSection->m_BendList.GetHeadPosition();
		//		while(NULL != pos)
		//		{
		//			CWellBaseObj*  pObj = (CDrawObj*)pWellSection->m_BendList.GetNext(pos);
		//			if (pObj->GetType() == GDOUBLEFOX_SECTIONBEND)
		//			{
		//				CBendObj* pBend = (CBendObj*)pObj;
		//				CTrackObj* pTrackLeft = NULL;
		//				CTrackObj* pTrackRight = NULL;
		//				pTrackLeft = (CTrackObj*)pBend->m_pLayerLeft->GetParentObj();
		//				if (pBend->m_pLayerRight != NULL)
		//				{
		//					pTrackRight = (CTrackObj*)pBend->m_pLayerRight->GetParentObj();
		//				}
		//				if (pTrackRight == pTrackObj || pTrackLeft ==pTrackObj)
		//				{
		//					pWellSection->DeleteBend(pBend);
		//					GetDoc()->Invalidate(pWellSection);
		//				}
		//			}
		//		}
		//	}
		//}

		//清空道内的子对象
		pTrackObj->ClearChildren();

		if (pTrackObj->GetTrackType() != Track_Sample)
		{
			pTrackObj->BuidChildObject(fields,datas);
		}
		else
		{
			if(vecdatas2.size() == 0)
				return;

			CTrackSample* pTrackSample = (CTrackSample*)pTrackObj;
			pTrackSample->BuidChildObject(fields,datas,fields2, vecdatas2);
		}
	}

	void CItemSingleWell::ApplingWellDbTemplate()
	{
		//CDlgApplyTemplate dlg("WellColumn");
		//
		//if(dlg.DoModal() == IDCANCEL)
		//	return;

		//if(dlg.m_pMemFile)
		//	ApplingFileTemplate(*dlg.m_pMemFile);
	}

	void CItemSingleWell::ApplingFileTemplate(CFile &fr)
	{
		CWellPole *pWellObj = GetWellObject();

		SetReUnDoAction(FALSE);

		//备份井内道对象
		//CTrackList tracklist;
		TRACKLIST tracklist;
		tracklist.assign(pWellObj->GetTrackList().begin(), pWellObj->GetTrackList().end());
		pWellObj->GetTrackList().clear();
			//POSITION pos = pWellObj->GetTrackList()->GetTailPosition();
			//while (pos!=NULL)
			//{
			//	CTrackObj* pTrackObj = (CTrackObj*)pWellObj->GetTrackList()->GetPrev(pos);
			//	tracklist.AddHead(pTrackObj);
			//}
			//pWellObj->GetTrackList()->RemoveAll();

		CString strWellTitle = pWellObj->m_strTitle;
		CString	strWellName  = pWellObj->GetWellName();
		double fLevel = pWellObj->m_fLevel;
		double topDepth = pWellObj->m_dSdep;
		double endDepth = pWellObj->m_dEdep;
		double top = pWellObj->GetPos().top;
		double left = pWellObj->GetPos().left;
		double proportion = pWellObj->m_fProportion;
		double dOldTrackHead = pWellObj->m_dHeightTrackHead;
		double dOldWellHead = pWellObj->m_dHeightTrackHead;

		std::vector<CWellPole::well_interval > oldWellIntervalVec;
		oldWellIntervalVec.insert(oldWellIntervalVec.begin(),pWellObj->GetIntervalVec()->begin(),pWellObj->GetIntervalVec()->end());

		AfxGetPublicFunction()->SetCodeType(CODE_GB2321);
		if(pWellObj->ReadPCG(fr, -1) == 0)
		{
			//恢复道备份
			TRACKLIST::reverse_iterator rit = tracklist.rbegin();
			for (; rit != tracklist.rend(); rit++)
			{
				pWellObj->GetTrackList().push_front(*rit);
			}
			tracklist.clear();
			//POSITION pos = tracklist.GetTailPosition();
			//while (pos!=NULL)
			//{
			//	CTrackObj* pTrackObj = (CTrackObj*)tracklist.GetPrev(pos);

			//	pWellObj->GetTrackList()->AddHead(pTrackObj);
			//}
			//tracklist.RemoveAll();

			//AfxGetPublicFunction()->SetCodeType((DWORD)::GetPreferences().WorkaroundSave.m_nCodeMode);
			return ;
		}
		else
		{

			pWellObj->m_strTitle = strWellTitle;
			pWellObj->SetWellName(strWellName);
			pWellObj->m_fLevel = fLevel;
			pWellObj->GetPos().left = left;
			pWellObj->GetPos().top = top;

			pWellObj->m_dSdep = topDepth;			
			pWellObj->m_dEdep = endDepth;

			pWellObj->GetIntervalVec()->clear();
			pWellObj->GetIntervalVec()->insert(pWellObj->GetIntervalVec()->begin(),oldWellIntervalVec.begin(),oldWellIntervalVec.end());

			pWellObj->m_fProportion = proportion;
			pWellObj->ReSetWellHead();
			pWellObj->CalculateSize(pWellObj->GetPos().TopLeft());

			//应用井模板
			TRACKLIST::iterator it = tracklist.begin();
			for (; it != tracklist.end(); it++)
				pWellObj->GetTemplateList().push_front(*it);
			pWellObj->ApplingTemplate(TRUE,dOldTrackHead,dOldWellHead);	
			ImportDataAll(pWellObj, FALSE);
		}
		//AfxGetPublicFunction()->SetCodeType((DWORD)::GetPreferences().WorkaroundSave.m_nCodeMode);
	}
	void CItemSingleWell::ApplingWellTemplate()
	{
		CFileDialog dlg(TRUE,NULL,"", OFN_EXPLORER|OFN_ENABLESIZING|OFN_HIDEREADONLY|OFN_ALLOWMULTISELECT,
			"Well Template (*.dml)|*.dml|",NULL,0);

		CString filepathstr;
		if (dlg.DoModal()!=IDOK)
		{
			return;
		}
		//保存路径
		filepathstr=dlg.GetPathName();
		CString ext = dlg.GetFileExt();
		if(ext == "dml") //dml格式
		{
			CStdioFile fr;
			if(!fr.Open(filepathstr,CFile::modeRead)) 
				return;

			ApplingFileTemplate(fr);
			//CWellPole *pWellObj = GetWellObject();

			//SetReUnDoAction();

			////备份井内道对象
			//CTrackList tracklist;
			//POSITION pos = pWellObj->GetTrackList()->GetTailPosition();
			//while (pos!=NULL)
			//{
			//	CTrackObj* pTrackObj = (CTrackObj*)pWellObj->GetTrackList()->GetPrev(pos);
			//	tracklist.AddHead(pTrackObj);
			//}
			//pWellObj->GetTrackList()->RemoveAll();

			//CString strWellTitle = pWellObj->m_strTitle;
			//CString	strWellName  = pWellObj->GetWellName();
			//double fLevel = pWellObj->m_fLevel;
			//double topDepth = pWellObj->m_fSdep;
			//double endDepth = pWellObj->m_fEdep;
			//double top = pWellObj->GetPos().top;
			//double left = pWellObj->GetPos().left;
			//double proportion = pWellObj->m_fProportion;
			//double dOldTrackHead = pWellObj->m_fHighTrackHead;
			//double dOldWellHead = pWellObj->m_fHighWellHead;

			//AfxGetPublicFunction()->SetCodeType(CODE_GB2321);
			//if(pWellObj->ReadDML(fr, -1) == 0)
			//{
			//	//恢复道备份
			//	POSITION pos = tracklist.GetTailPosition();
			//	while (pos!=NULL)
			//	{
			//		CTrackObj* pTrackObj = (CTrackObj*)tracklist.GetPrev(pos);

			//		pWellObj->GetTrackList()->AddHead(pTrackObj);
			//	}
			//	tracklist.RemoveAll();

			//	AfxGetPublicFunction()->SetCodeType((DWORD)::GetPreferences().WorkaroundSave.m_nCodeMode);
			//	return ;
			//}
			//else
			//{

			//	pWellObj->m_strTitle = strWellTitle;
			//	pWellObj->SetWellName(strWellName);
			//	pWellObj->m_fLevel = fLevel;
			//	pWellObj->GetPos().left = left;
			//	pWellObj->GetPos().top = top;
			//	pWellObj->m_fSdep = topDepth;
			//	pWellObj->m_fEdep = endDepth;
			//	pWellObj->m_fProportion = proportion;
			//	pWellObj->ReSetWellHead();
			//	pWellObj->ComputeSize(pWellObj->GetPos().TopLeft());

			//	//应用井模板
			//	pos = tracklist.GetHeadPosition();
			//	while(pos != NULL)
			//		pWellObj->GetTemplateList().AddHead(tracklist.GetNext(pos));

			//	pWellObj->ApplingTemplate(TRUE,dOldTrackHead,dOldWellHead);	
			//}
			//AfxGetPublicFunction()->SetCodeType((DWORD)::GetPreferences().WorkaroundSave.m_nCodeMode);
			//fr.Close();
		}
	}

	void CItemSingleWell::ImportDataAll(CWellPole* pWell, BOOL bReplace)
	{
		AfxGetMainWnd()->BeginWaitCursor();
		if (NULL == pWell)
		{
			return;
		}
		CString strWellName = pWell->GetWellName();

		//SetReUnDoAction(FALSE);

		//Db::CSqlStatementManager *pSqlManager = AfxGetGeo()->GetSqlStatementManager();
		//
		////如果是斜井，读取井斜数据 
		//if(pWell->GetWellType() == Well_Incline)
		//{
		//	if(pSqlManager->HasDB())
		//	{
		//		vector<CString> fields;
		//		//fields.push_back("well_name");
		//		fields.push_back("inclined_deep");
		//		fields.push_back("angle");
		//		fields.push_back("azimuth");
		//		fields.push_back("vertical_deep");
		//		fields.push_back("x_offset");
		//		fields.push_back("y_offset");
		//		CDataBinderWell BinderWell("well_deviation",fields,pWell->GetWellName());
		//		BinderWell.AttachInput(AfxGetGeo()->GetSqlStatementManager());
		//		BinderWell.ReadData();
		//		StringVectorSet data;
		//		BinderWell.PutDataInStrVector(data);
		//		//data = BinderWell.GetDataSet();
		//		pWell->LoadFromStringVec(data);
		//		pWell->ComputeTrajectory();
		//	}
		//	

		//	CInclinedWellObj* pIncWell = (CInclinedWellObj*)pWell;//static_cast<CInclinedWellObj*>(pWell);//ggff
		//	//pIncWell->LoadFromStringVec(data);

		//	double angle = GetWellProjecttionAngle(pIncWell);

		//	pIncWell->SetProjectionAngle(angle); //设置投影角度
		//	pIncWell->SetLevelProportion( pIncWell->m_fProportion);
		//	//pIncWell->ComputeTrajectory();
		//	pIncWell->ComputeSize(pIncWell->GetAnchorPoint());

		//}
		//else
		//{
		//	if(pWell->m_InclinedWellList.GetCount()>0 && pWell->m_bVWell)
		//		pWell->ComputeSize(pWell->GetAnchorPoint());
		//}

		//ImportDataFromDB(pWell,pWell,pSqlManager,bReplace);

		//GetDoc()->Invalidate();
	}

	//void CItemSingleWell::ImportDataFromLM(CTrackGroupObj* pGroup,CWellPole* pWell,CLMInterface* pLM)
	//{
	//	CString strID;
	//	strID.Format("%d", pWell->GetWellName());
	//	POSITION pos = pGroup->GetTrackList()->GetHeadPosition();
	//	while( NULL != pos)
	//	{
	//		CTrackObj* pTrack = (CTrackObj*)pGroup->GetTrackList()->GetNext(pos);
	//		if (pTrack->GetTrackType() == Track_Group)
	//		{
	//			CTrackGroupObj* pTrackGroup = (CTrackGroupObj*)pTrack;
	//			ImportDataFromLM(pTrackGroup,pWell,pLM);
	//		}
	//		else
	//		{
	//			vector<CString> fields;
	//			StringVectorSet datas;
	//			//读井分层数据
	//			if (pTrack->GetTrackType() == Track_StandardLayer)
	//			{
	//				fields.push_back("name");
	//				fields.push_back("depth");
	//				long rt = pLM->ReadWellPickSet(strID.GetBuffer(), fields, datas);

	//				//删除井外的数据
	//				for(int i=0; i<datas.size(); i++)
	//				{
	//					if(atof(datas[i][1])<pWell->m_fSdep || atof(datas[i][1])>pWell->m_fEdep)
	//						datas.erase(datas.begin()+i);
	//				}
	//			}//读岩性数据
	//			else if (pTrack->GetTrackType() == Track_Lith)
	//			{
	//				fields.push_back("lithology");
	//				fields.push_back("color");
	//				fields.push_back("top");
	//				fields.push_back("bottom");
	//				long rt = pLM->ReadWellLithSet(strID.GetBuffer(), fields, datas);
	//				//删除井外的数据
	//				for(int i=0; i<datas.size(); i++)
	//				{
	//					if(atof(datas[i][3])<pWell->m_fSdep || atof(datas[i][2])>pWell->m_fEdep)
	//						datas.erase(datas.begin()+i);
	//				}

	//			}//读测井曲线
	//			else if (pTrack->GetTrackType() == Track_Curve)
	//			{
	//				CTrackCurveObj* pTrackCurve = (CTrackCurveObj*)pTrack;
	//				long rt = pLM->ReadWellLogValue(strID.GetBuffer(), pTrackCurve->m_strTrackName.GetBuffer(),pTrackCurve->GetDataObj());
	//				pTrackCurve->ReadCurveData();
	//			}
	//			pTrack->BuidChildObject(fields, datas);
	//			fields,Clear();
	//			datas.clear();
	//		}
	//	}
	//}

	//void CItemSingleWell::ImportDataFromDB(CTrackGroupObj* pGroup, CWellPole* pWell,Db::CSqlStatementManager *pSqlManager, BOOL bReplace)
	//{
	//	//从文件中读取相关类型道的配置
	//	POSITION pos = pGroup->GetTrackList()->GetHeadPosition();
	//	while( NULL != pos)
	//	{
	//		CTrackObj* pTrack = pGroup->GetTrackList()->GetNext(pos);
	//		if (pTrack->GetTrackType() == Track_Group)
	//		{
	//			CTrackGroupObj* pTrackGroup = (CTrackGroupObj*)pTrack;
	//			ImportDataFromDB(pTrackGroup, pWell, pSqlManager, bReplace);
	//		}
	//		else
	//		{
	//			ImportTrackDataFromDB(pTrack, pWell, pSqlManager, bReplace);
	//		}
	//	}
	//}
	//
	//void CItemSingleWell::ImportTrackDataFromDB(CTrackObj* pTrack, CWellPole* pWell,Db::CSqlStatementManager *pSqlManager, BOOL bReplace)
	//{
	//	if (pTrack->GetTrackType() == Track_Depth)
	//		return;

	//	if(!bReplace && pTrack->GetChildObjList().GetCount() > 0)
	//	{
	//		pTrack->ResetChildProperties();
	//		return;
	//	}

	//	if(!pSqlManager->HasDB())
	//		return;

	//	CString strTrackType;
	//	CString tableinfo;
	//	CString tableother;
	//	CString strcurvename;
	//	CString str;
	//	vector<CString> fieldsID;
	//	vector<CString> fieldinfo;
	//	vector<CString> fieldother;
	//	CDataTableConfig  dataConfig;

	//	GetTrackTable(pTrack, strTrackType, tableinfo, strcurvename);
	//	dataConfig.SetTableID(strTrackType);
	//	dataConfig.Read();
	//	fieldsID = dataConfig.GetFieldsID();

	//	//库查询时需要的表名和字段名
	//	tableinfo = pSqlManager->GetTableName(pTrack->m_strConfigTable);
	//	tableother = pSqlManager->GetTableName(pTrack->m_strConfigTableOther);

	//	if (pTrack->GetTrackType() == Track_Curve)
	//	{
	//		tableinfo = "well_log";
	//	}
	//	else if (pTrack->GetTrackType() == Track_Discrete)
	//	{
	//		tableinfo = "well_discrete";
	//	}

	//	if (pSqlManager->HasTable(tableinfo))
	//	{
	//		Db::CSqlStatementManager::CTableInfo *pTableInfo = pSqlManager->GetTableInfo(tableinfo);
	//		fieldinfo.clear();
	//		for(int i = 0; i < pTrack->m_VecConfigField.size(); i++)
	//		{
	//			str = pTableInfo->GetColumnIdName(pTrack->m_VecConfigField[i]);
	//			//if(str.IsEmpty())
	//			//	continue;

	//			fieldinfo.push_back(str);
	//			//if(i< fieldsID0.size())
	//			//	fieldsID.push_back(fieldsID0[i]);
	//		}

	//		StringVectorSet data;					
	//		StringVectorSet dataother;
	//		if (pTrack->GetTrackType() == Track_Curve)
	//		{
	//			CTrackCurveObj* pCurveObj = (CTrackCurveObj*)pTrack;
	//			strcurvename = pCurveObj->m_strTrackName;
	//			fieldinfo.push_back("depth");
	//			fieldinfo.push_back(strcurvename);
	//			CString strSGXh;
	//			CString strVer;
	//			CDataBinderWellCurve WellCurve(pWell->GetWellName(),strcurvename,strSGXh,strVer);
	//			WellCurve.AttachInput(AfxGetGeo()->GetSqlStatementManager());
	//			WellCurve.ReadData();
	//			BuildTrackInObj(pTrack,WellCurve.GetCurveDepth(),WellCurve.GetCurveData(),WellCurve.GetDataNum());
	//			CTrackCurveObj *pTrackCurve = (CTrackCurveObj*)pTrack;
	//			pTrackCurve->ComputePointsInclined();
	//		}
	//		else if (pTrack->GetTrackType() == Track_Discrete)
	//		{
	//			CTrackDiscreteObj* pDiscreteObj = (CTrackDiscreteObj*)pTrack;
	//			strcurvename = pDiscreteObj->m_strTrackName;
	//			fieldinfo.push_back("depth");
	//			fieldinfo.push_back(strcurvename);
	//			CDataBinderWellDiscrete WellDis(pWell->GetWellName(),strcurvename);
	//			WellDis.AttachInput(AfxGetGeo()->GetSqlStatementManager());
	//			WellDis.ReadData();
	//			BuildTrackInObj(pTrack,WellDis.GetCurveDepth(),WellDis.GetCurveData(),WellDis.GetDataNum());
	//		}
	//		else
	//		{
	//			CDataBinderWell databinder(tableinfo,fieldinfo,pWell->GetWellName());
	//			databinder.AttachInput(AfxGetGeo()->GetSqlStatementManager());
	//			databinder.ReadData();
	//			databinder.PutDataInStrVector(data);
	//			CDataTrackPropertyPage datapage(pWell, pTrack);
	//			if (!pTrack->m_strConfigClass.IsEmpty() && (tableinfo == "well_stratum" || tableinfo == "well_facies"))
	//			{
	//				datapage.SelectDatas(data,tableinfo,pTrack->m_strConfigClass,pWell->GetWellName());
	//			}

	//			if (AfxGetGeo()->GetSqlStatementManager()->HasTable(tableother))
	//			{
	//				Db::CSqlStatementManager::CTableInfo *pTableInfo2 = pSqlManager->GetTableInfo(tableother);
	//				fieldother.clear();
	//				for(int i = 0; i < pTrack->m_VecConfigFieldOther.size(); i++)
	//				{
	//					str = pTableInfo2->GetColumnIdName(pTrack->m_VecConfigFieldOther[i]);
	//					fieldother.push_back(str);
	//				}

	//				CDataBinderWell databinder2(tableother,fieldother,pWell->GetWellName());
	//				databinder2.AttachInput(AfxGetGeo()->GetSqlStatementManager());
	//				databinder2.ReadData();
	//				databinder2.PutDataInStrVector(dataother);
	//			}
	//			BuildTrackInObj(pTrack, fieldsID, data,fieldother,dataother);
	//		}
	//	}

	//	fieldsID.clear();
	//	fieldinfo.clear();
	//	fieldother.clear();
	//}

	void CItemSingleWell::ExportDataAll(CWellPole* pWell)
	{
		TRACKLIST tracklist;
		pWell->GetAllTrack(&tracklist);

		TRACKLIST::iterator it = tracklist.begin();
		for (; it != tracklist.end(); it++)
			ExportDataToDB(*it);

	}

	void CItemSingleWell::ExportDataToDB(CTrackObj* pTrackObj)
	{
		//Db::CSqlStatementManager *pSqlManager = AfxGetGeo()->GetSqlStatementManager();
		//CWellPole *pWell = (CWellPole*)pTrackObj->GetParentObj();
		//CString strWellName = pWell->GetWellName();

		//CString updateTabName;  //修改过的表数据
		/////////非曲线、散点道、岩样道回写
		//if (pTrackObj->GetTrackType() != Track_Curve && pTrackObj->GetTrackType() != Track_Discrete)
		//{
		//	Db::CSqlStatementManager *pSqlManager = AfxGetGeo()->GetSqlStatementManager();
		//	vector<CString> fieldeng;
		//	CString tableng;
		//	if(pSqlManager->HasDB())
		//	{
		//		/////库查询时需要的表名和字段名
		//		tableng = pSqlManager->GetTableName(pTrackObj->m_strConfigTable);
		//		if (!tableng.IsEmpty())
		//		{
		//			Db::CSqlStatementManager::CTableInfo *pTableInfo = pSqlManager->GetTableInfo(tableng);
		//			CString str;
		//			for(int i = 0; i < pTrackObj->m_VecConfigField.size(); i++)
		//			{
		//				str = pTableInfo->GetColumnIdName(pTrackObj->m_VecConfigField[i]);
		//				fieldeng.push_back(str);
		//			}
		//		}
		//	}
		//	if (AfxGetGeo()->GetSqlStatementManager()->HasTable(tableng))
		//	{
		//		CDataTableNoQueryExec DataNoQueryExec;
		//		DataNoQueryExec.AttachInput(pSqlManager);
		//		DataNoQueryExec.SetTableName(tableng);	
		//		//////把库中的表数据删除
		//		CString str1,strwhere;
		//		str1 = "well_name";
		//		str1 = DataNoQueryExec.GetFieldFmtStr(str1);
		//		strwhere.Format("%s='%s'",str1,strWellName);
		//		DataNoQueryExec.DelFromWhere(strwhere);
		//		//////把数据写入库中
		//		StringVectorSet	datas;
		//		vector<CString> valuevector;
		//		pTrackObj->GetChildDatas(datas);
		//		for (int i = 0; i < datas.size(); i++)
		//		{
		//			valuevector.clear();
		//			valuevector = datas[i];
		//			DataNoQueryExec.AddRecord(fieldeng,valuevector);
		//		}

		//		updateTabName = tableng;
		//	}
		//}
		/////////曲线道回写
		//else if (pTrackObj->GetTrackType() == Track_Curve)
		//{
		//	CTrackCurveObj *pTrackCurve = (CTrackCurveObj*)pTrackObj;
		//	CString strCurve = pTrackCurve->m_strTrackName;
		//	if (pTrackCurve->GetDataObj()->GetCount() > 0)
		//	{
		//		CDataObj_Curve *pCurveChild = (CDataObj_Curve *)pTrackCurve->GetDataObj();

		//		CString strOperNum = pTrackCurve->m_strOperationNum;
		//		CString strVerNum = pTrackCurve->m_strVersionNum;
		//		double fsdep,fedep,frlev;
		//		int nCount = 0;
		//		fsdep = pCurveChild->m_startdep;
		//		fedep = pCurveChild->m_enddep;
		//		frlev = pCurveChild->m_rlev;
		//		nCount = pCurveChild->m_sample_count;
		//		double *pCuveData = new double[nCount];
		//		for (int i = 0; i < nCount; i++)
		//		{
		//			pCuveData[i] = pCurveChild->m_curve_value[i];
		//		}
		//		CDataCurveNoQueryExec DataCurve;
		//		DataCurve.SetTable("well_log");
		//		DataCurve.AttachInput(pSqlManager);
		//		DataCurve.SetParams(strWellName,strCurve,strOperNum,strVerNum);
		//		DataCurve.DeleteData();
		//		DataCurve.AddCurve(strWellName,strCurve,strOperNum,strVerNum,fsdep,fedep,frlev,pCuveData,nCount);

		//		updateTabName = "well_log";
		//	}
		//}
		/////////散点道回写
		//else if (pTrackObj->GetTrackType() == Track_Discrete)
		//{
		//	CTrackDiscreteObj *pTrackDiscrete = (CTrackDiscreteObj*)pTrackObj;
		//	CString strCurve = pTrackDiscrete->m_strTrackName;
		//	if (pTrackDiscrete->GetDataObj()->GetCount() > 0)
		//	{
		//		CDataObj_Discrete *pCurveChild = (CDataObj_Discrete *)pTrackDiscrete->GetDataObj();

		//		int nCount = 0;
		//		nCount = pCurveChild->m_nDataCount;
		//		double *pDepth = new double[nCount];
		//		double *pValue = new double[nCount];
		//		for (int j=0; j < nCount; j++)
		//		{
		//			pValue[j] = pCurveChild->m_fDataArr[j];
		//			pDepth[j] = pCurveChild->m_fDepth[j];
		//		}
		//		CDataDiscreteNoQueryExec DataDiscrete;
		//		DataDiscrete.SetTable("well_discrete");
		//		DataDiscrete.AttachInput(pSqlManager);
		//		DataDiscrete.SetParams(strWellName,strCurve);
		//		DataDiscrete.DeleteData();
		//		DataDiscrete.AddData(strWellName,strCurve,pDepth,pValue,nCount);

		//		updateTabName = "well_discrete";
		//	}
		//}

		//if(!updateTabName.IsEmpty())
		//{//发送修改数据的通知给其它模块
		//	GeoNetwork::CMsgContent msgContent;
		//	msgContent.SetMsgUpdateTable(GeoNetwork::BROADCAST,updateTabName,strWellName,0);

		//	CMapEditCtrl* pEditCtrl = (CMapEditCtrl*)(GetWnd()->GetMapCtrl());
		//	pEditCtrl->m_ClientService.PushSendMsg(&msgContent);
		//}
	}

	//void CItemSingleWell::MoveDiscreteSegement(CWellBaseObj* pObj,const double fdistance)
	//{
	//	if (pObj->GetType() == GDOUBLEFOX_DISCRETESEGMENT)
	//	{
	//		CTrackInDiscreteSegment* pDiscreteSegment = (CTrackInDiscreteSegment*)pObj;
	//		CRect8 RectOld = pDiscreteSegment->GetPosition();
	//		CTrackDiscreteObj* pTrackDiscrete = (CTrackDiscreteObj*)pDiscreteSegment->GetParentObj();
	//		CWellPole* pWell = (CWellPole*)pTrackDiscrete->GetParentObj();
	//		float fdepth = 0.0;
	//		double ftopdepth = pWell->ScreenYToDepth(RectOld.top);
	//		double fbotdepth = pWell->ScreenYToDepth(RectOld.bottom);

	//		//int nCount = pTrackDiscrete->m_sample_count;
	//		//for(int i = 0; i < nCount; i++)
	//		//{
	//		//	fdepth = pTrackDiscrete->m_curve_depth[i];
	//		//	if (fdepth >= ftopdepth && fdepth <= fbotdepth)
	//		//	{
	//		//		pTrackDiscrete->m_curve_depth[i] += -pWell->ScreenCYToHeight(fdistance);
	//		//	}
	//		//}
	//		//pTrackDiscrete->ComputePoints();
	//		CDataObj_Discrete *pChild = (CDataObj_Discrete*)pTrackDiscrete->GetDataObj();
	//		if (pChild != NULL)
	//		{
	//			for (int kk=0;kk<pChild->m_nDataCount;kk++)
	//			{
	//				fdepth = pChild->m_fDepth[kk];
	//				if (fdepth >= ftopdepth && fdepth <= fbotdepth)
	//				{
	//					pChild->m_fDepth[kk] -= pWell->ScreenCYToHeight(fdistance);
	//				}
	//			}
	//		}
	//		pTrackDiscrete->ReadCurveData();
	//	}
	//}

	//void CItemSingleWell::GetDepthAndValueDiscreteSegement(CWellBaseObj* pObj,CArray<double> &ArrDepth,CArray<double> &ArrValue,const double dTop, const double dBot,int &nStartIndex,int &nEndIndex)
	//{
	//	CWellPole* pWell = (CWellPole*)GetWellObject();
	//	double ftopdepth = pWell->ScreenYToDepth(dTop);
	//	double fbotdepth = pWell->ScreenYToDepth(dBot);
	//	nStartIndex = 0;
	//	nEndIndex = 0;
	//	float fdepth = 0;
	//	BOOL bFirst = TRUE;
	//	if (pObj != NULL && pObj->GetType() == GDOUBLEFOX_DISCRETESEGMENT)
	//	{
	//		CTrackDiscreteObj* pTrackDiscrete = (CTrackDiscreteObj*)pObj->GetParentObj();
	//		CDataObj_Discrete* pDataObj = (CDataObj_Discrete*)pTrackDiscrete->GetDataObj();
	//		int nCount = pDataObj->m_nDataCount;
	//		for (int i = 0; i < nCount; i++)
	//		{
	//			fdepth = pDataObj->m_fDepth[i];
	//			if (fdepth >= ftopdepth && fdepth <= fbotdepth)
	//			{
	//				if (bFirst)
	//				{
	//					nStartIndex = i;
	//					bFirst = FALSE;
	//				}
	//				nEndIndex = i;
	//				fdepth = pDataObj->m_fDepth[i];
	//				double fvalue = pDataObj->m_fDataArr[i];
	//				ArrDepth.Add(pDataObj->m_fDepth[i]);
	//				ArrValue.Add(pDataObj->m_fDataArr[i]);
	//			}
	//		}
	//	}
	//}

	//void CItemSingleWell::SortDiscreteSegment(CArray<double> &ArrDepth,CArray<double> &ArrValue)
	//{
	//	int nCount = ArrDepth.GetCount();
	//	double dNumber;
	//	double ddepth1;
	//	double ddepth2;
	//	for (int i = 0; i < nCount-1; i++)
	//	{
	//		for (int j = i+1; j < nCount; j++)
	//		{
	//			ddepth1 = ArrDepth.GetAt(i);
	//			ddepth2 = ArrDepth.GetAt(j);
	//			if (ddepth1 > ddepth2)
	//			{
	//				dNumber = ArrDepth.GetAt(i);
	//				ArrDepth.SetAt(i,ArrDepth.GetAt(j));
	//				ArrDepth.SetAt(j,dNumber);

	//				dNumber = ArrValue.GetAt(i);
	//				ArrValue.SetAt(i,ArrValue.GetAt(j));
	//				ArrValue.SetAt(j,dNumber);
	//			}
	//		}
	//	}
	//}

	//void CItemSingleWell::SetDiscreteSegment(CWellBaseObj* pObj,CArray<double> &ArrDepth,CArray<double> &ArrValue,const int nStartIndex,const int nEndIndex)
	//{
	//	if (pObj != NULL && pObj->GetType() == GDOUBLEFOX_DISCRETESEGMENT)
	//	{
	//		CTrackDiscreteObj* pTrackDiscrete = (CTrackDiscreteObj*)pObj->GetParentObj();
	//		CDataObj_Discrete* pDataObj = (CDataObj_Discrete*)pTrackDiscrete->GetDataObj();
	//		if (nStartIndex >= nEndIndex || nStartIndex < 0 || nEndIndex < 0 || ArrDepth.GetCount() == 0 || ArrValue.GetCount() == 0)
	//		{
	//			return;
	//		}
	//		for (int i = nStartIndex; i <= nEndIndex; i++)
	//		{
	//			pDataObj->m_fDataArr[i] = ArrValue.GetAt(i - nStartIndex);
	//			pDataObj->m_fDepth[i] = ArrDepth.GetAt(i - nStartIndex);
	//		}
	//		pTrackDiscrete->ReadCurveData();
	//	}
	//}

	void CItemSingleWell::DrawWellHandle()
	{
		DrawHandle(&GetView()->m_pDoc->GetDC());
	}

	void CItemSingleWell::GetOperationAndVersion(const CString strWellName, const CString strCurveName, vector<CString> &OperatVec, vector<CString> &VersionVec)
	{
		//vector<CString> fields;
		//fields.push_back("version");
		//fields.push_back("operation_number");
		//Db::CSqlStatementManager *pSqlManager = AfxGetGeo()->GetSqlStatementManager();
		//if (!pSqlManager->HasDB())
		//{
		//	return;
		//}
		//CDataBinderWell  CurveTab("well_log",fields,strWellName);
		//CurveTab.AttachInput(pSqlManager);
		//CString strWhere1;
		//CString str1 = CurveTab.GetFieldFmtStr("curve_name");
		//strWhere1 = str1 + "=" + "'" + strCurveName + "'";
		//CurveTab.SetWhereSql(strWhere1);
		//CurveTab.ReadData();
		//StringVectorSet	Datas;
		//CString strOperat,strVersion;
		////Datas = CurveTab.GetDataSet();
		//CurveTab.PutDataInStrVector(Datas);
		//OperatVec.clear();
		//VersionVec.clear();
		//for (int i = 0; i < Datas.size(); i++)
		//{
		//	strVersion = Datas[i][0];
		//	strOperat = Datas[i][1];
		//	OperatVec.push_back(strOperat);
		//	VersionVec.push_back(strVersion);
		//}
	}

	void CItemSingleWell::GetAllCurveNameInDb(CStringArray &strNameArr,const CString strTableName,CString nameField)
	{


		//Db::CSqlStatementManager *pSqlManager = AfxGetGeo()->GetSqlStatementManager();
		//if (pSqlManager->HasDB())
		//{
		//	vector<CString> fields;
		//	fields.push_back(nameField);
		//	CString strWellName = m_pWell->GetWellName();
		//	CDataBinderWell  CurveTab(strTableName,fields,strWellName);
		//	CurveTab.AttachInput(pSqlManager);
		//	CurveTab.ReadData();
		//	StringVectorSet	Datas;
		//	CString strCurveName;
		//	//Datas = CurveTab.GetDataSet();
		//	CurveTab.PutDataInStrVector(Datas);
		//	strNameArr.RemoveAll();
		//	for (int i = 0; i < Datas.size(); i++)
		//	{
		//		strCurveName = Datas[i][0];
		//		strNameArr.Add(strCurveName);
		//	}
		//}
		//else
		//{
		//	for(int ii = 0; ii< m_pWell->m_CurveDataVecs.size(); ii++)
		//	{
		//		strNameArr.Add(m_pWell->m_CurveDataVecs[ii]->m_curve_name);
		//	}
		//}
	}

	//void CItemSingleWell::GetLegendObject(const CStringArray &StyleList,CRect8 rt)
	//{
	//	if (NULL == m_pWell || StyleList.GetCount() == 0)
	//	{
	//		return;
	//	}
	//	CWellBaseObjList Objectlist;
	//	GetSymbolObj(Objectlist,StyleList,m_pWell);		
 //       CXy* pXy = (CXy*)m_pWell->GetParentXY();
	//	CreatLegendObject(Objectlist,rt,pXy);
	//}

	//BOOL CItemSingleWell::IsRepeat(CWellBaseObjList &Objectlist,const CString strName)
	//{
	//	BOOL bRepeat = FALSE;
	//	CWellBaseObjList ListLast;
	//	POSITION pos = Objectlist.GetHeadPosition();
	//	while(pos)
	//	{
	//		CInsertDraw* pInsertDraw = (CInsertDraw*)Objectlist.GetNext(pos);
	//		if (strName == pInsertDraw->GetName())
	//		{
	//			bRepeat = TRUE;
	//		}
	//	}
	//	return bRepeat;
	//}

	//void CItemSingleWell::CreatLegendObject(CWellBaseObjList &Objectlist,CRect8 rt,CXy* pXy)
	//{
	//	if (NULL == pXy || Objectlist.GetCount() == 0)
	//	{
	//		return;
	//	}

	//	double legendW = GetDC()->GetRealWidth(60.0);

	//	int nIndexRow = 0;//行
	//	int nIndexCol = 1;//列
	//	nIndexCol = (int)rt.Width()/legendW;
	//	if (nIndexCol < 1)
	//	{
	//		nIndexCol = 1;
	//	}

	//	CRect8 rtOne;
	//	double ftop = rt.top;
	//	int nIndexColAdd = 1;
	//	CInsertDraw* pInsertDraw = NULL;
	//	CCurveEx* pLegendCurve = NULL;
	//	CText* pText = NULL;
	//	CRect8 rttext;
	//	CString strText;
	//	CStringArray StrArr;
	//	POSITION posAdd = NULL;
	//	CPositionList addList;
	//	int nNumber = 0;
	//	int nIndex = 0;
	//	POSITION pos = Objectlist.GetHeadPosition();
	//	while(pos)
	//	{
	//		nIndex = nNumber%nIndexCol;
	//		if (nIndex==0 && nNumber>0)
	//		{
	//			ftop = rtOne.bottom  - 0.25*legendW;
	//			nIndexRow++;
	//		}
	//		nNumber++;

	//		rtOne.left = rt.left + nIndex*1.2*legendW;
	//		rtOne.right = rtOne.left + 0.8*legendW;
	//		rtOne.top = ftop;
	//		rtOne.bottom = rtOne.top - 0.8*legendW;

	//		pInsertDraw = (CInsertDraw*)Objectlist.GetNext(pos);
	//		pInsertDraw->x0=rtOne.left;
	//		pInsertDraw->y0=rtOne.bottom;
	//		pInsertDraw->rect=((CXyBase*)pInsertDraw->pDraw)->m_range;
	//		pInsertDraw->m_size.cy=rtOne.Height();
	//		pInsertDraw->m_size.cx=rtOne.Width();
	//	
	//		pLegendCurve = new CCurveEx(5);
	//		pLegendCurve->x[0] = pInsertDraw->x0;
	//		pLegendCurve->y[0] = pInsertDraw->y0 + pInsertDraw->m_size.cy;

	//		pLegendCurve->x[1] = pLegendCurve->x[0] + pInsertDraw->m_size.cx;
	//		pLegendCurve->y[1] = pLegendCurve->y[0];

	//		pLegendCurve->x[2] = pLegendCurve->x[1];
	//		pLegendCurve->y[2] = pInsertDraw->y0;

	//		pLegendCurve->x[3] = pInsertDraw->x0;
	//		pLegendCurve->y[3] = pInsertDraw->y0;

	//		pLegendCurve->x[4] = pLegendCurve->x[0];
	//		pLegendCurve->y[4] = pLegendCurve->y[0];

	//		CText* pText = new CText();
	//		rttext.top = pLegendCurve->y[2] + 0;
	//		rttext.bottom = rttext.top - 0.20*legendW;
	//		rttext.left = pLegendCurve->x[0];
	//		rttext.right = pLegendCurve->x[1];
	//		pText->SetRange(rttext);
	//		pText->m_size.cx = GetDC()->GetRealWidth(5.0);
	//		pText->m_size.cy = pText->m_size.cx*2.5;
	//		pText->SetAlignsH(CText::alignCenterH);
	//		pText->x0 = rttext.CenterPoint().x0;
	//		pText->SetAlignsV(CText::alignCenterV);
	//		pText->y0 = rttext.CenterPoint().y0;
	//		strText = pInsertDraw->GetName();
	//		StrArr.RemoveAll();
	//		AfxGetPublicFunction()->ScanfString(StrArr,strText, '\\');
	//		strText = StrArr.GetAt(StrArr.GetCount()-1);
	//		pText->SetName(strText);

	//		posAdd = pXy->AddElement(pText,DOUBLEFOX_TEXT);
	//		addList.AddTail(posAdd);
	//		posAdd = pXy->AddElement(pInsertDraw,DOUBLEFOX_DRAW);
	//		addList.AddTail(posAdd);
	//		//pXy->AddMark((CXyBase*)pInsertDraw->pDraw);
	//		posAdd = pXy->AddElement(pLegendCurve,DOUBLEFOX_CURVE);
	//		addList.AddTail(posAdd);
	//	}

	//	//for undo/redo
	//	if(addList.GetCount()>0)
	//	{
	//		CActionAddItem* pAction = new CActionAddItem(GetDoc(), 0, addList);
	//		GetDoc()->SetActionItem(pAction);
	//	}
	//}

	CInsertDraw *CItemSingleWell::GetLegendInsertDraw(CString strMark)
	{
		CInsertDraw *pNewDraw = NULL;

		//AfxGetGlobalMark()->BackupMark();
		//AfxGetGlobalMark()->AttachMark(GetDoc()->GetDraw()->GetMark());

		//CXy* AddCXy = NULL;
		//CXy* pMark = NULL;
		//CXy *pGMark = NULL;

		//pGMark = (CXy*)AfxGetGlobalMark()->FindMark(strMark);
		//pMark = (CXy*)AfxGetGlobalWellXy()->GetMark()->FindMark(strMark);

		//if(pGMark != NULL || pMark != NULL)
		//{
		//	if(pGMark == NULL)
		//	{
		//		pNewDraw = new CInsertDraw;
		//		pMark->m_strName = strMark;//pTrackChild->m_strLith;
		//		AddCXy = new CXy();
		//		*AddCXy = *pMark;
		//		pNewDraw->SetName(strMark);
		//		pNewDraw->pDraw = AddCXy;
		//		pNewDraw->SetExtendMode(CInsertDraw::modeCenter);											

		//		GetDoc()->GetDraw()->AddMark(AddCXy);
		//	}
		//	else
		//	{
		//		pNewDraw = new CInsertDraw;
		//		pNewDraw->SetName(strMark);
		//		pNewDraw->pDraw = pGMark;
		//		pNewDraw->SetExtendMode(CInsertDraw::modeCenter);											
		//	}
		//}

		//AfxGetGlobalMark()->RestoreMark();

		return pNewDraw;
	}
	//void CItemSingleWell::GetSymbolObj(CWellBaseObjList &Objectlist,const CStringArray &StyleList, CWellPole* pWell)
	//{
	//	CStringArray StrArr;
	//	if (NULL == pWell)
	//	{
	//		return;
	//	}
	//	//符号类别名
	//	CString strMarkNormal; strMarkNormal.Format("%s", LIB_MARK_NORMAL); strMarkNormal.TrimRight("\\");
	//	CString strMarkFill; strMarkFill.Format("%s", LIB_MARK_FILL); strMarkFill.TrimRight("\\");
	//	CString strMarkLitho; strMarkLitho.Format("%s", LIB_MARK_LITHO); strMarkLitho.TrimRight("\\");
	//	CString strMarkResult; strMarkResult.Format("%s", LIB_MARK_RESULT);strMarkResult.TrimRight("\\");
	//	CString strMarkBreakStratum; strMarkBreakStratum.Format("%s", LIB_MARK_BREAKSTRATUM); strMarkBreakStratum.TrimRight("\\");
	//	CString strMarkBreakLitho; strMarkBreakLitho.Format("%s", LIB_MARK_BREAKLITHO); strMarkBreakLitho.TrimRight("\\");
	//	CString strMarkStratum; strMarkStratum.Format("%s", LIB_MARK_STRATUMFLUID); strMarkStratum.TrimRight("\\");
	//	CString strMarkChart; strMarkChart.Format("%s", LIB_MARK_CHART); strMarkChart.TrimRight("\\");
	//	CString strMarkFluid; strMarkFluid.Format("%s", LIB_MARK_FLUID); strMarkFluid.TrimRight("\\");

	//	CTrackList tracklist;
	//	pWell->GetAllTrack(&tracklist);
	//	CInsertDraw* pInsertDraw = NULL;
	//	CXyBase* AddCXy = NULL;
	//	CString strMark;
	//	CXy* pMark = NULL;
	//	CXy *pGMark = NULL;
	//	POSITION pos = tracklist.GetHeadPosition();
	//	while(pos)
	//	{
	//		CTrackObj* pTrack = (CTrackObj*)tracklist.GetNext(pos);
	//		POSITION posChildren = pTrack->GetChildObjList().GetHeadPosition();
	//		if (pTrack->GetTrackType() == Track_Text || pTrack->GetTrackType() == Track_Stratum || pTrack->GetTrackType() == Track_SandLayer ||
	//			pTrack->GetTrackType() == Track_OilLayerGroup || pTrack->GetTrackType() == Track_ReserveUnit)
	//		{
	//			while(posChildren)
	//			{
	//				CTrackInTextRange* pObjChild = (CTrackInTextRange*)pTrack->GetChildObjList().GetNext(posChildren);
	//				for (int i = 0; i<StyleList.GetCount(); i++)
	//				{
	//					StrArr.RemoveAll();
	//					AfxGetPublicFunction()->ScanfString(StrArr,StyleList.GetAt(i), '\\');
	//					if (StrArr.GetAt(0) == strMarkFill)
	//					{
	//						if (!pObjChild->m_strLitho.IsEmpty() && StrArr.GetAt(1) == pObjChild->m_strLitho)
	//						{
	//							strMark.Format("%s", LIB_MARK_FILL);
	//							strMark = strMark + pObjChild->m_strLitho;
	//							if (!IsRepeat(Objectlist,strMark))
	//							{
	//								pInsertDraw = GetLegendInsertDraw(strMark);
	//								if(pInsertDraw)
	//									Objectlist.AddTail(pInsertDraw);
	//							}
	//						}
	//					}
	//				}
	//			}
	//		}
	//		else if (pTrack->GetTrackType() == Track_Lith)
	//		{
	//			CTrackLithObj* pTrackLitho = (CTrackLithObj*)pTrack;
	//			while(posChildren)
	//			{
	//				CTrackInLith* pTrackChild = (CTrackInLith*)pTrackLitho->GetChildObjList().GetNext(posChildren);
	//				for (int i = 0; i<StyleList.GetCount(); i++)
	//				{
	//					StrArr.RemoveAll();
	//					AfxGetPublicFunction()->ScanfString(StrArr,StyleList.GetAt(i), '\\');
	//					if (StrArr.GetAt(0) == strMarkLitho)
	//					{
	//						if(AfxGetGlobalWellXy() != NULL)
	//						{
	//							////主名
	//							if(!pTrackChild->m_strLith.IsEmpty() && StrArr.GetAt(1) == pTrackChild->m_strLith)
	//							{
	//								strMark.Format("%s", LIB_MARK_LITHOMAIN);
	//								strMark = strMark + pTrackChild->m_strLith;
	//								if (!IsRepeat(Objectlist,strMark))
	//								{

	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);
	//									
	//								}
	//							}
	//							////次名
	//							if(!pTrackChild->m_strFront.IsEmpty() && StrArr.GetAt(1) == pTrackChild->m_strFront)
	//							{
	//								strMark.Format("%s", LIB_MARK_LITHOFRONT);
	//								strMark = strMark + pTrackChild->m_strFront;
	//								if (!IsRepeat(Objectlist,strMark))
	//								{
	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);

	//								}
	//							}
	//							////含油气性
	//							if(!pTrackChild->m_strOilGas.IsEmpty() && StrArr.GetAt(1) == pTrackChild->m_strOilGas)
	//							{
	//								strMark.Format("%s", LIB_MARK_LITHOOILGAS);
	//								strMark = strMark + pTrackChild->m_strOilGas;
	//								if (!IsRepeat(Objectlist,strMark))
	//								{
	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);
	//
	//								}
	//							}
	//							////含油物
	//							if (!pTrackChild->m_strContent.IsEmpty() && StrArr.GetAt(1) == pTrackChild->m_strContent)
	//							{
	//								strMark.Format("%s", LIB_MARK_LITHOCONTENT);
	//								strMark = strMark + pTrackChild->m_strContent;
	//								if (!IsRepeat(Objectlist,strMark))
	//								{
	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);

	//								}
	//							}
	//							////构造
	//							if (!pTrackChild->m_strConstitution.IsEmpty() && StrArr.GetAt(1) == pTrackChild->m_strConstitution)
	//							{
	//								strMark.Format("%s", LIB_MARK_LITHOCONSTITU);
	//								strMark = strMark + pTrackChild->m_strConstitution;
	//								if (!IsRepeat(Objectlist,strMark))
	//								{
	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);
	//								}
	//							}
	//						}
	//					}
	//				}
	//			}
	//		}
	//		else if (pTrack->GetTrackType() == Track_Curve || pTrack->GetTrackType() == Track_Discrete)
	//		{
	//			CTrackCurveObjBase* pTrckCurve = (CTrackCurveObjBase*)pTrack;
	//			if(AfxGetGlobalWellXy() != NULL)
	//			{
	//				for (int i = 0; i<StyleList.GetCount(); i++)
	//				{
	//					StrArr.RemoveAll();
	//					AfxGetPublicFunction()->ScanfString(StrArr,StyleList.GetAt(i), '\\');
	//					if (StrArr.GetAt(0) == strMarkFill)
	//					{
	//						if (pTrckCurve->IsFillBrushPattern() && pTrckCurve->m_pMarkFill != NULL)
	//						{
	//							strMark.Format("%s", LIB_MARK_FILL);
	//							strMark = strMark + pTrckCurve->m_strFillSymbol;
	//							if (!IsRepeat(Objectlist,strMark) && StrArr.GetAt(1) == pTrckCurve->m_strFillSymbol)
	//							{
	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);
	//							}
	//						}
	//					}
	//					else if (StrArr.GetAt(0) == strMarkChart)
	//					{
	//						if (pTrckCurve->IsShowDot() && pTrckCurve->m_pMarkChart != NULL)
	//						{
	//							strMark.Format("%s", LIB_MARK_CHART);
	//							strMark = strMark + pTrckCurve->m_strDotSymbol;
	//							if (!IsRepeat(Objectlist,strMark) && StrArr.GetAt(1) == pTrckCurve->m_strDotSymbol)
	//							{
	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);
	//							}
	//						}
	//					}
	//				}
	//			}
	//		}
	//		else if (pTrack->GetTrackType() == Track_Result)
	//		{
	//			CTrackResultObj* pTrackResult = (CTrackResultObj*)pTrack;
	//			if (pTrackResult->m_nKind == 0 && AfxGetGlobalWellXy() != NULL)
	//			{
	//				while(posChildren)
	//				{
	//					CTrackInResult* pTrackChild = (CTrackInResult*)pTrack->GetChildObjList().GetNext(posChildren);										
	//					for (int i = 0; i<StyleList.GetCount(); i++)
	//					{
	//						StrArr.RemoveAll();
	//						AfxGetPublicFunction()->ScanfString(StrArr,StyleList.GetAt(i), '\\');
	//						if (StrArr.GetAt(0) == "解释")
	//						{
	//							if (pTrackChild->m_pMarkSymbol != NULL && StrArr.GetAt(1) == pTrackChild->m_strResult)
	//							{
	//								strMark = pTrackChild->GetMarkSymbol();
	//								if (!IsRepeat(Objectlist,strMark))
	//								{
	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);

	//								}
	//							}
	//						}
	//						if (StrArr.GetAt(0) == "流体")
	//						{
	//							if (StrArr.GetAt(1) == pTrackChild->m_strResult)
	//							{
	//								strMark.Format("%s", LIB_MARK_FLUIDCOLOR);
	//								strMark = strMark + pTrackChild->m_strResult;
	//								if (!IsRepeat(Objectlist,strMark))
	//								{
	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);

	//								}
	//							}
	//						}
	//						if (StrArr.GetAt(0) == "连层")
	//						{
	//							if (pTrackChild->m_pMarkResult != NULL && StrArr.GetAt(1) == pTrackChild->m_strResult)
	//							{
	//								strMark.Format("%s", LIB_MARK_STRATUMFLUID);
	//								strMark = strMark + pTrackChild->m_strResult;
	//								if (!IsRepeat(Objectlist,strMark))
	//								{
	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);

	//								}
	//							}
	//						}
	//						if (StrArr.GetAt(0) == "填充")
	//						{
	//							if(!pTrackChild->m_strLitho.IsEmpty() && StrArr.GetAt(1) == pTrackChild->m_strLitho)
	//							{
	//								strMark.Format("%s", LIB_MARK_FILL);
	//								strMark = strMark + pTrackChild->m_strLitho;
	//								if (!IsRepeat(Objectlist,strMark))
	//								{
	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);

	//								}
	//							}
	//						}
	//					}
	//				}
	//			}
	//		}
	//		else if (pTrack->GetTrackType() == Track_Symbol)
	//		{
	//			CTrackSymbolObj* pTrackSymbol = (CTrackSymbolObj*)pTrack;
	//			if (AfxGetGlobalWellXy() != NULL)
	//			{
	//				while(posChildren)
	//				{
	//					CTrackInSymbol* pTrackChild = (CTrackInSymbol*)pTrack->GetChildObjList().GetNext(posChildren);
	//					for (int i = 0; i<StyleList.GetCount(); i++)
	//					{
	//						StrArr.RemoveAll();
	//						AfxGetPublicFunction()->ScanfString(StrArr,StyleList.GetAt(i), '\\');
	//						if (StrArr.GetAt(0) == "符号")
	//						{
	//							if (pTrackChild->m_pMarkSymbol != NULL && StrArr.GetAt(1) == pTrackChild->m_strName)
	//							{
	//								strMark.Format("%s", LIB_MARK_NORMAL);
	//								strMark = strMark+pTrackChild->m_strName;
	//								if (!IsRepeat(Objectlist,strMark))
	//								{
	//									pInsertDraw = GetLegendInsertDraw(strMark);
	//									if(pInsertDraw)
	//										Objectlist.AddTail(pInsertDraw);

	//								}
	//							}
	//						}
	//					}
	//				}
	//			}
	//		}			
	//	}
	//	tracklist.RemoveAll();
	//}

	void CItemSingleWell::BeSelectBorderLine(CTrackGroup* pGroup,CPoint2D pt,double dHandleSize)
	{
		CTrackObj* pTrack = NULL;
		CTrackGroup* pTrackGroup = NULL;
		TRACKLIST::reverse_iterator rit = pGroup->GetTrackList().rbegin();
		for (; rit != pGroup->GetTrackList().rend(); rit++)
		{
			pTrack = *rit;
			if (pTrack->IsOnTrackRight(pt,dHandleSize))
			{
				//左右拖动
				nDragHandle = 4;
				selectMode = CItemNestBase::size;
				OnDraw(GetDC());
				Select(pTrack);
				OnDraw(GetDC());
				//GetView()->SetCapture();
				return; 
			}
			else if (pTrack->IsOnTrackTop(pt,dHandleSize))
			{//上下拖动
				nDragHandle = 6;
				selectMode = CItemNestBase::border;
				//GetView()->SetCapture();
				return; 
			}
			else if (pTrack->IsOnWellTop(pt,dHandleSize))
			{//井头上下拖动
				nDragHandle = 2;
				selectMode = CItemNestBase::border;
				//GetView()->SetCapture();
				return;
			}
			else if (pTrack->GetTrackType() == Track_Group)
			{
				pTrackGroup = (CTrackGroup*)pTrack;
				BeSelectBorderLine(pTrackGroup,pt,dHandleSize);
			}
		}
	}

	BOOL CItemSingleWell::SetMoveCursor(CTrackGroup* pGroup,CPoint2D pt,double dHandleSize,CWellPole* pWell)
	{
		CTrackObj* pTrack = NULL;
		CWellBaseObj*  pObjIn = NULL;
		CTrackGroup* pTrackGroup = NULL;
		TRACKLIST::reverse_iterator rit = pGroup->GetTrackList().rbegin();
		for (; rit != pGroup->GetTrackList().rend(); rit++)
		{
			//设置光标移动到道边界、道头、道内对象时的状态
			double tracktop  = pWell->m_HeadRect.bottom-pWell->m_dHeightTrackHead;
			double trackbot = pWell->GetPos().bottom;
			pTrack = *rit;
			if (pTrack->GetTrackType()==Track_Group)
			{
				pTrackGroup = (CTrackGroup*)pTrack;
				if(pTrackGroup->FindTrackGroupOnRight(pt,dHandleSize) != NULL)
				{
					if(pWell->GetWellType() == Well_Incline && m_VCursor)
						SetCursor(m_VCursor);
					else
						SetCursor(AfxGetApp()->LoadCursor(IDC_SIZEWE));

					return TRUE;
				}
				else
				{
					if(SetMoveCursor(pTrackGroup,pt,dHandleSize,pWell))
						return TRUE;
					else if(pTrackGroup->IsInTrackHead(pt,dHandleSize))
					{
						SetCursor(AfxGetApp()->LoadCursor(IDC_MOVE4WAY));
						return TRUE;
					}
				}
			}
			else if(pTrack->IsOnTrackRight(pt,dHandleSize))
			{
				if(pWell->GetWellType() == Well_Incline && m_VCursor)
					SetCursor(m_VCursor);
				else
					SetCursor(AfxGetApp()->LoadCursor(IDC_SIZENS));

				return TRUE;
			}
			//道头上下边界
			else if (pTrack->IsOnTrackTop(pt,dHandleSize))
			{
				if(pWell->GetWellType() == Well_Incline && m_HCursor)
					SetCursor(m_HCursor);
				else
					SetCursor(AfxGetApp()->LoadCursor(IDC_SIZENS));

				return TRUE;
			}
			//井头边界
			else if (pTrack->IsOnWellTop(pt,dHandleSize))
			{
				if(pWell->GetWellType() == Well_Incline && m_HCursor)
					SetCursor(m_HCursor);
				else
					SetCursor(AfxGetApp()->LoadCursor(IDC_SIZENS));

				return TRUE;
			}
			////道内
			else if(pTrack->IsInTrackHead(pt,dHandleSize))
			{
				SetCursor(AfxGetApp()->LoadCursor(IDC_MOVE4WAY));
				return TRUE;
			}
			//道内子对象
			else if ((pt.y0<tracktop)&&(pt.y0>trackbot)&&(pt.x0>pTrack->m_HeadRect.left)&&(pt.x0<pTrack->GetPos().right))
			{
				CRect8 r = CRect8(pt.x0,pt.y0,pt.x0,pt.y0);
				CSize8 sz=GetDoc()->GetSelectSize();
				double sx=GetDC()->GetRealWidth(sz.cx);
				double sy=fabs(GetDC()->GetRealHeight(sz.cy));
				r.InflateRect(sx,sy);
				pObjIn = pTrack->ObjectAt(r,dHandleSize);
				
				if(pObjIn)
				{
					if ((pWell->GetWellType()==Well_Section) &&
							(pTrack->GetTrackType() == Track_Stratum || pTrack->GetTrackType() == Track_Result || pTrack->GetTrackType() == Track_StandardLayer))
					{
						SetCursor(AfxGetApp()->LoadCursor(IDC_MOVE4WAY));// (IDC_DRAG_BREAK));
						return TRUE;
					}
					else
					{
						if((pObjIn == pTrack &&(pTrack->GetTrackType()==Track_Curve||pTrack->GetTrackType()==Track_Discrete))
							|| pObjIn != pTrack)
						{
							SetCursor(AfxGetApp()->LoadCursor(IDC_MOVE4WAY));
							return TRUE;
						}
					}
				}
			}
		}

		return FALSE;
	}

	BOOL CItemSingleWell::SetMoveCursor(CTrackGroup* pGroup, CPoint2D pt, double dHandleSize, CWellPole* pWell, int& handle)
	{
		CTrackObj* pTrack = NULL;
		CWellBaseObj*  pObjIn = NULL;
		CTrackGroup* pTrackGroup = NULL;
		TRACKLIST::reverse_iterator rit = pGroup->GetTrackList().rbegin();
		for (; rit != pGroup->GetTrackList().rend(); rit++)
		{
			//设置光标移动到道边界、道头、道内对象时的状态
			double tracktop = pWell->m_HeadRect.bottom - pWell->m_dHeightTrackHead;
			double trackbot = pWell->GetPos().bottom;
			pTrack = *rit;
			if (pTrack->GetTrackType() == Track_Group)
			{
				pTrackGroup = (CTrackGroup*)pTrack;
				if (pTrackGroup->FindTrackGroupOnRight(pt, dHandleSize) != NULL)
				{
					
					if (pWell->GetWellType() == Well_Incline && m_VCursor)
						SetCursor(m_VCursor);
					else
						handle = 11;// SetCursor(AfxGetApp()->LoadCursor(IDC_SIZEWE));

					return TRUE;
				}
				else
				{
					if (SetMoveCursor(pTrackGroup, pt, dHandleSize, pWell, handle))
						return TRUE;
					else if (pTrackGroup->IsInTrackHead(pt, dHandleSize))
					{
						handle = 5;
						//SetCursor(AfxGetApp()->LoadCursor(IDC_MOVE4WAY));
						return TRUE;
					}
				}
			}
			else if (pTrack->IsOnTrackRight(pt, dHandleSize))
			{
				if (pWell->GetWellType() == Well_Incline && m_VCursor)
					SetCursor(m_VCursor);
				else
					handle = 11; // SetCursor(AfxGetApp()->LoadCursor(IDC_SIZENS));

				return TRUE;
			}
			//道头上下边界
			else if (pTrack->IsOnTrackTop(pt, dHandleSize))
			{
				if (pWell->GetWellType() == Well_Incline && m_HCursor)
					SetCursor(m_HCursor);
				else
					handle = 10; // SetCursor(AfxGetApp()->LoadCursor(IDC_SIZENS));

				return TRUE;
			}
			//井头边界
			else if (pTrack->IsOnWellTop(pt, dHandleSize))
			{
				if (pWell->GetWellType() == Well_Incline && m_HCursor)
					SetCursor(m_HCursor);
				else
					handle = 10; // SetCursor(AfxGetApp()->LoadCursor(IDC_SIZENS));

				return TRUE;
			}
			////道内
			else if (pTrack->IsInTrackHead(pt, dHandleSize))
			{
				handle = 5;//SetCursor(AfxGetApp()->LoadCursor(IDC_MOVE4WAY));
				return TRUE;
			}
			//道内子对象
			else if ((pt.y0 < tracktop) && (pt.y0 > trackbot) && (pt.x0 > pTrack->m_HeadRect.left) && (pt.x0 < pTrack->GetPos().right))
			{
				CRect8 r = CRect8(pt.x0, pt.y0, pt.x0, pt.y0);
				CSize8 sz = GetDoc()->GetSelectSize();
				double sx = GetDC()->GetRealWidth(sz.cx);
				double sy = fabs(GetDC()->GetRealHeight(sz.cy));
				r.InflateRect(sx, sy);
				pObjIn = pTrack->ObjectAt(r, dHandleSize);

				if (pObjIn)
				{
					if ((pWell->GetWellType() == Well_Section) &&
						(pTrack->GetTrackType() == Track_Stratum || pTrack->GetTrackType() == Track_Result || pTrack->GetTrackType() == Track_StandardLayer))
					{
						handle = 5;//SetCursor(AfxGetApp()->LoadCursor(IDC_MOVE4WAY));// (IDC_DRAG_BREAK));
						return TRUE;
					}
					else
					{
						if ((pObjIn == pTrack && (pTrack->GetTrackType() == Track_Curve || pTrack->GetTrackType() == Track_Discrete))
							|| pObjIn != pTrack)
						{
							handle = 5; // SetCursor(AfxGetApp()->LoadCursor(IDC_MOVE4WAY));
							return TRUE;
						}
					}
				}
			}
		}

		return FALSE;
	}
	BOOL CItemSingleWell::SortTrackWhenMoving(CTrackGroup* pGroup,CTrackObj* pTrackMoving, int& ideep)
	{
		////不移动
		if(pTrackMoving->m_HeadRect.PtInRect(pTrackMoving->m_active_head.CenterPoint()))
		{
			return FALSE;
		}
		if(ideep == 0)  //记录undo/redo时，执行一次就可以了，防止挪动一次道时如果递归调用，会有多次进行undo/redo
			SetReUnDoAction();
		ideep++;

		CTrackObj* pTrack = NULL;

		CTrackObj* pParentGroup = NULL;
		CWellBaseObj* pParentObj = NULL;
		pGroup->RemoveTrack(pTrackMoving);
		TRACKLIST::iterator posObj;
		TRACKLIST::iterator it = pGroup->GetTrackList().begin();
		for(; it!= pGroup->GetTrackList().end(); it++)
		{
			pTrack = *it; // pGroup->GetTrackList()->GetAt(pos);			
			posObj = it;

			pParentGroup = (CTrackGroup*)pTrack->GetParent();
			pParentObj = pTrack->GetParent();
			//由于插入道时从左到右，依次与链表中的道进行比较，所以下边判断落脚点在左部时只要横坐标小于目的道的中心点即可
			BOOL bLeft  = pTrackMoving->m_active_head.CenterPoint().x0 <= pTrack->m_HeadRect.CenterPoint().x0;
			BOOL bRight = pTrackMoving->m_active_head.CenterPoint().x0 >= pTrack->m_HeadRect.CenterPoint().x0 &&
				          pTrackMoving->m_active_head.CenterPoint().x0 <= pTrack->m_HeadRect.right;
			BOOL bIn = pTrack->m_HeadRect.PtInRect(pTrackMoving->m_active_head.CenterPoint());
			/////在道左侧
			//if (bLeft)
			//{
			//	if (pTrack->GetTrackType() == Track_Group)
			//	{
			//		CTrackGroup* pTrackGroup = (CTrackGroup*)pTrack;
			//		if (pTrackGroup->m_HeadRect.PtInRect(pTrackMoving->m_active_head.CenterPoint()))
			//		{//移动道的落脚点在pTrack内部
			//			if (pTrackGroup->GetGroupType() == Group_Vertical)
			//			{
			//				pTrackMoving->SetTrackWidth(pTrack->m_dTrackWidth / pTrackMoving->m_dTrackWidth);
			//				//TRACKLIST::iterator tit = pTrackGroup->GetTrackList().begin();
			//				//for (; tit != pTrackGroup->GetTrackList().end(); tit++)
			//				//{

			//				//}
			//				pTrackGroup->GetTrackList().push_back(pTrackMoving);
			//				//pTrackGroup->GetTrackList().insert(posObj, pTrackMoving);
			//				pTrackMoving->SetParent(pTrackGroup);
			//				return TRUE;
			//			}
			//			else
			//			{//水平组合道，则进入递归
			//				(SortTrackWhenMoving(pTrackGroup, pTrackMoving, ideep));

			//				return TRUE;
			//			}
			//		}
			//		else
			//		{
			//			if(pGroup->GetGroupType() == Group_Vertical)
			//			{
			//				pTrackMoving->SetTrackWidth(pGroup->m_dTrackWidth/pTrackMoving->m_dTrackWidth);
			//			}
			//			//pGroup->GetTrackList()->InsertBefore(posObj,pTrackMoving);
			//			pGroup->GetTrackList().insert(posObj, pTrackMoving);
			//			pTrackMoving->SetParent(pGroup);
			//			return TRUE;
			//		}
			//	}
			//	else
			//	{

			//		///////曲线与散点组合成纵向的组合道
			//		if ((pTrack->GetTrackType() == Track_Curve || pTrack->GetTrackType() == Track_Discrete ||
			//			pTrackMoving->GetTrackType() == Track_Curve || pTrackMoving->GetTrackType() == Track_Discrete) &&
			//			bIn)
			//		{
			//			CTrackGroup* pTrackGroup = new CTrackGroup();
			//			pTrackGroup->SetGroupType(Group_Vertical);
			//			pTrackGroup->m_font = pGroup->m_font;
			//			pTrackGroup->m_pen = pGroup->m_pen;
			//			pTrackGroup->m_HeadRect = pTrack->m_HeadRect;
			//			pTrackGroup->SetRange(pTrack->m_HeadRect);
			//			pTrackGroup->m_dTrackWidth = pTrack->m_dTrackWidth;
			//			pTrackMoving->m_dTrackWidth = pTrack->m_dTrackWidth;
			//			pTrackGroup->SetParent(pParentObj);

			//			pTrackGroup->SetParentXY(pGroup->GetParentXY());
			//			if (pTrack->m_HeadRect.CenterPoint().y0 > pTrackMoving->m_active_head.CenterPoint().y0)
			//			{
			//				pTrackGroup->AddTrack(pTrack);
			//				pTrackGroup->AddTrack(pTrackMoving);
			//			}
			//			else
			//			{
			//				pTrackGroup->AddTrack(pTrackMoving);
			//				pTrackGroup->AddTrack(pTrack);
			//			}
			//			pGroup->GetTrackList().insert(posObj, pTrackGroup);
			//			pGroup->GetTrackList().erase(posObj);
			//			return TRUE;
			//		}
			//		///////非曲线与散点道组合成水平方向的组合道
			//		else
			//		{
			//			if (pGroup->GetGroupType() == Group_Vertical)
			//			{
			//				pTrackMoving->SetTrackWidth(pGroup->m_dTrackWidth / pTrackMoving->m_dTrackWidth);
			//			}
			//			pGroup->GetTrackList().insert(posObj, pTrackMoving);
			//			pTrackMoving->SetParent(pGroup);
			//			return TRUE;
			//		}
			//	}
			//}
			///////道右侧
			//else if (bRight)
			if(bLeft || bRight)
			{
				if (pTrack->GetTrackType() == Track_Group)
				{//移动道的落脚点是子组合道,且在其右边的范围。
					CTrackGroup* pTrackGroup = (CTrackGroup*)pTrack;
					if(bIn) //pTrackGroup->m_HeadRect.PtInRect(pTrackMoving->m_active_head.CenterPoint()))
					{//移动道的落脚点在pTrack内部
						if (pTrackGroup->GetGroupType() == Group_Vertical)
						{
							pTrackMoving->SetTrackWidthRatio(pTrack->m_dTrackWidth/pTrackMoving->m_dTrackWidth);
							pTrackGroup->GetTrackList().push_back(pTrackMoving);
							pTrackMoving->SetParent(pTrackGroup);
							return TRUE;
						}
						else 
						{//水平组合道，则进入递归
							(SortTrackWhenMoving(pTrackGroup, pTrackMoving, ideep));

							return TRUE;
						}
					}
					else
					{//移动道的落脚点不在pTrack内部，但其落脚点在pTrack的上边或下边，则直接加入到pGroup
						if(pGroup->GetGroupType() == Group_Vertical)
						{
							pTrackMoving->SetTrackWidthRatio(pGroup->m_dTrackWidth/pTrackMoving->m_dTrackWidth);
						}
						if(bRight) //落脚点在目的道的右侧，则加入到目的道的后面
							posObj++;
						pGroup->GetTrackList().insert(posObj,pTrackMoving);
						pTrackMoving->SetParent(pGroup);
						return TRUE;
					}
				}
				else
				{//移动道的落脚点是不是组合道,在右边的范围

					if ((pTrack->GetTrackType() == Track_Curve || pTrack->GetTrackType() == Track_Discrete ||
						pTrackMoving->GetTrackType() == Track_Curve || pTrackMoving->GetTrackType() == Track_Discrete) &&
						bIn)
					{//曲线或散点道进行垂直组合，并将新的组合道加入
						CTrackGroup* pTrackGroup = new CTrackGroup();
						pTrackGroup->SetGroupType(Group_Vertical);
						pTrackGroup->m_font = pGroup->m_font;
						pTrackGroup->m_pen = pGroup->m_pen;
						pTrackGroup->m_dTrackWidth = pTrack->m_dTrackWidth;
						pTrackMoving->m_dTrackWidth = pTrack->m_dTrackWidth;

						pTrackGroup->SetParent(pParentObj);
						pTrackGroup->SetParentXY(pGroup->GetParentXY());
						if (pTrack->m_HeadRect.CenterPoint().y0 > pTrackMoving->m_active_head.CenterPoint().y0)
						{
							pTrackGroup->AddTrack(pTrack);
							pTrackGroup->AddTrack(pTrackMoving);
						}
						else
						{
							pTrackGroup->AddTrack(pTrackMoving);
							pTrackGroup->AddTrack(pTrack);
						}
						pGroup->GetTrackList().insert(posObj, pTrackGroup);
						pGroup->GetTrackList().erase(posObj);
						return TRUE;
					}
					else
					{//其它类型的道，直接加入。
						if (pGroup->GetGroupType() == Group_Vertical)
						{
							pTrackMoving->SetTrackWidthRatio(pGroup->m_dTrackWidth / pTrackMoving->m_dTrackWidth);
						}
						if (bRight)
							posObj++;
						pGroup->GetTrackList().insert(posObj, pTrackMoving);
						pTrackMoving->SetParent(pGroup);
						return TRUE;
					}
				}
			}
		}


		//最后一条道右侧
		if(pGroup->GetGroupType() == Group_Vertical)
		{
			pTrackMoving->SetTrackWidthRatio(pGroup->m_dTrackWidth/pTrackMoving->m_dTrackWidth);
		}
		pGroup->GetTrackList().push_back(pTrackMoving);
		pTrackMoving->SetParent(pGroup);
		return TRUE;
	
	//	return FALSE;
	}

	void CItemSingleWell::SetDrawObj(CWellBaseObj* pObj)		
	{ 
		double oldangle = 0 ;
		//if(m_pWell)
		//	oldangle = m_pWell->GetHeadLineAngle();

		m_pWell = (CWellPole*)pObj;

		if(m_pWell)
		{
			//if(abs(m_pWell->GetHeadLineAngle() - oldangle)>0.0001)
			//	CreateVHCursor();
		}
	}
	void CItemSingleWell::DestroyVHCursor()
	{
		if(m_HCursor)
		{
			::DestroyCursor(m_HCursor);
			m_HCursor = NULL;
			m_pHCursorBmp->DeleteObject();
			delete m_pHCursorBmp;
			m_pHCursorMaskBmp->DeleteObject();
			delete m_pHCursorMaskBmp;
		}
		if(m_VCursor)
		{
			::DestroyCursor(m_VCursor);
			m_VCursor = NULL;
			m_pVCursorBmp->DeleteObject();
			delete m_pVCursorBmp;
			m_pVCursorMaskBmp->DeleteObject();
			delete m_pVCursorMaskBmp;
		}
	}
	void CItemSingleWell::CreateVHCursor()
	{
		if(!m_pWell)
			return;
		if(m_pWell->GetWellType() == Well_Incline)
		{
			if(abs(m_pWell->GetHeadLineAngle())<0.0001)
				return;

			DestroyVHCursor();

			HCURSOR cursor = AfxGetApp()->LoadCursor(IDC_SIZEWE) ;//AfxGetApp()->LoadStandardCursor(IDC_DRAG_HOR);
			m_pVCursorBmp = new CBitmap;
			m_pVCursorMaskBmp = new CBitmap;
			m_VCursor = CreateAngleCursor(cursor,m_pVCursorBmp,m_pVCursorMaskBmp,-m_pWell->GetHeadLineAngle());

			cursor = AfxGetApp()->LoadCursor(IDC_SIZENS) ;//AfxGetApp()->LoadStandardCursor(IDC_DRAG_HOR);
			m_pHCursorBmp = new CBitmap;
			m_pHCursorMaskBmp = new CBitmap;
			m_HCursor = CreateAngleCursor(cursor,m_pHCursorBmp,m_pHCursorMaskBmp,-m_pWell->GetHeadLineAngle());
		}
	}

	HCURSOR CItemSingleWell::CreateAngleCursor(HCURSOR cursor,CBitmap* pCursorBmp ,CBitmap* pCursorMaskBmp,double angle)
	{
		HCURSOR retCursor = NULL;

		ICONINFO cursorinfo;
		BOOL b = GetIconInfo((HICON)(cursor),&cursorinfo);

		BITMAP maskBitInfo,cursorBitInfo;
		::GetObject((HGDIOBJ)cursorinfo.hbmMask,sizeof(BITMAP),&maskBitInfo);//得到原始光标的掩码为图信息
		::GetObject((HGDIOBJ)cursorinfo.hbmColor,sizeof(BITMAP),&cursorBitInfo);//得到原始光标的位图信息

		CBitmap sCousorbmp,sMaskbmp;
		sCousorbmp.Attach(cursorinfo.hbmColor);
		sMaskbmp.Attach(cursorinfo.hbmMask);

		CDC *pDC = GetDC()->GetDC();

		CPoint2D pospts[4];  //原始光标的大小
		pospts[0].x0 = 0; pospts[0].y0 = maskBitInfo.bmHeight;
		pospts[1].x0 = maskBitInfo.bmWidth; pospts[1].y0 = maskBitInfo.bmHeight;
		pospts[2].x0 = maskBitInfo.bmWidth; pospts[2].y0 = 0;
		pospts[3].x0 = 0; pospts[3].y0 = 0;

		for(int ii = 0; ii< 4; ii++)
		{
			//pospts[ii].RotatePt(0,0,angle);
		}
		CPoint plgPts[4];//旋转后放置新光标的四个角坐标

		CPoint topleftPt,botRightPt,tpt;  //放置旋转后光标区域的左上，右下角
		botRightPt.x = topleftPt.x = int(pospts[0].x0);
		botRightPt.y = topleftPt.y = int(pospts[0].y0);
		for(int ii =0;ii<4; ii++)
		{
			tpt.x = int(pospts[ii].x0);
			tpt.y = int(pospts[ii].y0);
			plgPts[ii] = tpt;
			if(tpt.x <topleftPt.x)
				topleftPt.x = tpt.x;
			if(tpt.x>botRightPt.x)
				botRightPt.x = tpt.x;
			if(tpt.y< topleftPt.y)
				topleftPt.y = tpt.y;
			if(tpt.y>botRightPt.y)
				botRightPt.y  = tpt.y;
		}

		if(topleftPt.y<0) //如果旋转后有坐标小于0，就偏移一下，确保光标的区域及坐标是正数
		{
			int l = -topleftPt.y;
			topleftPt.y += l;
			botRightPt.y+=l;
			for(int ii = 0; ii<4; ii++)
			{
				plgPts[ii].y+=l;
			}
		}
		if(topleftPt.x<0)//如果旋转后有坐标小于0，就偏移一下，确保光标的区域及坐标是正数
		{
			int l = -topleftPt.x;
			botRightPt.x += l;
			topleftPt.x+=l;
			for(int ii = 0; ii<4; ii++)
			{
				plgPts[ii].x+=l;
			}
		}

		CRect rect;
		rect.SetRect(topleftPt,botRightPt); //旋转后光标的区域

		CBitmap *pOldBitmap;
		CBitmap *pOldmaskmap;

		CDC dc; dc.CreateCompatibleDC(pDC);
		CDC smaskdc,scursordc;
		smaskdc.CreateCompatibleDC(pDC);
		scursordc.CreateCompatibleDC(pDC);

		pOldmaskmap = smaskdc.SelectObject(&sMaskbmp);  //使用原始光标的掩码位图
		pOldBitmap = scursordc.SelectObject(&sCousorbmp); //使用原始光标的位图

		CDC memDC;
		memDC.CreateCompatibleDC(&dc);

		CBitmap *pNewbkCousorbmp; //使用原始光标的位图及掩码位图形成一个新的光标位图，这个新的光标位图的背景色制定为蓝色
		pNewbkCousorbmp = new CBitmap;
		pNewbkCousorbmp->CreateBitmap(cursorBitInfo.bmWidth,cursorBitInfo.bmHeight,cursorBitInfo.bmPlanes,cursorBitInfo.bmBitsPixel,NULL);
		CBitmap *pOldNewbkBmp = memDC.SelectObject(pNewbkCousorbmp);
		memDC.FillSolidRect(0,0,cursorBitInfo.bmWidth,cursorBitInfo.bmHeight,RGB(0,0,255));//新位图充填蓝色

		scursordc.SetBkColor(RGB(0,0,0));
		scursordc.SetTextColor(RGB(255,255,255));
		scursordc.BitBlt(0,0,maskBitInfo.bmWidth,maskBitInfo.bmHeight,&smaskdc,0,0,SRCAND);

		memDC.SetBkColor(RGB(255,255,255));
		memDC.SetTextColor(RGB(0,0,0));
		memDC.BitBlt(0,0,cursorBitInfo.bmWidth,cursorBitInfo.bmHeight,&smaskdc,0,0,SRCAND);

		memDC.BitBlt(0,0,cursorBitInfo.bmWidth,cursorBitInfo.bmHeight,&scursordc,0,0,SRCPAINT);//声称了所需的新光标位图，蓝色背景色(上述代码是透明位图的原理)

		//pDC->BitBlt(10,100,maskBitInfo.bmWidth,maskBitInfo.bmHeight,&memDC,0,0,SRCCOPY);

		smaskdc.SelectObject(pOldmaskmap);
		scursordc.SelectObject(pOldBitmap);
		smaskdc.DeleteDC(); scursordc.DeleteDC();

		//pCursorBmp = new CBitmap();
		pCursorBmp->CreateBitmap(rect.Width(),rect.Height(),cursorBitInfo.bmPlanes,cursorBitInfo.bmBitsPixel,NULL);//将需要的光标位图按照旋转后的大小生成

		pOldBitmap = dc.SelectObject(pCursorBmp);

		//pCursorMaskmap = new CBitmap();
		pCursorMaskBmp->CreateBitmap(rect.Width(),rect.Height(),1,1,NULL);//将需要的光标掩码位图按照旋转后的大小生成

		CPoint points[3];
		points[0] = plgPts[0]; /*points[0].Offset(-rect.left,-rect.top);*/
		points[1] = plgPts[1];/* points[1].Offset(-rect.left,-rect.top);*/
		points[2] = plgPts[3]; /*points[2].Offset(-rect.left,-rect.top);*/
		CBitmap maskBmp;
		ZeroMemory(&maskBmp,sizeof(maskBmp));
		dc.FillSolidRect(0,0,rect.Width(),rect.Height(),RGB(0,0,255));  //将有角度光标的位图背景全部蓝色
		dc.PlgBlt(points,&memDC,0,0,cursorBitInfo.bmWidth,cursorBitInfo.bmHeight,maskBmp,0,0);//将上面新制作的新背景光标位图旋转
		maskBmp.DeleteObject();

		memDC.SelectObject(pOldNewbkBmp);
		delete pNewbkCousorbmp;

		pOldmaskmap = memDC.SelectObject(pCursorMaskBmp);
		dc.SetBkColor(RGB(0,0,255));
		memDC.BitBlt(0,0,rect.Width(),rect.Height(),&dc,0,0,SRCCOPY);//生成有角度光标的掩码为图,透明色是蓝色

		//pDC->BitBlt(100,10,rect.Width(),rect.Height(),&memDC,0,0,SRCCOPY);

		//pDC->BitBlt(100,100,rect.Width(),rect.Height(),&dc,0,0,SRCCOPY);

		memDC.SelectObject(pOldmaskmap);
		memDC.DeleteDC();

		dc.SelectObject(pOldBitmap);

		ICONINFO newicon;
		newicon.fIcon = FALSE;
		newicon.xHotspot = rect.Width()/2;
		newicon.yHotspot = rect.Height()/2;
		newicon.hbmMask = HBITMAP(pCursorMaskBmp->GetSafeHandle());
		newicon.hbmColor = HBITMAP(pCursorBmp->GetSafeHandle());

		retCursor = ::CreateIconIndirect(&newicon);

		sCousorbmp.Detach();
		sMaskbmp.Detach();

		::DeleteObject(cursorinfo.hbmColor);
		::DeleteObject(cursorinfo.hbmMask);

		return retCursor;
	}
	void CItemSingleWell::DrawHandle(CXyDC *pDC, const CPoint2D &point)
	{
		CItemNestBase::DrawHandle(pDC,point);
	}
	void CItemSingleWell::DrawHandle(CXyDC *pDC)
	{
		if(m_pWell != NULL)
		{
			if(m_pWell->GetWellType() == Well_Incline)
			{
				//std::vector<CPoint2D> pts;
				//m_pWell->GetFrameCurve(pts);

				//LOGBRUSH logBrush ;
				//logBrush.lbStyle = BS_SOLID;
				//logBrush.lbColor = RGB(255,133,133);
				//CPen pen,*pOldPen;
				//pen.CreatePen(PS_DOT|PS_GEOMETRIC|PS_ENDCAP_SQUARE,3,&logBrush);
				//pOldPen = pDC->GetDC()->SelectObject(&pen);

				//CPoint pt,pt0;
				//if(pts.size()>0)
				//{
				//	pt0 = pDC->GetScreen(pts[0]);
				//	pDC->GetDC()->MoveTo(pt0);
				//	for(int ii = 1; ii< pts.size(); ii++)
				//	{
				//		pt = pDC->GetScreen(pts[ii]);
				//		pDC->GetDC()->LineTo(pt);
				//	}
				//	pDC->GetDC()->LineTo(pt0);
				//}
				////pDC->GetDC()->SetROP2(rop2);
				//pen.DeleteObject();
				//pDC->GetDC()->SelectObject(pOldPen);

			}
			else
				CItemNestBase::DrawHandle(pDC);
		}
		else
			CItemNestBase::DrawHandle(pDC);
	}

	BOOL CItemSingleWell::AnalysisPor()
	{
	/*	CWellPole* pWell = GetWellObject();
		if (NULL == pWell)
		{
			return FALSE;
		}
		CDlgCurvePorAnalysis dlg;

		CTrackList CurveList;
		pWell->GetTrackCurve(&CurveList);
		POSITION pos = CurveList.GetHeadPosition();
		while(pos)
		{
			CTrackCurveObj* pTrackCurve = (CTrackCurveObj*)CurveList.GetNext(pos);
			dlg.m_CurveList.AddTail(pTrackCurve->GetDataObj());
			dlg.m_Por1.m_CurveList.AddTail(pTrackCurve->GetDataObj());
		}

		CDataObj_Curve *pChild = NULL;

		if(dlg.m_CurveList.GetCount() > 0)
		{
			pChild = (CDataObj_Curve*)dlg.m_CurveList.GetHead();
		}

		if(pChild ==  NULL) 
		{
			return FALSE;
		}
		double PorTemp,SwWaterTemp,SwOilTemp,AnalysisHd;
		dlg.m_Por1.m_stdep = pChild->m_startdep;
		dlg.m_Por1.m_endep = pChild->m_enddep;
		dlg.m_Por1.m_rlev = pChild->m_rlev;
		dlg.m_Por1.m_porPara.sdep = dlg.m_Por1.m_stdep;
		dlg.m_Por1.m_porPara.edep = dlg.m_Por1.m_endep;
		dlg.m_Por2.m_stdep = pWell->m_fSdep;
		dlg.m_Por2.m_endep = pWell->m_fEdep;
		if (dlg.DoModal() != IDOK)
		{
			return FALSE;
		}
		PorTemp     = dlg.m_Por;
		SwWaterTemp = dlg.m_SwWater;
		SwOilTemp   = dlg.m_SwOil;
		AnalysisHd  = dlg.m_AnalysisHd;
		if (!dlg.m_bAddTrack)
		{
			return FALSE;
		}
		CreatePorTrack(pWell,dlg.m_Por1.m_CurveList,dlg.m_bShowAnalysis,PorTemp,SwWaterTemp,SwOilTemp,AnalysisHd);*/

		return TRUE;
	}

	BOOL CItemSingleWell::AnalysisSand()
	{
		//CWellPole* pWell = GetWellObject();
		//if (NULL == pWell)
		//{
		//	return FALSE;
		//}
		//CDlgCurveSandAnalysis dlg;

		//CTrackList CurveList;
		//pWell->GetTrackCurve(&CurveList);
		//POSITION pos = CurveList.GetHeadPosition();
		//while(pos)
		//{
		//	CTrackCurveObj* pTrackCurve = (CTrackCurveObj*)CurveList.GetNext(pos);
		//	dlg.m_CurveList.AddTail(pTrackCurve->GetDataObj());
		//	dlg.m_Sand1.m_CurveList.AddTail(pTrackCurve->GetDataObj());
		//	dlg.m_Sand2.m_CurveList.AddTail(pTrackCurve->GetDataObj());
		//}
		//CurveList.RemoveAll();

		//CDataObj_Curve *pChild = NULL;

		//if(dlg.m_CurveList.GetCount() > 0)
		//{
		//	pChild = (CDataObj_Curve*)dlg.m_CurveList.GetHead();
		//}

		//if(pChild ==  NULL) 
		//{
		//	return FALSE;
		//}
		//dlg.m_Sand1.m_rlev = pChild->m_rlev;
		//dlg.m_Sand1.m_stdep = pWell->m_fSdep;
		//dlg.m_Sand1.m_endep = pWell->m_fEdep;
		//dlg.m_Sand1.m_sandPara.sdep = pChild->m_startdep;
		//dlg.m_Sand1.m_sandPara.edep = pChild->m_enddep;
		////dlg.m_Sand1.m_pCurve = pCurveData;

		////dlg.m_Sand2.m_pCurve = pCurveData;
		//dlg.m_Sand2.m_rlev = pChild->m_rlev;
		//dlg.m_Sand2.m_sandPara.sdep = pWell->m_fSdep;
		//dlg.m_Sand2.m_sandPara.edep = pWell->m_fEdep;
		//dlg.m_Sand2.m_stdep = pWell->m_fSdep;
		//dlg.m_Sand2.m_endep = pWell->m_fEdep;

		//if(dlg.DoModal() != IDOK)
		//{
		//	return FALSE;
		//}

		//double PorTemp,SwWaterTemp,SwOilTemp,AnalysisHd;
		//PorTemp = dlg.m_Por;
		//SwWaterTemp = dlg.m_SwWater;
		//SwOilTemp = dlg.m_SwOil;
		//AnalysisHd = dlg.m_AnalysisHd;
		//if (!dlg.m_bAddTrack)
		//{
		//	return FALSE;
		//}

		//CreateSandTrack(pWell,dlg.m_Sand1.m_CurveList,dlg.m_bShowAnalysis,PorTemp,SwWaterTemp,SwOilTemp,AnalysisHd);
	
		return TRUE;
	}

	BOOL CItemSingleWell::CalculatePor()
	{	
		//CTrackObj* pTrackSelected = NULL;
		//CWellBaseObj* pObjSelected = NULL;
		//if(m_WellObjSelectlist.GetCount() > 0)
		//	pObjSelected = m_WellObjSelectlist.GetHead();

		//if (pObjSelected->GetType() == GDOUBLEFOX_TRACK)
		//{
		//	pTrackSelected = (CTrackObj*)pObjSelected;
		//}

		//if (NULL == pTrackSelected)
		//	return FALSE;

		//if(pTrackSelected->GetTrackType() != Track_Curve)
		//	return FALSE;

		//CTrackCurveObj* pTrackCurve = (CTrackCurveObj*)pTrackSelected;
		//CDlgCurvePor dlg;
		//dlg.m_dSkeleon = pTrackCurve->m_curve_left;
		//dlg.m_dFluid = pTrackCurve->m_curve_right;
		//if(dlg.DoModal() != IDOK)
		//	return FALSE;

		//CTrackCurveObj* pTrackCurveNew = new CTrackCurveObj;
		//pTrackCurveNew->m_strTrackName = "POR";
		//pTrackCurveNew->m_curve_left = 0.0;
		//pTrackCurveNew->m_curve_right = 100.0;
		//pTrackCurveNew->m_pen = pTrackCurve->m_pen;
		//pTrackCurveNew->m_penCurve = pTrackCurve->m_penCurve;
		//pTrackCurveNew->m_font = pTrackCurve->m_font;
		//pTrackCurveNew->m_fontHeadMark = pTrackCurve->m_fontHeadMark;
		//pTrackCurveNew->m_dataObj.m_curve_name = pTrackCurveNew->m_strTitle;
		//pTrackCurveNew->m_dataObj.m_curve_unit = pTrackCurve->m_dataObj.m_depth_unit;
		//pTrackCurveNew->m_dataObj.m_startdep = pTrackCurve->m_dataObj.m_startdep;
		//pTrackCurveNew->m_dataObj.m_enddep = pTrackCurve->m_dataObj.m_enddep;
		//pTrackCurveNew->m_dataObj.m_rlev = pTrackCurve->m_dataObj.m_rlev;
		//pTrackCurveNew->m_dataObj.m_construct_num = pTrackCurve->m_dataObj.m_construct_num;
		//pTrackCurveNew->m_dataObj.m_maxvalue = pTrackCurve->m_dataObj.m_maxvalue;
		//pTrackCurveNew->m_dataObj.m_minvalue = pTrackCurve->m_dataObj.m_minvalue;
		//pTrackCurveNew->m_dataObj.m_sample_count = pTrackCurve->m_dataObj.m_sample_count;

		//if(pTrackCurveNew->m_dataObj.m_sample_count > 0)
		//{
		//	pTrackCurveNew->m_dataObj.m_curve_depth = new float [pTrackCurveNew->m_dataObj.m_sample_count];
		//	pTrackCurveNew->m_dataObj.m_curve_value = new float [pTrackCurveNew->m_dataObj.m_sample_count];

		//	double dValue = 0;
		//	for(int i=0; i<pTrackCurveNew->m_dataObj.m_sample_count; i++)
		//	{
		//		pTrackCurveNew->m_dataObj.m_curve_depth[i] = pTrackCurve->m_dataObj.m_curve_depth[i];
		//		dValue = (pTrackCurve->m_dataObj.m_curve_value[i]-dlg.m_dSkeleon)/(dlg.m_dFluid-dlg.m_dSkeleon);
		//		pTrackCurveNew->m_dataObj.m_curve_value[i] = dValue * 100.0;
		//	}
		//}

		////插入道下方
		//CTrackList tracklist;
		//tracklist.AddTail(pTrackCurveNew);
		//AddTrack(pTrackSelected, tracklist, TRUE);

		return TRUE;
	}

	BOOL CItemSingleWell::CalculateSH()
	{	
		//CTrackObj* pTrackSelected = NULL;
		//CWellBaseObj* pObjSelected = NULL;
		//if(m_WellObjSelectlist.GetCount() > 0)
		//	pObjSelected = m_WellObjSelectlist.GetHead();

		//if (pObjSelected->GetType() == GDOUBLEFOX_TRACK)
		//{
		//	pTrackSelected = (CTrackObj*)pObjSelected;
		//}

		//if (NULL == pTrackSelected)
		//	return FALSE;

		//if(pTrackSelected->GetTrackType() != Track_Curve)
		//	return FALSE;

		//CTrackCurveObj* pTrackCurve = (CTrackCurveObj*)pTrackSelected;
		//CDlgCurveSH dlg;
		//dlg.m_dSand = pTrackCurve->m_curve_left;
		//dlg.m_dMud = pTrackCurve->m_curve_right;
		//if(dlg.DoModal() != IDOK)
		//	return FALSE;

		//CTrackCurveObj* pTrackCurveNew = new CTrackCurveObj;
		//pTrackCurveNew->m_strTrackName = "SH";
		//pTrackCurveNew->m_curve_left = 0.0;
		//pTrackCurveNew->m_curve_right = 100.0;
		//pTrackCurveNew->m_pen = pTrackCurve->m_pen;
		//pTrackCurveNew->m_penCurve = pTrackCurve->m_penCurve;
		//pTrackCurveNew->m_font = pTrackCurve->m_font;
		//pTrackCurveNew->m_fontHeadMark = pTrackCurve->m_fontHeadMark;
		//pTrackCurveNew->m_dataObj.m_curve_name = pTrackCurveNew->m_strTitle;
		//pTrackCurveNew->m_dataObj.m_curve_unit = pTrackCurve->m_dataObj.m_depth_unit;
		//pTrackCurveNew->m_dataObj.m_startdep = pTrackCurve->m_dataObj.m_startdep;
		//pTrackCurveNew->m_dataObj.m_enddep = pTrackCurve->m_dataObj.m_enddep;
		//pTrackCurveNew->m_dataObj.m_rlev = pTrackCurve->m_dataObj.m_rlev;
		//pTrackCurveNew->m_dataObj.m_construct_num = pTrackCurve->m_dataObj.m_construct_num;
		//pTrackCurveNew->m_dataObj.m_maxvalue = pTrackCurve->m_dataObj.m_maxvalue;
		//pTrackCurveNew->m_dataObj.m_minvalue = pTrackCurve->m_dataObj.m_minvalue;
		//pTrackCurveNew->m_dataObj.m_sample_count = pTrackCurve->m_dataObj.m_sample_count;
		//if(pTrackCurveNew->m_dataObj.m_sample_count > 0)
		//{
		//	pTrackCurveNew->m_dataObj.m_curve_depth = new float [pTrackCurveNew->m_dataObj.m_sample_count];
		//	pTrackCurveNew->m_dataObj.m_curve_value = new float [pTrackCurveNew->m_dataObj.m_sample_count];
		//	double dValue = 0;
		//	for(int i=0; i<pTrackCurveNew->m_dataObj.m_sample_count; i++)
		//	{
		//		pTrackCurveNew->m_dataObj.m_curve_depth[i] = pTrackCurve->m_dataObj.m_curve_depth[i];
		//		dValue = (pTrackCurve->m_dataObj.m_curve_value[i] - dlg.m_dSand)/(dlg.m_dMud - dlg.m_dSand);
		//		if(dValue < 0.0) dValue = 0.0; 
		//		if(dValue > 1.0) dValue = 1.0; 
		//		dValue = (exp(dlg.m_dGCUR * dValue * log(2.0)) - 1.0) / (exp(dlg.m_dGCUR * log(2.0)) - 1.0); 
		//		if(dValue < 0.0) dValue = 0.0; 
		//		if(dValue > .999) dValue = .999; 
		//		pTrackCurveNew->m_dataObj.m_curve_value[i] = dValue * 100.0;
		//	}
		//}
		////插入到道下面
		//CTrackList tracklist;
		//tracklist.AddTail(pTrackCurveNew);
		//AddTrack(pTrackSelected, tracklist, TRUE);

		return TRUE;
	}

	void CItemSingleWell::CurveDataStatistic()
	{
		if(GetItem() == NULL)
			return;

		CWellBaseObj* pObjSelect = ((CItemWellBase*)GetItem())->GetDrawObj();
		//if (pObjSelect->GetType() == GDOUBLEFOX_LOGCURVESEGMENT)
		//{
		//	CTrackInCurveSegment* pTrackInCurveSegment = (CTrackInCurveSegment*)pObjSelect;
		//	CTrackCurveObj* pTrackCurve = (CTrackCurveObj*)pTrackInCurveSegment->GetParentObj();

		//	double sdep = pTrackInCurveSegment->m_fSdep;
		//	double edep = pTrackInCurveSegment->m_fEdep;
		//	//标准化顶底深
		//	if(float(sdep/pTrackCurve->m_fRlev) != int(sdep/pTrackCurve->m_fRlev))
		//	{
		//		sdep = float(int(sdep/pTrackCurve->m_fRlev + 1)*pTrackCurve->m_fRlev);
		//	}
		//	if(float(edep/pTrackCurve->m_fRlev) != int(edep/pTrackCurve->m_fRlev))
		//	{
		//		edep = float(int(edep/pTrackCurve->m_fRlev)*pTrackCurve->m_fRlev);
		//	}

		//	StringVectorSet	datas;
		//	vector<CString> vectorfield;
		//	vectorfield.push_back("DEPTH");
		//	vectorfield.push_back(pTrackCurve->m_strTrackName);
		//	CString strDepth;
		//	CString strValue;
		//	double  fDepth;
		//	vector<CString> vectorinfor;
		//	int nCount = int((edep - sdep)/pTrackCurve->m_fRlev) + 1;

		//	CString strTitle;
		//	strTitle.LoadString(IDS_STR_TEMPLATE_CHART);
		//	CPropertySheet StatisticSheet(strTitle);
		//	StatisticSheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;
		//	CDlgCurveStatisticHistogram page1;
		//	page1.m_StructCurveData.fSdep = sdep;
		//	page1.m_StructCurveData.fEdep = edep;
		//	page1.m_StructCurveData.fRlev = pTrackCurve->m_fRlev;
		//	page1.m_StructCurveData.curve_name = pTrackCurve->m_strTrackName;
		//	page1.m_StructCurveData.curve_num = pTrackCurve->m_curve_num;
		//	page1.m_StructCurveData.curve_value = new float[nCount];
		//	page1.m_StructCurveData.curve_depth = new float[nCount];


		//	int curveStart = int((sdep - pTrackCurve->m_fSdep)/pTrackCurve->m_fRlev+0.5);
		//	for(int j=0; j<nCount; j++)
		//	{
		//		page1.m_StructCurveData.curve_value[j] = pTrackCurve->GetCurveValue(curveStart+j);
		//		page1.m_StructCurveData.curve_depth[j] = sdep+j*pTrackCurve->m_fRlev;
		//		vectorinfor.clear();
		//		strValue.Format("%f",pTrackCurve->GetCurveValue(curveStart+j));
		//		fDepth = sdep+j*pTrackCurve->m_fRlev;
		//		strDepth.Format("%f",fDepth);
		//		vectorinfor.push_back(strDepth);
		//		vectorinfor.push_back(strValue);
		//		datas.push_back(vectorinfor);
		//	}
		//	page1.m_strTrackName = pTrackCurve->m_strTrackName;
		//	StatisticSheet.AddPage(&page1);

		//	CDataPropertyPage datapage(vectorfield,datas);
		//	datapage.SetGridCtrlEdit(false);
		//	datapage.SetCurveStatistic(true);

		//	StatisticSheet.AddPage(&datapage);
		//	StatisticSheet.DoModal();
		//}
		//if (pObjSelect->GetType() == KEP_TRACK)
		//{
		//	CTrackObj* pTrack = (CTrackObj*)pObjSelect;

		//	//获取图道的数据表、字段
		//	CString table;		
		//	CDataTableConfig      TempDataConfig;
		//	CString strTitle;
		//	strTitle.LoadString(IDS_STR_TEMPLATE_CHART);
		//	if (pTrack->GetTrackType() == Track_Curve)
		//	{
		//		CTrackCurveObj* pTrackCurve = (CTrackCurveObj*)pTrack;
		//		if (0 == pTrackCurve->GetDataCount())
		//		{
		//			return;
		//		}
		//		double sdep = pTrackCurve->m_fSdep;
		//		double edep = pTrackCurve->m_fEdep;
		//		//标准化顶底深
		//		if(float(sdep/pTrackCurve->m_fRlev) != int(sdep/pTrackCurve->m_fRlev))
		//		{
		//			sdep = float(int(sdep/pTrackCurve->m_fRlev + 1)*pTrackCurve->m_fRlev);
		//		}
		//		if(float(edep/pTrackCurve->m_fRlev) != int(edep/pTrackCurve->m_fRlev))
		//		{
		//			edep = float(int(edep/pTrackCurve->m_fRlev)*pTrackCurve->m_fRlev);
		//		}

		//		StringVectorSet	datas;
		//		vector<CString> vectorfield;
		//		vectorfield.push_back("DEPTH");
		//		vectorfield.push_back(pTrackCurve->m_strTrackName);
		//		CString strDepth;
		//		CString strValue;
		//		double  fDepth;
		//		vector<CString> vectorinfor;

		//		CPropertySheet StatisticSheet(strTitle);
		//		StatisticSheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;
		//		CDlgCurveStatisticHistogram page1;
		//		page1.m_StructCurveData.fSdep = sdep;
		//		page1.m_StructCurveData.fEdep = edep;
		//		page1.m_StructCurveData.fRlev = pTrackCurve->m_fRlev;
		//		page1.m_StructCurveData.curve_name = pTrackCurve->m_strTrackName;
		//		page1.m_StructCurveData.curve_num = pTrackCurve->m_curve_num;
		//		page1.m_StructCurveData.curve_value = new float[pTrackCurve->GetDataCount()];
		//		page1.m_StructCurveData.curve_depth = new float[pTrackCurve->GetDataCount()];
		//		for(int j=0; j<pTrackCurve->GetDataCount(); j++)
		//		{
		//			page1.m_StructCurveData.curve_value[j] = pTrackCurve->GetCurveValue(j);
		//			page1.m_StructCurveData.curve_depth[j] = sdep+j*pTrackCurve->m_fRlev;
		//			vectorinfor.clear();
		//			strValue.Format("%f",pTrackCurve->GetCurveValue(j));
		//			fDepth = sdep+j*pTrackCurve->m_fRlev;
		//			strDepth.Format("%f",fDepth);
		//			vectorinfor.push_back(strDepth);
		//			vectorinfor.push_back(strValue);
		//			datas.push_back(vectorinfor);
		//		}
		//		page1.m_strTrackName = pTrackCurve->m_strTrackName;
		//		StatisticSheet.AddPage(&page1);

		//		TempDataConfig.SetTableID("Curve");
		//		TempDataConfig.Read();
		//		table = TempDataConfig.GetTableBase();

		//		CDataTrackPropertyPage datapage(GetWellObject(),pTrackCurve,datas,table,pTrackCurve->m_strTrackName);
		//		datapage.m_bCurve = TRUE;
		//		datapage.SetDataConfig(TempDataConfig);
		//		datapage.SetGridCtrlEdit(false);
		//		datapage.SetCurveStatistic(true);

		//		StatisticSheet.AddPage(&datapage);
		//		StatisticSheet.DoModal();
		//	}
		//	else if (pTrack->GetTrackType() == Track_Discrete)
		//	{
		//		CTrackDiscreteObj* pTrackDiscrete = (CTrackDiscreteObj*)pTrack;
		//		if (0 == pTrackDiscrete->GetDataCount())
		//		{
		//			return;
		//		}
		//		CWellPole* pWell = (CWellPole*)pTrackDiscrete->GetParentObj();
		//		double sdep = pWell->m_fSdep;
		//		double edep = pWell->m_fEdep;

		//		StringVectorSet	datas;
		//		vector<CString> vectorfield;
		//		vectorfield.push_back("DEPTH");
		//		vectorfield.push_back(pTrackDiscrete->m_strTrackName);
		//		CString strDepth;
		//		CString strValue;
		//		double  fDepth;
		//		vector<CString> vectorinfor;

		//		CPropertySheet StatisticSheet(strTitle);
		//		StatisticSheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;
		//		CDlgCurveStatisticHistogram page1;
		//		page1.m_bDiscrete = true;
		//		page1.m_StructCurveData.fSdep = sdep;
		//		page1.m_StructCurveData.fEdep = edep;
		//		page1.m_StructCurveData.curve_name = pTrackDiscrete->m_strTrackName;
		//		page1.m_StructCurveData.curve_num = pTrackDiscrete->m_curve_num;
		//		page1.m_nDiscreteCount = pTrackDiscrete->GetDataCount();
		//		page1.m_StructCurveData.curve_value = new float[pTrackDiscrete->GetDataCount()];
		//		page1.m_StructCurveData.curve_depth = new float[pTrackDiscrete->GetDataCount()];
		//		for(int j=0; j<pTrackDiscrete->GetDataCount(); j++)
		//		{
		//			page1.m_StructCurveData.curve_value[j] = pTrackDiscrete->GetCurveValue(j);
		//			page1.m_StructCurveData.curve_depth[j] = pTrackDiscrete->GetCurveDepth(j);
		//			vectorinfor.clear();
		//			strValue.Format("%f",pTrackDiscrete->GetCurveValue(j));
		//			fDepth = pTrackDiscrete->GetCurveDepth(j);
		//			strDepth.Format("%f",fDepth);
		//			vectorinfor.push_back(strDepth);
		//			vectorinfor.push_back(strValue);
		//			datas.push_back(vectorinfor);
		//		}
		//		page1.m_strTrackName = pTrackDiscrete->m_strTrackName;
		//		StatisticSheet.AddPage(&page1);

		//		TempDataConfig.SetTableID("Discrete");
		//		TempDataConfig.Read();
		//		table = TempDataConfig.GetTableBase();
		//		CDataTrackPropertyPage datapage(GetWellObject(),pTrackDiscrete, datas, table,pTrackDiscrete->m_strTrackName);
		//		datapage.m_bCurve = TRUE;
		//		datapage.SetDataConfig(TempDataConfig);
		//		datapage.SetGridCtrlEdit(false);
		//		datapage.SetCurveStatistic(true);

		//		StatisticSheet.AddPage(&datapage);
		//		StatisticSheet.DoModal();
		//	}
		//}
	
	}

	//void CItemSingleWell::CreatePorTrack(CWellPole* pWell,CDataObjList& CurveList,BOOL bAddResult,double PorTemp,double SwWaterTemp,double SwOilTemp,double AnalysisHd)
	//{
	//	CTrackList trackList;
	//	CWellBaseObj*  pObj = NULL;
	//	CTrackObj* pTrack = NULL;

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//生成新的组合道
	//	CTrackGroupObj* pTrackGroup_1 = new CTrackGroupObj;
	//	pTrackGroup_1->SetGroupType(Group_Vertical);
	//	pTrackGroup_1->m_font = pWell->m_fontTrack;
	//	pTrackGroup_1->m_pen = pWell->m_penTrack;
	//	pTrackGroup_1->SetPenGrid(pWell->m_penGridMajor, pWell->m_penGridMinor);
	//	pTrackGroup_1->SetFontHeadMark(pWell->m_fontHeadMark);
	//	pTrackGroup_1->SetFontGridMark(pWell->m_fontGridMark);
	//	pTrackGroup_1->SetSpace(pWell->m_fMajorSpace, pWell->m_fMinorSpace);
	//	pTrackGroup_1->m_dTrackWidth = 30.0;

	//	CTrackCurveObj* pTrackCurveObj_11 = NULL;
	//	pTrackCurveObj_11 = CreateNewCurveTrack(pWell,"SW","%",30.0,atof("100"),float(atof("0")),FALSE,RGB(0,0,255));
	//	CTrackCurveObj* pTrackCurveObj_12 = NULL;
	//	pTrackCurveObj_12 = CreateNewCurveTrack(pWell,"PERM","豪达西",30.0,atof("0.1"),atof("1000"),TRUE,RGB(255,128,0));

	//	pTrackGroup_1->SetParentGroup(pWell);
	//	pTrackGroup_1->SetParentObj(pWell);
	//	pTrackGroup_1->SetParentXY(pWell->GetParentXY());
	//	pTrackGroup_1->AddTrack(pTrackCurveObj_11);
	//	pTrackGroup_1->AddTrack(pTrackCurveObj_12);

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//生成新的组合道
	//	CTrackGroupObj* pTrackGroup_2 = new CTrackGroupObj;
	//	pTrackGroup_2->SetGroupType(Group_Vertical);
	//	pTrackGroup_2->m_font = pWell->m_fontTrack;
	//	pTrackGroup_2->m_pen = pWell->m_penTrack;
	//	pTrackGroup_2->SetPenGrid(pWell->m_penGridMajor, pWell->m_penGridMinor);
	//	pTrackGroup_2->SetFontHeadMark(pWell->m_fontHeadMark);
	//	pTrackGroup_2->SetFontGridMark(pWell->m_fontGridMark);
	//	pTrackGroup_2->SetSpace(pWell->m_fMajorSpace, pWell->m_fMinorSpace);
	//	pTrackGroup_2->m_dTrackWidth = 30.0;

	//	CTrackCurveObj* pTrackCurveObj_21 = NULL;
	//	pTrackCurveObj_21 = CreateNewCurveTrack(pWell,"SH","%",30.0,atof("0"),atof("100"),FALSE,RGB(255,0,0));
	//	CTrackCurveObj* pTrackCurveObj_22 = NULL;
	//	pTrackCurveObj_22 = CreateNewCurveTrack(pWell,"POR","%",30.0,atof("100"),atof("0"),FALSE,RGB(0,0,255));

	//	//////
	//	pTrackCurveObj_21->SetFillStyleLeft(TRUE);
	//	pTrackCurveObj_21->SetFillBrushPattern(TRUE);
	//	pTrackCurveObj_21->SetShowHeadFill(FALSE);
	//	pTrackCurveObj_21->m_fillClr = RGB(213, 213, 213);
	//	pTrackCurveObj_21->m_penCurve.m_color = RGB(255,0,0);
	//	pTrackCurveObj_21->m_strFillSymbol = "砂质泥岩";
	//	if(!pTrackCurveObj_21->m_strFillSymbol.IsEmpty())
	//	{
	//		CString strMark;
	//		strMark.Format("%s", LIB_MARK_FILL);
	//		strMark = strMark + pTrackCurveObj_21->m_strFillSymbol;
	//		pTrackCurveObj_21->m_pMarkFill = (CXyBase*)AfxGetGlobalWellXy()->GetMark()->FindMark(strMark);
	//	}

	//	pTrackCurveObj_22->SetFillStyleLeft(TRUE);
	//	pTrackCurveObj_22->SetFillBrushPattern(TRUE);
	//	pTrackCurveObj_22->SetShowHeadFill(FALSE);
	//	pTrackCurveObj_22->m_fillClr = RGB(255, 255, 0);
	//	pTrackCurveObj_22->m_penCurve.m_color = RGB(0,0,255);
	//	pTrackCurveObj_22->m_strFillSideCurve = "SH";
	//	pTrackCurveObj_22->m_strFillSymbol = "砂岩";
	//	if(!pTrackCurveObj_22->m_strFillSymbol.IsEmpty())
	//	{
	//		CString strMark;
	//		strMark.Format("%s", LIB_MARK_FILL);
	//		strMark = strMark + pTrackCurveObj_22->m_strFillSymbol;
	//		pTrackCurveObj_22->m_pMarkFill = (CXyBase*)AfxGetGlobalWellXy()->GetMark()->FindMark(strMark);
	//	}

	//	//////
	//	pTrackGroup_2->SetParentGroup(pWell);
	//	pTrackGroup_2->SetParentObj(pWell);
	//	pTrackGroup_2->SetParentXY(pWell->GetParentXY());
	//	pTrackGroup_2->AddTrack(pTrackCurveObj_21);
	//	pTrackGroup_2->AddTrack(pTrackCurveObj_22);
	//	/////////////////////////////////////////////////////////////////////////////////////////////////

	//	pWell->AddTrack(pTrackGroup_1);
	//	pWell->AddTrack(pTrackGroup_2);

	//	int nIndex = 0;
	//	CDataObj_Curve* pDataObj_Curve = NULL;
	//	POSITION pos = CurveList.GetHeadPosition();
	//	while(pos)
	//	{
	//		pDataObj_Curve = (CDataObj_Curve*)CurveList.GetNext(pos);
	//		if (nIndex == 4)
	//		{
	//			break;
	//		}
	//		if (pDataObj_Curve->m_curve_name == pTrackCurveObj_11->m_strTrackName)
	//		{
	//			pTrackCurveObj_11->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_11->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_11->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_11->ReadCurveData();
	//			nIndex++;
	//		}
	//		else if (pDataObj_Curve->m_curve_name == pTrackCurveObj_12->m_strTrackName)
	//		{
	//			pTrackCurveObj_12->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_12->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_12->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_12->ReadCurveData();
	//			nIndex++;
	//		}
	//		else if (pDataObj_Curve->m_curve_name == pTrackCurveObj_21->m_strTrackName)
	//		{
	//			pTrackCurveObj_21->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_21->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_21->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_21->ReadCurveData();
	//			nIndex++;
	//		}
	//		else if (pDataObj_Curve->m_curve_name == pTrackCurveObj_22->m_strTrackName)
	//		{
	//			pTrackCurveObj_22->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_22->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_22->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_22->ReadCurveData();
	//			nIndex++;
	//		}
	//	}

	//	if(bAddResult)
	//	{
	//		//增加解释道
	//		CClientDC dc(NULL);
	//		//设置井内所有道对象的属性
	//		CTrackResultObj* pTrackResult = new CTrackResultObj();
	//		pTrackResult->m_strTitle = "解释";
	//		pTrackResult->m_font = pWell->m_fontTrack;
	//		pTrackResult->m_pen = pWell->m_penTrack;
	//		pTrackResult->SetPenGrid(pWell->m_penGridMajor, pWell->m_penGridMinor);
	//		pTrackResult->SetFontHeadMark(pWell->m_fontHeadMark,FALSE);
	//		pTrackResult->SetFontGridMark(pWell->m_fontGridMark);
	//		pTrackResult->SetSpace(pWell->m_fMajorSpace, pWell->m_fMinorSpace);
	//		CString titlename = pTrackResult->m_strTitle;
	//		pTrackResult->m_dTrackWidth = 30.0;
	//		pWell->AddTrack(pTrackResult);

	//		CPoint2D ptf = pWell->GetPos().TopLeft();
	//		pWell->ComputeSize(ptf);
	//		////////////////////////////////////////////////////////////////////////
	//		if (pTrackCurveObj_11!=NULL&&pTrackCurveObj_22!=NULL)
	//		{
	//			double sdep = pTrackCurveObj_11->m_fSdep;
	//			double edep = pTrackCurveObj_11->m_fEdep;
	//			//标准化顶底深
	//			if(float(sdep/pTrackCurveObj_11->m_fRlev) != int(sdep/pTrackCurveObj_11->m_fRlev))
	//			{
	//				sdep = float(int(sdep/pTrackCurveObj_11->m_fRlev + 1)*pTrackCurveObj_11->m_fRlev);
	//			}
	//			if(float(edep/pTrackCurveObj_11->m_fRlev) != int(edep/pTrackCurveObj_11->m_fRlev))
	//			{
	//				edep = float(int(edep/pTrackCurveObj_11->m_fRlev)*pTrackCurveObj_11->m_fRlev);
	//			}
	//			int index1,index2;

	//			//曲线数据的起始点和结束点序号
	//			index1 = int((pWell->m_fSdep - sdep)/pTrackCurveObj_11->m_fRlev);
	//			index2 = int((pWell->m_fEdep - sdep)/pTrackCurveObj_11->m_fRlev);
	//			index2 +=1;
	//			float fTop,fEnd;
	//			CString strType,strType1;
	//			CRect8 analysisrect;
	//			int analysisIndex = -1;
	//			CRect8 rect = pTrackResult->GetPos();
	//			rect.top= pTrackResult->m_HeadRect.bottom;

	//			for (int i=index1;i<index2;i++)
	//			{
	//				if(analysisIndex == -1)
	//				{
	//					fTop = fEnd =  sdep+(i-index1)*pTrackCurveObj_11->m_fRlev;
	//					if (pTrackCurveObj_11->GetCurveValue(i)>=SwWaterTemp&&pTrackCurveObj_11->GetCurveValue(i)<=100&&pTrackCurveObj_22->GetCurveValue(i)>PorTemp)
	//					{
	//						analysisIndex = i;
	//						strType = "水层";
	//					}
	//					else if (pTrackCurveObj_11->GetCurveValue(i)>=SwOilTemp&&pTrackCurveObj_11->GetCurveValue(i)<SwWaterTemp&&pTrackCurveObj_22->GetCurveValue(i)>PorTemp)
	//					{
	//						analysisIndex = i;
	//						strType = "油水同层";
	//					}
	//					else if (pTrackCurveObj_11->GetCurveValue(i)<SwOilTemp&&pTrackCurveObj_22->GetCurveValue(i)>PorTemp)
	//					{
	//						analysisIndex = i;
	//						strType = "油层";
	//					}
	//				}
	//				else
	//				{
	//					strType1="";
	//					if (pTrackCurveObj_11->GetCurveValue(i)>=SwWaterTemp&&pTrackCurveObj_11->GetCurveValue(i)<=100)
	//					{
	//						strType1 = "水层";
	//					}
	//					else if (pTrackCurveObj_11->GetCurveValue(i)>=SwOilTemp&&pTrackCurveObj_11->GetCurveValue(i)<SwWaterTemp)
	//					{
	//						strType1 = "油水同层";
	//					}
	//					else if (pTrackCurveObj_11->GetCurveValue(i)<SwOilTemp)
	//					{
	//						strType1 = "油层";
	//					}

	//					if ((pTrackCurveObj_22->GetCurveValue(i)<=PorTemp||strType1!=strType)&&(fEnd>fTop))
	//					{
	//						if((fEnd-fTop)>AnalysisHd)
	//						{
	//							analysisrect.left = pTrackResult->GetPos().left;
	//							analysisrect.right = pTrackResult->GetPos().right;

	//							//analysisrect.top = pTrackResult->m_HeadRect.bottom+(fTop-pWell->m_fSdep)/0.0254/
	//							//	(double)pWell->m_fProportion * dc.GetDeviceCaps(LOGPIXELSY);
	//							//analysisrect.bottom = pTrackResult->m_HeadRect.bottom+(fEnd-pWell->m_fSdep)/0.0254/
	//							//	(double)pWell->m_fProportion * dc.GetDeviceCaps(LOGPIXELSY);

	//							//创建岩性对象
	//							CTrackInResult* pTrackInResult = new CTrackInResult();
	//							pTrackInResult->m_fSdep = fTop/*pWell->ScreenYToDepth(pTrackInResult->GetPos().top)*/;
	//							pTrackInResult->m_fEdep = fEnd/*pWell->ScreenYToDepth(pTrackInResult->GetPos().bottom)*/;
	//							analysisrect.top = pWell->DepthToScreenY(pTrackInResult->m_fSdep);
	//							analysisrect.bottom = pWell->DepthToScreenY(pTrackInResult->m_fEdep);
	//							pTrackInResult->SetRange(analysisrect);

	//							pTrackInResult->m_strResult = strType;
	//							if(!pTrackInResult->m_strResult.IsEmpty())
	//							{
	//								CString strMark;
	//								strMark.Format("%s", LIB_MARK_STRATUMFLUID);
	//								strMark = strMark + pTrackInResult->m_strResult;
	//								if(AfxGetGlobalWellXy() != NULL)
	//									pTrackInResult->m_pMarkResult = (CXyBase*)AfxGetGlobalWellXy()->GetMark()->FindMark(strMark);

	//								strMark = pTrackInResult->GetMarkSymbol();
	//								if(AfxGetGlobalWellXy() != NULL)
	//									pTrackInResult->m_pMarkSymbol = (CXyBase*)AfxGetGlobalWellXy()->GetMark()->FindMark(strMark);

	//								strMark.Format("%s", LIB_MARK_FLUIDCOLOR);
	//								strMark = strMark + pTrackInResult->m_strResult;
	//								if(AfxGetGlobalWellXy() != NULL)
	//									pTrackInResult->m_brush.m_color = AfxGetGlobalWellXy()->GetMark()->FindMarkColor(strMark);
	//							}
	//							pTrackInResult->m_fValidThick = pTrackInResult->m_fEdep - pTrackInResult->m_fSdep;
	//							//if (pTrackInResult->GetPos().top < rect.top||pTrackInResult->GetPos().bottom>rect.bottom)
	//							//{
	//							//	//隐藏对象
	//							//	pTrackInResult->SetViewState(UNVIEW_STATE);
	//							//}
	//							if(pTrackInResult->m_fSdep >= pWell->m_fEdep || pTrackInResult->m_fEdep <= pWell->m_fSdep)
	//								pTrackInResult->SetViewState(UNVIEW_STATE);
	//							//添加到子对象链表中
	//							pTrackResult->Add(pTrackInResult);
	//						}
	//						analysisIndex = -1;
	//					}
	//					else
	//					{
	//						fEnd = sdep+(i-index1)*pTrackCurveObj_11->m_fRlev;
	//					}
	//				}
	//			}
	//			//最后一个解释结果
	//			if(analysisIndex!=-1)
	//			{
	//				if ((fEnd-fTop)>AnalysisHd)
	//				{
	//					analysisrect.left = pTrackResult->GetPos().left;
	//					analysisrect.right = pTrackResult->GetPos().right;

	//					//analysisrect.top = pTrackResult->m_HeadRect.bottom+(fTop-pWell->m_fSdep)/0.0254/
	//					//	(double)pWell->m_fProportion * dc.GetDeviceCaps(LOGPIXELSY);
	//					//analysisrect.bottom = pTrackResult->m_HeadRect.bottom+(fEnd-pWell->m_fEdep)/0.0254/
	//					//	(double)pWell->m_fProportion * dc.GetDeviceCaps(LOGPIXELSY);

	//					//创建岩性对象
	//					CTrackInResult* pTrackInResult = new CTrackInResult();
	//					pTrackInResult->m_fSdep = fTop/*pWell->ScreenYToDepth(pTrackInResult->GetPos().top)*/;
	//					pTrackInResult->m_fEdep = fEnd/*pWell->ScreenYToDepth(pTrackInResult->GetPos().bottom)*/;
	//					analysisrect.top = pWell->DepthToScreenY(pTrackInResult->m_fSdep);
	//					analysisrect.bottom = pWell->DepthToScreenY(pTrackInResult->m_fEdep);
	//					pTrackInResult->SetRange(analysisrect);
	//					//if (pTrackInResult->GetPos().top < rect.top||pTrackInResult->GetPos().bottom>rect.bottom)
	//					//{
	//					//	//隐藏对象
	//					//	pTrackInResult->SetViewState(UNVIEW_STATE);
	//					//}
	//					pTrackInResult->m_fValidThick = pTrackInResult->m_fEdep - pTrackInResult->m_fSdep;
	//					if(pTrackInResult->m_fSdep >= pWell->m_fEdep || pTrackInResult->m_fEdep <= pWell->m_fSdep)
	//						pTrackInResult->SetViewState(UNVIEW_STATE);
	//					//添加到子对象链表中
	//					pTrackResult->Add(pTrackInResult);
	//				}
	//			}
	//		}
	//	}
	//	else
	//	{
	//		//重新排列组合关系
	//		//pWell->SortTrackGroup();
	//		CPoint2D ptf = pWell->GetPos().TopLeft();
	//		pWell->ComputeSize(ptf);
	//	}
	//}

	//void CItemSingleWell::CreateSandTrack(CWellPole* pWell,CDataObjList& CurveList,BOOL bAddResult,double PorTemp,double SwWaterTemp,double SwOilTemp,double AnalysisHd)
	//{
	//	CTrackList trackList;
	//	CWellBaseObj*  pObj = NULL;
	//	CTrackObj* pTrack = NULL;

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//生成新的组合道
	//	CTrackGroupObj* pTrackGroup_1 = new CTrackGroupObj;
	//	pTrackGroup_1->SetGroupType(Group_Vertical);
	//	pTrackGroup_1->m_font = pWell->m_fontTrack;
	//	pTrackGroup_1->m_pen = pWell->m_penTrack;
	//	pTrackGroup_1->SetPenGrid(pWell->m_penGridMajor, pWell->m_penGridMinor);
	//	pTrackGroup_1->SetFontHeadMark(pWell->m_fontHeadMark);
	//	pTrackGroup_1->SetFontGridMark(pWell->m_fontGridMark);
	//	pTrackGroup_1->SetSpace(pWell->m_fMajorSpace, pWell->m_fMinorSpace);
	//	pTrackGroup_1->m_dTrackWidth = 30.0;

	//	CTrackCurveObj* pTrackCurveObj_11 = NULL;
	//	pTrackCurveObj_11 = CreateNewCurveTrack(pWell,"SH","%",30.0,float(atof("0")),float(atof("100")),FALSE,RGB(0,0,255));

	//	CTrackCurveObj* pTrackCurveObj_12 = NULL;
	//	pTrackCurveObj_12 = CreateNewCurveTrack(pWell,"PERM","豪达西",30.0,float(atof("0.1")),float(atof("1000")),TRUE,RGB(255,128,0));

	//	pTrackGroup_1->SetParentGroup(pWell);
	//	pTrackGroup_1->SetParentObj(pWell);
	//	pTrackGroup_1->SetParentXY(pWell->GetParentXY());
	//	pTrackGroup_1->AddTrack(pTrackCurveObj_11);
	//	pTrackGroup_1->AddTrack(pTrackCurveObj_12);

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//生成新的组合道
	//	CTrackGroupObj* pTrackGroup_2 = new CTrackGroupObj;
	//	pTrackGroup_2->SetGroupType(Group_Vertical);
	//	pTrackGroup_2->m_font = pWell->m_fontTrack;
	//	pTrackGroup_2->m_pen = pWell->m_penTrack;
	//	pTrackGroup_2->SetPenGrid(pWell->m_penGridMajor, pWell->m_penGridMinor);
	//	pTrackGroup_2->SetFontHeadMark(pWell->m_fontHeadMark);
	//	pTrackGroup_2->SetFontGridMark(pWell->m_fontGridMark);
	//	pTrackGroup_2->SetSpace(pWell->m_fMajorSpace, pWell->m_fMinorSpace);
	//	pTrackGroup_2->m_dTrackWidth = 30.0;

	//	CTrackCurveObj* pTrackCurveObj_21 = NULL;
	//	pTrackCurveObj_21 = CreateNewCurveTrack(pWell,"SW","%",30.0,float(atof("100")),float(atof("0")),FALSE,RGB(0,0,255));

	//	CTrackCurveObj* pTrackCurveObj_22 = NULL;
	//	pTrackCurveObj_22 = CreateNewCurveTrack(pWell,"PORH","%",30.0,float(atof("0")),float(atof("25")),FALSE,RGB(255,128,0));

	//	CTrackCurveObj* pTrackCurveObj_23 = NULL;
	//	pTrackCurveObj_23 = CreateNewCurveTrack(pWell,"PORX","%",30.0,float(atof("0")),float(atof("25")),FALSE,RGB(255,128,255));

	//	pTrackGroup_2->SetParentGroup(pWell);
	//	pTrackGroup_2->SetParentObj(pWell);
	//	pTrackGroup_2->SetParentXY(pWell->GetParentXY());
	//	pTrackGroup_2->AddTrack(pTrackCurveObj_21);
	//	pTrackGroup_2->AddTrack(pTrackCurveObj_22);
	//	pTrackGroup_2->AddTrack(pTrackCurveObj_23);

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//生成新的组合道
	//	CTrackGroupObj* pTrackGroup_3 = new CTrackGroupObj;
	//	pTrackGroup_3->SetGroupType(Group_Vertical);
	//	pTrackGroup_3->m_font = pWell->m_fontTrack;
	//	pTrackGroup_3->m_pen = pWell->m_penTrack;
	//	pTrackGroup_3->SetPenGrid(pWell->m_penGridMajor, pWell->m_penGridMinor);
	//	pTrackGroup_3->SetFontHeadMark(pWell->m_fontHeadMark);
	//	pTrackGroup_3->SetFontGridMark(pWell->m_fontGridMark);
	//	pTrackGroup_3->SetSpace(pWell->m_fMajorSpace, pWell->m_fMinorSpace);
	//	pTrackGroup_3->m_dTrackWidth = 30.0;

	//	CTrackCurveObj* pTrackCurveObj_31 = NULL;
	//	pTrackCurveObj_31 = CreateNewCurveTrack(pWell,"CAL","英寸",30.0,float(atof("8")),float(atof("18")),FALSE,RGB(255,0,0));

	//	CTrackCurveObj* pTrackCurveObj_32 = NULL;
	//	pTrackCurveObj_32 = CreateNewCurveTrack(pWell,"POR","%",30.0,float(atof("50")),float(atof("0")),FALSE,RGB(255,128,0));

	//	CTrackCurveObj* pTrackCurveObj_33 = NULL;
	//	pTrackCurveObj_33 = CreateNewCurveTrack(pWell,"PORF","%",30.0,float(atof("50")),float(atof("0")),FALSE,RGB(0,0,255));

	//	CTrackCurveObj* pTrackCurveObj_34 = NULL;
	//	pTrackCurveObj_34 = CreateNewCurveTrack(pWell,"PORW","%",30.0,float(atof("50")),float(atof("0")),FALSE,RGB(0,0,255));

	//	pTrackCurveObj_33->SetFillStyleLeft(TRUE);
	//	pTrackCurveObj_33->SetFillBrushPattern(TRUE);
	//	pTrackCurveObj_33->SetShowHeadFill(FALSE);
	//	pTrackCurveObj_33->m_fillClr = RGB(0,0,0);
	//	pTrackCurveObj_33->m_strFillSideCurve = "POR";

	//	pTrackCurveObj_34->SetFillStyleLeft(TRUE);
	//	pTrackCurveObj_34->SetFillBrushPattern(TRUE);
	//	pTrackCurveObj_34->SetShowHeadFill(FALSE);
	//	pTrackCurveObj_34->m_fillClr = RGB(255,0,0);
	//	pTrackCurveObj_34->m_strFillSideCurve = "PORF";

	//	pTrackGroup_3->SetParentGroup(pWell);
	//	pTrackGroup_3->SetParentObj(pWell);
	//	pTrackGroup_3->SetParentXY(pWell->GetParentXY());
	//	pTrackGroup_3->AddTrack(pTrackCurveObj_31);
	//	pTrackGroup_3->AddTrack(pTrackCurveObj_32);
	//	pTrackGroup_3->AddTrack(pTrackCurveObj_33);
	//	pTrackGroup_3->AddTrack(pTrackCurveObj_34);

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//生成新的组合道
	//	CTrackGroupObj* pTrackGroup_4 = new CTrackGroupObj;
	//	pTrackGroup_4->SetGroupType(Group_Vertical);
	//	pTrackGroup_4->m_font = pWell->m_fontTrack;
	//	pTrackGroup_4->m_pen = pWell->m_penTrack;
	//	pTrackGroup_4->SetPenGrid(pWell->m_penGridMajor, pWell->m_penGridMinor);
	//	pTrackGroup_4->SetFontHeadMark(pWell->m_fontHeadMark);
	//	pTrackGroup_4->SetFontGridMark(pWell->m_fontGridMark);
	//	pTrackGroup_4->SetSpace(pWell->m_fMajorSpace, pWell->m_fMinorSpace);
	//	pTrackGroup_4->m_dTrackWidth = 30.0;

	//	CTrackCurveObj* pTrackCurveObj_41 = NULL;
	//	pTrackCurveObj_41 = CreateNewCurveTrack(pWell,"SH","%",30.0,float(atof("0")),float(atof("100")),FALSE,RGB(255,0,0));

	//	CTrackCurveObj* pTrackCurveObj_42 = NULL;
	//	pTrackCurveObj_42 = CreateNewCurveTrack(pWell,"POR","%",30.0,float(atof("100")),float(atof("0")),FALSE,RGB(0,0,255));

	//	pTrackCurveObj_41->SetFillStyleLeft(TRUE);
	//	pTrackCurveObj_41->SetFillBrushPattern(TRUE);
	//	pTrackCurveObj_41->SetShowHeadFill(FALSE);
	//	pTrackCurveObj_41->m_fillClr = RGB(213, 213, 213);
	//	pTrackCurveObj_41->m_strFillSymbol = "砂质泥岩";
	//	if(!pTrackCurveObj_41->m_strFillSymbol.IsEmpty())
	//	{
	//		CString strMark;
	//		strMark.Format("%s", LIB_MARK_FILL);
	//		strMark = strMark + pTrackCurveObj_41->m_strFillSymbol;
	//		pTrackCurveObj_41->m_pMarkFill = (CXyBase*)AfxGetGlobalWellXy()->GetMark()->FindMark(strMark);
	//	}

	//	pTrackCurveObj_42->SetFillStyleLeft(TRUE);
	//	pTrackCurveObj_42->SetFillBrushPattern(TRUE);
	//	pTrackCurveObj_42->SetShowHeadFill(FALSE);
	//	pTrackCurveObj_42->m_fillClr = RGB(255, 255, 0);
	//	pTrackCurveObj_42->m_strFillSideCurve = "SH";
	//	pTrackCurveObj_42->m_strFillSymbol = "砂岩";
	//	if(!pTrackCurveObj_42->m_strFillSymbol.IsEmpty())
	//	{
	//		CString strMark;
	//		strMark.Format("%s", LIB_MARK_FILL);
	//		strMark = strMark + pTrackCurveObj_42->m_strFillSymbol;
	//		pTrackCurveObj_42->m_pMarkFill = (CXyBase*)AfxGetGlobalWellXy()->GetMark()->FindMark(strMark);
	//	}

	//	pTrackGroup_4->SetParentGroup(pWell);
	//	pTrackGroup_4->SetParentObj(pWell);
	//	pTrackGroup_4->SetParentXY(pWell->GetParentXY());
	//	pTrackGroup_4->AddTrack(pTrackCurveObj_41);
	//	pTrackGroup_4->AddTrack(pTrackCurveObj_42);
	//	/////////////////////////////////////////////////////////////////////////////////////////////////

	//	pWell->AddTrack(pTrackGroup_1);
	//	pWell->AddTrack(pTrackGroup_2);
	//	pWell->AddTrack(pTrackGroup_3);
	//	pWell->AddTrack(pTrackGroup_4);

	//	int nIndex = 0;
	//	CDataObj_Curve* pDataObj_Curve = NULL;
	//	POSITION pos = CurveList.GetHeadPosition();
	//	while(pos)
	//	{
	//		pDataObj_Curve = (CDataObj_Curve*)CurveList.GetNext(pos);
	//		if (nIndex == 11)
	//		{
	//			break;
	//		}
	//		if (pDataObj_Curve->m_curve_name == pTrackCurveObj_11->m_strTrackName)
	//		{
	//			pTrackCurveObj_11->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_11->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_11->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_11->ReadCurveData();
	//			nIndex++;
	//		}
	//		/*else*/ if (pDataObj_Curve->m_curve_name == pTrackCurveObj_12->m_strTrackName)
	//		{
	//			pTrackCurveObj_12->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_12->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_12->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_12->ReadCurveData();
	//			nIndex++;
	//		}
	//		/*else*/ if (pDataObj_Curve->m_curve_name == pTrackCurveObj_21->m_strTrackName)
	//		{
	//			pTrackCurveObj_21->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_21->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_21->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_21->ReadCurveData();
	//			nIndex++;
	//		}
	//		/*else*/ if (pDataObj_Curve->m_curve_name == pTrackCurveObj_22->m_strTrackName)
	//		{
	//			pTrackCurveObj_22->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_22->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_22->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_22->ReadCurveData();
	//			nIndex++;
	//		}
	//		/*else*/ if (pDataObj_Curve->m_curve_name == pTrackCurveObj_23->m_strTrackName)
	//		{
	//			pTrackCurveObj_23->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_23->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_23->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_23->ReadCurveData();
	//			nIndex++;
	//		}
	//		/*else*/ if (pDataObj_Curve->m_curve_name == pTrackCurveObj_31->m_strTrackName)
	//		{
	//			pTrackCurveObj_31->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_31->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_31->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_31->ReadCurveData();
	//			nIndex++;
	//		}
	//		/*else*/ if (pDataObj_Curve->m_curve_name == pTrackCurveObj_32->m_strTrackName)
	//		{
	//			pTrackCurveObj_32->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_32->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_32->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_32->ReadCurveData();
	//			nIndex++;
	//		}
	//		/*else*/ if (pDataObj_Curve->m_curve_name == pTrackCurveObj_33->m_strTrackName)
	//		{
	//			pTrackCurveObj_33->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_33->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_33->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_33->ReadCurveData();
	//			nIndex++;
	//		}
	//		/*else*/ if (pDataObj_Curve->m_curve_name == pTrackCurveObj_34->m_strTrackName)
	//		{
	//			pTrackCurveObj_34->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_34->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_34->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_34->ReadCurveData();
	//			nIndex++;
	//		}
	//		/*else*/ if (pDataObj_Curve->m_curve_name == pTrackCurveObj_41->m_strTrackName)
	//		{
	//			pTrackCurveObj_41->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_41->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_41->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_41->ReadCurveData();
	//			nIndex++;
	//		}
	//		/*else*/ if (pDataObj_Curve->m_curve_name == pTrackCurveObj_42->m_strTrackName)
	//		{
	//			pTrackCurveObj_42->m_dataObj = *pDataObj_Curve;
	//			pTrackCurveObj_42->m_fSdep = pDataObj_Curve->m_startdep;
	//			pTrackCurveObj_42->m_fEdep = pDataObj_Curve->m_enddep;
	//			pTrackCurveObj_42->ReadCurveData();
	//			nIndex++;
	//		}
	//	}

	//	if(bAddResult)
	//	{
	//		//增加解释道
	//		CClientDC dc(NULL);
	//		//设置井内所有道对象的属性
	//		CTrackResultObj* pTrackResult = new CTrackResultObj();
	//		pTrackResult->m_strTitle = "解释";
	//		pTrackResult->m_font = pWell->m_fontTrack;
	//		pTrackResult->m_pen = pWell->m_penTrack;
	//		pTrackResult->SetPenGrid(pWell->m_penGridMajor, pWell->m_penGridMinor);
	//		pTrackResult->SetFontHeadMark(pWell->m_fontHeadMark,FALSE);
	//		pTrackResult->SetFontGridMark(pWell->m_fontGridMark);
	//		pTrackResult->SetSpace(pWell->m_fMajorSpace, pWell->m_fMinorSpace);
	//		CString titlename = pTrackResult->m_strTitle;
	//		pTrackResult->m_dTrackWidth = 30.0;
	//		pWell->AddTrack(pTrackResult);

	//		//重新排列组合关系
	//		//pWell->SortTrackGroup();
	//		CPoint2D ptf = pWell->GetPos().TopLeft();
	//		pWell->ComputeSize(ptf);
	//		////////////////////////////////////////////////////////////////////////
	//		if (pTrackCurveObj_21!=NULL&&pTrackCurveObj_32!=NULL)
	//		{
	//			double sdep = pTrackCurveObj_21->m_fSdep;
	//			double edep = pTrackCurveObj_21->m_fEdep;
	//			//标准化顶底深
	//			if(float(sdep/pTrackCurveObj_21->m_fRlev) != int(sdep/pTrackCurveObj_21->m_fRlev))
	//			{
	//				sdep = float(int(sdep/pTrackCurveObj_21->m_fRlev + 1)*pTrackCurveObj_21->m_fRlev);
	//			}
	//			if(float(edep/pTrackCurveObj_21->m_fRlev) != int(edep/pTrackCurveObj_21->m_fRlev))
	//			{
	//				edep = float(int(edep/pTrackCurveObj_21->m_fRlev)*pTrackCurveObj_21->m_fRlev);
	//			}
	//			int index1,index2;

	//			//曲线数据的起始点和结束点序号
	//			index1 = int((pWell->m_fSdep - sdep)/pTrackCurveObj_21->m_fRlev);
	//			index2 = int((pWell->m_fEdep - sdep)/pTrackCurveObj_21->m_fRlev);
	//			index2 +=1;
	//			float fTop,fEnd;
	//			CString strType,strType1;
	//			CRect8 analysisrect;
	//			int analysisIndex = -1;
	//			CRect8 rect = pTrackResult->GetPos();
	//			rect.top= pTrackResult->m_HeadRect.bottom;

	//			for (int i=index1;i<index2;i++)
	//			{
	//				if(analysisIndex == -1)
	//				{
	//					fTop = fEnd =  sdep+(i-index1)*pTrackCurveObj_21->m_fRlev;
	//					if (pTrackCurveObj_21->GetCurveValue(i)>=SwWaterTemp&&pTrackCurveObj_21->GetCurveValue(i)<=100&&pTrackCurveObj_32->GetCurveValue(i)>PorTemp)
	//					{
	//						analysisIndex = i;
	//						strType = "水层";
	//					}
	//					else if (pTrackCurveObj_21->GetCurveValue(i)>=SwOilTemp&&pTrackCurveObj_21->GetCurveValue(i)<SwWaterTemp&&pTrackCurveObj_32->GetCurveValue(i)>PorTemp)
	//					{
	//						analysisIndex = i;
	//						strType = "油水同层";
	//					}
	//					else if (pTrackCurveObj_21->GetCurveValue(i)<SwOilTemp&&pTrackCurveObj_32->GetCurveValue(i)>PorTemp)
	//					{
	//						analysisIndex = i;
	//						strType = "油层";
	//					}
	//				}
	//				else
	//				{
	//					strType1="";
	//					if (pTrackCurveObj_21->GetCurveValue(i)>=SwWaterTemp&&pTrackCurveObj_21->GetCurveValue(i)<=100)
	//					{
	//						strType1 = "水层";
	//					}
	//					else if (pTrackCurveObj_21->GetCurveValue(i)>=SwOilTemp&&pTrackCurveObj_21->GetCurveValue(i)<SwWaterTemp)
	//					{
	//						strType1 = "油水同层";
	//					}
	//					else if (pTrackCurveObj_21->GetCurveValue(i)<SwOilTemp)
	//					{
	//						strType1 = "油层";
	//					}

	//					if ((pTrackCurveObj_32->GetCurveValue(i)<=PorTemp||strType1!=strType)&&(fEnd>fTop))
	//					{
	//						if((fEnd-fTop)>AnalysisHd)
	//						{
	//							analysisrect.left = pTrackResult->GetPos().left;
	//							analysisrect.right = pTrackResult->GetPos().right;

	//							//analysisrect.top = pTrackResult->m_HeadRect.bottom+(fTop-pWell->m_fSdep)/0.0254/
	//							//	(double)pWell->m_fProportion * dc.GetDeviceCaps(LOGPIXELSY);
	//							//analysisrect.bottom = pTrackResult->m_HeadRect.bottom+(fEnd-pWell->m_fSdep)/0.0254/
	//							//	(double)pWell->m_fProportion * dc.GetDeviceCaps(LOGPIXELSY);

	//							//创建岩性对象
	//							CTrackInResult* pTrackInResult = new CTrackInResult();
	//							pTrackInResult->m_fSdep = fTop/*pWell->ScreenYToDepth(pTrackInResult->GetPos().top)*/;
	//							pTrackInResult->m_fEdep = fEnd/*pWell->ScreenYToDepth(pTrackInResult->GetPos().bottom)*/;
	//							analysisrect.top = pWell->DepthToScreenY(pTrackInResult->m_fSdep);
	//							analysisrect.bottom = pWell->DepthToScreenY(pTrackInResult->m_fEdep);
	//							pTrackInResult->SetRange(analysisrect);

	//							pTrackInResult->m_strResult = strType;
	//							if(!pTrackInResult->m_strResult.IsEmpty())
	//							{
	//								CString strMark;
	//								strMark.Format("%s", LIB_MARK_STRATUMFLUID);
	//								strMark = strMark + pTrackInResult->m_strResult;
	//								if(AfxGetGlobalWellXy() != NULL)
	//									pTrackInResult->m_pMarkResult = (CXyBase*)AfxGetGlobalWellXy()->GetMark()->FindMark(strMark);

	//								strMark = pTrackInResult->GetMarkSymbol();
	//								if(AfxGetGlobalWellXy() != NULL)
	//									pTrackInResult->m_pMarkSymbol = (CXyBase*)AfxGetGlobalWellXy()->GetMark()->FindMark(strMark);

	//								strMark.Format("%s", LIB_MARK_FLUIDCOLOR);
	//								strMark = strMark + pTrackInResult->m_strResult;
	//								if(AfxGetGlobalWellXy() != NULL)
	//									pTrackInResult->m_brush.m_color = AfxGetGlobalWellXy()->GetMark()->FindMarkColor(strMark);
	//							}
	//							pTrackInResult->m_fValidThick = pTrackInResult->m_fEdep - pTrackInResult->m_fSdep;
	//							//if (pTrackInResult->GetPos().top < rect.top||pTrackInResult->GetPos().bottom>rect.bottom)
	//							//{
	//							//	//隐藏对象
	//							//	pTrackInResult->SetViewState(UNVIEW_STATE);
	//							//}
	//							if(pTrackInResult->m_fSdep >= pWell->m_fEdep || pTrackInResult->m_fEdep <= pWell->m_fSdep)
	//								pTrackInResult->SetViewState(UNVIEW_STATE);
	//							//添加到子对象链表中
	//							pTrackResult->Add(pTrackInResult);
	//						}
	//						analysisIndex = -1;
	//					}
	//					else
	//					{
	//						fEnd = sdep+(i-index1)*pTrackCurveObj_21->m_fRlev;
	//					}
	//				}
	//			}
	//			//最后一个解释结果
	//			if(analysisIndex!=-1)
	//			{
	//				if ((fEnd-fTop)>AnalysisHd)
	//				{
	//					analysisrect.left = pTrackResult->GetPos().left;
	//					analysisrect.right = pTrackResult->GetPos().right;

	//					//analysisrect.top = pTrackResult->m_HeadRect.bottom+(fTop-pWell->m_fSdep)/0.0254/
	//					//	(double)pWell->m_fProportion * dc.GetDeviceCaps(LOGPIXELSY);
	//					//analysisrect.bottom = pTrackResult->m_HeadRect.bottom+(fEnd-pWell->m_fEdep)/0.0254/
	//					//	(double)pWell->m_fProportion * dc.GetDeviceCaps(LOGPIXELSY);

	//					//创建岩性对象
	//					CTrackInResult* pTrackInResult = new CTrackInResult();
	//					pTrackInResult->m_fSdep = fTop/*pWell->ScreenYToDepth(pTrackInResult->GetPos().top)*/;
	//					pTrackInResult->m_fEdep = fEnd/*pWell->ScreenYToDepth(pTrackInResult->GetPos().bottom)*/;
	//					analysisrect.top = pWell->DepthToScreenY(pTrackInResult->m_fSdep);
	//					analysisrect.bottom = pWell->DepthToScreenY(pTrackInResult->m_fEdep);
	//					pTrackInResult->SetRange(analysisrect);
	//					//if (pTrackInResult->GetPos().top < rect.top||pTrackInResult->GetPos().bottom>rect.bottom)
	//					//{
	//					//	//隐藏对象
	//					//	pTrackInResult->SetViewState(UNVIEW_STATE);
	//					//}
	//					pTrackInResult->m_fValidThick = pTrackInResult->m_fEdep - pTrackInResult->m_fSdep;
	//					if(pTrackInResult->m_fSdep >= pWell->m_fEdep || pTrackInResult->m_fEdep <= pWell->m_fSdep)
	//						pTrackInResult->SetViewState(UNVIEW_STATE);
	//					//添加到子对象链表中
	//					pTrackResult->Add(pTrackInResult);
	//				}
	//			}
	//		}
	//	}
	//	else
	//	{
	//		//重新排列组合关系
	//		//pWell->SortTrackGroup();
	//		CPoint2D ptf = pWell->GetPos().TopLeft();
	//		pWell->ComputeSize(ptf);
	//	}
	//}

	CTrackCurve* CItemSingleWell::CreateNewCurveTrack(CWellPole* pWell,CString strTrackName,CString strUnit,double TrackWidth,double LeftValue,double RightValue,BOOL bLog,COLORREF clr)
	{
		CTrackCurve* pTrackCurveObj = new CTrackCurve;
		pTrackCurveObj->m_font = pWell->m_fontTrack;
		pTrackCurveObj->m_pen = pWell->m_penTrack;
		pTrackCurveObj->SetPenGrid(pWell->m_penGridMajor, pWell->m_penGridMinor);
		pTrackCurveObj->SetFontHeadMark(pWell->m_fontHeadMark,FALSE);
		pTrackCurveObj->SetFontGridMark(pWell->m_fontGridMark);
		pTrackCurveObj->SetSpace(pWell->m_fMajorSpace, pWell->m_fMinorSpace);
		pTrackCurveObj->m_dTrackWidth = TrackWidth;
		pTrackCurveObj->m_strTrackName = strTrackName;
		pTrackCurveObj->m_strTitle = strTrackName;
		pTrackCurveObj->m_curve_num = 1;
		pTrackCurveObj->m_curve_unit = strUnit;
		pTrackCurveObj->m_curve_left = LeftValue;
		pTrackCurveObj->m_curve_right = RightValue;
		pTrackCurveObj->SetLog(bLog);
		pTrackCurveObj->m_penCurve.m_color = clr;

		return pTrackCurveObj;
	}

	void  CItemSingleWell::DrawSelectPolyRange(CXyDC* pXyDC,std::vector<CPoint2D>& PtsVec)
	{
		if(PtsVec.size() == 0)
			return;

		int ptNum = PtsVec.size();
		if(m_PointNum < ptNum)
		{
			if(m_PointNum>0)
			{
				delete [] m_pPointBuf;
			}

			m_PointNum = ptNum;
			m_pPointBuf = new CPoint [m_PointNum];
		}

		for(int ii = 0; ii< ptNum; ii++)
		{
			m_pPointBuf[ii] = pXyDC->GetScreen(PtsVec[ii].x0,PtsVec[ii].y0);//m_HeadPtArr[ii].x0,m_HeadPtArr[ii].y0);
		}

		CBrush brush,*pbrush; 
		brush.CreateSolidBrush(RGB(160,192,255));

		CDC *pCDC = pXyDC->GetDC();

		pbrush = pCDC->SelectObject(&brush);

		pCDC->Polygon(m_pPointBuf,ptNum); 

		pCDC->SelectObject(pbrush);

	}

	double  CItemSingleWell::GetWellProjecttionAngle(CWellPole *pWellObj)
	{
		double angle = 0;
		typedef struct _JXTraceStruct//斜井数据结构
		{
			double xs;							//井斜深
			double xj;							//井斜角
			double zfwj;						//真方位角
			double x;							//投影横坐标
			double y;							//投影纵坐标
		} JXTraceStruct;
		JXTraceStruct jx,jx1;
		//CArray <JXTraceStruct,JXTraceStruct> JxArray;;//井斜数据,这张表里存得全是原始数据	
		std::vector<JXTraceStruct> JxArray;
		Struct_InclinedWell incWellStruct;
		INCLINEDWELLSTRUCTLIST::iterator it = pWellObj->m_InclinedWellList.begin();
		for(; it!= pWellObj->m_InclinedWellList.end(); it++)
		{
			incWellStruct = *it;
			jx.xs = incWellStruct.depth;
			jx.xj = incWellStruct.bevel;
			jx.zfwj = incWellStruct.azimuth;

			//JxArray.Add(jx);
			JxArray.push_back(jx);
		}
		if(JxArray.size()>0 /*.GetSize() >0*/)
		{
			//sina1,cosa1=前一个点井斜角，sina2,cosa2=后一个点斜井角,sinb1,cosb1=前一个点方位角
			//,cosb2,sinb2,=后一点方位角,cosb2b1=后一个方位角减去前一个方位角;
			double sina1,sina2,cosa1,cosa2,cosb1,cosb2,sinb1,sinb2,cosb2b1;
			double x3,y3,depV ;//井轨迹点 
			x3=y3 = 0 ;
			double dx,dy,dh;//井位移增量，井垂深增量
			int ii,num;

			double b1,b2; //方位角1，方位角2;

			double ya; //狗腿角，全方位角

			double tmpY,tmpY2;
			depV = 0;

			double tdmp ;

			BOOL bAddFirst = FALSE;
			jx = JxArray[0];
			if(jx.xs>0.000001)
			{//如果第一个点不是从0点开始，就添加一个，这样就能让原始的第一个点数据能正常计算。
				jx1.xs = jx1.x = jx1.y = jx1.zfwj =  jx1.xj =  0;
				//JxArray.InsertAt(0,jx1);
				JxArray.insert(JxArray.begin(),jx1);
				bAddFirst = TRUE;
			}
			else
			{
				jx.x = jx.y = 0;
				JxArray[0] = jx;
			}
			num =JxArray.size(); // JxArray.GetCount();

			for(ii = 1; ii<num; ii++)
			{
				jx = JxArray[ii-1];
				jx1 = JxArray[ii];

				if(jx.xj<0.0000001 && jx1.xj<0.0000001)
				{
					dx = 0; dy = 0; dh = jx1.xs - jx.xs;
				}
				else
				{
					b1 = jx.zfwj / 180 * PI ; b2 = jx1.zfwj / 180 * PI;;
					if(jx.xj<0.0000001 && jx1.xj>0.0000001) //当第一个井斜角为0时，设其方位角同第二个一样。
						b1 = b2;
					if(jx.xj>0.0000001 && jx1.xj<0.0000001)//当第2个井斜角为0时，设其方位角同第1个一样。
						b2 = b1;

					sina1 = sin(jx.xj/180*PI); cosa1 = cos(jx.xj/180*PI);
					sina2 = sin(jx1.xj/180*PI); cosa2 = cos(jx1.xj/180*PI);
					sinb1 = sin(b1); cosb1 = cos(b1);
					sinb2 = sin(b2); cosb2 = cos(b2);
					cosb2b1 = cos(b2 - b1);

					tdmp= cosa1*cosa2 + sina1*sina2*cosb2b1;
					if(tdmp>1)
						tdmp = 1;
					if(tdmp<-1)
						tdmp = -1;

					ya = acos(tdmp);//acos参数在1和-1之间
					//tmpY = tan(Ya/2)/ya;
					if(ya<0.0000001)
						tmpY = 0.5;
					else if(ya<0.00001)
					{
						tmpY2 = tmpY*tmpY;
						tmpY = 0.5+tmpY2/24+tmpY2*tmpY2/240+17*tmpY2*tmpY2*tmpY2/40320;//幂级数
					}
					else
					{
						tmpY = tan(ya/2)/ya;
					}

					dy = (jx1.xs - jx.xs)*(sina1*cosb1+sina2*cosb2)*tmpY;
					dx = (jx1.xs - jx.xs)*(sina1*sinb1+sina2*sinb2)*tmpY;
					dh = (jx1.xs - jx.xs)*(cosa1+cosa2)*tmpY;
				}

				depV =depV+dh;
				//jx1.depV = depV;

				x3 = x3+dx;
				y3 = y3+dy;

				jx1.x = x3;
				jx1.y = y3;

				JxArray[ii] = jx1;
			}

			int firstid = 0;
			if(bAddFirst)
			{
				firstid = 1;
			}

			double k;
			BOOL bleft = FALSE;
			double xh,yh,xt,yt;

			xh = JxArray[firstid].x; yh = JxArray[firstid].y;
			xt = JxArray[JxArray.size()-1].x; yt = JxArray[JxArray.size() -1].y;
				//JxArray.RemoveAt(0);
			if(!(abs(xh-xt)<0.00001 && abs(yh-yt)<0.00001))
			{//井头和井尾位置一样就不做计算了。
				if(abs(xh-xt)<0.00001)
				{//垂直
					if(yh>yt)
						bleft = FALSE;
					else
						bleft = TRUE;

					k = 999999.99999;
					angle = 0;
				}
				else if(abs(yh-yt)<0.00001)
				{//水平
					k = 0;
					if(xh>xt)
						bleft = FALSE;
					else
						bleft = TRUE;
					angle = 90;
				}
				else
				{
					k = -1*(yh-yt)/(xh-xt);//注意K的计算，因为这个窗口坐标系下，y轴是向下增长的。
					if(k<0)
					{
						if(xh<xt )
						{
							bleft = TRUE;
						}
						else
						{
							bleft = FALSE;
						}
					}
					else
					{
						if(xh<xt )
						{
							bleft = FALSE;
						}
						else
						{
							bleft = TRUE;
						}
					}

					double tmpa;
					tmpa = atan(-1/k);

					if(tmpa>0)
					{
						if(bleft)
							tmpa = 360 - tmpa*180/PI ;
						else
							tmpa = 180 - tmpa*180/PI;
					}
					else
					{
						if(bleft)
							tmpa = - tmpa*180/PI ;
						else
							tmpa = 180 - tmpa*180/PI;
					}
					angle = 90+ tmpa;

					//k = -1.0*(xh -xt)/(yh-yt);  //开始视角方向,与井起始结束点连线垂直
				}
			}
		}
		return angle;
	}

	//void CItemSingleWell::AddWellIntervals(CXTPPropertyGridItem* pParentItem)
	//{
	//	//CCustomItemButton* pItemButton = new CCustomItemButton(IDS_STR_WELLDEPTHSETUP, GetOwner(),"");
	//	//pItemButton->SetFlags(xtpGridItemHasExpandButton/*|xtpGridItemHasEdit*/);
	//	//pParentItem->AddChildItem(pItemButton);

	//	//CPropertyGridItemAdd ItemAdd(NULL);

	//	//CString strTitle;
	//	//strTitle.LoadString(IDS_STR_WELL_INTERVAL);

	//	//if(m_pWell)
	//	//{
	//	//	CString strDepth;
	//	//	CString tmpStr;
	//	//	CXTPPropertyGridItem *pGridItem,*pItem1;

	//	//	if(m_pWell->GetIntervalVec()->size()>0)
	//	//	{
	//	//		for(int ii = 0; ii< m_pWell->GetIntervalVec()->size(); ii++)
	//	//		{
	//	//			tmpStr.Format("%s%d",strTitle,ii+1);
	//	//			pGridItem = pParentItem->AddChildItem(new CXTPPropertyGridItemCategory(tmpStr));

	//	//			ItemAdd.SetItem(pGridItem);

	//	//			pItem1 = ItemAdd.AddItemDouble(IDS_STR_WELL_TOPDEPTH,m_pWell->GetIntervalTop(ii));
	//	//			pItem1->SetReadOnly(TRUE);

	//	//			pItem1 = ItemAdd.AddItemDouble(IDS_STR_WELL_ENDDEPTH,m_pWell->GetIntervalBottom(ii));
	//	//			pItem1->SetReadOnly(TRUE);

	//	//			pGridItem->Expand();

	//	//			if(!strDepth.IsEmpty())
	//	//				strDepth += ";";
	//	//			tmpStr.Format("%g-%g", m_pWell->GetIntervalTop(ii),m_pWell->GetIntervalBottom(ii));
	//	//			strDepth += tmpStr;
	//	//		}
	//	//	}
	//	//	else
	//	//	{
	//	//		tmpStr.Format("%s%d",strTitle,1);
	//	//		pGridItem = pParentItem->AddChildItem(new CXTPPropertyGridItemCategory(tmpStr));

	//	//		ItemAdd.SetItem(pGridItem);

	//	//		pItem1 = ItemAdd.AddItemDouble(IDS_STR_WELL_TOPDEPTH,m_pWell->m_fSdep);
	//	//		pItem1->SetReadOnly(TRUE);

	//	//		pItem1 = ItemAdd.AddItemDouble(IDS_STR_WELL_ENDDEPTH,m_pWell->m_fEdep);
	//	//		pItem1->SetReadOnly(TRUE);

	//	//		pGridItem->Expand();

	//	//		strDepth.Format("%g-%g", m_pWell->m_fSdep, m_pWell->m_fEdep);
	//	//	}

	//	//	pItemButton->SetValue(strDepth);
	//	//}
	//}

	CWellPole *CItemSingleWell::GetWellObject()
	{
		CWellPoleDoc* pDoc = (CWellPoleDoc*)(GetView()->m_pDoc);
		return pDoc->GetWellPole();
	}
	void CItemSingleWell::SetReUnDoAction(BOOL bNoSaveData , UINT actionType)
	{
		CItemWellBase::SetReUnDoAction(bNoSaveData, actionType);
		m_pWell = GetWellObject();
	}

	void CItemSingleWell::CancelSelection(void)
	{
		CItemWellBase::CancelSelection();
		if (m_pWell != NULL)
		{
			m_pWell->ClearCurveSegmentObj();
		}
		m_pWell = NULL;
	}

}