kev/Drawer/Module/GeoSigmaDraw/WellAndSection/WellSection/ItemWcsSingleWell.cpp

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


#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 "MultiWellSectionLib/SectionWellObj.h"
#include "MultiWellSectionLib/BendObj.h"
#include "MultiWellSectionLib/FenceBendObj.h"
#include "MultiWellSectionLib/WellSection.h"
#include "MultiWellSectionLib/WellFence.h"

#include "ActionAddItem.h"
#include "ItemAddBend.h"
#include "ItemWcsTrack.h"
#include "ItemWcsTrackIn.h"
#include "ItemWcsSingleWell.h"

#include "MultiWellSectionDoc.h"
#include "MultiWellSectionlView.h"
//<2F><><EFBFBD><EFBFBD>(ptx,pty)<29><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>x1,y1),(x2,y2)<29><><EFBFBD>ߵĽ<DFB5><C4BD><EFBFBD>.
extern CPoint2D GetVPt_Line(double x1, double y1, double x2, double y2, double ptx, double pty);

/*<2A>õ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>㣬<EFBFBD><E3A3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>㣨ox<6F><78>oy<6F><79><EFBFBD>ľ<EFBFBD><C4BE><EFBFBD><EFBFBD><EFBFBD>l,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>start<72><74><EFBFBD><EFBFBD>end<6E>㴹ֱ<E3B4B9><D6B1>,oid<69>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD>־<EFBFBD><D6BE>=1<><31>ʾ˳ʱ<CBB3><CAB1><EFBFBD><EFBFBD>ת90<39><30>=2<><32>ʾ<EFBFBD><CABE>ʱ<EFBFBD><CAB1>
<EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ľ<EFBFBD><EFBFBD><EFBFBD>l<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ij<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֱ<EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><EFBFBD>oid<EFBFBD><EFBFBD>ʾ<EFBFBD><EFBFBD><EFBFBD>ĸ<EFBFBD>*/
extern CPoint2D GetPtV_Vector(double ox, double oy, double startx, double starty, double endx, double endy, double l, int oid);

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

		SetType(ITEM_WELL);

		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;
		//}
		
		strcpy(m_logFont.lfFaceName,"<EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
		m_logFont.lfHeight = -12;
		m_logFont.lfWidth = 0;
		m_logFont.lfCharSet = 1;//<2F><><EFBFBD><EFBFBD><EFBFBD>ּ<EFBFBD>
		m_logFont.lfUnderline = 0;//<2F><><EFBFBD>»<EFBFBD><C2BB><EFBFBD>
		m_logFont.lfStrikeOut = 0;//<2F>޹ᴩ<DEB9><E1B4A9>
		m_logFont.lfWeight = 400;//<2F><><EFBFBD><EFBFBD>//<2F><> 700;
		m_logFont.lfItalic = 0; //<2F><><EFBFBD><EFBFBD>
		m_logFont.lfCharSet = GB2312_CHARSET;
		m_logFont.lfEscapement = 0;
		m_logFont.lfOrientation = 0;
	}

	CItemWcsSingleWell::~CItemWcsSingleWell(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* CItemWcsSingleWell::GetDrawObj()
	{
		CMultiWellSectionDoc* pDoc = (CMultiWellSectionDoc*)(GetView()->m_pDoc);
		return m_pWell;
	}

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

		CMultiWellSectionDoc* pDoc = (CMultiWellSectionDoc*)GetDoc();

 		m_bLDown = TRUE;

		int nHandleSize=10;
		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;

				return;
			}
		}
		else
		{
			pObj = pObjSelected;
			nDragHandle = pObj->HitTest(ptReal,dHandleSize,TRUE);

			if (nDragHandle!=0)
			{
				selectMode = CItemNestBase::size;

				return;
			}
		}

		//ѡ<>е<EFBFBD><D0B5>߿<EFBFBD><DFBF>϶<EFBFBD><CFB6><EFBFBD><EFBFBD><EFBFBD>
		BeSelectBorderLine(pWell,ptReal,dHandleSize ,pDC);

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

			////<2F>е<EFBFBD>ǰѡ<C7B0>ж<EFBFBD><D0B6><EFBFBD> <20><><EFBFBD>жϵ<D0B6>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӷ<EFBFBD><D3B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӷ<EFBFBD><D3B6><EFBFBD><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD>ΪNULL<4C><4C><EFBFBD>жϾ<D0B6><CFBE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		    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)
			{
			    /////// <20><><EFBFBD><EFBFBD>о<EFBFBD><D0BE>Ϊ<EFBFBD>༭<EFBFBD><E0BCAD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɢ<EFBFBD><C9A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>m_childObjects<74>ڵĶ<DAB5><C4B6><EFBFBD>
				//if (pObjSelected->GetType() == GDOUBLEFOX_DISCRETESEGMENT && pObj != pObjSelected)
				//{
				//	CTrackDiscreteObj* pTrackDiscrete = (CTrackDiscreteObj*)pObjSelected->GetParentObj();
				//	if(pTrackDiscrete != NULL)
				//		pTrackDiscrete->GetChildObjList().RemoveAll();
				//}
				///////<2F><>ѡ<EFBFBD><D1A1><EFBFBD><EFBFBD><EFBFBD>ߵ<EFBFBD><DFB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȶ<EFBFBD><C8B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ߵ<EFBFBD><DFB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>m_childObjects<74>ڵĶ<DAB5><C4B6><EFBFBD>
				//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;
							//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>֮ǰ<D6AE><C7B0><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD>߶<EFBFBD><DFB6><EFBFBD>
							//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)
							{  //<2F><><EFBFBD>ȵ<EFBFBD>,б<><D0B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD>ӵ<EFBFBD><D3B5>ڶ<EFBFBD><DAB6><EFBFBD>s
								if (bChange)
								{
									//<2F><><EFBFBD><EFBFBD>ʮ<EFBFBD><CAAE><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>Ҫȫͼ<C8AB><CDBC><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD>ȥ<EFBFBD><C8A5><EFBFBD><EFBFBD>Ϊ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD><EFBFBD>Ƶ<EFBFBD><C6B5>µ<EFBFBD>ʮ<EFBFBD><CAAE><EFBFBD>ߴ<EFBFBD><DFB4>󣬵<EFBFBD><F3A3ACB5><EFBFBD>Ҫʮ<D2AA><CAAE><EFBFBD><EFBFBD>ʱֱ<CAB1><D6B1> OnDrawЧ<77>ʸ<EFBFBD>

									OnDraw(GetDC(), pDC);

								}
								return;
							}

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

							CItemWcsTrack *pItemTrack = (CItemWcsTrack *)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->IsSectionWell() &&
						(pObj->GetType()== KEP_RESULT||
						pObj->GetType()== KEP_LAYERGROUP||
						pObj->GetType()== KEP_STANDARD))
					{
						CItemAddBend *pAddBend = new CItemAddBend(GetDoc());
						pAddBend->SetPos(GetPos());
						pAddBend->SetItemWell(this);
						pAddBend->SetDrawObj(pObj);
						POSITION pos = m_WellObjSelectlist.GetHeadPosition();
						while(pos)
						{
							pAddBend->m_WellObjSelectlist.AddTail(m_WellObjSelectlist.GetNext(pos));
						}
						if (m_pItemSelected != NULL)
							delete m_pItemSelected;
						m_pItemSelected = pAddBend;
						m_pItemSelected->OnLButtonDown(pDC, nFlags, point, vk);
						m_bEditTrackInData = TRUE;

						OnDraw(GetDC() ,pDC);
						return;
					}
				}

				CreateDragImage();
			}
			else
			{

				if(GetType() == ITEM_SECTIONWELL)
					selectMode = ESelectMode::move;

				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)
			{//<2F><><EFBFBD><EFBFBD>ʮ<EFBFBD><CAAE><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>Ҫȫͼ<C8AB><CDBC><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD>ȥ<EFBFBD><C8A5><EFBFBD><EFBFBD>Ϊ<EFBFBD>ظ<EFBFBD><D8B8><EFBFBD><EFBFBD>Ƶ<EFBFBD><C6B5>µ<EFBFBD>ʮ<EFBFBD><CAAE><EFBFBD>ߴ<EFBFBD><DFB4>󣬵<EFBFBD><F3A3ACB5><EFBFBD>Ҫʮ<D2AA><CAAE><EFBFBD><EFBFBD>ʱֱ<CAB1><D6B1> OnDrawЧ<77>ʸ<EFBFBD>
				//if (::GetPreferences().WorkaroundDisplay.m_bViewCrossLine)
				//  GetDoc()->Invalidate();
				//else
				//	OnDraw(GetDC());
			}
		}

	}

	void CItemWcsSingleWell::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(),pDC);
			}

			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())
			{ 
				//<2F>Ͼ<EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD><EFBFBD>߽<EFBFBD>
				if(selectMode== CItemNestBase::border)
				{
					SetReUnDoAction(TRUE, IDS_STRING_ACTION_MOVE, 3);
					pWellObj = GetWellObject();
					CPoint2D ptf = pWellObj->GetAnchorPoint();//ʹ<>þ<EFBFBD>ͷ<EFBFBD>ĵ<EFBFBD><C4B5><EFBFBD>б<EFBFBD><D0B1>ʱҲ<CAB1><D2B2><EFBFBD><EFBFBD>(<28><>Ϊб<CEAA><D0B1><EFBFBD><EFBFBD>m_position<6F><6E><EFBFBD>仯)
					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;
						//////<2F><><EFBFBD>Ƶ<EFBFBD>ͷ<EFBFBD><CDB7>С<EFBFBD>߶<EFBFBD>
						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)//<2F>϶<EFBFBD><CFB6><EFBFBD>
					{
						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)//<2F>϶<EFBFBD><CFB6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƶ㣬<C6B5><E3A3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
						{
							SetReUnDoAction(TRUE, IDS_STRING_ACTION_MOVE, 3);
							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)
								{
									////<2F>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD><D0B5><EFBFBD>λ<EFBFBD><CEBB>
									//if(pTrackObj->GetTrackType() == Track_Group)
									//	pWellObj->SortTrack((CTrackGroupObj*)pTrackObj);
									//else
									//	pWellObj->SortTrack(pTrackObj);
									int ideep = 0;
									SortTrackWhenMoving(pWellObj,pTrackObj, ideep);

									CPoint2D ptf =pWellObj->GetAnchorPoint();//ʹ<>þ<EFBFBD>ͷ<EFBFBD>ĵ<EFBFBD><C4B5><EFBFBD>б<EFBFBD><D0B1>ʱҲ<CAB1><D2B2><EFBFBD><EFBFBD>(<28><>Ϊб<CEAA><D0B1><EFBFBD><EFBFBD>m_position<6F><6E><EFBFBD>仯)  pWellObj->GetPos().TopLeft();
									pWellObj->CalculateSize(ptf);

									//<2F><><EFBFBD>¼<EFBFBD><C2BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӷ<EFBFBD><D3B6><EFBFBD>
									pWellObj->ResetChildPosition();

									if (pWellObj->IsSectionWell())
									{
										CWellSection* pSection = (CWellSection*)pWellObj->GetParent();
										if (pSection->GetType()== KEP_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->GetWell() == pWellObj||(pBend->m_pLayerRight!=NULL&&pBend->m_pLayerRight->GetWell() == pWellObj))
												{
													pBend->CreateBendLines();
													pBend->CreateBendFills();
												}
											}
										}
									}
								}
							}
							//else if (pObj->GetType()==GDOUBLEFOX_LOGCURVESEGMENT)//<2F><><EFBFBD>߶<EFBFBD>
							//{
							//	CTrackInCurveSegment* pSegment = (CTrackInCurveSegment*)pObj;
							//	pSegment->m_fSdep = pWellObj->ScreenYToDepth(pSegment->GetPos().top);			// <20><><EFBFBD>߶ε<DFB6><CEB5><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>
							//	pSegment->m_fEdep = pWellObj->ScreenYToDepth(pSegment->GetPos().bottom);			// <20><><EFBFBD>߶εĽ<CEB5><C4BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
							//}
							//// <20><>о<EFBFBD><D0BE>Ϊʱ
							//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(TRUE, IDS_STRING_ACTION_MOVE, 3);
								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(TRUE, IDS_STRING_ACTION_MOVE, 3);
							pWellObj = GetWellObject();
							if (pObj->GetType()== KEP_TRACK)
							{
								CPoint2D ptf =pWellObj->GetAnchorPoint();//ʹ<>þ<EFBFBD>ͷ<EFBFBD>ĵ<EFBFBD><C4B5><EFBFBD>б<EFBFBD><D0B1>ʱҲ<CAB1><D2B2><EFBFBD><EFBFBD>(<28><>Ϊб<CEAA><D0B1><EFBFBD><EFBFBD>m_position<6F><6E><EFBFBD>仯)   pWellObj->GetPos().TopLeft();
								CTrackObj *pCTrackObj = (CTrackObj *) pObj;
								if (nDragHandle==4)
								{
									//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
									CPoint2D lastPoint = GetDC()->GetReal(m_lastPoint);
									
									lastPoint = pWellObj->ReCalculatePoint(lastPoint);

									pObj->MoveHandleTo(nDragHandle,lastPoint);
								}
								pWellObj->CalculateSize(ptf);
							}
							else 
							{
								//<2F><><EFBFBD>ö<EFBFBD><C3B6>󽻻<EFBFBD><F3BDBBBB><EFBFBD><EFBFBD><EFBFBD>
								pObj->MoveHandleTo(nDragHandle, lastPoint);
							}
						}
					}
				}
				//ˢ<><CBA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
				GetDoc()->Invalidate(/*rect*/);
			}
		}

		/// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɢ<EFBFBD><C9A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>巶Χ֮<CEA7><D6AE><EFBFBD>ҷ<EFBFBD><D2B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>о<EFBFBD><D0BE>λ<EFBFBD><CEBB><EFBFBD>ȶ<EFBFBD>ʱȡ<CAB1><C8A1>ɢ<EFBFBD><C9A2><EFBFBD><EFBFBD>ѡ<EFBFBD><D1A1>״̬
		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());
							}
						}
					}
					else if(pTrack->GetTrackType() == Track_Curve)
					{
						if(m_pItemSelected != NULL &&m_pItemSelected->GetType() != ITEM_SELECT)
						{//<2F><><EFBFBD><EFBFBD><EFBFBD>ߵ<EFBFBD><DFB5>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>꣬<EFBFBD>ͻ<EFBFBD>ѡ<EFBFBD><D1A1><EFBFBD><EFBFBD><EFBFBD>ߵ<EFBFBD>
							delete m_pItemSelected;

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

							//OnDraw(GetDC());
							

						}
					}
				}
			}	
		}

		// 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 CItemWcsSingleWell::OnLButtonDblClk(UINT nFlags, CPoint point)
	{

	}

	int CItemWcsSingleWell::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();
		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ק<EFBFBD><D7A7>ʼ<EFBFBD><CABC>

		int nHandleSize= HANDLESIZE;
		double dHandleSize = GetDC()->GetRealSize(CSize(nHandleSize/2, nHandleSize/2)).cx;
		if(IsCaptureState() && m_bLDown)
		{
			//if(m_pDragImage != NULL)
			//{
			//	CPoint scpt = point;
			//	CPoint pt = point;
			//	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->BeginDrag(0, pt);
			//	//m_pDragImage->DragEnter(GetWnd(), point);
			//	m_pDragImage->DragMove(point); //move the drag image to those coordinates
			//	//TRACE("ppp \r\n");
			//	//m_pDragImage->Draw(GetDC()->GetDC(),0,point,ILD_TRANSPARENT);
			//}

			if (m_pDragImage == NULL)
			{
				CWnd* pWnd = CWnd::FromHandle(GetView()->GetHWND());
				DrawSelected(GetDC(), pWnd);
			}
			//ˢ<><CBA2>
			//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)// <20>ƶ<EFBFBD>ͼԪ<CDBC><D4AA><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7> 	
			{
				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;

					//<2F>ƶ<EFBFBD><C6B6><EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
					activehead.OffsetRect(delta.x0, delta.y0);
					pTrackObj->MoveToActiveTrackHead(activehead);
				}				
			}
			//ˢ<><CBA2>
			if (m_pDragImage == NULL)
			{
				CWnd* pWnd = CWnd::FromHandle(GetView()->GetHWND());
				DrawSelected(GetDC(), pWnd);
			}

			m_firstPoint = m_lastPoint;
		}
		else
		{
			m_lastPoint = point;
		}
		return 1;
	}

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

	int CItemWcsSingleWell::GetSubMenu()
	{
		// <20><>
		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;
			// <20><><EFBFBD>ȵ<EFBFBD><C8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD>
			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()->IsSectionWell() &&
			(pObjSelected->GetType()== KEP_RESULT||
			pObjSelected->GetType()== KEP_LAYERGROUP||
			pObjSelected->GetType()== KEP_STANDARD))
		{
			iRMenu = 49;
		}
		//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 CItemWcsSingleWell::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
	{	
		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 = HANDLESIZE;// ::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)*/
		{
			//<2F><><EFBFBD><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>״̬
			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 CItemWcsSingleWell::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 = HANDLESIZE;// ::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;
			}
		}
		else /*if(pObjSelected != NULL)*/
		{
			//<2F><><EFBFBD><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>״̬
			if (pObjSelected->GetType() != KEP_TRACK)
			{
					int nHandle = pObjSelected->HitTest(lastPoint, dHandleSize, TRUE);
					if (nHandle != 0)
					{
						handle = 2;
						return TRUE;
					}
			}
		}

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

	BOOL CItemWcsSingleWell::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++)
		{
			//<2F><><EFBFBD>ù<EFBFBD><C3B9><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߽硢<DFBD><E7A1A2>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD>ʱ<EFBFBD><CAB1>״̬
			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;
			}
			//<2F><>ͷ<EFBFBD><CDB7><EFBFBD>±߽<C2B1>
			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;
			}
			//<2F><>ͷ<EFBFBD>߽<EFBFBD>
			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;
			}
			////<2F><><EFBFBD><EFBFBD>
			else if (pTrack->IsInTrackHead(pt, dHandleSize))
			{
				handle = 5;//SetCursor(AfxGetApp()->LoadCursor(IDC_MOVE4WAY));
				return TRUE;
			}
			//<2F><><EFBFBD><EFBFBD><EFBFBD>Ӷ<EFBFBD><D3B6><EFBFBD>
			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->IsSectionWell()) &&
						(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;
	}

	void CItemWcsSingleWell::OnDraw(CXyDC* pXyDC)
	{
		CMultiWellSectionView *pView = (CMultiWellSectionView*)GetView();
		CWnd* pWnd = CWnd::FromHandle(GetView()->GetHWND());
		if(!m_bWellFrame)
		{
			DrawHandle(pXyDC);
			DrawSelected(pXyDC, pWnd);
		}
		else
		{
			CXyDC xyDC;
			xyDC =  *GetDC();
			pView->BeginSelectBmpDC();
			xyDC.Create(&pView->GetSelectDC());
			DrawHandle(&xyDC);
			DrawSelected(&xyDC, pWnd);
			pView->EndItemSelectBmpDC(); // pView->GetMemDC());
			pView->m_pDoc->Invalidate();
		}
	}

	void CItemWcsSingleWell::OnDraw(CXyDC* pXyDC,CDC *pDC)
	{
		CMultiWellSectionView *pView = (CMultiWellSectionView*)GetView();
		CWnd* pWnd = CWnd::FromHandle(GetView()->GetHWND());
		if (!m_bWellFrame)
		{
			DrawHandle(pXyDC);
			DrawSelected(pXyDC, pWnd);
		}
		else
		{
			CXyDC xyDC;
			xyDC = *GetDC();
			//pView->BeginSelectBmpDC();
			//xyDC.Create(&pView->GetSelectDC());
			//DrawHandle(&xyDC);
			//DrawSelected(&xyDC, pWnd);
			//pView->EndItemSelectBmpDC(); // pView->GetMemDC());
			DrawHandle(pXyDC);
			DrawSelected(pXyDC,pWnd);

			pView->m_pDoc->Invalidate();
		}
	}

	void CItemWcsSingleWell::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);

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

		if (m_bDrag && m_lastPoint != m_downPoint)//<2F><><EFBFBD><EFBFBD>ק<EFBFBD><D7A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>塢<EFBFBD><E5A1A2><EFBFBD>Ƶ㣩
		{
			CPoint pt1, pt2;
			if (selectMode == CItemNestBase::border)//<2F>ϵ<EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>
			{
				if (pWell->GetWellType() == Well_Incline)
				{
					CPoint2D tpt1, tpt2, vpt, lastpt, fpt, tpt3, tpt4;
					if (nDragHandle == 6)
					{//<2F><>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
						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)
					{//<2F><>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
						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<70>൱<EFBFBD><E0B5B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>tpt1,tpt2ͬ<32><CDAC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(<28><><EFBFBD>Կ<EFBFBD><D4BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(tpt1,tpt2)ƫ<>Ƶ<EFBFBD><C6B5><EFBFBD>(fpt,lastPt)λ<><CEBB>)

						vpt = nsWellPoleFunc::GetVPt_Line(tpt1.x0, tpt1.y0, tpt2.x0, tpt2.y0, lastpt.x0, lastpt.y0); //vpt=<3D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>tpt1,tpt2<74>ϵ<EFBFBD>ͶӰ

						double xx = (tpt2.x0 - vpt.x0);
						double yy = (tpt2.y0 - vpt.y0);
						tpt3.x0 = fpt.x0 + xx; tpt3.y0 = fpt.y0 + yy;// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(fpt,lastpt)ƫ<><C6AB>xx,yy<79><79><EFBFBD>͵õ<CDB5>(tpt1,tpt2)<29>ڹ<EFBFBD><DAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>lastPt<50><74>ƽ<EFBFBD><C6BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD>ͶӰ
						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)//<2F>ϵ<EFBFBD>ͷ
					{
						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)//<2F><>ק<EFBFBD><D7A7>ͷ
					{
						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)//<2F><>ѡ<EFBFBD><D1A1><EFBFBD>Ӷ<EFBFBD><D3B6>󣬻<EFBFBD><F3A3ACBB><EFBFBD>ѡ<EFBFBD><D1A1>״̬
				{
					if (selectMode == CItemNestBase::move)//<2F><><EFBFBD><EFBFBD>
					{
						if (pWell->GetParent() != NULL)
						{
							CWellSection* pSection = (CWellSection*)pWell->GetParent();
							CWellPole* pFWell = (CWellPole*)pSection->m_WellList.GetHead();
							if (pWell != pFWell)
							{
								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
						{
							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)//<2F><><EFBFBD>Ƶ<EFBFBD>
					{
						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)
					{//<2F>ж<EFBFBD><D0B6><EFBFBD>б<EFBFBD><D0B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӷ<EFBFBD><D3B6><EFBFBD>,
						if (pParentObj->GetType() == KEP_TRACK)
							bNoInclineObj = FALSE; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD><D0B1><EFBFBD><EFBFBD><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD>,<2C>Ͳ<EFBFBD><CDB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƶ<EFBFBD>״̬
					}
					if (bNoInclineObj)
					{
						if (selectMode == CItemNestBase::move)//<2F><><EFBFBD><EFBFBD>
						{
							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 ||//<2F><>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD><EFBFBD><EFBFBD>ק<EFBFBD><D7A7>
										pObj->GetType() == KEP_FAULTPOINT/*||//<2F>ϵ<EFBFBD><CFB5><EFBFBD><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD><EFBFBD><EFBFBD>ק<EFBFBD><D7A7>
										pObj->GetType() == GDOUBLEFOX_COREWELL*/)//<2F><><EFBFBD><EFBFBD>ȡо<C8A1><D0BE><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD><EFBFBD><EFBFBD>ק<EFBFBD><D7A7>
									{
										pDC->MoveTo(rect.TopLeft());
										pDC->LineTo(rect.BottomRight());
									}
									else
									{
										pDC->Rectangle(rect);
									}
								}
							}
						}
						else if (nDragHandle != 0)//<2F><><EFBFBD>Ƶ<EFBFBD>
						{
							if (pObjSelected->GetType() == KEP_TRACK)//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
							{
								CTrackObj* pTrackObj = (CTrackObj*)pObjSelected;

								if (nDragHandle == 4)//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ק
								{
									if (pWell->GetWellType() == Well_Incline)
									{
										double h = pWell->GetTrackHeadHigh();
										CPoint2D tpt1, tpt2;  //tpt1,tpt2<74>ǵ<EFBFBD>ͷ<EFBFBD>ײ<EFBFBD><D7B2>ĺ<EFBFBD><C4BA>߶<EFBFBD>
										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<74><33><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǵ<EFBFBD>ͷ<EFBFBD>ײ<EFBFBD><D7B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ཻ<EFBFBD>ĵ<EFBFBD>
											//tpt4 = GetPtAlongVector(tpt3.x0,tpt3.y0,lastpt.x0,lastpt.y0,h,1);//tpt3,tpt4<74><34><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD>ײ<EFBFBD><D7B2><EFBFBD><EFBFBD>ߴ<EFBFBD>ֱ<EFBFBD><D6B1>
											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)//<2F><><EFBFBD><EFBFBD><EFBFBD>϶<EFBFBD><CFB6>ĵ<EFBFBD><C4B5>ڶ<EFBFBD><DAB6><EFBFBD>ʱ<EFBFBD><CAB1>Ҫ<EFBFBD>ж<EFBFBD><D0B6>Ƿ<EFBFBD><C7B7><EFBFBD>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD>
								{
									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;
			//<2F><>ѡ<EFBFBD><D1A1>״̬
			if (m_WellObjSelectlist.GetCount() == 0)//<2F><>ѡ<EFBFBD><D1A1><EFBFBD>Ӷ<EFBFBD><D3B6>󣬻<EFBFBD><F3A3ACBB><EFBFBD>ѡ<EFBFBD><D1A1>״̬
			{
				//<2F><><EFBFBD><EFBFBD><EFBFBD>Ƶ<EFBFBD>
				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
					{//<2F><>ѡ<EFBFBD>п<EFBFBD>

						TRACE("  draw in obj select \r\n");
						if (pObj->GetViewState() == UNVIEW_STATE)
							continue;

						CWellBaseObj *pParentObj = pObj->GetParent();
						if (pParentObj && bInclineWell)
						{//<2F>ж<EFBFBD><D0B6><EFBFBD>б<EFBFBD><D0B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӷ<EFBFBD><D3B6><EFBFBD>,<2C><><EFBFBD>Ի<EFBFBD><D4BB><EFBFBD>ѡ<EFBFBD><D1A1>״̬
							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);

						//<2F><><EFBFBD><EFBFBD><EFBFBD>Ƶ<EFBFBD>

						if (pObj->GetType() != KEP_COREWELL)  //ȡо<C8A1><D0BE><EFBFBD>ݲ<EFBFBD><DDB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƶ<EFBFBD>
						{
							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)
							//{
							//	//д<><D0B4><EFBFBD><EFBFBD>
							//	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);
							//}
						}
					}
					//ѡ<><D1A1><EFBFBD><EFBFBD>Χ<EFBFBD><CEA7>ɫ

					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 CItemWcsSingleWell::DrawSelected(CXyDC *pXyDC,CWnd *pWnd)
	{
		DrawMoveSelected(pXyDC,pWnd);
	}

	void CItemWcsSingleWell::SetScrollBarRange()
	{
		//CMapFrame2D& mapFrame2D = GetWnd()->GetMapFrame()->GetMapFrame2D();
		//for(int i=mapFrame2D.m_SplitterWnd.GetCount()-1; i>-1; i--)
		//{
		//	mapFrame2D.m_SplitterWnd[i].pMapWnd2D->SetScrollBarRange();
		//}
	}

	bool CItemWcsSingleWell::AddTrack()
	{
		CWellPole* pWellPole = GetWellObject();
	
		return true;
	}

	BOOL CItemWcsSingleWell::AddTrack(CTrackObj* pSelectTrack, int trackType[], int trackNum, TRACKLIST& newTracks)
	{
		TRACKLIST trackList;
		CTrackObj* pTrackObj = NULL;
		CString strTrack, str;
		strTrack = "<EFBFBD><EFBFBD>";
		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)//ȥ<><C8A5> <20><><EFBFBD><EFBFBD>" 
				str = str.Left(pos);

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

			trackList.push_back(pTrackObj);

			newTracks.push_back(pTrackObj);
		}

		AddTrack(pSelectTrack, trackList);
		return TRUE;
	}

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

		return NULL;
	}

	bool CItemWcsSingleWell::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 CItemWcsSingleWell::AddTrack(CTrackObj* pTrackSelected, TRACKLIST& trackAddList, BOOL bTrackGroup)
	{//<2F><><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>1<EFBFBD><31><EFBFBD><EFBFBD>ֱ<EFBFBD>Ӽӵ<D3BC><D3B5><EFBFBD><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>󣩣<EFBFBD>2<EFBFBD><32>ѡ<EFBFBD><D1A1><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӣ<EFBFBD><D3A3>ӵ<EFBFBD><D3B5>˾<EFBFBD><CBBE><EFBFBD><EFBFBD>ĺ<EFBFBD><C4BA>棩
		//<2F><>3<EFBFBD><33>ѡ<EFBFBD><D1A1><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ϵ<EFBFBD><CFB5>е<EFBFBD><D0B5>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD>ѡ<EFBFBD>еľ<D0B5><C4BE>ڵ<EFBFBD><DAB5><EFBFBD><EFBFBD><EFBFBD>4<EFBFBD><34><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӵĵ<D3B5><C4B5><EFBFBD>ѡ<EFBFBD>еĵ<D0B5><C4B5><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD>£<EFBFBD>Ȼ<EFBFBD><C8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD><EFBFBD>룬<EFBFBD><EBA3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɶ<EFBFBD><C9B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ߵ<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ã<EFBFBD>
		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;
			}
		}

		//<2F><><EFBFBD><EFBFBD>
		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)
			{//<2F><>trackAddList<73>еĵ<D0B5><C4B5><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD>£<EFBFBD>Ȼ<EFBFBD><C8BB><EFBFBD><EFBFBD><EFBFBD>룬<EFBFBD><EBA3AC><EFBFBD><EFBFBD>pTrackSelectedҲ<64><D2B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD>
				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); //ѡ<>е<EFBFBD><D0B5><EFBFBD><EFBFBD>µ<EFBFBD><C2B5><EFBFBD><EFBFBD>е<EFBFBD>λ<EFBFBD><CEBB>
			if (itpos != pGroupParent->GetTrackList().end())
				itpos++;  //ʹ<>µ<EFBFBD><C2B5><EFBFBD><EFBFBD><EFBFBD>ѡ<EFBFBD>е<EFBFBD><D0B5>ĺ<EFBFBD><C4BA><EFBFBD>
		}
		it = trackAddList.begin();
		for (; it != trackAddList.end(); it++)
		{ //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>еĵ<D0B5><C4B5><EFBFBD><EFBFBD>뵽<EFBFBD>½<EFBFBD><C2BD><EFBFBD><EFBFBD>ĵ<EFBFBD><C4B5><EFBFBD><EFBFBD><EFBFBD>
			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);

			/////<2F>ж<EFBFBD><D0B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӵĵ<D3B5><C4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD><D0B5>Ƿ<EFBFBD><C7B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
			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;
			}

			//<2F><><EFBFBD>ӵ<EFBFBD>
			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);

		//<2F>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ã<EFBFBD><C3A3><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
		//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* CItemWcsSingleWell::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* CItemWcsSingleWell::CreateItem(CWellBaseObj*  pObj)
	{
		CItemWellBase* pItem = NULL;
		if(pObj->GetType() == KEP_TRACK)
		{
			pItem = new CItemWcsTrack(GetDoc());
			pItem->SetPos(GetPos());
			pItem->SetDrawObj(pObj);
			pItem->SetItemWell(this);
		}
		else if(pObj->GetParent() != NULL && pObj->GetParent()->GetType() == KEP_TRACK)
		{
			pItem = new CItemWcsTrackIn(GetDoc());
			pItem->SetPos(GetPos());
			((CItemWcsTrackIn*)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 CItemWcsSingleWell::DeleteItem()
	{
		CItemWellBase::DeleteItem();

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

	void CItemWcsSingleWell::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()); //<2F><><EFBFBD>ƴ<EFBFBD><C6B4>϶<EFBFBD><CFB6><EFBFBD>
			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;

		//// 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

		CBitmap* pBitmap=GetBitmap(GetDC()->GetDC(),rect,inclineWellRect,bTrack,(CPoint*)plgPts);
		m_pDragImage->Add(pBitmap, RGB(255,255,255));
		delete pBitmap;
	}

	CBitmap* CItemWcsSingleWell::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);

		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();//<2F><><EFBFBD>ƴ<EFBFBD><C6B4>϶<EFBFBD><CFB6><EFBFBD>
				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 CItemWcsSingleWell::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) // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǰѡ<C7B0>е<EFBFBD><D0B5><EFBFBD><EFBFBD><EFBFBD>û<EFBFBD>е<EFBFBD><D0B5>򷵻<EFBFBD>
			return;

		SetReUnDoAction(); 
		pWellObj = GetWellObject();//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>undoaction<6F><6E>Ҫ<EFBFBD><D2AA><EFBFBD>»<EFBFBD><C2BB><EFBFBD>һ<EFBFBD>¾<EFBFBD><C2BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
		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); //<2F><><EFBFBD>룬<EFBFBD><EBA3AC><EFBFBD>Ӷ<EFBFBD>ʹ<EFBFBD><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		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 CItemWcsSingleWell::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) // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ǰѡ<C7B0>е<EFBFBD><D0B5>Ҳ<EFBFBD>û<EFBFBD>е<EFBFBD><D0B5>򷵻<EFBFBD>
			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 CItemWcsSingleWell::Clear()
	{
		if(m_pItemSelected != NULL)
			delete m_pItemSelected;
		m_pItemSelected = NULL;
		m_WellObjSelectlist.RemoveAll();
	}

	int CItemWcsSingleWell::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;
				CItemWcsTrackIn *pItemTrackIn = new CItemWcsTrackIn(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();	

			delete m_pItemSelected;
			m_pItemSelected = NULL;
	
		}
		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)
					{
						CItemWcsTrack 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 CItemWcsSingleWell::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_FluidProducingProfile:
			{
				strTrackType = "FluidProducingProfile";
			}
			break;
		case Track_WaterInjectionProfile:
			{
				strTrackType = "WaterInjectionProfile";
			}
			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 CItemWcsSingleWell::AddTrackInObjData()
	{
		if(NULL == m_pItemSelected)
			return;

	}

	void CItemWcsSingleWell::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 CItemWcsSingleWell::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;
		}
		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>½<EFBFBD><C2BD>ͽ<EFBFBD><CDBD>۵<EFBFBD><DBB5>͵ز<CDB5><D8B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱɾ<CAB1><C9BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		if (pTrackObj->GetTrackType() == Track_Result || pTrackObj->GetTrackType() == Track_Stratum)
		{
			CWellSection* pWellSection = (CWellSection*)pWellObj->GetParent();
			if (NULL != pWellSection)
			{
				POSITION pos = pWellSection->m_BendList.GetHeadPosition();
				while(NULL != pos)
				{
					CWellBaseObj*  pObj = (CWellBaseObj*)pWellSection->m_BendList.GetNext(pos);
					if (pObj->GetType() == KEP_SECTIONBEND)
					{
						CBendObj* pBend = (CBendObj*)pObj;
						CTrackObj* pTrackLeft = NULL;
						CTrackObj* pTrackRight = NULL;
						pTrackLeft = (CTrackObj*)pBend->m_pLayerLeft->GetParent();
						if (pBend->m_pLayerRight != NULL)
						{
							pTrackRight = (CTrackObj*)pBend->m_pLayerRight->GetParent();
						}
						if (pTrackRight == pTrackObj || pTrackLeft ==pTrackObj)
						{
							pWellSection->DeleteBend(pBend);
							GetDoc()->Invalidate();// pWellSection);
						}
					}
				}
			}
		}

		//<2F><><EFBFBD>յ<EFBFBD><D5B5>ڵ<EFBFBD><DAB5>Ӷ<EFBFBD><D3B6><EFBFBD>
		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 CItemWcsSingleWell::ApplingWellDbTemplate()
	{
		//CDlgApplyTemplate dlg("WellColumn");
		//
		//if(dlg.DoModal() == IDCANCEL)
		//	return;

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

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

		SetReUnDoAction(FALSE);

		//<2F><><EFBFBD>ݾ<EFBFBD><DDBE>ڵ<EFBFBD><DAB5><EFBFBD><EFBFBD><EFBFBD>
		//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)
		{
			//<2F>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
			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());

			//Ӧ<>þ<EFBFBD>ģ<EFBFBD><C4A3>
			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);
	}

	BOOL CItemWcsSingleWell::ApplingTemplate(CKXmlParse& xp)
	{
		CWellPole* pWellObj = GetWellObject();

		SetReUnDoAction();

		//<2F><><EFBFBD>ݾ<EFBFBD><DDBE>ڵ<EFBFBD><DAB5><EFBFBD><EFBFBD><EFBFBD>
		//CTrackList tracklist;
		TRACKLIST tracklist;
		tracklist.assign(pWellObj->GetTrackList().begin(), pWellObj->GetTrackList().end());
		pWellObj->GetTrackList().clear();

		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(xp, -1) == 0)
		{
			//<2F>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
			TRACKLIST::reverse_iterator rit = tracklist.rbegin();
			for (; rit != tracklist.rend(); rit++)
			{
				pWellObj->GetTrackList().push_front(*rit);
			}
			tracklist.clear();
			return FALSE;
		}
		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());

			//Ӧ<>þ<EFBFBD>ģ<EFBFBD><C4A3>
			TRACKLIST::iterator it = tracklist.begin();
			for (; it != tracklist.end(); it++)
				pWellObj->GetTemplateList().push_front(*it);
			pWellObj->ApplingTemplate(TRUE, dOldTrackHead, dOldWellHead);
			//ImportDataAll(pWellObj, FALSE);
		}

		return TRUE;
	}
	BOOL CItemWcsSingleWell::ApplingWellTemplate(CString filePath)
	{
		//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;
		//}
		////<2F><><EFBFBD><EFBFBD>·<EFBFBD><C2B7>
		//filepathstr=dlg.GetPathName();
		//CString ext = dlg.GetFileExt();
		//if(ext == "dml") //dml<6D><6C>ʽ
		//{
		//	CStdioFile fr;
		//	if(!fr.Open(filepathstr,CFile::modeRead)) 
		//		return;

		//	ApplingFileTemplate(fr);
		//}
		BOOL b = FALSE;
		CString strExt = "";
		if (filePath.GetLength() < 4)
			return FALSE;
		strExt = filePath.Right(4);
		strExt = strExt.MakeLower();
		if (strExt == ".pcg")
		{
			CKXmlParse xp;
			if (xp.ReadXmlFile(filePath.GetBuffer()))
			{
				b = ApplingTemplate(xp);
			}
			else
				b = TRUE;
		}

		return b;
	}



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


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

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

	}

	void CItemWcsSingleWell::ExportDataToDB(CTrackObj* pTrackObj)
	{
		
	}


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

	void CItemWcsSingleWell::GetOperationAndVersion(const CString strWellName, const CString strCurveName, vector<CString> &OperatVec, vector<CString> &VersionVec)
	{
		
	}

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


	}

	

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


		return pNewDraw;
	}
	
	void CItemWcsSingleWell::BeSelectBorderLine(CTrackGroup* pGroup,CPoint2D pt,double dHandleSize, CDC *pDC)
	{
		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))
			{
				//<2F><><EFBFBD><EFBFBD><EFBFBD>϶<EFBFBD>
				nDragHandle = 4;
				selectMode = CItemNestBase::size;
				OnDraw(GetDC(),pDC);
				Select(pTrack);
				OnDraw(GetDC(),pDC);
				//GetView()->SetCapture();
				return;
			}
			else if (pTrack->IsOnTrackTop(pt, dHandleSize))
			{//<2F><><EFBFBD><EFBFBD><EFBFBD>϶<EFBFBD>
				nDragHandle = 6;
				selectMode = CItemNestBase::border;
				//GetView()->SetCapture();
				return;
			}
			else if (pTrack->IsOnWellTop(pt, dHandleSize))
			{//<2F><>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD><EFBFBD>϶<EFBFBD>
				nDragHandle = 2;
				selectMode = CItemNestBase::border;
				//GetView()->SetCapture();
				return;
			}
			else if (pTrack->GetTrackType() == Track_Group)
			{
				pTrackGroup = (CTrackGroup*)pTrack;
				BeSelectBorderLine(pTrackGroup, pt, dHandleSize ,pDC);
			}
		}
	}

	BOOL CItemWcsSingleWell::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++)
		{
			//<2F><><EFBFBD>ù<EFBFBD><C3B9><EFBFBD><EFBFBD>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߽硢<DFBD><E7A1A2>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD><EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD>ʱ<EFBFBD><CAB1>״̬
			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;
			}
			//<2F><>ͷ<EFBFBD><CDB7><EFBFBD>±߽<C2B1>
			else if (pTrack->IsOnTrackTop(pt, dHandleSize))
			{
				if (pWell->GetWellType() == Well_Incline && m_HCursor)
					SetCursor(m_HCursor);
				else
					SetCursor(AfxGetApp()->LoadCursor(IDC_SIZENS));

				return TRUE;
			}
			//<2F><>ͷ<EFBFBD>߽<EFBFBD>
			else if (pTrack->IsOnWellTop(pt, dHandleSize))
			{
				if (pWell->GetWellType() == Well_Incline && m_HCursor)
					SetCursor(m_HCursor);
				else
					SetCursor(AfxGetApp()->LoadCursor(IDC_SIZENS));

				return TRUE;
			}
			////<2F><><EFBFBD><EFBFBD>
			else if (pTrack->IsInTrackHead(pt, dHandleSize))
			{
				SetCursor(AfxGetApp()->LoadCursor(IDC_MOVE4WAY));
				return TRUE;
			}
			//<2F><><EFBFBD><EFBFBD><EFBFBD>Ӷ<EFBFBD><D3B6><EFBFBD>
			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->IsSectionWell()) &&
						(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 CItemWcsSingleWell::SortTrackWhenMoving(CTrackGroup* pGroup,CTrackObj* pTrackMoving, int& ideep)
	{
		////<2F><><EFBFBD>ƶ<EFBFBD>
		if(pTrackMoving->m_HeadRect.PtInRect(pTrackMoving->m_active_head.CenterPoint()))
		{
			return FALSE;
		}
		if(ideep == 0)  //<2F><>¼undo/redoʱ<6F><CAB1>ִ<EFBFBD><D6B4>һ<EFBFBD>ξͿ<CEBE><CDBF><EFBFBD><EFBFBD>ˣ<EFBFBD><CBA3><EFBFBD>ֹŲ<D6B9><C5B2>һ<EFBFBD>ε<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD>ݹ<EFBFBD><DDB9><EFBFBD><EFBFBD>ã<EFBFBD><C3A3><EFBFBD><EFBFBD>ж<EFBFBD><D0B6>ν<EFBFBD><CEBD><EFBFBD>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();
			//<2F><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ң<EFBFBD><D2A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>еĵ<D0B5><C4B5><EFBFBD><EFBFBD>бȽϣ<C8BD><CFA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>±<EFBFBD><C2B1>ж<EFBFBD><D0B6><EFBFBD><EFBFBD>ŵ<EFBFBD><C5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱֻҪ<D6BB><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD><D0A1>Ŀ<EFBFBD>ĵ<EFBFBD><C4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĵ㼴<C4B5><E3BCB4>
			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 || bRight)
			{
				if (pTrack->GetTrackType() == Track_Group)
				{//<2F>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ŵ<EFBFBD><C5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ұߵķ<DFB5>Χ<EFBFBD><CEA7>
					CTrackGroup* pTrackGroup = (CTrackGroup*)pTrack;
					if(bIn) //pTrackGroup->m_HeadRect.PtInRect(pTrackMoving->m_active_head.CenterPoint()))
					{//<2F>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ŵ<EFBFBD><C5B5><EFBFBD>pTrack<63>ڲ<EFBFBD>
						if (pTrackGroup->GetGroupType() == Group_Vertical)
						{
							pTrackMoving->SetTrackWidthRatio(pTrack->m_dTrackWidth/pTrackMoving->m_dTrackWidth);
							pTrackGroup->GetTrackList().push_back(pTrackMoving);
							pTrackMoving->SetParent(pTrackGroup);
							return TRUE;
						}
						else 
						{//ˮƽ<CBAE><C6BD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݹ<EFBFBD>
							(SortTrackWhenMoving(pTrackGroup, pTrackMoving, ideep));

							return TRUE;
						}
					}
					else
					{//<2F>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ŵ㲻<C5B5><E3B2BB>pTrack<63>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ŵ<EFBFBD><C5B5><EFBFBD>pTrack<63><6B><EFBFBD>ϱ߻<CFB1><DFBB>±ߣ<C2B1><DFA3><EFBFBD>ֱ<EFBFBD>Ӽ<EFBFBD><D3BC>뵽pGroup
						if(pGroup->GetGroupType() == Group_Vertical)
						{
							pTrackMoving->SetTrackWidthRatio(pGroup->m_dTrackWidth/pTrackMoving->m_dTrackWidth);
						}
						if(bRight) //<2F><><EFBFBD>ŵ<EFBFBD><C5B5><EFBFBD>Ŀ<EFBFBD>ĵ<EFBFBD><C4B5><EFBFBD><EFBFBD>Ҳ࣬<D2B2><E0A3AC><EFBFBD><EFBFBD><EFBFBD>뵽Ŀ<EBB5BD>ĵ<EFBFBD><C4B5>ĺ<EFBFBD><C4BA><EFBFBD>
							posObj++;
						pGroup->GetTrackList().insert(posObj,pTrackMoving);
						pTrackMoving->SetParent(pGroup);
						return TRUE;
					}
				}
				else
				{//<2F>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ŵ<EFBFBD><C5B5>Dz<EFBFBD><C7B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD>,<2C><><EFBFBD>ұߵķ<DFB5>Χ

					if ((pTrack->GetTrackType() == Track_Curve || pTrack->GetTrackType() == Track_Discrete ||
						pTrackMoving->GetTrackType() == Track_Curve || pTrackMoving->GetTrackType() == Track_Discrete) &&
						bIn)
					{//<2F><><EFBFBD>߻<EFBFBD>ɢ<EFBFBD><C9A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD>ֱ<EFBFBD><D6B1><EFBFBD>ϣ<EFBFBD><CFA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD><C2B5><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD><EFBFBD><EFBFBD>
						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
					{//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>͵ĵ<CDB5><C4B5><EFBFBD>ֱ<EFBFBD>Ӽ<EFBFBD><D3BC>롣
						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;
					}
				}
			}
		}


		//<2F><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD>Ҳ<EFBFBD>
		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 CItemWcsSingleWell::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 CItemWcsSingleWell::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 CItemWcsSingleWell::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 CItemWcsSingleWell::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);//<2F>õ<EFBFBD>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊͼ<CEAA><CDBC>Ϣ
		::GetObject((HGDIOBJ)cursorinfo.hbmColor,sizeof(BITMAP),&cursorBitInfo);//<2F>õ<EFBFBD>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λͼ<CEBB><CDBC>Ϣ

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

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

		CPoint2D pospts[4];  //ԭʼ<D4AD><CABC><EFBFBD><EFBFBD><EFBFBD>Ĵ<EFBFBD>С
		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];//<2F><>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¹<EFBFBD><C2B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĸ<EFBFBD><C4B8><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

		CPoint topleftPt,botRightPt,tpt;  //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϣ<EFBFBD><CFA3><EFBFBD><EFBFBD>½<EFBFBD>
		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) //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD><D0A1>0<EFBFBD><30><EFBFBD><EFBFBD>ƫ<EFBFBD><C6AB>һ<EFBFBD>£<EFBFBD>ȷ<EFBFBD><C8B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		{
			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)//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD><D0A1>0<EFBFBD><30><EFBFBD><EFBFBD>ƫ<EFBFBD><C6AB>һ<EFBFBD>£<EFBFBD>ȷ<EFBFBD><C8B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		{
			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); //<2F><>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>

		CBitmap *pOldBitmap;
		CBitmap *pOldmaskmap;

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

		pOldmaskmap = smaskdc.SelectObject(&sMaskbmp);  //ʹ<><CAB9>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λͼ
		pOldBitmap = scursordc.SelectObject(&sCousorbmp); //ʹ<><CAB9>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λͼ

		CDC memDC;
		memDC.CreateCompatibleDC(&dc);

		CBitmap *pNewbkCousorbmp; //ʹ<><CAB9>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λͼ<CEBB><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λͼ<CEBB>γ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>µĹ<C2B5><C4B9><EFBFBD>λͼ<CEBB><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>µĹ<C2B5><C4B9><EFBFBD>λͼ<CEBB>ı<EFBFBD><C4B1><EFBFBD>ɫ<EFBFBD>ƶ<EFBFBD>Ϊ<EFBFBD><CEAA>ɫ
		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));//<2F><>λͼ<CEBB><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɫ

		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);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>¹<EFBFBD><C2B9><EFBFBD>λͼ<CEBB><CDBC><EFBFBD><EFBFBD>ɫ<EFBFBD><C9AB><EFBFBD><EFBFBD>ɫ(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>͸<EFBFBD><CDB8>λͼ<CEBB><CDBC>ԭ<EFBFBD><D4AD>)

		//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);//<2F><><EFBFBD><EFBFBD>Ҫ<EFBFBD>Ĺ<EFBFBD><C4B9><EFBFBD>λͼ<CEBB><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD>Ĵ<EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD>

		pOldBitmap = dc.SelectObject(pCursorBmp);

		//pCursorMaskmap = new CBitmap();
		pCursorMaskBmp->CreateBitmap(rect.Width(),rect.Height(),1,1,NULL);//<2F><><EFBFBD><EFBFBD>Ҫ<EFBFBD>Ĺ<EFBFBD><C4B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λͼ<CEBB><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD>Ĵ<EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD>

		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));  //<2F><><EFBFBD>нǶȹ<C7B6><C8B9><EFBFBD><EFBFBD><EFBFBD>λͼ<CEBB><CDBC><EFBFBD><EFBFBD>ȫ<EFBFBD><C8AB><EFBFBD><EFBFBD>ɫ
		dc.PlgBlt(points,&memDC,0,0,cursorBitInfo.bmWidth,cursorBitInfo.bmHeight,maskBmp,0,0);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>±<EFBFBD><C2B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λͼ<CEBB><CDBC>ת
		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);//<2F><><EFBFBD><EFBFBD><EFBFBD>нǶȹ<C7B6><C8B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊͼ,͸<><CDB8>ɫ<EFBFBD><C9AB><EFBFBD><EFBFBD>ɫ

		//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 CItemWcsSingleWell::DrawHandle(CXyDC *pDC, const CPoint2D &point)
	{
		CItemNestBase::DrawHandle(pDC,point);
	}
	void CItemWcsSingleWell::DrawHandle(CXyDC *pDC)
	{
		if(m_pWell != NULL)
		{
			if(m_pWell->GetWellType() == Well_Incline)
			{

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

	BOOL CItemWcsSingleWell::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 CItemWcsSingleWell::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 CItemWcsSingleWell::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;
		//	}
		//}

		////<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>·<EFBFBD>
		//CTrackList tracklist;
		//tracklist.AddTail(pTrackCurveNew);
		//AddTrack(pTrackSelected, tracklist, TRUE);

		return TRUE;
	}

	BOOL CItemWcsSingleWell::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;
		//	}
		//}
		////<2F><><EFBFBD>뵽<EFBFBD><EBB5BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		//CTrackList tracklist;
		//tracklist.AddTail(pTrackCurveNew);
		//AddTrack(pTrackSelected, tracklist, TRUE);

		return TRUE;
	}

	void CItemWcsSingleWell::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;
		//	//<2F><>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		//	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;

		//	//<2F><>ȡͼ<C8A1><CDBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݱ<EFBFBD><DDB1><EFBFBD><EFBFBD>ֶ<EFBFBD>
		//	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;
		//		//<2F><>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		//		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 CItemWcsSingleWell::CreatePorTrack(CWellPole* pWell,CDataObjList& CurveList,BOOL bAddResult,double PorTemp,double SwWaterTemp,double SwOilTemp,double AnalysisHd)
	//{
	//	CTrackList trackList;
	//	CWellBaseObj*  pObj = NULL;
	//	CTrackObj* pTrack = NULL;

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//<2F><><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD><C2B5><EFBFBD><EFBFBD>ϵ<EFBFBD>
	//	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","<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>",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);

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//<2F><><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD><C2B5><EFBFBD><EFBFBD>ϵ<EFBFBD>
	//	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 = "ɰ<><C9B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
	//	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 = "ɰ<><C9B0>";
	//	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)
	//	{
	//		//<2F><><EFBFBD>ӽ<EFBFBD><D3BD>͵<EFBFBD>
	//		CClientDC dc(NULL);
	//		//<2F><><EFBFBD>þ<EFBFBD><C3BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD><D0B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//		CTrackResultObj* pTrackResult = new CTrackResultObj();
	//		pTrackResult->m_strTitle = "<22><><EFBFBD><EFBFBD>";
	//		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;
	//			//<2F><>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//			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;

	//			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD>ͽ<EFBFBD><CDBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//			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 = "ˮ<><CBAE>";
	//					}
	//					else if (pTrackCurveObj_11->GetCurveValue(i)>=SwOilTemp&&pTrackCurveObj_11->GetCurveValue(i)<SwWaterTemp&&pTrackCurveObj_22->GetCurveValue(i)>PorTemp)
	//					{
	//						analysisIndex = i;
	//						strType = "<22><>ˮͬ<CBAE><CDAC>";
	//					}
	//					else if (pTrackCurveObj_11->GetCurveValue(i)<SwOilTemp&&pTrackCurveObj_22->GetCurveValue(i)>PorTemp)
	//					{
	//						analysisIndex = i;
	//						strType = "<22>Ͳ<EFBFBD>";
	//					}
	//				}
	//				else
	//				{
	//					strType1="";
	//					if (pTrackCurveObj_11->GetCurveValue(i)>=SwWaterTemp&&pTrackCurveObj_11->GetCurveValue(i)<=100)
	//					{
	//						strType1 = "ˮ<><CBAE>";
	//					}
	//					else if (pTrackCurveObj_11->GetCurveValue(i)>=SwOilTemp&&pTrackCurveObj_11->GetCurveValue(i)<SwWaterTemp)
	//					{
	//						strType1 = "<22><>ˮͬ<CBAE><CDAC>";
	//					}
	//					else if (pTrackCurveObj_11->GetCurveValue(i)<SwOilTemp)
	//					{
	//						strType1 = "<22>Ͳ<EFBFBD>";
	//					}

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

	//							//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD>
	//							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)
	//							//{
	//							//	//<2F><><EFBFBD>ض<EFBFBD><D8B6><EFBFBD>
	//							//	pTrackInResult->SetViewState(UNVIEW_STATE);
	//							//}
	//							if(pTrackInResult->m_fSdep >= pWell->m_fEdep || pTrackInResult->m_fEdep <= pWell->m_fSdep)
	//								pTrackInResult->SetViewState(UNVIEW_STATE);
	//							//<2F><><EFBFBD>ӵ<EFBFBD><D3B5>Ӷ<EFBFBD><D3B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//							pTrackResult->Add(pTrackInResult);
	//						}
	//						analysisIndex = -1;
	//					}
	//					else
	//					{
	//						fEnd = sdep+(i-index1)*pTrackCurveObj_11->m_fRlev;
	//					}
	//				}
	//			}
	//			//<2F><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD>ͽ<EFBFBD><CDBD><EFBFBD>
	//			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);

	//					//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD>
	//					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)
	//					//{
	//					//	//<2F><><EFBFBD>ض<EFBFBD><D8B6><EFBFBD>
	//					//	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);
	//					//<2F><><EFBFBD>ӵ<EFBFBD><D3B5>Ӷ<EFBFBD><D3B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//					pTrackResult->Add(pTrackInResult);
	//				}
	//			}
	//		}
	//	}
	//	else
	//	{
	//		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϲ<EFBFBD>ϵ
	//		//pWell->SortTrackGroup();
	//		CPoint2D ptf = pWell->GetPos().TopLeft();
	//		pWell->ComputeSize(ptf);
	//	}
	//}

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

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//<2F><><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD><C2B5><EFBFBD><EFBFBD>ϵ<EFBFBD>
	//	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","<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>",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);

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//<2F><><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD><C2B5><EFBFBD><EFBFBD>ϵ<EFBFBD>
	//	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);

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//<2F><><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD><C2B5><EFBFBD><EFBFBD>ϵ<EFBFBD>
	//	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","Ӣ<><D3A2>",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);

	//	/////////////////////////////////////////////////////////////////////////////////////////////////
	//	//<2F><><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD><C2B5><EFBFBD><EFBFBD>ϵ<EFBFBD>
	//	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 = "ɰ<><C9B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD>";
	//	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 = "ɰ<><C9B0>";
	//	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)
	//	{
	//		//<2F><><EFBFBD>ӽ<EFBFBD><D3BD>͵<EFBFBD>
	//		CClientDC dc(NULL);
	//		//<2F><><EFBFBD>þ<EFBFBD><C3BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD><D0B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//		CTrackResultObj* pTrackResult = new CTrackResultObj();
	//		pTrackResult->m_strTitle = "<22><><EFBFBD><EFBFBD>";
	//		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);

	//		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϲ<EFBFBD>ϵ
	//		//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;
	//			//<2F><>׼<EFBFBD><D7BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//			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;

	//			//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݵ<EFBFBD><DDB5><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD>ͽ<EFBFBD><CDBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//			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 = "ˮ<><CBAE>";
	//					}
	//					else if (pTrackCurveObj_21->GetCurveValue(i)>=SwOilTemp&&pTrackCurveObj_21->GetCurveValue(i)<SwWaterTemp&&pTrackCurveObj_32->GetCurveValue(i)>PorTemp)
	//					{
	//						analysisIndex = i;
	//						strType = "<22><>ˮͬ<CBAE><CDAC>";
	//					}
	//					else if (pTrackCurveObj_21->GetCurveValue(i)<SwOilTemp&&pTrackCurveObj_32->GetCurveValue(i)>PorTemp)
	//					{
	//						analysisIndex = i;
	//						strType = "<22>Ͳ<EFBFBD>";
	//					}
	//				}
	//				else
	//				{
	//					strType1="";
	//					if (pTrackCurveObj_21->GetCurveValue(i)>=SwWaterTemp&&pTrackCurveObj_21->GetCurveValue(i)<=100)
	//					{
	//						strType1 = "ˮ<><CBAE>";
	//					}
	//					else if (pTrackCurveObj_21->GetCurveValue(i)>=SwOilTemp&&pTrackCurveObj_21->GetCurveValue(i)<SwWaterTemp)
	//					{
	//						strType1 = "<22><>ˮͬ<CBAE><CDAC>";
	//					}
	//					else if (pTrackCurveObj_21->GetCurveValue(i)<SwOilTemp)
	//					{
	//						strType1 = "<22>Ͳ<EFBFBD>";
	//					}

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

	//							//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD>
	//							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)
	//							//{
	//							//	//<2F><><EFBFBD>ض<EFBFBD><D8B6><EFBFBD>
	//							//	pTrackInResult->SetViewState(UNVIEW_STATE);
	//							//}
	//							if(pTrackInResult->m_fSdep >= pWell->m_fEdep || pTrackInResult->m_fEdep <= pWell->m_fSdep)
	//								pTrackInResult->SetViewState(UNVIEW_STATE);
	//							//<2F><><EFBFBD>ӵ<EFBFBD><D3B5>Ӷ<EFBFBD><D3B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//							pTrackResult->Add(pTrackInResult);
	//						}
	//						analysisIndex = -1;
	//					}
	//					else
	//					{
	//						fEnd = sdep+(i-index1)*pTrackCurveObj_21->m_fRlev;
	//					}
	//				}
	//			}
	//			//<2F><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD>ͽ<EFBFBD><CDBD><EFBFBD>
	//			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);

	//					//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD>
	//					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)
	//					//{
	//					//	//<2F><><EFBFBD>ض<EFBFBD><D8B6><EFBFBD>
	//					//	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);
	//					//<2F><><EFBFBD>ӵ<EFBFBD><D3B5>Ӷ<EFBFBD><D3B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	//					pTrackResult->Add(pTrackInResult);
	//				}
	//			}
	//		}
	//	}
	//	else
	//	{
	//		//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϲ<EFBFBD>ϵ
	//		//pWell->SortTrackGroup();
	//		CPoint2D ptf = pWell->GetPos().TopLeft();
	//		pWell->ComputeSize(ptf);
	//	}
	//}

	CTrackCurve* CItemWcsSingleWell::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  CItemWcsSingleWell::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  CItemWcsSingleWell::GetWellProjecttionAngle(CWellPole *pWellObj)
	{
		double angle = 0;
		typedef struct _JXTraceStruct//б<><D0B1><EFBFBD><EFBFBD><EFBFBD>ݽṹ
		{
			double xs;							//<2F><>б<EFBFBD><D0B1>
			double xj;							//<2F><>б<EFBFBD><D0B1>
			double zfwj;						//<2F>淽λ<E6B7BD><CEBB>
			double x;							//ͶӰ<CDB6><D3B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
			double y;							//ͶӰ<CDB6><D3B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
		} JXTraceStruct;
		JXTraceStruct jx,jx1;
		//CArray <JXTraceStruct,JXTraceStruct> JxArray;;//<2F><>б<EFBFBD><D0B1><EFBFBD><EFBFBD>,<2C><><EFBFBD>ű<EFBFBD><C5B1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȫ<EFBFBD><C8AB>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD>	
		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=ǰһ<C7B0><D2BB><EFBFBD>㾮б<E3BEAE>ǣ<EFBFBD>sina2,cosa2=<3D><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>б<EFBFBD><D0B1><EFBFBD><EFBFBD>,sinb1,cosb1=ǰһ<C7B0><D2BB><EFBFBD>㷽λ<E3B7BD><CEBB>
			//,cosb2,sinb2,=<3D><>һ<EFBFBD>㷽λ<E3B7BD><CEBB>,cosb2b1=<3D><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>λ<EFBFBD>Ǽ<EFBFBD>ȥǰһ<C7B0><D2BB><EFBFBD><EFBFBD>λ<EFBFBD><CEBB>;
			double sina1,sina2,cosa1,cosa2,cosb1,cosb2,sinb1,sinb2,cosb2b1;
			double x3,y3,depV ;//<2F><><EFBFBD>켣<EFBFBD><ECBCA3> 
			x3=y3 = 0 ;
			double dx,dy,dh;//<2F><>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
			int ii,num;

			double b1,b2; //<2F><>λ<EFBFBD><CEBB>1<EFBFBD><31><EFBFBD><EFBFBD>λ<EFBFBD><CEBB>2;

			double ya; //<2F><><EFBFBD>Ƚǣ<C8BD>ȫ<EFBFBD><C8AB>λ<EFBFBD><CEBB>

			double tmpY,tmpY2;
			depV = 0;

			double tdmp ;

			BOOL bAddFirst = FALSE;
			jx = JxArray[0];
			if(jx.xs>0.000001)
			{//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD>㲻<EFBFBD>Ǵ<EFBFBD>0<EFBFBD>㿪ʼ<E3BFAA><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭʼ<D4AD>ĵ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>㡣
				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) //<2F><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>б<EFBFBD><D0B1>Ϊ0ʱ<30><CAB1><EFBFBD><EFBFBD><EFBFBD>䷽λ<E4B7BD><CEBB>ͬ<EFBFBD>ڶ<EFBFBD><DAB6><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>
						b1 = b2;
					if(jx.xj>0.0000001 && jx1.xj<0.0000001)//<2F><><EFBFBD><EFBFBD>2<EFBFBD><32><EFBFBD><EFBFBD>б<EFBFBD><D0B1>Ϊ0ʱ<30><CAB1><EFBFBD><EFBFBD><EFBFBD>䷽λ<E4B7BD><CEBB>ͬ<EFBFBD><CDAC>1<EFBFBD><31>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>
						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<6F><73><EFBFBD><EFBFBD><EFBFBD><EFBFBD>1<EFBFBD><31>-1֮<31><D6AE>
					//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;//<2F>ݼ<EFBFBD><DDBC><EFBFBD>
					}
					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))
			{//<2F><>ͷ<EFBFBD>;<EFBFBD>βλ<CEB2><CEBB>һ<EFBFBD><D2BB><EFBFBD>Ͳ<EFBFBD><CDB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ˡ<EFBFBD>
				if(abs(xh-xt)<0.00001)
				{//<2F><>ֱ
					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);//ע<><D7A2>K<EFBFBD>ļ<EFBFBD><C4BC>㣬<EFBFBD><E3A3AC>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD>£<EFBFBD>y<EFBFBD><79><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ġ<EFBFBD>
					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);  //<2F><>ʼ<EFBFBD>ӽǷ<D3BD><C7B7><EFBFBD>,<2C>뾮<EFBFBD><EBBEAE>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ߴ<EFBFBD>ֱ
				}
			}
		}
		return angle;
	}

	

	CWellPole *CItemWcsSingleWell::GetWellObject()
	{
		//CMultiWellSectionDoc* pDoc = (CMultiWellSectionDoc*)(GetView()->GetDocument());
		//return pDoc->GetWellPole();
		return m_pWell;
	}
	void CItemWcsSingleWell::SetReUnDoAction(BOOL bNoSaveData , UINT actionType , int actionItemType, CWellBaseObj* pWellBase)
	{
		CItemWellBase::SetReUnDoAction(bNoSaveData, actionType ,actionItemType, m_pWell);
		//m_pWell = GetWellObject();
		m_pWell = GetWellObject();
	}

	void CItemWcsSingleWell::DrawMovedTrackPicture(CDC* pDC)
	{
		if (m_WellObjSelectlist.GetCount() != 1)
			return;

		CTrackObj* pTrackObj = (CTrackObj*)m_WellObjSelectlist.GetHead();
		CXyDC xyDC;
		xyDC = *GetDC();
		xyDC.Create(pDC);
		CWellPole* pWellObj = GetWellObject();
		CTrackObj* pCurrentInTrack = GetMoveInTrack(pWellObj, pTrackObj);
		if (pCurrentInTrack)
		{
			CRect oldrect;

			CRect rect = GetDC()->GetScreen(pCurrentInTrack->m_HeadRect);

			CBrush brush;
			brush.CreateSolidBrush(RGB(230, 230, 150));

			xyDC.GetDC()->FillRect(rect, &brush);

			pCurrentInTrack->DrawMoveTrackFrame(&xyDC, CPoint2D(0, 0));

		}
		CPoint2D endPoint = GetDC()->GetReal(m_lastPoint);
		CPoint2D downPoint = GetDC()->GetReal(m_downPoint);
		CPoint2D deltaPt(endPoint.x0 - downPoint.x0, endPoint.y0 - downPoint.y0);
		pTrackObj->DrawMoveTrackFrame(&xyDC, deltaPt);
	}

	CTrackObj* CItemWcsSingleWell::GetMoveInTrack(CTrackGroup* pGroup, CTrackObj* pTrackMoving)
	{
		CTrackObj* pRetTrack = NULL;
		if (pTrackMoving->m_HeadRect.PtInRect(pTrackMoving->m_active_head.CenterPoint()))
		{
			return pRetTrack;
		}
		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();
			//<2F><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ң<EFBFBD><D2A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>еĵ<D0B5><C4B5><EFBFBD><EFBFBD>бȽϣ<C8BD><CFA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>±<EFBFBD><C2B1>ж<EFBFBD><D0B6><EFBFBD><EFBFBD>ŵ<EFBFBD><C5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱֻҪ<D6BB><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD><D0A1>Ŀ<EFBFBD>ĵ<EFBFBD><C4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĵ㼴<C4B5><E3BCB4>
			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 || bRight)
			{
				if (pTrack->GetTrackType() == Track_Group)
				{//<2F>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ŵ<EFBFBD><C5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ұߵķ<DFB5>Χ<EFBFBD><CEA7>
					CTrackGroup* pTrackGroup = (CTrackGroup*)pTrack;
					if (bIn) //pTrackGroup->m_HeadRect.PtInRect(pTrackMoving->m_active_head.CenterPoint()))
					{//<2F>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ŵ<EFBFBD><C5B5><EFBFBD>pTrack<63>ڲ<EFBFBD>
						if (pTrackGroup->GetGroupType() == Group_Vertical)
						{
							return pTrackGroup;
						}
						else
						{//ˮƽ<CBAE><C6BD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݹ<EFBFBD>
							return (GetMoveInTrack(pTrackGroup, pTrackMoving));
						}
					}
					else
					{//<2F>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ŵ㲻<C5B5><E3B2BB>pTrack<63>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ŵ<EFBFBD><C5B5><EFBFBD>pTrack<63><6B><EFBFBD>ϱ߻<CFB1><DFBB>±ߣ<C2B1><DFA3><EFBFBD>ֱ<EFBFBD>Ӽ<EFBFBD><D3BC>뵽pGroup
						return pTrack;
					}
				}
				else
				{//<2F>ƶ<EFBFBD><C6B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ŵ㲻<C5B5><E3B2BB><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD>,<2C><><EFBFBD>ұߵķ<DFB5>Χ
					return pTrack;
				}
			}
		}
		//<2F><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD>Ҳ<EFBFBD>
		return pTrack;
	}
}