tinmap.cpp

并行TIN生成算法, 基于DeWall算法理论实现

// TinMap.cpp : implementation of the CTinMap class
//

#include "stdafx.h"
#include "TinApp.h"

#include "TinDoc.h"
#include "TinMap.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

/////////////////////////////////////////////////////////////////////////////
// CTinMap

IMPLEMENT_DYNCREATE(CTinMap, CView)

BEGIN_MESSAGE_MAP(CTinMap, CView)
	ON_WM_SIZE()
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_MOUSEMOVE()
	ON_WM_MOUSEWHEEL()
	ON_WM_SETCURSOR()
	ON_COMMAND(ID_ZOOM_INT, OnZoomInt)
	ON_UPDATE_COMMAND_UI(ID_ZOOM_INT, OnUpdateZoomInt)
	ON_COMMAND(ID_ZOOM_OUT, OnZoomOut)
	ON_UPDATE_COMMAND_UI(ID_ZOOM_OUT, OnUpdateZoomOut)
	ON_COMMAND(ID_MOVE_PAN, OnMovePan)
	ON_UPDATE_COMMAND_UI(ID_MOVE_PAN, OnUpdateMovePan)
	// 标准打印命令
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CTinMap 构造/析构

CTinMap::CTinMap()
{
	m_dw = m_dh = MoveX = MoveY = 0;
	m_pMemDC = 0;	m_pMemBM = 0;

	m_nTool1 = m_nTool2 = 0;

}

CTinMap::~CTinMap()
{
	if(m_pMemDC)	delete m_pMemDC;
	if(m_pMemBM)	delete m_pMemBM;
}

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

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CTinMap 绘制

void CTinMap::OnDraw(CDC* pDC)
{
	CTinDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);

	if (m_pMemDC)
	{
		pDC->BitBlt(0, 0, m_cw, m_ch, m_pMemDC, MoveX, -MoveY, SRCCOPY);
	}
}

/////////////////////////////////////////////////////////////////////////////
// CTinMap 打印

BOOL CTinMap::OnPreparePrinting(CPrintInfo* pInfo)
{
	// default preparation
	return DoPreparePrinting(pInfo);
}

void CTinMap::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// TODO: add extra initialization before printing
}

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

/////////////////////////////////////////////////////////////////////////////
// CTinMap 诊断

#ifdef _DEBUG
void CTinMap::AssertValid() const
{
	CView::AssertValid();
}

void CTinMap::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CTinDoc* CTinMap::GetDocument() const // 非调试版本是内联的
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CTinDoc)));
	return (CTinDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CTinMap 消息处理程序

void CTinMap::OnInitialUpdate() 
{
	CView::OnInitialUpdate();
	
	m_dw = GetSystemMetrics(SM_CXSCREEN);
	m_dh = GetSystemMetrics(SM_CYSCREEN);
	if (m_dw == 0 || m_dh == 0)	return;

	m_pMemDC = new CDC;	m_pMemBM = new CBitmap;
	if (m_pMemDC && m_pMemBM)
	{
		CDC *pDC = GetDC();
		if (pDC == NULL)
		{
			delete m_pMemDC;	delete m_pMemBM;
			m_pMemDC = 0;	m_pMemBM = 0;
		}
		else
		{
			long bInit = 1;
			if (m_pMemDC->CreateCompatibleDC(pDC))
			{
				if (m_pMemBM->CreateCompatibleBitmap(pDC, m_dw, m_dh))
				{
					if (m_pMemDC->SelectObject(m_pMemBM))
						m_pMemDC->SetStretchBltMode(COLORONCOLOR);
					else
						bInit = 0;
				}
				else
					bInit = 0;
			}
			else
				bInit = 0;

			if (!bInit)
			{
				delete m_pMemDC;	delete m_pMemBM;
				m_pMemDC = 0;	m_pMemBM = 0;
			}

			ReleaseDC(pDC);	
		}
	}
	else
	{
		if (m_pMemDC)	delete m_pMemDC;
		if (m_pMemBM)	delete m_pMemBM;
		m_pMemDC = 0;	m_pMemBM = 0;
	}
}

void CTinMap::OnSize(UINT nType, int cx, int cy) 
{
	CView::OnSize(nType, cx, cy);
	
	m_cw = cx;	m_ch = cy;

	CTinDoc* pDoc = GetDocument();	ASSERT_VALID(pDoc);
	if (pDoc && m_pMemDC)
	{
		pDoc->SetViewportExt(m_cw, m_ch);

		PatBlt(m_pMemDC->m_hDC, 0, 0, m_dw, m_dh, WHITENESS);
		pDoc->Move(m_pMemDC, 0, 0);

		Invalidate(0);
	}	
}

void CTinMap::OnUpdate(CView* pSender, LPARAM lHint, CObject* pHint) 
{
	CTinDoc* pDoc = GetDocument();	ASSERT_VALID(pDoc);

	m_nTool1 = m_nTool2 = 0;

	if (pDoc && m_pMemDC)
	{
		pDoc->SetViewportExt(m_cw, m_ch);

		PatBlt(m_pMemDC->m_hDC, 0, 0, m_dw, m_dh, WHITENESS);
		pDoc->Move(m_pMemDC, 0, 0);

		Invalidate(1);
	}
}

void CTinMap::OnLButtonDown(UINT nFlags, CPoint point) 
{
	CTinDoc* pDoc = GetDocument();	ASSERT_VALID(pDoc);
	m_bLBDown = 1;	m_prePoint = point;	m_midPoint = point;	MoveX = 0;	MoveY = 0;
	
	if (m_nTool1 == ID_ZOOM_INT || m_nTool1 == ID_ZOOM_OUT || m_nTool1 == ID_MOVE_PAN)
		SetCapture();
	
	CView::OnLButtonDown(nFlags, point);
}

void CTinMap::OnLButtonUp(UINT nFlags, CPoint point) 
{
	CTinDoc* pDoc = GetDocument();	ASSERT_VALID(pDoc);
	if (m_nTool1 == ID_ZOOM_INT || m_nTool1 == ID_ZOOM_OUT || m_nTool1 == ID_MOVE_PAN)
		ReleaseCapture();

	if (m_bLBDown)
	{
		if (m_nTool1 == ID_ZOOM_INT || m_nTool1 == ID_ZOOM_OUT)	// 放大或缩小
		{
			CDC* pDC = GetDC();
			CPen *oldPen, newPen;

			newPen.CreatePen(PS_DOT, 1, RGB(0, 255, 0));
			oldPen = pDC->SelectObject(&newPen);	long oldRop = pDC->SetROP2(R2_NOTXORPEN);
			
			pDC->Rectangle(CRect(m_prePoint.x, m_prePoint.y, m_midPoint.x, m_midPoint.y));
			m_midPoint = point;
			
			pDC->SetROP2(oldRop);	pDC->SelectObject(oldPen);		newPen.DeleteObject();
			ReleaseDC(pDC);
			
			long mx, my;	double xs, ys;

			my = m_ch / 2 - (m_midPoint.y + m_prePoint.y) / 2;
			mx = m_cw / 2 - (m_midPoint.x + m_prePoint.x) / 2;
			ys = m_ch / (1.0 * abs(m_midPoint.y - m_prePoint.y));
			xs = m_cw / (1.0 * abs(m_midPoint.x - m_prePoint.x));
			if (abs(m_midPoint.x - m_prePoint.x) < 4 || abs(m_midPoint.y - m_prePoint.y) < 4)
				xs = ys = 1.5;
			
			PatBlt(m_pMemDC->m_hDC, 0, 0, m_dw, m_dh, WHITENESS);
			if (m_nTool1 == ID_ZOOM_INT)
			{
				if (xs > ys)
					pDoc->Zoom(m_pMemDC, mx, -my, xs, xs, TRUE);
				else
					pDoc->Zoom(m_pMemDC, mx, -my, ys, ys, TRUE);
			}
			else
			{
				if (xs < ys)
					pDoc->Zoom(m_pMemDC, mx, -my, xs, xs, FALSE);
				else
					pDoc->Zoom(m_pMemDC, mx, -my, ys, ys, FALSE);
			}
			Invalidate(0);
		}
		else if (m_nTool1 == ID_MOVE_PAN) // 地图漫游
		{
			MoveX = m_prePoint.x - point.x;
			MoveY = point.y - m_prePoint.y;

			PatBlt(m_pMemDC->m_hDC, 0, 0, m_dw, m_dh, WHITENESS);
			pDoc->Move(m_pMemDC, MoveX, MoveY);

			MoveX = 0;		MoveY = 0;
			Invalidate(0);
		}
	}

	m_bLBDown = 0;
	
	CView::OnLButtonUp(nFlags, point);
}

void CTinMap::OnMouseMove(UINT nFlags, CPoint point) 
{
	if (m_bLBDown)
	{
		if (m_nTool1 == ID_ZOOM_INT || m_nTool1 == ID_ZOOM_OUT)	// 放大或缩小或分割
		{
			CDC* pDC = GetDC();
			CPen *oldPen, newPen;

			newPen.CreatePen(PS_DOT, 1, RGB(0, 255, 0));
			oldPen = pDC->SelectObject(&newPen);	int oldRop = pDC->SetROP2(R2_NOTXORPEN);
			
			pDC->Rectangle(CRect(m_prePoint.x, m_prePoint.y, m_midPoint.x, m_midPoint.y));
			
			m_midPoint = point;
			pDC->Rectangle(CRect(m_prePoint.x, m_prePoint.y, m_midPoint.x, m_midPoint.y));
			
			pDC->SetROP2(oldRop);	pDC->SelectObject(oldPen);	newPen.DeleteObject();
			ReleaseDC(pDC);
		}
		else if (m_nTool1 == ID_MOVE_PAN) // 地图漫游
		{
			long dx = point.x - m_midPoint.x;
			long dy = point.y - m_midPoint.y;
			
			MoveX = m_prePoint.x - point.x;
			MoveY = point.y - m_prePoint.y;
			
			ScrollWindow(dx, dy, NULL, NULL);
			
			m_midPoint = point;
		}
	}
	
	CView::OnMouseMove(nFlags, point);
}

BOOL CTinMap::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) 
{
	CTinDoc* pDoc = GetDocument();	ASSERT_VALID(pDoc);

	if (zDelta > 0)
	{
		PatBlt(m_pMemDC->m_hDC, 0, 0, m_dw, m_dh, WHITENESS);
		pDoc->Zoom(m_pMemDC, 0, 0, 1.05, 1.05, TRUE);
	}
	else
	{
		PatBlt(m_pMemDC->m_hDC, 0, 0, m_dw, m_dh, WHITENESS);
		pDoc->Zoom(m_pMemDC, 0, 0, 1.05, 1.05, FALSE);
	}
	Invalidate();	UpdateWindow();
	
	return CView::OnMouseWheel(nFlags, zDelta, pt);
}

BOOL CTinMap::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
{
	CWinApp *winApp = AfxGetApp();

	if (m_nTool1 != 0)
	{
		if		(m_nTool1 == ID_ZOOM_INT)
		{	SetCursor(winApp->LoadCursor(129));	return FALSE;	}
		else if (m_nTool1 == ID_ZOOM_OUT)
		{	SetCursor(winApp->LoadCursor(130));	return FALSE;	}
		else if (m_nTool1 == ID_MOVE_PAN)
		{	SetCursor(winApp->LoadCursor(132));	return FALSE;	}
	}
	
	return CView::OnSetCursor(pWnd, nHitTest, message);
}

void CTinMap::MoveTo(double x, double y)
{
	CTinDoc* pDoc = GetDocument();	ASSERT_VALID(pDoc);

	PatBlt(m_pMemDC->m_hDC, 0, 0, m_dw, m_dh, WHITENESS);
	pDoc->MoveTo(m_pMemDC, x, y);
	Invalidate(0);
}

void CTinMap::OnZoomInt() 
{
	if (m_nTool1 != ID_ZOOM_INT)	m_nTool1 = ID_ZOOM_INT;
	else							m_nTool1 = 0;
}

void CTinMap::OnUpdateZoomInt(CCmdUI* pCmdUI) 
{
	if (m_nTool1 == ID_ZOOM_INT)	pCmdUI->SetCheck(1);
	else							pCmdUI->SetCheck(0);
}

void CTinMap::OnZoomOut() 
{
	if (m_nTool1 != ID_ZOOM_OUT)	m_nTool1 = ID_ZOOM_OUT;
	else							m_nTool1 = 0;
}

void CTinMap::OnUpdateZoomOut(CCmdUI* pCmdUI) 
{
	if (m_nTool1 == ID_ZOOM_OUT)	pCmdUI->SetCheck(1);
	else							pCmdUI->SetCheck(0);
}

void CTinMap::OnMovePan() 
{
	if (m_nTool1 != ID_MOVE_PAN)	m_nTool1 = ID_MOVE_PAN;
	else							m_nTool1 = 0;
}

void CTinMap::OnUpdateMovePan(CCmdUI* pCmdUI) 
{
	if (m_nTool1 == ID_MOVE_PAN)	pCmdUI->SetCheck(1);
	else							pCmdUI->SetCheck(0);
}