Work/m68hc11/backup/MCUVIEW.CPP

#include <m68hc11/mcuview.hpp>
#include <m68hc11/m68hc11.hpp>
#include <statbar/statbarx.hpp>

MCUView::MCUView(void)
{
  mCreateHandler.setCallback(this,&MCUView::createHandler);
  mSizeHandler.setCallback(this,&MCUView::sizeHandler);
	mCloseHandler.setCallback(this,&MCUView::closeHandler);
	mDestroyHandler.setCallback(this,&MCUView::destroyHandler);
	mCommandHandler.setCallback(this,&MCUView::commandHandler);
	mCancelHandler.setCallback(this,&MCUView::cancelHandler);
	mStartHandler.setCallback(this,&MCUView::startHandler);
	mErrorEventHandler.setCallback(this,&MCUView::errorEventHandler);
	mMCUEventHandler.setCallback(this,&MCUView::mcuEventHandler);
	mMessageHandler.setCallback(this,&MCUView::messageHandler);
	MDIWindow::insertHandler(MDIWindow::CreateHandler,&mCreateHandler);
	MDIWindow::insertHandler(MDIWindow::SizeHandler,&mSizeHandler);
	MDIWindow::insertHandler(MDIWindow::CloseHandler,&mCloseHandler);
	MDIWindow::insertHandler(MDIWindow::DestroyHandler,&mDestroyHandler);
	MDIWindow::insertHandler(MDIWindow::CommandHandler,&mCommandHandler);
	MCUThread::setErrorEventHandler(&mErrorEventHandler);
	MCUThread::setMCUEventHandler(&mMCUEventHandler);
	MCUThread::setMessageHandler(&mMessageHandler);
}

MCUView::~MCUView()
{
	MDIWindow::removeHandler(MDIWindow::CreateHandler,&mCreateHandler);
	MDIWindow::removeHandler(MDIWindow::SizeHandler,&mSizeHandler);
	MDIWindow::removeHandler(MDIWindow::CloseHandler,&mCloseHandler);
	MDIWindow::removeHandler(MDIWindow::DestroyHandler,&mDestroyHandler);
	MDIWindow::removeHandler(MDIWindow::CommandHandler,&mCommandHandler);
	MCUThread::setErrorEventHandler(0);
	MCUThread::setMCUEventHandler(0);
	MCUThread::setMessageHandler(0);
}

CallbackData::ReturnType MCUView::createHandler(CallbackData &someCallbackData)
{
  mMCUDialog.setCancelHandler(&mCancelHandler);  
	mMCUDialog.setStartHandler(&mStartHandler);
  mMCUDialog.perform(*this);
	mStatusBar=::new StatusBarEx(*this,StatusBarID);
	mStatusBar.disposition(PointerDisposition::Delete);
	mStatusBar->setText("Press start and then switch on the device.");
  return FALSE;
}

CallbackData::ReturnType MCUView::sizeHandler(CallbackData &/*someCallbackData*/)
{
  return FALSE;
}

CallbackData::ReturnType MCUView::closeHandler(CallbackData &/*someCallbackData*/)
{
  return FALSE;
}

CallbackData::ReturnType MCUView::destroyHandler(CallbackData &/*someCallbackData*/)
{
  return FALSE;
}

CallbackData::ReturnType MCUView::commandHandler(CallbackData &/*someCallbackData*/)
{
  return FALSE;
}

CallbackData::ReturnType MCUView::cancelHandler(CallbackData &/*someCallbackData*/)
{
  isInEvents(false);
  MDIWindow::postMessage(*this,WM_CLOSE,0,0L);
	return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MCUView::startHandler(CallbackData &/*someCallbackData*/)
{
  mMCUDialog.enableStart(FALSE);
  listen(mStrPathBinary);
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MCUView::messageHandler(CallbackData &someCallbackData)
{
  mStatusBar->setText(*((String*)someCallbackData.lParam()));
  return (CallbackData::ReturnType)FALSE;
}

CallbackData::ReturnType MCUView::errorEventHandler(CallbackData &someCallbackData)
{
  switch(MCUThread::ErrorEvent(someCallbackData.wParam()))
	{
	  case MCUThread::ErrorFileOpen :
		  mStatusBar->setText(String(STRING_ERRORFILEOPEN)+*((String*)someCallbackData.lParam())+String("'."));
		  break;
		case MCUThread::ErrorPortOpen :
		  mStatusBar->setText(STRING_ERRORPORTOPEN);
		  break;
		case MCUThread::ErrorPortSettings :
		  mStatusBar->setText(STRING_ERRORPORTSETTINGS);
		  break;
		case MCUThread::ErrorTimeout :
		  mStatusBar->setText(STRING_ERRORTIMEOUT);
		  break;
		case MCUThread::ErrorReadError :
		  mStatusBar->setText(STRING_ERRORREADERROR);
		  break;
		case MCUThread::ErrorTalkBackFailure :
		  mStatusBar->setText(STRING_ERRORTALKBACKFAILURE);
		  break;
		case MCUThread::ErrorTalkBackData :
		  mStatusBar->setText(STRING_ERRORTALKBACKDATA);
		  break;
	}
  mMCUDialog.enableStart(TRUE);
  return FALSE;
}

CallbackData::ReturnType MCUView::mcuEventHandler(CallbackData &someCallbackData)
{
  switch(MCUThread::MCUEvent(someCallbackData.wParam()))
	{
	  case MCUThread::EventString :
		  handleStringData(someCallbackData);
			break;
	  case MCUThread::EventSingleByte :
		  handleSingleByteData(someCallbackData);
		  break;
		case MCUThread::EventDoubleByte :
		  handleEventDoubleByte(someCallbackData);
		  break;
		case MCUThread::EventQuadByte :
		  handleEventQuadByte(someCallbackData);
		  break;
		case MCUThread::EventVarByte :
		  handleEventVarByte(someCallbackData);
		  break;
		case MCUThread::EventRegs :
		  handleEventRegs(someCallbackData);
		  break;
		case MCUThread::EventEnd :
		  mMCUDialog.enableStart(TRUE);
		  break;
	}
  return FALSE;
}

void MCUView::handleEventRegs(CallbackData &someCallbackData)
{
  GlobalData<BYTE> &regData=(GlobalData<BYTE> &)*((GlobalData<BYTE> *)someCallbackData.lParam());
  mMCUDialog.setRegisters(regData);
}

void MCUView::handleEventVarByte(CallbackData &someCallbackData)
{
  GlobalData<BYTE> &byteData=(GlobalData<BYTE> &)*((GlobalData<BYTE> *)someCallbackData.lParam());
  mMCUDialog.setVarByteData(byteData);
}

void MCUView::handleEventQuadByte(CallbackData &someCallbackData)
{
  mMCUDialog.setQuadByteData(*((DWORD*)someCallbackData.lParam()));
}

void MCUView::handleEventDoubleByte(CallbackData &someCallbackData)
{
  mMCUDialog.setDoubleByteData(*((WORD*)someCallbackData.lParam()));
}

void MCUView::handleSingleByteData(CallbackData &someCallbackData)
{
  mMCUDialog.setSingleByteData(*((BYTE*)someCallbackData.lParam()));
}

void MCUView::handleStringData(CallbackData &someCallbackData)
{
  mMCUDialog.setStringData(*((String*)someCallbackData.lParam()));
}

// *** virtuals

void MCUView::preRegister(WNDCLASS &wndClass)
{
	wndClass.hbrBackground =(HBRUSH)COLOR_APPWORKSPACE;
}

void MCUView::preCreate(MDICREATESTRUCT &createStruct)
{
	createStruct.cx=InitialWidth;
	createStruct.cy=InitialHeight;
	createStruct.style^=WS_THICKFRAME;
}