#include "StdAfx.h"
#include "ItemFault.h"
#include "ItemBend.h"

#include "WellPoleLib/WellMarkNamesList.h"
#include "WellPoleLib/WellCommonDef.h"
#include "WellPoleLib/WellBaseObj.h"
#include "WellPoleLib/WellClassObjGroup.h"

#include "MultiWellSectionLib\BendObj.h"
#include "MultiWellSectionLib\WellSection.h"

#include "MultiWellSectionDoc.h"
#include "MultiWellSectionlView.h"

//#include <math.h>
namespace NItem
{	
	CItemFault::CItemFault(CSigmaDoc* pDoc)
		: CItemWellBase(pDoc)
	{
		SetType(ITEM_FAULT);
		m_bAdjustTrow = FALSE;
		m_pFaultObj = NULL;
		m_pItemWellSection = NULL;
		m_SelectHandle = 0;
	}

	CItemFault::~CItemFault(void)
	{

	}

	void CItemFault::OnLButtonDown(CDC *pDC, UINT nFlags, CPoint point, int vk)
	{
		m_downPoint = m_firstPoint = m_lastPoint = point;

		if(m_pFaultObj != NULL)
		{
			CPoint2D ptReal = GetDC()->GetReal(point);

			CWellBaseObj* pObj = m_pFaultObj;
			int nHandleSize = HANDLESIZE; // ::GetPreferences().WorkaroundHandle.m_nHandleSize;
			double dHandleSize = GetDC()->GetRealSize(CSize(nHandleSize/2, nHandleSize/2)).cx;
			nDragHandle = pObj->HitTest(ptReal,dHandleSize,TRUE);
			if (nDragHandle!=0)
			{
				selectMode = ESelectMode::size;
				//GetView()->SetCapture();
			}
			else
			{
				selectMode = ESelectMode::move;
				//GetView()->SetCapture();
			}

			if (m_SelectHandle != nDragHandle)
			{
				OnDraw(GetDC() ,pDC);
				m_SelectHandle = nDragHandle;
				OnDraw(GetDC() ,pDC);
			}
		}
		
		//刷新属性页
	}
	POSITION gpos = NULL;
	void CItemFault::OnLButtonUp(CDC *pDC, UINT nFlags, CPoint point, int vk)
	{
		m_firstPoint = m_lastPoint = point;

		CPoint2D lastPoint = GetDC()->GetReal(point);

		if((m_downPoint.x-m_lastPoint.x)!=0 || (m_downPoint.y-m_lastPoint.y)!=0)
		{
			if (m_pFaultObj != NULL)
			{
				if (IsCaptureState())
				{
					if(m_pItemWellSection != NULL)
						SetReUnDoAction(FALSE, IDS_STRING_ACTION_MOVE, 2);

					if (selectMode==CItemSelect::size && nDragHandle!=0)
					{
						if (nDragHandle<=m_pFaultObj->m_ptArr.GetCount())
						{
							//内置对象交互句柄
							m_pFaultObj->MoveHandleTo(nDragHandle, lastPoint);
						}
						else
						{
							CPoint2D ptDrag = m_pFaultObj->GetHandle(nDragHandle);
						
							CPoint2D downPoint = GetDC()->GetReal(m_downPoint);
							CPoint2D lastPoint = GetDC()->GetReal(m_lastPoint);
							CPoint2D delta(lastPoint.x0-downPoint.x0,lastPoint.y0-downPoint.y0);
							/////点的活动范围
							double minY = 0.0;
							double maxY = 0.0;
							minY = min(m_pFaultObj->m_ptArr.GetAt(0).y0,m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-1).y0);
							minY = max(m_pFaultObj->m_ptArr.GetAt(0).y0,m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-1).y0);
							double minX = 0.0;
							double maxX = 0.0;
							minX = min(m_pFaultObj->m_ptArr.GetAt(0).x0,m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-1).x0);
							minX = max(m_pFaultObj->m_ptArr.GetAt(0).x0,m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-1).x0);
							/////判断拖动点的是左侧的还是右侧的
							CPoint2D ptTemp;
							BOOL bLeft = FALSE;
							BOOL bRight = FALSE;
							FaultOnBendCrossStruct SelectBendCross;//鼠标选中的
			
							for (int ii=0;ii<m_pFaultObj->m_ptCrossArr.GetCount();ii++)
							{
								SelectBendCross = m_pFaultObj->m_ptCrossArr.GetAt(ii);
								if (SelectBendCross.LeftCrossPt==m_pFaultObj->GetHandle(nDragHandle))
								{
									bLeft = TRUE;
									break;
								}
								else if (SelectBendCross.RightCrossPt==m_pFaultObj->GetHandle(nDragHandle))
								{
									bRight = TRUE;
									break;
								}
							}
							//////整体拖动连层
							if (m_bAdjustTrow)
							{
								double fHeight = delta.y0;
								for (int ii=0;ii<m_pFaultObj->m_ptCrossArr.GetCount();ii++)
								{
									FaultOnBendCrossStruct BendCross = m_pFaultObj->m_ptCrossArr.GetAt(ii);
									CBendObj* pBend = BendCross.pBend;
									int nCount = pBend->m_faultArr.GetCount();
									for(int i=0; i<nCount; i++)
									{
										FaultOnBendStruct faultOn_Bend = BendCross.pBend->m_faultArr.GetAt(i);
										CFaultObj* pFault = faultOn_Bend.pFault;
										if (pFault==m_pFaultObj)
										{
											if (bLeft)
											{
												pBend->ComputeMoveHeight(m_pFaultObj,fHeight,TRUE);
											} 
											else if (bRight)
											{
												pBend->ComputeMoveHeight(m_pFaultObj,fHeight,FALSE);
											}
										}
									}
								}
								CWellSection* pWellSection = (CWellSection*)m_pItemWellSection->GetWellSection();
								double fDelta = pWellSection->ScreenCYToHeight(fHeight);
								for (int ii=0;ii<m_pFaultObj->m_ptCrossArr.GetCount();ii++)
								{
									FaultOnBendCrossStruct BendCross = m_pFaultObj->m_ptCrossArr.GetAt(ii);
									CBendObj* pBend = BendCross.pBend;
									int nCount = pBend->m_faultArr.GetCount();
									for(int i=0; i<nCount; i++)
									{
										FaultOnBendStruct faultOn_Bend = pBend->m_faultArr.GetAt(i);
										CFaultObj* pFault = faultOn_Bend.pFault;
										if (pFault==m_pFaultObj)
										{
											if (bLeft)
											{
												if (delta.y0>0)
												{
													pBend->m_faultArr.GetAt(i).faultThrow.fUThrow += fabs(fDelta);
												} 
												else
												{
													pBend->m_faultArr.GetAt(i).faultThrow.fUThrow += -fabs(fDelta);
												}
											}
											else if (bRight)
											{
												if (delta.y0>0)
												{
													pBend->m_faultArr.GetAt(i).faultThrow.fDThrow += -fabs(fDelta);
												} 
												else
												{
													pBend->m_faultArr.GetAt(i).faultThrow.fDThrow += fabs(fDelta);
												}
											}
											//pBend->CreateBendLines();
											//pBend->CreateBendFills();
										}
									}
								}
							}
							//////拖动单个连层
							else
							{
								if(bLeft || bRight)//ggff 20160525
								{
									CBendObj* pBend = SelectBendCross.pBend;
									pBend->ComputeMoveHeight(m_pFaultObj,delta.y0,bLeft);
									CWellSection* pWellSection = (CWellSection*)m_pItemWellSection->GetWellSection();
									double fDelta = pWellSection->ScreenCYToHeight(delta.y0);
									for(int i=0; i<pBend->m_faultArr.GetCount(); i++)
									{
										FaultOnBendStruct faultOn_Bend = pBend->m_faultArr.GetAt(i);
										CFaultObj* pFault = faultOn_Bend.pFault;
										if (pFault == m_pFaultObj)
										{
											if(bLeft)
											{
												if (delta.y0>0)
												{
													pBend->m_faultArr.GetAt(i).faultThrow.fUThrow += fabs(fDelta);
												} 
												else
												{
													pBend->m_faultArr.GetAt(i).faultThrow.fUThrow += -fabs(fDelta);
												}									
											}
											else
											{
												if (delta.y0>0)
												{
													pBend->m_faultArr.GetAt(i).faultThrow.fDThrow += -fabs(fDelta);
												} 
												else
												{
													pBend->m_faultArr.GetAt(i).faultThrow.fDThrow += fabs(fDelta);
												}
											}

										}
									}

								}

							}

						}
					}
					else if (selectMode==CItemSelect::move)
					{
						CRect8 position = m_pFaultObj->GetPos();
						CPoint2D downPoint = GetDC()->GetReal(m_downPoint);
						CPoint2D lastPoint = GetDC()->GetReal(m_lastPoint);
						CPoint2D delta(lastPoint.x0-downPoint.x0,lastPoint.y0-downPoint.y0);
						m_pFaultObj->m_delta = delta;
						position.OffsetRect(delta.x0, delta.y0);
						m_pFaultObj->MoveTo(position);
					}
					m_pFaultObj->FaultReCut();
					GetDoc()->Invalidate();// (m_pFaultObj->GetParent());
					m_pItemWellSection->GetWellSection()->ReSetPosition();
					//GetView()->SetScrollBarRange();

