#include <hookproc/excptdlg.hpp>
#include <hookproc/excpthk.hpp>
#include <common/font.hpp>

WORD ExceptDlg::performDialog(const ExceptionRecord &exceptionRecord,const Context &exceptionContext)
{
  String staticControl("STATIC");
	String editControl("EDIT");
	DialogTemplate dlgTemplate;
	DialogItemTemplate argEdit;
	DialogItemTemplate argStatic;
	DialogItemTemplate argButton;
	DialogItemTemplate staticEAX;
	DialogItemTemplate staticEBX;
	DialogItemTemplate staticECX;
	DialogItemTemplate staticEDX;
	DialogItemTemplate staticESI;
	DialogItemTemplate staticEDI;
	DialogItemTemplate staticESP;
	DialogItemTemplate staticEBP;
	DialogItemTemplate staticDS;
	DialogItemTemplate staticES;
	DialogItemTemplate staticFS;
	DialogItemTemplate staticGS;
	DialogItemTemplate staticCS;
	DialogItemTemplate staticSS;
	DialogItemTemplate staticEIP;
	DialogItemTemplate staticFlagsCarry;
	DialogItemTemplate staticFlagsZero;
	DialogItemTemplate staticFlagsOverflow;
	DialogItemTemplate staticFlagsSign;
	DialogItemTemplate staticFlagsAuxiliary;
	DialogItemTemplate staticFlagsParity;
	DialogItemTemplate staticFlagsDirection;
	DialogItemTemplate staticFlagsInterrupt;
	DialogItemTemplate registerEAX;
	DialogItemTemplate registerEBX;
	DialogItemTemplate registerECX;
	DialogItemTemplate registerEDX;
	DialogItemTemplate registerESI;
	DialogItemTemplate registerEDI;
	DialogItemTemplate registerESP;
	DialogItemTemplate registerEBP;
	DialogItemTemplate registerDS;
	DialogItemTemplate registerES;
	DialogItemTemplate registerFS;
	DialogItemTemplate registerGS;
	DialogItemTemplate registerCS;
	DialogItemTemplate registerSS;
	DialogItemTemplate registerEIP;
	DialogItemTemplate registerFlagsSign;
	DialogItemTemplate registerFlagsCarry;
	DialogItemTemplate registerFlagsOverflow;
	DialogItemTemplate registerFlagsZero;
	DialogItemTemplate registerFlagsParity;
	DialogItemTemplate registerFlagsAuxiliary;
	DialogItemTemplate registerFlagsDirection;
	DialogItemTemplate registerFlagsInterrupt;
	DialogItemTemplate staticFlagsLabel;

  mExceptionRecord=exceptionRecord;
	mExceptionContext=exceptionContext;
	dlgTemplate.titleText(exceptionRecord.exceptionCodeString().isNull()?"Exception Handler":(LPSTR)(String&)exceptionRecord.exceptionCodeString());
	dlgTemplate.posRect(Rect(8,19,345,225)); 
	dlgTemplate.pointSize(6);
  dlgTemplate.typeFace("Helv");
	dlgTemplate.style(DS_MODALFRAME|WS_TABSTOP|WS_VISIBLE|WS_CAPTION|DS_3DLOOK|DS_SETFONT|WS_POPUP|WS_SYSMENU);

	argEdit.className(editControl);
  argEdit.titleText("");
	argEdit.style(WS_BORDER|WS_TABSTOP|WS_VISIBLE|WS_CHILD|ES_AUTOHSCROLL|ES_AUTOVSCROLL|ES_MULTILINE|ES_WANTRETURN|ES_READONLY);
	argEdit.posRect(Rect(2,60,340,140));  
	argEdit.itemID(EditControlID);

	argButton.className("BUTTON");
	argButton.titleText("Ok");
	argButton.style(WS_CHILD|WS_VISIBLE|BS_DEFPUSHBUTTON);
	argButton.posRect(Rect(145,205,50,14));
	argButton.itemID(IDOK);

	staticEAX.className(staticControl);
	staticEAX.titleText("eax:");
	staticEAX.style(WS_CHILD|WS_VISIBLE);
	staticEAX.posRect(Rect(2,9,19,8));
	staticEAX.itemID(-1);

	staticEBX.className(staticControl);
	staticEBX.titleText("ebx:");
	staticEBX.style(WS_CHILD|WS_VISIBLE);
	staticEBX.posRect(Rect(72,9,17,8));
	staticEBX.itemID(-1);

	staticECX.className(staticControl);
	staticECX.titleText("ecx:");
	staticECX.style(WS_CHILD|WS_VISIBLE);
	staticECX.posRect(Rect(143,9,16,8));
	staticECX.itemID(-1);

	staticEDX.className(staticControl);
	staticEDX.titleText("edx:");
	staticEDX.style(WS_CHILD|WS_VISIBLE);
	staticEDX.posRect(Rect(213,9,16,8));
	staticEDX.itemID(-1);

	staticESI.className(staticControl);
	staticESI.titleText("esi:");
	staticESI.style(WS_CHILD|WS_VISIBLE);
	staticESI.posRect(Rect(2,23,19,8));
	staticESI.itemID(-1);

	staticEDI.className(staticControl);
	staticEDI.titleText("edi:");
	staticEDI.style(WS_CHILD|WS_VISIBLE);
	staticEDI.posRect(Rect(72,23,14,8));
	staticEDI.itemID(-1);

	staticESP.className(staticControl);
	staticESP.titleText("esp:");
	staticESP.style(WS_CHILD|WS_VISIBLE);
	staticESP.posRect(Rect(143,23,16,8));
	staticESP.itemID(-1);

	staticEBP.className(staticControl);
	staticEBP.titleText("ebp:");
	staticEBP.style(WS_CHILD|WS_VISIBLE);
	staticEBP.posRect(Rect(213,23,17,8));
	staticEBP.itemID(-1);

	staticDS.className(staticControl);
	staticDS.titleText("ds:");
	staticDS.style(WS_CHILD|WS_VISIBLE);
	staticDS.posRect(Rect(2,37,13,8));
	staticDS.itemID(-1);

	registerDS.className(editControl);
	registerDS.titleText("");
	registerDS.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerDS.posRect(Rect(17,36,26,12));
	registerDS.itemID(DebugDS);

	staticES.className(staticControl);
	staticES.titleText("es:");
	staticES.style(WS_CHILD|WS_VISIBLE);
	staticES.posRect(Rect(45,37,13,8));
	staticES.itemID(-1);

	registerES.className(editControl);
	registerES.titleText("");
	registerES.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerES.posRect(Rect(59,36,26,12));
	registerES.itemID(DebugES);

	staticFS.className(staticControl);
	staticFS.titleText("fs:");
	staticFS.style(WS_CHILD|WS_VISIBLE);
	staticFS.posRect(Rect(87,37,13,8));
	staticFS.itemID(-1);

	registerFS.className(editControl);
	registerFS.titleText("");
	registerFS.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerFS.posRect(Rect(101,36,26,12));
	registerFS.itemID(DebugFS);

	staticGS.className(staticControl);
	staticGS.titleText("gs:");
	staticGS.style(WS_CHILD|WS_VISIBLE);
	staticGS.posRect(Rect(128,37,13,8));
	staticGS.itemID(-1);

	registerGS.className(editControl);
	registerGS.titleText("");
	registerGS.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerGS.posRect(Rect(142,36,26,12));
	registerGS.itemID(DebugGS);

	staticCS.className(staticControl);
	staticCS.titleText("cs:");
	staticCS.style(WS_CHILD|WS_VISIBLE);
	staticCS.posRect(Rect(169,37,13,8));
	staticCS.itemID(-1);

	registerCS.className(editControl);
	registerCS.titleText("");
	registerCS.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerCS.posRect(Rect(183,36,26,12));
	registerCS.itemID(DebugCS);

	staticSS.className(staticControl);
	staticSS.titleText("ss:");
	staticSS.style(WS_CHILD|WS_VISIBLE);
	staticSS.posRect(Rect(210,37,13,8));
	staticSS.itemID(-1);

	registerSS.className(editControl);
	registerSS.titleText("");
	registerSS.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerSS.posRect(Rect(224,36,26,12));
	registerSS.itemID(DebugSS);

	staticEIP.className(staticControl);
	staticEIP.titleText("eip:");
	staticEIP.style(WS_CHILD|WS_VISIBLE);
	staticEIP.posRect(Rect(281,9,13,8));
	staticEIP.itemID(-1);

	registerEAX.className(editControl);
	registerEAX.titleText("");
	registerEAX.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerEAX.posRect(Rect(22,7,48,12));
	registerEAX.itemID(DebugEAX);

	registerEBX.className(editControl);
	registerEBX.titleText("");
	registerEBX.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerEBX.posRect(Rect(92,7,48,12));
	registerEBX.itemID(DebugEBX);

	registerECX.className(editControl);
	registerECX.titleText("");
	registerECX.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerECX.posRect(Rect(162,7,48,12));
	registerECX.itemID(DebugECX);

	registerEDX.className(editControl);
	registerEDX.titleText("");
	registerEDX.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerEDX.posRect(Rect(231,7,48,12));
	registerEDX.itemID(DebugEDX);

	registerESI.className(editControl);
	registerESI.titleText("");
	registerESI.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerESI.posRect(Rect(22,21,48,12));
	registerESI.itemID(DebugESI);

	registerEDI.className(editControl);
	registerEDI.titleText("");
	registerEDI.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerEDI.posRect(Rect(92,21,48,12));
	registerEDI.itemID(DebugEDI);

	registerESP.className(editControl);
	registerESP.titleText("");
	registerESP.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerESP.posRect(Rect(162,21,48,12));
	registerESP.itemID(DebugESP);

	registerEBP.className(editControl);
	registerEBP.titleText("");
	registerEBP.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerEBP.posRect(Rect(231,21,48,12));
	registerEBP.itemID(DebugEBP);

	registerEIP.className(editControl);
	registerEIP.titleText("");
	registerEIP.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerEIP.posRect(Rect(295,7,48,12));
	registerEIP.itemID(DebugEIP);

	registerFlagsCarry.className(editControl);
	registerFlagsCarry.titleText("");
	registerFlagsCarry.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerFlagsCarry.posRect(Rect(257,36,10,12));
	registerFlagsCarry.itemID(DebugFlagsCarry);

	registerFlagsZero.className(editControl);
	registerFlagsZero.titleText("");
	registerFlagsZero.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerFlagsZero.posRect(Rect(268,36,10,12));
	registerFlagsZero.itemID(DebugFlagsZero);

	registerFlagsSign.className(editControl);
	registerFlagsSign.titleText("");
	registerFlagsSign.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerFlagsSign.posRect(Rect(279,36,10,12));
	registerFlagsSign.itemID(DebugFlagsSign);

	registerFlagsOverflow.className(editControl);
	registerFlagsOverflow.titleText("");
	registerFlagsOverflow.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerFlagsOverflow.posRect(Rect(290,36,10,12));
	registerFlagsOverflow.itemID(DebugFlagsOverflow);

	registerFlagsParity.className(editControl);
	registerFlagsParity.titleText("");
	registerFlagsParity.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerFlagsParity.posRect(Rect(301,36,10,12));
	registerFlagsParity.itemID(DebugFlagsParity);

	registerFlagsAuxiliary.className(editControl);
	registerFlagsAuxiliary.titleText("");
	registerFlagsAuxiliary.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerFlagsAuxiliary.posRect(Rect(312,36,10,12));
	registerFlagsAuxiliary.itemID(DebugFlagsAuxiliary);

	registerFlagsDirection.className(editControl);
	registerFlagsDirection.titleText("");
	registerFlagsDirection.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerFlagsDirection.posRect(Rect(323,36,10,12));
	registerFlagsDirection.itemID(DebugFlagsDirection);

	registerFlagsInterrupt.className(editControl);
	registerFlagsInterrupt.titleText("");
	registerFlagsInterrupt.style(WS_CHILD|WS_VISIBLE|ES_MULTILINE|WS_BORDER|WS_TABSTOP|ES_READONLY);
	registerFlagsInterrupt.posRect(Rect(334,36,10,12));
	registerFlagsInterrupt.itemID(DebugFlagsInterrupt);

	staticFlagsLabel.className(staticControl);
	staticFlagsLabel.titleText("Flags");
	staticFlagsLabel.style(WS_CHILD|WS_VISIBLE);
	staticFlagsLabel.posRect(Rect(293,25,24,8));
	staticFlagsLabel.itemID(-1);

	staticFlagsCarry.className(staticControl);
	staticFlagsCarry.titleText("cf:");
	staticFlagsCarry.style(WS_CHILD|WS_VISIBLE);
	staticFlagsCarry.posRect(Rect(259,50,8,8));
	staticFlagsCarry.itemID(-1);

	staticFlagsZero.className(staticControl);
	staticFlagsZero.titleText("zf:");
	staticFlagsZero.style(WS_CHILD|WS_VISIBLE);
	staticFlagsZero.posRect(Rect(270,50,8,8));
	staticFlagsZero.itemID(-1);

	staticFlagsSign.className(staticControl);
	staticFlagsSign.titleText("sf:");
	staticFlagsSign.style(WS_CHILD|WS_VISIBLE);
	staticFlagsSign.posRect(Rect(281,50,8,8));
	staticFlagsSign.itemID(-1);

	staticFlagsOverflow.className(staticControl);
	staticFlagsOverflow.titleText("ov:");
	staticFlagsOverflow.style(WS_CHILD|WS_VISIBLE);
	staticFlagsOverflow.posRect(Rect(292,50,8,8));
	staticFlagsOverflow.itemID(-1);

	staticFlagsParity.className(staticControl);
	staticFlagsParity.titleText("pf:");
	staticFlagsParity.style(WS_CHILD|WS_VISIBLE);
	staticFlagsParity.posRect(Rect(303,50,8,8));
	staticFlagsParity.itemID(-1);

	staticFlagsAuxiliary.className(staticControl);
	staticFlagsAuxiliary.titleText("af:");
	staticFlagsAuxiliary.style(WS_CHILD|WS_VISIBLE);
	staticFlagsAuxiliary.posRect(Rect(314,50,8,8));
	staticFlagsAuxiliary.itemID(-1);

	staticFlagsInterrupt.className(staticControl);
	staticFlagsInterrupt.titleText("if:");
	staticFlagsInterrupt.style(WS_CHILD|WS_VISIBLE);
	staticFlagsInterrupt.posRect(Rect(336,50,8,8));
	staticFlagsInterrupt.itemID(-1);

	staticFlagsDirection.className(staticControl);
	staticFlagsDirection.titleText("df:");
	staticFlagsDirection.style(WS_CHILD|WS_VISIBLE);
	staticFlagsDirection.posRect(Rect(325,50,8,8));
	staticFlagsDirection.itemID(-1);

	dlgTemplate+=argEdit;
	dlgTemplate+=argButton;
	dlgTemplate+=staticEAX;
	dlgTemplate+=staticEBX;
	dlgTemplate+=staticECX;
	dlgTemplate+=staticEDX;
	dlgTemplate+=staticESI;
	dlgTemplate+=staticEDI;
	dlgTemplate+=staticESP;
	dlgTemplate+=staticEBP;
	dlgTemplate+=staticDS;
	dlgTemplate+=staticES;
	dlgTemplate+=staticFS;
	dlgTemplate+=staticGS;
	dlgTemplate+=staticCS;
	dlgTemplate+=staticSS;
	dlgTemplate+=staticEIP;
	dlgTemplate+=staticFlagsCarry;
	dlgTemplate+=staticFlagsZero;
	dlgTemplate+=staticFlagsOverflow;
	dlgTemplate+=staticFlagsSign;
	dlgTemplate+=staticFlagsAuxiliary;
	dlgTemplate+=staticFlagsParity;
	dlgTemplate+=staticFlagsDirection;
	dlgTemplate+=staticFlagsInterrupt;
	dlgTemplate+=registerEAX;
	dlgTemplate+=registerEBX;
	dlgTemplate+=registerECX;
	dlgTemplate+=registerEDX;
	dlgTemplate+=registerESI;
	dlgTemplate+=registerEDI;
	dlgTemplate+=registerESP;
	dlgTemplate+=registerEBP;
	dlgTemplate+=registerDS;
	dlgTemplate+=registerES;
	dlgTemplate+=registerFS;
	dlgTemplate+=registerGS;
	dlgTemplate+=registerCS;
	dlgTemplate+=registerSS;
	dlgTemplate+=registerEIP;
	dlgTemplate+=registerFlagsSign;
	dlgTemplate+=registerFlagsCarry;
	dlgTemplate+=registerFlagsOverflow;
	dlgTemplate+=registerFlagsZero;
	dlgTemplate+=registerFlagsParity;
	dlgTemplate+=registerFlagsAuxiliary;
	dlgTemplate+=registerFlagsDirection;
	dlgTemplate+=registerFlagsInterrupt;
	dlgTemplate+=staticFlagsLabel;

	createDialog(dlgTemplate);
	clear();
  return TRUE;
}

DWORD ExceptDlg::eax(void)const
{
  String strString;

  sendMessage(DebugEAX,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::eax(DWORD eax)
{
  String strString;

	::sprintf(strString,"%08lx",eax);
	strString.upper();
	sendMessage(DebugEAX,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

DWORD ExceptDlg::ebx(void)const
{
  String strString;

	sendMessage(DebugEBX,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::ebx(DWORD ebx)
{
  String strString;

	::sprintf(strString,"%08lx",ebx);
	strString.upper();
	sendMessage(DebugEBX,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

DWORD ExceptDlg::ecx(void)const
{
  String strString;

	sendMessage(DebugECX,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::ecx(DWORD ecx)
{
  String strString;

	::sprintf(strString,"%08lx",ecx);
	strString.upper();
	sendMessage(DebugECX,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

DWORD ExceptDlg::edx(void)const
{
  String strString;

	sendMessage(DebugEDX,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::edx(DWORD edx)
{
  String strString;

	::sprintf(strString,"%08lx",edx);
	strString.upper();
	sendMessage(DebugEDX,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

DWORD ExceptDlg::esi(void)const
{
  String strString;

	sendMessage(DebugESI,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::esi(DWORD esi)
{
  String strString;

	::sprintf(strString,"%08lx",esi);
	strString.upper();
	sendMessage(DebugESI,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

DWORD ExceptDlg::edi(void)const
{
  String strString;

	sendMessage(DebugEDI,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::edi(DWORD edi)
{
  String strString;

	::sprintf(strString,"%08lx",edi);
	strString.upper();
	sendMessage(DebugEDI,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

DWORD ExceptDlg::esp(void)const
{
  String strString;

	sendMessage(DebugESP,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::esp(DWORD esp)
{
  String strString;

	::sprintf(strString,"%08lx",esp);
	strString.upper();
	sendMessage(DebugESP,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

DWORD ExceptDlg::ebp(void)const
{
  String strString;

	sendMessage(DebugEBP,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::ebp(DWORD ebp)
{
  String strString;

	::sprintf(strString,"%08lx",ebp);
	strString.upper();
	sendMessage(DebugEBP,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

DWORD ExceptDlg::eip(void)const
{
  String strString;

	sendMessage(DebugEIP,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::eip(DWORD eip)
{
  String strString;

	::sprintf(strString,"%08lx",eip);
	strString.upper();
	sendMessage(DebugEIP,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

WORD ExceptDlg::ds(void)const
{
  String strString;

	sendMessage(DebugDS,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::ds(WORD ds)
{
  String strString;

	::sprintf(strString,"%04lx",ds);
	strString.upper();
	sendMessage(DebugDS,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

WORD ExceptDlg::es(void)const
{
  String strString;

	sendMessage(DebugES,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::es(WORD es)
{
  String strString;

	::sprintf(strString,"%04lx",es);
	strString.upper();
	sendMessage(DebugES,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

WORD ExceptDlg::fs(void)const
{
  String strString;

	sendMessage(DebugFS,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::fs(WORD fs)
{
  String strString;

	::sprintf(strString,"%04lx",fs);
	strString.upper();
	sendMessage(DebugFS,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

WORD ExceptDlg::gs(void)const
{
  String strString;

	sendMessage(DebugGS,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::gs(WORD gs)
{
  String strString;

  ::sprintf(strString,"%04lx",gs);
	strString.upper();
	sendMessage(DebugGS,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

WORD ExceptDlg::cs(void)const
{
  String strString;

  sendMessage(DebugCS,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::cs(WORD cs)
{
  String strString;
  
	::sprintf(strString,"%04lx",cs);
	strString.upper();
	sendMessage(DebugCS,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

WORD ExceptDlg::ss(void)const
{
  String strString;

	sendMessage(DebugSS,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::ss(WORD ss)
{
  String strString;

	::sprintf(strString,"%04lx",ss);
	strString.upper();
	sendMessage(DebugSS,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

BOOL ExceptDlg::signFlag(void)const
{
  String strString;

	sendMessage(DebugFlagsSign,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::signFlag(BOOL signFlag)
{
  String strString;

	::sprintf(strString,"%01lx",signFlag);
	strString.upper();
	sendMessage(DebugFlagsSign,WM_SETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
}

BOOL ExceptDlg::carryFlag(void)const
{
  String strString;

  sendMessage(DebugFlagsCarry,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::carryFlag(BOOL carryFlag)
{
  String strString;

	::sprintf(strString,"%01lx",carryFlag);
	strString.upper();
	sendMessage(DebugFlagsCarry,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

BOOL ExceptDlg::overflowFlag(void)const
{
  String strString;

  sendMessage(DebugFlagsOverflow,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::overflowFlag(BOOL overflowFlag)
{
  String strString;

  ::sprintf(strString,"%01lx",overflowFlag);
	strString.upper();
	sendMessage(DebugFlagsOverflow,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

BOOL ExceptDlg::zeroFlag(void)const
{
  String strString;

	sendMessage(DebugFlagsZero,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::zeroFlag(BOOL zeroFlag)
{
  String strString;

	::sprintf(strString,"%01lx",zeroFlag);
	strString.upper();
	sendMessage(DebugFlagsZero,WM_SETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
}

BOOL ExceptDlg::parityFlag(void)const
{
  String strString;

	sendMessage(DebugFlagsParity,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::parityFlag(BOOL parityFlag)
{
  String strString;

  ::sprintf(strString,"%01lx",parityFlag);
	strString.upper();
	sendMessage(DebugFlagsParity,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

BOOL ExceptDlg::auxiliaryFlag(void)const
{
  String strString;

	sendMessage(DebugFlagsAuxiliary,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::auxiliaryFlag(BOOL auxiliaryFlag)
{
  String strString;

  ::sprintf(strString,"%01lx",auxiliaryFlag);
	strString.upper();
	sendMessage(DebugFlagsAuxiliary,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

BOOL ExceptDlg::directionFlag(void)const
{
  String strString;

	sendMessage(DebugFlagsDirection,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::directionFlag(BOOL directionFlag)
{
  String strString;

	::sprintf(strString,"%01lx",directionFlag);
	strString.upper();
	sendMessage(DebugFlagsDirection,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

BOOL ExceptDlg::interruptFlag(void)const
{
  String strString;

	sendMessage(DebugFlagsInterrupt,WM_GETTEXT,String::MaxString,(LPARAM)(LPSTR)strString);
	return strString.hex();
}

void ExceptDlg::interruptFlag(BOOL interruptFlag)
{
  String strString;

	::sprintf(strString,"%01lx",interruptFlag);
	strString.upper();
	sendMessage(DebugFlagsInterrupt,WM_SETTEXT,0,(LPARAM)(LPSTR)strString);
}

void ExceptDlg::clear(void)
{
  eax(0);ebx(0);ecx(0);edx(0);esi(0);edi(0);esp(0);ebp(0);eip(0);ds(0);es(0);fs(0);gs(0);cs(0);ss(0);
	signFlag(FALSE);
	carryFlag(FALSE);
	overflowFlag(FALSE);
	zeroFlag(FALSE);
	parityFlag(FALSE);
	auxiliaryFlag(FALSE);
	directionFlag(FALSE);
	interruptFlag(FALSE);
}

void ExceptDlg::showException(DWORD exceptionAddress)
{
  Block<String> codeLines;
	PureViewOfFile codeView;
	String codeLine;

	codeView.createView(MaxDecodeBytes,exceptionAddress);
	mDisAssembler.setBaseAddress(exceptionAddress);
	mDisAssembler.displayLines(FALSE);
	mDisAssembler.disassemble(codeLines,codeView);
	for(int lineIndex=0;lineIndex<codeLines.size();lineIndex++)
	{
	  codeLine+=codeLines[lineIndex];
		codeLine+="\r\n";
	}
  sendMessage(EditControlID,WM_SETTEXT,0,(LONG)(LPSTR)codeLine);
}

void ExceptDlg::showContext(void)
{
  eax(mExceptionContext.eax());
	ebx(mExceptionContext.ebx());
	ecx(mExceptionContext.ecx());
	edx(mExceptionContext.edx());
	esi(mExceptionContext.esi());
	edi(mExceptionContext.edi());
	esp(mExceptionContext.esp());
	ebp(mExceptionContext.ebp());
	eip(mExceptionContext.eip());
	ds(mExceptionContext.segDS());
	es(mExceptionContext.segES());
	fs(mExceptionContext.segFS());
	gs(mExceptionContext.segGS());
	cs(mExceptionContext.segCS());
	ss(mExceptionContext.segSS());
	signFlag((mExceptionContext.eFlags()&0x00000080?TRUE:FALSE));
	carryFlag((mExceptionContext.eFlags()&0x00000001?TRUE:FALSE));
	overflowFlag((mExceptionContext.eFlags()&0xFFFFF800?TRUE:FALSE));
	zeroFlag((mExceptionContext.eFlags()&0x00000040?TRUE:FALSE));
	parityFlag((mExceptionContext.eFlags()&0x00000004?TRUE:FALSE));
	auxiliaryFlag((mExceptionContext.eFlags()&0x00000010?TRUE:FALSE));
	directionFlag((mExceptionContext.eFlags()&0x00000400?TRUE:FALSE));
	interruptFlag((mExceptionContext.eFlags()&0x00000200?TRUE:FALSE));
}

// virtuals

WORD ExceptDlg::dlgCommand(DWORD commandID,CallbackData &/*someCallbackData*/)
{
	switch(commandID)
	{
		case IDOK :
			break;
		case IDCANCEL :
      break;
	}
  return FALSE;
}

WORD ExceptDlg::dlgCode(CallbackData &/*someCallbackData*/)
{
  return DLGC_WANTALLKEYS;
}

BOOL ExceptDlg::dlgInitDialog(CallbackData &/*someCallbackData*/)
{
	sendMessage(EditControlID,WM_SETFONT,(WPARAM)(HFONT)mEditFont,MAKELPARAM(TRUE,0));
  showException((DWORD)mExceptionRecord.exceptionAddress());
	showContext();
	::SetFocus(getItem(IDOK));
	return FALSE;
}

void ExceptDlg::dlgDestroyDialog(CallbackData &/*someCallbackData*/)
{
}