mainfrm.cpp

The application wizard has created this SoccerDoctor application for you. This application not onl

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

#include "stdafx.h"
#include "SoccerDoctor.h"
#include "TypeExplorer.h"
#include "MainFrm.h"
#include "AutoplayConfiger.h"
#include "StatisticDialog.h" // CStatisticDialog
#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// CMainFrame

IMPLEMENT_DYNAMIC(CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP(CMainFrame, CFrameWnd)
	ON_WM_CREATE()
	ON_WM_SETFOCUS()
	ON_COMMAND_RANGE(ID_LOGPLAYER_LOAD, ID_LOGPLAYER_ACCELERATE, OnLogplayerCommand)
	ON_WM_CLOSE()
	ON_WM_TIMER()
	ON_UPDATE_COMMAND_UI_RANGE(ID_LOGPLAYER_PLAY, ID_LOGPLAYER_ACCELERATE,OnUpdateLogplayerCommand)
	ON_COMMAND_RANGE(ID_DISPLAYER_KICKMARGIN, ID_DISPLAYER_SELECTNONE ,OnDisplayerCommand)
	ON_UPDATE_COMMAND_UI_RANGE(ID_DISPLAYER_KICKMARGIN, ID_DISPLAYER_SELECTNONE, OnUpdateDisplayerCommand)
	ON_COMMAND(ID_ANALYZER_TYPEXPLORER, OnTypeExplorer)
	ON_WM_KEYDOWN()
	ON_COMMAND_RANGE(ID_MONITOR_CONNECT, ID_MONITOR_SAVELOG,OnMonitorCommand)
	ON_UPDATE_COMMAND_UI_RANGE(ID_MONITOR_CONNECT, ID_MONITOR_SAVELOG, OnUpdateMonitorCommand)
	ON_COMMAND(ID_SHOWDETAILS, OnObjectDetails)
	ON_COMMAND_RANGE(ID_DISPLAYER_SELECTLEFT1, ID_DISPLAYER_SELECTBALL,OnDispSelectObject)
	ON_UPDATE_COMMAND_UI_RANGE(ID_DISPLAYER_SELECTLEFT1, ID_DISPLAYER_SELECTBALL,OnUpdateSelectBar)
	ON_WM_CHAR()
	ON_COMMAND(ID_SYSTEM_NEW, OnNewDoctor)
	ON_COMMAND(ID_SYSTEM_HIDE, OnMainFrameHide)
	ON_COMMAND(ID_DRAWINGTOOLS, OnDrawingtools)
	ON_WM_DROPFILES()
	ON_COMMAND(ID_TOOLBOX_AUTOPLAYER, OnAutoplayer)
	ON_COMMAND(ID_TOOLBOX_STATISTICS, OnToolboxStatistics)
	ON_COMMAND(ID_TOOLBOX_PRESENT, OnToolboxPresent)
END_MESSAGE_MAP()

static UINT indicators[] =
{
	ID_SEPARATOR,           // status line indicator
	ID_INDICATOR_CAPS,
	ID_INDICATOR_NUM,
	ID_INDICATOR_SCRL,
};


// CMainFrame construction/destruction

CMainFrame::CMainFrame()
{
	m_pStatisticDlg = NULL;
	m_soccerMonior.init(this);
	m_logPlayer.init(this);
	m_displayer.init(this);
	m_analyzer.init(this);
}

CMainFrame::~CMainFrame()
{
	if( m_pStatisticDlg != NULL ){
		delete m_pStatisticDlg;
	}
}


int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if (CFrameWnd::OnCreate(lpCreateStruct) == -1)
		return -1;
	
	if (!m_wndToolBar.CreateEx(this) ||
		!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
	{
		TRACE0("Failed to create toolbar\n");
		return -1;      // fail to create
	}
	if (!m_wndSelectBar.CreateEx(this) ||
		!m_wndSelectBar.LoadToolBar(IDR_SELECT_TOOLBAR))
	{
		TRACE0("Failed to create selectbar\n");
		return -1;      // fail to create
	}
	if (!m_wndDlgBar.Create(this, IDR_MAINFRAME, 
		CBRS_ALIGN_TOP, AFX_IDW_DIALOGBAR))
	{
		TRACE0("Failed to create dialogbar\n");
		return -1;		// fail to create
	}

	if (!m_wndReBar.Create(this) ||
		!m_wndReBar.AddBar(&m_wndToolBar) ||
		!m_wndReBar.AddBar(&m_wndSelectBar) ||
		!m_wndReBar.AddBar(&m_wndDlgBar))
	{
		TRACE0("Failed to create rebar\n");
		return -1;      // fail to create
	}

	// TODO: Remove this if you don't want tool tips
	m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
		CBRS_TOOLTIPS | CBRS_FLYBY);
	m_wndSelectBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
		CBRS_TOOLTIPS | CBRS_FLYBY);

	
	// resize window to let it looks good
	CRect wndRect,rebarRect,dispRect;
	GetWindowRect(wndRect);
	m_wndReBar.GetWindowRect(rebarRect);
	dispRect = wndRect;
	wndRect.bottom = rebarRect.bottom;
	dispRect.top = rebarRect.bottom;
	MoveWindow(wndRect);
	m_displayer.MoveWindow(dispRect);
	return 0;
}

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
	if( !CFrameWnd::PreCreateWindow(cs) )
		return FALSE;
	// TODO: Modify the Window class or styles here by modifying
	//  the CREATESTRUCT cs

	cs.style = WS_OVERLAPPED | WS_CAPTION | FWS_ADDTOTITLE | WS_SYSMENU | WS_MINIMIZEBOX ;
	cs.dwExStyle &= ~WS_EX_CLIENTEDGE ;
	cs.dwExStyle |= WS_EX_ACCEPTFILES ;
	cs.dwExStyle |= WS_EX_TOPMOST ;
	
	cs.lpszClass = AfxRegisterWndClass(0);
	return TRUE;
}