					CXy* pxy = GetDoc()->GetDraw();
					if (pxy->GetValueList()->GetHeadPosition() != gpos)
					{
						gpos = pxy->GetValueList()->GetHeadPosition();
					}
				}
			}		
		}
		ReleaseCapture();
		m_bDrag = FALSE;
		nDragHandle = 0;
	}

	int CItemFault::OnMouseMove(CDC *pDC, UINT nFlags, CPoint point)
	{
		if(m_pFaultObj == NULL)
			return 0;

		CPoint2D lastPoint = GetDC()->GetReal(point);
		if(IsCaptureState())
		{
			//刷新
			OnDraw(GetDC(), pDC);

			m_bDrag = TRUE;
			m_lastPoint = point;

			//刷新
			OnDraw(GetDC(), pDC);

			m_firstPoint = m_lastPoint;
		}
		else
			m_lastPoint = point;

		return 1;
	}

	BOOL CItemFault::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
	{
		CPoint2D lastPoint = GetDC()->GetReal(m_lastPoint);
		int nHandleSize = HANDLESIZE;// ::GetPreferences().WorkaroundHandle.m_nHandleSize;
		double dHandleSize = GetDC()->GetRealSize(CSize(nHandleSize/2, nHandleSize/2)).cx;
		int nHandle = m_pFaultObj->HitTest(lastPoint,dHandleSize,TRUE);
		if(nHandle!=0)
		{
			SetCursor(GetHandleCursor(nHandle));
			return TRUE;
		}
		else
		{
			CRect8 rt = CRect8(lastPoint.x0, lastPoint.y0, lastPoint.x0, lastPoint.y0);
			if(m_pFaultObj->Intersects(rt, dHandleSize))
			{
				SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEALL));
				return TRUE;	
			}
		}

		SetCursor(AfxGetApp()->LoadStandardCursor(IDC_UPARROW));
		return TRUE;

		//GetDoc()->GetCursor().SetCursor(CursorSelect);
		//return GetDoc()->GetCursor().SetCursor();
	}

	BOOL CItemFault::OnSetCursor(CPoint pt, int& handle)
	{
		CPoint2D lastPoint = GetDC()->GetReal(pt);
		int nHandleSize = HANDLESIZE;// ::GetPreferences().WorkaroundHandle.m_nHandleSize;
		double dHandleSize = GetDC()->GetRealSize(CSize(nHandleSize / 2, nHandleSize / 2)).cx;
		int nHandle = m_pFaultObj->HitTest(lastPoint, dHandleSize, TRUE);
		if (nHandle != 0)
		{
			//SetCursor(GetHandleCursor(nHandle));
			handle = 15;
			return TRUE;
		}
		else
		{
			CRect8 rt = CRect8(lastPoint.x0, lastPoint.y0, lastPoint.x0, lastPoint.y0);
			CSize8 sz = GetDoc()->GetSelectSize();
			double sx = GetDC()->GetRealWidth(sz.cx);
			double sy = fabs(GetDC()->GetRealHeight(sz.cy));
			rt.InflateRect(sx, sy);
			if (m_pFaultObj->Intersects(rt, dHandleSize))
			{
				handle =  5;//SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEALL));
				return TRUE;
			}
		}

		return TRUE;
	}

	int CItemFault::GetSubMenu()
	{
		// 井
		int iRMenu = 48;

		//if(m_pFaultObj == NULL)
		//	return iRMenu;

		return iRMenu;
	}

	void CItemFault::OnDraw(CXyDC* pXyDC)
	{	
		CDC *pDC = GetDC()->GetDC();
		CPen pen(PS_DOT, 0, RGB(0, 0, 0));
		CPen *pOldPen = (CPen *)pDC->SelectObject(&pen);
		int old = pDC->SetROP2(R2_NOTXORPEN);

		if(m_pFaultObj!=NULL)
		{
			if(m_bDrag && m_lastPoint!=m_downPoint)//画拖拽框（整体、控制点）
			{
				if (nDragHandle!=0)//控制点
				{
					//CPoint ptTest;
					CPoint ptNow;
					CPen pen(PS_SOLID, 1, RGB(255,0,0));
					dfPoint ptHandle;
					dfPoint ptTemp;
					CPen *pOldPen = (CPen *)pDC->SelectObject(&pen);
					CPointArr ptArr;
					CPoint cptTemp;
					std::vector<CPoint> cptArr;
					if (nDragHandle<=m_pFaultObj->m_OrgCtrlPts.size())
					{
						if (nDragHandle==1)
						{

							//ptHandle.x0 = m_lastPoint.x;
							//ptHandle.y0 = m_lastPoint.y;
							//ptArr.Add(ptHandle);
							cptArr.push_back(m_lastPoint);

							cptTemp = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[1]);

							cptArr.push_back(cptTemp);
							//ptTemp.x0 = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts.GetAt(1)).x;
							//ptTemp.y0 = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts.GetAt(1)).y;
							//ptArr.Add(ptTemp);
						}
						else if (nDragHandle==m_pFaultObj->m_OrgCtrlPts.size())
						{
							//ptTemp.x0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-2)).x;
							//ptTemp.y0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-2)).y;
							//ptArr.Add(ptTemp);
							cptTemp = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[m_pFaultObj->m_OrgCtrlPts.size()-2]);
							cptArr.push_back(cptTemp);
							//ptHandle.x0 = m_lastPoint.x;
							//ptHandle.y0 = m_lastPoint.y;
							//ptArr.Add(ptHandle);
							cptArr.push_back(m_lastPoint);
						}
						else
						{
							cptTemp = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[nDragHandle - 2]);
							cptArr.push_back(cptTemp);

							cptArr.push_back(m_lastPoint);

							cptTemp = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[nDragHandle]);
							cptArr.push_back(cptTemp);
							//ptTemp.x0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(nDragHandle-2)).x;
							//ptTemp.y0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(nDragHandle-2)).y;
							//ptArr.Add(ptTemp);

							//ptHandle.x0 = m_lastPoint.x;
							//ptHandle.y0 = m_lastPoint.y;
							//ptArr.Add(ptHandle);
							//
							//ptTemp.x0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(nDragHandle)).x;
							//ptTemp.y0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(nDragHandle)).y;
							//ptArr.Add(ptTemp);
						}
						//CPoint *pPoint = new CPoint[ptArr.GetCount()];
						//for (int ii=0;ii<ptArr.GetCount();ii++)
						//{
						//	pPoint[ii].x = ptArr.GetAt(ii).x0;
						//	pPoint[ii].y = ptArr.GetAt(ii).y0;
						//}
						//pDC->Polyline(pPoint,ptArr.GetCount());

						//delete []pPoint;
						//pPoint = NULL;
						//画拖动控制点
						pDC->Polyline(cptArr.data(), cptArr.size());
						ptNow = m_lastPoint;

					}
					else
					{
						CPoint2D ptDrag = m_pFaultObj->GetHandle(nDragHandle);
						CPoint2D ptNew = GetBendCrossControlPt(m_pFaultObj->GetHandle(nDragHandle),ptDrag);
						ptNow = pXyDC->GetScreen(ptNew);
						double Ymax;
						double Ymin;
						Ymax = max(m_pFaultObj->m_ptArr.GetAt(0).y0,m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-1).y0);
						Ymin = min(m_pFaultObj->m_ptArr.GetAt(0).y0,m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-1).y0);
						//ptNew = GetBendCrossControlPt(m_pFaultObj->GetHandle(10),ptDrag);
						//ptTest = pXyDC->GetScreen(ptNew);
					}
					int nHandleSize = HANDLESIZE; // ::GetPreferences().WorkaroundHandle.m_nHandleSize;
					CRect rect(ptNow.x-nHandleSize/2,ptNow.y-nHandleSize/2,ptNow.x+nHandleSize/2,ptNow.y+nHandleSize/2);
					pDC->Rectangle(rect);

					//CRect rect1(ptTest.x-nHandleSize/2,ptTest.y-nHandleSize/2,ptTest.x+nHandleSize/2,ptTest.y+nHandleSize/2);
					//pDC->Rectangle(rect1);

					pDC->SelectObject(pOldPen);
					pen.DeleteObject();

				}
				else if(selectMode==CItemSelect::move)//整体
				{
					CPen pen(PS_SOLID, 1, RGB(255,0,0));
					dfPoint ptHandle;
					dfPoint ptTemp;
					CPen *pOldPen = (CPen *)pDC->SelectObject(&pen);
					CPoint *pPoint = new CPoint[m_pFaultObj->m_ptArr.GetSize()];
					CPoint delta = CPoint(m_lastPoint.x-m_downPoint.x,m_lastPoint.y-m_downPoint.y);
					for (int ii=0;ii<m_pFaultObj->m_ptArr.GetSize();ii++)
					{
						pPoint[ii].x = pXyDC->GetScreen(m_pFaultObj->m_ptArr[ii]).x+delta.x;
						pPoint[ii].y = pXyDC->GetScreen(m_pFaultObj->m_ptArr[ii]).y+delta.y;
					}
					pDC->Polyline(pPoint,m_pFaultObj->m_ptArr.GetSize());
					delete[]pPoint;
					pPoint = NULL;

					//画控制点
					for(int i=0; i<m_pFaultObj->m_OrgCtrlPts.size(); i++)
					{
						CPoint pt;
						pt.x = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[i]).x + delta.x;
						pt.y = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[i]).y + delta.y;

						int nHandleSize = HANDLESIZE;// ::GetPreferences().WorkaroundHandle.m_nHandleSize;
						CRect rect(pt.x-nHandleSize/2, pt.y-nHandleSize/2, pt.x+nHandleSize/2, pt.y+nHandleSize/2);
						pDC->Rectangle(rect);
					}

					pDC->SelectObject(pOldPen);
					pen.DeleteObject();
				}
			}

			//画选中状态
			if(!m_bDrag || m_firstPoint==m_downPoint)
			{
				CRect rect = pXyDC->GetScreen(m_pFaultObj->GetPos());
				//画控制点
				CPoint2D point;
				CPoint pt;

				CPen pen;
				pen.CreatePen(PS_SOLID, 1, RGB(200,0,0));
				CPen *pOldPen = (CPen *)pDC->SelectObject(&pen);

				//画断层线上的点
				int nHandleSize = HANDLESIZE;// ::GetPreferences().WorkaroundHandle.m_nHandleSize;
				int tHSize = nHandleSize / 2;
				int nFault = m_pFaultObj->GetHandleCount() - m_pFaultObj->GetCrossCount();
				for(int i=1; i<=nFault; i++)
				{
					point = m_pFaultObj->GetHandle(i);
					pt = pXyDC->GetScreen(point);	

					if (m_SelectHandle != i || m_SelectHandle <1)
					{
						CRect rect(pt.x - tHSize, pt.y - tHSize, pt.x + tHSize, pt.y + tHSize);
						pDC->Rectangle(rect);
					}
					else
					{
						int thSize1 = tHSize + 1;
						pDC->PatBlt(pt.x - tHSize, pt.y - tHSize, tHSize * 2, tHSize * 2, PATINVERT);
						rect = CRect(pt.x - thSize1, pt.y - thSize1, pt.x + thSize1, pt.y + thSize1);
						pDC->Rectangle(rect);
					}
				}

				//画与层位的断点
				CBrush brush;
				brush.CreateSolidBrush(RGB(0,0,0));
				CBrush* pOldBrush = pDC->SelectObject(&brush);
				CPoint pts[4];
				for (int i=0;i<m_pFaultObj->m_ptCrossArr.GetCount();i++)
				{
					FaultOnBendCrossStruct FaultBendCross = m_pFaultObj->m_ptCrossArr.GetAt(i);
					
					//左断点
					point = FaultBendCross.LeftCrossPt;
					pt = pXyDC->GetScreen(point);	
					int nHandleSize = HANDLESIZE;// ::GetPreferences().WorkaroundHandle.m_nHandleSize;
					CRect rect(pt.x-nHandleSize/2,pt.y-nHandleSize/2,pt.x+nHandleSize/2,pt.y+nHandleSize/2);
					pts[0].x = rect.CenterPoint().x;
					pts[0].y = rect.CenterPoint().y - rect.Height()/2;
					pts[1].x = rect.CenterPoint().x + rect.Width()/2;
					pts[1].y = rect.CenterPoint().y;
					pts[2].x = rect.CenterPoint().x;
					pts[2].y = rect.CenterPoint().y + rect.Height()/2;
					pts[3].x = rect.CenterPoint().x - rect.Width()/2;
					pts[3].y = rect.CenterPoint().y;

					if(FaultBendCross.pBend->IsSlotTypeResult())
						pDC->Polygon(pts, 4);
					else
						pDC->Ellipse(rect);

					//右断点
					point = FaultBendCross.RightCrossPt;
					pt = pXyDC->GetScreen(point);	
					rect = CRect(pt.x-nHandleSize/2,pt.y-nHandleSize/2,pt.x+nHandleSize/2,pt.y+nHandleSize/2);
					pts[0].x = rect.CenterPoint().x;
					pts[0].y = rect.CenterPoint().y - rect.Height()/2;
					pts[1].x = rect.CenterPoint().x + rect.Width()/2;
					pts[1].y = rect.CenterPoint().y;
					pts[2].x = rect.CenterPoint().x;
					pts[2].y = rect.CenterPoint().y + rect.Height()/2;
					pts[3].x = rect.CenterPoint().x - rect.Width()/2;
					pts[3].y = rect.CenterPoint().y;

					if(FaultBendCross.pBend->IsSlotTypeResult())
						pDC->Polygon(pts, 4);
					else
						pDC->Ellipse(rect);
				}
				pDC->SelectObject(pOldBrush);
			}
		}
		pDC->SelectObject(pOldPen);
		pen.DeleteObject();
		pDC->SetROP2(old);
	}

	void CItemFault::OnDraw(CXyDC* pXyDC, CDC* pDC)
	{
		CPen pen(PS_DOT, 0, RGB(0, 0, 0));
		CPen *pOldPen = (CPen *)pDC->SelectObject(&pen);
		int old = pDC->SetROP2(R2_NOTXORPEN);

		if (m_pFaultObj != NULL)
		{
			if (m_bDrag && m_lastPoint != m_downPoint)//画拖拽框（整体、控制点）
			{
				if (nDragHandle != 0)//控制点
				{
					//CPoint ptTest;
					CPoint ptNow;
					CPen pen(PS_SOLID, 1, RGB(255, 0, 0));
					dfPoint ptHandle;
					dfPoint ptTemp;
					CPen *pOldPen = (CPen *)pDC->SelectObject(&pen);
					CPointArr ptArr;
					CPoint cptTemp;
					std::vector<CPoint> cptArr;
					if (nDragHandle <= m_pFaultObj->m_OrgCtrlPts.size())
					{
						if (nDragHandle == 1)
						{

							//ptHandle.x0 = m_lastPoint.x;
							//ptHandle.y0 = m_lastPoint.y;
							//ptArr.Add(ptHandle);
							cptArr.push_back(m_lastPoint);

							cptTemp = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[1]);

							cptArr.push_back(cptTemp);
							//ptTemp.x0 = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts.GetAt(1)).x;
							//ptTemp.y0 = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts.GetAt(1)).y;
							//ptArr.Add(ptTemp);
						}
						else if (nDragHandle == m_pFaultObj->m_OrgCtrlPts.size())
						{
							//ptTemp.x0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-2)).x;
							//ptTemp.y0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-2)).y;
							//ptArr.Add(ptTemp);
							cptTemp = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[m_pFaultObj->m_OrgCtrlPts.size() - 2]);
							cptArr.push_back(cptTemp);
							//ptHandle.x0 = m_lastPoint.x;
							//ptHandle.y0 = m_lastPoint.y;
							//ptArr.Add(ptHandle);
							cptArr.push_back(m_lastPoint);
						}
						else
						{
							cptTemp = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[nDragHandle - 2]);
							cptArr.push_back(cptTemp);

							cptArr.push_back(m_lastPoint);

							cptTemp = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[nDragHandle]);
							cptArr.push_back(cptTemp);
							//ptTemp.x0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(nDragHandle-2)).x;
							//ptTemp.y0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(nDragHandle-2)).y;
							//ptArr.Add(ptTemp);

							//ptHandle.x0 = m_lastPoint.x;
							//ptHandle.y0 = m_lastPoint.y;
							//ptArr.Add(ptHandle);
							//
							//ptTemp.x0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(nDragHandle)).x;
							//ptTemp.y0 = pXyDC->GetScreen(m_pFaultObj->m_ptArr.GetAt(nDragHandle)).y;
							//ptArr.Add(ptTemp);
						}
						//CPoint *pPoint = new CPoint[ptArr.GetCount()];
						//for (int ii=0;ii<ptArr.GetCount();ii++)
						//{
						//	pPoint[ii].x = ptArr.GetAt(ii).x0;
						//	pPoint[ii].y = ptArr.GetAt(ii).y0;
						//}
						//pDC->Polyline(pPoint,ptArr.GetCount());

						//delete []pPoint;
						//pPoint = NULL;
						//画拖动控制点
						pDC->Polyline(cptArr.data(), cptArr.size());
						ptNow = m_lastPoint;

					}
					else
					{
						CPoint2D ptDrag = m_pFaultObj->GetHandle(nDragHandle);
						CPoint2D ptNew = GetBendCrossControlPt(m_pFaultObj->GetHandle(nDragHandle), ptDrag);
						ptNow = pXyDC->GetScreen(ptNew);
						double Ymax;
						double Ymin;
						Ymax = max(m_pFaultObj->m_ptArr.GetAt(0).y0, m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount() - 1).y0);
						Ymin = min(m_pFaultObj->m_ptArr.GetAt(0).y0, m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount() - 1).y0);
						//ptNew = GetBendCrossControlPt(m_pFaultObj->GetHandle(10),ptDrag);
						//ptTest = pXyDC->GetScreen(ptNew);
					}
					int nHandleSize = HANDLESIZE; // ::GetPreferences().WorkaroundHandle.m_nHandleSize;
					CRect rect(ptNow.x - nHandleSize / 2, ptNow.y - nHandleSize / 2, ptNow.x + nHandleSize / 2, ptNow.y + nHandleSize / 2);
					pDC->Rectangle(rect);

					//CRect rect1(ptTest.x-nHandleSize/2,ptTest.y-nHandleSize/2,ptTest.x+nHandleSize/2,ptTest.y+nHandleSize/2);
					//pDC->Rectangle(rect1);

					pDC->SelectObject(pOldPen);
					pen.DeleteObject();

				}
				else if (selectMode == CItemSelect::move)//整体
				{
					CPen pen(PS_SOLID, 1, RGB(255, 0, 0));
					dfPoint ptHandle;
					dfPoint ptTemp;
					CPen *pOldPen = (CPen *)pDC->SelectObject(&pen);
					CPoint *pPoint = new CPoint[m_pFaultObj->m_ptArr.GetSize()];
					CPoint delta = CPoint(m_lastPoint.x - m_downPoint.x, m_lastPoint.y - m_downPoint.y);
					for (int ii = 0; ii < m_pFaultObj->m_ptArr.GetSize(); ii++)
					{
						pPoint[ii].x = pXyDC->GetScreen(m_pFaultObj->m_ptArr[ii]).x + delta.x;
						pPoint[ii].y = pXyDC->GetScreen(m_pFaultObj->m_ptArr[ii]).y + delta.y;
					}
					pDC->Polyline(pPoint, m_pFaultObj->m_ptArr.GetSize());
					delete[]pPoint;
					pPoint = NULL;

					//画控制点
					for (int i = 0; i < m_pFaultObj->m_OrgCtrlPts.size(); i++)
					{
						CPoint pt;
						pt.x = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[i]).x + delta.x;
						pt.y = pXyDC->GetScreen(m_pFaultObj->m_OrgCtrlPts[i]).y + delta.y;

						int nHandleSize = HANDLESIZE;// ::GetPreferences().WorkaroundHandle.m_nHandleSize;
						CRect rect(pt.x - nHandleSize / 2, pt.y - nHandleSize / 2, pt.x + nHandleSize / 2, pt.y + nHandleSize / 2);
						pDC->Rectangle(rect);
					}

					pDC->SelectObject(pOldPen);
					pen.DeleteObject();
				}
			}

			//画选中状态
			if (!m_bDrag || m_firstPoint == m_downPoint)
			{
				CRect rect = pXyDC->GetScreen(m_pFaultObj->GetPos());
				//画控制点
				CPoint2D point;
				CPoint pt;

				CPen pen;
				pen.CreatePen(PS_SOLID, 1, RGB(200, 0, 0));
				CPen *pOldPen = (CPen *)pDC->SelectObject(&pen);

				//画断层线上的点
				int nHandleSize = HANDLESIZE;// ::GetPreferences().WorkaroundHandle.m_nHandleSize;
				int tHSize = nHandleSize / 2;
				int nFault = m_pFaultObj->GetHandleCount() - m_pFaultObj->GetCrossCount();
				for (int i = 1; i <= nFault; i++)
				{
					point = m_pFaultObj->GetHandle(i);
					pt = pXyDC->GetScreen(point);

					if (m_SelectHandle != i || m_SelectHandle < 1)
					{
						CRect rect(pt.x - tHSize, pt.y - tHSize, pt.x + tHSize, pt.y + tHSize);
						pDC->Rectangle(rect);
					}
					else
					{
						int thSize1 = tHSize + 1;
						pDC->PatBlt(pt.x - tHSize, pt.y - tHSize, tHSize * 2, tHSize * 2, PATINVERT);
						rect = CRect(pt.x - thSize1, pt.y - thSize1, pt.x + thSize1, pt.y + thSize1);
						pDC->Rectangle(rect);
					}
				}

				//画与层位的断点
				CBrush brush;
				brush.CreateSolidBrush(RGB(0, 0, 0));
				CBrush* pOldBrush = pDC->SelectObject(&brush);
				CPoint pts[4];
				for (int i = 0; i < m_pFaultObj->m_ptCrossArr.GetCount(); i++)
				{
					FaultOnBendCrossStruct FaultBendCross = m_pFaultObj->m_ptCrossArr.GetAt(i);

					//左断点
					point = FaultBendCross.LeftCrossPt;
					pt = pXyDC->GetScreen(point);
					int nHandleSize = HANDLESIZE;// ::GetPreferences().WorkaroundHandle.m_nHandleSize;
					CRect rect(pt.x - nHandleSize / 2, pt.y - nHandleSize / 2, pt.x + nHandleSize / 2, pt.y + nHandleSize / 2);
					pts[0].x = rect.CenterPoint().x;
					pts[0].y = rect.CenterPoint().y - rect.Height() / 2;
					pts[1].x = rect.CenterPoint().x + rect.Width() / 2;
					pts[1].y = rect.CenterPoint().y;
					pts[2].x = rect.CenterPoint().x;
					pts[2].y = rect.CenterPoint().y + rect.Height() / 2;
					pts[3].x = rect.CenterPoint().x - rect.Width() / 2;
					pts[3].y = rect.CenterPoint().y;

					if (FaultBendCross.pBend->IsSlotTypeResult())
						pDC->Polygon(pts, 4);
					else
						pDC->Ellipse(rect);

					//右断点
					point = FaultBendCross.RightCrossPt;
					pt = pXyDC->GetScreen(point);
					rect = CRect(pt.x - nHandleSize / 2, pt.y - nHandleSize / 2, pt.x + nHandleSize / 2, pt.y + nHandleSize / 2);
					pts[0].x = rect.CenterPoint().x;
					pts[0].y = rect.CenterPoint().y - rect.Height() / 2;
					pts[1].x = rect.CenterPoint().x + rect.Width() / 2;
					pts[1].y = rect.CenterPoint().y;
					pts[2].x = rect.CenterPoint().x;
					pts[2].y = rect.CenterPoint().y + rect.Height() / 2;
					pts[3].x = rect.CenterPoint().x - rect.Width() / 2;
					pts[3].y = rect.CenterPoint().y;

					if (FaultBendCross.pBend->IsSlotTypeResult())
						pDC->Polygon(pts, 4);
					else
						pDC->Ellipse(rect);
				}
				pDC->SelectObject(pOldBrush);
			}
		}
		pDC->SelectObject(pOldPen);
		pen.DeleteObject();
		pDC->SetROP2(old);
	}

	CPoint2D CItemFault::GetBendCrossControlPt(CPoint2D ptIn,CPoint2D ptDrag)
	{
		CWellSection *pWellSection = m_pItemWellSection->GetWellSection();
		CPoint2D ptNew;
		CPoint2D ptCross1,ptCross2;
		//画拖动控制点
		double minY = 0.0;
		double maxY = 0.0;
		minY = min(m_pFaultObj->m_ptArr.GetAt(0).y0,m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-1).y0);
		maxY = max(m_pFaultObj->m_ptArr.GetAt(0).y0,m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-1).y0);
		double minX = 0.0;
		double maxX = 0.0;
		minX = min(m_pFaultObj->m_ptArr.GetAt(0).x0,m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-1).x0);
		maxX = max(m_pFaultObj->m_ptArr.GetAt(0).x0,m_pFaultObj->m_ptArr.GetAt(m_pFaultObj->m_ptArr.GetCount()-1).x0);
		double distance = 0.0;
		CPoint2D pt = GetDC()->GetReal(m_lastPoint);
		if ((ptIn.x0 != ptDrag.x0)||(ptIn.y0 != ptDrag.y0))
		{
			pt.x0 = pt.x0+(ptIn.x0-ptDrag.x0);
		}
		CPoint2D ptTop1,ptTop2,ptTopNew1,ptTopNew2;
		ptTop1.y0 = ptTop2.y0 = ptIn.y0;
		ptTop1.x0 = minX;
		ptTop2.x0 = maxX;
		ptTopNew1.x0 = minX;
		ptTopNew2.x0 = maxX;
		if (pt.y0>maxY)
		{
			ptTopNew1.y0 = maxY;
			ptTopNew2.y0 = maxY;
		}
		else
		{
			ptTopNew1.y0 = pt.y0;
			ptTopNew2.y0 = pt.y0;
		}
		if (pt.y0<minY)
		{
			ptTopNew1.y0 = minY;
			ptTopNew2.y0 = minY;
		}
		else
		{
			ptTopNew1.y0 = pt.y0;
			ptTopNew2.y0 = pt.y0;
		}
		for(int k=0; k<m_pFaultObj->m_ptArr.GetCount()-1; k++)
		{
			if(LineIntersect(ptCross1, m_pFaultObj->m_ptArr.GetAt(k), m_pFaultObj->m_ptArr.GetAt(k+1), ptTop1, ptTop2))
			{
				distance = ptCross1.x0-ptIn.x0;
				break;
			}
		}
		for(int k=0; k<m_pFaultObj->m_ptArr.GetCount()-1; k++)
		{
			if(LineIntersect(ptCross2, m_pFaultObj->m_ptArr.GetAt(k), m_pFaultObj->m_ptArr.GetAt(k+1), ptTopNew1, ptTopNew2))
			{
				ptNew.x0 = ptCross2.x0-distance;
				ptNew.y0 = ptCross2.y0;
				break;
			}
		}
		return ptNew;
	}

	int CItemFault::DeleteSelection(void)
	{
		if(GetDrawObj() == NULL)
			return 0;
	
		//if(NULL != m_pItemWellSection)
		//	m_pItemWellSection->SetReUnDoAction();

		CWellSection* pWellSection = (CWellSection*)m_pFaultObj->GetParent();
		pWellSection->DeleteOneFault(m_pFaultObj);
		//POSITION posFind = pWellSection->m_FaultList.Find(m_pFaultObj);
		//pWellSection->m_FaultList.RemoveAt(posFind);						
		//POSITION posBend = pWellSection->m_BendList.GetHeadPosition();			
		//while(posBend != NULL)
		//{
		//	CDrawObj* pObj = pWellSection->m_BendList.GetNext(posBend);
		//	CBendObj* pBendObj = (CBendObj*)pObj;
		//	int nCount = pBendObj->m_faultArr.GetCount();
		//	for(int i=0; i<nCount; i++)
		//	{
		//		FaultOnBendStruct faultOn_Bend = pBendObj->m_faultArr.GetAt(i);
		//		if (faultOn_Bend.pFault == m_pFaultObj)
		//		{
		//			pBendObj->m_faultArr.RemoveAt(i);
		//			pBendObj->bPlug = FALSE;
		//			pBendObj->FaultCutLines();
		//			pBendObj->CreateBendLines();
		//			pBendObj->CreateBendFills();
		//			break;
		//		}
		//	}					
		//}			
		//delete m_pFaultObj;	
		return 1;
	}

	HCURSOR CItemFault::GetHandleCursor(int nHandle)
	{
		int nFault = m_pFaultObj->GetHandleCount()-m_pFaultObj->GetCrossCount();
		if(nHandle <= nFault)
			return AfxGetApp()->LoadCursor(IDC_SIZEALL);// IDC_DRAG_BREAK);
		else
		{
			int nCross = nHandle - nFault;
			int nFault = m_pFaultObj->GetHandleCount()-m_pFaultObj->GetCrossCount();
			FaultOnBendCrossStruct BendCross = m_pFaultObj->m_ptCrossArr.GetAt((nCross-1)/2);
			if (BendCross.pBend->m_ptBeginBreak.x0<BendCross.pBend->m_ptEndBreak.x0)
			{
				if(nCross%2 == 0)
					return AfxGetApp()->LoadCursor(IDC_SIZENESW);	
				else
					return AfxGetApp()->LoadCursor(IDC_SIZENWSE);	
			}
			else
			{
				if(nCross%2 == 0)
					return AfxGetApp()->LoadCursor(IDC_SIZENESW);
				else
					return AfxGetApp()->LoadCursor(IDC_SIZENWSE);

			}
		}
	}

	void CItemFault::AddFaultPoint()
	{
		if (m_pFaultObj)
		{
			if (m_pFaultObj->AddFaultPoint(m_SelectHandle - 1))
			{
				m_pFaultObj->FaultReCut();
				m_SelectHandle++;
				//if (0 < m_SelectHandle && m_SelectHandle <= m_pFaultObj->m_OrgCtrlPts.size())
				//{
				//	m_SelectHandle++;
				//}
				//GetView()->Invalidate();
				GetDoc()->Invalidate();
			}
		}
	}

	void CItemFault::DeleteFaultPoint()
	{
		if (m_pFaultObj)
		{
			if (m_pFaultObj->DeleteFaultPoint(m_SelectHandle - 1))
			{
				m_pFaultObj->FaultReCut();
				GetDoc()->Invalidate();
			}
		}
	}
}