repos_ecs/源数据/PC环境监控/tryto v1.0.0.3/只运行 IDE/IDE/IDEView.cpp

// VectorView.cpp : implementation of the CIDEView class
//

#include "stdafx.h"
#include "IDEView.h"
#include "PicSizeDlg.h"
#include "gooddc.h"
#include "graphdef.h"
#include "MainFrm.h"
#include "PicListDlg.h"
#include ".\ideview.h"
#include "BaseProDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#pragma	 warning (disable: 4700)

CDrawObjList g_Copied;
/////////////////////////////////////////////////////////////////////////////
// CIDEView

IMPLEMENT_DYNCREATE(CIDEView, CScrollView)

BEGIN_MESSAGE_MAP(CIDEView, CScrollView)
	//{{AFX_MSG_MAP(CIDEView)
	ON_WM_CREATE()
	ON_WM_DESTROY()
	ON_COMMAND(ID_EDIT_UNFREEZE, OnEditUnfreeze)
	ON_COMMAND(ID_EDIT_PASTE, OnEditPaste)
	ON_COMMAND(ID_EDIT_MOVETOFRONT, OnEditMovetofront)
	ON_COMMAND(ID_EDIT_MOVETOBACK, OnEditMovetoback)
	ON_COMMAND(ID_EDIT_HINVERT, OnEditHinvert)
	ON_COMMAND(ID_EDIT_FREEZE, OnEditFreeze)
	ON_COMMAND(ID_EDIT_CUT, OnEditCut)
	ON_COMMAND(ID_EDIT_COPY, OnEditCopy)
	ON_COMMAND(ID_EDIT_CLEAR, OnEditDelete)
	ON_COMMAND(ID_DESK_GRID, OnDeskGrid)
	ON_COMMAND(ID_ALIGN_TOP, OnAlignTop)
	ON_COMMAND(ID_ALIGN_VCENTER, OnAlignVcenter)
	ON_COMMAND(ID_ALIGN_RIGHT, OnAlignRight)
	ON_COMMAND(ID_ALIGN_LEFT, OnAlignLeft)
	ON_COMMAND(ID_ALIGN_HCENTER, OnAlignHcenter)
	ON_COMMAND(ID_ALIGN_BOTTOM, OnAlignBottom)
	ON_COMMAND(ID_EDIT_VINVERT, OnEditVinvert)
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_COMMAND(ID_POINTER, OnPointer)
	ON_WM_KEYDOWN()
	ON_COMMAND(ID_FILE_NEW, OnFileNew)
	ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
	ON_COMMAND(ID_FILE_SAVE, OnFileSave)
	ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs)
	ON_COMMAND(ID_APP_EXIT, OnAppExit)
	ON_UPDATE_COMMAND_UI(ID_DESK_GRID, OnUpdateDeskGrid)
	ON_UPDATE_COMMAND_UI(ID_EDIT_FREEZE, OnUpdateEditFreeze)
	ON_COMMAND(ID_REDO, OnRedo)
	ON_COMMAND(ID_UNDO, OnUndo)
	ON_UPDATE_COMMAND_UI(ID_UNDO, OnUpdateUndo)
	ON_UPDATE_COMMAND_UI(ID_REDO, OnUpdateRedo)
	ON_COMMAND(ID_PICSIZE, OnPicsize)
	ON_UPDATE_COMMAND_UI(ID_ALIGN_BOTTOM, OnUpdateAlignBottom)
	ON_UPDATE_COMMAND_UI(ID_ALIGN_HCENTER, OnUpdateAlignHcenter)
	ON_UPDATE_COMMAND_UI(ID_ALIGN_LEFT, OnUpdateAlignLeft)
	ON_UPDATE_COMMAND_UI(ID_ALIGN_RIGHT, OnUpdateAlignRight)
	ON_UPDATE_COMMAND_UI(ID_ALIGN_TOP, OnUpdateAlignTop)
	ON_UPDATE_COMMAND_UI(ID_ALIGN_VCENTER, OnUpdateAlignVcenter)
	ON_UPDATE_COMMAND_UI(ID_EDIT_HINVERT, OnUpdateEditHinvert)
	ON_UPDATE_COMMAND_UI(ID_EDIT_MOVETOBACK, OnUpdateEditMovetoback)
	ON_UPDATE_COMMAND_UI(ID_EDIT_MOVETOFRONT, OnUpdateEditMovetofront)
	ON_UPDATE_COMMAND_UI(ID_EDIT_VINVERT, OnUpdateEditVinvert)
	ON_UPDATE_COMMAND_UI(ID_EDIT_COPY, OnUpdateEditCopy)
	ON_UPDATE_COMMAND_UI(ID_EDIT_CUT, OnUpdateEditCut)
	ON_UPDATE_COMMAND_UI(ID_EDIT_CLEAR, OnUpdateEditClear)
	ON_UPDATE_COMMAND_UI(ID_EDIT_PASTE, OnUpdateEditPaste)
	ON_COMMAND(ID_DRAW_TLINE, OnDrawTline)
	ON_COMMAND(ID_DRAW_TEXT, OnDrawText)
	ON_COMMAND(ID_DRAW_RECT, OnDrawRect)
	ON_COMMAND(ID_DRAW_DATA, OnDrawData)
	ON_COMMAND(ID_DRAW_BUTTON, OnDraw3drect)
	ON_COMMAND(ID_DRAW_3CIRCLE, OnDraw3circle)
	ON_UPDATE_COMMAND_UI(ID_POINTER, OnUpdatePointer)
	ON_WM_LBUTTONDBLCLK()
	ON_WM_TIMER()
	ON_UPDATE_COMMAND_UI(ID_DRAW_3CIRCLE, OnUpdateDraw3circle)
	ON_UPDATE_COMMAND_UI(ID_DRAW_BUTTON, OnUpdateDraw3drect)
	ON_UPDATE_COMMAND_UI(ID_DRAW_DATA, OnUpdateDrawData)
	ON_UPDATE_COMMAND_UI(ID_DRAW_TEXT, OnUpdateDrawText)
	ON_UPDATE_COMMAND_UI(ID_DRAW_TLINE, OnUpdateDrawTline)
	ON_WM_RBUTTONDOWN()
	ON_COMMAND(ID_EDIT_SAVE, OnEditSave)
	ON_UPDATE_COMMAND_UI(ID_EDIT_SAVE, OnUpdateEditSave)
	ON_WM_ERASEBKGND()
	ON_UPDATE_COMMAND_UI(ID_DRAW_RECT, OnUpdateDrawRect)
	ON_UPDATE_COMMAND_UI(ID_PICSIZE, OnUpdatePicsize)
	ON_COMMAND(ID_DRAW_BITMAP, OnDrawBitmap)
	ON_UPDATE_COMMAND_UI(ID_DRAW_BITMAP, OnUpdateDrawBitmap)
	ON_COMMAND(ID_DRAW_CURVE, OnDrawCurve)
	ON_UPDATE_COMMAND_UI(ID_DRAW_CURVE, OnUpdateDrawCurve)
	ON_COMMAND(ID_DRAW_WATCH, OnDrawWatch)
	ON_UPDATE_COMMAND_UI(ID_DRAW_WATCH, OnUpdateDrawWatch)
	ON_COMMAND(ID_DRAW_BAR, OnDrawBar)
	ON_UPDATE_COMMAND_UI(ID_DRAW_BAR, OnUpdateDrawBar)
	ON_COMMAND(ID_VERSPACE, OnVerspace)
	ON_UPDATE_COMMAND_UI(ID_VERSPACE, OnUpdateVerspace)
	ON_COMMAND(ID_SAMEWIDTH, OnSamewidth)
	ON_UPDATE_COMMAND_UI(ID_SAMEWIDTH, OnUpdateSamewidth)
	ON_COMMAND(ID_SAMEHEIGHT, OnSameheight)
	ON_UPDATE_COMMAND_UI(ID_SAMEHEIGHT, OnUpdateSameheight)
	ON_COMMAND(ID_HORSPACE, OnHorspace)
	ON_UPDATE_COMMAND_UI(ID_HORSPACE, OnUpdateHorspace)
	ON_COMMAND(ID_ALLSAME, OnAllsame)
	ON_UPDATE_COMMAND_UI(ID_ALLSAME, OnUpdateAllsame)
	ON_COMMAND(ID_OPENPIC, OnOpenpic)
	ON_COMMAND(ID_DRAW_ARC, OnDrawArc)
	ON_COMMAND(ID_DRAW_BREAKER, OnDrawBreaker)
	ON_COMMAND(ID_DRAW_FAN, OnDrawFan)
	ON_COMMAND(ID_DRAW_GRID, OnDrawGrid)
	ON_COMMAND(ID_DRAW_HISCURVE, OnDrawHiscurve)
	ON_COMMAND(ID_DRAW_LINE, OnDrawLine)
	ON_COMMAND(ID_DRAW_PIE, OnDrawPie)
	ON_COMMAND(ID_DRAW_PIPE, OnDrawPipe)
	ON_COMMAND(ID_DRAW_POLYGON, OnDrawPolygon)
	ON_COMMAND(ID_DRAW_REPORT, OnDrawReport)
	ON_COMMAND(ID_DRAW_SINGLEBAR, OnDrawSinglebar)
	ON_COMMAND(ID_DRAW_TRANSFER, OnDrawTransfer)
	ON_COMMAND(ID_DRAW_YPIPE, OnDrawYpipe)
	ON_COMMAND(ID_DRAW_ZHELINE, OnDrawZheline)
	ON_COMMAND(ID_DRAW_ZHEPIPE, OnDrawZhepipe)
	ON_COMMAND(ID_DRAW_ARROW, OnDrawArrow)
	ON_COMMAND(ID_DRAW_ELLIPSE, OnDrawEllipse)
	ON_COMMAND(ID_DRAW_SWITCH, OnDrawSwitch)
	ON_COMMAND(ID_DRAW_OCX, OnDrawOCX)
	ON_COMMAND(ID_DRAW_FLASH, OnDrawFlash)
	ON_COMMAND(ID_DRAW_BTNRADIO, OnDrawBtnRadio)
	ON_COMMAND(ID_DRAW_BTNCHECK, OnDrawBtnCheck)

	ON_COMMAND(ID_COMBINE, OnCombine)
	ON_COMMAND(ID_DISCOMBINE, OnDiscombine)
	ON_COMMAND(ID_DRAW_ROUNDRECT, OnDrawRoundrect)
	ON_COMMAND(ID_FILE_PRINT, OnFilePrint)
	ON_UPDATE_COMMAND_UI(ID_DRAW_SWITCH, OnUpdateDrawSwitch)
	ON_UPDATE_COMMAND_UI(ID_DRAW_ARC, OnUpdateDrawArc)
	ON_UPDATE_COMMAND_UI(ID_DRAW_ARROW, OnUpdateDrawArrow)
	ON_UPDATE_COMMAND_UI(ID_DRAW_BREAKER, OnUpdateDrawBreaker)
	ON_UPDATE_COMMAND_UI(ID_DRAW_ELLIPSE, OnUpdateDrawEllipse)
	ON_UPDATE_COMMAND_UI(ID_DRAW_FAN, OnUpdateDrawFan)
	ON_UPDATE_COMMAND_UI(ID_DRAW_GRID, OnUpdateDrawGrid)
	ON_UPDATE_COMMAND_UI(ID_DRAW_HISCURVE, OnUpdateDrawHiscurve)
	ON_UPDATE_COMMAND_UI(ID_DRAW_PIE, OnUpdateDrawPie)
	ON_UPDATE_COMMAND_UI(ID_DRAW_PIPE, OnUpdateDrawPipe)
	ON_UPDATE_COMMAND_UI(ID_DRAW_POLYGON, OnUpdateDrawPolygon)
	ON_UPDATE_COMMAND_UI(ID_DRAW_REPORT, OnUpdateDrawReport)
	ON_UPDATE_COMMAND_UI(ID_DRAW_SINGLEBAR, OnUpdateDrawSinglebar)
	ON_UPDATE_COMMAND_UI(ID_DRAW_TRANSFER, OnUpdateDrawTransfer)
	ON_UPDATE_COMMAND_UI(ID_DRAW_YPIPE, OnUpdateDrawYpipe)
	ON_UPDATE_COMMAND_UI(ID_DRAW_ZHELINE, OnUpdateDrawZheline)
	ON_UPDATE_COMMAND_UI(ID_DRAW_ZHEPIPE, OnUpdateDrawZhepipe)
	ON_UPDATE_COMMAND_UI(ID_DRAW_LINE, OnUpdateDrawLine)
	ON_UPDATE_COMMAND_UI(ID_DISCOMBINE, OnUpdateDiscombine)
	ON_UPDATE_COMMAND_UI(ID_COMBINE, OnUpdateCombine)
	ON_UPDATE_COMMAND_UI(ID_DRAW_ROUNDRECT, OnUpdateDrawRoundrect)
	ON_UPDATE_COMMAND_UI(ID_DRAW_OCX, OnUpdateDrawOCX)
	ON_UPDATE_COMMAND_UI(ID_DRAW_FLASH, OnUpdateDrawFlash)
	ON_UPDATE_COMMAND_UI(ID_DRAW_BTNRADIO, OnUpdateDrawBtnRadio)
	ON_UPDATE_COMMAND_UI(ID_DRAW_BTNCHECK, OnUpdateDrawBtnCheck)
	ON_WM_MOUSEWHEEL()
	//}}AFX_MSG_MAP
	// Standard printing commands
	ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CScrollView::OnFilePrintPreview)
	ON_COMMAND(ID_PROPERTY, OnProperty)
	ON_UPDATE_COMMAND_UI(ID_PROPERTY, OnUpdateProperty)
	ON_WM_CLOSE()
	ON_WM_KILLFOCUS()
	ON_WM_SETFOCUS()
	ON_WM_HSCROLL()
	END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CIDEView construction/destruction

CIDEView::CIDEView()
{
	// TODO: add construction code here
	m_mouseState = FALSE;
	m_bDrag = FALSE;
	nDragHandle = 0;
	nBDragHandle = 0;
	m_bMoveElements = FALSE;
	m_bFreezed = FALSE;
	m_bRectSelect = FALSE;
	m_mouseRect = CRect(0,0,0,0);
	m_pCurActionObj = NULL;
	m_bPolygon = FALSE;

	//创建临时文件
	char tmpPathc[_MAX_PATH+1];
    GetTempPath(_MAX_PATH,tmpPathc);
	CString tmpPath = tmpPathc;
	::CreateDirectory(tmpPath+"\\VDTemp",NULL);
	CGraph* pGraph = new CGraph(CSize(0,0));
	pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\First.ed");
	pGraph->Store();
	pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\Second.ed");
	pGraph->Store();
	pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\Third.ed");
	pGraph->Store();
	pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\Forth.ed");
	pGraph->Store();
	pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\Fifth.ed");
	pGraph->Store();
	pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\Six.ed");
	pGraph->Store();
	delete pGraph;

    m_nRudoPosition = 0;
	m_nCanUndoTimes = 0;
	m_nCanRedoTimes = 0;

   	m_tblTime = CTime::GetCurrentTime();

	m_bOcxCreate = false;
	m_bIsHaveOCX = false;//是否有OCX
	m_bModified = FALSE;
}

CIDEView::~CIDEView()
{
	int test=0;
}

BOOL CIDEView::PreCreateWindow(CREATESTRUCT& cs)
{
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	return CScrollView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CIDEView drawing
void CIDEView::OnDraw(CDC* pDC)
{
	CIDEDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	// TODO: add draw code for native data here
	//if( !m_bIsHaveOCX )
	{
		CRect rect=NULL;
		CGoodDC dc;
		dc.Create(pDC);

		CRect rectClip;
		dc.GetClipBox(&rectClip);
		dc.FillSolidRect(rectClip,RGB(128,128,128));
		LAYOUTSTRUCT layout;
		CRect m_rect = layout.rect;
		CString sOCXPath;
		int nOcxIndex=0;
		rect = m_pGraph->Draw(&dc,sOCXPath,nOcxIndex);
		if(m_bHandle)
		{
			POSITION pos = m_selection.GetHeadPosition();
			while(pos != NULL)
			{
				CDrawObj* pObj = m_selection.GetNext(pos);
				pObj->DrawTracker(&dc);
			}
		}

		// 画响应动作的图元的外框；
		//if (m_pCurActionObj  !=  NULL )
		//{
		//	m_pCurActionObj->DrawFrame(&dc);
		//}


		CPen dotpen;
		dotpen.CreatePen(PS_DOT, 1, RGB(195,195,195));
		CPen* oldobj = dc.SelectObject(&dotpen);

		dc.MoveTo(m_mouseRect.left,m_mouseRect.top);
		dc.LineTo(m_mouseRect.right,m_mouseRect.top);
		dc.LineTo(m_mouseRect.right,m_mouseRect.bottom);
		dc.LineTo(m_mouseRect.left,m_mouseRect.bottom);
		dc.LineTo(m_mouseRect.left,m_mouseRect.top);

		dc.SelectObject(oldobj);

		if( rect.Width()>0 && rect.Height()>0 && g_bRun && nOcxIndex>=0 && nOcxIndex<=9 )
		{
			if( !m_bOcxCreate && sOCXPath!="" )
			{
				m_bOcxCreate = true;
				ShowOCX( rect,sOCXPath,nOcxIndex );
			}
			dc.Destroy( );
		}
		else
			dc.Destroy();
	}
}

/////////////////////////////////////////////////////////////////////////////
// CIDEView printing

BOOL CIDEView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	pInfo->SetMinPage(1);
	pInfo->SetMaxPage(1);

	return DoPreparePrinting(pInfo);
}

void CIDEView::OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo)
{
	// TODO: add extra initialization before printing
	CString sTemp;
	int nTemp=0;
	if(m_pGraph->m_Type == 0)
	{
		int nOffsetX = pDC->GetDeviceCaps(PHYSICALOFFSETX);
		int nOffsetY = pDC->GetDeviceCaps(PHYSICALOFFSETY);
		int nLogPixelX = pDC->GetDeviceCaps(LOGPIXELSX);
		int nLogPixelY = pDC->GetDeviceCaps(LOGPIXELSY);
		pDC->SetMapMode(MM_ISOTROPIC);
		pDC->SetWindowExt(100,100);
		pDC->SetViewportExt(nLogPixelX,nLogPixelY);
		pDC->SetViewportOrg(-nOffsetX,-nOffsetY);
		m_pGraph->Draw(pDC,sTemp,nTemp);
	}
	else
	{
		CSize size = m_pGraph->m_sizePic;
		int nHScale = pInfo->m_rectDraw.Width() / size.cx;
		int nVScale = pInfo->m_rectDraw.Height() / size.cy;
		int nScale = min(nHScale,nVScale);
		pDC->SetMapMode(MM_ISOTROPIC);
		pDC->SetWindowExt(1000,1000);
		pDC->SetViewportExt(1000*nScale,1000*nScale);
		int nHOffset = pInfo->m_rectDraw.Width() - nScale*size.cx;
		int nVOffset = pInfo->m_rectDraw.Height() - nScale*size.cy;
		pDC->SetViewportOrg(nHOffset/2,nVOffset/2);
		m_pGraph->Print(pDC);
	}
}

void CIDEView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add cleanup after printing
}

/////////////////////////////////////////////////////////////////////////////
// CIDEView diagnostics

#ifdef _DEBUG
void CIDEView::AssertValid() const
{
	CScrollView::AssertValid();
}

void CIDEView::Dump(CDumpContext& dc) const
{
	CScrollView::Dump(dc);
}

CIDEDoc* CIDEView::GetDocument() // non-debug version is inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CIDEDoc)));
	return (CIDEDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CIDEView message handlers

BOOL CIDEView::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, CCreateContext* pContext) 
{
	// TODO: Add your specialized code here and/or call the base class
	
	return CWnd::Create(lpszClassName, lpszWindowName, dwStyle, rect, pParentWnd, nID, pContext);
}

int CIDEView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CScrollView::OnCreate(lpCreateStruct) ==  -1)
	{
		return -1;
	}

	m_bMove = TRUE;
	m_bHandle = TRUE;
	m_bModified = FALSE;
	m_pointMouse = CPoint(0,0);
	CString strPicFile = AfxGetApp()->m_lpCmdLine;
	if(!strPicFile.IsEmpty()) m_bMove = FALSE;
	m_pGraph = new CGraph(CSize(0,0));
	m_pGraph->SetPicFile(strPicFile);
	m_pGraph->SetView(this);
	m_pGraph->Load();
	RefreshScrollSizes();

	//CWnd   *pWnd   =   GetParent();       ////下面这段子框架全屏幕显示 
	//RECT   rect; 
	//WINDOWPLACEMENT   wp,oldwp; 
	//POINT pmin,pmax; 
	//GetWindowPlacement(&oldwp); 
	//if(pWnd   !=   NULL) 
	//	pWnd-> GetClientRect(&rect);     
	//
	//rect.bottom = 900;

	//pmax.x   =   rect.right   ; 
	//pmax.y   =   rect.bottom   ; 
	//pmin   =   oldwp.ptMinPosition   ; 
	//wp.length   =   sizeof(WINDOWPLACEMENT); 
	//wp.flags     =   WPF_RESTORETOMAXIMIZED; 
	//wp.showCmd   =   SW_SHOWMAXIMIZED; 
	//wp.rcNormalPosition   =   rect; 
	//SetWindowPlacement(&wp);           ////上面这段子框架全屏幕显示 


#if VIEW_USE_THREAD

	InitializeCriticalSection( &m_csFreshGraph );
	m_hFreshGraphThread = NULL;

	m_hIDEViewRunObject = ::CreateEvent(
		NULL,           /* Security */
		TRUE,           /* Manual event */
		0,              /* Clear on creation */
		"CIDEView::m_hIDEViewRunObject");

	m_hFreshGraphObject = ::CreateEvent(
		NULL,           /* Security */
		TRUE,           /* Manual event */
		0,              /* Clear on creation */
		0);

	if( m_hFreshGraphThread == NULL )
	{
		MTVERIFY( m_hFreshGraphThread = ::CreateThread(NULL, 0, FreshGraphThread, (void*)this, 0, 0) );
	}
#else
	SetTimer(3, 1000, NULL);
#endif

	return 0;
}

void CIDEView::OnDestroy() 
{
	CScrollView::OnDestroy();
	
#if VIEW_USE_THREAD
	MTVERIFY( SetEvent(  m_hFreshGraphObject ) );
	MTVERIFY( SetEvent( m_hIDEViewRunObject ) );
	MTVERIFY( WaitForSingleObject( m_hFreshGraphThread, INFINITE ) != WAIT_FAILED );
	MTVERIFY( CloseHandle( m_hFreshGraphThread ) );
	m_hFreshGraphThread = NULL;
	MTVERIFY( CloseHandle( m_hIDEViewRunObject ) );
	MTVERIFY( CloseHandle( m_hFreshGraphObject ) );
	m_hFreshGraphObject = NULL;
	DeleteCriticalSection( &m_csFreshGraph );
#endif

	// TODO: Add your message handler code here
	POSITION pos = m_copied.GetHeadPosition();
	while(pos != NULL)
	{	
		CDrawObj *pObj = m_copied.GetNext(pos);
		delete pObj;
	}
	m_copied.RemoveAll();

	pos = g_Copied.GetHeadPosition();
	while(pos != NULL)
	{	
		CDrawObj *pObj = g_Copied.GetNext(pos);
		delete pObj;
	}
	g_Copied.RemoveAll();

	pos = m_deleted.GetHeadPosition();
	while(pos != NULL)
	{	
		CDrawObj *pObj = m_deleted.GetNext(pos);
		delete pObj;
	}
	m_deleted.RemoveAll();
	
	delete m_pGraph;
	m_pGraph = NULL;

	// TODO: Add your message handler code here

}

void CIDEView::OnEditUnfreeze() 
{
	m_bFreezed = FALSE;
}

void CIDEView::OnEditPaste() 
{
	// TODO: Add your command handler code here
#if 1
	m_selection.RemoveAll();
	POSITION pos = g_Copied.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj *pObj = g_Copied.GetNext(pos);
		CDrawObj *pNewObj = pObj->Clone();
		pObj->m_rect.OffsetRect(20,20);
		pNewObj->m_rect.OffsetRect(20,20);
		if (pNewObj->IsKindOf( RUNTIME_CLASS(CDrawPoly) ))
		{
			int nPointCount = ((CDrawPoly*)pNewObj)->m_nPoints;
			for (int i = 0; i<nPointCount; i++)
			{
				((CDrawPoly*)pNewObj)->m_points[i] +=  CSize(20,20);
				((CDrawPoly*)pObj)->m_points[i] +=  CSize(20,20);
			}
		}
		pNewObj->m_pView = this;
		m_pGraph->m_DrawObjList.AddTail(pNewObj);
		m_selection.AddTail(pNewObj);
	}
	Invalidate(FALSE);
	m_bModified = TRUE;
#else
	m_selection.RemoveAll();
	POSITION pos = m_copied.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj *pObj = m_copied.GetNext(pos);
		CDrawObj *pNewObj = pObj->Clone();
		pObj->m_rect.OffsetRect(20,20);
		pNewObj->m_rect.OffsetRect(20,20);
		if (pNewObj->IsKindOf( RUNTIME_CLASS(CDrawPoly) ))
		{
			int nPointCount = ((CDrawPoly*)pNewObj)->m_nPoints;
			for (int i = 0; i<nPointCount; i++)
			{
				((CDrawPoly*)pNewObj)->m_points[i] +=  CSize(20,20);
				((CDrawPoly*)pObj)->m_points[i] +=  CSize(20,20);
			}
		}
		m_pGraph->m_DrawObjList.AddTail(pNewObj);
		m_selection.AddTail(pNewObj);
	}
	Invalidate(FALSE);
	m_bModified = TRUE;
#endif
}

void CIDEView::OnEditMovetofront() 
{
	// TODO: Add your command handler code here
	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		POSITION pos0 = m_pGraph->m_DrawObjList.Find(pObj);
		m_pGraph->m_DrawObjList.RemoveAt(pos0);
		m_pGraph->m_DrawObjList.AddTail(pObj);
		pObj->Invalidate();
	}
	Invalidate(FALSE);
	m_bModified = TRUE;	
}

void CIDEView::OnEditMovetoback() 
{
	// TODO: Add your command handler code here
	POSITION pos = m_selection.GetTailPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetPrev(pos);
		POSITION pos0 = m_pGraph->m_DrawObjList.Find(pObj);
		m_pGraph->m_DrawObjList.RemoveAt(pos0);
		m_pGraph->m_DrawObjList.AddHead(pObj);
		pObj->Invalidate();
	}
	Invalidate(FALSE);
	m_bModified = TRUE;
}

void CIDEView::OnEditHinvert() 
{
	// TODO: Add your command handler code here
	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj *pObj = m_selection.GetNext(pos);
		int temp = pObj->m_rect.left;
		pObj->m_rect.left = pObj->m_rect.right;
		pObj->m_rect.right = temp;
		pObj->Invalidate();
		m_bModified = TRUE;
	}
	Invalidate(FALSE);

	m_bModified = TRUE;
}

void CIDEView::OnEditFreeze() 
{
	// TODO: Add your command handler code here
	m_bFreezed = !m_bFreezed;
}

void CIDEView::OnEditCut() 
{
	// TODO: Add your command handler code here
	OnEditCopy();
	OnEditDelete();
	Invalidate(FALSE);
}

void CIDEView::OnEditCopy() 
{
	// TODO: Add your command handler code here
#if 1
	POSITION pos = g_Copied.GetHeadPosition();
	while(pos != NULL)
	{	
		CDrawObj *pObj = g_Copied.GetNext(pos);
		delete pObj;
	}
	g_Copied.RemoveAll();

	pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		CDrawObj *pNewObj = pObj->Clone();
		g_Copied.AddTail(pNewObj);
	}
#else
	POSITION pos = m_copied.GetHeadPosition();
	while(pos != NULL)
	{	
		CDrawObj *pObj = m_copied.GetNext(pos);
		delete pObj;
	}
	m_copied.RemoveAll();

	pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		CDrawObj *pNewObj = pObj->Clone();
		m_copied.AddTail(pNewObj);
	}
#endif
}

void CIDEView::OnEditDelete() 
{
	POSITION pos = m_deleted.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_deleted.GetNext(pos);
		delete pObj;
	}
	m_deleted.RemoveAll();

#if 0
	pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		pObj->Invalidate();
		Remove(pObj);
		m_deleted.AddTail(pObj);
	}
	m_selection.RemoveAll();
#endif

	for(POSITION pos = m_selection.GetHeadPosition();pos!=NULL;)
	{
		POSITION pos1 = pos ; //要在这里做一个备份
		CDrawObj* pObj = m_selection.GetNext(pos);//他会改变 pos的值
		pObj->Invalidate();
		Remove(pObj);
		m_deleted.AddTail(pObj);
	}
	m_selection.RemoveAll();

	m_bModified = TRUE;
}

void CIDEView::OnDeskGrid()
{
	m_pGraph->m_bGrid = !m_pGraph->m_bGrid;
	m_bModified = TRUE;
	Invalidate(FALSE);
}

void CIDEView::OnAlignTop() 
{
	CRect rect = GetAlignRect();

	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		CRect r = pObj->m_rect;
		r.OffsetRect(0, rect.top - min(r.top, r.bottom));
		pObj->MoveTo(r);
		m_bModified = TRUE;
	}
	Invalidate(FALSE);	
}

void CIDEView::OnAlignVcenter() 
{
	CRect rect = GetAlignRect();
	int y0 = rect.top + rect.Height() / 2;

	POSITION pos = m_selection.GetTailPosition();
	m_selection.GetPrev(pos);
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetPrev(pos);
		CRect r = pObj->m_rect;
		int y = r.top + r.Height() / 2;
		r.OffsetRect(0, y0-y);
		pObj->MoveTo(r);
		m_bModified = TRUE;
	}
	Invalidate(FALSE);

}

void CIDEView::OnAlignRight() 
{
	CRect rect = GetAlignRect();
	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		CRect r = pObj->m_rect;
		r.OffsetRect(rect.right - max(r.left, r.right), 0);
		pObj->MoveTo(r);
		m_bModified = TRUE;
	}
	Invalidate(FALSE);
	
}

void CIDEView::OnAlignLeft() 
{
	CRect rect = GetAlignRect();

	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		CRect r = pObj->m_rect;
		r.OffsetRect(rect.left - min(r.left, r.right), 0);
		pObj->MoveTo(r);
		m_bModified = TRUE;
	}
	Invalidate(FALSE);

}

void CIDEView::OnAlignHcenter() 
{
	CRect rect = GetAlignRect();
	int x0 = rect.left + rect.Width() / 2;

	POSITION pos = m_selection.GetTailPosition();
	m_selection.GetPrev(pos);
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetPrev(pos);
		CRect r = pObj->m_rect;
		int x = r.left + r.Width() / 2;
		r.OffsetRect(x0-x, 0);
		pObj->MoveTo(r);
		m_bModified = TRUE;
	}
	Invalidate(FALSE);

}

void CIDEView::OnAlignBottom() 
{
	CRect rect = GetAlignRect();

	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		CRect r = pObj->m_rect;
		r.OffsetRect(0, rect.bottom - max(r.top, r.bottom));
		pObj->MoveTo(r);
		m_bModified = TRUE;
	}
	Invalidate(FALSE);	
}

void CIDEView::OnEditVinvert() 
{
	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj *pObj = m_selection.GetNext(pos);
		int temp = pObj->m_rect.top;
		pObj->m_rect.top = pObj->m_rect.bottom;
		pObj->m_rect.bottom = temp;
		pObj->Invalidate();
		m_bModified = TRUE;
	}
	Invalidate(FALSE);
}

void CIDEView::OnMouseMove(UINT nFlags, CPoint point) 
{
	if(CDrawObj::bRuning == TRUE) 
	{
		POSITION pos = m_pGraph->m_DrawObjList.GetHeadPosition();
		while(pos != NULL)
		{
			CDrawObj* pObj = m_pGraph->m_DrawObjList.GetNext(pos);
			
			if ( (pObj->m_bOnButtonDown) && 0!=pObj->m_rect.PtInRect(point) ) 
			{
				HCURSOR hCursor;
				hCursor = AfxGetApp() -> LoadCursor(IDC_HANDCUR);
				SetCursor(hCursor);
				break;
			}
		}

		// 运行状态下，做动作响应处理
		//CClientDC dc(this);
		//OnPrepareDC(&dc);
		//CPoint local = point;
		//dc.DPtoLP(&local);
		//CDrawObj* tmp = ObjectAt(local);
		//if ( tmp  !=  NULL ) //该图元响应move动作
		//{
		//	if (tmp->m_bOnMove)
		//	{
		//		m_nCurActionType = MOUSE_MOVE;
		//		m_pCurActionObj = tmp;
		//		tmp->ProcessAction(MOUSE_MOVE);
		//	}
		//	if (tmp->IsKindOf( RUNTIME_CLASS(CDrawButton) ) ||
		//		( tmp->IsKindOf( RUNTIME_CLASS(CDrawBitmap) ) && 
		//		( tmp->m_downAction.m_nActionType == LINK_COMMOND || tmp->m_downAction.m_nActionType == SET_COMMOND || 
		//		  //tmp->m_downAction.m_nActionType == YT_COMMOND || tmp->m_downAction.m_nActionType == YK_COMMOND || 
		//		  tmp->m_downAction.m_nActionType == EXIT_COMMOND || tmp->m_downAction.m_nActionType == EXTERN_COMMOND) ) )
		//	{
		//		//::SetCursor(LoadCursor(NULL,(char*)   IDC_HAND));
		//		m_pCurActionObj = tmp;
		//	}
		//}
		//else
		//{
		//	m_pCurActionObj = NULL;
		//}
		return;
	}

	CClientDC dc(this);
	OnPrepareDC(&dc);
	CPoint local = point;
	dc.DPtoLP(&local);
	CSize offset = point-local;
	m_pointMouse = local;
	bool bFresh = false;
	
	if (m_mouseState == TRUE)   //鼠标按下
	{
		if ((g_nElementNo != 0)&&(m_tempObj != NULL) )  //添加新的图元
		{
			//画新图元的外形
			m_tempObj->m_rect = CRect(m_startPoint,m_pointMouse);
			m_bModified = TRUE;

			CRect freshRect = m_tempObj->m_rect;
			freshRect.NormalizeRect();
			CRect lastRect = CRect(m_lastPoint,m_lastPoint+CSize(4,4));
			lastRect.NormalizeRect();
			freshRect.UnionRect(freshRect,lastRect);
			freshRect.InflateRect(4,4);
			freshRect.OffsetRect(offset);
			InvalidateRect(freshRect,FALSE);
		}
		else if (m_bDrag == TRUE)			// 改变图元大小
		{
			m_selection.GetHead()->MoveHandleTo(nBDragHandle,local);
			SetCursor(m_selection.GetHead()->GetHandleCursor());
			m_bModified = TRUE;
			
			CRect freshRect = m_selection.GetHead()->m_rect;
			freshRect.NormalizeRect();
			CRect lastRect = CRect(m_lastPoint,m_lastPoint+CSize(4,4));
			lastRect.NormalizeRect();
			freshRect.UnionRect(freshRect,lastRect);
			freshRect.InflateRect(4,4);
			freshRect.OffsetRect(offset);
			InvalidateRect(freshRect,FALSE);
		}
		else if (m_bRectSelect == TRUE)  // 区选图元
		{
			m_mouseRect = CRect(m_startPoint,local);
			CRect freshRect = m_mouseRect;	// 需要刷新的区域
			freshRect.NormalizeRect();
			CRect lastRect = CRect(m_startPoint,m_lastPoint);
			lastRect.NormalizeRect();
			freshRect.UnionRect(freshRect,lastRect);
			freshRect.InflateRect(4,4);
			freshRect.OffsetRect(offset);
			InvalidateRect(freshRect,FALSE);
		}
	}
	
	//如果鼠标没按下，则判断是否到选中图元（一个）的边上了，是的话，改变图标
	if (m_mouseState == FALSE) 
	{
		if ((g_nElementNo == 0) && (m_selection.GetCount() == 1))
		{
			nDragHandle = m_selection.GetHead()->HitTest(local);
			if ( (nDragHandle>0)&&(nDragHandle<9) ) 
			{
				SetCursor(m_selection.GetHead()->GetHandleCursor());
			}
		}
	}
	
	if((m_bMoveElements == TRUE)&&(!m_bFreezed))	//移动一个或多个图元
	{
		HCURSOR hCursor;
		hCursor = AfxGetApp() -> LoadCursor(IDC_CURSOR1);
		SetCursor(hCursor);
		
		CRect freshRect;	// 需要刷新的区域
		bool bFirst = true;
		POSITION pos = m_selection.GetHeadPosition();
		while( pos != NULL)
		{
			CDrawObj* pObj = m_selection.GetNext(pos);
			CRect rect = pObj->m_rect;
			if (bFirst)
			{
				freshRect = rect;
				freshRect.InflateRect(4,4);
			}
			else
				freshRect.UnionRect(freshRect, rect);
			CPoint delta = CPoint(local-m_lastPoint);
			rect +=  delta;
			pObj->MoveTo(rect);
			rect.NormalizeRect();
			freshRect.UnionRect(freshRect, rect);
			freshRect.InflateRect(4,4);
			m_bModified = TRUE;
			bFirst = false;
			InvalidateRect(freshRect,FALSE);
		}
	}

	CString str;
	//要访问类CMainFrame，需要将mainfrm.h文件引入
	CMainFrame * pFrame = (CMainFrame *) AfxGetApp()->m_pMainWnd;
	CStatusBar * pStatus = (CStatusBar *) &pFrame->m_wndStatusBar;
	str.Format (g_strLogicDoorinate, local.x, local.y);
	pStatus->SetPaneText(1, str);

	// 根据情况，刷新部分区域
	if (bFresh )
		Invalidate(FALSE);

	m_lastPoint = local;
	CScrollView::OnMouseMove(nFlags, point);
}


long CIDEView::OnOutbarNotify(WPARAM wParam, LPARAM lParam)
{
	return 0;
}

void CIDEView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	if(CDrawObj::bRuning == TRUE) 
	{
		// 运行状态下，做动作响应处理
		CClientDC dc(this);
		OnPrepareDC(&dc);
		CPoint local = point;
		dc.DPtoLP(&local);
		CDrawObj* tmp = ObjectAt(local);
		if ( tmp  !=  NULL && 1)  //该图元响应click动作
		{ 
			if (tmp->m_bOnButtonDown)
			{
				m_nCurActionType = MOUSE_CLICK_DOWN;
				m_pCurActionObj = tmp;
				tmp->ProcessAction(MOUSE_CLICK_DOWN);
			}
		}
		else
		{
			m_pCurActionObj = NULL;
		}
		return;
	}
	CClientDC dc(this);
	OnPrepareDC(&dc);
	CPoint local = point;
	dc.DPtoLP(&local);
	m_bDrag = FALSE;
	m_mouseState = TRUE;
	m_startPoint = local;
	m_lastPoint = local;
	//生成一个图元
	if (g_nElementNo != 0)
	{
		if ( g_nElementNo ==  POLYGON || g_nElementNo ==  ZHELINE)
		{
			if ( m_bPolygon )
			{
				((CDrawPoly*)m_tempObj)->AddPoint(local);
				((CDrawPoly*)m_tempObj)->RecalcBounds();
				CRect freshRect = m_tempObj->m_rect;
				freshRect.NormalizeRect();
				freshRect.InflateRect(4,4);
				InvalidateRect(freshRect,FALSE);
			}
			else
			{
				m_selection.RemoveAll();
				m_tempObj = CreateDrawObjbyNo(g_nElementNo);
				if (m_tempObj != NULL) 
				{
					m_pGraph->m_DrawObjList.AddTail(m_tempObj);
					m_selection.AddTail(m_tempObj);
					((CDrawPoly*)m_tempObj)->AddPoint(local);
					m_bPolygon = true;
				}	
			}
		}
		else
		{
			m_selection.RemoveAll();
			m_tempObj = CreateDrawObjbyNo(g_nElementNo);  /**/
			if (m_tempObj != NULL) 
			{
				m_pGraph->m_DrawObjList.AddTail(m_tempObj);
				m_selection.AddTail(m_tempObj);
			}
		}
	}
	else if(nDragHandle == 0) //选择一个图元
	{
		CDrawObj *pObj = ObjectAt(local);
		if(pObj != NULL)
		{
			//selectMode = move;
			if(!IsSelected(pObj)) 
				Select(pObj, (nFlags & MK_CONTROL) != 0);
			else if((nFlags & MK_CONTROL) != 0)
			{
				POSITION ipos = m_selection.Find(pObj);
				if(ipos != NULL) m_selection.RemoveAt(ipos);
			}	//去掉selection中的该图元；
			m_bMoveElements = TRUE;
		}

		else if((nFlags & MK_CONTROL) == 0)
		{
			m_selection.RemoveAll();
			m_bMoveElements = FALSE;
			m_bRectSelect = TRUE;  //rectselect 区域选
		}
	}
	else	//拉动一个图元  //nDragHandle不等于0
	{
		m_bDrag = TRUE;
		nBDragHandle = nDragHandle;
	}
	//Invalidate(FALSE);
	CScrollView::OnLButtonDown(nFlags, point);
}

void CIDEView::OnLButtonUp(UINT nFlags, CPoint point) 
{
	if(CDrawObj::bRuning == TRUE) 
	{
		m_pCurActionObj = NULL;

		// 运行状态下，做动作响应处理
		CClientDC dc(this);
		OnPrepareDC(&dc);
		CPoint local = point;
		dc.DPtoLP(&local);
		CDrawObj* tmp = ObjectAt(point);
		if ( tmp  !=  NULL && tmp->m_bOnButtonUp)  //该图元响应click动作
		{ 
			m_nCurActionType = MOUSE_CLICK_UP;
			m_pCurActionObj = tmp;
			if (tmp->m_bOnButtonUp)
			{
				tmp->ProcessAction(MOUSE_CLICK_UP);
			}
		}
		else
		{
			m_pCurActionObj = NULL;
		}
		return;
	}

	CClientDC dc(this);
	OnPrepareDC(&dc);
	CPoint local = point;
	dc.DPtoLP(&local);
 	m_mouseState = FALSE;
	m_endPoint = local;
		
	if ((g_nElementNo != 0)&&(m_tempObj != NULL) )  //添加新设备
	{
		if ( (g_nElementNo ==  POLYGON  || g_nElementNo ==  ZHELINE )&& m_bPolygon)
		{
			;
		}
		else
		{
			m_tempObj->m_rect = CRect(m_startPoint,m_endPoint);
			if ((abs(CPoint(m_endPoint-m_startPoint).x)<6)&&(abs(CPoint(m_endPoint-m_startPoint).y)<6)) 
			{
				Remove(m_tempObj);
				delete m_tempObj;
				m_tempObj = NULL;
				g_nElementNo = 0;
			}
			else  //图元添加成功了，做临时文件处理
			{
				if (m_nRudoPosition == 0) //上一次也是编辑
				{
					ExchangeSave();
					if (m_nCanUndoTimes<5) 
					{
						m_nCanUndoTimes++;
					}
				}
				else  //上一次不是编辑
				{
					FileProcess();
				}
				m_nRudoPosition = 0;
				m_nCanRedoTimes = 0;
			}
		}
	}
	
	if (m_bRectSelect)   //选中一堆图元
	{
		m_mouseRect.NormalizeRect();
		ObjectIn();
	}

	if((m_bMoveElements == TRUE)&&(!m_bFreezed))		//移动，也要临时文件记录
	{
		if (m_nRudoPosition == 0) //上一次也是编辑
		{
			ExchangeSave();
		}
		else  //上一次不是编辑
		{
			FileProcess();
		}
		m_nRudoPosition = 0;
		m_nCanRedoTimes = 0;
	}
	
	if(m_bDrag)
	{
		if (m_nRudoPosition == 0) //上一次也是编辑
		{
			ExchangeSave();
		}
		else  //上一次不是编辑
		{
			FileProcess();
		}
		m_nRudoPosition = 0;
		m_nCanRedoTimes = 0;
	}
	m_bMoveElements = FALSE;
	m_bDrag = FALSE;
	m_mouseRect = CRect(0,0,0,0);
	m_bRectSelect = FALSE;          
	Invalidate(FALSE);      
	CScrollView::OnLButtonUp(nFlags, point);
}

CDrawObj * CIDEView::CreateDrawObjbyNo(int objNo)
{
	if (objNo == TlineShape) 
	{
		CDrawTLine * temp = new CDrawTLine();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == TextShape) 
	{
		CDrawText * temp = new CDrawText();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == RectShape) 
	{
		CDrawRect * temp = new CDrawRect();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == DataShape) 
	{
		CDrawDatabox * temp = new CDrawDatabox();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == BUTTON) 
	{
		CDrawButton * temp = new CDrawButton();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == ThreeDCircleShape) 
	{
		CDraw3dCircle * temp = new CDraw3dCircle();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
    if (objNo == RealCurveShape) 
	{
		CDrawCurve * temp = new CDrawCurve();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == BarShape) 
	{
		CDrawBar * temp = new CDrawBar();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == ELLIPSE) 
	{
		CDrawOval * temp = new CDrawOval();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == LINE) 
	{
		CDrawLine * temp = new CDrawLine();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == BREAKER) 
	{
		CDrawBreaker * temp = new CDrawBreaker();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == SWITCH) 
	{
		CDrawSwitch * temp = new CDrawSwitch();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == GRID) 
	{
		CDrawGrid * temp = new CDrawGrid();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == BitmapShape) 
	{
		CDrawBitmap * temp = new CDrawBitmap();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if( objNo == GifShape )
	{
		CDrawGif* temp = new CDrawGif();
		temp->m_pView = this;
		CDrawObj* ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == TRANSFER) 
	{
		CDrawTransfer * temp = new CDrawTransfer();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == ARC) 
	{
		CDrawArc * temp = new CDrawArc();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == ARROW) 
	{
		CDrawArrow * temp = new CDrawArrow();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == POLYGON) 
	{
		CDrawPoly * temp = new CDrawPoly();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == ZHELINE) 
	{
		CDrawMLine * temp = new CDrawMLine();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == PIPE) 
	{
		CDrawPipe * temp = new CDrawPipe();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if (objNo == ZHEPIPE) 
	{
		CDrawZhePipe * temp = new CDrawZhePipe();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == YPIPE)
	{
		CDrawYPipe * temp = new CDrawYPipe();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == WatchShape)
	{
		CDrawWatch * temp = new CDrawWatch();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == SINGLEBAR)
	{
		CDrawSingleBar * temp = new CDrawSingleBar();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == ROUNDRECT )
	{
		CDrawRoundRect * temp = new CDrawRoundRect();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == PIE )
	{
		CDrawPie* temp = new CDrawPie();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == FAN )
	{
		CDrawFan* temp = new CDrawFan();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == HISCurveShape )
	{
		CDrawHisCurve* temp = new CDrawHisCurve();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == REPORT )
	{
		CDrawTable* temp = new CDrawTable();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == OCX )
	{
		CDrawOCX* temp = new CDrawOCX();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == GIF )
	{
		CDrawGif* temp = new CDrawGif();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == FLASH )
	{
		CDrawFlash* temp = new CDrawFlash();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == BtnRadio )
	{
		CDrawBtnRadio* temp = new CDrawBtnRadio();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	if ( objNo == BtnCheck )
	{
		CDrawBtnCheck* temp = new CDrawBtnCheck();
		temp->m_pView = this;
		CDrawObj * ele = (CDrawObj *)temp;
		return ele;
	}
	//if ( objNo == FLASH )
	//{
	//	CDrawFlash* temp = new CDrawFlash();
	//	temp->m_pView = this;
	//	CDrawObj * ele = (CDrawObj *)temp;
	//	return ele;
	//}
	return NULL;
}

void CIDEView::OnPointer() 
{
	g_nElementNo = 0;
}

void CIDEView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
{
	int n = nRepCnt;
	BOOL bShiftDown = (GetKeyState(VK_SHIFT)&0xf0);
	if(!bShiftDown)
	{
		if(GetKeyState(VK_CONTROL)&0xf0) 
		{
			n *= 10;
		}
	}
	switch(nChar)
	{
	case VK_UP:
		if(bShiftDown) KeyMove(0,0,0,-n); 
		else KeyMove(0,-n,0,-n);
		m_bModified = TRUE;
		break;
	case VK_DOWN:
		if(bShiftDown) KeyMove(0,0,0,n);
		else KeyMove(0,n,0,n);
		m_bModified = TRUE;
		break;
	case VK_LEFT:
		if(bShiftDown) KeyMove(0,0,-n,0);
		else KeyMove(-n,0,-n,0);
		m_bModified = TRUE;
		break;
	case VK_RIGHT:
		if(bShiftDown) KeyMove(0,0,n,0);
		else KeyMove(n,0,n,0);
		m_bModified = TRUE;
		break;
	case VK_DELETE:
#if 0
		POSITION pos = m_selection.GetHeadPosition();
		while(pos != NULL)
		{
			CDrawObj *pObj = m_selection.GetNext(pos);
			Remove(pObj);
			delete pObj;
			m_bModified = TRUE;
		}
		m_selection.RemoveAll();
#endif
		for(POSITION pos = m_selection.GetHeadPosition();pos!=NULL;)
		{
			POSITION pos1 = pos ; //要在这里做一个备份
			CDrawObj *pObj = m_selection.GetNext(pos);//他会改变 pos的值
			Remove(pObj);
			if( pObj != NULL )
			{
				delete pObj;
				pObj = NULL;
			}
			//m_selection.RemoveAt(pos1);
			m_bModified = TRUE;
		}
		m_selection.RemoveAll();
		break;
	}
	Invalidate(FALSE);
	CScrollView::OnKeyDown(nChar, nRepCnt, nFlags);
}


void CIDEView::KeyMove(int x1,int y1,int x2,int y2)
{
	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		CRect rect = pObj->m_rect;
		if(rect.left<rect.right)
		{
			rect.left +=  x1;
			rect.right +=  x2;
		}
		else
		{
			rect.left +=  x2;
			rect.right +=  x1;
		}
		if(rect.top<rect.bottom)
		{
			rect.top +=  y1;
			rect.bottom +=  y2;
		}
		else
		{
			rect.top +=  y2;
			rect.bottom +=  y1;
		}
		pObj->MoveTo(rect);
		m_bModified = TRUE;
	}

}

CDrawObj* CIDEView::ObjectAt(CPoint point)
{
	CRect rect(point, CSize(1, 1));
	POSITION pos = m_pGraph->m_DrawObjList.GetTailPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_pGraph->m_DrawObjList.GetPrev(pos);
		if(pObj->Intersects(rect))	return pObj;
	}

	return NULL;
}


BOOL CIDEView::IsSelected(CDrawObj* pDrawObj)
{
	return m_selection.Find((CObject *)pDrawObj)  !=  NULL;
}

void CIDEView::Select(CDrawObj* pObj, BOOL bAdd)
{
	if(!bAdd)
	{
		POSITION pos = m_selection.GetHeadPosition();
		while(pos != NULL)
		{
			CDrawObj* pObj = m_selection.GetNext(pos);
			pObj->Invalidate();
		}
		m_selection.RemoveAll();
	}

	if(pObj == NULL||IsSelected(pObj)) return;


	{
		m_selection.AddTail(pObj);
		pObj->Invalidate();
	}
}

void CIDEView::Remove(CDrawObj* pObj)
{
	POSITION pos;

	pos = m_selection.Find(pObj);
	if(pos != NULL) m_selection.RemoveAt(pos);

	pos = m_pGraph->m_DrawObjList.Find(pObj);
	if(pos != NULL) m_pGraph->m_DrawObjList.RemoveAt(pos);

	m_bModified = TRUE;
}

void CIDEView::OnFileNew() 
{
	if(m_bModified)
	{
		if(MessageBox(g_strSaveModify,g_strSelect,MB_YESNO|MB_ICONQUESTION) == IDYES) 
			OnFileSave();
		}
	m_selection.RemoveAll();
	m_freezed.RemoveAll();
	m_pGraph->SetPicFile("");
	m_pGraph->Load();
	Invalidate(FALSE);
	POINT point;
	point.x = 0;
	point.y = 0;
	ScrollToPosition(point);
	m_bModified = TRUE;
}

void CIDEView::OnFileOpen() 
{
	if(m_bModified)
	{
		if(MessageBox(g_strSaveModify,g_strSelect,MB_YESNO|MB_ICONQUESTION) == IDYES) 
			OnFileSave();
	}
	DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
	CString strFindPicFile = "";
	LPSTR lpszFile = (char*)(const char*)strFindPicFile;
	LPSTR lpszFilter = (char *)(LPCTSTR)g_strPictureFile2;
	CFileDialog dlg(TRUE,".view",lpszFile,dwFlags,lpszFilter);
	if(dlg.DoModal() == IDOK)
	{
		m_selection.RemoveAll();
		m_freezed.RemoveAll();
		CString strPicFile = dlg.GetPathName();
		ASSERT(!strPicFile.IsEmpty());
		m_pGraph->SetPicFile(strPicFile);
		m_pGraph->Load();

		//应该保存
		char    tmpPathc[_MAX_PATH+1];
		GetTempPath(_MAX_PATH,tmpPathc);
		CString tmpPath = tmpPathc;

		CString oldFile = m_pGraph->m_strPicFile;
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\first.ed");
		m_pGraph->Store();
		m_pGraph->m_strPicFile = oldFile;

		RefreshScrollSizes();
		POINT point;
		point.x = 0;
		point.y = 0;
		ScrollToPosition(point);
		m_bModified = FALSE;
	}
}

void CIDEView::OnFileSave() 
{
	if(m_pGraph->m_strPicFile.IsEmpty()) 
		OnFileSaveAs();
	else
	{
		CRect rect = CRect(CPoint(0,0),m_pGraph->m_sizePic);
		POSITION pos = m_pGraph->m_DrawObjList.GetHeadPosition();
		while(pos != NULL)
		{
			CDrawObj *pObj = m_pGraph->m_DrawObjList.GetNext(pos);
			CRect r = pObj->m_rect;
			r.NormalizeRect();
			if((r & rect).IsRectEmpty())
			{
				Remove(pObj);
				delete pObj;
			}
		}
		m_pGraph->Store();
		m_bModified = FALSE;
	}
}
void CIDEView::FileSave() 
{
	if(m_pGraph->m_strPicFile.IsEmpty()) 
		OnFileSaveAs();
	else
	{
		CRect rect = CRect(CPoint(0,0),m_pGraph->m_sizePic);
		POSITION pos = m_pGraph->m_DrawObjList.GetHeadPosition();
		while(pos != NULL)
		{
			CDrawObj *pObj = m_pGraph->m_DrawObjList.GetNext(pos);
			CRect r = pObj->m_rect;
			r.NormalizeRect();
			if((r & rect).IsRectEmpty())
			{
				Remove(pObj);
				delete pObj;
			}
		}
		m_pGraph->Store();
		m_bModified = FALSE;
	}
}
void CIDEView::OnFileSaveAs() 
{
	DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
	CString strFindPicFile = "";
	LPSTR lpszFile = (char*)(const char*)strFindPicFile;
	LPSTR lpszFilter = (char *)(LPCTSTR)g_strPictureFile2;
	CFileDialog dlg(FALSE,".view",lpszFile,dwFlags,lpszFilter);
	if(dlg.DoModal() == IDOK)
	{
		CString strPicFile = dlg.GetPathName();
		ASSERT(!strPicFile.IsEmpty());
		m_pGraph->SetPicFile(strPicFile);
		OnFileSave();
	}
}

void CIDEView::RefreshScrollSizes(void)
{
	CSize sizeTotal = m_pGraph->m_sizePic;
	CSize sizePage = CSize(200,200);
	CSize sizeLine = CSize(10,10);
	SetScrollSizes(MM_TEXT,sizeTotal,sizePage,sizeLine);
	Invalidate(FALSE);
}

void CIDEView::OnAppExit() 
{
	if(m_bModified)
	{
		if(MessageBox(g_strSaveModify,g_strSelect,MB_YESNO|MB_ICONQUESTION) == IDYES) 
			OnFileSave();
	}

	CMainFrame *pMainFrm=(CMainFrame*)AfxGetApp()->m_pMainWnd;
	pMainFrm->OnSuperEnd();
}


CRect CIDEView::GetAlignRect(void)
{
	CDrawObj* pObj = m_selection.GetTail();
	CRect rect = pObj->m_rect;
	rect.NormalizeRect();
	return rect;
}

void CIDEView::OnPrint(CDC* pDC, CPrintInfo* pInfo) 
{
	CString sTemp;
	int nTemp=0;
	if(m_pGraph->m_Type == 0)
	{
		int nOffsetX = pDC->GetDeviceCaps(PHYSICALOFFSETX);
		int nOffsetY = pDC->GetDeviceCaps(PHYSICALOFFSETY);
		int nLogPixelX = pDC->GetDeviceCaps(LOGPIXELSX);
		int nLogPixelY = pDC->GetDeviceCaps(LOGPIXELSY);
		pDC->SetMapMode(MM_ISOTROPIC);
		pDC->SetWindowExt(100,100);
		pDC->SetViewportExt(nLogPixelX,nLogPixelY);
		pDC->SetViewportOrg(-nOffsetX,-nOffsetY);
		m_pGraph->Draw(pDC,sTemp,nTemp);
	}
	else
	{
		CSize size = m_pGraph->m_sizePic;
		int nHScale = pInfo->m_rectDraw.Width() / size.cx;
		int nVScale = pInfo->m_rectDraw.Height() / size.cy;
		int nScale = min(nHScale,nVScale);
		pDC->SetMapMode(MM_ISOTROPIC);
		pDC->SetWindowExt(1000,1000);
		pDC->SetViewportExt(1000*nScale,1000*nScale);
		int nHOffset = pInfo->m_rectDraw.Width() - nScale*size.cx;
		int nVOffset = pInfo->m_rectDraw.Height() - nScale*size.cy;
		pDC->SetViewportOrg(nHOffset/2,nVOffset/2);
		m_pGraph->Print(pDC);
	}
}

void CIDEView::OnUpdateDeskGrid(CCmdUI* pCmdUI) 
{
	if ( g_bRun ) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
	pCmdUI->SetCheck(m_pGraph->m_bGrid);
}

void CIDEView::OnUpdateEditFreeze(CCmdUI* pCmdUI) 
{
	pCmdUI->SetCheck(m_bFreezed);
}


//选出载鼠标拖动区域的图元
void CIDEView::ObjectIn()
{
	POSITION pos = m_pGraph->m_DrawObjList.GetTailPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_pGraph->m_DrawObjList.GetPrev(pos);
		CRect r = pObj->m_rect;
		r.NormalizeRect();
		if ((r.left>m_mouseRect.left)&&(r.right<m_mouseRect.right)
			&&(r.bottom<m_mouseRect.bottom)&&(r.top>m_mouseRect.top)) 
			m_selection.AddTail(pObj);
	}
}


//用作do/redo的
void CIDEView::ExchangeSave()
{
    char    tmpPathc[_MAX_PATH+1];
    GetTempPath(_MAX_PATH,tmpPathc);
	CString tmpPath = tmpPathc;
	CFile::Remove(_T(tmpPath+"\\VDTemp\\"+"\\Six.ed")); 
	CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Fifth.ed"),_T(tmpPath+"\\VDTemp\\"+"\\Six.ed"));
	CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Forth.ed"),_T(tmpPath+"\\VDTemp\\"+"\\Fifth.ed"));
    CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Third.ed"),_T(tmpPath+"\\VDTemp\\"+"\\Forth.ed"));
    CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Second.ed"),_T(tmpPath+"\\VDTemp\\"+"\\Third.ed"));
	CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\First.ed"),_T(tmpPath+"\\VDTemp\\"+"\\Second.ed"));
	CString oldFile = m_pGraph->m_strPicFile;
	m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\First.ed");
    m_pGraph->Store();
	m_pGraph->m_strPicFile = oldFile;
}

void CIDEView::OnRedo() 
{
	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		pObj->Invalidate();
	}
	m_selection.RemoveAll();

	char    tmpPathc[_MAX_PATH+1];
    GetTempPath(_MAX_PATH,tmpPathc);
	CString tmpPath = tmpPathc;
	CString oldFile = m_pGraph->m_strPicFile;

	if (m_nRudoPosition == -1) 
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\first.ed");
	else if (m_nRudoPosition == -2) 
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\second.ed");
	else if (m_nRudoPosition == -3) 
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\third.ed");
	else if (m_nRudoPosition == -4)
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\forth.ed");
	else if (m_nRudoPosition == -5)
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\fifth.ed");
	else 
		return;
	m_pGraph->Load();
	m_pGraph->m_strPicFile = oldFile;
	m_nRudoPosition++;
	m_nCanUndoTimes++;
	m_nCanRedoTimes--;
	Invalidate(FALSE);
}

void CIDEView::OnUndo() 
{
	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		pObj->Invalidate();
	}
	m_selection.RemoveAll();

	char    tmpPathc[_MAX_PATH+1];
    GetTempPath(_MAX_PATH,tmpPathc);
	CString tmpPath = tmpPathc;
	CString oldFile = m_pGraph->m_strPicFile;
	if (m_nRudoPosition == 0) 
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\second.ed");
	if (m_nRudoPosition == -1) 
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\third.ed");
	if (m_nRudoPosition == -2) 
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\forth.ed");
	if (m_nRudoPosition == -3) 
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\fifth.ed");
	if (m_nRudoPosition == -4) 
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\six.ed");
	if(m_nRudoPosition == -5) return;
	m_pGraph->Load();
	m_pGraph->m_strPicFile = oldFile;
	m_nRudoPosition--;
	m_nCanUndoTimes--;
	m_nCanRedoTimes++;
	Invalidate(FALSE);
}

void CIDEView::FileProcess()
{
    char   tmpPathc[_MAX_PATH+1];
    GetTempPath(_MAX_PATH,tmpPathc);
	CString tmpPath = tmpPathc;

    if(m_nRudoPosition == -1)
    {
		CString oldFile = m_pGraph->m_strPicFile;
		m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\first.ed");
		m_pGraph->Store();
		m_pGraph->m_strPicFile = oldFile;
    }
 
    if(m_nRudoPosition == -2)
    {
 		CFile::Remove(_T(tmpPath+"\\VDTemp\\"+"\\Second.ed"));
		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Third.ed"),_T(tmpPath+"\\VDTemp\\"+"\\second.ed"));
		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Forth.ed"),_T(tmpPath+"\\VDTemp\\"+"\\third.ed"));
		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Fifth.ed"),_T(tmpPath+"\\VDTemp\\"+"\\forth.ed"));
 		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Six.ed"),_T(tmpPath+"\\VDTemp\\"+"\\fifth.ed"));
		CFile file6(_T(tmpPath+"\\VDTemp\\"+"\\Six.ed"),CFile::modeReadWrite|CFile::modeCreate);
			file6.Close();
		CString oldFile = m_pGraph->m_strPicFile;
		if (m_nRudoPosition == 0) 
			m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\first.ed");
		m_pGraph->Store();
		m_pGraph->m_strPicFile = oldFile;
    }
    if(m_nRudoPosition == -3)
    {
 		CFile::Remove(_T(tmpPath+"\\VDTemp\\"+"\\Second.ed"));
		CFile::Remove(_T(tmpPath+"\\VDTemp\\"+"\\Third.ed"));
		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Forth.ed"),_T(tmpPath+"\\VDTemp\\"+"\\second.ed"));
		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Fifth.ed"),_T(tmpPath+"\\VDTemp\\"+"\\third.ed"));
 		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Six.ed"),_T(tmpPath+"\\VDTemp\\"+"\\forth.ed"));
		CFile file6(_T(tmpPath+"\\VDTemp\\"+"\\Six.ed"),CFile::modeReadWrite|CFile::modeCreate);
			file6.Close();
		CFile file5(_T(tmpPath+"\\VDTemp\\"+"\\fifth.ed"),CFile::modeReadWrite|CFile::modeCreate);
			file5.Close();
		CString oldFile = m_pGraph->m_strPicFile;
		if (m_nRudoPosition == 0) 
			m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\first.ed");
		m_pGraph->Store();
		m_pGraph->m_strPicFile = oldFile;
    }
 
    if(m_nRudoPosition == -4)
    {
 		CFile::Remove(_T(tmpPath+"\\VDTemp\\"+"\\Second.ed"));
		CFile::Remove(_T(tmpPath+"\\VDTemp\\"+"\\third.ed"));
		CFile::Remove(_T(tmpPath+"\\VDTemp\\"+"\\Forth.ed"));
		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\fifth.ed"),_T(tmpPath+"\\VDTemp\\"+"\\second.ed"));
		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\six.ed"),_T(tmpPath+"\\VDTemp\\"+"\\third.ed"));
		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Fifth.ed"),_T(tmpPath+"\\VDTemp\\"+"\\forth.ed"));
 		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\Six.ed"),_T(tmpPath+"\\VDTemp\\"+"\\fifth.ed"));
		CFile file4(_T(tmpPath+"\\VDTemp\\"+"\\forth.ed"),CFile::modeReadWrite|CFile::modeCreate);
			file4.Close();
		CFile file6(_T(tmpPath+"\\VDTemp\\"+"\\Six.ed"),CFile::modeReadWrite|CFile::modeCreate);
			file6.Close();
		CFile file5(_T(tmpPath+"\\VDTemp\\"+"\\fifth.ed"),CFile::modeReadWrite|CFile::modeCreate);
			file5.Close();
		CString oldFile = m_pGraph->m_strPicFile;
		if (m_nRudoPosition == 0) 
			m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\first.ed");
		m_pGraph->Store();
		m_pGraph->m_strPicFile = oldFile;
    }
	
	if(m_nRudoPosition == -5)
    {
 		CFile::Remove(_T(tmpPath+"\\VDTemp\\"+"\\Second.ed"));
		CFile::Remove(_T(tmpPath+"\\VDTemp\\"+"\\third.ed"));
		CFile::Remove(_T(tmpPath+"\\VDTemp\\"+"\\Forth.ed"));
		CFile::Remove(_T(tmpPath+"\\VDTemp\\"+"\\fifth.ed"));
		CFile::Rename(_T(tmpPath+"\\VDTemp\\"+"\\six.ed"),_T(tmpPath+"\\VDTemp\\"+"\\second.ed"));
		CFile file4(_T(tmpPath+"\\VDTemp\\"+"\\forth.ed"),CFile::modeReadWrite|CFile::modeCreate);
			file4.Close();
		CFile file6(_T(tmpPath+"\\VDTemp\\"+"\\Six.ed"),CFile::modeReadWrite|CFile::modeCreate);
			file6.Close();
		CFile file5(_T(tmpPath+"\\VDTemp\\"+"\\fifth.ed"),CFile::modeReadWrite|CFile::modeCreate);
			file5.Close();
		CFile file3(_T(tmpPath+"\\VDTemp\\"+"\\third.ed"),CFile::modeReadWrite|CFile::modeCreate);
			file3.Close();
		CString oldFile = m_pGraph->m_strPicFile;
		if (m_nRudoPosition == 0) 
			m_pGraph->m_strPicFile = _T(tmpPath+"\\VDTemp\\"+"\\first.ed");
		m_pGraph->Store();
		m_pGraph->m_strPicFile = oldFile;
  }
}

void CIDEView::OnUpdateUndo(CCmdUI* pCmdUI) 
{
	if (g_bRun == FALSE && m_nCanUndoTimes) {
		pCmdUI->Enable(TRUE);
	}
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateRedo(CCmdUI* pCmdUI) 
{
	if (g_bRun == FALSE && m_nCanRedoTimes) {
		pCmdUI->Enable(TRUE);
	}
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnPicsize() 
{
	CPicSizeDlg dlg;
	dlg.m_nPictureHeight = m_pGraph->m_sizePic.cy;
	dlg.m_nPictureWidth = m_pGraph->m_sizePic.cx;
	dlg.m_nGridSize = m_pGraph->m_sizeGrid.cx;
	dlg.m_clrBack = m_pGraph->m_clrBack;
	dlg.m_bGrid = m_pGraph->m_bGrid;
	if(dlg.DoModal() == IDOK)
	{
		m_pGraph->m_sizePic.cy = dlg.m_nPictureHeight;
		m_pGraph->m_sizePic.cx = dlg.m_nPictureWidth;
		m_pGraph->m_sizeGrid.cy = dlg.m_nGridSize;
		m_pGraph->m_sizeGrid.cx = dlg.m_nGridSize;
		m_pGraph->m_clrBack = dlg.m_clrBack;
		m_pGraph->m_bGrid = dlg.m_bGrid;
		m_bModified = TRUE;
	}
	RefreshScrollSizes();
}

void CIDEView::OnUpdateAlignBottom(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount()>1))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateAlignHcenter(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount()>1))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateAlignLeft(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount()>1))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateAlignRight(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount()>1))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateAlignTop(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount()>1))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateAlignVcenter(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount()>1))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateEditHinvert(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount()>0))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateEditMovetoback(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount()>0))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateEditMovetofront(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount()>0))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateEditVinvert(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount()>0))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateEditCopy(CCmdUI* pCmdUI) 
{
	if(m_selection.GetCount()>0)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateEditCut(CCmdUI* pCmdUI) 
{
	if(m_selection.GetCount()>0)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateEditClear(CCmdUI* pCmdUI) 
{
	if(m_selection.GetCount()>0)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnUpdateEditPaste(CCmdUI* pCmdUI) 
{
#if 1
	if(g_Copied.GetCount()>0)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
#else
	if(m_copied.GetCount()>0)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
#endif
}

void CIDEView::OnDrawTline() 
{
	g_nElementNo = TlineShape;
}

void CIDEView::OnDrawText() 
{
	g_nElementNo = TextShape;
}

void CIDEView::OnDrawRect() 
{
	g_nElementNo = RectShape;
}

void CIDEView::OnDrawData() 
{
	g_nElementNo = DataShape;
}

void CIDEView::OnDrawBitmap() 
{
	g_nElementNo = BitmapShape;
}

void CIDEView::OnDrawCurve() 
{
	g_nElementNo = RealCurveShape;
}

void CIDEView::OnDrawWatch() 
{
	g_nElementNo = WatchShape;
}

void CIDEView::OnDrawBar() 
{
	g_nElementNo = BarShape;
}

void CIDEView::OnDraw3drect() 
{
	g_nElementNo = BUTTON;
}

void CIDEView::OnDraw3circle() 
{
	g_nElementNo = ThreeDCircleShape;
}

void CIDEView::OnDrawOCX() 
{
	g_nElementNo = OCX;
}
void CIDEView::OnDrawGIF() 
{
	g_nElementNo = GIF;
}
void CIDEView::OnDrawFlash() 
{
	g_nElementNo = FLASH;
}
void CIDEView::OnDrawBtnRadio() 
{
	g_nElementNo = BtnRadio;
}
void CIDEView::OnDrawBtnCheck() 
{
	g_nElementNo = BtnCheck;
}

void CIDEView::OnUpdatePointer(CCmdUI* pCmdUI) 
{
	if(g_nElementNo == 0)
		pCmdUI->SetCheck(TRUE);
	else
		pCmdUI->SetCheck(FALSE);
}

//属性设定
void CIDEView::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	if(CDrawObj::bRuning == TRUE) return;
	if (m_selection.GetCount()<1) {
		return;
	}
	
	CClientDC dc(this);
	OnPrepareDC(&dc);
	CPoint local = point;
	dc.DPtoLP(&local);
	if ( (g_nElementNo = POLYGON  || g_nElementNo ==  ZHELINE ) && m_tempObj  !=  NULL && m_bPolygon)
	{
		((CDrawPoly*)m_tempObj)->AddPoint(local);
		m_bPolygon = false;
		((CDrawPoly*)m_tempObj)->RecalcBounds();
		CRect freshRect = m_tempObj->m_rect;
		freshRect.NormalizeRect();
		freshRect.InflateRect(4,4);
		InvalidateRect(freshRect,FALSE);
		m_tempObj = NULL;
		g_nElementNo = 0;
	}
	else
	{
		if (m_selection.GetCount()>1) 
		{
			COLORREF	_clrFore;		// 前景色
			COLORREF	_clrLine;		// 线色
			COLORREF	_clrBack;		// 背景色
			COLORREF	_clrFill;		// 填充色
			LOGFONT		_logfont;		// 字体
			CString     _strLineType;	// 线型
			int         _nLineWidth;	// 线宽
			int			_nFillMode;		//填充類型

			int nPosIndex=0;
			POSITION pos = m_selection.GetHeadPosition();
			while(pos != NULL)
			{
				CDrawObj* pObj = m_selection.GetNext(pos);
				pObj->m_bModifyMore = TRUE;
				
				if( nPosIndex==0 )
				{
					if ( pObj->OnAttrib() )
					{
						m_bModified = TRUE;

						_clrFore = pObj->m_clrFore;
						_clrLine = pObj->m_clrLine;
						_clrBack = pObj->m_clrBack;
						_clrFill = pObj->m_clrFill;
						_logfont = pObj->m_logfont;
						_strLineType = pObj->m_strLineType;
						_nLineWidth = pObj->m_nLineWidth;
						_nFillMode = pObj->m_nFillMode;
					}
					else
					{
						return;
					}
				}
				else
				{
					pObj->m_clrFore = _clrFore;
					pObj->m_clrLine = _clrLine;
					pObj->m_clrBack = _clrBack;
					pObj->m_clrFill = _clrFill;
					pObj->m_logfont = _logfont;
					pObj->m_strLineType = _strLineType;
					pObj->m_nLineWidth = _nLineWidth;
					pObj->m_nFillMode = _nFillMode;
				}

				CRect freshRect = pObj->m_rect;
				freshRect.NormalizeRect();
				freshRect.InflateRect(4,4);
				InvalidateRect(freshRect,FALSE);
				g_nElementNo = 0;

				nPosIndex++;
			}
		}
		else
		{
			POSITION pos = m_selection.GetHeadPosition();
			CDrawObj *pObj = m_selection.GetNext(pos);
			pObj->m_bModifyMore = FALSE;

			if ( pObj->OnAttrib() )
				m_bModified = TRUE;

			CRect freshRect = pObj->m_rect;
			freshRect.NormalizeRect();
			freshRect.InflateRect(4,4);
			InvalidateRect(freshRect,FALSE);
			g_nElementNo = 0;
		}
	}

	CScrollView::OnLButtonDblClk(nFlags, point);
}

void CIDEView::ChangeView()
{
	if(g_strViewName != "")
	{
		if(m_bModified)
		{
			if(MessageBox(g_strSaveModify,g_strSelect,MB_YESNO|MB_ICONQUESTION) == IDYES) 
				OnFileSave();
		}

		m_selection.RemoveAll();
		m_freezed.RemoveAll();

		m_pGraph->SetPicFile(g_strViewName);
		m_pGraph->Load();
		m_pGraph->SetView(this);

		m_pCurActionObj = NULL;
		m_nCurActionType = -1;
		Invalidate(FALSE);

		RefreshScrollSizes();
		POINT point;
		point.x = 0;
		point.y = 0;
		ScrollToPosition(point);
		m_bModified = FALSE;
	}
}

void CIDEView::OnTimer(UINT nIDEvent) 
{
	if (g_bRun) 
	{
#if VIEW_USE_THREAD
#else
		if( m_pGraph )
		{
			m_pGraph->Fresh();		//My:这才是更新视图画面上变量的值;
			//Invalidate(FALSE);//chn 刷新		
		}
#endif
	}
	CScrollView::OnTimer(nIDEvent);
}

void CIDEView::OnUpdateDraw3circle(CCmdUI* pCmdUI) 
{
	if (g_bRun == TRUE) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
}

void CIDEView::OnUpdateDraw3drect(CCmdUI* pCmdUI) 
{
	if (g_bRun == TRUE) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
}


void CIDEView::OnUpdateDrawData(CCmdUI* pCmdUI) 
{
	if (g_bRun == TRUE) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
}

void CIDEView::OnUpdateDrawRect(CCmdUI* pCmdUI) 
{
	if (g_bRun == TRUE) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
}

void CIDEView::OnUpdateDrawText(CCmdUI* pCmdUI) 
{
	if (g_bRun == TRUE) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
}

void CIDEView::OnUpdateDrawTline(CCmdUI* pCmdUI) 
{
	if (g_bRun == TRUE) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
}

void CIDEView::OnUpdateDrawBitmap(CCmdUI* pCmdUI) 
{
	if (g_bRun == TRUE) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
}

void CIDEView::OnUpdateDrawCurve(CCmdUI* pCmdUI) 
{
	if (g_bRun == TRUE) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
}

void CIDEView::OnUpdateDrawWatch(CCmdUI* pCmdUI) 
{
	if (g_bRun == TRUE) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
}

void CIDEView::OnUpdateDrawBar(CCmdUI* pCmdUI) 
{
	if (g_bRun == TRUE) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
}

void CIDEView::OnRButtonDown(UINT nFlags, CPoint point) 
{
	if (g_bRun)
    {
        return;
    }

	CPoint tmpPoint;
	GetCursorPos(&tmpPoint);

    CMenu menu;
    menu.LoadMenu(IDR_DRAW_POP);
    menu.GetSubMenu(0)->TrackPopupMenu(TPM_LEFTALIGN, tmpPoint.x, tmpPoint.y,this); 

	CScrollView::OnRButtonDown(nFlags, point);
}


void CIDEView::OnEditSave() 
{
	OnFileSave();
}

void CIDEView::OnUpdateEditSave(CCmdUI* pCmdUI) 
{
	if(m_bModified)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}


BOOL CIDEView::OnEraseBkgnd(CDC* pDC) 
{
	return false;
}


void CIDEView::OnUpdatePicsize(CCmdUI* pCmdUI) 
{
	if (g_bRun == TRUE) {
		pCmdUI->Enable(FALSE);
	}
	else
		pCmdUI->Enable(TRUE);
}


void CIDEView::OnVerspace() 
{
	CDrawObj* pTop;
	CDrawObj* pBottom;
	int top = 2000;
	int bottom = 0;
	int heightSum = 0;
	int alignCount = 0;
	int nY = 0;

	// 先取top, bottom两个图元；
	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		alignCount++;
		pObj->m_bAligned = false;
		CRect r = pObj->m_rect;
		r.NormalizeRect();
		if (r.top < top)
		{
			pTop = pObj;
			top = r.top;
		}
		if (r.bottom > bottom)
		{
			pBottom = pObj;
			bottom = r.bottom;
		}
		heightSum +=  r.Height();
	}
	pTop->m_bAligned = true;
	pBottom->m_bAligned = true;
	alignCount -= 2;
	int space = bottom - top - heightSum; 
	int perSpace = space / (alignCount+1);
	nY = top + pTop->m_rect.Height() + perSpace;
	
	for (int i = 1; i <= alignCount; i++ )
	{
		POSITION pos = m_selection.GetHeadPosition();
		CDrawObj* curObj;
		int top1 = 2000;
		while(pos != NULL)
		{
			CDrawObj* pObj = m_selection.GetNext(pos);
			CRect rec = pObj->m_rect;
			rec.NormalizeRect();
			if ( !pObj->m_bAligned )
			{
				if ( rec.top < top1)
				{
					top1 = rec.top;
					curObj = pObj;
				}
			}
		}
		
		CRect r = curObj->m_rect;
		r.OffsetRect(0, nY - top1);
		curObj->MoveTo(r);
		curObj->m_bAligned = true;
		nY +=  (perSpace + r.Height());
	}
	m_bModified = TRUE;
	Invalidate(FALSE);
}


void CIDEView::OnUpdateVerspace(CCmdUI* pCmdUI) 
{
	if(m_selection.GetCount()>2)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnSamewidth() 
{
	CRect rect = GetAlignRect();
	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		CRect r = pObj->m_rect;
		r.NormalizeRect();
		r.right = r.left + (rect.right - rect.left);
		pObj->m_rect = r;
		m_bModified = TRUE;
	}
	Invalidate(FALSE);
}

void CIDEView::OnUpdateSamewidth(CCmdUI* pCmdUI) 
{
	if(m_selection.GetCount()>1)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnSameheight() 
{
	CRect rect = GetAlignRect();
	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		CRect r = pObj->m_rect;
		r.NormalizeRect();
		r.bottom = r.top + (rect.bottom - rect.top);
		pObj->m_rect = r;
		m_bModified = TRUE;
	}
	Invalidate(FALSE);
}



void CIDEView::OnHorspace() 
{
	CDrawObj* pLeft = NULL;
	CDrawObj* pRight = NULL;
	int left = 2000;
	int right = 0;
	int widthSum = 0;
	int alignCount = 0;
	int nX = 0;

	// 先取top, bottom两个图元；
	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		alignCount++;
		pObj->m_bAligned = false;
		CRect r = pObj->m_rect;
		r.NormalizeRect();
		if (r.left < left)
		{
			pLeft = pObj;
			left = r.left;
		}
		if (r.right > right)
		{
			pRight = pObj;
			right = r.right;
		}
		widthSum +=  r.Width();
	}
	pLeft->m_bAligned = true;
	pRight->m_bAligned = true;
	alignCount -=  2;
	int space = right - left - widthSum; 
	int perSpace = space / (alignCount+1);
	nX = left + pLeft->m_rect.Width() + perSpace;
	
	for (int i = 1; i <= alignCount; i++ )
	{
		POSITION pos = m_selection.GetHeadPosition();
		CDrawObj* curObj;
		int left1 = 2000;
		while(pos != NULL)
		{
			CDrawObj* pObj = m_selection.GetNext(pos);
			CRect rec = pObj->m_rect;
			rec.NormalizeRect();
			if ( !pObj->m_bAligned )
			{
				if ( rec.left < left1)
				{
					left1 = rec.left;
					curObj = pObj;
				}
			}
		}
		
		CRect r = curObj->m_rect;
		r.OffsetRect(nX - left1, 0);
		curObj->MoveTo(r);
		curObj->m_bAligned = true;
		nX +=  (perSpace + r.Width());
	}
	m_bModified = TRUE;
	Invalidate(FALSE);
}


void CIDEView::OnAllsame() 
{
	CRect rect = GetAlignRect();
	POSITION pos = m_selection.GetHeadPosition();
	while (pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		CRect r = pObj->m_rect;
		r.NormalizeRect();
		r.bottom = r.top + (rect.bottom - rect.top);
		r.right = r.left + (rect.right - rect.left);
		pObj->m_rect = r;
		m_bModified = TRUE;
	}
	Invalidate(FALSE);
}

void CIDEView::OnUpdateSameheight(CCmdUI* pCmdUI) 
{
	if(m_selection.GetCount()>1)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}


void CIDEView::OnUpdateHorspace(CCmdUI* pCmdUI) 
{
	if(m_selection.GetCount()>2)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}


void CIDEView::OnUpdateAllsame(CCmdUI* pCmdUI) 
{
	if(m_selection.GetCount()>1)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}

void CIDEView::OnEndPrintPreview(CDC* pDC, CPrintInfo* pInfo, POINT point, CPreviewView* pView) 
{
	CScrollView::OnEndPrintPreview(pDC, pInfo, point, pView);
	CMainFrame *pFrame = (CMainFrame*)AfxGetApp()->m_pMainWnd;
	pFrame->SetWindowText(g_strStoneuIspcms);
	pFrame->HideRunBar();
	pFrame->ShowWindow(SW_SHOWMAXIMIZED);
	pFrame->UpdateWindow();
	pFrame->RecalcLayout();
}

void CIDEView::OnOpenpic() 
{
	CPicListDlg dlg;
	if ( dlg.DoModal() == IDOK )
	{
		g_strViewName = _PICTUREDIR + dlg.m_strPicName;
		g_strViewName = g_strViewName + ".view";

		CMainFrame *pFrame = (CMainFrame*)AfxGetApp()->m_pMainWnd;
		CString strPath;
		strPath = g_strDirectory + CString("\\") + CString(g_strViewName);
		pFrame->AddIDEView( dlg.m_strPicName, strPath );
	}
}

void CIDEView::OnDrawArc() 
{
	g_nElementNo = ARC;
	
}

void CIDEView::OnDrawBreaker() 
{
	g_nElementNo = BREAKER;
	
}

void CIDEView::OnDrawFan() 
{
	g_nElementNo = FAN;
	
}

void CIDEView::OnDrawGrid() 
{
	g_nElementNo = GRID;
	
}

void CIDEView::OnDrawHiscurve() 
{
	g_nElementNo = HISCurveShape;
	
}

void CIDEView::OnDrawLine() 
{
	g_nElementNo = LINE;
	
}


void CIDEView::OnDrawPie() 
{
	g_nElementNo = PIE;
	
}

void CIDEView::OnDrawPipe() 
{
	g_nElementNo = PIPE;
}

void CIDEView::OnDrawPolygon() 
{
	g_nElementNo = POLYGON;
	
}

void CIDEView::OnDrawReport() 
{
	g_nElementNo = REPORT;
	
}

void CIDEView::OnDrawSinglebar() 
{
	g_nElementNo = SINGLEBAR;
	
}

void CIDEView::OnDrawTransfer() 
{
	g_nElementNo = TRANSFER;
	
}


void CIDEView::OnDrawYpipe() 
{
	g_nElementNo = YPIPE;
	
}


void CIDEView::OnDrawZheline() 
{
	g_nElementNo = ZHELINE;
}


void CIDEView::OnDrawZhepipe() 
{
	g_nElementNo = ZHEPIPE;
}


void CIDEView::OnDrawArrow() 
{
	g_nElementNo = ARROW;
}


void CIDEView::OnDrawEllipse() 
{
	g_nElementNo = ELLIPSE;
}

void CIDEView::OnDrawSwitch() 
{
	g_nElementNo = SWITCH;
}


void CIDEView::OnUpdateDrawSwitch(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
}


void CIDEView::OnUpdateDrawArc(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawArrow(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawBreaker(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawEllipse(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawFan(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawGrid(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawHiscurve(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawPie(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawPipe(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawPolygon(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawReport(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawSinglebar(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawTransfer(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawYpipe(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawZheline(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawZhepipe(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
	
}


void CIDEView::OnUpdateDrawLine(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
}


void CIDEView::OnDrawRoundrect() 
{
	g_nElementNo = ROUNDRECT;	
}


void CIDEView::OnUpdateDrawRoundrect(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
}

void CIDEView::OnUpdateDrawOCX(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
}
void CIDEView::OnUpdateDrawGIF(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
}
void CIDEView::OnUpdateDrawFlash(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
}
void CIDEView::OnUpdateDrawBtnRadio(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
}
void CIDEView::OnUpdateDrawBtnCheck(CCmdUI* pCmdUI) 
{
	pCmdUI->Enable(TRUE);
}
void CIDEView::SetHisTime(CTime time)
{
	m_tblTime = time;

	POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		pObj->m_bHisFreshed = false;
	}
}

void CIDEView::OnUpdateDiscombine(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount() == 1))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);	
}

void CIDEView::OnUpdateCombine(CCmdUI* pCmdUI) 
{
	if((m_selection.GetCount()>1))
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}


void CIDEView::OnCombine() 
{ 
 	CDrawComposite* pTempObj = new CDrawComposite(m_selection);
    pTempObj->m_pView = this;
    
    POSITION pos = m_selection.GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pObj = m_selection.GetNext(pos);
		pObj->Invalidate();
		Remove(pObj);
	}
	m_selection.RemoveAll();

	if (pTempObj != NULL) 
	{
		m_pGraph->m_DrawObjList.AddTail(pTempObj);
        m_selection.AddTail(pTempObj);
	}
}


// 分解组合图元
void CIDEView::OnDiscombine() 
{
    if (m_selection.GetCount() != 1)
    {
		MessageBox(g_strUnSelectEntity);
        return;
    }

    CDrawObj* pObj = m_selection.GetHead();
    if (!pObj->IsKindOf(RUNTIME_CLASS(CDrawComposite)))
    {
		MessageBox(g_strIsNotPrimitive);
        return;
    }

    m_selection.RemoveAll();

    // 分解并添加到画面
    POSITION pos = (((CDrawComposite*)pObj)->m_ObjList).GetHeadPosition();
	while(pos != NULL)
	{
		CDrawObj* pTmpObj = (((CDrawComposite*)pObj)->m_ObjList).GetNext(pos);
		pTmpObj->m_pView = this;
        m_pGraph->m_DrawObjList.AddTail(pTmpObj);
        m_selection.AddTail(pTmpObj);
	}
	
    // 删除组合图元
    pos = m_pGraph->m_DrawObjList.Find(pObj);
    if (NULL != pos)
    {
        m_pGraph->m_DrawObjList.RemoveAt(pos);
    }

    // 选择
    

    //tbd 内存泄漏
//  delete pObj;    
}

void CIDEView::OnProperty()
{
	// TODO: 在此添加命令处理程序代码

	if(CDrawObj::bRuning == TRUE) return;
	if (m_selection.GetCount()<1) 
	{
		return;
	}
	
	CClientDC dc(this);
	OnPrepareDC(&dc);
	//CPoint local = point;
	//dc.DPtoLP(&local);
	if ( (g_nElementNo = POLYGON  || g_nElementNo ==  ZHELINE ) && m_tempObj  !=  NULL && m_bPolygon)
	{
//		((CDrawPoly*)m_tempObj)->AddPoint(local);
		m_bPolygon = false;
		((CDrawPoly*)m_tempObj)->RecalcBounds();
		CRect freshRect = m_tempObj->m_rect;
		freshRect.NormalizeRect();
		freshRect.InflateRect(4,4);
		InvalidateRect(freshRect,FALSE);
		m_tempObj = NULL;
		g_nElementNo = 0;
	}
	else
	{
		if (m_selection.GetCount()>1) 
		{
			COLORREF	_clrFore;		// 前景色
			COLORREF	_clrLine;		// 线色
			COLORREF	_clrBack;		// 背景色
			COLORREF	_clrFill;		// 填充色
			LOGFONT		_logfont;		// 字体
			CString     _strLineType;	// 线型
			int         _nLineWidth;	// 线宽
			int			_nFillMode;		//填充類型

			int nPosIndex=0;
			POSITION pos = m_selection.GetHeadPosition();
			while(pos != NULL)
			{
				CDrawObj* pObj = m_selection.GetNext(pos);
				pObj->m_bModifyMore = TRUE;
				
				if( nPosIndex==0 )
				{
					if ( pObj->OnAttrib() )
					{
						m_bModified = TRUE;

						_clrFore = pObj->m_clrFore;
						_clrLine = pObj->m_clrLine;
						_clrBack = pObj->m_clrBack;
						_clrFill = pObj->m_clrFill;
						_logfont = pObj->m_logfont;
						_strLineType = pObj->m_strLineType;
						_nLineWidth = pObj->m_nLineWidth;
						_nFillMode = pObj->m_nFillMode;
					}
					else
					{
						return;
					}
				}
				else
				{
					pObj->m_clrFore = _clrFore;
					pObj->m_clrLine = _clrLine;
					pObj->m_clrBack = _clrBack;
					pObj->m_clrFill = _clrFill;
					pObj->m_logfont = _logfont;
					pObj->m_strLineType = _strLineType;
					pObj->m_nLineWidth = _nLineWidth;
					pObj->m_nFillMode = _nFillMode;
				}

				CRect freshRect = pObj->m_rect;
				freshRect.NormalizeRect();
				freshRect.InflateRect(4,4);
				InvalidateRect(freshRect,FALSE);
				g_nElementNo = 0;

				nPosIndex++;
			}
		}
		else
		{
			POSITION pos = m_selection.GetHeadPosition();
			CDrawObj *pObj = m_selection.GetNext(pos);
			pObj->m_bModifyMore = FALSE;

			if ( pObj->OnAttrib() )
				m_bModified = TRUE;

			CRect freshRect = pObj->m_rect;
			freshRect.NormalizeRect();
			freshRect.InflateRect(4,4);
			InvalidateRect(freshRect,FALSE);
			g_nElementNo = 0;
		}
	}
}

void CIDEView::OnUpdateProperty(CCmdUI *pCmdUI)
{
	// TODO: 在此添加命令更新用户界面处理程序代码
}

void CIDEView::OnClose()
{
	// TODO: 在此添加消息处理程序代码和/或调用默认值
	if(m_bModified)
	{
		if(MessageBox(g_strSaveModify,g_strSelect,MB_YESNO|MB_ICONQUESTION) == IDYES) 
			OnFileSave();
	}
	CScrollView::OnClose();
}

#if VIEW_USE_THREAD
DWORD WINAPI CIDEView::FreshGraphThread( void *pData )
{
	CIDEView *pView = (CIDEView *)pData;
	
	do
	{
		if( pView != NULL )
		{
			if( pView->m_pGraph != NULL )
			{
				pView->m_pGraph->Fresh();		

				//pView->Invalidate(FALSE);				
			}
		}
		Sleep(100);
	}while( WaitForSingleObject( pView->m_hIDEViewRunObject, 125L ) == WAIT_TIMEOUT );

	return 0;
}
#endif
void CIDEView::OnKillFocus(CWnd* pNewWnd)
{
	CScrollView::OnKillFocus(pNewWnd);

	// TODO: 在此处添加消息处理程序代码
	//TRACE("Enter KillFocus\n");
}

void CIDEView::OnSetFocus(CWnd* pOldWnd)
{
	CScrollView::OnSetFocus(pOldWnd);

	// TODO: 在此处添加消息处理程序代码
	//TRACE("Enter SetFocus\n");

}

void CIDEView::OnActivateView(BOOL bActivate, CView* pActivateView, CView* pDeactiveView)
{
	// TODO: 在此添加专用代码和/或调用基类

	CScrollView::OnActivateView(bActivate, pActivateView, pDeactiveView);
}

CString CIDEView::RegSearch(HKEY hKey, TCHAR rootKey[], CString path,CString sContent)
{
	CString sRet;
	DWORD	numSubKey=0;					//存放子键的项数
	DWORD	i;								//计数
	DWORD   sizeSubKey;						//子键大小
	TCHAR	subKey[255];			//子键名

	/*打开hKey中的rootKey, hKey乃继承递归调用者之hKey, rootKey乃递归调用者之subKey*/
	RegOpenKeyEx(	hKey,					//欲开之键柄
					rootKey,				//欲开之根键名
					0,						//保留值，强制0
					KEY_READ,				//权限
					&hKey);					//打开子键后，返回键柄


	///*首先查当前键下的值们(表明是复数哈)是否有符合条件的*/
	char lpWstr[MAX_PATH];
	DWORD lpType = NULL;
	DWORD maxBufSize = MAX_PATH;
	if(RegQueryValueEx(hKey, NULL, NULL, &lpType, (LPBYTE)lpWstr, &maxBufSize) == ERROR_SUCCESS)
	{
		CString sGet(lpWstr);

		if( -1!=sGet.Find( sContent ) && sGet.GetLength()>=5 && path.Find( "CLSID" )!=-1 )
		{
			RegCloseKey(hKey);						    //收尾工作是一定要做的，否则机器会异常的慢
			sRet = path.Mid( 6,0x26 );
			return sRet;								//跳出递归
		}
	}
	/*没有查到，则进入子键查询*/
	else
	{
		/*首先查得当前键下的子键项数*/
		RegQueryInfoKey(	hKey,
							NULL,
							NULL,
							NULL,
							&numSubKey,		//查得子键的项数
							NULL,
							NULL,
							NULL,
							NULL,
							NULL,
							NULL,
							NULL);
		
		/*如果子键数不为0，遍历子键*/
		if (numSubKey)	
		{
			for (i=0; i<numSubKey; i++)
			{
				subKey[0]='\0';				//该两行很重要，保证了每次循环的初始	
				sizeSubKey=255;	//第一行清空子键，第二行赋缓冲区大小

				RegEnumKeyEx(	hKey,		//键柄
								i,			//子键序号
								subKey,		//存入子键名
								&sizeSubKey,//指明缓冲区大小
								NULL,
								NULL,
								NULL,
								NULL);
				CString s;
				s = RegSearch (hKey,subKey,path+subKey+"\\",sContent);	//递归
				if( s.GetLength()>10 )
				{
					sRet = s;//.Mid( 6,0x26 );
					return sRet;
				}
			}
		}
	}
	RegCloseKey(hKey);						//收尾工作是一定要做的，否则机器会异常的慢

	return sRet;
}
CString CIDEView::GetClsidbyName( CString sName )
{
	CString sRet;
	CString sPathName;
	sPathName.Format( "%s",g_strDirectory );
	sPathName += "\\ocx";
	sPathName += "\\ocxList.txt";

	CString sTemp;
	CStdioFile File;
	
	if(!File.Open(sPathName,CFile::modeRead))
		File.Open(sPathName,CFile::modeCreate|CFile::modeRead);
	while(File.ReadString(sTemp))//定义一个CString变量sTemp作为缓冲区
	{	
		int nPos = sTemp.Find( sName );
		if( nPos!=-1 )
		{
			sRet = sTemp.Mid( sName.GetLength()+1,sTemp.GetLength()-sName.GetLength() );
			break;
		}
	}
	File.Close();

	return sRet;
}
void CIDEView::ShowOCX( CRect rect,CString sOcxPath,int iIndex )
{
	//g_strDirectory;
	//把宽高写入ini
	CHAR strFile[MAX_PATH + 1] = "";
	memset(strFile, 0, sizeof(strFile));
	wsprintf(strFile, "C:\\OCXRect.ini");

	if( rect.left<0 )
		rect.left = 0;
	if( rect.top<0 )
		rect.top = 0;

	CString sW,sH,sIndex;
	sW.Format( "%d",rect.Width() );
	sH.Format( "%d",rect.Height() );
	sIndex.Format("%d",iIndex );

	WritePrivateProfileString("WH",  "W", sW, strFile);
	WritePrivateProfileString("WH",  "H", sH, strFile);
	WritePrivateProfileString("WH",  "INDEX", sIndex, strFile);
	///////////////////////////////////////////////////////
	CString sName;
	for (int iPosFile = sOcxPath.GetLength() - 1; iPosFile >= 0; iPosFile--)
	{
		if (sOcxPath[iPosFile] == '\\')
		{
			sName = sOcxPath.Mid( iPosFile+1,sOcxPath.GetLength()-iPosFile-5 );
			break;
		}
	}

	CString sClsid = GetClsidbyName( sName );//RegSearch (HKEY_CLASSES_ROOT,"","",sName+" Control");//
	//SToneu_Door_WG="{AED861D5-723E-4F31-AA24-0F20B382103E}";//
	//StoneU_HC_OCX ="{80043A10-F014-4817-9832-38A38202E0B8}";//
	//if( sClsid=="" )
	//{
	//	if( RegisterOCX( sOcxPath ) )//注册OCX
	//		sClsid = RegSearch (HKEY_CLASSES_ROOT,"","",sName+" Control");
	//}

	if( sClsid!="" )
	{
		USES_CONVERSION;
		CLSID clsid;
		HRESULT hr = CLSIDFromString(T2OLE(sClsid), &clsid);

		bool f;
		static int ID = 62001;
		int nRet = m_OcxWnd.CreateControl( clsid, _T("132"), WS_CHILD | WS_VISIBLE, rect, this,ID );
		ID++;
		if( nRet == 0 )
			f = false;
		else
			f = true;
	}
	else
	{
		CString str;
		str.Format( "请在 <\\Ocx\\ocxList.txt> 里填入控件的sClsid" );
		MessageBox(str, g_strTip, MB_ICONWARNING);
	}
}