// CMainFrame diagnostics

#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
	CFrameWnd::AssertValid();
}

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

#endif //_DEBUG


void CMainFrame::OnLogplayerCommand(UINT id)
{
	// TODO: Add your command handler code here
	switch(id){
		case ID_LOGPLAYER_LOAD:
			m_logPlayer.DoCommand(CmdLoad);
			break;
		case ID_LOGPLAYER_PLAY:
			m_logPlayer.DoCommand(CmdPlay);
			return;
		case ID_LOGPLAYER_STOP:
			m_logPlayer.DoCommand(CmdStop);
			return;
		case ID_LOGPLAYER_REVERSE:
			m_logPlayer.DoCommand(CmdReverse);
			return;
		case ID_LOGPLAYER_REWIND:
			m_logPlayer.DoCommand(CmdRewind);
			break;
		case ID_LOGPLAYER_FORWARD:
			m_logPlayer.DoCommand(CmdForward);
			break;
		case ID_LOGPLAYER_BACKWARD:
			m_logPlayer.DoCommand(CmdBackward);
			break;
		case ID_LOGPLAYER_ACCELERATE:
			m_logPlayer.DoCommand(CmdAccelerate);
			return;
		case ID_LOGPLAYER_DECELERATE:
			m_logPlayer.DoCommand(CmdDecelerate);
			return;
		case ID_LOGPLAYER_JUMPTO:
			m_logPlayer.DoCommand(CmdJump);
			break;
		default:
			break;
	};
	DisplayCycle(m_logPlayer.GetDisplayInfo());
}

void CMainFrame::WriteStatus(CString str)
{
	m_wndDlgBar.SetDlgItemText(IDC_STATUS,str);
}

void CMainFrame::OnClose()
{
	// TODO: Add your message handler code here and/or call default
	CRect wndRect;
	GetWindowRect(&wndRect);
	theApp.WriteProfileInt("MainFrame","Left",wndRect.left);
	theApp.WriteProfileInt("MainFrame","Top",wndRect.top);
	
	m_displayer.GetWindowRect(&wndRect);
	theApp.WriteProfileInt("Displayer","Left",wndRect.left);
	theApp.WriteProfileInt("Displayer","Top",wndRect.top);
	theApp.WriteProfileInt("Displayer","Right",wndRect.right);
	theApp.WriteProfileInt("Displayer","Bottom",wndRect.bottom);
	if( m_displayer.GetStyle() & WS_MAXIMIZE ){
		theApp.WriteProfileInt("Displayer","FullScreen",1);
	}else{
		theApp.WriteProfileInt("Displayer","FullScreen",0);
	}
	KillTimer(IDT_LOGPLAYER);
	m_displayer.DestroyWindow();
	CFrameWnd::OnClose();
}

void CMainFrame::OnTimer(UINT nIDEvent)
{
	// TODO: Add your message handler code here and/or call default
	if(nIDEvent == IDT_LOGPLAYER)
		DisplayCycle(m_logPlayer.GetDisplayInfo());
	CFrameWnd::OnTimer(nIDEvent);
}

void CMainFrame::OnUpdateLogplayerCommand(CCmdUI *pCmdUI)
{
	// TODO: Add your command update UI handler code here
	bool status = false;
	switch( pCmdUI->m_nID ){
	case ID_LOGPLAYER_LOAD:
		status = m_logPlayer.getCommandStatus(CmdLoad);
		break;
	case ID_LOGPLAYER_PLAY:
		status = m_logPlayer.getCommandStatus(CmdPlay);
		break;
	case ID_LOGPLAYER_STOP:
		status = m_logPlayer.getCommandStatus(CmdStop);
		break;
	case ID_LOGPLAYER_REVERSE:
		status = m_logPlayer.getCommandStatus(CmdReverse);
		break;
	case ID_LOGPLAYER_REWIND:
		status = m_logPlayer.getCommandStatus(CmdRewind);
		break;
	case ID_LOGPLAYER_FORWARD:
		status = m_logPlayer.getCommandStatus(CmdForward);
		break;
	case ID_LOGPLAYER_BACKWARD:
		status = m_logPlayer.getCommandStatus(CmdBackward);
		break;
	case ID_LOGPLAYER_ACCELERATE:
		status = m_logPlayer.getCommandStatus(CmdAccelerate);
		break;
	case ID_LOGPLAYER_DECELERATE:
		status = m_logPlayer.getCommandStatus(CmdDecelerate);
		break;
	case ID_LOGPLAYER_JUMPTO:
		status = m_logPlayer.getCommandStatus(CmdJump);
		break;
	default:
		break;
	};
	pCmdUI->Enable(status);
}

void CMainFrame::DisplayCycle(const cycle_info_t *pInfo)
{
	m_displayer.SetDisplayInfo(pInfo);
}
void CMainFrame::OnDisplayerCommand(UINT nID)
{
	// TODO: Add your command handler code here
	switch (nID){
		case ID_DISPLAYER_STAMINA:
			m_displayer.DoCommand(CmdStamina);
			break;
		case ID_DISPLAYER_KICKMARGIN:
			m_displayer.DoCommand(CmdKickmargin);
			break;
		case ID_DISPLAYER_NUMBER:
			m_displayer.DoCommand(CmdNumber);
			break;
		case ID_DISPLAYER_VIEWAREA:
			m_displayer.DoCommand(CmdViewarea);
			break;
		case ID_DISPLAYER_ENLARGEPLAYER:
			m_displayer.DoCommand(CmdEnlarge);
			break;
		case ID_DISPLAYER_REDUCEPLAYER:
			m_displayer.DoCommand(CmdReduce);
			break;
		case ID_DISPLAYER_VELOCITY:
			m_displayer.DoCommand(CmdVelocity);
			break;
		case ID_DISPLAYER_FULLSCREEN:
			m_displayer.DoCommand(CmdFullscreen);
			break;
		case ID_DISPLAYER_OFFSIDELINE:
			m_displayer.DoCommand(CmdOffsideLine);
			break;
		case ID_DISPLAYER_BALLDETAIL:
			m_displayer.DoCommand(CmdBallDetail);
			break;
		case ID_DISPLAYER_PASSCOURSE:
			m_displayer.DoCommand(CmdPassCourse);
			break;
		case ID_DISPLAYER_SELECTNONE:
			m_displayer.DoCommand(CmdSelectNone);
			break;
		default:
			break;
	}
}

void CMainFrame::OnUpdateDisplayerCommand(CCmdUI *pCmdUI)
{
	// TODO: Add your command update UI handler code here
	switch(pCmdUI->m_nID){
		case ID_DISPLAYER_REDUCEPLAYER:
			pCmdUI->Enable(m_displayer.GetStatus(CmdReduce));
			break;
		case ID_DISPLAYER_ENLARGEPLAYER:
			pCmdUI->Enable(m_displayer.GetStatus(CmdEnlarge));
			break;
		case ID_DISPLAYER_NUMBER:
			pCmdUI->SetCheck(m_displayer.GetStatus(CmdNumber));
			break;
		case ID_DISPLAYER_VIEWAREA:
			pCmdUI->SetCheck(m_displayer.GetStatus(CmdViewarea));
			break;
		case ID_DISPLAYER_STAMINA:
			pCmdUI->SetCheck(m_displayer.GetStatus(CmdStamina));
			break;
		case ID_DISPLAYER_KICKMARGIN:
			pCmdUI->SetCheck(m_displayer.GetStatus(CmdKickmargin));
			break;
		case ID_DISPLAYER_VELOCITY:
			pCmdUI->SetCheck(m_displayer.GetStatus(CmdVelocity));
			break;
		case ID_DISPLAYER_FULLSCREEN:
			pCmdUI->SetCheck(m_displayer.GetStatus(CmdFullscreen));
			break;
		case ID_DISPLAYER_OFFSIDELINE:
			pCmdUI->SetCheck(m_displayer.GetStatus(CmdOffsideLine));
			break;
		case ID_DISPLAYER_BALLDETAIL:
			pCmdUI->SetCheck(m_displayer.GetStatus(CmdBallDetail));
			break;
		case ID_DISPLAYER_PASSCOURSE:
			pCmdUI->SetCheck(m_displayer.GetStatus(CmdPassCourse));
			break;
		case ID_DISPLAYER_SELECTNONE:
			pCmdUI->Enable(m_displayer.GetStatus(CmdSelectNone));
			break;
		default:
			break;
	}
}

const server_params_t* CMainFrame::getServerParam() const
{
	return m_logPlayer.getServerParam();
}

const player_params_t* CMainFrame::getPlayerParam() const
{
	return m_logPlayer.getPlayerParam();
}

const player_type_t* CMainFrame::getPlayerType(UINT nType)
{
	return m_logPlayer.getPlayerType(nType);
}
void CMainFrame::OnTypeExplorer()
{
	// TODO: Add your command handler code here
	CTypeExplorer typeDlg;
	typeDlg.DoModal();
}

void CMainFrame::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	switch (nChar) {
	case VK_LEFT: // left
		SendMessage(WM_COMMAND,ID_LOGPLAYER_BACKWARD);
		break;
	case VK_RIGHT: // right
		SendMessage(WM_COMMAND,ID_LOGPLAYER_FORWARD);
		break;
	case VK_UP: // enlarge player
		SendMessage(WM_COMMAND,ID_DISPLAYER_ENLARGEPLAYER);
		break;
	case VK_DOWN:
		SendMessage(WM_COMMAND,ID_DISPLAYER_REDUCEPLAYER);
		break;
	case VK_F2:
		SendMessage(WM_COMMAND,ID_LOGPLAYER_LOAD);
		break;
	case VK_F5:
		SendMessage(WM_COMMAND,ID_LOGPLAYER_PLAY);
		break;
	case VK_TAB:
		SendMessage(WM_COMMAND,ID_SHOWDETAILS);
		break;
	case VK_DELETE: