Initial

m68hc11/backup/COMMCTRL.HPP

@@ -0,0 +1,228 @@
+#ifndef _COMMON_COMMCONTROL_HPP_
+#define _COMMON_COMMCONTROL_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_OPENFILE_HPP_
+#include <common/openfile.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_GLOBALDATA_HPP_
+#include <common/gdata.hpp>
+#endif
+#ifndef _M68HC11_DEVICECONTROLBLOCK_HPP_
+#include <m68hc11/dcb.hpp>
+#endif
+#ifndef _M68HC11_COMMSTATUS_HPP_
+#include <m68hc11/commstat.hpp>
+#endif
+#ifndef _THREAD_EVENT_HPP_
+#include <thread/event.hpp>
+#endif
+
+class CommControl
+{
+public:
+  enum {TimeOut=5000};
+  enum Port{PortCOM1,PortCOM2,PortCOM3,PortCOM4};
+	enum EventMask{EventBreak=EV_BREAK,EventCts=EV_CTS,EventDsr=EV_DSR,EventErr=EV_ERR,EventRing=EV_RING,
+	               EventRlsd=EV_RLSD,EventRxChar=EV_RXCHAR,EventRxFlag=EV_RXFLAG,EventTxEmpty=EV_TXEMPTY,
+								 EventAll=EV_BREAK|EV_CTS|EV_DSR|EV_ERR|EV_RING|EV_RLSD|EV_RXCHAR|EV_RXFLAG|EV_TXEMPTY};
+  CommControl(void);
+	virtual ~CommControl();
+	bool open(Port commPort,BOOL overlappedIO=false);
+	void close();
+	bool getDeviceControlBlock(DeviceControlBlock &deviceControlBlock)const;
+	bool setDeviceControlBlock(const DeviceControlBlock &deviceControlBlock)const;
+  bool setDeviceControlBlock(String strControlBlock)const;   // (ie) "baud=1200 parity=N data=8 stop=1"
+  DWORD readLine(String &strLine);
+	DWORD writeLine(const String &strLine)const;
+	DWORD read(void *pBuffer,int length,DWORD timeout=0L);
+	DWORD write(BYTE *pBuffer,int length)const;
+  DWORD write(GlobalData<BYTE> &sndBuffer);
+	DWORD enumerateDevices(Block<Port> &deviceList);
+	DWORD enumerateDevices(Block<String> &deviceList);
+	bool clearError(void)const;
+	bool clearError(CommStatus &commStatus)const;
+	bool clearBreak(void)const;
+	bool clearReceiveQueue(void);
+	bool readFully(GlobalData<BYTE> &dataBytes);
+  bool readFully(BYTE *pBuffer,DWORD byteCount);
+	bool setBreak(void)const;
+	bool waitEvent(DWORD &eventMask,DWORD timeout);
+	bool waitEvent(DWORD timeout=TimeOut);
+	bool waitForBreak(DWORD timeout=TimeOut);
+	bool waitForData(DWORD timeout=TimeOut);
+  bool waitForTransmit(DWORD timeout=TimeOut);
+  bool setEventMask(DWORD eventMask)const;
+  bool hasData(void);
+	bool isOkay(void)const;
+  static void portToString(CommControl::Port port,String &strPort);
+  static CommControl::Port stringToPort(const String &strPort);
+  static void showBytes(GlobalData<BYTE> rcvBytes);
+  static void showBytes(BYTE *pBuffer,DWORD byteCount);
+private:
+  CommControl(const CommControl &someCommControl);
+	CommControl &operator=(const CommControl &someCommControl);
+  void showError(DWORD errorMask)const;
+
+  FileHandle mCommDevice;
+	Block<String> mStrPorts;
+	CommStatus mCommStatus;
+	Event mIOEvent;
+	Overlapped mOverlapped;
+};
+
+inline
+CommControl::CommControl(void)
+{
+  mOverlapped.event((HANDLE)mIOEvent);
+  mStrPorts.insert(&String("\\.\\COM1"));
+  mStrPorts.insert(&String("\\.\\COM2"));
+  mStrPorts.insert(&String("\\.\\COM3"));
+  mStrPorts.insert(&String("\\.\\COM4"));
+}
+
+inline
+CommControl::CommControl(const CommControl &someCommControl)
+{ // private implementation
+  *this=someCommControl;
+}
+
+inline
+CommControl::~CommControl()
+{
+  close();
+}
+
+inline
+CommControl &CommControl::operator=(const CommControl &/*someCommControl*/)
+{ // private implementation
+  return *this;
+}
+
+inline
+bool CommControl::open(Port commPort,BOOL overlappedIO)
+{
+  close();
+	mCommDevice.open(mStrPorts[commPort],FileHandle::ReadWrite,FileHandle::ShareNone,FileHandle::Open,(overlappedIO?FileHandle::FlagOverlapped:FileHandle::Normal));
+	return isOkay();
+}
+
+inline
+void CommControl::close(void)
+{
+  if(!isOkay())return;
+	mCommDevice.close();
+}
+
+inline
+DWORD CommControl::readLine(String &strLine)
+{
+  strLine.reserve(1024);
+  if(!isOkay())return FALSE;
+	clearError(mCommStatus);
+	if(!mCommStatus.bytesInReceiveQueue())return FALSE;
+	return mCommDevice.getLine(strLine);
+}
+
+inline
+DWORD CommControl::writeLine(const String &strLine)const
+{
+  if(!isOkay()||strLine.isNull())return FALSE;
+	return mCommDevice.writeLine(strLine);
+}
+
+inline
+DWORD CommControl::write(GlobalData<BYTE> &sndBuffer)
+{
+  if(!isOkay()||!sndBuffer.size())return 0;
+	return write(&sndBuffer[0],sndBuffer.size());
+}
+
+inline
+DWORD CommControl::write(BYTE *pBuffer,int length)const
+{
+  if(!isOkay()||!pBuffer||!length)return 0;
+	return mCommDevice.write(pBuffer,length);
+}
+
+inline
+bool CommControl::setBreak(void)const
+{
+  if(!isOkay())return false;
+	return ::SetCommBreak((HANDLE)mCommDevice);
+}
+
+inline
+bool CommControl::clearBreak(void)const
+{
+  if(!isOkay())return false;
+	return ::ClearCommBreak((HANDLE)mCommDevice);
+}
+
+inline
+bool CommControl::getDeviceControlBlock(DeviceControlBlock &deviceControlBlock)const
+{
+  if(!isOkay())return false;
+	return ::GetCommState((HANDLE)mCommDevice,&((DeviceControlBlock&)deviceControlBlock).getDCB());
+}
+
+inline
+bool CommControl::setDeviceControlBlock(const DeviceControlBlock &deviceControlBlock)const
+{
+  if(!isOkay())return false;
+	return ::SetCommState((HANDLE)mCommDevice,&((DeviceControlBlock&)deviceControlBlock).getDCB());
+}
+
+inline
+bool CommControl::setDeviceControlBlock(String strControlBlock)const   // (ie) "baud=1200 parity=N data=8 stop=1"
+{
+  DeviceControlBlock deviceControlBlock;
+  if(!::BuildCommDCB(strControlBlock.str(),&((DeviceControlBlock&)deviceControlBlock).getDCB()))return false;
+  return ::SetCommState((HANDLE)mCommDevice,&((DeviceControlBlock&)deviceControlBlock).getDCB()); 
+}
+
+inline
+bool CommControl::setEventMask(DWORD eventMask)const
+{
+  if(!isOkay())return false;
+	return ::SetCommMask((HANDLE)mCommDevice,eventMask);
+}
+
+inline
+bool CommControl::waitEvent(DWORD timeout)
+{
+  DWORD eventMask;
+	return waitEvent(eventMask,timeout);
+}
+
+inline
+bool CommControl::waitForBreak(DWORD timeout)
+{
+  if(!isOkay())return false;
+	setEventMask(EventBreak);
+	return waitEvent(timeout);
+}
+
+inline
+bool CommControl::waitForData(DWORD timeout)
+{
+  if(!isOkay())return false;
+	setEventMask(EventRxChar);
+	return waitEvent(timeout);
+}
+
+inline
+bool CommControl::waitForTransmit(DWORD timeout)
+{
+  if(!isOkay())return false;
+	setEventMask(EventTxEmpty);
+	return waitEvent(timeout);
+}
+#endif

m68hc11/backup/COMMSTAT.HPP

@@ -0,0 +1,213 @@
+#ifndef _M68HC11_COMMSTATUS_HPP_
+#define _M68HC11_COMMSTATUS_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class CommStatus : private _COMSTAT
+{
+public:
+  CommStatus(void);
+	CommStatus(const CommStatus &someCommStatus);
+	virtual ~CommStatus();
+	CommStatus &operator=(const CommStatus &someCommStatus);
+	BOOL operator==(const CommStatus &someCommStatus)const;
+	BOOL waitingForCts(void)const;
+	BOOL waitingForDsr(void)const;
+	BOOL waitingForRlsd(void)const;
+	BOOL waitingRcvdXOff(void)const;
+	BOOL waitingSentXOff(void)const;
+	BOOL waitingRcvdEof(void)const;
+	BOOL waitingForTx(void)const;
+	DWORD bytesInReceiveQueue(void)const;
+	DWORD bytesInSendQueue(void)const;
+	_COMSTAT &getCOMSTAT(void);
+private:
+	void waitingForCts(BOOL waitingForCts);
+	void waitingForDsr(BOOL waitingForDsr);
+	void waitingForRlsd(BOOL waitingForRlsd);
+	void waitingRcvdXOff(BOOL waitingRcvdXOff);
+	void waitingSentXOff(BOOL waitingSentXOff);
+	void waitingRcvdEof(BOOL waitingRcvdEof);
+	void waitingForTx(BOOL waitingForTx);
+	void bytesInReceiveQueue(DWORD bytesInReceiveQueue);
+	void bytesInSendQueue(DWORD bytesInSendQueue);
+  void setZero(void);
+};
+
+inline
+CommStatus::CommStatus(void)
+{
+  setZero();
+}
+
+inline
+CommStatus::CommStatus(const CommStatus &someCommStatus)
+{
+  *this=someCommStatus;
+}
+
+inline
+CommStatus::~CommStatus()
+{
+}
+
+inline
+CommStatus &CommStatus::operator=(const CommStatus &someCommStatus)
+{
+  waitingForCts(someCommStatus.waitingForCts());
+  waitingForDsr(someCommStatus.waitingForDsr());
+	waitingForRlsd(someCommStatus.waitingForRlsd());
+	waitingRcvdXOff(someCommStatus.waitingRcvdXOff());
+	waitingSentXOff(someCommStatus.waitingSentXOff());
+	waitingRcvdEof(someCommStatus.waitingRcvdEof());
+	waitingForTx(someCommStatus.waitingForTx());
+	bytesInReceiveQueue(someCommStatus.bytesInReceiveQueue());
+	bytesInSendQueue(someCommStatus.bytesInSendQueue());
+	return *this;
+}
+
+inline
+BOOL CommStatus::operator==(const CommStatus &someCommStatus)const
+{
+  return (waitingForCts()==someCommStatus.waitingForCts()&&
+          waitingForDsr()==someCommStatus.waitingForDsr()&&
+	        waitingForRlsd()==someCommStatus.waitingForRlsd()&&
+	        waitingRcvdXOff()==someCommStatus.waitingRcvdXOff()&&
+	        waitingSentXOff()==someCommStatus.waitingSentXOff()&&
+	        waitingRcvdEof()==someCommStatus.waitingRcvdEof()&&
+	        waitingForTx()==someCommStatus.waitingForTx()&&
+	        bytesInReceiveQueue()==someCommStatus.bytesInReceiveQueue()&&
+	        bytesInSendQueue()==someCommStatus.bytesInSendQueue());
+}
+
+inline
+BOOL CommStatus::waitingForCts(void)const
+{
+  return _COMSTAT::fCtsHold;
+}
+
+inline
+void CommStatus::waitingForCts(BOOL waitingForCts)
+{
+  _COMSTAT::fCtsHold=waitingForCts;
+}
+
+inline
+BOOL CommStatus::waitingForDsr(void)const
+{
+  return _COMSTAT::fDsrHold;
+}
+
+inline
+void CommStatus::waitingForDsr(BOOL waitingForDsr)
+{
+  _COMSTAT::fDsrHold=waitingForDsr;
+}
+
+inline
+BOOL CommStatus::waitingForRlsd(void)const
+{
+  return _COMSTAT::fRlsdHold;
+}
+
+inline
+void CommStatus::waitingForRlsd(BOOL waitingForRlsd)
+{
+  _COMSTAT::fRlsdHold=waitingForRlsd;
+}
+
+inline
+BOOL CommStatus::waitingRcvdXOff(void)const
+{
+  return _COMSTAT::fXoffHold;
+}
+
+inline
+void CommStatus::waitingRcvdXOff(BOOL waitingRcvdXOff)
+{
+  _COMSTAT::fXoffHold=waitingRcvdXOff;
+}
+
+inline
+BOOL CommStatus::waitingSentXOff(void)const
+{
+  return _COMSTAT::fXoffSent;
+}
+
+inline
+void CommStatus::waitingSentXOff(BOOL waitingSentXOff)
+{
+  _COMSTAT::fXoffSent=waitingSentXOff;
+}
+
+inline
+BOOL CommStatus::waitingRcvdEof(void)const
+{
+  return _COMSTAT::fEof;
+}
+
+inline
+void CommStatus::waitingRcvdEof(BOOL waitingRcvdEof)
+{
+  _COMSTAT::fEof=waitingRcvdEof;
+
+}
+
+inline
+BOOL CommStatus::waitingForTx(void)const
+{
+  return _COMSTAT::fTxim;
+}
+
+inline
+void CommStatus::waitingForTx(BOOL waitingForTx)
+{
+  _COMSTAT::fTxim=waitingForTx;
+}
+
+inline
+DWORD CommStatus::bytesInReceiveQueue(void)const
+{
+  return _COMSTAT::cbInQue;
+}
+
+inline
+void CommStatus::bytesInReceiveQueue(DWORD bytesInReceiveQueue)
+{
+  _COMSTAT::cbInQue=bytesInReceiveQueue;
+}
+
+inline
+DWORD CommStatus::bytesInSendQueue(void)const
+{
+  return _COMSTAT::cbOutQue;
+}
+
+inline
+void CommStatus::bytesInSendQueue(DWORD bytesInSendQueue)
+{
+  _COMSTAT::cbOutQue=bytesInSendQueue;
+}
+
+inline
+_COMSTAT &CommStatus::getCOMSTAT(void)
+{
+  return *this;
+}
+
+inline
+void CommStatus::setZero(void)
+{
+  _COMSTAT::fCtsHold=0;
+	_COMSTAT::fDsrHold=0;
+	_COMSTAT::fRlsdHold=0;
+	_COMSTAT::fXoffHold=0;
+	_COMSTAT::fXoffSent=0;
+	_COMSTAT::fEof=0;
+	_COMSTAT::fTxim=0;
+	_COMSTAT::fReserved=0;
+	_COMSTAT::cbInQue=0;
+	_COMSTAT::cbOutQue=0;
+}
+#endif

m68hc11/backup/DCB.CPP

@@ -0,0 +1,318 @@
+#include <m68hc11/dcb.hpp>
+
+DeviceControlBlock::DeviceControlBlock(void)
+{
+  setZero();
+}
+
+DeviceControlBlock::DeviceControlBlock(const DeviceControlBlock &someDeviceControlBlock)
+{
+	*this=someDeviceControlBlock;
+}
+
+DeviceControlBlock::~DeviceControlBlock()
+{
+}
+
+DeviceControlBlock &DeviceControlBlock::operator=(const DeviceControlBlock &someDeviceControlBlock)
+{
+  baudRate(someDeviceControlBlock.baudRate());
+	binaryEnabled(someDeviceControlBlock.binaryEnabled());
+	enableParity(someDeviceControlBlock.enableParity());
+	ctsFlowControlOutMonitor(someDeviceControlBlock.ctsFlowControlOutMonitor());
+	dsrFlowControlOutMonitor(someDeviceControlBlock.dsrFlowControlOutMonitor());
+	dtrControl(someDeviceControlBlock.dtrControl());
+	dsrSensitivityEnable(someDeviceControlBlock.dsrSensitivityEnable());
+	continueOnXOff(someDeviceControlBlock.continueOnXOff());
+	xonXOffEnableTransmit(someDeviceControlBlock.xonXOffEnableTransmit());
+	xonXOffEnableReceive(someDeviceControlBlock.xonXOffEnableReceive());
+	errorCharEnable(someDeviceControlBlock.errorCharEnable());
+	discardNullEnable(someDeviceControlBlock.discardNullEnable());
+	rtsControl(someDeviceControlBlock.rtsControl());
+	abortOnErrorEnable(someDeviceControlBlock.abortOnErrorEnable());
+	xonLimit(someDeviceControlBlock.xonLimit());
+	xoffLimit(someDeviceControlBlock.xoffLimit());
+	dataBits(someDeviceControlBlock.dataBits());
+	parity(someDeviceControlBlock.parity());
+	stopBits(someDeviceControlBlock.stopBits());
+	xonChar(someDeviceControlBlock.xonChar());
+	xoffChar(someDeviceControlBlock.xoffChar());
+	errorChar(someDeviceControlBlock.errorChar());
+	eofChar(someDeviceControlBlock.eofChar());
+	evtChar(someDeviceControlBlock.evtChar());
+  return *this;
+}
+
+BOOL DeviceControlBlock::operator==(const DeviceControlBlock &someDeviceControlBlock)
+{
+  return(baudRate()==someDeviceControlBlock.baudRate()&&
+	       binaryEnabled()==someDeviceControlBlock.binaryEnabled()&&
+	       enableParity()==someDeviceControlBlock.enableParity()&&
+	       ctsFlowControlOutMonitor()==someDeviceControlBlock.ctsFlowControlOutMonitor()&&
+	       dsrFlowControlOutMonitor()==someDeviceControlBlock.dsrFlowControlOutMonitor()&&
+	       dtrControl()==someDeviceControlBlock.dtrControl()&&
+	       dsrSensitivityEnable()==someDeviceControlBlock.dsrSensitivityEnable()&&
+	       continueOnXOff()==someDeviceControlBlock.continueOnXOff()&&
+	       xonXOffEnableTransmit()==someDeviceControlBlock.xonXOffEnableTransmit()&&
+	       xonXOffEnableReceive()==someDeviceControlBlock.xonXOffEnableReceive()&&
+	       errorCharEnable()==someDeviceControlBlock.errorCharEnable()&&
+	       discardNullEnable()==someDeviceControlBlock.discardNullEnable()&&
+	       rtsControl()==someDeviceControlBlock.rtsControl()&&
+	       abortOnErrorEnable()==someDeviceControlBlock.abortOnErrorEnable()&&
+	       xonLimit()==someDeviceControlBlock.xonLimit()&&
+	       xoffLimit()==someDeviceControlBlock.xoffLimit()&&
+	       dataBits()==someDeviceControlBlock.dataBits()&&
+	       parity()==someDeviceControlBlock.parity()&&
+	       stopBits()==someDeviceControlBlock.stopBits()&&
+	       xonChar()==someDeviceControlBlock.xonChar()&&
+	       xoffChar()==someDeviceControlBlock.xoffChar()&&
+	       errorChar()==someDeviceControlBlock.errorChar()&&
+	       eofChar()==someDeviceControlBlock.eofChar()&&
+	       evtChar()==someDeviceControlBlock.evtChar());
+}
+
+DWORD DeviceControlBlock::baudRate(void)const
+{
+  return _DCB::BaudRate;
+}
+
+void DeviceControlBlock::baudRate(DWORD baudRate)
+{
+  _DCB::BaudRate=baudRate;
+}
+
+BOOL DeviceControlBlock::binaryEnabled(void)const
+{
+  return _DCB::fBinary;
+}
+
+void DeviceControlBlock::binaryEnabled(BOOL binaryEnabled)
+{
+  _DCB::fBinary=binaryEnabled;
+}
+
+BOOL DeviceControlBlock::enableParity(void)const
+{
+  return _DCB::fParity;
+}
+
+void DeviceControlBlock::enableParity(BOOL parity)
+{
+  _DCB::fParity=parity;
+}
+
+BOOL DeviceControlBlock::ctsFlowControlOutMonitor(void)const
+{
+  return _DCB::fOutxCtsFlow;
+}
+
+void DeviceControlBlock::ctsFlowControlOutMonitor(BOOL ctsFlowControlOut)
+{
+  _DCB::fOutxCtsFlow=ctsFlowControlOut;
+}
+
+BOOL DeviceControlBlock::dsrFlowControlOutMonitor(void)const
+{
+  return _DCB::fOutxDsrFlow;
+}
+
+void DeviceControlBlock::dsrFlowControlOutMonitor(BOOL dsrFlowControlOut)
+{
+  _DCB::fOutxDsrFlow=dsrFlowControlOut;
+}
+
+DeviceControlBlock::DtrControl DeviceControlBlock::dtrControl(void)const
+{
+  return DtrControl(_DCB::fDtrControl);
+}
+
+void DeviceControlBlock::dtrControl(DtrControl dtrControl)
+{
+  _DCB::fDtrControl=(DWORD)dtrControl;
+}
+
+BOOL DeviceControlBlock::dsrSensitivityEnable(void)const
+{
+  return _DCB::fDsrSensitivity;
+}
+
+void DeviceControlBlock::dsrSensitivityEnable(BOOL dsrSensitivityEnable)
+{
+  _DCB::fDsrSensitivity=dsrSensitivityEnable;
+}
+
+BOOL DeviceControlBlock::continueOnXOff(void)const
+{
+  return _DCB::fTXContinueOnXoff;
+}
+
+void DeviceControlBlock::continueOnXOff(BOOL continueOnXOff)
+{
+  _DCB::fTXContinueOnXoff=continueOnXOff;
+}
+
+BOOL DeviceControlBlock::xonXOffEnableTransmit(void)const
+{
+  return _DCB::fOutX;
+}
+
+void DeviceControlBlock::xonXOffEnableTransmit(BOOL xonXOffEnable)
+{
+  _DCB::fOutX=xonXOffEnable;
+}
+
+BOOL DeviceControlBlock::xonXOffEnableReceive(void)const
+{
+  return _DCB::fInX;
+}
+
+void DeviceControlBlock::xonXOffEnableReceive(BOOL xonXOffEnable)
+{
+  _DCB::fInX=xonXOffEnable;
+}
+
+BOOL DeviceControlBlock::errorCharEnable(void)const
+{
+  return _DCB::fErrorChar;
+}
+
+void DeviceControlBlock::errorCharEnable(BOOL errorCharEnable)
+{
+  _DCB::fErrorChar=errorCharEnable;
+}
+
+BOOL DeviceControlBlock::discardNullEnable(void)const
+{
+  return _DCB::fNull;
+}
+
+void DeviceControlBlock::discardNullEnable(BOOL discardNullEnable)
+{
+  _DCB::fNull=discardNullEnable;
+}
+
+DeviceControlBlock::RtsControl DeviceControlBlock::rtsControl(void)const
+{
+  return RtsControl(_DCB::fRtsControl);
+}
+
+void DeviceControlBlock::rtsControl(RtsControl rtsControl)
+{
+  _DCB::fRtsControl=(DWORD)rtsControl;
+}
+
+BOOL DeviceControlBlock::abortOnErrorEnable(void)const
+{
+  return _DCB::fAbortOnError;
+}
+
+void DeviceControlBlock::abortOnErrorEnable(BOOL abortOnError)
+{
+  _DCB::fAbortOnError=abortOnError;
+}
+
+WORD DeviceControlBlock::xonLimit(void)const
+{
+  return _DCB::XonLim;
+}
+
+void DeviceControlBlock::xonLimit(WORD xonLimit)
+{
+  _DCB::XonLim=xonLimit;
+}
+
+WORD DeviceControlBlock::xoffLimit(void)const
+{
+  return _DCB::XoffLim;
+}
+
+void DeviceControlBlock::xoffLimit(WORD xoffLimit)
+{
+  _DCB::XoffLim=xoffLimit;
+}
+
+BYTE DeviceControlBlock::dataBits(void)const
+{
+  return _DCB::ByteSize;
+}
+
+void DeviceControlBlock::dataBits(BYTE dataBits)
+{
+  _DCB::ByteSize=dataBits;
+}
+
+DeviceControlBlock::Parity DeviceControlBlock::parity(void)const
+{
+  return Parity(_DCB::Parity);
+}
+
+void DeviceControlBlock::parity(Parity parity)
+{
+  _DCB::Parity=BYTE(parity);
+}
+
+BYTE DeviceControlBlock::stopBits(void)const
+{
+  return _DCB::StopBits;
+}
+
+void DeviceControlBlock::stopBits(BYTE stopBits)
+{
+  _DCB::StopBits=stopBits;
+}
+
+char DeviceControlBlock::xonChar(void)const
+{
+  return _DCB::XonChar;
+}
+
+void DeviceControlBlock::xonChar(char xonChar)
+{
+  _DCB::XonChar=xonChar;
+}
+
+char DeviceControlBlock::xoffChar(void)const
+{
+  return _DCB::XoffChar;
+}
+
+void DeviceControlBlock::xoffChar(char xoffChar)
+{
+  _DCB::XoffChar=xoffChar;
+}
+
+char DeviceControlBlock::errorChar(void)const
+{
+  return _DCB::ErrorChar;
+}
+
+void DeviceControlBlock::errorChar(char errorChar)
+{
+  _DCB::ErrorChar=errorChar;
+}
+
+char DeviceControlBlock::eofChar(void)const
+{
+  return _DCB::EofChar;
+}
+
+void DeviceControlBlock::eofChar(char eofChar)
+{
+  _DCB::EofChar;
+}
+
+char DeviceControlBlock::evtChar(void)const
+{
+  return _DCB::EvtChar;
+}
+
+void DeviceControlBlock::evtChar(char evtChar)
+{
+  _DCB::EvtChar=evtChar;
+}
+
+void DeviceControlBlock::setZero(void)
+{
+  ::memset(&(_DCB&)*this,0,sizeof(_DCB));
+	_DCB::DCBlength=sizeof(_DCB);
+}

m68hc11/backup/DCB.HPP

@@ -0,0 +1,79 @@
+#ifndef _M68HC11_DEVICECONTROLBLOCK_HPP_
+#define _M68HC11_DEVICECONTROLBLOCK_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_STDLIB_HPP_
+#include <common/stdlib.hpp>
+#endif
+
+class DeviceControlBlock : private _DCB
+{
+public:
+  enum DtrControl{DtrControlDisable=DTR_CONTROL_DISABLE,DtrControlEnable=DTR_CONTROL_ENABLE,DtrControlHandshake=DTR_CONTROL_HANDSHAKE};
+	enum RtsControl{RtsControlDisable=RTS_CONTROL_DISABLE,RtsControlEnable=RTS_CONTROL_ENABLE,RtsControlHandshake=RTS_CONTROL_HANDSHAKE,RtsControlToggle=RTS_CONTROL_TOGGLE};
+	enum Parity{ParityNone,ParityOdd,ParityEven,ParityMark};
+  DeviceControlBlock(void);
+	DeviceControlBlock(const DeviceControlBlock &someDeviceControlBlock);
+	virtual ~DeviceControlBlock();
+	DeviceControlBlock &operator=(const DeviceControlBlock &someDeviceControlBlock);
+	BOOL operator==(const DeviceControlBlock &someDeviceControlBlock);
+	DWORD baudRate(void)const;
+	void baudRate(DWORD baudRate);
+	BOOL binaryEnabled(void)const;
+	void binaryEnabled(BOOL binaryEnabled);
+	BOOL enableParity(void)const;
+	void enableParity(BOOL parity);
+	BOOL ctsFlowControlOutMonitor(void)const;
+	void ctsFlowControlOutMonitor(BOOL ctsFlowControlOut);
+	BOOL dsrFlowControlOutMonitor(void)const;
+	void dsrFlowControlOutMonitor(BOOL dsrFlowControlOut);
+	DtrControl dtrControl(void)const;
+	void dtrControl(DtrControl dtrControl);
+	BOOL dsrSensitivityEnable(void)const;
+	void dsrSensitivityEnable(BOOL dsrSensitivityEnable);
+	BOOL continueOnXOff(void)const;
+	void continueOnXOff(BOOL continueOnXOff);
+	BOOL xonXOffEnableTransmit(void)const;
+	void xonXOffEnableTransmit(BOOL xonXOffEnable);
+	BOOL xonXOffEnableReceive(void)const;
+	void xonXOffEnableReceive(BOOL xonXOffEnable);
+	BOOL errorCharEnable(void)const;
+	void errorCharEnable(BOOL errorCharEnable);
+	BOOL discardNullEnable(void)const;
+	void discardNullEnable(BOOL discardNullEnable);
+	RtsControl rtsControl(void)const;
+	void rtsControl(RtsControl rtsControl);
+	BOOL abortOnErrorEnable(void)const;
+	void abortOnErrorEnable(BOOL abortOnError);
+	WORD xonLimit(void)const;
+	void xonLimit(WORD xonLimit);
+	WORD xoffLimit(void)const;
+	void xoffLimit(WORD xoffLimit);
+	BYTE dataBits(void)const;
+	void dataBits(BYTE dataBits);
+	Parity parity(void)const;
+	void parity(Parity parity);
+	BYTE stopBits(void)const;
+	void stopBits(BYTE stopBits);
+	char xonChar(void)const;
+	void xonChar(char xonChar);
+	char xoffChar(void)const;
+	void xoffChar(char xoffChar);
+	char errorChar(void)const;
+	void errorChar(char errorChar);
+	char eofChar(void)const;
+	void eofChar(char eofChar);
+	char evtChar(void)const;
+	void evtChar(char evtChar);
+	_DCB &getDCB(void);
+private:
+  void setZero(void);
+};
+
+inline
+_DCB &DeviceControlBlock::getDCB(void)
+{
+  return *this;
+}
+#endif

m68hc11/backup/Editfnd.cpp

@@ -0,0 +1,51 @@
+#include <m68hc11/editfnd.hpp>
+
+EditFind::EditFind(void)
+{
+}
+
+EditFind::~EditFind()
+{
+}
+
+// virtuals
+
+void EditFind::init(void)
+{
+  CharRange searchRange;
+
+	searchRange.posMin(0);
+	searchRange.posMax(0);
+	mFindTextEx.searchRange(searchRange);
+}
+
+void EditFind::leaveEdit(const String &strText)
+{
+  findNext();
+}
+
+void EditFind::find(void)
+{
+  findNext();
+}
+
+void EditFind::findNext(void)
+{
+  String currText;
+
+	getText(currText);
+	if(currText.isNull())return;
+	if(!(currText==lastSearchText()))lastFindIndex(-1);
+	mFindTextEx.strFind(currText);
+	if(!mFindTextEx.searchRange().posMin()&&!mFindTextEx.searchRange().posMax())mFindTextEx.searchRange(CharRange(0,-1));
+	else 
+	{
+	  CharRange searchRange(mFindTextEx.foundRange());
+		searchRange.posMin(searchRange.posMax());
+		searchRange.posMax(-1);
+		mFindTextEx.searchRange(searchRange);
+	}
+//	mRichEditControl->setFocus();
+	mRichEditControl->findText(mFindTextEx);
+//	setFocus();
+}

m68hc11/backup/Editfnd.hpp

@@ -0,0 +1,35 @@
+#ifndef _M68HC11_EDITFIND_HPP_
+#define _M68HC11_EDITFIND_HPP_
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _COMMON_RICHEDIT_HPP_
+#include <common/richedit.hpp>
+#endif
+#ifndef _M68HC11_FIND_HPP_
+#include <m68hc11/find.hpp>
+#endif
+
+class EditFind : private Find
+{
+public:
+  EditFind(void);
+	virtual ~EditFind();
+	void perform(GUIWindow &parentWindow,RichEditControl &richEditControl);
+protected:
+	virtual void findNext(void);
+  virtual void init(void);
+	virtual void find(void);
+	virtual void leaveEdit(const String &strText);
+private:
+  SmartPointer<RichEditControl> mRichEditControl;
+	FindTextEx mFindTextEx;
+};
+
+inline
+void EditFind::perform(GUIWindow &parentWindow,RichEditControl &richEditControl)
+{
+  mRichEditControl=&richEditControl;
+  Find::perform(parentWindow);
+}
+#endif

m68hc11/backup/Find.cpp

@@ -0,0 +1,192 @@
+#include <m68hc11/find.hpp>
+#include <common/keydata.hpp>
+
+Find::Find(void)
+: mLastFindIndex(-1)
+{
+  mKeyDownHandler.setCallback(this,&Find::keyDownHandler);
+	mDlgCodeHandler.setCallback(this,&Find::dlgCodeHandler);
+	mEditHook.insertHandler(WinHookProc::KeyDownHandler,&mKeyDownHandler);
+	mEditHook.insertHandler(WinHookProc::DialogCodeHandler,&mDlgCodeHandler);
+}
+
+Find::Find(const Find &find)
+{ // private implementation
+  *this=find;
+}
+
+Find::~Find()
+{
+  mEditHook.removeHandler(WinHookProc::KeyDownHandler,&mKeyDownHandler);
+	mEditHook.removeHandler(WinHookProc::DialogCodeHandler,&mDlgCodeHandler);
+}
+
+Find &Find::operator=(const Find &find)
+{ // private implementation
+  return *this;
+}
+
+void Find::perform(GUIWindow &parentWindow)
+{
+  create(parentWindow);
+}
+
+void Find::create(GUIWindow &parentWindow)
+{
+	String staticName("STATIC");
+	String editName("EDIT");
+	String buttonName("BUTTON");
+
+	DialogTemplate dlgTemplate;
+	DialogItemTemplate staticFind;
+	DialogItemTemplate editFind;
+	DialogItemTemplate cancelButton;
+	DialogItemTemplate fnButton;
+  DialogItemTemplate wmButton;
+
+	dlgTemplate.titleText("Find");
+	dlgTemplate.posRect(Rect(10,73,236,62));
+	dlgTemplate.pointSize(8);
+	dlgTemplate.typeFace("Helv");
+	dlgTemplate.style(DS_MODALFRAME|WS_VISIBLE|WS_CAPTION|DS_3DLOOK|WS_SYSMENU|DS_SETFONT|WS_POPUP); // WS_POPUP
+
+	staticFind.className(staticName);
+	staticFind.titleText("Fi&nd what:");
+	staticFind.style(WS_CHILD|WS_VISIBLE);
+	staticFind.posRect(Rect(4,8,42,8));
+	staticFind.itemID(-1);
+
+	editFind.className(editName);
+	editFind.titleText("");
+	editFind.style(WS_CHILD|WS_VISIBLE|ES_AUTOHSCROLL|WS_BORDER|WS_TABSTOP|WS_GROUP);
+	editFind.posRect(Rect(47,7,128,12));
+	editFind.itemID(FindText);
+
+	fnButton.className(buttonName);
+	fnButton.titleText("&Find Next");
+	fnButton.style(WS_VISIBLE|WS_CHILD|WS_TABSTOP|WS_GROUP|BS_DEFPUSHBUTTON);
+	fnButton.posRect(Rect(182,5,50,14));
+	fnButton.itemID(FindNext);
+
+	wmButton.className(buttonName);
+	wmButton.titleText("Match &whole word only");
+	wmButton.style(WS_VISIBLE|WS_CHILD|WS_TABSTOP|BS_AUTOCHECKBOX|WS_GROUP);
+	wmButton.posRect(Rect(4,26,100,12));
+	wmButton.itemID(FindWhole);
+
+	cancelButton.className(buttonName);
+	cancelButton.titleText("Cancel");
+	cancelButton.style(WS_VISIBLE|WS_CHILD|WS_TABSTOP|WS_GROUP);
+	cancelButton.posRect(Rect(182,23,50,14));
+	cancelButton.itemID(CancelFind);
+
+	dlgTemplate+=staticFind;
+	dlgTemplate+=editFind;
+	dlgTemplate+=cancelButton;
+	dlgTemplate+=fnButton;
+	dlgTemplate+=wmButton;
+  createDialog(parentWindow,dlgTemplate,DynamicDialog::ModelessDialog);
+}
+
+CallbackData::ReturnType Find::keyDownHandler(CallbackData &someCallbackData)
+{
+  KeyData keyData(someCallbackData);
+	String strEditText;
+
+  if(keyData.isEscapeKey())GUIWindow::postMessage(*this,WM_CLOSE,0,0L);
+	else if(keyData.isEnterKey())
+	{
+	  getText(strEditText);
+	  leaveEdit(strEditText);
+	}
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType Find::dlgCodeHandler(CallbackData &someCallbackData)
+{
+  return (CallbackData::ReturnType)DLGC_WANTALLKEYS;
+}
+
+WORD Find::dlgCommand(DWORD commandID,CallbackData &someCallbackData)
+{
+	switch(commandID)
+	{
+		case FindText :
+			break;
+		case FindNext :
+			handleFindNext();
+			break;
+		case CancelFind :
+			destroy();
+			break;
+	}
+	return FALSE;
+}
+
+WORD Find::dlgCode(CallbackData &someCallbackData)
+{
+  return DLGC_WANTALLKEYS;
+}
+
+BOOL Find::dlgInitDialog(CallbackData &/*someCallbackData*/)
+{
+  mEditHook.hookWin(getItem(FindText));
+	init();
+	return TRUE;
+}
+
+void Find::dlgDestroyDialog(CallbackData &/*someCallbackData*/)
+{
+  mEditHook.unhookWin();
+	return;
+}
+
+void Find::getText(String &strEditText)
+{
+  String strText;
+
+	DynamicDialog::getText(FindText,strText);
+	strEditText=strText;
+}
+
+BOOL Find::matchWholeWordOnly(void)const
+{
+  return ::SendMessage(getItem(FindWhole),BM_GETCHECK,0,0L);
+}
+
+void Find::handleFind(void)
+{
+  find();
+}
+
+void Find::handleFindNext(void)
+{
+  findNext();
+}
+
+// virtuals
+
+void Find::init(void)
+{
+}
+
+void Find::find(void)
+{
+  String currText;
+
+	getText(currText);
+	lastSearchText(currText);
+}
+
+void Find::findNext(void)
+{
+  String currText;
+
+	getText(currText);
+	lastSearchText(currText);
+}
+
+void Find::leaveEdit(const String &strEditText)
+{
+  lastSearchText(strEditText);
+}

m68hc11/backup/Find.hpp

@@ -0,0 +1,81 @@
+#ifndef _M68HC11_FIND_HPP_
+#define _M68HC11_FIND_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _DIALOG_DYNAMICDIALOG_HPP_
+#include <dialog/dyndlg.hpp>
+#endif
+#ifndef _COMMON_HOOKPROC_HPP_
+#include <common/hookproc.hpp>
+#endif
+
+class Find : private DynamicDialog
+{
+public:
+	Find(void);
+	virtual ~Find();
+  void perform(GUIWindow &parentWindow);
+	int lastFindIndex(void)const;
+	const String &lastSearchText(void)const;
+	void setFocus(void)const;
+protected:
+  virtual void init(void);
+	virtual void find(void);
+	virtual void findNext(void);
+	virtual void leaveEdit(const String &strText);
+	void getText(String &strEditText);
+	void lastFindIndex(int lastFindIndex);
+	void lastSearchText(const String &lastSearchText);
+	BOOL matchWholeWordOnly(void)const;
+private:
+  enum{FindText=101,CancelFind=IDCANCEL,FindNext=103,FindWhole=104};
+	Find(const Find &find);
+	Find &operator=(const Find &find);
+	CallbackData::ReturnType keyDownHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType dlgCodeHandler(CallbackData &someCallbackData);
+	void handleFind(void);
+	void handleFindNext(void);
+	void create(GUIWindow &parentWindow);
+	WORD dlgCommand(DWORD commandID,CallbackData &someCallbackData);
+	WORD dlgCode(CallbackData &someCallbackData);
+	BOOL dlgInitDialog(CallbackData &someCallbackData);
+	void dlgDestroyDialog(CallbackData &someCallbackData);
+
+  Callback<Find> mKeyDownHandler;
+	Callback<Find> mDlgCodeHandler;
+	String mLastSearchText;
+  int mLastFindIndex;
+	WinHookProc mEditHook;
+};
+
+inline
+const String &Find::lastSearchText(void)const
+{
+  return mLastSearchText;
+}
+
+inline
+void Find::lastSearchText(const String &lastSearchText)
+{
+  mLastSearchText=lastSearchText;
+}
+
+inline
+void Find::lastFindIndex(int lastFindIndex)
+{
+  mLastFindIndex=lastFindIndex;
+}
+
+inline
+int Find::lastFindIndex(void)const
+{
+  return mLastFindIndex;
+}
+
+inline
+void Find::setFocus(void)const
+{
+  GUIWindow::setFocus();
+}
+#endif

m68hc11/backup/M68HC11.HPP

@@ -0,0 +1,6 @@
+#ifndef _M68HC11_M68HC11_HPP_
+#define _M68HC11_M68HC11_HPP_
+#ifndef _M68HC11_M68HC11_H_
+#include <m68hc11/m68hc11.h>
+#endif
+#endif

m68hc11/backup/M68REG.CPP

@@ -0,0 +1,219 @@
+#include <m68hc11/m68reg.hpp>
+#include <m68hc11/commctrl.hpp>
+
+M68Reg::M68Reg(void)
+:	mM68KeyName(STRING_M68KEYNAME),
+	mHistoryKeyName(STRING_HISTORYKEYNAME),
+	mSettingsKeyName(STRING_SETTINGSKEYNAME),
+	mSerialKeyName(STRING_SERIALKEYNAME),
+	mHistoryKeyShortName(STRING_HISTORYKEYSHORTNAME),
+	mSettingsEMAIL(STRING_SETTINGSEMAIL),
+	mSerialPort(STRING_SERIALPORT),
+	mSerialBaud(STRING_SERIALBAUD),
+	mSerialData(STRING_SERIALDATA),
+	mSerialParity(STRING_SERIALPARITY),
+	mSerialStop(STRING_SERIALSTOP),
+	mRegKeySettings(RegKey::CurrentUser),
+	mRegKeyHistory(RegKey::CurrentUser),
+	mRegKeySerial(RegKey::CurrentUser)
+{
+  guarantee();
+	getCacheNames();
+}
+
+M68Reg::M68Reg(const M68Reg &someM68Reg)
+:	mM68KeyName(STRING_M68KEYNAME),
+	mHistoryKeyName(STRING_HISTORYKEYNAME),
+	mSettingsKeyName(STRING_SETTINGSKEYNAME),
+	mSerialKeyName(STRING_SERIALKEYNAME),
+	mHistoryKeyShortName(STRING_HISTORYKEYSHORTNAME),
+	mSettingsEMAIL(STRING_SETTINGSEMAIL),
+	mSerialPort(STRING_SERIALPORT),
+	mSerialBaud(STRING_SERIALBAUD),
+	mSerialData(STRING_SERIALDATA),
+	mSerialParity(STRING_SERIALPARITY),
+	mSerialStop(STRING_SERIALSTOP),
+	mRegKeySettings(RegKey::CurrentUser),
+	mRegKeyHistory(RegKey::CurrentUser),
+	mRegKeySerial(RegKey::CurrentUser)
+{
+  *this=someM68Reg;
+}
+
+M68Reg::~M68Reg()
+{
+}
+
+M68Reg &M68Reg::operator=(const M68Reg &/*someM68Reg*/)
+{
+  return *this;
+}
+
+void M68Reg::getCacheNames(void)
+{
+  int itemIndex(0);
+	String entryName;
+	DWORD status;
+
+	mCachedNames.remove();
+	while(mRegKeyHistory.enumValue(itemIndex++,entryName,status))mCachedNames.insert(&entryName);
+}
+
+String M68Reg::email(void)
+{
+  String strEMAIL;
+  mRegKeySettings.queryValue(mSettingsEMAIL,strEMAIL);
+	return strEMAIL;
+}
+
+void M68Reg::email(const String &email)
+{
+  mRegKeySettings.setValue(mSettingsEMAIL,email);
+}
+
+bool M68Reg::setBaud(const String &strBaud)
+{
+  return mRegKeySerial.setValue(mSerialBaud,strBaud);
+}
+
+String M68Reg::getBaud(void)
+{
+  String strBaud;
+	mRegKeySerial.queryValue(mSerialBaud,strBaud);
+	return strBaud;
+}
+
+bool M68Reg::setParity(const String &strParity)
+{
+  return mRegKeySerial.setValue(mSerialParity,strParity);
+}
+
+String M68Reg::getParity(void)
+{
+  String strParity;
+	mRegKeySerial.queryValue(mSerialParity,strParity);
+	return strParity;
+}
+
+bool M68Reg::setDataBits(const String &strDataBits)
+{
+  return mRegKeySerial.setValue(mSerialData,strDataBits);
+}
+
+String M68Reg::getDataBits(void)
+{
+  String strData;
+	mRegKeySerial.queryValue(mSerialData,strData);
+	return strData;
+}
+
+bool M68Reg::setStopBits(const String &stopBits)
+{
+  return mRegKeySerial.setValue(mSerialStop,stopBits);
+}
+
+String M68Reg::getStopBits(void)
+{
+  String strStop;
+
+	mRegKeySerial.queryValue(mSerialStop,strStop);
+	return strStop;
+}
+
+bool M68Reg::setPort(const String &strPort)
+{
+  return mRegKeySerial.setValue(mSerialPort,strPort);
+}
+
+String M68Reg::getPort(void)
+{
+  String strPort;
+	mRegKeySerial.queryValue(mSerialPort,strPort);
+	return strPort;
+}
+
+String M68Reg::getSerialSettings(void)
+{
+  String serialSettings;
+
+	serialSettings+="baud=";
+	serialSettings+=getBaud();
+	serialSettings+=" ";
+	serialSettings+="parity=";
+	serialSettings+=getParity();
+	serialSettings+=" ";
+	serialSettings+="data=";
+	serialSettings+=getDataBits();
+	serialSettings+=" ";
+	serialSettings+="stop=";
+	serialSettings+=getStopBits();
+	return serialSettings;
+}
+
+void M68Reg::guarantee(void)
+{
+	if(!mRegKeySettings.openKey(mSettingsKeyName))
+	{
+	  mRegKeySettings.createKey(mSettingsKeyName,"");
+	  mRegKeySettings.openKey(mSettingsKeyName);
+  }
+	if(!mRegKeyHistory.openKey(mHistoryKeyName))
+	{
+	  mRegKeyHistory.createKey(mHistoryKeyName,"");
+	  mRegKeyHistory.openKey(mHistoryKeyName);
+  }
+	if(!mRegKeySerial.openKey(mSerialKeyName))
+	{
+	  CommControl commControl;
+		Block<String> deviceList;
+
+		commControl.enumerateDevices(deviceList);
+	  mRegKeySerial.createKey(mSerialKeyName,"");
+	  mRegKeySerial.openKey(mSerialKeyName);
+    setBaud("1200");
+    setParity("N");
+		setDataBits("8");
+    setStopBits("1");
+		setPort(deviceList.size()?deviceList[0]:"COM1");
+	}
+}
+
+BOOL M68Reg::isOkay(void)const
+{
+  return mRegKeySettings.isOkay()&&mRegKeyHistory.isOkay()&&mRegKeySerial.isOkay();
+}
+
+BOOL M68Reg::getHistory(Block<String> &nameList)
+{
+	nameList=mCachedNames;
+	return nameList.size()?TRUE:FALSE;
+}
+
+BOOL M68Reg::setHistory(Block<String> &nameList)
+{
+	RegKey regKey(RegKey::CurrentUser);
+	mRegKeyHistory.closeKey();
+	regKey.openKey(mM68KeyName);
+	regKey.deleteKey(mHistoryKeyShortName);
+	regKey.closeKey();
+  mRegKeyHistory.createKey(mHistoryKeyName,"");
+	mRegKeyHistory.openKey(mHistoryKeyName);
+	for(int itemIndex=0;itemIndex<nameList.size();itemIndex++)mRegKeyHistory.setValue(nameList[itemIndex],0);
+  return nameList.size()?TRUE:FALSE;
+}
+
+BOOL M68Reg::insertHistory(const String &strName)
+{
+  for(int itemIndex=0;itemIndex<mCachedNames.size();itemIndex++)if(mCachedNames[itemIndex]==strName)return FALSE;
+	mCachedNames.insert(&strName);
+	if(mCachedNames.size()>MaxCachedNames)
+	{
+	  Block<String> mruCachedNames;
+		for(int itemIndex=0;itemIndex<MaxCachedNames;itemIndex++)mruCachedNames.insert(&String());
+	  for(itemIndex=0;itemIndex<MaxCachedNames;itemIndex++)mruCachedNames[mruCachedNames.size()-itemIndex-1]=mCachedNames[mCachedNames.size()-itemIndex-1];
+		mCachedNames=mruCachedNames;
+		setHistory(mCachedNames);
+	}
+	else mRegKeyHistory.setValue(strName,0);
+	return TRUE;
+}

m68hc11/backup/M68REG.HPP

@@ -0,0 +1,61 @@
+#ifndef _M68HC11_M68REG_HPP_
+#define _M68HC11_M68REG_HPP_
+#ifndef _COMMON_REGKEY_HPP_
+#include <common/regkey.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _M68HC11_M68HC11_HPP_
+#include <m68hc11/m68hc11.hpp>
+#endif
+
+class M68Reg
+{
+public:
+  M68Reg(void);
+	M68Reg(const M68Reg &someM68Reg);
+	virtual ~M68Reg();
+	M68Reg &operator=(const M68Reg &someM68Reg);
+	BOOL getHistory(Block<String> &nameList);
+	BOOL setHistory(Block<String> &nameList);
+	BOOL insertHistory(const String &strName);
+  bool setBaud(const String &strBaud);
+	String getBaud(void);
+	bool setParity(const String &strParity);
+	String getParity(void);
+	bool setDataBits(const String &strDataBits);
+	String getDataBits(void);
+	bool setStopBits(const String &stopBits);
+	String getStopBits(void);
+	bool setPort(const String &strPort);
+	String getPort(void);
+	String getSerialSettings(void);
+	String email(void);
+	void email(const String &email);
+	BOOL isOkay(void)const;
+private:
+  enum {MaxCachedNames=5};
+  void guarantee(void);
+  void getCacheNames(void);
+
+  Block<String> mCachedNames;
+	String mHistoryKeyName;
+	String mSettingsKeyName;
+	String mSerialKeyName;
+	String mHistoryKeyShortName;
+	String mSettingsEMAIL;
+	String mM68KeyName;
+	String mSerialPort;
+	String mSerialBaud;
+	String mSerialData;
+	String mSerialParity;
+	String mSerialStop;
+	RegKey mRegKeySettings;
+	RegKey mRegKeyHistory;
+	RegKey mRegKeySerial;
+};
+#endif

m68hc11/backup/M68hc11.h

@@ -0,0 +1,150 @@
+#ifndef _M68HC11_M68HC11_H_
+#define _M68HC11_M68HC11_H_
+
+#define MCUDLG_REGISTERS	101
+#define MCUDLG_CCR	      102
+#define MCUDLG_MESSAGES	  109
+#define MCUDLG_PC	        103
+#define MCUDLG_SP	        104
+#define MCUDLG_Y	        105
+#define MCUDLG_X	        106
+#define MCUDLG_A	        107
+#define MCUDLG_B	        108
+
+#define SERIAL_STOP	104
+#define SERIAL_PARITY	105
+#define SERIAL_APPLY	106
+#define SERIAL_TEST	107
+#define SERIAL_DATA	103
+#define SERIAL_BAUD	102
+#define SERIAL_PORT	101
+
+#define SBCMENU_FILENEW		            500
+#define SBCMENU_FILEOPEN   						501
+#define SBCMENU_FILESAVE              502
+#define SBCMENU_FILESAVEAS            503
+#define SBCMENU_FILEPRINT             504
+#define SBCMENU_FILEQUIT				      505
+#define SBCMENU_FILECLOSE             506
+#define SBCMENU_EDITCUT               507 
+#define SBCMENU_EDITCOPY							508
+#define SBCMENU_EDITPASTE							509
+#define SBCMENU_EDITFIND							510
+#define SBCMENU_SETTINGSSERIAL        511
+#define SBCMENU_CODECOMPILE				    512
+#define SBCMENU_CODECOMPILEANDLOAD		513
+#define SBCMENU_HELPCONTENTS		      514
+#define SBCMENU_HELPSEARCH			      515
+#define SBCMENU_REGISTRATION		      516
+#define SBCMENU_HELPABOUT				      517
+
+#define IDM_CASCADE     				      10013
+#define IDM_TILE           			      10014 
+#define IDM_ARRANGE     				      10015
+#define IDM_CLOSEALL    				      10016
+#define IDM_MINIMIZEALL 				      10017
+#define IDM_RESTOREALL  				      10018
+
+#define STRING_M68KEYNAME             600 
+#define	STRING_HISTORYKEYNAME					601
+#define	STRING_SETTINGSKEYNAME				602
+#define	STRING_SERIALKEYNAME					603
+#define STRING_HISTORYKEYSHORTNAME		604
+#define STRING_SETTINGSEMAIL					605
+#define STRING_SERIALPORT							606
+#define STRING_SERIALBAUD							607
+#define STRING_SERIALDATA							608
+#define STRING_SERIALPARITY						609
+#define STRING_SERIALSTOP             610
+#define STRING_COM1                   611
+#define STRING_COM2										612
+#define STRING_COM3										613
+#define STRING_COM4										614
+
+#define STRING_CODEVIEWCLASSNAME      500
+#define STRING_MCUVIEWCLASSNAME       501
+#define STRING_UNTITLED               502
+#define STRING_HELPFILENAME           503
+
+#define STRING_REGISTERPORTA          700
+#define STRING_REGISTERRESERVED1			701
+#define STRING_REGISTERPIOC						702
+#define STRING_REGISTERPORTC					703
+#define STRING_REGISTERPORTB					704
+#define STRING_REGISTERPORTCL					705
+#define STRING_REGISTERRESERVED2			706
+#define STRING_REGISTERDDRC						707
+#define STRING_REGISTERPORTD					708
+#define STRING_REGISTERDDRD						709
+#define STRING_REGISTERPORTE					710
+#define STRING_REGISTERCFORC					711
+#define STRING_REGISTEROC1M						712
+#define STRING_REGISTEROC1D						713
+#define STRING_REGISTERTCNTH1					714
+#define STRING_REGISTERTCNTLO					715
+#define STRING_REGISTERTIC1HI					716
+#define STRING_REGISTERTIC1LO					717
+#define STRING_REGISTERTIC2HI					718
+#define STRING_REGISTERTIC2LO					719
+#define STRING_REGISTERTIC3HI					720
+#define STRING_REGISTERTIC3LO					721
+#define STRING_REGISTERTOC1HI					722
+#define STRING_REGISTERTOC1LO					723
+#define STRING_REGISTERTOC2HI					724
+#define STRING_REGISTERTOC2LO					725
+#define STRING_REGISTERTOC3HI					726
+#define STRING_REGISTERTOC3LO					727
+#define STRING_REGISTERTOC4HI					728
+#define STRING_REGISTERTOC4LO					729
+#define STRING_REGISTERTI405HI				730
+#define STRING_REGISTERTI405LO				731
+#define STRING_REGISTERTCTL1					732
+#define STRING_REGISTERTCTL2					733
+#define STRING_REGISTERTMSK1					734
+#define STRING_REGISTERTFLG1					735
+#define STRING_REGISTERTMSK2					736
+#define STRING_REGISTERTFLG2					737
+#define STRING_REGISTERPACTL					738
+#define STRING_REGISTERPACNT					739
+#define STRING_REGISTERSPCR						740
+#define STRING_REGISTERSPSR						741
+#define STRING_REGISTERSPDR						742
+#define STRING_REGISTERBAUD						743
+#define STRING_REGISTERSCCR1					744
+#define STRING_REGISTERSCCR2					745
+#define STRING_REGISTERSCSR						746
+#define STRING_REGISTERSCDR						747
+#define STRING_REGISTERADCTL					748
+#define STRING_REGISTERADR1						749
+#define STRING_REGISTERADR2						750
+#define STRING_REGISTERADR3						751
+#define STRING_REGISTERADR4						752
+#define STRING_REGISTERBPROT					753
+#define STRING_REGISTEREPROG					754
+#define STRING_REGISTERRESERVED3			755
+#define STRING_REGISTERRESERVED4			756
+#define STRING_REGISTEROPTION					757
+#define STRING_REGISTERCOPRST					758
+#define STRING_REGISTERPPROG					759
+#define STRING_REGISTERHPRIO					760
+#define STRING_REGISTERINIT						761
+#define STRING_REGISTERTEST1					762
+#define STRING_REGISTERCONFIG					763
+
+#define STRING_ERRORFILEOPEN          764
+#define STRING_ERRORPORTOPEN          765
+#define STRING_ERRORPORTSETTINGS      766
+#define STRING_ERRORTIMEOUT           767
+#define STRING_ERRORREADERROR         768
+#define STRING_ERRORTALKBACKFAILURE   769
+#define STRING_ERRORTALKBACKDATA      770
+
+#define STRING_EVENTSINGLEBYTE	      771
+#define STRING_EVENTQUADBYTE					772
+#define STRING_EVENTVARBYTE						773
+#define STRING_EVENTREGDATASTART			774
+#define STRING_EVENTREGDATACOMPLETE		775
+#define STRING_EVENTCODECOMPLETE			776
+#define STRING_EVENTDOUBLEBYTE        777
+#define STRING_EVENTSTRING            778
+#endif

m68hc11/backup/MAIN.CPP

@@ -0,0 +1,120 @@
+#include <m68hc11/mainfrm.hpp>
+
+int PASCAL WinMain(HINSTANCE /*hInstance*/,HINSTANCE /*hPrevInstance*/,LPSTR /*lpszCmdLine*/,int /*nCmdShow*/)
+{
+  MainFrame frameWindow;
+//	frameWindow.splash();
+	frameWindow.createWindow("M68HC11","M68HC11 v1.00","mainMenu","MOT");
+	return frameWindow.messageLoop();
+}
+
+#if 0
+#include <m68hc11/commctrl.hpp>
+
+int PASCAL WinMain(HINSTANCE /*hInstance*/,HINSTANCE /*hPrevInstance*/,LPSTR /*lpszCmdLine*/,int /*nCmdShow*/)
+{
+  CommControl commControl;
+	CommStatus commStatus;
+	DeviceControlBlock deviceControlBlock;
+	BYTE charByte(0xFF);
+
+	commControl.open(CommControl::PortCOM1);
+	if(!commControl.isOkay())return FALSE;
+	if(!commControl.setDeviceControlBlock("baud=1200 data=8 stop=1 parity=N"))::OutputDebugString("Set operation failed\n");
+
+  String strString;
+	charByte='a';
+	while(TRUE)
+	{
+	  commControl.write(&charByte,sizeof(charByte));
+//		commControl.waitForData();
+    commControl.read(&charByte,sizeof(charByte));
+		::sprintf(strString,"%02x\n",(int)charByte);
+    ::OutputDebugString(strString);
+		charByte++;
+
+//	  commControl.clearError(commStatus);
+
+//		if(commStatus.bytesInReceiveQueue())
+//		{
+//	    commControl.read(&charByte,sizeof(charByte));
+//			::sprintf(strString,"%02x\n",(int)charByte);
+//      ::OutputDebugString(strString);
+//			break;
+//		}
+		::Sleep(250);
+	}
+
+
+
+/*
+  ::OutputDebugString("waiting for break signal...\n");
+	commControl.setEventMask(CommControl::EventBreak);  // EventBreak
+	if(!commControl.waitEvent())::OutputDebugString("timeout waiting for break.\n");
+	else ::OutputDebugString("break received, loading code...\n");
+
+
+	BYTE ioBuffer[256];
+
+	for(int index=0;index<256;index++)ioBuffer[index]=index;
+	charByte=0xFF;
+	commControl.write(&charByte,sizeof(charByte));
+
+//	commControl.clearError(commStatus);
+//  if(commStatus.bytesInReceiveQueue())commControl.read(ioBuffer,commStatus.bytesInReceiveQueue());
+
+	commControl.write(ioBuffer,sizeof(ioBuffer));
+	::memset(ioBuffer,0,sizeof(ioBuffer));
+
+  String strString;
+  ::OutputDebugString("receiving echo\n");  
+	while(TRUE)
+	{
+	  commControl.clearError(commStatus);
+
+		if(commStatus.bytesInReceiveQueue())
+		{
+	    commControl.read(ioBuffer,sizeof(ioBuffer));
+	    for(index=0;index+8<sizeof(ioBuffer);index+=8)
+	    {
+	      ::sprintf(strString,"%02x %02x %02x %02x %02x %02x %02x %02x\n",
+		      ioBuffer[index],ioBuffer[index+1],ioBuffer[index+2],ioBuffer[index+3],ioBuffer[index+4],
+			    ioBuffer[index+5],ioBuffer[index+6],ioBuffer[index+7]);
+		      ::OutputDebugString(strString);
+	    }
+			break;
+		}
+		::Sleep(1000);
+	}
+*/
+  return FALSE;
+}
+
+#if 0
+	for(int index=0;index<256;index++)ioBuffer[index]=index;
+	charByte=0xFF;
+	commControl.write(&charByte,sizeof(charByte));
+	commControl.write(ioBuffer,sizeof(ioBuffer));
+	::memset(ioBuffer,0,sizeof(ioBuffer));
+
+  ::OutputDebugString("receiving echo\n");
+	while(TRUE)
+	{
+	  commControl.clearError(commStatus);
+		if(commStatus.bytesInReceiveQueue())
+		{
+	    commControl.read(ioBuffer,sizeof(ioBuffer));
+	    for(index=0;index+8<sizeof(ioBuffer);index+=8)
+	    {
+	      ::sprintf(strString,"%02x %02x %02x %02x %02x %02x %02x %02x\n",
+		      ioBuffer[index],ioBuffer[index+1],ioBuffer[index+2],ioBuffer[index+3],ioBuffer[index+4],
+			    ioBuffer[index+5],ioBuffer[index+6],ioBuffer[index+7]);
+		      ::OutputDebugString(strString);
+	    }
+			break;
+		}
+		::Sleep(1000);
+	}
+
+#endif
+#endif

m68hc11/backup/MCUDLG.CPP

@@ -0,0 +1,147 @@
+#include <m68hc11/mcudlg.hpp>
+#include <m68hc11/odlstled.hpp>
+#include <m68hc11/m68hc11.hpp>
+#include <common/stdio.hpp>
+
+MCUDlg::MCUDlg(void)
+{
+  mInitHandler.setCallback(this,&MCUDlg::initHandler);
+	mCreateHandler.setCallback(this,&MCUDlg::createHandler);
+	mCloseHandler.setCallback(this,&MCUDlg::closeHandler);
+	mDestroyHandler.setCallback(this,&MCUDlg::destroyHandler);
+	mCommandHandler.setCallback(this,&MCUDlg::commandHandler);
+	insertHandler(VectorHandler::InitDialogHandler,&mInitHandler);
+	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
+	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+}
+
+MCUDlg::MCUDlg(const MCUDlg &someMCUDlg)
+{ // private implementation
+  *this=someMCUDlg;
+}
+
+MCUDlg::~MCUDlg()
+{
+	removeHandler(VectorHandler::InitDialogHandler,&mInitHandler);
+	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	removeHandler(VectorHandler::CloseHandler,&mCloseHandler);
+	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+}
+
+MCUDlg &MCUDlg::operator=(const MCUDlg &someMCUDlg)
+{ // private implementation
+  return *this;
+}
+
+BOOL MCUDlg::perform(GUIWindow &parentWindow)
+{
+	::CreateDialogParam(processInstance(),(LPSTR)"MCUDLG",(HWND)parentWindow,DWindow::DlgProc,(LPARAM)(DWindow*)this);
+	return isValid();
+}
+
+CallbackData::ReturnType MCUDlg::initHandler(CallbackData &someCallbackData)
+{
+  mOwnerDrawList=::new OwnerDrawListBinaryLed(*this,getItem(MCUDLG_REGISTERS),MCUDLG_REGISTERS);
+	mOwnerDrawList.disposition(PointerDisposition::Delete);
+	for(int index=STRING_REGISTERPORTA;index<=STRING_REGISTERCONFIG;index++)mOwnerDrawList->insertString(String(index));
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MCUDlg::createHandler(CallbackData &someCallbackData)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MCUDlg::closeHandler(CallbackData &someCallbackData)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MCUDlg::destroyHandler(CallbackData &someCallbackData)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MCUDlg::commandHandler(CallbackData &someCallbackData)
+{
+  switch(someCallbackData.wmCommandID())
+	{
+    case IDCANCEL :
+		  handleCancel();
+      break;
+		case IDOK :
+		  handleOk();
+			break;
+	}
+  return (CallbackData::ReturnType)FALSE;
+}
+
+void MCUDlg::setRegister(int mcuRegister,BYTE value)
+{
+  String stringData;
+	String strItem;
+	String strData;
+
+	if(LB_ERR==mOwnerDrawList->getText(stringData,mcuRegister))return;
+	strItem=stringData.betweenString(0,'\t');
+	if(strItem.isNull())::sprintf(strData,"%s\t%d",(LPSTR)stringData,value);
+	else ::sprintf(strData,"%s\t%d",(LPSTR)strItem,value);
+  mOwnerDrawList->deleteString(mcuRegister);
+	mOwnerDrawList->insertString(strData,mcuRegister);
+}
+
+void MCUDlg::setRegisters(GlobalData<BYTE> &regData)
+{
+  mOwnerDrawList->setRedraw(FALSE);
+	for(int index=0;index<regData.size();index++)setRegister(index,regData[index]);
+	mOwnerDrawList->setRedraw(TRUE);
+}
+
+void MCUDlg::setVarByteData(GlobalData<BYTE> &byteData)
+{
+  String strData;
+	String strLine;
+	String strHexLine;
+
+  for(int index=0;index<byteData.size();index++)
+	{
+	  ::sprintf(strData,"%c",byteData[index]);
+		strLine+=strData;
+	}
+  for(index=0;index<byteData.size();index++)
+	{
+	  ::sprintf(strData,"%02lx",int(byteData[index]));
+		strHexLine+=strData;
+	}
+	sendMessage(MCUDLG_MESSAGES,LB_INSERTSTRING,-1,(LPARAM)(LPSTR)strLine);
+	sendMessage(MCUDLG_MESSAGES,LB_INSERTSTRING,-1,(LPARAM)(LPSTR)strHexLine);
+}
+
+void MCUDlg::setSingleByteData(BYTE singleByteData)
+{
+  String strLine;
+
+
+  if(isprint(singleByteData))::sprintf(strLine,"%c (%02lxh)",singleByteData,(int)singleByteData);
+	else ::sprintf(strLine,"'' (%02lxh)",(int)singleByteData);
+	sendMessage(MCUDLG_MESSAGES,LB_INSERTSTRING,-1,(LPARAM)(LPSTR)strLine);
+//	::sprintf(strLine,"%02lx",int(singleByteData));
+//	sendMessage(MCUDLG_MESSAGES,LB_INSERTSTRING,-1,(LPARAM)(LPSTR)strLine);
+}
+
+void MCUDlg::setStringData(const String &string)
+{
+	sendMessage(MCUDLG_MESSAGES,LB_INSERTSTRING,-1,(LPARAM)(LPSTR)string.str());
+}
+
+void MCUDlg::setQuadByteData(DWORD quadByteData)
+{
+}
+
+void MCUDlg::setDoubleByteData(WORD doubleByteData)
+{
+}
+

m68hc11/backup/MCUDLG.HPP

@@ -0,0 +1,81 @@
+#ifndef _M68HC11_MCUDLG_HPP_
+#define _M68HC11_MCUDLG_HPP_
+#ifndef _COMMON_DWINDOW_HPP_
+#include <common/dwindow.hpp>
+#endif
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _COMMON_GLOBALDATA_HPP_
+#include <common/gdata.hpp>
+#endif
+
+class OwnerDrawListBinaryLed;
+
+class MCUDlg : public DWindow
+{
+public:
+  MCUDlg(void);
+	virtual ~MCUDlg();
+	BOOL perform(GUIWindow &parentWindow);
+	void setCancelHandler(PureCallback *pCallback);
+	void setStartHandler(PureCallback *pCallback);
+  void setRegister(int mcuRegister,BYTE value);
+  void setRegisters(GlobalData<BYTE> &regData);
+	void setVarByteData(GlobalData<BYTE> &byteData);
+	void setQuadByteData(DWORD quadByteData);
+	void setDoubleByteData(WORD doubleByteData);
+	void setSingleByteData(BYTE singleByteData);
+	void setStringData(const String &string);
+	void enableStart(BOOL enable);
+private:
+  MCUDlg(const MCUDlg &someMCUDlg);
+	MCUDlg &operator=(const MCUDlg &someMCUDlg);
+	CallbackData::ReturnType initHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType closeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+	void handleCancel(void);
+	void handleOk(void);
+
+  Callback<MCUDlg> mInitHandler;
+	Callback<MCUDlg> mCreateHandler;
+	Callback<MCUDlg> mCloseHandler;
+	Callback<MCUDlg> mDestroyHandler;
+	Callback<MCUDlg> mCommandHandler;
+	SmartPointer<OwnerDrawListBinaryLed> mOwnerDrawList;
+	CallbackPointer mCancelHandler;
+	CallbackPointer mStartHandler;
+};
+
+inline
+void MCUDlg::setCancelHandler(PureCallback *pCallback)
+{
+  mCancelHandler=CallbackPointer(pCallback);
+}
+
+inline
+void MCUDlg::setStartHandler(PureCallback *pCallback)
+{
+  mStartHandler=CallbackPointer(pCallback);
+}
+
+inline
+void MCUDlg::handleCancel(void)
+{
+  mCancelHandler.callback(CallbackData());
+}
+
+inline
+void MCUDlg::handleOk(void)
+{
+  mStartHandler.callback(CallbackData());
+}
+
+inline
+void MCUDlg::enableStart(BOOL enable)
+{
+  ::EnableWindow(getItem(IDOK),enable);
+}
+#endif

m68hc11/backup/MCUTHRD.CPP

@@ -0,0 +1,238 @@
+#include <m68hc11/mcuthrd.hpp>
+#include <m68hc11/commctrl.hpp>
+#include <m68hc11/m68hc11.hpp>
+#include <m68hc11/m68reg.hpp>
+#include <common/openfile.hpp>
+#include <common/gdata.hpp>
+
+MCUThread::MCUThread(void)
+: mIsInEvents(false)
+{
+  mThreadHandler.setCallback(this,&MCUThread::threadHandler);
+	insertHandler(&mThreadHandler);
+}
+
+MCUThread::MCUThread(const MCUThread &someMCUThread)
+: mIsInEvents(false)
+{ // private implementation
+  *this=someMCUThread;
+}
+
+MCUThread::~MCUThread()
+{
+  removeHandler(&mThreadHandler);
+}
+
+MCUThread &MCUThread::operator=(const MCUThread &someMCUThread)
+{ // private implementation
+  return *this;
+}
+
+void MCUThread::listen(const String &strPathBinary)
+{
+  String *pString=::new String(strPathBinary);
+  ThreadMessage threadMessage(ThreadMessage::TM_USER,ThMsgListen,int(pString));
+	postMessage(threadMessage);
+	return;
+}
+
+DWORD MCUThread::threadHandler(ThreadMessage &someThreadMessage)
+{
+  switch(someThreadMessage.message())
+	{
+	  case ThreadMessage::TM_CREATE :
+		  break;
+		case ThreadMessage::TM_DESTROY :
+		  break;
+		case ThreadMessage::TM_USER :
+		  if(ThMsgListen==someThreadMessage.userDataOne())
+			{
+			  String *pString=(String*)someThreadMessage.userDataTwo();
+			  thListen(*pString);
+				::delete pString;
+			}
+		  break;
+	}
+  return FALSE;  
+}
+
+void MCUThread::thListen(const String &strPathBinary)
+{
+  CommControl commControl;
+
+  sendMessage("Initializing device...");
+	if(!openDevice(commControl))return;
+	sendMessage("Loading code...");
+	if(!codeLoad(commControl,strPathBinary))return;
+	sendMessage("Processing events...");
+	processEvents(commControl);
+  return;
+}
+
+BOOL MCUThread::openDevice(CommControl &commControl,bool useOverlappedIO)
+{
+  M68Reg mcuReg;
+
+	if(!commControl.open(CommControl::stringToPort(mcuReg.getPort()),useOverlappedIO))
+	{
+	  mErrorEventHandler.callback(CallbackData(ErrorPortOpen,0L));
+		return FALSE;
+	}
+	if(!commControl.setDeviceControlBlock(mcuReg.getSerialSettings()))
+	{
+	  mErrorEventHandler.callback(CallbackData(ErrorPortSettings,0L));
+		return FALSE;
+	}
+	commControl.setEventMask(CommControl::EventBreak);
+	if(!commControl.waitEvent())
+	{
+	  mErrorEventHandler.callback(CallbackData(ErrorTimeout,0L));
+		return FALSE;
+	}
+	return TRUE;
+}
+
+BOOL MCUThread::codeLoad(CommControl &commControl,const String &strPathBinary)
+{
+  FileHandle inFile;
+	BYTE sndBuffer[256];
+//	BYTE rcvBuffer[256];
+  GlobalData<BYTE> rcvBuffer;
+	WORD codeLength(0);
+	BYTE prefix(0xFF);
+	BYTE *ptrByte;
+
+	if(!inFile.open(strPathBinary))
+	{
+	  mErrorEventHandler.callback(CallbackData(ErrorFileOpen,int(&(String&)strPathBinary)));
+		return FALSE;
+	}
+	::memset(sndBuffer,1,sizeof(sndBuffer));
+//	::memset(&rcvBuffer,0,sizeof(rcvBuffer));
+	ptrByte=sndBuffer;
+	while(inFile.read(*ptrByte)&&codeLength<=256){codeLength++;ptrByte++;}
+	commControl.write(&prefix,sizeof(prefix));
+	commControl.clearReceiveQueue();
+	commControl.write(sndBuffer,sizeof(sndBuffer));
+	if(!commControl.waitForData())
+	{
+	  mErrorEventHandler.callback(CallbackData(ErrorTalkBackFailure,0L));
+		return false;
+	}
+	rcvBuffer.size(sizeof(sndBuffer));
+	rcvBuffer.setZero();
+	commControl.readFully(rcvBuffer);
+//	commControl.readFully(rcvBuffer,sizeof(rcvBuffer));
+	if(::memcmp(&rcvBuffer[0],sndBuffer,sizeof(sndBuffer)))
+	{
+	  mErrorEventHandler.callback(CallbackData(ErrorTalkBackData,0L));
+		return false;
+	}
+  return true;
+}	
+
+// event types
+// 0x00 - character
+// 0x01 - WORD 
+// 0x02 - DWORD
+// 0x03 - varchar : [WORD:count,countcharacters]
+// 0xFF - end 
+
+BOOL MCUThread::processEvents(CommControl &commControl)
+{
+  GlobalData<BYTE> byteData;
+	String strString;
+  BYTE event(0x00);
+	BYTE ack(0x00);
+	WORD wordData;
+	DWORD dwordData;
+	char charData;
+	int index;
+	int map(0x1000);
+
+	::OutputDebugString("MCUThread::processEvents[Thread is starting]");
+  isInEvents(true);
+  while(isInEvents())
+	{
+	  if(!commControl.hasData())continue;
+    commControl.read(&event,sizeof(event));
+		switch(MCUEvent(event))
+		{
+		  case EventString :
+			  {
+			    String str;
+			    sendMessage(STRING_EVENTSTRING);
+				  while(true)
+				  {
+				    commControl.read(&charData,sizeof(charData));
+					  if(!charData)break;
+					  str+=charData;
+				  }
+				  mMCUEventHandler.callback(CallbackData(EventString,int(&str)));
+				  commControl.write(&ack,sizeof(ack));
+				}
+			  break;
+		  case EventSingleByte :
+			  sendMessage(STRING_EVENTSINGLEBYTE);
+			  commControl.read(&charData,sizeof(charData));
+				mMCUEventHandler.callback(CallbackData(EventSingleByte,int(&charData)));
+				commControl.write(&ack,sizeof(ack));
+			  break;
+			case EventDoubleByte :
+			  sendMessage(STRING_EVENTDOUBLEBYTE);
+			  commControl.read(&wordData,sizeof(wordData));
+				mMCUEventHandler.callback(CallbackData(EventDoubleByte,int(&wordData)));
+				commControl.write(&ack,sizeof(ack));
+			  break;
+			case EventQuadByte :
+				sendMessage(STRING_EVENTQUADBYTE);
+		    commControl.read(&dwordData,sizeof(dwordData));
+				mMCUEventHandler.callback(CallbackData(EventQuadByte,(int)&dwordData));
+				commControl.write(&ack,sizeof(ack));
+			  break;
+			case EventVarByte :
+				sendMessage(STRING_EVENTVARBYTE);
+			  commControl.read(&wordData,sizeof(wordData));
+				byteData.size(wordData);
+				for(index=0;index<byteData.size();index++)
+				{
+				  commControl.read(&charData,sizeof(charData));
+					byteData[index]=charData;
+				}
+				mMCUEventHandler.callback(CallbackData(EventVarByte,int(&byteData)));
+				commControl.write(&ack,sizeof(ack));
+			  break;
+			case EventRegs :
+				map=0x1000;
+				byteData.size(64);
+				sendMessage(STRING_EVENTREGDATASTART);
+			  for(index=0;index<byteData.size();index++)
+				{
+			    commControl.read(&charData,sizeof(charData));
+					byteData[index]=charData;
+				}
+				sendMessage(STRING_EVENTREGDATACOMPLETE);
+				mMCUEventHandler.callback(CallbackData(EventRegs,int(&byteData)));
+				commControl.write(&ack,sizeof(ack));
+				break;
+			case EventEnd :
+			  sendMessage(STRING_EVENTCODECOMPLETE);
+				mMCUEventHandler.callback(CallbackData(EventEnd,0L));
+				isInEvents(false);
+			  break;
+			default :
+			  {
+				  String str;
+					::sprintf(str,"unexpected character : 0x%04lx\n",(int)event);
+			    ::OutputDebugString(str);
+				}
+		}
+	}
+	::OutputDebugString("MCUThread::processEvents[Thread is ending normally]");
+	return TRUE;
+}
+
+void MCUThread::sendMessage(const String &strMessage)
+{
+  mMessageHandler.callback(CallbackData(0,int(&(String&)strMessage)));
+}

m68hc11/backup/MCUTHRD.HPP

@@ -0,0 +1,72 @@
+#ifndef _M68HC11_MCUTHREAD_HPP_
+#define _M68HC11_MCUTHREAD_HPP_
+#ifndef _THREAD_MESSAGETHREAD_HPP_
+#include <thread/mthread.hpp>
+#endif
+#ifndef _COMMON_CALLBACK_HPP_
+#include <common/callback.hpp>
+#endif
+
+class CommControl;
+
+class MCUThread :  protected MessageThread
+{
+public:
+	enum MCUEvent{EventSingleByte=0x00,EventDoubleByte=0x01,EventQuadByte=0x02,EventVarByte=0x03,EventRegs=0x04,EventString=0x05,EventEnd=0xFF};
+  enum ErrorEvent{ErrorFileOpen,ErrorPortOpen,ErrorPortSettings,ErrorTimeout,ErrorReadError,ErrorTalkBackFailure,ErrorTalkBackData};
+  MCUThread(void);
+	virtual ~MCUThread();
+	void listen(const String &strPathBinary);
+	void setErrorEventHandler(PureCallback *pCallback);
+	void setMCUEventHandler(PureCallback *pCallback);
+	void setMessageHandler(PureCallback *pCallback);
+	bool isInEvents(void)const;
+	void isInEvents(bool isInEvents);
+private:
+  enum{ThMsgListen};
+  MCUThread(const MCUThread &someMCUThread);
+	MCUThread &operator=(const MCUThread &someMCUThread);
+	DWORD threadHandler(ThreadMessage &someThreadMessage);
+  void thListen(const String &strPathBinary);
+  BOOL openDevice(CommControl &commControl,bool userOverlappedIO=false);
+  BOOL codeLoad(CommControl &commControl,const String &strPathBinary);
+  BOOL processEvents(CommControl &commControl);
+  void sendMessage(const String &strMessage);
+
+	ThreadCallback<MCUThread> mThreadHandler;
+	CallbackPointer mErrorEventHandler;
+	CallbackPointer mMCUEventHandler;
+	CallbackPointer mMessageHandler;
+	bool mIsInEvents;
+};
+
+inline
+void MCUThread::setErrorEventHandler(PureCallback *pCallback)
+{
+  mErrorEventHandler=CallbackPointer(pCallback);
+}
+
+inline
+void MCUThread::setMCUEventHandler(PureCallback *pCallback)
+{
+  mMCUEventHandler=CallbackPointer(pCallback);
+}
+
+inline
+void MCUThread::setMessageHandler(PureCallback *pCallback)
+{
+  mMessageHandler=CallbackPointer(pCallback);
+}
+
+inline
+bool MCUThread::isInEvents(void)const
+{
+  return mIsInEvents;
+}
+
+inline
+void MCUThread::isInEvents(bool isInEvents)
+{
+  mIsInEvents=isInEvents;
+}
+#endif

m68hc11/backup/MCUVIEW.CPP

@@ -0,0 +1,193 @@
+#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;
+}

m68hc11/backup/MCUVIEW.HPP

@@ -0,0 +1,66 @@
+#ifndef _M68HC11_MCUVIEW_HPP_
+#define _M68HC11_MCUVIEW_HPP_
+#ifndef _COMMON_MDIWIN_HPP_
+#include <common/mdiwin.hpp>
+#endif
+#ifndef _COMMON_GLOBALDATA_HPP_
+#include <common/gdata.hpp>
+#endif
+#ifndef _M68HC11_MCUDLG_HPP_
+#include <m68hc11/mcudlg.hpp>
+#endif
+#ifndef _M68HC11_MCUTHREAD_HPP_
+#include <m68hc11/mcuthrd.hpp>
+#endif
+
+class StatusBarEx;
+
+class MCUView : public MDIWindow, public MCUThread
+{
+public:
+  MCUView(void);
+	virtual ~MCUView();
+	void setCode(const String &strPathBinary);
+protected:
+	virtual void preRegister(WNDCLASS &wndClass);
+	virtual void preCreate(MDICREATESTRUCT &createStruct);
+private:
+  enum {StatusBarID=101,InitialWidth=565,InitialHeight=360};
+  CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType sizeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType closeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType cancelHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType startHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType errorEventHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType mcuEventHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType messageHandler(CallbackData &someCallbackData);
+	void handleEventRegs(CallbackData &someCallbackData);
+  void handleEventVarByte(CallbackData &someCallbackData);
+  void handleEventQuadByte(CallbackData &someCallbackData);
+	void handleEventDoubleByte(CallbackData &someCallbackData);
+	void handleSingleByteData(CallbackData &someCallbackData);
+	void handleStringData(CallbackData &someCallbackData);
+
+  Callback<MCUView> mCreateHandler;
+  Callback<MCUView> mSizeHandler;
+	Callback<MCUView> mCloseHandler;
+	Callback<MCUView> mDestroyHandler;
+	Callback<MCUView> mCommandHandler;
+	Callback<MCUView> mCancelHandler;
+	Callback<MCUView> mStartHandler;
+	Callback<MCUView> mErrorEventHandler;
+	Callback<MCUView> mMCUEventHandler;
+	Callback<MCUView> mMessageHandler;
+	SmartPointer<StatusBarEx> mStatusBar;
+	MCUDlg mMCUDialog;
+	String mStrPathBinary;
+};
+
+inline
+void MCUView::setCode(const String &strPathBinary)
+{
+  mStrPathBinary=strPathBinary;
+}
+#endif

m68hc11/backup/Mainfrm.cpp

@@ -0,0 +1,497 @@
+#include <m68hc11/mainfrm.hpp>
+#include <m68hc11/serdlg.hpp>
+#include <m68hc11/codeview.hpp>
+#include <m68hc11/mcuview.hpp>
+#include <m68hc11/m68reg.hpp>
+#include <m68hc11/splash.hpp>
+#include <printman/printman.hpp>
+#include <common/assert.hpp>
+#include <common/opendlg.hpp>
+#include <common/gdata.hpp>
+#include <common/crsctrl.hpp>
+#include <common/diskinfo.hpp>
+
+char MainFrame::szClassName[]="M68HC11";
+char MainFrame::szMenuName[]="mainMenu";
+
+MainFrame::MainFrame(void)
+{
+  mQueryEndSessionHandler.setCallback(this,&MainFrame::queryEndSessionHandler);
+  mPaintHandler.setCallback(this,&MainFrame::paintHandler);
+	mDestroyHandler.setCallback(this,&MainFrame::destroyHandler);
+	mCommandHandler.setCallback(this,&MainFrame::commandHandler);
+	mSizeHandler.setCallback(this,&MainFrame::sizeHandler);
+	mCreateHandler.setCallback(this,&MainFrame::createHandler);
+	mLineHandler.setCallback(this,&MainFrame::lineHandler);
+	insertHandlers();
+}
+
+MainFrame::~MainFrame()
+{
+	destroy();
+}
+
+void MainFrame::insertHandlers(void)
+{
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	insertHandler(VectorHandler::SizeHandler,&mSizeHandler);
+	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	insertHandler(VectorHandler::QueryEndSessionHandler,&mQueryEndSessionHandler);
+}
+
+void MainFrame::removeHandlers(void)
+{
+	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	removeHandler(VectorHandler::SizeHandler,&mSizeHandler);
+	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	removeHandler(VectorHandler::QueryEndSessionHandler,&mQueryEndSessionHandler);
+}
+
+CallbackData::ReturnType MainFrame::createHandler(CallbackData &/*someCallbackData*/)
+{
+  GlobalData<int> statParts;
+
+	createToolBar();
+	mStatusBar=::new StatusBarEx(*this,StatusBarID);
+	mStatusBar.disposition(PointerDisposition::Delete);
+	statParts.size(2);
+	*((int*)&statParts[0])=300;
+	*((int*)&statParts[1])=400;
+	mStatusBar->setParts(statParts);
+	mStatusBar->setText("Ready");
+	applyHistory(getFrameMenu());
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainFrame::destroyHandler(CallbackData &/*someCallbackData*/)
+{
+	removeHandlers();
+	::PostQuitMessage(0);
+	::WinHelp(*this,0,HELP_QUIT,0);
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainFrame::queryEndSessionHandler(CallbackData &someCallbackData)
+{
+   if(getClient().hasChildren())return (CallbackData::ReturnType)FALSE;
+	 return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainFrame::sizeHandler(CallbackData &someCallbackData)
+{
+  Rect statusRect;
+	Rect toolRect;
+	Rect cRect;
+
+  mToolBar.windowRect(toolRect);
+	mStatusBar->windowRect(statusRect);
+	cRect.right(someCallbackData.loWord());
+	cRect.bottom(someCallbackData.hiWord());
+	getClient().moveWindow(0,toolRect.bottom()-toolRect.top(),cRect.right(),cRect.bottom()-((statusRect.bottom()-statusRect.top())+(toolRect.bottom()-toolRect.top())));
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainFrame::lineHandler(CallbackData &someCallbackData)
+{
+  String msg;
+	::sprintf(msg,"Ln %d, Col %d",someCallbackData.loWord(),someCallbackData.hiWord());
+	mStatusBar->setText(msg,1);
+	mStatusBar->update();
+  return FALSE;
+}
+
+CallbackData::ReturnType MainFrame::paintHandler(CallbackData &/*someCallbackData*/)
+{
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType MainFrame::commandHandler(CallbackData &someCallbackData)
+{
+	switch(someCallbackData.wmCommandID())
+	{
+	  case MenuCodeCompile :
+		  handleCodeCompile();
+			break;
+		case MenuCodeCompileAndLoad :
+		  handleCodeCompileAndLoad();
+			break;
+	  case MenuEditCut :
+		  handleEditCut();
+		  break;
+		case MenuEditCopy :
+		  handleEditCopy();
+		  break;
+		case MenuEditPaste :
+		  handleEditPaste();
+		  break;
+		case MenuEditFind :
+		  handleEditFind();
+		  break;
+	  case MenuCascade :
+		  cascade();
+			break;
+		case MenuTile :
+		  tile();
+			break;
+		case MenuArrange :
+		  arrange();
+			break;
+		case MenuCloseAll :
+		  closeAll();
+			break;
+		case MenuMinimizeAll :
+		  minimizeAll();
+			break;
+		case MenuRestoreAll :
+		  restoreAll();
+			break;
+	  case MenuFileNew :
+		  handleFileNew();
+			break;
+		case MenuFileOpen :
+		  handleFileOpen();
+		  break;
+	  case MenuFileSave :
+		  handleFileSave();
+			break;
+		case MenuFilePrint :
+		  handleFilePrint();
+			break;
+		case MenuFileSaveAs :
+		  handleFileSaveAs();
+			break;
+		case MenuFileClose :
+		  handleFileClose();
+			break;
+		case MenuFileQuit :
+		  break;
+		case MenuSettingsSerial :
+		  handleCommunications();
+		  break;
+		case MenuHelpContents :
+		  handleHelp();
+		  break;
+		case MenuHelpSearch :
+		  handleHelp();
+		  break;
+		case MenuRegistration :
+		  break;
+		case MenuHelpAbout :
+		  break;
+	}
+	if(someCallbackData.wParam()>=StartDynamicID)handleFileOpen(someCallbackData);
+	return (CallbackData::ReturnType)FALSE;
+}
+
+// handlers
+
+void MainFrame::handleCodeCompile(void)
+{
+  CursorControl cursorControl;
+  SmartPointer<MDIWindow> mdiWindow;
+	String strMessage;
+
+	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
+	CodeView &codeView=(CodeView&)*mdiWindow;
+	if(codeView.isDirty()&&IDYES==::MessageBox(*this,(LPSTR)"Save Changes?",(LPSTR)"M68HC11",MB_YESNO))if(!handleFileSave())return;
+	mStatusBar->setText("compiling...");
+	cursorControl.waitCursor(TRUE);
+	m68Assembler.assemble(codeView.getTitle());
+	cursorControl.waitCursor(FALSE);
+	strMessage=m68Assembler.strLastMessage()+String(", code size is ")+String().fromInt(m68Assembler.codeSize())+String(" byte(s).");
+	mStatusBar->setText(strMessage);
+}
+
+void MainFrame::handleCodeCompileAndLoad(void)
+{
+  CursorControl cursorControl;
+	BOOL assembleResult;
+	String strPathBinary;
+	String strMessage;
+
+  SmartPointer<MDIWindow> mdiWindow;
+	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
+	CodeView &codeView=(CodeView&)*mdiWindow;
+	if(codeView.isDirty()&&IDYES==::MessageBox(*this,(LPSTR)"Save Changes?",(LPSTR)"M68HC11",MB_YESNO))if(!handleFileSave())return;
+	mStatusBar->setText("compiling...");
+	cursorControl.waitCursor(TRUE);
+	assembleResult=m68Assembler.assemble(codeView.getTitle());
+	cursorControl.waitCursor(FALSE);
+	strMessage=m68Assembler.strLastMessage()+String(", code size is ")+String().fromInt(m68Assembler.codeSize())+String(" byte(s).");
+	mStatusBar->setText(strMessage);
+	if(!assembleResult)return;
+	strPathBinary=codeView.getTitle().betweenString(0,'.');
+	strPathBinary+=".bin";
+	codeLoad(strPathBinary);
+}
+
+void MainFrame::handleEditCut(void)
+{
+  SmartPointer<MDIWindow> mdiWindow;
+	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
+	((CodeView&)*mdiWindow).cut();
+}
+
+void MainFrame::handleEditCopy(void)
+{
+  SmartPointer<MDIWindow> mdiWindow;
+	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
+	((CodeView&)*mdiWindow).copy();
+}
+
+void MainFrame::handleEditPaste(void)
+{
+  SmartPointer<MDIWindow> mdiWindow;
+	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
+	((CodeView&)*mdiWindow).paste();
+}
+
+void MainFrame::handleEditFind(void)
+{
+  SmartPointer<MDIWindow> mdiWindow;
+	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
+	((CodeView&)*mdiWindow).find();
+}
+
+void MainFrame::handleFileNew(void)
+{
+  CodeView *pCodeView;
+
+	pCodeView=::new CodeView;
+	pCodeView->setLineHandler(&mLineHandler);
+	pCodeView->createWindow(*this,STRING_CODEVIEWCLASSNAME,STRING_CODEVIEWCLASSNAME,"codeMenu","Doc");
+	insert(*pCodeView);
+}
+
+void MainFrame::handleFileOpen(CallbackData &someCallbackData)
+{
+	PureMenu fileMenu;
+	String menuItemString;
+
+	getFrameMenu().getSubMenu(0,fileMenu);
+	menuItemString=fileMenu.menuItemString(someCallbackData.wParam(),PureMenu::ByCommand);
+	if(menuItemString.isNull())return;
+	menuItemString=menuItemString.betweenString(')',0);
+	menuItemString.trimLeft();
+	handleFileOpen(menuItemString);
+}
+
+void MainFrame::handleFileOpen(void)
+{
+  OpenDialog openDialog;
+  String strPathFileName;
+
+	if(!openDialog.getOpenFileName(*this,"*.asm","Open File","*.asm",strPathFileName))return;
+	handleFileOpen(strPathFileName);
+}
+
+void MainFrame::handleFileOpen(const String &strPathFileName)
+{
+  CodeView *pCodeView;
+	CursorControl cursorControl;
+
+  if(bringDocumentToFront(strPathFileName))return;
+  mStatusBar->setText("Loading...");
+	cursorControl.waitCursor(TRUE);
+
+  pCodeView=::new CodeView;
+	insert(*pCodeView);        // insert the pointer before creating/activating the window
+	pCodeView->createWindow(*this,STRING_CODEVIEWCLASSNAME,STRING_CODEVIEWCLASSNAME,"codeMenu","Doc");
+	pCodeView->setLineHandler(&mLineHandler);
+	pCodeView->open(strPathFileName);
+  mStatusBar->setText("Ready");
+	cursorControl.waitCursor(FALSE);
+	updateHistory(strPathFileName);
+}
+
+void MainFrame::handleFileClose(void)
+{
+  SmartPointer<MDIWindow> mdiWindow;
+	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
+	mdiWindow->close();
+}
+
+void MainFrame::handleFilePrint(void)
+{
+  SmartPointer<MDIWindow> mdiWindow;
+	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return;
+	((CodeView&)*mdiWindow).print();
+}
+
+BOOL MainFrame::handleFileSave(void)
+{
+  SmartPointer<MDIWindow> mdiWindow;
+	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return FALSE;
+	CodeView &codeView=(CodeView&)*mdiWindow;
+	if(codeView.getTitle()==String(STRING_UNTITLED))return handleFileSaveAs();
+	if(!codeView.save())return mStatusBar->setText(codeView.getTitle()+String(" save failed.")),FALSE;
+	return mStatusBar->setText(codeView.getTitle()+String(" saved.")),TRUE;
+	return TRUE;
+}
+
+BOOL MainFrame::handleFileSaveAs(void)
+{
+  SmartPointer<MDIWindow> mdiWindow;
+  OpenDialog openDialog;
+	String strPathFileName;
+
+	if(!getActive(mdiWindow)||!(mdiWindow->className()==String(STRING_CODEVIEWCLASSNAME)))return FALSE;
+	if(!openDialog.getSaveFileName(*this,"Assembly Files","File Save","*.asm",strPathFileName))return FALSE;
+	if(!strPathFileName.strstr(".asm"))strPathFileName+=".asm";
+	if(!((CodeView&)*mdiWindow).save(strPathFileName))return mStatusBar->setText(strPathFileName+String(" save failed!.")),FALSE;
+  return mStatusBar->setText(strPathFileName+String(" saved.")),TRUE;
+}
+
+void MainFrame::handleCommunications(void)
+{
+  SerialDlg serDlg;
+	serDlg.perform(*this);
+}
+
+void MainFrame::handleHelp(void)
+{
+  String strPathHelpFileName;
+  DiskInfo diskInfo;
+
+	diskInfo.getCurrentDirectory(strPathHelpFileName);
+	strPathHelpFileName+=String(STRING_HELPFILENAME);
+	::WinHelp(*this,strPathHelpFileName,HELP_CONTENTS,0);
+}
+
+// support & testing 
+BOOL MainFrame::codeLoad(const String &strPathBinary)
+{
+  MCUView *pMCUView;
+
+	pMCUView=::new MCUView;
+	pMCUView->createWindow(*this,STRING_MCUVIEWCLASSNAME,STRING_MCUVIEWCLASSNAME,"mcuMenu","Doc");
+	insert(*pMCUView);
+	pMCUView->setCode(strPathBinary);
+  return TRUE;
+}
+
+void MainFrame::setParts(int numParts)
+{
+  GlobalData<int> statParts;
+  if(1==numParts){statParts.size(1);*((int*)&statParts[0])=FirstPartWidth;}
+	else {statParts.size(2);*((int*)&statParts[0])=FirstPartWidth;*((int*)&statParts[0]+1)=SecondPartWidth;}
+	mStatusBar->setParts(statParts);
+}
+
+void MainFrame::updateHistory(const String &pathFileName)
+{
+  M68Reg m68Reg;
+  Array<SmartPointer<MDIWindow> >mdiWindows;
+
+	if(!m68Reg.insertHistory(pathFileName))return;
+	removeHistory(getFrameMenu());
+	applyHistory(getFrameMenu());
+  getDocuments(mdiWindows);
+  for(int index=0;index<mdiWindows.size();index++)
+	{
+	  SmartPointer<MDIWindow> &mdiWindow=mdiWindows[index];
+	  removeHistory(mdiWindow->getMenu());
+		applyHistory(mdiWindow->getMenu());
+	}
+}
+
+void MainFrame::removeHistory(PureMenu &pureMenu)
+{
+	M68Reg m68Reg;
+	UINT startID(StartDynamicID);
+	Block<String> nameList;
+	PureMenu fileMenu;
+
+	m68Reg.getHistory(nameList);
+	if(!nameList.size())return;
+	pureMenu.getSubMenu(0,fileMenu);
+	for(int itemIndex=0;itemIndex<nameList.size();itemIndex++)fileMenu.removeMenu(startID++,PureMenu::ByCommand);
+  int entries(fileMenu.size());
+	if((int)PureMenu::TypeSeparator&(int)fileMenu.getMenuItemType(entries-1,PureMenu::ByPosition))fileMenu.removeMenu(entries-1,PureMenu::ByPosition);
+}
+
+void MainFrame::applyHistory(PureMenu &pureMenu)
+{
+  M68Reg m68Reg;
+	Block<String> nameList;
+	PureMenu fileMenu;
+  String strItem;
+
+	m68Reg.getHistory(nameList);
+	if(!nameList.size())return;
+	pureMenu.getSubMenu(0,fileMenu);
+	fileMenu.appendSeparator();
+	for(int itemIndex=0;itemIndex<nameList.size();itemIndex++)
+	{
+	  ::sprintf(strItem,"%d) %s",itemIndex+1,(char*)nameList[itemIndex]);
+		fileMenu.appendMenu(StartDynamicID+itemIndex,strItem);
+	}
+}
+
+void MainFrame::createToolBar(void)
+{
+  Block<AddBitmap> addBitmaps;
+
+  mToolBar.create(*this,ToolBarID);
+	addBitmaps.insert(&AddBitmap(0,HINST_COMMCTRL));
+	if(!mToolBar.addBitmaps(addBitmaps))return;
+	mToolBar.addButton(ToolBarButton(STD_FILENEW,MenuFileNew,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
+	mToolBar.addButton(ToolBarButton(STD_FILEOPEN,MenuFileOpen,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
+	mToolBar.addButton(ToolBarButton(STD_FILESAVE,MenuFileSave,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
+	mToolBar.addButton(ToolBarButton(STD_PRINT,MenuFilePrint,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
+	mToolBar.addButton(ToolBarButton(STD_CUT,MenuEditCut,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
+	mToolBar.addButton(ToolBarButton(STD_COPY,MenuEditCopy,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
+	mToolBar.addButton(ToolBarButton(STD_PASTE,MenuEditPaste,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
+	mToolBar.addButton(ToolBarButton(STD_FIND,MenuEditFind,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
+	mToolBar.addButton(ToolBarButton(STD_PRINT,MenuFilePrint,ToolBarButton::StateEnabled,ToolBarButton::StyleButton));
+}
+
+BOOL MainFrame::bringDocumentToFront(const String &strTitle)
+{
+  Array<SmartPointer<MDIWindow> >mdiWindows;
+
+  getDocuments(mdiWindows);
+	for(int index=0;index<mdiWindows.size();index++)
+	{
+	  SmartPointer<MDIWindow> &mdiWindow=mdiWindows[index];
+    if(((CodeView&)*mdiWindow).getTitle()==strTitle){mdiWindow->bringWindowToTop();return TRUE;}
+	}
+	return false;
+}
+
+void MainFrame::splash(void)
+{
+  SplashScreen splashScreen("SPLASH","M68HC11");
+	splashScreen.perform();
+}
+
+// virtuals
+
+void MainFrame::mdiDestroy(MDIWindow &mdiWindow)
+{
+  Array<SmartPointer<MDIWindow> >mdiWindows;
+  WORD winCount(0);
+
+  getDocuments(mdiWindows);
+	for(int index=0;index<mdiWindows.size();index++)
+	{
+	  SmartPointer<MDIWindow> &mdiWindowPtr=mdiWindows[index];
+	  if(mdiWindowPtr->className()==String(STRING_CODEVIEWCLASSNAME)&&((MDIWindow*)mdiWindowPtr!=&mdiWindow))winCount++;
+	}
+	if(!winCount)setParts(SinglePart);
+}
+
+void MainFrame::mdiActivate(MDIWindow &mdiWindow)
+{
+  if(mdiWindow.className()==String(STRING_CODEVIEWCLASSNAME))setParts(DoublePart);
+  removeHistory(mdiWindow.getMenu());
+	applyHistory(mdiWindow.getMenu());
+}
+
+void MainFrame::mdiDeactivate(MDIWindow &/*mdiWindow*/)
+{
+}

m68hc11/backup/Mainfrm.hpp

@@ -0,0 +1,110 @@
+#ifndef _M68HC11_MAINFRAME_HPP_
+#define _M68HC11_MAINFRAME_HPP_
+#ifndef _COMMON_MDIFRM_HPP_
+#include <common/mdifrm.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _STATBAR_STATUSBAREX_HPP_
+#include <statbar/statbarx.hpp>
+#endif
+#ifndef _TOOLBAR_TOOLBAR_HPP_
+#include <toolbar/toolbar.hpp>
+#endif
+#ifndef _M68HC11_COMMCONTROL_HPP_
+#include <m68hc11/commctrl.hpp>
+#endif
+#ifndef _M68HC11_M68HC11_HPP_
+#include <m68hc11/m68hc11.hpp>
+#endif
+#ifndef _AS68HC11_M68ASSEMBLER_HPP_
+#include <as68hc11/asm6811.hpp>
+#endif
+
+class MainFrame : public FrameWindow
+{
+public:
+	MainFrame(void);
+	virtual ~MainFrame();
+	static String className(void);
+	void splash(void);
+protected:
+  virtual void mdiDestroy(MDIWindow &mdiWindow);
+  virtual void mdiActivate(MDIWindow &mdiWindow);
+  virtual void mdiDeactivate(MDIWindow &mdiWindow);
+private:
+  enum {StatusBarID=500,ToolBarID=501,StartDynamicID=30000};
+  enum{SinglePart=1,DoublePart=2,FirstPartWidth=340,SecondPartWidth=420};
+  enum{MenuFileSave=SBCMENU_FILESAVE,MenuFileQuit=SBCMENU_FILEQUIT,MenuFilePrint=SBCMENU_FILEPRINT,
+	     MenuSettingsSerial=SBCMENU_SETTINGSSERIAL,MenuHelpContents=SBCMENU_HELPCONTENTS,
+			 MenuHelpSearch=SBCMENU_HELPSEARCH,MenuRegistration=SBCMENU_REGISTRATION,MenuFileNew=SBCMENU_FILENEW,
+			 MenuFileOpen=SBCMENU_FILEOPEN,MenuHelpAbout=SBCMENU_HELPABOUT,MenuFileClose=SBCMENU_FILECLOSE,
+			 MenuFileSaveAs=SBCMENU_FILESAVEAS,MenuCascade=IDM_CASCADE,MenuTile=IDM_TILE,MenuArrange=IDM_ARRANGE,
+			 MenuCloseAll=IDM_CLOSEALL,MenuMinimizeAll=IDM_MINIMIZEALL,MenuRestoreAll=IDM_RESTOREALL,
+			 MenuEditCut=SBCMENU_EDITCUT,MenuEditCopy=SBCMENU_EDITCOPY,MenuEditPaste=SBCMENU_EDITPASTE,
+			 MenuEditFind=SBCMENU_EDITFIND,MenuCodeCompile=SBCMENU_CODECOMPILE,
+			 MenuCodeCompileAndLoad=SBCMENU_CODECOMPILEANDLOAD};
+  CallbackData::ReturnType queryEndSessionHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType paintHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType keyDownHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType sizeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType timerHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType activateAppHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType displayChangeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType lineHandler(CallbackData &someCallbackData);
+	void createToolBar(void);
+  void handleCodeCompile(void);
+	void handleCodeCompileAndLoad(void);
+	void handleCommunications(void);
+  void handleEditCut(void);
+  void handleEditCopy(void);
+  void handleEditPaste(void);
+  void handleEditFind(void);
+  void handleFileNew(void);
+  void handleFileOpen(void);
+	void handleFileOpen(CallbackData &someCallbackData);
+  void handleFileOpen(const String &strPathFileName);
+	void handleFileClose(void);
+	void handleFilePrint(void);
+	void handleHelp(void);
+	BOOL handleFileSave(void);
+  BOOL handleFileSaveAs(void);
+  BOOL codeLoad(const String &strPathBinary);
+	void registerClass(void)const;
+	void insertHandlers(void);
+	void removeHandlers(void);
+	void setParts(int numParts);
+  void applyHistory(PureMenu &pureMenu);
+  void updateHistory(const String &pathFileName);
+  void removeHistory(PureMenu &pureMenu);
+  BOOL bringDocumentToFront(const String &strTitle);
+
+  Callback<MainFrame> mQueryEndSessionHandler;
+	Callback<MainFrame> mPaintHandler;
+	Callback<MainFrame> mDestroyHandler;
+	Callback<MainFrame> mCommandHandler;
+	Callback<MainFrame> mSizeHandler;
+	Callback<MainFrame> mCreateHandler;
+	Callback<MainFrame> mLineHandler;
+	SmartPointer<StatusBarEx> mStatusBar;
+	CommControl mCommControl;
+	ToolBar mToolBar;
+//	SerialSettings mSerialSettings;
+	M68Assembler m68Assembler;
+	static char szClassName[];
+	static char szMenuName[];
+};
+
+inline
+String MainFrame::className(void)
+{
+	return String(szClassName);
+}
+#endif

m68hc11/backup/ODLSTLED.CPP

@@ -0,0 +1,129 @@
+#include <m68hc11/odlstled.hpp>
+#include <common/drawitem.hpp>
+#include <common/measure.hpp>
+#include <common/purebmp.hpp>
+
+OwnerDrawListBinaryLed::OwnerDrawListBinaryLed(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID)
+: OwnerDrawList(parentWnd,hControlWnd,controlID), mRGBGray(192,192,192), mGrayBrush(mRGBGray), 
+  mDisabledBrush(RGBColor(128,128,128)), mOneBitmap("ONE"), mZeroBitmap("ZERO"), mBlankBitmap("BLANK"),
+	mDashBitmap("DASH"), mFont("Courier",14)
+{
+}
+
+OwnerDrawListBinaryLed::OwnerDrawListBinaryLed(GUIWindow &parentWnd,const Rect &initRect,int controlID,DWORD style)
+: OwnerDrawList(parentWnd,initRect,controlID,style), mRGBGray(192,192,192), mGrayBrush(mRGBGray),
+  mDisabledBrush(RGBColor(128,128,128)), mOneBitmap("ONE"), mZeroBitmap("ZERO"), mBlankBitmap("BLANK"),
+	mDashBitmap("DASH"), mFont("Courier",14)
+{
+}
+
+OwnerDrawListBinaryLed::~OwnerDrawListBinaryLed()
+{
+}
+
+OwnerDrawListBinaryLed &OwnerDrawListBinaryLed::operator=(const OwnerDrawListBinaryLed &/*someOwnerDrawListBinaryLed*/)
+{  // private implementation
+  return *this;
+}
+
+// **** virtuals
+
+LPARAM OwnerDrawListBinaryLed::handleControlColor(PureDevice &/*pureDevice*/,Control &/*wndListBox*/)
+{
+  return (LPARAM)(GDIObj)mGrayBrush;
+}
+
+WORD OwnerDrawListBinaryLed::handleDraw(const DrawItem &drawItem)
+{
+	if(!isOkay()||-1==drawItem.itemID()||DrawItem::ListBox!=drawItem.controlType())return FALSE;
+	PureDevice pureDevice(drawItem.deviceContext());
+	pureDevice.setBkColor(mRGBGray);
+  switch(drawItem.itemAction())
+	{
+		case DrawItem::Select :
+		case DrawItem::DrawEntire :
+		case DrawItem::Focus :
+			drawEntire(drawItem);
+			break;
+	}
+  return TRUE;
+}
+
+WORD OwnerDrawListBinaryLed::handleMeasureItem(MeasureItem &measureItem)
+{
+  measureItem.itemHeight(20);
+	return TRUE;
+}
+
+void OwnerDrawListBinaryLed::drawEntire(const DrawItem &drawItem)
+{
+	PureDevice pureDevice(drawItem.deviceContext());
+	PureDevice memDevice;
+	String stringData;
+	String strNumber;
+	TEXTMETRIC textMetric;
+	Rect drawRect;
+	SIZE sizeExtent;
+	HFONT hPrevFont;
+
+	if(!isOkay())return;
+  stringData.reserve(256);
+	drawRect=drawItem.rectItem();
+  hPrevFont=(HFONT)::SelectObject(drawItem.deviceContext(),(GDIObj)mFont);
+	memDevice.compatibleDevice(pureDevice);
+	sendMessage(drawItem.hwndItem(),LB_GETTEXT,drawItem.itemID(),(LPARAM)(LPSTR)stringData);
+	strNumber=stringData.betweenString('\t',0);
+	if(strNumber.isNull())setBitmap();
+	else 
+	{
+	  setBitmap(::atoi(strNumber));
+		stringData=stringData.betweenString(0,'\t');
+	}
+  if(stringData.isNull())::MessageBeep(0);
+	::GetTextMetrics(drawItem.deviceContext(),&textMetric);
+	::GetTextExtentPoint32(drawItem.deviceContext(),(LPSTR)stringData,stringData.length(),&sizeExtent);
+	if(drawItem.itemState()&ODS_DISABLED)
+	{
+	  ::GrayString(drawItem.deviceContext(),(HBRUSH)(GDIObj)mDisabledBrush,(GRAYSTRINGPROC)0,(LPARAM)(LPSTR)stringData,stringData.length(),mBlankBitmap.width()+6,(drawRect.bottom()+drawRect.top()-textMetric.tmHeight)/2,0,0);
+	  memDevice.select(mBlankBitmap,TRUE);
+    Rect stretchRect(drawRect);
+		stretchRect.right(mBlankBitmap.width());
+		stretchRect.bottom(sizeExtent.cy);
+		pureDevice.stretchBlt(stretchRect,memDevice,Rect(0,0,mBlankBitmap.width(),mBlankBitmap.height()),PureDevice::MergeCopy);
+		memDevice.select(mBlankBitmap,FALSE);
+	}
+	else 
+	{
+	  ::TextOut(drawItem.deviceContext(),mBlankBitmap.width()+6,(drawRect.bottom()+drawRect.top()-textMetric.tmHeight)/2,(LPSTR)stringData,stringData.length());
+	  memDevice.select(mBlankBitmap,TRUE);
+    Rect stretchRect(drawRect);
+		stretchRect.right(mBlankBitmap.width());
+		stretchRect.bottom(sizeExtent.cy);
+		pureDevice.stretchBlt(stretchRect,memDevice,Rect(0,0,mBlankBitmap.width(),mBlankBitmap.height()),PureDevice::MergeCopy);
+	  memDevice.select(mBlankBitmap,FALSE);
+	}
+  if((((UINT)drawItem.itemState())&ODS_FOCUS))
+	{
+		Rect bmpRect(drawRect);
+		bmpRect.right(bmpRect.left()+mBlankBitmap.width());
+		bmpRect.bottom(bmpRect.top()+sizeExtent.cy);
+		::DrawFocusRect(drawItem.deviceContext(),(RECT*)&bmpRect);
+	}
+  ::SelectObject(drawItem.deviceContext(),hPrevFont);
+}
+
+void OwnerDrawListBinaryLed::setBitmap(BYTE value)
+{
+  for(int index=0,mask=0x80;index<8;index++,mask/=2)
+	  mBlankBitmap.setFrom(value&mask?mOneBitmap:mZeroBitmap,getPlacementRect(index));
+}
+
+void OwnerDrawListBinaryLed::setBitmap(void)
+{
+  for(int index=0,mask=0x80;index<8;index++,mask/=2)mBlankBitmap.setFrom(mDashBitmap,getPlacementRect(index));
+}
+
+Rect OwnerDrawListBinaryLed::getPlacementRect(int position)
+{
+  return Rect(position*CellWidth,0,CellWidth,CellHeight);
+}

m68hc11/backup/ODLSTLED.HPP

@@ -0,0 +1,44 @@
+#ifndef _COMMON_OWNERDRAWLISTBINARYLED_HPP_
+#define _COMMON_OWNERDRAWLISTBINARYLED_HPP_
+#ifndef _COMMON_BRUSH_HPP_
+#include <common/brush.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _COMMON_OWNERDRAWLIST_HPP_
+#include <common/odlist.hpp>
+#endif
+#ifndef _COMMON_PUREBITMAP_HPP_
+#include <common/purebmp.hpp>
+#endif
+
+class OwnerDrawListBinaryLed : public OwnerDrawList
+{
+public:
+  OwnerDrawListBinaryLed(GUIWindow &parentWnd,HWND hControlWnd,UINT controlID);
+  OwnerDrawListBinaryLed(GUIWindow &parentWnd,const Rect &initRect,int controlID,DWORD style=LBS_NOTIFY|WS_BORDER|LBS_HASSTRINGS|WS_VSCROLL|LBS_OWNERDRAWFIXED|WS_CLIPCHILDREN|WS_CLIPSIBLINGS);
+	virtual ~OwnerDrawListBinaryLed();
+	OwnerDrawListBinaryLed &operator=(const OwnerDrawListBinaryLed &someOwnerDrawListBinaryLed);
+protected:
+  virtual WORD handleDraw(const DrawItem &drawItem);
+	virtual WORD handleMeasureItem(MeasureItem &measureItem);
+	virtual LPARAM handleControlColor(PureDevice &pureDevice,Control &wndListBox);
+  virtual void drawEntire(const DrawItem &drawItem);
+private:
+  enum {BmSel=0,BmUnSel=1};
+	enum {CellWidth=13,CellHeight=23};
+  Rect getPlacementRect(int position);
+  void setBitmap(BYTE value);
+	void setBitmap(void);
+
+  PureBitmap mBlankBitmap;
+	PureBitmap mOneBitmap;
+	PureBitmap mZeroBitmap;
+	PureBitmap mDashBitmap;
+  Font mFont;
+	RGBColor mRGBGray;
+	Brush mGrayBrush;
+  Brush mDisabledBrush;
+};
+#endif

m68hc11/backup/SERDLG.CPP

@@ -0,0 +1,313 @@
+#include <m68hc11/serdlg.hpp>
+#include <m68hc11/m68reg.hpp>
+
+SerialDlg::SerialDlg(void)
+{
+  mInitHandler.setCallback(this,&SerialDlg::initHandler);
+  mDestroyHandler.setCallback(this,&SerialDlg::destroyHandler);
+	mCommandHandler.setCallback(this,&SerialDlg::commandHandler);
+	mCloseHandler.setCallback(this,&SerialDlg::closeHandler);
+  DWindow::insertHandler(VectorHandler::InitDialogHandler,&mInitHandler);
+	DWindow::insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	DWindow::insertHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	DWindow::insertHandler(VectorHandler::CloseHandler,&mCloseHandler);
+}
+
+SerialDlg::~SerialDlg()
+{
+  DWindow::removeHandler(VectorHandler::InitDialogHandler,&mInitHandler);
+	DWindow::removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	DWindow::removeHandler(VectorHandler::CommandHandler,&mCommandHandler);
+	DWindow::removeHandler(VectorHandler::CloseHandler,&mCloseHandler);
+}
+
+SerialDlg &SerialDlg::operator=(const SerialDlg &/*someSerialDlg*/)
+{  // private implementation
+  return *this;
+}
+
+BOOL SerialDlg::perform(GUIWindow &parentWindow) // ,SerialSettings &serialSettings)
+{
+  return ::DialogBoxParam(processInstance(),(LPSTR)"SERIAL",(HWND)parentWindow,DWindow::DlgProc,(LPARAM)(DWindow*)this);
+}
+
+CallbackData::ReturnType SerialDlg::initHandler(CallbackData &/*someCallbackData*/)
+{
+  mStatusBar=::new StatusBarEx(*this,StatusBarID);
+	mStatusBar.disposition(PointerDisposition::Delete);
+	initSerialSettings();
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType SerialDlg::destroyHandler(CallbackData &/*someCallbackData*/)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType SerialDlg::commandHandler(CallbackData &someCallbackData)
+{
+  switch(someCallbackData.wmCommandID())
+	{
+	  case IDOK :
+		  if(applySerialSettings())endDialog(TRUE);
+		  break;
+		case IDCANCEL :
+		  endDialog(FALSE);
+		  break;
+		case SerialStopBits :
+		case SerialParity :
+		case SerialDataBits :
+		case SerialBaud :
+		case SerialPort :
+	    mStatusBar->setText(" ");
+		  break;
+		case SerialApply :
+		  applySerialSettings();
+			break;
+		case SerialTest :
+		  testDevice();
+		  break;
+	}
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType SerialDlg::closeHandler(CallbackData &/*someCallbackData*/)
+{
+  return (CallbackData::ReturnType)FALSE;
+}
+
+void SerialDlg::initSerialSettings(void)
+{
+  M68Reg mcuReg;
+
+	initPorts();
+	initBaud();
+	initDataBits();
+	initStopBits();
+	initParity();
+  sendMessage(SerialPort,CB_SELECTSTRING,-1,(LPARAM)(LPSTR)mcuReg.getPort());
+  sendMessage(SerialBaud,CB_SELECTSTRING,-1,(LPARAM)(LPSTR)mcuReg.getBaud());
+	sendMessage(SerialDataBits,CB_SELECTSTRING,-1,(LPARAM)(LPSTR)mcuReg.getDataBits());
+  sendMessage(SerialParity,CB_SELECTSTRING,-1,(LPARAM)(LPSTR)mcuReg.getParity());
+  sendMessage(SerialStopBits,CB_SELECTSTRING,-1,(LPARAM)(LPSTR)mcuReg.getStopBits());
+}
+
+void SerialDlg::initPorts(void)
+{
+  String strPort;
+  CommControl commControl;
+  Block<CommControl::Port> ports;
+
+  sendMessage(SerialPort,CB_RESETCONTENT,0,0L);
+	commControl.enumerateDevices(ports);
+	for(int index=0;index<ports.size();index++)
+	{
+	  if(ports[index]==CommControl::PortCOM1)sendMessage(SerialPort,CB_ADDSTRING,0,(LPARAM)(LPSTR)String(STRING_COM1));
+		else if(ports[index]==CommControl::PortCOM2)sendMessage(SerialPort,CB_ADDSTRING,0,(LPARAM)(LPSTR)String(STRING_COM2));
+		else if(ports[index]==CommControl::PortCOM3)sendMessage(SerialPort,CB_ADDSTRING,0,(LPARAM)(LPSTR)String(STRING_COM3));
+		else if(ports[index]==CommControl::PortCOM4)sendMessage(SerialPort,CB_ADDSTRING,0,(LPARAM)(LPSTR)String(STRING_COM4));
+	}
+}
+
+void SerialDlg::initBaud(void)
+{
+  String strBaudRate;
+
+  sendMessage(SerialBaud,CB_RESETCONTENT,0,0L);
+	sendMessage(SerialBaud,CB_ADDSTRING,0,(LPARAM)(LPSTR)"1200");
+	sendMessage(SerialBaud,CB_ADDSTRING,0,(LPARAM)(LPSTR)"2400");
+	sendMessage(SerialBaud,CB_ADDSTRING,0,(LPARAM)(LPSTR)"4800");
+	sendMessage(SerialBaud,CB_ADDSTRING,0,(LPARAM)(LPSTR)"9600");
+	sendMessage(SerialBaud,CB_ADDSTRING,0,(LPARAM)(LPSTR)"14400");
+	sendMessage(SerialBaud,CB_ADDSTRING,0,(LPARAM)(LPSTR)"19200");
+	sendMessage(SerialBaud,CB_ADDSTRING,0,(LPARAM)(LPSTR)"38400");
+	sendMessage(SerialBaud,CB_ADDSTRING,0,(LPARAM)(LPSTR)"57600");
+	sendMessage(SerialBaud,CB_ADDSTRING,0,(LPARAM)(LPSTR)"115200");
+}
+
+void SerialDlg::initDataBits(void)
+{
+  sendMessage(SerialDataBits,CB_RESETCONTENT,0,0L);
+	sendMessage(SerialDataBits,CB_ADDSTRING,0,(LPARAM)(LPSTR)"4");
+	sendMessage(SerialDataBits,CB_ADDSTRING,0,(LPARAM)(LPSTR)"5");
+	sendMessage(SerialDataBits,CB_ADDSTRING,0,(LPARAM)(LPSTR)"6");
+	sendMessage(SerialDataBits,CB_ADDSTRING,0,(LPARAM)(LPSTR)"7");
+	sendMessage(SerialDataBits,CB_ADDSTRING,0,(LPARAM)(LPSTR)"8");
+}
+
+void SerialDlg::initParity(void)
+{
+  sendMessage(SerialParity,CB_RESETCONTENT,0,0L);
+	sendMessage(SerialParity,CB_ADDSTRING,0,(LPARAM)(LPSTR)"None");
+	sendMessage(SerialParity,CB_ADDSTRING,0,(LPARAM)(LPSTR)"Odd");
+	sendMessage(SerialParity,CB_ADDSTRING,0,(LPARAM)(LPSTR)"Even");
+	sendMessage(SerialParity,CB_ADDSTRING,0,(LPARAM)(LPSTR)"Mark");
+	sendMessage(SerialParity,CB_ADDSTRING,0,(LPARAM)(LPSTR)"Space");
+}
+
+void SerialDlg::initStopBits()
+{
+  sendMessage(SerialStopBits,CB_RESETCONTENT,0,0L);
+	sendMessage(SerialStopBits,CB_ADDSTRING,0,(LPARAM)(LPSTR)"1");
+	sendMessage(SerialStopBits,CB_ADDSTRING,0,(LPARAM)(LPSTR)"1.5");
+	sendMessage(SerialStopBits,CB_ADDSTRING,0,(LPARAM)(LPSTR)"2");
+}
+
+CommControl::Port SerialDlg::getCommPort(void)const
+{
+  String strPort;
+
+	sendMessage(SerialPort,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strPort);
+	return CommControl::stringToPort(strPort);
+}
+
+String SerialDlg::getCommSettings(void)const
+{  
+  String strBaud;
+	String strDataBits;
+  String strSettings;
+	String strParity;
+	String strStopBits;
+	LRESULT currSel;
+
+	sendMessage(SerialBaud,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strBaud);
+	strSettings+="baud=";
+	strSettings+=strBaud;
+	strSettings+=" ";
+	sendMessage(SerialDataBits,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strDataBits);
+	strSettings+="data=";
+	strSettings+=strDataBits;
+	strSettings+=" ";
+	currSel=sendMessage(SerialParity,CB_GETCURSEL,0,0L);
+	sendMessage(SerialParity,CB_GETLBTEXT,0,(LPARAM)(LPSTR)strParity);
+	if(String("None")==strParity)strParity="N";
+	else if(String("Odd")==strParity)strParity="O";
+	else if(String("Even")==strParity)strParity="E";
+	else if(String("Space")==strParity)strParity="S";
+  strSettings+="parity=";
+	strSettings+=strParity;
+	strSettings+=" ";
+  currSel=sendMessage(SerialStopBits,CB_GETCURSEL,0,0L);
+  sendMessage(SerialStopBits,CB_GETLBTEXT,0,(LPARAM)(LPSTR)strStopBits);
+	strSettings+="stop=";
+	strSettings+=strStopBits;
+	return strSettings;
+}
+
+bool SerialDlg::applySerialSettings(void)
+{
+	CommControl commControl;
+	M68Reg mcuReg;
+	String strCommSettings;
+	String strBaud;
+	String strDataBits;
+	String strStopBits;
+	String strParity;
+	LRESULT currSel;
+
+	strCommSettings=getCommSettings();
+	if(!commControl.open(getCommPort()))
+	{
+	  mStatusBar->setText("Error opening port.");
+		::MessageBeep(0);
+		return false;
+	}
+  if(!commControl.setDeviceControlBlock(strCommSettings)){mStatusBar->setText("Failed to apply settings.");return false;}
+	sendMessage(SerialBaud,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strBaud);
+  mcuReg.setBaud(strBaud);
+	sendMessage(SerialDataBits,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strDataBits);
+	mcuReg.setDataBits(strDataBits);
+	currSel=sendMessage(SerialParity,CB_GETCURSEL,0,0L);
+	sendMessage(SerialParity,CB_GETLBTEXT,0,(LPARAM)(LPSTR)strParity);
+	if(String("None")==strParity)strParity="N";
+	else if(String("Odd")==strParity)strParity="O";
+	else if(String("Even")==strParity)strParity="E";
+	else if(String("Space")==strParity)strParity="S";
+  mcuReg.setParity(strParity);
+  currSel=sendMessage(SerialStopBits,CB_GETCURSEL,0,0L);
+  sendMessage(SerialStopBits,CB_GETLBTEXT,0,(LPARAM)(LPSTR)strStopBits);
+  mcuReg.setStopBits(strStopBits);
+  mStatusBar->setText("Settings have been applied.");
+	return true;
+}
+
+void SerialDlg::testDevice(void)
+{
+  CommControl commControl;
+	BYTE prefix(0xFF);
+	GlobalData<BYTE> rcvBuffer;
+	GlobalData<BYTE> sndBuffer;
+  BYTE codeBytes[]={0x8E,0x00,0xFF,0xCE,0x10,0x00,0x6F,0x2C,0xCC,0x33,0x0C,0xA7,0x2B,0xE7,0x2D,0x1F,0x2E,0x20,0xFC,0xA6,0x2F,0x4C,0x1F,0x2E,0x80,0xFC,0xA7,0x2F,0x7E,0x00,0x0F};
+
+  sndBuffer.size(256);
+	sndBuffer.setZero();
+	rcvBuffer.size(sndBuffer.size());
+	rcvBuffer.setZero();
+	::memcpy(&sndBuffer[0],codeBytes,sizeof(codeBytes));
+  if(IDCANCEL==::MessageBox(*this,"This operation will overwrite the contents of MCU RAM with the ECHO program.","WARNING",MB_OKCANCEL))return;
+	if(!commControl.open(getCommPort())){mStatusBar->setText("Error opening port.");return;}
+  if(!commControl.setDeviceControlBlock(getCommSettings())){mStatusBar->setText("Failed to apply settings.");return;}
+	mStatusBar->setText("waiting for break signal....please reset the device.");
+	if(!commControl.waitForBreak()){mStatusBar->setText("timeout waiting for break.");return;}
+	mStatusBar->setText("break received, loading code...");
+	commControl.write(&prefix,sizeof(prefix));
+	commControl.clearReceiveQueue();
+	commControl.write(sndBuffer);
+	mStatusBar->setText("Waiting for response.");
+	if(!commControl.waitForData()){mStatusBar->setText("Timeout reached for receive.");return;}
+	commControl.readFully(rcvBuffer);
+	if(::memcmp(&rcvBuffer[0],&sndBuffer[0],sndBuffer.size()))
+	{
+	  mStatusBar->setText("Failed to verify program load.");
+		return;
+  }
+	::Sleep(250);
+	if(!echo(commControl))mStatusBar->setText("Received unexpected results from program.");
+	else mStatusBar->setText("The program has been verified, all tests successful.");
+  return;
+}
+
+bool SerialDlg::echo(CommControl &commControl)
+{
+	BYTE sndByte('a');
+	BYTE rcvByte=0;
+	DWORD rcvCount(0);
+	String str;
+
+  if(!commControl.isOkay())
+	{
+	  if(!commControl.open(getCommPort())){mStatusBar->setText("Unable to open comm port.");mStatusBar->setText("Error opening port.");return false;}
+    if(!commControl.setDeviceControlBlock(getCommSettings())){mStatusBar->setText("Failed to apply settings.");return false;}
+  }
+	commControl.clearError();
+	while('z'!=rcvByte)
+	{
+	  CommStatus commStatus;
+	  commControl.write(&sndByte,sizeof(sndByte));
+    if(commControl.waitForData()) 
+		{
+			rcvByte=0;
+      commControl.read(&rcvByte,sizeof(rcvByte));
+			str+=rcvByte;
+			mStatusBar->setText(str);
+			if(!rcvCount&&rcvByte!='b')
+			{
+			  mStatusBar->setText("Unexpected character in input stream.");
+			  return false;
+		  }
+			sndByte++;
+			rcvCount++;
+		}
+	}
+	::Sleep(250);
+	return true;
+}
+
+String SerialDlg::getByteString(BYTE charByte)
+{
+  String str;
+	::sprintf(str.str(),"char:%d(0x%08lx)",(int)charByte,(int)charByte);
+	return str;
+}
+
+

m68hc11/backup/SERDLG.HPP

@@ -0,0 +1,61 @@
+#ifndef _M68HC11_SERIALDLG_HPP_
+#define _M68HC11_SERIAL_HPP_
+#ifndef _COMMON_DWINDOW_HPP_
+#include <common/dwindow.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _M68HC11_M68HC11_HPP_
+#include <m68hc11/m68hc11.hpp>
+#endif
+#ifndef _STATBAR_STATUSBAREX_HPP_
+#include <statbar/statbarx.hpp>
+#endif
+#ifndef _COMMON_COMMCONTROL_HPP_
+#include <m68hc11/commctrl.hpp>
+#endif
+
+class CommControl;
+
+class SerialDlg : public DWindow
+{
+public:
+  SerialDlg(void);
+	virtual ~SerialDlg();
+  BOOL perform(GUIWindow &parentWindow);
+private:
+  enum{SerialStopBits=SERIAL_STOP,SerialParity=SERIAL_PARITY,SerialDataBits=SERIAL_DATA,
+	     SerialBaud=SERIAL_BAUD,SerialPort=SERIAL_PORT,SerialApply=SERIAL_APPLY,SerialTest=SERIAL_TEST};
+	enum {StatusBarID=500};
+	SerialDlg &operator=(const SerialDlg &someSerialDlg);
+	CallbackData::ReturnType initHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType closeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType dlgCodeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType controlColorHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType measureItemHandler(CallbackData &someCallbackData);
+	String getByteString(BYTE charByte);
+  CommControl::Port getCommPort(void)const;
+  String getCommSettings(void)const;
+  bool applySerialSettings(void);
+	void initSerialSettings(void);
+  void testDevice(void);
+  void initDataBits(void);
+  void initParity(void);
+  void initStopBits(void);
+	void initPorts(void);
+	void initBaud(void);
+  bool echo(CommControl &commControl);
+
+	Callback<SerialDlg> mInitHandler;
+	Callback<SerialDlg> mDestroyHandler;
+	Callback<SerialDlg> mCommandHandler;
+	Callback<SerialDlg> mCloseHandler;
+	SmartPointer<StatusBarEx> mStatusBar;
+};
+#endif

m68hc11/backup/SETTINGS.HPP

@@ -0,0 +1,130 @@
+#ifndef _M68HC11_SERIALSETUP_HPP_
+#define _M68HC11_SERIALSETUP_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class SerialSettings
+{
+public:
+  SerialSettings(void);
+	SerialSettings(const SerialSettings &someSerialSettings);
+	virtual ~SerialSettings();
+	SerialSettings &operator=(const SerialSettings &someSerialSettings);
+	BOOL operator==(const SerialSettings &someSerialSettings)const;
+  DWORD port(void)const;
+	void port(DWORD port);
+	DWORD baudRate(void)const;
+	void baudRate(DWORD baudRate);
+	DWORD parity(void)const;
+	void parity(DWORD parity);
+	DWORD stopBits(void)const;
+	void stopBits(DWORD stopBits);
+	DWORD dataBits(void)const;
+	void dataBits(DWORD dataBits);
+private:
+  DWORD mSerialPort;
+  DWORD mBaudRate;
+	DWORD mParity;
+	DWORD mStopBits;
+	DWORD mDataBits;
+};
+
+inline
+SerialSettings::SerialSettings(void)
+: mSerialPort(0), mBaudRate(1200), mParity(0), mStopBits(0), mDataBits(8)
+{
+}
+
+inline
+SerialSettings::SerialSettings(const SerialSettings &someSerialSettings)
+{
+  *this=someSerialSettings;
+}
+
+inline
+SerialSettings::~SerialSettings()
+{
+}
+
+inline
+SerialSettings &SerialSettings::operator=(const SerialSettings &someSerialSettings)
+{
+  port(someSerialSettings.port());
+	baudRate(someSerialSettings.baudRate());
+	parity(someSerialSettings.parity());
+	stopBits(someSerialSettings.stopBits());
+	dataBits(someSerialSettings.dataBits());
+	return *this;
+}
+
+inline
+BOOL SerialSettings::operator==(const SerialSettings &someSerialSettings)const
+{
+  return (port()==someSerialSettings.port()&&
+	        baudRate()==someSerialSettings.baudRate()&&
+					parity()==someSerialSettings.parity()&&
+					stopBits()==someSerialSettings.stopBits()&&
+					dataBits()==someSerialSettings.dataBits());
+}
+
+inline
+DWORD SerialSettings::port(void)const
+{
+  return mSerialPort;
+}
+
+inline
+void SerialSettings::port(DWORD port)
+{
+  mSerialPort=port;
+}
+
+inline
+DWORD SerialSettings::baudRate(void)const
+{
+  return mBaudRate;
+}
+
+inline
+void SerialSettings::baudRate(DWORD baudRate)
+{
+  mBaudRate=baudRate;
+}
+
+inline
+DWORD SerialSettings::parity(void)const
+{
+  return mParity;
+}
+
+inline
+void SerialSettings::parity(DWORD parity)
+{
+  mParity=parity;
+}
+
+inline
+DWORD SerialSettings::stopBits(void)const
+{
+  return mStopBits;
+}
+
+inline
+void SerialSettings::stopBits(DWORD stopBits)
+{
+  mStopBits=stopBits;
+}
+
+inline
+DWORD SerialSettings::dataBits(void)const
+{
+  return mDataBits;
+}
+
+inline
+void SerialSettings::dataBits(DWORD dataBits)
+{
+  mDataBits=dataBits;
+}
+#endif

m68hc11/backup/SPLASH.CPP

@@ -0,0 +1,156 @@
+#include <m68hc11/splash.hpp>
+#include <common/resbmp.hpp>
+#include <common/dib.hpp>
+#include <common/bitmap.hpp>
+
+char SplashScreen::szClassName[]="SplashScreen";
+
+SplashScreen::SplashScreen(const String &strBitmap,const String &strCaption,UINT timeout) 
+: mBitmapName(strBitmap), mStrCaption(strCaption), mTimeout(timeout),
+  mTextFont("Times New Roman",12,Font::PitchVariable|Font::FamilySwiss,Font::WeightBold)
+{
+  mResBitmap=new ResBitmap(mBitmapName);
+	mResBitmap.disposition(PointerDisposition::Delete);
+  mCreateHandler.setCallback(this,&SplashScreen::createHandler);
+	mPaintHandler.setCallback(this,&SplashScreen::paintHandler);
+	mDestroyHandler.setCallback(this,&SplashScreen::destroyHandler);
+	mPaletteChangedHandler.setCallback(this,&SplashScreen::paletteChangedHandler);
+	mSetFocusHandler.setCallback(this,&SplashScreen::setFocusHandler);
+	mTimerHandler.setCallback(this,&SplashScreen::timerHandler);
+	insertHandler(VectorHandler::CreateHandler,&mCreateHandler);
+	insertHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	insertHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	insertHandler(VectorHandler::PaletteChangedHandler,&mPaletteChangedHandler);
+	insertHandler(VectorHandler::SetFocusHandler,&mSetFocusHandler);
+	insertHandler(VectorHandler::TimerHandler,&mTimerHandler);
+	registerClass();
+}
+
+SplashScreen::SplashScreen(const SplashScreen &someSplashScreen)
+{ // private implementation
+}
+
+SplashScreen::~SplashScreen()
+{
+	removeHandler(VectorHandler::CreateHandler,&mCreateHandler);
+  removeHandler(VectorHandler::PaintHandler,&mPaintHandler);
+	removeHandler(VectorHandler::DestroyHandler,&mDestroyHandler);
+	removeHandler(VectorHandler::PaletteChangedHandler,&mPaletteChangedHandler);
+	removeHandler(VectorHandler::SetFocusHandler,&mSetFocusHandler);
+	removeHandler(VectorHandler::TimerHandler,&mTimerHandler);
+}
+
+void SplashScreen::registerClass(void)
+{
+  HINSTANCE hInstance(processInstance());
+	WNDCLASS wndClass;
+
+	if(::GetClassInfo(hInstance,szClassName,(WNDCLASS FAR*)&wndClass))return;
+	wndClass.style         =CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS|CS_OWNDC;
+	wndClass.lpfnWndProc   =(WNDPROC)Window::WndProc;
+	wndClass.cbClsExtra    =0;
+	wndClass.cbWndExtra    =sizeof(SplashScreen*);
+	wndClass.hInstance     =hInstance;
+	wndClass.hIcon         =::LoadIcon(NULL,IDI_APPLICATION);
+	wndClass.hCursor       =::LoadCursor(NULL,IDC_ARROW);
+  wndClass.hbrBackground =(HBRUSH)::GetStockObject(NULL_BRUSH);
+	wndClass.lpszMenuName  =0;
+	wndClass.lpszClassName =szClassName;
+	::RegisterClass(&wndClass);
+	assert(0!=::GetClassInfo(hInstance,szClassName,(WNDCLASS FAR*)&wndClass));
+}
+
+SplashScreen &SplashScreen::operator=(const SplashScreen &someSplashScreen)
+{ // private implementation
+  return *this;
+}
+
+BOOL SplashScreen::perform(Rect initRect)
+{ 
+  UINT style(0);
+  if(CW_USEDEFAULT==initRect.right())initRect.right(mResBitmap->width());
+	if(CW_USEDEFAULT==initRect.bottom())initRect.bottom(mResBitmap->height());
+	if(timeout())
+//	if(useTimer())
+	{
+	  PureDevice pureDevice;
+		pureDevice.screenDevice();
+		initRect.left((pureDevice.horizontalResolution()-mResBitmap->width())/2);
+		initRect.top((pureDevice.verticalResolution()-mResBitmap->height())/2);
+	  style=WS_POPUP|WS_CLIPSIBLINGS|0x04|WS_DLGFRAME;
+	}
+	else style=WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_BORDER|WS_DLGFRAME|0x04|WS_CLIPSIBLINGS;
+  createWindow(WS_EX_CONTROLPARENT,szClassName,timeout()?(char*)0:(char*)mStrCaption,style,initRect,NULL,NULL,processInstance(),(LPSTR)this);  // WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_BORDER|WS_DLGFRAME|0x04|WS_CLIPSIBLINGS
+	show(SW_SHOW);
+	update();
+	return messageLoop();
+}
+
+CallbackData::ReturnType SplashScreen::destroyHandler(CallbackData &someCallbackData)
+{
+  PureDevice pureDevice(*this);
+	((PurePalette&)*mDIBitmap).usePalette(pureDevice,FALSE);
+  postQuitMessage(onDestroy());
+	return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType SplashScreen::createHandler(CallbackData &someCallbackData)
+{
+	mPureDevice=new PureDevice(*this);
+	mPureDevice.disposition(PointerDisposition::Delete);
+  mDIBitmap=new DIBitmap(*mPureDevice,mResBitmap->width(),mResBitmap->height(),*mResBitmap);
+	mDIBitmap.disposition(PointerDisposition::Delete);
+	if(timeout())setTimer(TimerID,timeout());
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType SplashScreen::timerHandler(CallbackData &someCallbackData)
+{
+  killTimer(TimerID);
+	postMessage(*this,WM_CLOSE,0,0L);
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType SplashScreen::paletteChangedHandler(CallbackData &someCallbackData)
+{
+  if(!mDIBitmap.isOkay()||((HWND)*this==(HWND)someCallbackData.wParam()))return (CallbackData::ReturnType)FALSE;
+  PureDevice pureDevice(*this);
+	((PurePalette&)*mDIBitmap).usePalette(pureDevice,TRUE);
+	update();
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType SplashScreen::setFocusHandler(CallbackData &/*someCallbackData*/)
+{
+  if(!mDIBitmap.isOkay())return (CallbackData::ReturnType)FALSE;
+  PureDevice pureDevice(*this);
+	((PurePalette&)*mDIBitmap).usePalette(pureDevice,TRUE);
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType SplashScreen::paintHandler(CallbackData &someCallbackData)
+{
+  if(!mResBitmap.isOkay())return (CallbackData::ReturnType)FALSE;
+  PaintInformation *pPaintInfo=(PaintInformation*)someCallbackData.lParam();
+	PureDevice &pureDevice=(PureDevice&)*pPaintInfo;
+  mDIBitmap->copyBits(mResBitmap->ptrData(),mResBitmap->imageExtent());  
+	mDIBitmap->stretchBlt(pureDevice,Rect(0,0,width(),height()));
+	pureDevice.select((GDIObj)mTextFont,TRUE);
+	pureDevice.setTextColor(RGBColor(247,231,33));
+	pureDevice.setBkMode(PureDevice::Transparent);
+//	pureDevice.textOut(60,180,"1998 Diversified Software Solutions");
+	if(!mInstallLine.isNull())
+	{
+	  pureDevice.setTextColor(RGBColor(255,255,255));
+	  pureDevice.textOut(50,196,mInstallLine);
+	}
+  return (CallbackData::ReturnType)FALSE;
+}
+
+// virtuals
+int SplashScreen::onDestroy(void)
+{
+  return 0;
+}
+
+

m68hc11/backup/SPLASH.HPP

@@ -0,0 +1,68 @@
+#ifndef _M68HC11_SPLASHSCREEN_HPP_
+#define _M68HC11_SPLASHSCREEN_HPP_
+#ifndef _COMMON_SMARTPOINTER_HPP_
+#include <common/pointer.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_WINDOW_HPP_
+#include <common/window.hpp>
+#endif
+#ifndef _COMMON_RECTANGLE_HPP_
+#include <common/rect.hpp>
+#endif
+#ifndef _COMMON_FONT_HPP_
+#include <common/font.hpp>
+#endif
+
+class ResBitmap;
+class DIBitmap;
+
+class SplashScreen : public Window
+{
+public:
+  enum{TimeOut=2500};
+  SplashScreen(const String &strBitmap,const String &strCaption,UINT timeout=TimeOut);
+	virtual ~SplashScreen();
+  BOOL perform(Rect initRect=Rect(CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT));
+protected:
+  virtual int onDestroy(void);
+private:
+  enum {TimerID=0};
+  SplashScreen(const SplashScreen &someSplashScreen);
+	SplashScreen &operator=(const SplashScreen &someSplashScreen);
+	CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType paintHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType paletteChangedHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType setFocusHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType timerHandler(CallbackData &someCallbackData);
+	void registerClass(void);
+	UINT timeout(void)const;
+
+	Callback<SplashScreen> mPaintHandler;
+	Callback<SplashScreen> mCreateHandler;
+	Callback<SplashScreen> mDestroyHandler;
+	Callback<SplashScreen> mPaletteChangedHandler;
+	Callback<SplashScreen> mSetFocusHandler;
+	Callback<SplashScreen> mTimerHandler;
+
+	SmartPointer<ResBitmap> mResBitmap;
+	SmartPointer<DIBitmap> mDIBitmap;
+	SmartPointer<PureDevice> mPureDevice;
+	String mBitmapName;
+	String mStrCaption;
+	String mInstallLine;
+	UINT mTimeout;
+	Font mTextFont;
+	static char szClassName[];
+};
+
+inline
+UINT SplashScreen::timeout(void)const
+{
+  return mTimeout;
+}
+
+#endif

m68hc11/backup/XTRAINFO.HPP

@@ -0,0 +1,86 @@
+#ifndef _M68HC11_EXTRAINFO_HPP_
+#define _M68HC11_EXTRAINFO_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+
+class ExtraInfo
+{
+public:
+  ExtraInfo(void);
+	ExtraInfo(const ExtraInfo &someExtraInfo);
+	ExtraInfo(DWORD userDataOne,DWORD userDataTwo);
+	virtual ~ExtraInfo();
+	ExtraInfo &operator=(const ExtraInfo &someExtraInfo);
+	BOOL operator==(const ExtraInfo &someExtraInfo)const;
+  DWORD userDataOne(void)const;
+	void userDataOne(DWORD userDataOne);
+	DWORD userDataTwo(void)const;
+	void userDataTwo(DWORD userDataTwo);
+private:
+  DWORD mUserDataOne;
+	DWORD mUserDataTwo;
+};
+
+inline
+ExtraInfo::ExtraInfo(void)
+: mUserDataOne(0), mUserDataTwo(0)
+{
+}
+
+inline
+ExtraInfo::ExtraInfo(const ExtraInfo &someExtraInfo)
+{
+  *this=someExtraInfo;
+}
+
+inline
+ExtraInfo::ExtraInfo(DWORD userDataOne,DWORD userDataTwo)
+: mUserDataOne(userDataOne), mUserDataTwo(userDataTwo)
+{
+}
+
+inline
+ExtraInfo::~ExtraInfo()
+{
+}
+
+inline
+ExtraInfo &ExtraInfo::operator=(const ExtraInfo &someExtraInfo)
+{
+  userDataOne(someExtraInfo.userDataOne());
+	userDataTwo(someExtraInfo.userDataTwo());
+	return *this;
+}
+
+inline
+BOOL ExtraInfo::operator==(const ExtraInfo &someExtraInfo)const
+{
+  return (userDataOne()==someExtraInfo.userDataOne()&&
+	        userDataTwo()==someExtraInfo.userDataTwo());
+}
+
+inline
+DWORD ExtraInfo::userDataOne(void)const
+{
+  return mUserDataOne;
+}
+
+inline
+void ExtraInfo::userDataOne(DWORD userDataOne)
+{
+  mUserDataOne=userDataOne;
+}
+
+inline
+DWORD ExtraInfo::userDataTwo(void)const
+{
+  return mUserDataTwo;
+}
+
+inline
+void ExtraInfo::userDataTwo(DWORD userDataTwo)
+{
+  mUserDataTwo=userDataTwo;
+}
+#endif

m68hc11/backup/codeview.cpp

@@ -0,0 +1,270 @@
+#include <m68hc11/codeview.hpp>
+#include <m68hc11/m68hc11.hpp>
+#include <printman/printman.hpp>
+#include <fileio/fileio.hpp>
+#include <common/profile.hpp>
+#include <common/rgbcolor.hpp>
+#include <common/crsctrl.hpp>
+#include <common/keydata.hpp>
+
+CodeView::CodeView(void)
+: WinHookProc(WinHookProc::HookBefore)
+{
+  mCreateHandler.setCallback(this,&CodeView::createHandler);
+  mSizeHandler.setCallback(this,&CodeView::sizeHandler);
+	mCloseHandler.setCallback(this,&CodeView::closeHandler);
+	mDestroyHandler.setCallback(this,&CodeView::destroyHandler);
+	mCommandHandler.setCallback(this,&CodeView::commandHandler);
+	mKeyUpHandler.setCallback(this,&CodeView::keyUpHandler);
+	mKeyDownHandler.setCallback(this,&CodeView::keyDownHandler);
+	mLeftButtonDownHandler.setCallback(this,&CodeView::leftButtonDownHandler);
+	mSetFocusHandler.setCallback(this,&CodeView::setFocusHandler);
+	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);
+	MDIWindow::insertHandler(MDIWindow::SetFocusHandler,&mSetFocusHandler);
+	WinHookProc::insertHandler(MDIWindow::KeyDownHandler,&mKeyDownHandler);
+	WinHookProc::insertHandler(WinHookProc::KeyUpHandler,&mKeyUpHandler);
+	WinHookProc::insertHandler(WinHookProc::LeftButtonDownHandler,&mLeftButtonDownHandler);
+}
+
+CodeView::~CodeView()
+{
+	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);
+	MDIWindow::removeHandler(MDIWindow::SetFocusHandler,&mSetFocusHandler);
+	WinHookProc::removeHandler(MDIWindow::KeyDownHandler,&mKeyDownHandler);
+	WinHookProc::removeHandler(WinHookProc::KeyUpHandler,&mKeyUpHandler);
+	WinHookProc::removeHandler(WinHookProc::LeftButtonDownHandler,&mLeftButtonDownHandler);
+}
+
+CallbackData::ReturnType CodeView::keyDownHandler(CallbackData &someCallbackData)
+{
+  KeyData keyData(someCallbackData);
+
+  if(keyData.isEscapeKey())return (CallbackData::ReturnType)TRUE;
+	notifyCurrentLine();
+  return (CallbackData::ReturnType)FALSE;
+}
+
+CallbackData::ReturnType CodeView::keyUpHandler(CallbackData &someCallbackData)
+{
+  notifyCurrentLine();
+  return FALSE;
+}
+
+CallbackData::ReturnType CodeView::leftButtonDownHandler(CallbackData &someCallbackData)
+{
+  notifyCurrentLine();
+  return FALSE;
+}
+
+CallbackData::ReturnType CodeView::createHandler(CallbackData &someCallbackData)
+{
+  Rect controlRect;
+
+	getControlRect(controlRect);
+	mRichEditControl.createControl(*this,controlRect,EditControlID,WS_VSCROLL|WS_HSCROLL);
+	hookWin(mRichEditControl);
+	mRichEditControl.wantReturn(TRUE);
+//  mRichEditControl.setCharFormat("MS Sans Serif",FontMagic);  // "Courier New"
+//  mRichEditControl.setCharFormat("Courier",FontMagic);  // "Courier New"
+//  mRichEditControl.setCharFormat("Courier New",FontMagic);  // "Courier New"
+//  mRichEditControl.setCharFormat("Courier New",8);  // "Courier New"
+	Font font("Courier New",12);
+	mRichEditControl.setFont(font);
+  mRichEditControl.setTextColor(RGBColor(0,0,0));
+	mRichEditControl.setBkGndColor(RGBColor(255,255,255));
+	mRichEditControl.setReadOnly(FALSE);
+	mRichEditControl.limitText(0);
+	mRichEditControl.setFocus();
+	mClipboard=::new Clipboard(*this);
+	mClipboard.disposition(PointerDisposition::Delete);
+	setTitle(String());
+  return FALSE;
+}
+
+CallbackData::ReturnType CodeView::sizeHandler(CallbackData &someCallbackData)
+{
+  Rect controlRect;
+
+	if(SIZE_RESTORED==someCallbackData.wParam())mRichEditControl.show(SW_SHOWNORMAL);
+	getControlRect(controlRect);
+  mRichEditControl.moveWindow(controlRect,TRUE);
+  return FALSE;
+}
+
+CallbackData::ReturnType CodeView::closeHandler(CallbackData &someCallbackData)
+{
+  return FALSE;
+}
+
+CallbackData::ReturnType CodeView::destroyHandler(CallbackData &someCallbackData)
+{
+  if(!mRichEditControl.isDirty())return FALSE;
+	if(IDOK!=::MessageBox(*this,(LPSTR)"Do you want to save the changes?",(LPSTR)"The file has been changed",MB_YESNO))return FALSE;
+	save();
+	unhookWin();
+  return FALSE;
+}
+
+CallbackData::ReturnType CodeView::commandHandler(CallbackData &/*someCallbackData*/)
+{
+  return FALSE;
+}
+
+CallbackData::ReturnType CodeView::setFocusHandler(CallbackData &someCallbackData)
+{
+  mRichEditControl.setFocus();
+	notifyCurrentLine();
+  return (CallbackData::ReturnType)FALSE;
+}
+
+void CodeView::setTitle(const String &strTitle)
+{
+  String strCaption;
+	String strBase;
+
+  if(strTitle.isNull())mTitle=String(STRING_UNTITLED);
+	else mTitle=strTitle;
+	windowText(strCaption);
+	strBase=strCaption.betweenString(0,'-');
+	strBase.trimRight();
+	strBase+=String(" - [")+mTitle+String("]");
+	setCaption(strBase);
+}
+
+BOOL CodeView::save(void)
+{
+	Block<String> lineStrings;
+
+	mRichEditControl.getLines(lineStrings);
+	mRichEditControl.isDirty(FALSE);
+	return saveCode(lineStrings,getTitle());
+}
+
+BOOL CodeView::save(const String &strPathFileName)
+{
+  Block<String> lineStrings;
+
+	setTitle(strPathFileName);
+  mRichEditControl.getLines(lineStrings);
+	mRichEditControl.isDirty(FALSE);
+	return saveCode(lineStrings,strPathFileName);
+}
+
+void CodeView::find(void)
+{
+  mEditFind.perform(*this,mRichEditControl);
+}
+
+void CodeView::cut(void)
+{
+  if(!mClipboard.isOkay()||!mRichEditControl.isValid())return;
+	String strText;
+	if(mRichEditControl.getSelectedText(strText))mClipboard->setClipboard(strText);
+	mRichEditControl.cutSelection();
+}
+
+void CodeView::copy(void)
+{
+  if(!mClipboard.isOkay()||!mRichEditControl.isValid())return;
+	String strText;
+	if(!mRichEditControl.getSelectedText(strText))return;
+	mClipboard->setClipboard(strText);
+}
+
+void CodeView::paste(void)
+{
+  if(!mClipboard.isOkay())return;
+	mRichEditControl.pasteSpecial(CF_TEXT);
+}
+
+BOOL CodeView::saveCode(Block<String> &codeLines,const String &strPathFileName)
+{
+  FileIO outFile;
+	CursorControl cursorControl;
+
+	if(!codeLines.size())return FALSE;
+	outFile.open(strPathFileName,FileIO::GenericWrite,FileIO::FileShareRead,FileIO::Open(FileIO::CreateAlways));
+	if(!outFile.isOkay())return FALSE;
+	for(int lineIndex=0;lineIndex<codeLines.size();lineIndex++)
+	{															  
+	  String &strLine=codeLines[lineIndex];
+		if(!strLine.isNull()&&(*((char*)strLine)==0x0A||*((char*)strLine)==0x0D))
+		{
+		  if(strLine.length()<=2)strLine="\n";
+			else *((char*)strLine)=' ';
+		}
+		if(-1==strLine.strchr('\r'))strLine.insert("\r",strLine.length()-1);
+		outFile.write((char*)strLine,strLine.length());
+	}
+	outFile.close();
+	return TRUE;
+}
+
+void CodeView::open(const String &pathFileName)
+{
+  FileIO inFile;
+	String strLine;
+	String strLines;
+	String crlf("\n");
+
+	strLine.reserve(1024);
+	strLines.reserve(250000);
+	inFile.open(pathFileName);
+	if(!inFile.isOkay())return;
+	while(inFile.readLine(strLine))
+	{
+	  strLines+=strLine;
+		strLines+=crlf;
+	}
+	mRichEditControl.setCaption(strLines);
+	mRichEditControl.isDirty(FALSE);
+	setTitle(pathFileName);
+	inFile.close();
+}
+
+void CodeView::print(void)
+{
+  String strPrinter;
+  PrintManager printManager;
+	Block<String> codeLines;
+	Font textFont("Helv",36);
+
+	if(!printManager.choosePrinter((GUIWindow&)*(getFrame()),strPrinter))return;
+	printManager.openPrinter(strPrinter,(GUIWindow&)*(getFrame()),getTitle());
+	printManager.printLines(codeLines,textFont,Point(10,10));
+	printManager.endDoc();
+}
+
+void CodeView::notifyCurrentLine(void)
+{
+  CallbackData lineData(0,mRichEditControl.getCaretPosition());
+	mLineHandler.callback(lineData);
+}
+
+void CodeView::getControlRect(Rect &controlRect)
+{
+  clientRect(controlRect);
+	controlRect.left(BorderWidth);
+	controlRect.top(BorderWidth);
+	controlRect.right((controlRect.right()-BorderWidth)+1);
+	controlRect.bottom((controlRect.bottom()-BorderWidth)+1);
+}
+
+// *** virtuals
+
+void CodeView::preRegister(WNDCLASS &wndClass)
+{
+	wndClass.hbrBackground =(HBRUSH)COLOR_APPWORKSPACE;
+}
+
+void CodeView::preCreate(MDICREATESTRUCT &createStruct)
+{
+}

m68hc11/backup/codeview.hpp

@@ -0,0 +1,87 @@
+#ifndef _M68HC11_CODEVIEW_HPP_
+#define _M68HC11_CODEVIEW_HPP_
+#ifndef _COMMON_MDIWIN_HPP_
+#include <common/mdiwin.hpp>
+#endif
+#ifndef _COMMON_RICHEDIT_HPP_
+#include <common/richedit.hpp>
+#endif
+#ifndef _COMMON_HOOKPROC_HPP_
+#include <common/hookproc.hpp>
+#endif
+#ifndef _COMMON_CLIPBOARD_HPP_
+#include <common/clipbrd.hpp>
+#endif
+#ifndef _M68HC11_EDITFIND_HPP_
+#include <m68hc11/editfnd.hpp>
+#endif
+
+class CodeView : public MDIWindow, private WinHookProc
+{
+public:
+  CodeView(void);
+	virtual ~CodeView();
+	BOOL save(void);
+	BOOL save(const String &strPathFileName);
+  void open(const String &pathFileName);
+	void find(void);
+	void cut(void);
+	void copy(void);
+	void paste(void);
+	void print(void);
+	BOOL isDirty(void)const;
+	void setLineHandler(PureCallback *pPureCallback);
+	const String &getTitle(void)const;
+	void setTitle(const String &strTitle);
+protected:
+	virtual void preRegister(WNDCLASS &wndClass);
+	virtual void preCreate(MDICREATESTRUCT &createStruct);
+private:
+  enum {FontMagic=175,EditControlID=100,StatusBarID=101,BorderWidth=1};  // 165
+  CallbackData::ReturnType createHandler(CallbackData &someCallbackData);
+  CallbackData::ReturnType sizeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType closeHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType destroyHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType commandHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType keyUpHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType leftButtonDownHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType keyDownHandler(CallbackData &someCallbackData);
+	CallbackData::ReturnType setFocusHandler(CallbackData &someCallbackData);
+	BOOL saveCode(Block<String> &headerLines,const String &strPathFileName);
+  void getControlRect(Rect &controlRect);
+  void notifyCurrentLine(void);
+
+  Callback<CodeView> mCreateHandler;
+  Callback<CodeView> mSizeHandler;
+	Callback<CodeView> mCloseHandler;
+	Callback<CodeView> mDestroyHandler;
+	Callback<CodeView> mCommandHandler;
+	Callback<CodeView> mKeyUpHandler;
+	Callback<CodeView> mLeftButtonDownHandler;
+	Callback<CodeView> mKeyDownHandler;
+	Callback<CodeView> mSetFocusHandler;
+	CallbackPointer mLineHandler;
+	RichEditControl mRichEditControl;
+	SmartPointer<Clipboard> mClipboard;
+	EditFind mEditFind;
+	String mTitle;
+};
+
+inline
+BOOL CodeView::isDirty(void)const
+{
+  return mRichEditControl.isDirty();
+}
+
+inline
+void CodeView::setLineHandler(PureCallback *pPureCallback)
+{
+  mLineHandler=CallbackPointer(pPureCallback);
+}
+
+inline
+const String &CodeView::getTitle(void)const
+{
+  return mTitle;
+}
+#endif

m68hc11/backup/commctrl.cpp

@@ -0,0 +1,209 @@
+#include <m68hc11/commctrl.hpp>
+#include <m68hc11/m68hc11.hpp>
+#include <m68hc11/fmtlines.hpp>
+
+void CommControl::portToString(CommControl::Port port,String &strPort)
+{
+	if(port==CommControl::PortCOM1)strPort=String(STRING_COM1);
+	else if(port==CommControl::PortCOM2)strPort=String(STRING_COM2);
+	else if(port==CommControl::PortCOM3)strPort=String(STRING_COM3);
+	else strPort=String(STRING_COM4);
+}
+
+CommControl::Port CommControl::stringToPort(const String &strPort)
+{
+  if(strPort==String(STRING_COM1))return CommControl::PortCOM1;
+	else if(strPort==String(STRING_COM2))return CommControl::PortCOM2;
+	else if(strPort==String(STRING_COM3))return CommControl::PortCOM3;
+	else return CommControl::PortCOM4;
+}
+
+bool CommControl::readFully(GlobalData<BYTE> &dataBytes)
+{
+	CommStatus commStatus;
+  DWORD bytesRead=0;
+	DWORD byteCount;
+	DWORD bytesToRead;
+
+	if(!isOkay())return false;
+	clearError(commStatus);
+  byteCount=dataBytes.size();
+	if(!byteCount&&!commStatus.bytesInReceiveQueue())return false;
+	if(!byteCount){byteCount=commStatus.bytesInReceiveQueue();dataBytes.size(byteCount);}
+	return readFully(&dataBytes[0],dataBytes.size()); 
+}
+
+bool CommControl::readFully(BYTE *pBuffer,DWORD byteCount)
+{
+	CommStatus commStatus;
+  DWORD bytesRead=0;
+	DWORD bytesToRead;
+
+	if(!isOkay())return false;
+	clearError(commStatus);
+	if(!byteCount||!pBuffer)return false;
+	while(bytesRead<byteCount)
+	{
+	  if(commStatus.bytesInReceiveQueue())
+		{           
+		  bytesToRead=bytesRead+commStatus.bytesInReceiveQueue()>byteCount?byteCount-bytesRead:commStatus.bytesInReceiveQueue();
+	    read(&pBuffer[bytesRead],bytesToRead);
+		  bytesRead+=bytesToRead;
+		}
+		if(bytesRead==byteCount)break;
+		::Sleep(25);
+    clearError(commStatus);
+	}
+	showBytes(pBuffer,byteCount);
+	return true;
+}
+
+bool CommControl::hasData(void)
+{
+  CommStatus commStatus;
+	clearError(commStatus);
+	return commStatus.bytesInReceiveQueue()?true:false;
+}
+
+bool CommControl::clearReceiveQueue(void)
+{
+  GlobalData<BYTE> rcvBytes;
+	CommStatus commStatus;
+
+  if(!isOkay())return false;
+	::Sleep(1000);
+	clearError(commStatus);
+	if(!commStatus.bytesInReceiveQueue())return true;
+  ::OutputDebugString(String(String("Clearing ")+String().fromInt(commStatus.bytesInReceiveQueue())+String(" bytes from receive queue.\n")).str());
+	rcvBytes.size(commStatus.bytesInReceiveQueue());
+	read(&rcvBytes[0],rcvBytes.size());
+	showBytes(rcvBytes);
+	return true;
+}
+
+bool CommControl::waitEvent(DWORD &eventMask,DWORD timeout)
+{
+  BOOL result;
+	DWORD lastError;
+
+  eventMask=0;
+  if(!isOkay())return false;
+	mIOEvent.resetEvent();
+	result=::WaitCommEvent((HANDLE)mCommDevice,&eventMask,&mOverlapped.getOverlapped());
+	if(result)return true;
+	lastError=::GetLastError();
+	if(lastError!=ERROR_IO_PENDING)return false;
+	mIOEvent.waitEvent(timeout);
+	if(!mCommDevice.getOverlappedResult(mOverlapped,false))return false;
+	return true;
+}
+
+DWORD CommControl::enumerateDevices(Block<Port> &deviceList)
+{
+
+	deviceList.remove();
+	if(isOkay())return 0;
+	for(Port port=PortCOM1;port<=PortCOM4;((int&)port)++)
+	{
+	  if(mCommDevice.open(mStrPorts[port]))
+		{
+		  mCommDevice.close();
+			deviceList.insert(&port);
+		}
+	}
+	return deviceList.size();
+}
+
+DWORD CommControl::enumerateDevices(Block<String> &deviceList)
+{
+	deviceList.remove();
+	if(isOkay())return 0;
+	for(Port port=PortCOM1;port<=PortCOM4;((int&)port)++)
+	{
+	  if(mCommDevice.open(mStrPorts[port]))
+		{
+		  mCommDevice.close();
+			if(PortCOM1==port)deviceList.insert(&String("COM1"));
+			else if(PortCOM2==port)deviceList.insert(&String("COM2"));
+			else if(PortCOM3==port)deviceList.insert(&String("COM3"));
+			else if(PortCOM4==port)deviceList.insert(&String("COM4"));
+		}
+	}
+	return deviceList.size();
+}
+
+DWORD CommControl::read(void *pBuffer,int length,DWORD timeout)
+{
+  BOOL result;
+	DWORD lastError;
+
+  if(!isOkay())return FALSE;
+	mIOEvent.resetEvent();
+ 	result=mCommDevice.read((BYTE*)pBuffer,length,mOverlapped);
+	if(result)return TRUE;
+	lastError=::GetLastError();
+	if(lastError!=ERROR_IO_PENDING)return FALSE;
+	mIOEvent.waitEvent(TimeOut);
+	if(!mCommDevice.getOverlappedResult(mOverlapped,FALSE))return FALSE;
+	return TRUE;
+}
+
+bool CommControl::isOkay(void)const
+{
+  return mCommDevice.isOkay();
+}
+
+bool CommControl::clearError(CommStatus &commStatus)const
+{
+  DWORD errorMask(0);
+	bool returnCode(false);
+
+	if(!isOkay())return returnCode;
+	returnCode=::ClearCommError((HANDLE)mCommDevice,&errorMask,&commStatus.getCOMSTAT());
+	showError(errorMask);
+	return returnCode;
+}
+
+bool CommControl::clearError(void)const
+{
+  DWORD errorMask(0);
+	bool returnCode(false);
+
+  if(!isOkay())return false;
+	returnCode=::ClearCommError((HANDLE)mCommDevice,&errorMask,0);
+	showError(errorMask);
+	return returnCode;
+}
+
+void CommControl::showError(DWORD errorMask)const
+{
+  if(errorMask&CE_BREAK)::OutputDebugString("The hardware detected a break condition.\n");
+  if(errorMask&CE_DNS)::OutputDebugString("Windows 95 and Windows 98: A parallel device is not selected.\n");
+  if(errorMask&CE_FRAME)::OutputDebugString("The hardware detected a framing error.\n"); 
+  if(errorMask&CE_IOE)::OutputDebugString("An I/O error occurred during communications with the device.\n");
+  if(errorMask&CE_MODE)::OutputDebugString("The requested mode is not supported, or the hFile parameter is invalid. If this value is specified, it is the only valid error.\n"); 
+  if(errorMask&CE_OOP)::OutputDebugString("Windows 95 and Windows 98: A parallel device signaled that it is out of paper.\n");
+  if(errorMask&CE_OVERRUN)::OutputDebugString("A character-buffer overrun has occurred. The next character is lost.\n"); 
+  if(errorMask&CE_PTO)::OutputDebugString("Windows 95 and Windows 98: A time-out occurred on a parallel device.\n"); 
+  if(errorMask&CE_RXOVER)::OutputDebugString("An input buffer overflow has occurred. There is either no room in the input buffer, or a character was received after the end-of-file (EOF) character.\n"); 
+  if(errorMask&CE_RXPARITY)::OutputDebugString("The hardware detected a parity error.\n"); 
+  if(errorMask&CE_TXFULL)::OutputDebugString("The application tried to transmit a character, but the output buffer was full.\n");
+}
+
+void CommControl::showBytes(BYTE *pBuffer,DWORD byteCount)
+{
+  Block<String> strLines;
+
+  ::OutputDebugString("\n");
+	FormatLines::hexasciiLines(strLines,pBuffer,byteCount);
+	for(int index=0;index<strLines.size();index++)
+	{
+	  ::OutputDebugString(strLines[index].str());
+		::OutputDebugString("\n");
+	}
+}
+
+void CommControl::showBytes(GlobalData<BYTE> rcvBytes)
+{
+  showBytes(&rcvBytes[0],rcvBytes.size());
+}

m68hc11/backup/fmtlines.cpp

@@ -0,0 +1,120 @@
+#include <stdio.h>
+#include <m68hc11/fmtlines.hpp>
+
+DWORD FormatLines::hexasciiLines(Block<String> &lineStrings,GlobalData<BYTE> &globalData)
+{
+  return hexasciiLines(lineStrings,&globalData[0],globalData.size());
+}
+
+DWORD FormatLines::hexasciiLines(Block<String> &lineStrings,BYTE *pBuffer,DWORD byteCount)
+{
+	Block<String> asciiLines;
+	Block<String> hexLines;
+	String tmpString;
+	DWORD lineCount;
+
+	formatLines(asciiLines,pBuffer,byteCount,HexCharsPerLine,ASCIILine);
+	formatLines(hexLines,pBuffer,byteCount,HexCharsPerLine,HexLine);
+	lineCount=asciiLines.size();
+	for(DWORD itemIndex=0;itemIndex<lineCount;itemIndex++)
+	{
+		tmpString=hexLines[itemIndex]+asciiLines[itemIndex];
+		lineStrings.insert(&tmpString);
+	}
+	return lineCount;
+}
+
+
+DWORD FormatLines::formatLines(Block<String> &lineStrings,BYTE *pBuffer,DWORD byteCount,WORD charsPerLine,LineType lineType)
+{
+	WORD charCount;
+	String charString;
+	String charLine;
+	BYTE charByte;
+  BYTE prevByte;
+
+	if(!byteCount||!pBuffer)return byteCount;
+	charCount=0;
+	for(DWORD itemIndex=0;itemIndex<byteCount;itemIndex++)
+	{
+		charByte=pBuffer[itemIndex];
+		if(itemIndex&&(!(itemIndex%charsPerLine)))
+		{
+			if(HexLine==lineType)charLine.upper();
+			lineStrings.insert(&charLine);
+      *((char*)charLine)=0;
+			charCount=0;
+		}
+		if(HexLine==lineType)::sprintf(charString,"%02x",charByte);
+		else
+		{
+			if(isprint(charByte))::sprintf(charString,"%c",charByte);
+			else charString=".";
+		}
+    charCount++;
+		charLine+=charString;
+		if(HexLine==lineType)charLine+=" ";
+	}
+	while(charCount<charsPerLine)
+	{
+		if(HexLine==lineType)charLine+="?? ";
+    else charLine+="?";
+    charCount++;
+  }
+	if(charLine.length())
+	{
+		if(HexLine==lineType)charLine.upper();
+		lineStrings.insert(&charLine);
+	}
+	return lineStrings.size();
+}
+
+
+
+
+
+
+/*DWORD FormatLines::formatLines(Block<String> &lineStrings,GlobalData<BYTE> &globalData,WORD charsPerLine,LineType lineType)
+{
+	DWORD byteCount(globalData.size());
+	WORD charCount;
+	String charString;
+	String charLine;
+	BYTE charByte;
+  BYTE prevByte;
+
+	if(!byteCount)return byteCount;
+	charCount=0;
+	for(DWORD itemIndex=0;itemIndex<byteCount;itemIndex++)
+	{
+		charByte=globalData[itemIndex];
+		if(itemIndex&&(!(itemIndex%charsPerLine)))
+		{
+			if(HexLine==lineType)charLine.upper();
+			lineStrings.insert(&charLine);
+      *((char*)charLine)=0;
+			charCount=0;
+		}
+		if(HexLine==lineType)::sprintf(charString,"%02x",charByte);
+		else
+		{
+			if(isprint(charByte))::sprintf(charString,"%c",charByte);
+			else charString=".";
+		}
+    charCount++;
+		charLine+=charString;
+		if(HexLine==lineType)charLine+=" ";
+	}
+	while(charCount<charsPerLine)
+	{
+		if(HexLine==lineType)charLine+="?? ";
+    else charLine+="?";
+    charCount++;
+  }
+	if(charLine.length())
+	{
+		if(HexLine==lineType)charLine.upper();
+		lineStrings.insert(&charLine);
+	}
+	return lineStrings.size();
+}*/

m68hc11/backup/fmtlines.hpp

@@ -0,0 +1,60 @@
+#ifndef _M68HC11_FORMATLINES_HPP_
+#define _M68HC11_FORMATLINES_HPP_
+#ifndef _COMMON_WINDOWS_HPP_
+#include <common/windows.hpp>
+#endif
+#ifndef _COMMON_STRING_HPP_
+#include <common/string.hpp>
+#endif
+#ifndef _COMMON_BLOCK_HPP_
+#include <common/block.hpp>
+#endif
+#ifndef _COMMON_GLOBALDATA_HPP_
+#include <common/gdata.hpp>
+#endif
+
+class FormatLines
+{
+public:
+	enum{HexCharsPerLine=0x10,ASCIICharsPerLine=0x20};
+	FormatLines(void);
+	~FormatLines();
+	static DWORD hexLines(Block<String> &lineStrings,BYTE *pBuffer,DWORD byteCount,WORD hexCharsPerLine=HexCharsPerLine);
+	static DWORD hexLines(Block<String> &lineStrings,GlobalData<BYTE> &globalData,WORD hexCharsPerLine=HexCharsPerLine);
+	static DWORD asciiLines(Block<String> &lineStrings,BYTE *pBuffer,DWORD byteCount,WORD asciiCharsPerLine=ASCIICharsPerLine);
+	static DWORD asciiLines(Block<String> &lineStrings,GlobalData<BYTE> &globalData,WORD asciiCharsPerLine=ASCIICharsPerLine);
+	static DWORD hexasciiLines(Block<String> &lineStrings,BYTE *pBuffer,DWORD byteCount);
+	static DWORD hexasciiLines(Block<String> &lineStrings,GlobalData<BYTE> &globalData);
+private:
+	enum LineType{HexLine,ASCIILine};
+  static DWORD formatLines(Block<String> &lineStrings,BYTE *pBuffer,DWORD byteCount,WORD charsPerLine,LineType lineType);
+};
+
+inline
+FormatLines::FormatLines(void)
+{
+}
+
+inline
+FormatLines::~FormatLines()
+{
+}
+
+inline
+DWORD FormatLines::hexLines(Block<String> &lineStrings,GlobalData<BYTE> &globalData,WORD hexCharsPerLine)
+{
+	return formatLines(lineStrings,&globalData[0],globalData.size(),hexCharsPerLine,HexLine);
+}
+
+inline
+DWORD FormatLines::hexLines(Block<String> &lineStrings,BYTE *pBuffer,DWORD byteCount,WORD hexCharsPerLine)
+{
+	return formatLines(lineStrings,pBuffer,byteCount,hexCharsPerLine,HexLine);
+}
+
+inline
+DWORD FormatLines::asciiLines(Block<String> &lineStrings,BYTE *pBuffer,DWORD byteCount,WORD asciiCharsPerLine)
+{
+	return formatLines(lineStrings,pBuffer,byteCount,asciiCharsPerLine,ASCIILine);
+}
+#endif

m68hc11/backup/m68hc11.rc

@@ -0,0 +1,422 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#define APSTUDIO_HIDDEN_SYMBOLS
+#include "windows.h"
+#undef APSTUDIO_HIDDEN_SYMBOLS
+#include "m68hc11\m68hc11.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+APP                     ICON    DISCARDABLE     "MOT.ICO"
+MOT                     ICON    DISCARDABLE     "MOT.ICO"
+DOC                     ICON    DISCARDABLE     "DOC.ICO"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Bitmap
+//
+
+BLANK                   BITMAP  MOVEABLE PURE   "BLANK.BMP"
+ONE                     BITMAP  MOVEABLE PURE   "ONE.BMP"
+ZERO                    BITMAP  MOVEABLE PURE   "ZERO.BMP"
+DASH                    BITMAP  MOVEABLE PURE   "DASH.BMP"
+SPLASH                  BITMAP  MOVEABLE PURE   "SPLASH.BMP"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menu
+//
+
+MAINMENU MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "&New\tCtrl+N",                SBCMENU_FILENEW
+        MENUITEM "&Open...\tCtrl+O",            SBCMENU_FILEOPEN
+        MENUITEM SEPARATOR
+        MENUITEM "&Print\tCtrl+P",              SBCMENU_FILEPRINT
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                       SBCMENU_FILEQUIT
+    END
+    POPUP "&Settings"
+    BEGIN
+        MENUITEM "Se&rial...",                  SBCMENU_SETTINGSSERIAL
+    END
+    POPUP "&Help"
+    BEGIN
+        MENUITEM "&Contents",                   SBCMENU_HELPCONTENTS
+        MENUITEM "&Search",                     SBCMENU_HELPSEARCH
+        MENUITEM SEPARATOR
+        MENUITEM "&Registration...",            SBCMENU_REGISTRATION
+        MENUITEM SEPARATOR
+        MENUITEM "&About ...",                  SBCMENU_HELPABOUT
+    END
+END
+
+CODEMENU MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "&New\tCtrl+N",                SBCMENU_FILENEW
+        MENUITEM "&Open...\tCtrl+O",            SBCMENU_FILEOPEN
+        MENUITEM "&Close",                      SBCMENU_FILECLOSE
+        MENUITEM SEPARATOR
+        MENUITEM "&Save...\tCtrl+S",            SBCMENU_FILESAVE
+        MENUITEM "Save &As...",                 SBCMENU_FILESAVEAS
+        MENUITEM SEPARATOR
+        MENUITEM "&Print\tCtrl+P",              SBCMENU_FILEPRINT
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                       SBCMENU_FILEQUIT
+    END
+    POPUP "&Edit"
+    BEGIN
+        MENUITEM "Cu&t\tCtrl+X",                SBCMENU_EDITCUT
+        MENUITEM "&Copy\tCtrl+C",               SBCMENU_EDITCOPY
+        MENUITEM "&Paste\tCtrl+V",              SBCMENU_EDITPASTE
+        MENUITEM SEPARATOR
+        MENUITEM "&Find...\tAlt+F3",            SBCMENU_EDITFIND
+    END
+    POPUP "&Settings"
+    BEGIN
+        MENUITEM "Se&rial...",                  SBCMENU_SETTINGSSERIAL
+    END
+    POPUP "&Code"
+    BEGIN
+        MENUITEM "&Compile\tCtrl+C",            SBCMENU_CODECOMPILE
+        MENUITEM "Compile and Load\tCtrl+P",    SBCMENU_CODECOMPILEANDLOAD
+    END
+    POPUP "&Window"
+    BEGIN
+        MENUITEM "&Cascade\tShift+F5",          IDM_CASCADE
+        MENUITEM "&Tile\tShift+F4",             IDM_TILE
+        MENUITEM "&Arrange &icons",             IDM_ARRANGE
+        MENUITEM SEPARATOR
+        MENUITEM "Close &all",                  IDM_CLOSEALL
+        MENUITEM "Mi&nimize all",               IDM_MINIMIZEALL
+        MENUITEM "&Restore all",                IDM_RESTOREALL
+    END
+    POPUP "&Help"
+    BEGIN
+        MENUITEM "&Contents",                   SBCMENU_HELPCONTENTS
+        MENUITEM "&Search",                     SBCMENU_HELPSEARCH
+        MENUITEM SEPARATOR
+        MENUITEM "&Registration...",            SBCMENU_REGISTRATION
+        MENUITEM SEPARATOR
+        MENUITEM "&About ...",                  SBCMENU_HELPABOUT
+    END
+END
+
+MCUMENU MENU DISCARDABLE 
+BEGIN
+    POPUP "&File"
+    BEGIN
+        MENUITEM "&New\tCtrl+N",                SBCMENU_FILENEW, GRAYED
+        MENUITEM "&Open...\tCtrl+O",            SBCMENU_FILEOPEN, GRAYED
+        MENUITEM "&Close",                      SBCMENU_FILECLOSE
+        MENUITEM SEPARATOR
+        MENUITEM "&Save...\tCtrl+S",            SBCMENU_FILESAVE, GRAYED
+        MENUITEM "Save &As...",                 SBCMENU_FILESAVEAS, GRAYED
+        MENUITEM SEPARATOR
+        MENUITEM "&Print\tCtrl+P",              SBCMENU_FILEPRINT
+        MENUITEM SEPARATOR
+        MENUITEM "E&xit",                       SBCMENU_FILEQUIT
+    END
+    POPUP "&Edit"
+    BEGIN
+        MENUITEM "Cu&t\tCtrl+X",                SBCMENU_EDITCUT
+        MENUITEM "&Copy\tCtrl+C",               SBCMENU_EDITCOPY
+        MENUITEM "&Paste\tCtrl+V",              SBCMENU_EDITPASTE
+        MENUITEM SEPARATOR
+        MENUITEM "&Find...\tAlt+F3",            SBCMENU_EDITFIND
+    END
+    POPUP "&Window"
+    BEGIN
+        MENUITEM "&Cascade\tShift+F5",          IDM_CASCADE
+        MENUITEM "&Tile\tShift+F4",             IDM_TILE
+        MENUITEM "&Arrange &icons",             IDM_ARRANGE
+        MENUITEM SEPARATOR
+        MENUITEM "Close &all",                  IDM_CLOSEALL
+        MENUITEM "Mi&nimize all",               IDM_MINIMIZEALL
+        MENUITEM "&Restore all",                IDM_RESTOREALL
+    END
+    POPUP "&Help"
+    BEGIN
+        MENUITEM "&Contents",                   SBCMENU_HELPCONTENTS
+        MENUITEM "&Search",                     SBCMENU_HELPSEARCH
+        MENUITEM SEPARATOR
+        MENUITEM "&Registration...",            SBCMENU_REGISTRATION
+        MENUITEM SEPARATOR
+        MENUITEM "&About ...",                  SBCMENU_HELPABOUT
+    END
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+SERIAL DIALOG DISCARDABLE  6, 15, 207, 111
+STYLE DS_MODALFRAME | DS_3DLOOK | WS_POPUP | WS_VISIBLE | WS_CAPTION | 
+    WS_SYSMENU
+CAPTION "Serial Setup"
+FONT 6, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,153,3,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,153,18,50,14
+    PUSHBUTTON      "Test",SERIAL_TEST,153,32,50,14
+    COMBOBOX        SERIAL_BAUD,30,24,49,50,CBS_DROPDOWNLIST | WS_VSCROLL | 
+                    WS_TABSTOP
+    COMBOBOX        SERIAL_DATA,30,37,49,50,CBS_DROPDOWNLIST | WS_VSCROLL | 
+                    WS_TABSTOP
+    COMBOBOX        SERIAL_PARITY,30,63,49,50,CBS_DROPDOWNLIST | WS_VSCROLL | 
+                    WS_TABSTOP
+    COMBOBOX        SERIAL_PORT,30,11,49,50,CBS_DROPDOWNLIST | WS_VSCROLL | 
+                    WS_TABSTOP
+    LTEXT           "Port:",-1,3,14,18,8
+    LTEXT           "Baud:",-1,3,27,21,8
+    LTEXT           "Data:",-1,3,40,20,8
+    LTEXT           "Stop:",-1,4,53,19,8
+    LTEXT           "Parity:",-1,3,65,19,8
+    COMBOBOX        SERIAL_STOP,30,50,49,50,CBS_DROPDOWNLIST | WS_VSCROLL | 
+                    WS_TABSTOP
+    PUSHBUTTON      "Apply",SERIAL_APPLY,153,46,50,14
+END
+
+MCUDLG DIALOG DISCARDABLE  6, 5, 358, 174
+STYLE DS_MODALFRAME | DS_3DLOOK | WS_CHILD | WS_VISIBLE
+FONT 6, "MS Sans Serif"
+BEGIN
+    DEFPUSHBUTTON   "Start",IDOK,254,5,50,14
+    PUSHBUTTON      "Quit",IDCANCEL,304,5,50,14
+    LISTBOX         MCUDLG_REGISTERS,15,38,144,129,LBS_SORT | 
+                    LBS_OWNERDRAWFIXED | LBS_HASSTRINGS | WS_VSCROLL
+    EDITTEXT        MCUDLG_A,217,37,38,12
+    EDITTEXT        MCUDLG_B,256,37,38,12
+    EDITTEXT        MCUDLG_X,217,50,38,12
+    EDITTEXT        MCUDLG_Y,256,50,38,12
+    EDITTEXT        MCUDLG_SP,217,63,38,12
+    EDITTEXT        MCUDLG_PC,256,63,38,12
+    EDITTEXT        MCUDLG_CCR,217,76,38,12
+    LISTBOX         MCUDLG_MESSAGES,168,107,177,60,LBS_SORT | WS_VSCROLL
+    CTEXT           "MCU Registers",-1,44,26,60,8
+    CTEXT           "Processor",-1,203,26,49,8
+    LTEXT           "Accumulator A",-1,165,40,51,8
+    LTEXT           "Accumulator B",-1,297,39,49,8
+    LTEXT           "Index Register X",-1,163,52,52,8
+    LTEXT           "Index Register Y",-1,296,51,55,8
+    LTEXT           "SP",-1,201,65,13,8
+    LTEXT           "PC",-1,297,64,10,8
+    LTEXT           "CCR",-1,198,78,16,8
+    GROUPBOX        "",-1,2,19,349,154
+    LTEXT           "Debug Messages",-1,225,95,60,8
+END
+
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#define APSTUDIO_HIDDEN_SYMBOLS\r\n"
+    "#include ""windows.h""\r\n"
+    "#undef APSTUDIO_HIDDEN_SYMBOLS\r\n"
+    "#include ""m68hc11\\m68hc11.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    STRING_M68KEYNAME       "Software\\Diversified\\M68HC11"
+    STRING_HISTORYKEYNAME   "Software\\Diversified\\M68HC11\\History"
+    STRING_SETTINGSKEYNAME  "Software\\Diversified\\M68HC11\\Settings"
+    STRING_SERIALKEYNAME    "Software\\Diversified\\M68HC11\\Serial"
+    STRING_HISTORYKEYSHORTNAME "History"
+    STRING_SETTINGSEMAIL    "EMAIL"
+    STRING_SERIALPORT       "Port"
+    STRING_SERIALBAUD       "Baud"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    STRING_SERIALDATA       "Data"
+    STRING_SERIALPARITY     "Parity"
+    STRING_SERIALSTOP       "Stop"
+    STRING_COM1             "COM1"
+    STRING_COM2             "COM2"
+    STRING_COM3             "COM3"
+    STRING_COM4             "COM4"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    STRING_CODEVIEWCLASSNAME "CodeView"
+    STRING_MCUVIEWCLASSNAME "MCUView"
+    STRING_UNTITLED         "Untitled"
+    STRING_HELPFILENAME     "m68hc11.hlp"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    STRING_REGISTERADR4     "ADR4"
+    STRING_REGISTERBPROT    "BPROT"
+    STRING_REGISTEREPROG    "EPROG"
+    STRING_REGISTERRESERVED3 "RESERVED"
+    STRING_REGISTERRESERVED4 "RESERVED"
+    STRING_REGISTEROPTION   "OPTION"
+    STRING_REGISTERCOPRST   "COPRST"
+    STRING_REGISTERPPROG    "PPROG"
+    STRING_REGISTERHPRIO    "HPRIO"
+    STRING_REGISTERINIT     "INIT"
+    STRING_REGISTERTEST1    "TEST1"
+    STRING_REGISTERCONFIG   "CONFIG"
+    STRING_ERRORFILEOPEN    "Error opening '"
+    STRING_ERRORPORTOPEN    "Error opening communications port."
+    STRING_ERRORPORTSETTINGS "Error initializing port settings."
+    STRING_ERRORTIMEOUT     "Timeout waiting for device."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    STRING_ERRORREADERROR   "Error reading from device."
+    STRING_ERRORTALKBACKFAILURE "Error receiving response from device"
+    STRING_ERRORTALKBACKDATA "Error validating code load"
+    STRING_EVENTSINGLEBYTE  "Received single-byte event."
+    STRING_EVENTQUADBYTE    "Received quad-byte event."
+    STRING_EVENTVARBYTE     "Received variable-byte event."
+    STRING_EVENTREGDATASTART "Receiving register data..."
+    STRING_EVENTREGDATACOMPLETE "Register receive complete."
+    STRING_EVENTCODECOMPLETE "Received code completion event."
+    STRING_EVENTDOUBLEBYTE  "Received double-byte event."
+		STRING_EVENTSTRING      "Received string event."
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    STRING_REGISTERPORTA    "PORTA"
+    STRING_REGISTERRESERVED1 "RESERVED"
+    STRING_REGISTERPIOC     "PIOC"
+    STRING_REGISTERPORTC    "PORTC"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    STRING_REGISTERPORTB    "PORTB"
+    STRING_REGISTERPORTCL   "PORTCL"
+    STRING_REGISTERRESERVED2 "RESERVED"
+    STRING_REGISTERDDRC     "DDRC"
+    STRING_REGISTERPORTD    "PORTD"
+    STRING_REGISTERDDRD     "DDRD"
+    STRING_REGISTERPORTE    "PORTE"
+    STRING_REGISTERCFORC    "CFORC"
+    STRING_REGISTEROC1M     "OC1M"
+    STRING_REGISTEROC1D     "OC1D"
+    STRING_REGISTERTCNTH1   "TCNT(Hi)"
+    STRING_REGISTERTCNTLO   "TCNT(Lo)"
+    STRING_REGISTERTIC1HI   "TIC1(Hi)"
+    STRING_REGISTERTIC1LO   "TIC1(Lo)"
+    STRING_REGISTERTIC2HI   "TIC2(Hi)"
+    STRING_REGISTERTIC2LO   "TIC2(Lo)"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    STRING_REGISTERTIC3HI   "TIC3(Hi)"
+    STRING_REGISTERTIC3LO   "TIC3(Lo)"
+    STRING_REGISTERTOC1HI   "TOC1(Hi)"
+    STRING_REGISTERTOC1LO   "TOC1(Lo)"
+    STRING_REGISTERTOC2HI   "TOC2(Hi)"
+    STRING_REGISTERTOC2LO   "TOC2(Lo)"
+    STRING_REGISTERTOC3HI   "TOC3(Hi)"
+    STRING_REGISTERTOC3LO   "TOC3(Lo)"
+    STRING_REGISTERTOC4HI   "TOC4(Hi)"
+    STRING_REGISTERTOC4LO   "TOC4(Lo)"
+    STRING_REGISTERTI405HI  "TI405(Hi)"
+    STRING_REGISTERTI405LO  "TI4O5(Lo)"
+    STRING_REGISTERTCTL1    "TCTL1"
+    STRING_REGISTERTCTL2    "TCTL2"
+    STRING_REGISTERTMSK1    "TMSK1"
+    STRING_REGISTERTFLG1    "TFLG1"
+END
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    STRING_REGISTERTMSK2    "TMSK2"
+    STRING_REGISTERTFLG2    "TFLG2"
+    STRING_REGISTERPACTL    "PACTL"
+    STRING_REGISTERPACNT    "PACNT"
+    STRING_REGISTERSPCR     "SPCR"
+    STRING_REGISTERSPSR     "SPSR"
+    STRING_REGISTERSPDR     "SPDR"
+    STRING_REGISTERBAUD     "BAUD"
+    STRING_REGISTERSCCR1    "SCCR1"
+    STRING_REGISTERSCCR2    "SCCR2"
+    STRING_REGISTERSCSR     "SCSR"
+    STRING_REGISTERSCDR     "SCDR"
+    STRING_REGISTERADCTL    "ADCTL"
+    STRING_REGISTERADR1     "ADR1"
+    STRING_REGISTERADR2     "ADR2"
+    STRING_REGISTERADR3     "ADR3"
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+

m68hc11/backup/resource.h

@@ -0,0 +1,16 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by m68hc11.rc
+//
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NO_MFC                     1
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif