mainfrm.cpp

来自「ucOS 模拟环境」· C++ 代码 · 共 845 行 · 第 1/2 页

// MainFrm.cpp : implementation of the CMainFrame class
//


#include "stdafx.h"
#include "viewer.h"
#include "MainFrm.h"
#include "typedef.h"
#include "keydef.h"


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

#define  BACKGROUND_COLOR   (RGB(196,196,196))

#define SCR_WIDTH 	112
#define SCR_HEIGHT	128

#define KEYBOARD_W	320
#define KEYBOARD_H	95

#define	ED_XDOTS	SCR_WIDTH
#define	ED_YDOTS	SCR_HEIGHT



static CMainFrame *g_pMainFrm = NULL;

typedef unsigned long KEYTYPE;
extern "C" unsigned char		DispMap[ DISP_BUF_SIZE +10];


static CKeyQueue PCKeyQueue(4);


extern "C" void ResumeTask(void)
{
	
	::ResumeThread(g_pMainFrm->m_pTheThread->m_hThread);
}


extern "C" void SuspendTask(void)
{
//	CMainFrame *pMainFrm = (CMainFrame *)::AfxGetMainWnd();
	::SuspendThread(g_pMainFrm->m_pTheThread->m_hThread);
}
//----------------------------------------------------------------------
extern "C" void TurnOffSCR(void)
{
	//	pViewWnd->TurnOffSCR();
}
//----------------------------------------------------------------------
extern "C" bool AddPCKey(uchar key)
{
   bool bReturn = (Bool)PCKeyQueue.AddValue(key);
   ResumeTask();
   return bReturn;
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
extern "C" Bool HasPCKey(void)
{
	return (bool)PCKeyQueue.HasValue();
}
//----------------------------------------------------------------------
extern "C" uchar GetPCKey(void)
{
	uchar key;
	key = PCKeyQueue.GetValue();
	return key;

}
//----------------------------------------------------------------------
extern "C" void ClearPCKey(void)
{
#ifdef PCVER
	PCKeyQueue.Clear();
#else

#endif
}
//----------------------------------------------------------------------
extern "C" uchar TestPCKey(void)
{
	return PCKeyQueue.TestValue();
}

CKeyQueue::CKeyQueue(int size)
{
	bufsize = size;
	if(bufsize<2) bufsize = 2;
	else if(bufsize>512) bufsize = 512;

	pQueueBuf = (uchar*)malloc(bufsize);

	head = tail = 0;

	synchronize = 0;
}
//----------------------------------------------------------------------
CKeyQueue::~CKeyQueue()
{
	free(pQueueBuf);
}
//----------------------------------------------------------------------
uchar CKeyQueue::GetValue(void)
{
	if(synchronize) return 0xff;

	synchronize = 1;

	if(tail != head)
	{
		++head;
		if(head>=bufsize) head = 0;

		synchronize = 0;

		return *(pQueueBuf+head);
	}
	else
	{
		synchronize = 0;

		return 0xff;
	}
}
//----------------------------------------------------------------------
void CKeyQueue::Clear(void)
{
	if(synchronize==0)
		head = tail = 0;
}
//----------------------------------------------------------------------
bool CKeyQueue::AddValue(uchar val)
{
	int temp;

	if(synchronize) return false;

	synchronize = 1;

	temp = tail + 1;
	if(temp>=bufsize) temp = 0;

	if( temp != head)
	{
		tail = temp;
		*(pQueueBuf+tail) = val;
	}

	synchronize = 0;

	return (temp != head);
}
//----------------------------------------------------------------------
bool CKeyQueue::HasValue(void)
{
	return(tail!=head);
}
//----------------------------------------------------------------------
unsigned char CKeyQueue::TestValue(void)
{
	int temp;
	if(tail==head) return 0xff;
	else
	{
		temp = head + 1;
		if(temp>=bufsize) temp = 0;

		return *(pQueueBuf+temp);
	}
}



struct TKeyBoardInfo
{
   ulong m_ulKey;
   CRect m_Rect;
   TKeyBoardInfo(ulong ulkey, CRect rect)
   {
	   m_ulKey = ulkey;
	   m_Rect = rect;
   }
};


TKeyBoardInfo KeyMapRect[]=
{
		TKeyBoardInfo(VK_UP/*KEY_DOWN_UP*/,	 CRect(87,  5,  155,  29)), //arrow up KEY_UP
		TKeyBoardInfo(VK_DOWN,	 CRect(87, 65,  154,  89)), //arrow right KEY_DOWN
		TKeyBoardInfo(VK_LEFT,		CRect(5, 34,  72,  59)), //arrow left KEY_LEFT
		TKeyBoardInfo(VK_RIGHT,		CRect(170, 34,  237,  58)), //arrow down KEY_RIGHT
		TKeyBoardInfo(VK_ESCAPE,	CRect(247, 34,  314,  58)), //esc KEY_ESC
		TKeyBoardInfo(VK_RETURN, CRect(87, 35,  154,  58)), //enter KEY_ENTER
		TKeyBoardInfo(0xffffffff,	CRect(0, 0,  0,  0)), 
};



///////////////////////////////////////////////////////////////////////
void DrawBitmap(int x, int y, CDC *pDC, CBitmap *bitmap)
{
   CBitmap *pbmOld = NULL;
   CDC     dcMem;
   BITMAP  bmpinfo; 
 
   dcMem.CreateCompatibleDC(pDC);
   pbmOld = dcMem.SelectObject(bitmap);
   bitmap->GetBitmap(&bmpinfo);

   pDC->BitBlt(x, y, bmpinfo.bmWidth, bmpinfo.bmHeight, &dcMem, 0, 0, SRCCOPY);
 
   dcMem.SelectObject(pbmOld);
   dcMem.DeleteDC();
}

/////////////////////////////////////////////////////////////////////////////
// CMainFrame

IMPLEMENT_DYNAMIC(CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
	//{{AFX_MSG_MAP(CMainFrame)
	ON_WM_CREATE()
	ON_WM_ERASEBKGND()
	ON_WM_DESTROY()
	ON_WM_CLOSE()
	ON_WM_KEYDOWN()
	ON_WM_PAINT()
	ON_WM_TIMER()
	ON_WM_MOUSEWHEEL()
	ON_WM_SYSKEYDOWN()
	ON_COMMAND(ID_ZOOM2, OnZoom2)
	ON_COMMAND(ID_ZOOM1, OnZoom1)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction

extern "C" void UpdateScr()
{
	if(g_pMainFrm)
		g_pMainFrm->UpdateScr();
}

CMainFrame::CMainFrame()
{
	m_nZoomNum = 1;
#if 0
	m_mainWndRect.SetRect(0, 0,  640,720);
#else
	CViewerApp *pApp;
	pApp = (CViewerApp *)AfxGetApp();
	pApp->GetAppSetting();
	m_nZoomNum = pApp->m_setting.iZoom;
	m_mainWndRect.left = pApp->m_setting.iWindowLeft;
	m_mainWndRect.top = pApp->m_setting.iWindowTop;
	m_mainWndRect.right = pApp->m_setting.iWindowLeft + pApp->m_setting.iWindowWidth;
	m_mainWndRect.bottom = pApp->m_setting.iWindowTop + pApp->m_setting.iWindowHeight;
#endif
	m_pTheThread = NULL;
	memset( BitmapBuf, 0xff, sizeof( BitmapBuf ) );
	m_nTotalLines = 0;
}

CMainFrame::~CMainFrame()
{
//	KillTimer(IDT_1_S);
//	KillTimer(IDT_BLINK);
}

int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{

	if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;

	if( !keyboard.Create(NULL, NULL, AFX_WS_DEFAULT_VIEW,
			CRect(0,0,0,0), this, AFX_IDW_PANE_FIRST, NULL ) )
	{
		return -1;
	}
//	int nCnt = (*AfxGetApp()->m_lpCmdLine ? sizeof(indicators) : sizeof(indicatorsLook)) / sizeof(UINT);
//	UINT *pinfo = (*AfxGetApp()->m_lpCmdLine ? indicators: indicatorsLook);

	keyboard.ShowWindow(SW_SHOW);

	_CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

	if (m_mainWndRect.IsRectEmpty())
		GetWindowRect(&m_mainWndRect);

#ifdef _DEBUG
		 SetWindowPos(	&wndTop, 0, 0, 350, 330, SWP_SHOWWINDOW );
#else
	 	SetWindowPos(&wndTop,
		m_mainWndRect.left, m_mainWndRect.top, m_mainWndRect.Width(), m_mainWndRect.Height(),
		SWP_SHOWWINDOW);

#endif
	CString strTitle;
	strTitle.LoadString(IDR_MAINFRAME);
	strTitle += " (";
	strTitle += __DATE__;
	strTitle += "  ";
	strTitle += __TIME__;
	strTitle += ")";
	SetWindowText(strTitle);
	g_pMainFrm = this;
	
//	GetMenu()->CheckMenuRadioItem( ID_COPYSTYLECOLOR, ID_COPYASTEXT, ID_COPYSTYLECOLOR, MF_BYCOMMAND);

	return 0;
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
//	cs.dwExStyle &= ~WS_EX_CLIENTEDGE;
	return CFrameWnd::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CMainFrame diagnostics

#ifdef _DEBUG

void CMainFrame::AssertValid() const
{
	CFrameWnd::AssertValid();
}

void CMainFrame::Dump(CDumpContext& dc) const
{
	CFrameWnd::Dump(dc);
}

#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers

void CMainFrame::UpdateScr()
{
	CClientDC dc(this);
	OnDraw(&dc,TRUE);
}


BOOL CMainFrame::OnEraseBkgnd(CDC* pDC)
{
	// TODO: Add your message handler code here and/or call default
	CRect rect;
	CBrush bkBrush(BACKGROUND_COLOR),	*pOldBrush;
	GetClientRect( &rect );
	pOldBrush=pDC->SelectObject( &bkBrush );
	pDC->Rectangle( &rect );
	pDC->SelectObject( pOldBrush );
	return TRUE;
}

void CMainFrame::OnDestroy()
{
#ifndef _DEBUG
	CViewerApp *pApp;
	pApp = (CViewerApp *)AfxGetApp();
	pApp->WriteAppSetting ();
#endif
//	g_GetSeqKey.AddKey(KEY_EXIT_APP);
	ResumeThread( m_pTheThread->m_hThread );
	WaitForSingleObject( m_pTheThread->m_hThread, 2000);
	CFrameWnd::OnDestroy();
	PostNcDestroy();
	PostQuitMessage(0);
}

void CMainFrame::OnClose()
{
	PostMessage(WM_DESTROY);
	//CFrameWnd::OnClose();
}
void CMainFrame::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	if (0)//IS_FM_RUN_SEQ)
	{
		CFrameWnd::OnKeyDown(nChar, nRepCnt, nFlags);
		return;
	}
	KEYTYPE key=-1;
    bool InVaild = false;
	switch( nChar )
	{
		case VK_PRIOR:	
		case VK_NEXT:
			InVaild = true;
			break;
		case VK_UP:		
			key = KEY_DOWN_UP;
			break;
		case VK_DOWN:
			key = KEY_DOWN_DOWN;
			break;
		case VK_LEFT:
			key = KEY_DOWN_LEFT;
			break;
		case VK_RIGHT:	
			key = KEY_DOWN_RIGHT;
			break;
		case VK_RETURN:	
			key = KEY_DOWN_ENT;
			break;
		case VK_ESCAPE:	
			key = KEY_DOWN_C;
			break;
		default: