/*
 *   Emu48.c
 *
 *   This file is part of Emu48
 *
 *   Copyright (C) 1995 Sebastien Carlier
 *
 */
#include "pch.h"
#include "resource.h"
#include "Emu48.h"
#include "kml.h"

#define VERSION   "1.0"
#define EMU48_INI "Emu48.ini"

#ifdef _DEBUG
LPSTR szNoTitle = "Emu48 "VERSION" Debug";
#else
LPSTR szNoTitle;
#endif
LPSTR     szTitle = NULL;

static const char szLicence[] =
	"This program is free software; you can redistribute it and/or modify\r\n"
	"it under the terms of the GNU General Public License as published by\r\n"
	"the Free Software Foundation; either version 2 of the License, or\r\n"
	"(at your option) any later version.\r\n"
	"\r\n"
	"This program is distributed in the hope that it will be useful,\r\n"
	"but WITHOUT ANY WARRANTY; without even the implied warranty of\r\n"
	"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\r\n"
	"See the GNU General Public License for more details.\r\n"
	"\r\n"
	"You should have received a copy of the GNU General Public License\r\n"
	"along with this program; if not, write to the Free Software\r\n"
	"Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.";


HINSTANCE hApp = NULL;
HWND      hWnd = NULL;
HDC       hWindowDC  = NULL;
HPALETTE  hPalette = NULL;
HANDLE    hThread;
DWORD     lThreadId;
BOOL      bAutoSave = FALSE;
BOOL      bAutoSaveOnExit = TRUE;
BOOL      bAlwaysDisplayLog = TRUE;

//################
//#
//#    Window Status
//#
//################

VOID SetWindowTitle(LPSTR szString)
{
	if (szTitle)
	{
		LocalFree(szTitle);
	}
	if (szString)
	{
		szTitle = DuplicateString(szString);
	}
	else
	{
		szTitle = NULL;
	}
	if (szTitle)
	{
		SetWindowText(hWnd, szTitle);
	}
	else
	{
		SetWindowText(hWnd, szNoTitle);
	}
	return;
}

VOID UpdateWindowStatus()
{
	HMENU hMenu;
	hMenu = GetMenu(hWnd);
	
	if ((nState == 0)||(nState == 3))
	{
		if (szCurrentFilename[0])
			EnableMenuItem(hMenu,ID_FILE_SAVE,MF_ENABLED);
		else
			EnableMenuItem(hMenu,ID_FILE_SAVE,MF_GRAYED);
		EnableMenuItem(hMenu,ID_FILE_SAVEAS,MF_ENABLED);
		EnableMenuItem(hMenu,ID_FILE_CLOSE,MF_ENABLED);
		EnableMenuItem(hMenu,ID_BACKUP_SAVE,MF_GRAYED);
		EnableMenuItem(hMenu,ID_BACKUP_SAVE,MF_ENABLED);
		EnableMenuItem(hMenu,ID_VIEW_COPY,MF_ENABLED);
		EnableMenuItem(hMenu,ID_VIEW_RESET,MF_ENABLED);
		EnableMenuItem(hMenu,ID_OBJECT_LOAD,MF_ENABLED);
		EnableMenuItem(hMenu,ID_OBJECT_SAVE,MF_ENABLED);
	}
	else
	{
		EnableMenuItem(hMenu,ID_FILE_SAVE,MF_GRAYED);
		EnableMenuItem(hMenu,ID_FILE_SAVEAS,MF_GRAYED);
		EnableMenuItem(hMenu,ID_FILE_CLOSE,MF_ENABLED);
		EnableMenuItem(hMenu,ID_BACKUP_SAVE,MF_GRAYED);
		EnableMenuItem(hMenu,ID_VIEW_COPY,MF_GRAYED);
		EnableMenuItem(hMenu,ID_VIEW_RESET,MF_GRAYED);
		EnableMenuItem(hMenu,ID_OBJECT_LOAD,MF_GRAYED);
		EnableMenuItem(hMenu,ID_OBJECT_SAVE,MF_GRAYED);
	}
	if (bBackup)
	{
		EnableMenuItem(hMenu,ID_BACKUP_RESTORE,MF_ENABLED);
		EnableMenuItem(hMenu,ID_BACKUP_DELETE,MF_ENABLED);
	}
	else
	{
		EnableMenuItem(hMenu,ID_BACKUP_RESTORE,MF_GRAYED);
		EnableMenuItem(hMenu,ID_BACKUP_DELETE,MF_GRAYED);
	}
	return;
}



//################
//#
//#    Settings
//#
//################

static BOOL WritePrivateProfileInt(LPCTSTR lpszSection, LPCTSTR lpszEntry, int nValue, LPCTSTR lpszFilename)
{
	char s[16];
	wsprintf(s,"%i",nValue);
	return WritePrivateProfileString(lpszSection, lpszEntry, s, lpszFilename);
}

static VOID ReadSettings()
{
	// Files
	GetPrivateProfileString("Files","Emu48Directory",szCurrentDirectory,szEmu48Directory,260,EMU48_INI);
	bAutoSave       = GetPrivateProfileInt("Files","AutoSave",bAutoSave,EMU48_INI);
	bAutoSaveOnExit = GetPrivateProfileInt("Files","AutoSaveOnExit",bAutoSaveOnExit,EMU48_INI);
	// Port2
	bPort2IsShared  = GetPrivateProfileInt("Port2","IsShared",0,EMU48_INI);
	GetPrivateProfileString("Port2","Filename","SHARED.BIN",szPort2Filename,260,EMU48_INI);
	// Timers
	bAccurateTimer  = GetPrivateProfileInt("Timers","AccurateTimer",0,EMU48_INI);
	uT1Period       = GetPrivateProfileInt("Timers","T1Period",62,EMU48_INI);
	// KML
	bAlwaysDisplayLog = GetPrivateProfileInt("KML","AlwaysDisplayLog",bAlwaysDisplayLog,EMU48_INI);
	return;
}

static VOID WriteSettings()
{
	// Files
	WritePrivateProfileString("Files","Emu48Directory",szEmu48Directory,EMU48_INI);
	WritePrivateProfileInt("Files","AutoSave",bAutoSave,EMU48_INI);
	WritePrivateProfileInt("Files","AutoSaveOnExit",bAutoSaveOnExit,EMU48_INI);
	// Port2
	WritePrivateProfileInt("Port2","IsShared",bPort2IsShared,EMU48_INI);
	WritePrivateProfileString("Port2","Filename",szPort2Filename,EMU48_INI);
	// Timers
	WritePrivateProfileInt("Timers","AccurateTimer",bAccurateTimer,EMU48_INI);
	WritePrivateProfileInt("Timers","T1Period",uT1Period,EMU48_INI);
	// KML
	WritePrivateProfileInt("KML","AlwaysDisplayLog",bAlwaysDisplayLog,EMU48_INI);
	return;
}

static BOOL CALLBACK SettingsProc(HWND hDlg, UINT message, DWORD wParam, LONG lParam)
{
	
	switch (message)
	{
	case WM_INITDIALOG:
		CheckDlgButton(hDlg,IDC_PORT1WR,Chipset.Port1_Writeable);
		CheckDlgButton(hDlg,IDC_AUTOSAVE,bAutoSave);
		CheckDlgButton(hDlg,IDC_AUTOSAVEONEXIT,bAutoSaveOnExit);
		CheckDlgButton(hDlg,IDC_ALWAYSDISPLOG,bAlwaysDisplayLog);
		CheckDlgButton(hDlg,IDC_PORT2ISSHARED,bPort2IsShared);
		SetDlgItemText(hDlg,IDC_PORT2,szPort2Filename);
		SetDlgItemInt(hDlg,IDC_T1PERIOD,uT1Period,FALSE);
		CheckDlgButton(hDlg,IDC_USEMMTIMER,bAccurateTimer);
		if (nState == 1)
		{
			EnableWindow(GetDlgItem(hDlg,IDC_PORT1WR),FALSE);
		}
		else
		{
			EnableWindow(GetDlgItem(hDlg,IDC_PORT2ISSHARED),FALSE);
			EnableWindow(GetDlgItem(hDlg,IDC_PORT2),FALSE);
		}
		return TRUE;
	case WM_COMMAND:
		if (wParam == IDOK)
		{
			BOOL bTranslated;
			UINT uNewT1Period;
			if (Chipset.Port1Size)
			{
				UINT nOldState = SwitchToState(3);
				Chipset.Port1_Writeable = IsDlgButtonChecked(hDlg, IDC_PORT1WR);
				if (cCurrentRomType=='S')
				{
					Chipset.cards_status = (Chipset.Port1_Writeable)?0x5:0x1;
					if (Chipset.inte)
					{
						Chipset.Shutdn = FALSE;
						Chipset.SoftInt = TRUE;
						bInterrupt = TRUE;
					}
					Map(0x00,0xFF);
				}
				else
				{
					Chipset.cards_status = (Chipset.Port1_Writeable)?0xA:0x2;
					if (Chipset.inte)
					{
						Chipset.Shutdn = FALSE;
						Chipset.SoftInt = TRUE;
						bInterrupt = TRUE;
					}
					Map(0x00,0xFF);
				}
				SwitchToState(nOldState);
			}
			bAutoSave = IsDlgButtonChecked(hDlg, IDC_AUTOSAVE);
			bAutoSaveOnExit = IsDlgButtonChecked(hDlg, IDC_AUTOSAVEONEXIT);
			bAlwaysDisplayLog = IsDlgButtonChecked(hDlg, IDC_ALWAYSDISPLOG);
			if (nState == 1)
			{
				bPort2IsShared = IsDlgButtonChecked(hDlg,IDC_PORT2ISSHARED);
				GetDlgItemText(hDlg,IDC_PORT2,szPort2Filename,260);
			}
			bAccurateTimer = IsDlgButtonChecked(hDlg,IDC_USEMMTIMER);
			uNewT1Period   = GetDlgItemInt(hDlg, IDC_T1PERIOD, &bTranslated, FALSE);
			if (bTranslated)
				uT1Period = uNewT1Period;
			else
				uT1Period = 62;
			EndDialog(hDlg, wParam);
		}
		if (wParam == IDCANCEL)
		{
			EndDialog(hDlg, wParam);
		}
		if (wParam == IDC_T1DEFAULT)
		{
			SetDlgItemInt(hDlg,IDC_T1PERIOD,62,FALSE);
		}
		break;
	}
	return FALSE;
    UNREFERENCED_PARAMETER(lParam);
    UNREFERENCED_PARAMETER(hDlg);
}


//################
//#
//#    Save Helper
//#
//################

//
// UINT SaveChanges(BOOL bAuto);
// Return code :
// IDYES    File successfuly saved
// IDNO     File not saved
// IDCANCEL Cancel command
//
static UINT SaveChanges(BOOL bAuto)
{
	UINT uReply;
	
	if (pbyRom == NULL) return IDNO;
	
	if (bAuto)
		uReply = IDYES;
	else
		uReply = YesNoCancelMessage("Do you want to save changes ?");
	
	if (uReply != IDYES) return uReply;
	
	if (szCurrentFilename[0]==0)
	{ // Save As...
		uReply = GetSaveAsFilename();
		if (uReply != IDOK) return uReply;
		if (!SaveDocumentAs(szBufferFilename)) return IDCANCEL;
		WritePrivateProfileString("Files","LastDocument",szCurrentFilename,EMU48_INI);
		return IDYES;
	}
	
	SaveDocument();
	return IDYES;
}



//################
//#
//#    Message Handlers
//#
//################

//
// WM_CREATE
//
static LRESULT OnCreate(HWND hWindow)
{
	hWnd = hWindow;
	hWindowDC = GetDC(hWnd);
	return 0;
}

//
// WM_DESTROY
//
static LRESULT OnDestroy(HWND hWindow)
{
	
	SwitchToState(2);
	WriteSettings();
    ReleaseDC(hWnd, hWindowDC);
    hWnd = NULL;
    PostQuitMessage(0);
    return 0;
	UNREFERENCED_PARAMETER(hWindow);
}

//
// WM_PAINT
//
static LRESULT OnPaint(HWND hWindow)
{
	PAINTSTRUCT Paint;
	HDC hPaintDC;
	
	hPaintDC = BeginPaint(hWindow, &Paint);
	if (hMainDC == NULL) return 0;
	if ((nState==0)||(nState==3))
	{
		BitBlt(hPaintDC, 0, 0, nBackgroundW, nBackgroundH, hMainDC, nBackgroundX, nBackgroundY, SRCCOPY);
		UpdateMainDisplay();
		UpdateMenuDisplay();
		RefreshButtons();
	}
	else
	{
		BitBlt(hPaintDC, 0, 0, nBackgroundW, nBackgroundH, hMainDC, nBackgroundX, nBackgroundY, SRCCOPY);
	}
	EndPaint(hWindow, &Paint);
	return 0;
}

//
// ID_FILE_NEW
//
static LRESULT OnFileNew()
{
	UINT uReply;
	
	SaveBackup();
	if (pbyRom)
	{
		SwitchToState(1);
		uReply = SaveChanges(bAutoSave);
		if (uReply==IDCANCEL) goto cancel;
	}
	NewDocument();
	SetWindowTitle("Untitled");
	UpdateWindowStatus();
cancel:
	if (pbyRom) SwitchToState(0);
	return 0;
}

//
// ID_FILE_OPEN
//
static LRESULT OnFileOpen()
{
	UINT uReply;
	
	if (pbyRom)
	{
		SwitchToState(1);
		uReply = SaveChanges(bAutoSave);
		if (uReply==IDCANCEL) goto cancel;
	}
	if (GetOpenFilename())
	{
		OpenDocument(szBufferFilename);
	}
cancel:
	if (pbyRom)
	{
		SwitchToState(0);
	}
	return 0;
}

//
// ID_FILE_SAVE
//
static LRESULT OnFileSave()
{
	if (pbyRom == NULL) return 0;
	SwitchToState(1);
	SaveChanges(TRUE);
	SwitchToState(0);
	return 0;
}

//
// ID_FILE_SAVEAS
//
static LRESULT OnFileSaveAs()
{
	UINT uReply;
	
	if (pbyRom == NULL) return 0;
	SwitchToState(1);
	
	uReply = GetSaveAsFilename();
	if (uReply != IDOK)
	{
		SwitchToState(0);
		return 0;
	}
	if (!SaveDocumentAs(szBufferFilename))
	{
		SwitchToState(0);
		return 0;
	}
	WritePrivateProfileString("Files","LastDocument",szCurrentFilename,EMU48_INI);
	
	SwitchToState(0);
	return 0;
}

//
// ID_FILE_CLOSE
//
static LRESULT OnFileClose()
{
	if (pbyRom == NULL) return 0;
	SwitchToState(1);
	if (SaveChanges(bAutoSave)!=IDCANCEL)
	{
		KillKML();
		ResetDocument();
		SetWindowTitle(NULL);
	}
	else
	{
		SwitchToState(0);
	}
	return 0;
}

//
// ID_FILE_EXIT
//
static LRESULT OnFileExit()
{
	if (SaveChanges(bAutoSaveOnExit) == IDCANCEL)
	{
		return 0;
	}
	DestroyWindow(hWnd);
	return 0;
}

//
// WM_SYS_CLOSE
//
static LRESULT OnSysClose()
{
	if (SaveChanges(bAutoSaveOnExit) == IDCANCEL)
	{
		return 0;
	}
	DestroyWindow(hWnd);
	return 0;
}

//
// ID_VIEW_COPY
//
static LRESULT OnViewCopy()
{
	HBITMAP hOldBmp, hBmp;
	HDC hBmpDC;
	
	if (!OpenClipboard(hWnd)) return 0;
	if (!EmptyClipboard()) return 0;
	if (bLcdDoubled)
	{
		hBmp    = CreateBitmap(262,128,1,1,NULL);
		hBmpDC  = CreateCompatibleDC(NULL);
		hOldBmp = (HBITMAP)SelectObject(hBmpDC,hBmp);
		BitBlt(hBmpDC, 0, 0, 262, 128, hLcdDC, 0, 0, SRCCOPY);
	}
	else
	{
		hBmp    = CreateBitmap(131,64,1,1,NULL);
		hBmpDC  = CreateCompatibleDC(NULL);
		hOldBmp = (HBITMAP)SelectObject(hBmpDC,hBmp);
		BitBlt(hBmpDC, 0, 0, 131, 64, hLcdDC, 0, 0, SRCCOPY);
	}
	SetClipboardData(CF_BITMAP,hBmp);
	SelectObject(hBmpDC,hOldBmp);
	DeleteDC(hBmpDC);
	CloseClipboard();
	return 0;
}

//
// ID_VIEW_RESET
//
static LRESULT OnViewReset()
{
	if (nState!=0) return 0;
	if (YesNoMessage("Are you sure you want to press the Reset Button ?")==IDYES)
	{
		SwitchToState(3);
		Chipset.pc = 0;
		Chipset.inte = TRUE;
		Chipset.Shutdn = FALSE;
		Chipset.SoftInt = TRUE;
		bInterrupt = TRUE;
		SwitchToState(0);
	}
	return 0;
}

//
// ID_VIEW_SETTINGS
//
static LRESULT OnViewSettings()
{
	ReadSettings();
	if (nState == 1) UnmapPort2();
	if (DialogBox(hApp, MAKEINTRESOURCE(IDD_SETTINGS), hWnd, (DLGPROC)SettingsProc) == -1)
		AbortMessage("Settings Dialog Creation Error !");
	if (nState == 1) MapPort2(szPort2Filename);
	WriteSettings();
	return 0;
}

//
// ID_VIEW_SCRIPT
//
static LRESULT OnViewScript()
{
	CHAR cType = cCurrentRomType;
	if (nState!=0)
	{
		InfoMessage("You cannot change the KML script when Emu48 is not running.\n"
			"Use the File,New menu item to create a new calculator.");
		return 0;
	}
	SwitchToState(1);
retry:
	if (!DisplayChooseKml(cType)) goto ok;
	if (!InitKML(szCurrentKml,FALSE))
	{
		if (AbortMessage("This KML Script has errors.\nPress Ok to try to find a correct script.")==IDCANCEL)
		{
			if (szCurrentFilename[0])
				OnFileSave();
			else
				OnFileSaveAs();
			goto ok;
		}
		goto retry;
	}
ok:
	if (pbyRom) SwitchToState(0);
	return 0;
}

//
// ID_BACKUP_SAVE
//
static LRESULT OnBackupSave()
{
	UINT nOldState;
	if (pbyRom == NULL) return 0;
	nOldState = SwitchToState(1);
	SaveBackup();
	SwitchToState(nOldState);
	return 0;
}

//
// ID_BACKUP_RESTORE
//
static LRESULT OnBackupRestore()
{
	SwitchToState(1);
	RestoreBackup();
	if (pbyRom) SwitchToState(0);
	return 0;
}

//
// ID_BACKUP_DELETE
//
static LRESULT OnBackupDelete()
{
	ResetBackup();
	return 0;
}

//
// ID_OBJECT_LOAD
//
static LRESULT OnObjectLoad()
{
	static BOOL bWarning = TRUE;
	
	if (nState!=0)
	{
		InfoMessage("The emulator must be running to load an object.");
		return 0;
	}
	
	SwitchToState(3);
	
	if (bWarning)
	{
		UINT uReply = YesNoCancelMessage(
			"Warning: Trying to load an object while the emulator is busy \n"
			"will certainly result in a memory lost. Before loading an object \n"
			"you should be sure that the HP48 is not doing anything. \n"
			"Do you want to see this warning next time you try to load an object ?");
		switch (uReply)
		{
		case IDYES:
			break;
		case IDNO:
			bWarning = FALSE;
			break;
		case IDCANCEL:
			SwitchToState(0);
			return 0;
		}
	}
	
	if (!GetLoadObjectFilename())
	{
		SwitchToState(0);
		return 0;
	}
	
	if (!LoadObject(szBufferFilename))
	{
		SwitchToState(0);
		return 0;
	}
	
	SwitchToState(0);
	while (nState!=nNextState) Sleep(0);
	KeyboardEvent(TRUE,0,0x8000);
	Sleep(200);
	KeyboardEvent(FALSE,0,0x8000);
	Sleep(100);
	KeyboardEvent(TRUE,0,0x8000);
	Sleep(200);
	KeyboardEvent(FALSE,0,0x8000);
	return 0;
}

//
// ID_OBJECT_SAVE
//
static LRESULT OnObjectSave()
{
	
	if (nState!=0)
	{
		InfoMessage("The emulator must be running to save an object.");
		return 0;
	}
	
	SwitchToState(3);
	
	if (!GetSaveObjectFilename())
	{
		SwitchToState(0);
		return 0;
	}
	
	SaveObject(szBufferFilename);
	
	SwitchToState(0);
	
	return 0;
}


//
// ID_ABOUT
//
static BOOL CALLBACK About(HWND hDlg, UINT message, DWORD wParam, LONG lParam)
{
	
	switch (message)
	{
	case WM_INITDIALOG:
		SetDlgItemText(hDlg,IDC_VERSION,szNoTitle);
		SetDlgItemText(hDlg,IDC_LICENSE,szLicence);
		return TRUE;
	case WM_COMMAND:
		if ((wParam==IDOK)||(wParam==IDCANCEL))
		{
			EndDialog(hDlg, wParam);
			break;
		}
		break;
	}
	return FALSE;
    UNREFERENCED_PARAMETER(lParam);
    UNREFERENCED_PARAMETER(hDlg);
}

static LRESULT OnAbout()
{
	if (pbyRom) SwitchToState(3);
	if (DialogBox(hApp, MAKEINTRESOURCE(IDD_ABOUT), hWnd, (DLGPROC)About) == -1)
		AbortMessage("About Dialog Box Creation Error !");
	if (pbyRom) SwitchToState(0);
	return 0;
}

static LRESULT OnLButtonDown(UINT nFlags, WORD x, WORD y)
{
	if (nState==0) MouseButtonDownAt(nFlags, x,y);
	return 0;
}

static LRESULT OnLButtonUp(UINT nFlags, WORD x, WORD y) 
{
	if (nState==0) MouseButtonUpAt(nFlags, x,y);
	return 0;
}

static LRESULT OnMouseMove(UINT nFlags, WORD x, WORD y)
{
	if (nState==0) MouseMovesTo(nFlags, x,y);
	return 0;
}

static LRESULT OnKeyDown(int nVirtKey, DWORD lKeyData)
{
	if (nState==0) RunKey((BYTE)nVirtKey, TRUE);
	return 0;
	UNREFERENCED_PARAMETER(lKeyData);
}

static LRESULT OnKeyUp(int nVirtKey, DWORD lKeyData)
{
	if (nState==0) RunKey((BYTE)nVirtKey, FALSE);
	return 0;
	UNREFERENCED_PARAMETER(lKeyData);
}

static LRESULT CALLBACK MainWndProc(HWND hWindow, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
	case WM_CREATE:          return OnCreate(hWindow);
	case WM_DESTROY:         return OnDestroy(hWindow);
	case WM_PAINT:           return OnPaint(hWindow);
	case WM_ACTIVATE:
		if (LOWORD(wParam)==WA_INACTIVE) break;
	case WM_QUERYNEWPALETTE:
		if (hPalette)
		{
			SelectPalette(hWindowDC, hPalette, FALSE);
			if (RealizePalette(hWindowDC))
			{
				InvalidateRect(hWindow,NULL,TRUE);
				return TRUE;
			}
		}
		return FALSE;
	case WM_PALETTECHANGED:
		if ((HWND)wParam == hWindow) break;
		if (hPalette)
		{
			SelectPalette(hWindowDC, hPalette, FALSE);
			if (RealizePalette(hWindowDC))
			{
				//				UpdateColors(hWindowDC);
				InvalidateRect (hWnd, (LPRECT) (NULL), 1);
			}
		}
		return FALSE;
	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case ID_FILE_NEW:      return OnFileNew();
		case ID_FILE_OPEN:     return OnFileOpen();
		case ID_FILE_SAVE:     return OnFileSave();
		case ID_FILE_SAVEAS:   return OnFileSaveAs();
		case ID_FILE_CLOSE:    return OnFileClose();
		case ID_FILE_EXIT:     return OnFileExit();
		case ID_VIEW_COPY:     return OnViewCopy();
		case ID_VIEW_RESET:    return OnViewReset();
		case ID_VIEW_SETTINGS: return OnViewSettings();
		case ID_VIEW_SCRIPT:   return OnViewScript();
		case ID_BACKUP_SAVE:   return OnBackupSave();
		case ID_BACKUP_RESTORE:return OnBackupRestore();
		case ID_BACKUP_DELETE: return OnBackupDelete();
		case ID_OBJECT_LOAD:   return OnObjectLoad();
		case ID_OBJECT_SAVE:   return OnObjectSave();
		case ID_ABOUT:         return OnAbout();
		}
		break;
		case WM_SYSCOMMAND:
			switch (LOWORD(wParam))
			{
			case SC_CLOSE:       return OnSysClose();
			}
			break;
			case WM_LBUTTONDOWN:     return OnLButtonDown(wParam, LOWORD(lParam), HIWORD(lParam));
			case WM_LBUTTONUP:       return OnLButtonUp(wParam, LOWORD(lParam), HIWORD(lParam));
			case WM_MOUSEMOVE:       return OnMouseMove(wParam, LOWORD(lParam), HIWORD(lParam));
			case WM_KEYUP:           return OnKeyUp((int)wParam, lParam);
			case WM_KEYDOWN:         return OnKeyDown((int)wParam, lParam);
	}
	return DefWindowProc(hWindow, uMsg, wParam, lParam);
}

static BOOL FlushMessages(LPMSG msg)
{
	while (PeekMessage(msg, NULL, 0, 0, PM_REMOVE))
	{
		if (msg->message == WM_QUIT) return TRUE;
		TranslateMessage(msg);
		DispatchMessage(msg);
	}
	return FALSE;
}


int PASCAL WinMain(HANDLE hInst, HANDLE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
	MSG msg;
	WNDCLASS wc;
	RECT rectWindow;
	
	hApp = hInst;
	
	wc.style = CS_BYTEALIGNCLIENT;
	wc.lpfnWndProc = (WNDPROC)MainWndProc;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInst;
	wc.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(IDI_EMU48));
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = NULL;
	wc.lpszMenuName = MAKEINTRESOURCE(IDR_MENU);
	wc.lpszClassName = "CEmu48";
	
	if (!RegisterClass(&wc))
	{
		AbortMessage(
			"CEmu48 class registration failed.\n"
			"This application will now terminate.");
		return FALSE;
	}
	
	// Create window
	
	rectWindow.left   = 0;
	rectWindow.top    = 0;
	rectWindow.right  = 256;
	rectWindow.bottom = 0;
	AdjustWindowRect(&rectWindow, WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_OVERLAPPED, TRUE);
	
	hWnd = CreateWindow("CEmu48", "Emu48",
		WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_OVERLAPPED,
		CW_USEDEFAULT, CW_USEDEFAULT,
		rectWindow.right  - rectWindow.left,
		rectWindow.bottom - rectWindow.top,
		NULL,NULL,hApp,NULL
		);
	
	if (hWnd == NULL)
	{
		AbortMessage("Window creation failed.\n");
		return FALSE;
	}
	
	ShowWindow(hWnd, nCmdShow);
	
	if (FlushMessages(&msg)) return msg.wParam;
	
	// initialization
	
	GetCurrentDirectory(260, szCurrentDirectory);
	
	ReadSettings();
	
	szNoTitle = "Emu48 "VERSION;
	
	UpdateWindowStatus();
	
	nState     = 1;    // thread starts in an invalid state
	nNextState = 1;
	hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)&WorkerThread, NULL, 0, &lThreadId);
	if (hThread == NULL)
	{
		AbortMessage("Thread creation failed.");
		return FALSE;
	}
	
	MapPort2(szPort2Filename);
	
	if (lpCmdLine[0])
	{
		CHAR szTemp[256] = "Loading ";
		strcat(szTemp, lpCmdLine);
		SetWindowTitle(szTemp);
		if (FlushMessages(&msg)) return msg.wParam;
		if (OpenDocument(lpCmdLine))
			goto start;
	}
	
	GetPrivateProfileString("Files","LastDocument",NULL,szBufferFilename,260,EMU48_INI);
	if (szBufferFilename[0])
	{
		CHAR szTemp[256] = "Loading ";
		strcat(szTemp, szBufferFilename);
		SetWindowTitle(szTemp);
		if (FlushMessages(&msg)) return msg.wParam;
		if (OpenDocument(szBufferFilename))
			goto start;
	}
	
	SetWindowTitle("New Document");
	if (FlushMessages(&msg)) return msg.wParam;
	if (NewDocument())
	{
		SetWindowTitle("Untitled");
		goto start;
	}
	
	ResetDocument();
	SetWindowTitle(NULL);
	
start:
	if (pbyRom) SwitchToState(0);
	
	while (GetMessage(&msg, NULL, 0, 0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	
	SwitchToState(2);
	ResetDocument();
	ResetBackup();
	cCurrentRomType = 0;
	KillKML();
	UnmapPort2();
	
	return msg.wParam;
	UNREFERENCED_PARAMETER(lpCmdLine);
	UNREFERENCED_PARAMETER(hPrevInst);
}