/*  Pcsx - Pc Psx Emulator
 *  Copyright (C) 1999-2003  Pcsx Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>

#include "resource.h"
#include "AboutDlg.h"

#include "psxcommon.h"
#include "plugin.h"
#include "debug.h"
#include "Win32.h"
#include "sio.h"
#include "misc.h"
#include "cheat.h"

#ifdef __MINGW32__
#ifndef LVM_GETSELECTIONMARK
#define LVM_GETSELECTIONMARK (LVM_FIRST+66)
#endif
#ifndef ListView_GetSelectionMark
#define ListView_GetSelectionMark(w) (INT)SNDMSG((w),LVM_GETSELECTIONMARK,0,0)
#endif
#endif

int AccBreak = 0;
int ConfPlug = 0;
int StatesC = 0;
int CancelQuit = 0;
char cfgfile[256];
int Running = 0;
boolean UseGui = TRUE;
char PcsxrDir[256];

static HDC          hDC;
static HDC          hdcmem;
static HBITMAP      hBm;
static BITMAP       bm;

#ifdef ENABLE_NLS

unsigned int langsMax;

typedef struct {
	char lang[256];
} _langs;
_langs *langs = NULL;

typedef struct {
	char			id[8];
	char			name[64];
	LANGID			langid;
} LangDef;

LangDef sLangs[] = {
	{ "ar",		N_("Arabic"),				0x0401 },
	{ "ca",		N_("Catalan"),				0x0403 },
	{ "de",		N_("German"),				0x0407 },
	{ "el",		N_("Greek"),				0x0408 },
	{ "en",		N_("English"),				0x0409 },
	{ "es",		N_("Spanish"),				0x040a },
	{ "fr_FR",	N_("French"),				0x040c },
	{ "hu_HU",	N_("Hungarian"),			0x040e },
	{ "it",		N_("Italian"),				0x0410 },
	{ "pt",		N_("Portuguese"),			0x0816 },
	{ "pt_BR",	N_("Portuguese (Brazilian)"),		0x0416 },
	{ "ro",		N_("Romanian"),				0x0418 },
	{ "ru_RU",	N_("Russian"),				0x0419 },
	{ "zh_CN",	N_("Simplified Chinese"),	0x0804 },
	{ "zh_TW",	N_("Traditional Chinese"),	0x0404 },
	{ "ja",		N_("Japanese"),				0x0411 },
	{ "ko_KR",	N_("Korean"),				0x0412 },
	{ "", "", 0xFFFF },
};

char *ParseLang(char *id) {
	int i=0;

	while (sLangs[i].id[0] != '\0') {
		if (!strcmp(id, sLangs[i].id))
			return _(sLangs[i].name);
		i++;
	}

	return id;
}

static void SetDefaultLang(void) {
	LANGID langid;
	int i;

	langid = GetSystemDefaultLangID();

	i = 0;
	while (sLangs[i].id[0] != '\0') {
		if (langid == sLangs[i].langid) {
			strcpy(Config.Lang, sLangs[i].id);
			return;
		}
		i++;
	}

	strcpy(Config.Lang, "English");
}

#endif

void strcatz(char *dst, char *src) {
	int len = strlen(dst) + 1;
	strcpy(dst + len, src);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
	char *arg = NULL;
	char cdfile[MAXPATHLEN] = "", buf[4096];
	int loadstatenum = -1;

	strcpy(cfgfile, "Software\\Pcsxr");

	gApp.hInstance = hInstance;

#ifdef ENABLE_NLS
	bindtextdomain(PACKAGE, "Langs\\");
	textdomain(PACKAGE);
#endif

	Running = 0;

	GetCurrentDirectory(256, PcsxrDir);

	memset(&Config, 0, sizeof(PcsxConfig));
	strcpy(Config.Net, "Disabled");
	if (LoadConfig() == -1) {
		Config.PsxAuto = 1;
		strcpy(Config.PluginsDir, "Plugins\\");
		strcpy(Config.BiosDir,    "Bios\\");

		strcpy(Config.Mcd1, "memcards\\Mcd001.mcr");
		strcpy(Config.Mcd2, "memcards\\Mcd002.mcr");

		ConfPlug = 1;

#ifdef ENABLE_NLS
		{
			char text[256];
			SetDefaultLang();
			sprintf(text, "LANGUAGE=%s", Config.Lang);
			gettext_putenv(text);
		}
#endif

		ConfigurePlugins(gApp.hWnd);

		if (LoadConfig() == -1) {
			return 0;
		}
	}

	strcpy(Config.PatchesDir, "Patches\\");

#ifdef ENABLE_NLS
	if (Config.Lang[0] == 0) {
		SetDefaultLang();
		SaveConfig();
		LoadConfig();
	}
#endif

	// Parse command-line
	strncpy(buf, lpCmdLine, 4096);

	for (arg = strtok(buf, " "); arg != NULL; arg = strtok(NULL, " ")) {
		if (strcmp(arg, "-nogui") == 0) {
			UseGui = FALSE;
		} else if (strcmp(arg, "-runcd") == 0) {
			cdfile[0] = '\0';
		} else if (strcmp(arg, "-cdfile") == 0) {
			arg = strtok(NULL, " ");
			if (arg != NULL) {
				if (arg[0] == '"') {
					strncpy(buf, lpCmdLine + (arg - buf), 4096);
					arg = strtok(buf, "\"");
					if (arg != NULL) strcpy(cdfile, arg);
				} else {
					strcpy(cdfile, arg);
				}
				UseGui = FALSE;
			}
		} else if (strcmp(arg, "-psxout") == 0) {
			Config.PsxOut = TRUE;
		} else if (strcmp(arg, "-slowboot") == 0) {
			Config.SlowBoot = TRUE;
		} else if (strcmp(arg, "-help") == 0) {
			MessageBox(gApp.hWnd, _(
				"Usage: pcsxr [options]\n"
				"\toptions:\n"
				"\t-nogui\t\tDon't open the GUI\n"
				"\t-psxout\t\tEnable PSX output\n"
				"\t-slowboot\t\tEnable BIOS logo\n"
				"\t-runcd\t\tRuns CD-ROM (requires -nogui)\n"
				"\t-cdfile FILE\tRuns a CD image file (requires -nogui)\n"
				"\t-help\t\tDisplay this message"),
				"PCSXR", 0);

			return 0;
		}
	}

	if (SysInit() == -1) return 1;

	CreateMainWindow(nCmdShow);

	if (!UseGui) {
		SetIsoFile(cdfile);
		PostMessage(gApp.hWnd, WM_COMMAND, ID_FILE_RUN_NOGUI, 0);
	}

	RunGui();

	return 0;
}

void RunGui() {
	MSG msg;

	for (;;) {
		if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE)) {
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		else
		{
			// Avoid 100% cpu usage.
			Sleep(10);
		}
	}
}

void RestoreWindow() {
	AccBreak = 1;
	DestroyWindow(gApp.hWnd);
	CreateMainWindow(SW_SHOWNORMAL);

	if(Config.HideCursor)
		ShowCursor(TRUE);

	//SetCursor(LoadCursor(gApp.hInstance, IDC_ARROW));
	//ShowCursor(TRUE);

	if (!UseGui) PostMessage(gApp.hWnd, WM_COMMAND, ID_FILE_EXIT, 0);
}

void ResetMenuSlots() {
	char str[256];
	int i;

	for (i = 0; i < 9; i++) {
		GetStateFilename(str, i);
		if (CheckState(str) == -1)
			EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_SLOT1+i, MF_GRAYED);
		else
			EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_SLOT1+i, MF_ENABLED);
	}
}

void OpenConsole() {
	if (hConsole) return;
	AllocConsole();
	SetConsoleTitle("Psx Output");
	hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
}

void CloseConsole() {
	FreeConsole();
	hConsole = NULL;
}

void States_Load(int num) {
	char Text[256];
	int ret;

	SetMenu(gApp.hWnd, NULL);
	OpenPlugins(gApp.hWnd);

	GetStateFilename(Text, num);

	ret = LoadState(Text);
	if (ret == 0)
		 sprintf(Text, _("*PCSXR*: Loaded State %d"), num+1);
	else sprintf(Text, _("*PCSXR*: Error Loading State %d"), num+1);
	GPU_displayText(Text);

	Running = 1;
	CheatSearchBackupMemory();
	psxCpu->Execute();
}

void States_Save(int num) {
	char Text[256];
	int ret;

	SetMenu(gApp.hWnd, NULL);
	OpenPlugins(gApp.hWnd);

	GPU_updateLace();

	GetStateFilename(Text, num);
	GPU_freeze(2, (GPUFreeze_t *)&num);
	ret = SaveState(Text);
	if (ret == 0)
		 sprintf(Text, _("*PCSXR*: Saved State %d"), num+1);
	else sprintf(Text, _("*PCSXR*: Error Saving State %d"), num+1);
	GPU_displayText(Text);

	Running = 1;
	CheatSearchBackupMemory();
	psxCpu->Execute();
}

void OnStates_LoadOther() {
	OPENFILENAME ofn;
	char szFileName[MAXPATHLEN];
	char szFileTitle[MAXPATHLEN];
	char szFilter[256];

	memset(&szFileName,  0, sizeof(szFileName));
	memset(&szFileTitle, 0, sizeof(szFileTitle));
	memset(&szFilter,    0, sizeof(szFilter));

	strcpy(szFilter, _("PCSXR State Format"));
	strcatz(szFilter, "*.*");

	ofn.lStructSize			= sizeof(OPENFILENAME);
	ofn.hwndOwner			= gApp.hWnd;
	ofn.lpstrFilter			= szFilter;
	ofn.lpstrCustomFilter		= NULL;
	ofn.nMaxCustFilter		= 0;
	ofn.nFilterIndex		= 1;
	ofn.lpstrFile			= szFileName;
	ofn.nMaxFile			= MAXPATHLEN;
	ofn.lpstrInitialDir		= NULL;
	ofn.lpstrFileTitle		= szFileTitle;
	ofn.nMaxFileTitle		= MAXPATHLEN;
	ofn.lpstrTitle			= NULL;
	ofn.lpstrDefExt			= NULL;
	ofn.Flags			= OFN_HIDEREADONLY | OFN_NOCHANGEDIR;

	if (GetOpenFileName ((LPOPENFILENAME)&ofn)) {
		char Text[256];
		int ret;

		SetMenu(gApp.hWnd, NULL);
		OpenPlugins(gApp.hWnd);

		ret = LoadState(szFileName);
		if (ret == 0)
			 sprintf(Text, _("*PCSXR*: Loaded State %s"), szFileName);
		else sprintf(Text, _("*PCSXR*: Error Loading State %s"), szFileName);
		GPU_displayText(Text);

		Running = 1;
		psxCpu->Execute();
	}
}

void OnStates_SaveOther() {
	OPENFILENAME ofn;
	char szFileName[MAXPATHLEN];
	char szFileTitle[MAXPATHLEN];
	char szFilter[256];

	memset(&szFileName,  0, sizeof(szFileName));
	memset(&szFileTitle, 0, sizeof(szFileTitle));
	memset(&szFilter,    0, sizeof(szFilter));

	strcpy(szFilter, _("PCSXR State Format"));
	strcatz(szFilter, "*.*");

	ofn.lStructSize			= sizeof(OPENFILENAME);
	ofn.hwndOwner			= gApp.hWnd;
	ofn.lpstrFilter			= szFilter;
	ofn.lpstrCustomFilter	= NULL;
	ofn.nMaxCustFilter		= 0;
	ofn.nFilterIndex		= 1;
	ofn.lpstrFile			= szFileName;
	ofn.nMaxFile			= MAXPATHLEN;
	ofn.lpstrInitialDir		= NULL;
	ofn.lpstrFileTitle		= szFileTitle;
	ofn.nMaxFileTitle		= MAXPATHLEN;
	ofn.lpstrTitle			= NULL;
	ofn.lpstrDefExt			= NULL;
	ofn.Flags				= OFN_HIDEREADONLY | OFN_NOCHANGEDIR;

	if (GetOpenFileName ((LPOPENFILENAME)&ofn)) {
		char Text[256];
		int ret;

		SetMenu(gApp.hWnd, NULL);
		OpenPlugins(gApp.hWnd);

		ret = SaveState(szFileName);
		if (ret == 0)
			 sprintf(Text, _("*PCSXR*: Saved State %s"), szFileName);
		else sprintf(Text, _("*PCSXR*: Error Saving State %s"), szFileName);
		GPU_displayText(Text);

		Running = 1;
		psxCpu->Execute();
	}
}

LRESULT WINAPI MainWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
	char File[256];
	PAINTSTRUCT ps;
	RECT rect;

	switch (msg) {
		case WM_CREATE:
			hBm = LoadBitmap(gApp.hInstance, MAKEINTRESOURCE(MAIN_LOGO));
			GetObject(hBm, sizeof(BITMAP), (LPVOID)&bm);
			hDC = GetDC(hWnd);
			hdcmem = CreateCompatibleDC(hDC);
			ReleaseDC(hWnd, hDC);
			break;

		case WM_PAINT:
			hDC = BeginPaint(hWnd, &ps);
			SelectObject(hdcmem, hBm);
			if (!Running) BitBlt(hDC, 0, 0, bm.bmWidth, bm.bmHeight, hdcmem, 0, 0, SRCCOPY);
			EndPaint(hWnd, &ps);
			break;

		case WM_COMMAND:
			switch (LOWORD(wParam)) {
				case ID_FILE_EXIT:
					SysClose();
					SaveConfig();
					PostQuitMessage(0);
					exit(0);
					return TRUE;

				case ID_FILE_RUN_CD:
					SetIsoFile(NULL);
					SetMenu(hWnd, NULL);
					LoadPlugins();
					if (OpenPlugins(hWnd) == -1) {
						ClosePlugins();
						RestoreWindow();
						return TRUE;
					}
					if (CheckCdrom() == -1) {
						ClosePlugins();
						RestoreWindow();
						SysMessage(_("The CD does not appear to be a valid Playstation CD"));
						return TRUE;
					}

					// Auto-detect: region first, then rcnt reset
					SysReset();

					if (LoadCdrom() == -1) {
						ClosePlugins();
						RestoreWindow();
						SysMessage(_("Could not load CD-ROM!"));
						return TRUE;
					}
					if(Config.HideCursor)
						ShowCursor(FALSE);
					Running = 1;
					psxCpu->Execute();
					return TRUE;

				case ID_FILE_RUNBIOS:
					if (strcmp(Config.Bios, "HLE") == 0) {
						SysMessage(_("Running BIOS is not supported with Internal HLE Bios."));
						return TRUE;
					}
					SetIsoFile(NULL);
					SetMenu(hWnd, NULL);
					LoadPlugins();
					if (OpenPlugins(hWnd) == -1) {
						ClosePlugins();
						RestoreWindow();
						return TRUE;
					}
					if(Config.HideCursor)
						ShowCursor(FALSE);
					SysReset();
					CdromId[0] = '\0';
					CdromLabel[0] = '\0';
					Running = 1;
					psxCpu->Execute();
					return TRUE;

				case ID_FILE_RUN_ISO:
					if (!Open_Iso_Proc(File)) return TRUE;
					SetIsoFile(File);
					SetMenu(hWnd, NULL);
					LoadPlugins();
					if (OpenPlugins(hWnd) == -1) {
						ClosePlugins();
						RestoreWindow();
						return TRUE;
					}
					if (CheckCdrom() == -1) {
						ClosePlugins();
						RestoreWindow();
						SysMessage(_("The CD does not appear to be a valid Playstation CD"));
						return TRUE;
					}

					// Auto-detect: region first, then rcnt reset
					SysReset();

					if (LoadCdrom() == -1) {
						ClosePlugins();
						RestoreWindow();
						SysMessage(_("Could not load CD-ROM!"));
						return TRUE;
					}
					if(Config.HideCursor)
						ShowCursor(FALSE);
					Running = 1;
					psxCpu->Execute();
					return TRUE;

				case ID_FILE_RUN_EXE:
					if (!Open_File_Proc(File)) return TRUE;
					SetIsoFile(NULL);
					SetMenu(hWnd, NULL);
					LoadPlugins();
					if (OpenPlugins(hWnd) == -1) {
						ClosePlugins();
						RestoreWindow();
						return TRUE;
					}
					CheckCdrom();

					// Auto-detect: region first, then rcnt reset
					SysReset();

					Load(File);
					Running = 1;
					psxCpu->Execute();
					return TRUE;

				case ID_FILE_STATES_LOAD_SLOT1: States_Load(0); return TRUE;
				case ID_FILE_STATES_LOAD_SLOT2: States_Load(1); return TRUE;
				case ID_FILE_STATES_LOAD_SLOT3: States_Load(2); return TRUE;
				case ID_FILE_STATES_LOAD_SLOT4: States_Load(3); return TRUE;
				case ID_FILE_STATES_LOAD_SLOT5: States_Load(4); return TRUE;
				case ID_FILE_STATES_LOAD_SLOT6: States_Load(5); return TRUE;
				case ID_FILE_STATES_LOAD_SLOT7: States_Load(6); return TRUE;
				case ID_FILE_STATES_LOAD_SLOT8: States_Load(7); return TRUE;
				case ID_FILE_STATES_LOAD_SLOT9: States_Load(8); return TRUE;
				case ID_FILE_STATES_LOAD_OTHER: OnStates_LoadOther(); return TRUE;

				case ID_FILE_STATES_SAVE_SLOT1: States_Save(0); return TRUE;
				case ID_FILE_STATES_SAVE_SLOT2: States_Save(1); return TRUE;
				case ID_FILE_STATES_SAVE_SLOT3: States_Save(2); return TRUE;
				case ID_FILE_STATES_SAVE_SLOT4: States_Save(3); return TRUE;
				case ID_FILE_STATES_SAVE_SLOT5: States_Save(4); return TRUE;
				case ID_FILE_STATES_SAVE_SLOT6: States_Save(5); return TRUE;
				case ID_FILE_STATES_SAVE_SLOT7: States_Save(6); return TRUE;
				case ID_FILE_STATES_SAVE_SLOT8: States_Save(7); return TRUE;
				case ID_FILE_STATES_SAVE_SLOT9: States_Save(8); return TRUE;
				case ID_FILE_STATES_SAVE_OTHER: OnStates_SaveOther(); return TRUE;

				case ID_FILE_RUN_NOGUI:
					SetMenu(hWnd, NULL);
					LoadPlugins();
					if (OpenPlugins(hWnd) == -1) {
						ClosePlugins();
						RestoreWindow();
						return TRUE;
					}
					if (CheckCdrom() == -1) {
						fprintf(stderr, _("The CD does not appear to be a valid Playstation CD"));
						ClosePlugins();
						RestoreWindow();
						return TRUE;
					}

					// Auto-detect: region first, then rcnt reset
					SysReset();

					if (LoadCdrom() == -1) {
						fprintf(stderr, _("Could not load CD-ROM!"));
						ClosePlugins();
						RestoreWindow();
						return TRUE;
					}
					if(Config.HideCursor)
						ShowCursor(FALSE);
					Running = 1;
					psxCpu->Execute();
					return TRUE;

				case ID_EMULATOR_RUN:
					SetMenu(hWnd, NULL);
					OpenPlugins(hWnd);
					if(Config.HideCursor)
						ShowCursor(FALSE);
					Running = 1;
					CheatSearchBackupMemory();
					psxCpu->Execute();
					return TRUE;

				case ID_EMULATOR_RESET:
					SetMenu(hWnd, NULL);
					OpenPlugins(hWnd);
					CheckCdrom();

					// Auto-detect: region first, then rcnt reset
					SysReset();

					LoadCdrom();
					if(Config.HideCursor)
						ShowCursor(FALSE);
					Running = 1;
					psxCpu->Execute();
					return TRUE;

				case ID_EMULATOR_SHUTDOWN:
					ReleasePlugins();
					SetIsoFile(NULL);
					CdromId[0] = '\0';
					CdromLabel[0] = '\0';
					UpdateMenuItems();
					ShowCursor(TRUE); // we want GUI to have cursor always
					return TRUE;

				case ID_EMULATOR_SWITCH_ISO:
					if (!Open_Iso_Proc(File)) return TRUE;
					SetIsoFile(File);
					SetMenu(hWnd, NULL);
					if (OpenPlugins(hWnd) == -1) {
						ClosePlugins();
						RestoreWindow();
						return TRUE;
					}
					if(Config.HideCursor)
						ShowCursor(FALSE);
					Running = 1;
					SetCdOpenCaseTime(time(NULL) + 2);
					CheatSearchBackupMemory();
					psxCpu->Execute();
					return TRUE;

				case ID_CONFIGURATION_GRAPHICS:
					if (GPU_configure) GPU_configure();
					return TRUE;

				case ID_CONFIGURATION_SOUND:
					if (SPU_configure) SPU_configure();
					return TRUE;

				case ID_CONFIGURATION_CONTROLLERS:
					if (PAD1_configure) PAD1_configure();
					if (strcmp(Config.Pad1, Config.Pad2)) if (PAD2_configure) PAD2_configure();
					return TRUE;

				case ID_CONFIGURATION_CDROM:
				    if (CDR_configure) CDR_configure();
					return TRUE;

				case ID_CONFIGURATION_LINKCABLE:
#ifdef ENABLE_SIO1API
					if (SIO1_configure) SIO1_configure();
#endif
					return TRUE;

				case ID_CONFIGURATION_NETPLAY:
					DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_NETPLAY), hWnd, (DLGPROC)ConfigureNetPlayDlgProc);
					return TRUE;

				case ID_CONFIGURATION_MEMORYCARDMANAGER:
					DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_MCDCONF), hWnd, (DLGPROC)ConfigureMcdsDlgProc);
					return TRUE;

				case ID_CONFIGURATION_CPU:
					DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_CPUCONF), hWnd, (DLGPROC)ConfigureCpuDlgProc);
					return TRUE;

				case ID_CONFIGURATION_PGXP:
					DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_PGXPCONF), hWnd, (DLGPROC)ConfigurePGXPDlgProc);
					return TRUE;

				case ID_CONFIGURATION:
					ConfigurePlugins(hWnd);
					return TRUE;

				case ID_CONFIGURATION_CHEATLIST:
					DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_CHEATLIST), hWnd, (DLGPROC)CheatDlgProc);
					break;

				case ID_CONFIGURATION_CHEATSEARCH:
					DialogBox(gApp.hInstance, MAKEINTRESOURCE(IDD_CHEATSEARCH), hWnd, (DLGPROC)CheatSearchDlgProc);
					break;

				case ID_HELP_ABOUT:
					DialogBox(gApp.hInstance, MAKEINTRESOURCE(ABOUT_DIALOG), hWnd, (DLGPROC)AboutDlgProc);
					return TRUE;

				default:
#ifdef ENABLE_NLS
					if (LOWORD(wParam) >= ID_LANGS && LOWORD(wParam) <= (ID_LANGS + langsMax)) {
						AccBreak = 1;
						DestroyWindow(gApp.hWnd);
						ChangeLanguage(langs[LOWORD(wParam) - ID_LANGS].lang);
						CreateMainWindow(SW_NORMAL);
						return TRUE;
					}
#endif
					break;
			}
			break;

		case WM_SYSKEYDOWN:
			if (wParam != VK_F10)
				return DefWindowProc(hWnd, msg, wParam, lParam);
		case WM_KEYDOWN:
			PADhandleKey(wParam);
			return TRUE;

		case WM_DESTROY:
			if (!AccBreak) {
				if (Running) ClosePlugins();
				SysClose();
				SaveConfig();
				PostQuitMessage(0);
				exit(0);
			}
			else AccBreak = 0;

			DeleteObject(hBm);
			DeleteDC(hdcmem);
			return TRUE;

		case WM_EXITSIZEMOVE:
			if(Config.SaveWindowPos) {
				GetWindowRect(hWnd, &rect);
				Config.WindowPos[0] = rect.left;
				Config.WindowPos[1] = rect.top;
			}
			return TRUE;

		case WM_QUIT:
			SaveConfig();
			exit(0);
			break;

		default:
			return DefWindowProc(hWnd, msg, wParam, lParam);
	}

	return FALSE;
}

HWND mcdDlg;
McdBlock Blocks[2][15];
int IconC[2][15];
HIMAGELIST Iiml[2];
HICON eICON;

void CreateListView(int idc) {
	HWND List;
	LV_COLUMN col;

	List = GetDlgItem(mcdDlg, idc);

	col.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	col.fmt  = LVCFMT_LEFT;

	col.pszText  = _("Title");
	col.cx       = 170;
	col.iSubItem = 0;

	ListView_InsertColumn(List, 0, &col);

	col.pszText  = _("Status");
	col.cx       = 50;
	col.iSubItem = 1;

	ListView_InsertColumn(List, 1, &col);

	col.pszText  = _("Game ID");
	col.cx       = 90;
	col.iSubItem = 2;

	ListView_InsertColumn(List, 2, &col);

	col.pszText  = _("Game");
	col.cx       = 80;
	col.iSubItem = 3;

	ListView_InsertColumn(List, 3, &col);
}

int GetRGB() {
    HDC scrDC, memDC;
    HBITMAP oldBmp = NULL;
    HBITMAP curBmp = NULL;
    COLORREF oldColor;
    COLORREF curColor = RGB(255,255,255);
    int i, R, G, B;

    R = G = B = 1;

    scrDC = CreateDC("DISPLAY", NULL, NULL, NULL);
    memDC = CreateCompatibleDC(NULL);
    curBmp = CreateCompatibleBitmap(scrDC, 1, 1);
    oldBmp = (HBITMAP)SelectObject(memDC, curBmp);

    for (i = 255; i >= 0; --i) {
        oldColor = curColor;
        curColor = SetPixel(memDC, 0, 0, RGB(i, i, i));

        if (GetRValue(curColor) < GetRValue(oldColor)) ++R;
        if (GetGValue(curColor) < GetGValue(oldColor)) ++G;
        if (GetBValue(curColor) < GetBValue(oldColor)) ++B;
    }

    DeleteObject(oldBmp);
    DeleteObject(curBmp);
    DeleteDC(scrDC);
    DeleteDC(memDC);

    return (R * G * B);
}

HICON GetIcon(short *icon) {
    ICONINFO iInfo;
    HDC hDC;
    char mask[16*16];
    int x, y, c, Depth;

    hDC = CreateIC("DISPLAY",NULL,NULL,NULL);
    Depth=GetDeviceCaps(hDC, BITSPIXEL);
    DeleteDC(hDC);

    if (Depth == 16) {
        if (GetRGB() == (32 * 32 * 32))
            Depth = 15;
    }

    for (y=0; y<16; y++) {
        for (x=0; x<16; x++) {
            c = icon[y*16+x];
            if (Depth == 15 || Depth == 32)
				c = ((c&0x001f) << 10) |
					((c&0x7c00) >> 10) |
					((c&0x03e0)      );
			else
                c = ((c&0x001f) << 11) |
					((c&0x7c00) >>  9) |
					((c&0x03e0) <<  1);

            icon[y*16+x] = c;
        }
    }

    iInfo.fIcon = TRUE;
    memset(mask, 0, 16*16);
    iInfo.hbmMask  = CreateBitmap(16, 16, 1, 1, mask);
    iInfo.hbmColor = CreateBitmap(16, 16, 1, 16, icon);

    return CreateIconIndirect(&iInfo);
}

HICON hICON[2][3][15];
int aIover[2];
int ani[2];

void LoadMcdItems(int mcd, int idc) {
    HWND List = GetDlgItem(mcdDlg, idc);
    LV_ITEM item;
    HIMAGELIST iml = Iiml[mcd-1];
    int i, j;
    HICON hIcon;
    McdBlock *Info;

    aIover[mcd-1]=0;
    ani[mcd-1]=0;

    ListView_DeleteAllItems(List);

    for (i=0; i<15; i++) {

        item.mask      = LVIF_TEXT | LVIF_IMAGE;
        item.iItem       = i;
        item.iImage    = i;
        item.pszText  = LPSTR_TEXTCALLBACK;
        item.iSubItem = 0;

        IconC[mcd-1][i] = 0;
        Info = &Blocks[mcd-1][i];

        if ((Info->Flags & 0xF) == 1 && Info->IconCount != 0) {
            hIcon = GetIcon(Info->Icon);

            if (Info->IconCount > 1) {
                for(j = 0; j < 3; j++)
                    hICON[mcd-1][j][i]=hIcon;
            }
        } else {
            hIcon = eICON;
        }

        ImageList_ReplaceIcon(iml, -1, hIcon);
        ListView_InsertItem(List, &item);
    }
}

void UpdateMcdItems(int mcd, int idc) {
    HWND List = GetDlgItem(mcdDlg, idc);
    LV_ITEM item;
    HIMAGELIST iml = Iiml[mcd-1];
    int i, j;
    McdBlock *Info;
    HICON hIcon;

    aIover[mcd-1]=0;
    ani[mcd-1]=0;

    for (i=0; i<15; i++) {

        item.mask     = LVIF_TEXT | LVIF_IMAGE;
        item.iItem    = i;
        item.iImage   = i;
        item.pszText  = LPSTR_TEXTCALLBACK;
        item.iSubItem = 0;

        IconC[mcd-1][i] = 0;
        Info = &Blocks[mcd-1][i];

        if ((Info->Flags & 0xF) == 1 && Info->IconCount != 0) {
            hIcon = GetIcon(Info->Icon);

            if (Info->IconCount > 1) {
                for(j = 0; j < 3; j++)
                    hICON[mcd-1][j][i]=hIcon;
            }
        } else {
            hIcon = eICON;
        }

        ImageList_ReplaceIcon(iml, i, hIcon);
        ListView_SetItem(List, &item);
    }
    ListView_Update(List, -1);
}

void McdListGetDispInfo(int mcd, int idc, LPNMHDR pnmh) {
	LV_DISPINFO *lpdi = (LV_DISPINFO *)pnmh;
	McdBlock *Info;
	char buf[256];
	static char buftitle[256];

	Info = &Blocks[mcd - 1][lpdi->item.iItem];

	switch (lpdi->item.iSubItem) {
		case 0:
			switch (Info->Flags & 0xF) {
				case 1:
					if (MultiByteToWideChar(932, 0, (LPCSTR)Info->sTitle, -1, (LPWSTR)buf, sizeof(buf)) == 0) {
						lpdi->item.pszText = Info->Title;
					} else if (WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)buf, -1, (LPSTR)buftitle, sizeof(buftitle), NULL, NULL) == 0) {
						lpdi->item.pszText = Info->Title;
					} else {
						lpdi->item.pszText = buftitle;
					}
					break;
				case 2:
					lpdi->item.pszText = _("mid link block");
					break;
				case 3:
					lpdi->item.pszText = _("terminiting link block");
					break;
			}
			break;
		case 1:
			if ((Info->Flags & 0xF0) == 0xA0) {
				if ((Info->Flags & 0xF) >= 1 &&
					(Info->Flags & 0xF) <= 3) {
					lpdi->item.pszText = _("Deleted");
				} else lpdi->item.pszText = _("Free");
			} else if ((Info->Flags & 0xF0) == 0x50)
				lpdi->item.pszText = _("Used");
			else { lpdi->item.pszText = _("Free"); }
			break;
		case 2:
			if((Info->Flags & 0xF)==1)
				lpdi->item.pszText = Info->ID;
			break;
		case 3:
			if((Info->Flags & 0xF)==1)
				lpdi->item.pszText = Info->Name;
			break;
	}
}

void McdListNotify(int mcd, int idc, LPNMHDR pnmh) {
	switch (pnmh->code) {
		case LVN_GETDISPINFO: McdListGetDispInfo(mcd, idc, pnmh); break;
	}
}

void UpdateMcdDlg() {
	int i;

	for (i=1; i<16; i++) GetMcdBlockInfo(1, i, &Blocks[0][i-1]);
	for (i=1; i<16; i++) GetMcdBlockInfo(2, i, &Blocks[1][i-1]);
	UpdateMcdItems(1, IDC_LIST1);
	UpdateMcdItems(2, IDC_LIST2);
}

void LoadMcdDlg() {
	int i;

	for (i=1; i<16; i++) GetMcdBlockInfo(1, i, &Blocks[0][i-1]);
	for (i=1; i<16; i++) GetMcdBlockInfo(2, i, &Blocks[1][i-1]);
	LoadMcdItems(1, IDC_LIST1);
	LoadMcdItems(2, IDC_LIST2);
}

void UpdateMcdIcon(int mcd, int idc) {
    HWND List = GetDlgItem(mcdDlg, idc);
    HIMAGELIST iml = Iiml[mcd-1];
    int i;
    McdBlock *Info;
    int *count;

    if(!aIover[mcd-1]) {
        ani[mcd-1]++;

        for (i=0; i<15; i++) {
            Info = &Blocks[mcd-1][i];
            count = &IconC[mcd-1][i];

            if ((Info->Flags & 0xF) != 1) continue;
            if (Info->IconCount <= 1) continue;

            if (*count < Info->IconCount) {
                (*count)++;
                aIover[mcd-1]=0;

                if(ani[mcd-1] <= (Info->IconCount-1))  // last frame and below...
                    hICON[mcd-1][ani[mcd-1]][i] = GetIcon(&Info->Icon[(*count)*16*16]);
            } else {
                aIover[mcd-1]=1;
            }
        }

    } else {

        if (ani[mcd-1] > 1) ani[mcd-1] = 0;  // 1st frame
        else ani[mcd-1]++;                       // 2nd, 3rd frame

        for(i=0;i<15;i++) {
            Info = &Blocks[mcd-1][i];

            if (((Info->Flags & 0xF) == 1) && (Info->IconCount > 1))
                ImageList_ReplaceIcon(iml, i, hICON[mcd-1][ani[mcd-1]][i]);
        }
        InvalidateRect(List,  NULL, FALSE);
    }
}

static int copy = 0, copymcd = 0;
//static int listsel = 0;

BOOL CALLBACK ConfigureMcdsDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	char str[256];
	LPBYTE lpAND, lpXOR;
	LPBYTE lpA, lpX;
	int i, j;

	switch(uMsg) {
		case WM_INITDIALOG:
			mcdDlg = hW;

			SetWindowText(hW, _("Memcard Manager"));

			Button_SetText(GetDlgItem(hW, IDOK),        _("OK"));
			Button_SetText(GetDlgItem(hW, IDCANCEL),    _("Cancel"));
			Button_SetText(GetDlgItem(hW, IDC_MCDSEL1), _("Select Mcd"));
			Button_SetText(GetDlgItem(hW, IDC_FORMAT1), _("Format Mcd"));
			Button_SetText(GetDlgItem(hW, IDC_RELOAD1), _("Reload Mcd"));
			Button_SetText(GetDlgItem(hW, IDC_MCDSEL2), _("Select Mcd"));
			Button_SetText(GetDlgItem(hW, IDC_FORMAT2), _("Format Mcd"));
			Button_SetText(GetDlgItem(hW, IDC_RELOAD2), _("Reload Mcd"));
			Button_SetText(GetDlgItem(hW, IDC_COPYTO2), _("-> Copy ->"));
			Button_SetText(GetDlgItem(hW, IDC_COPYTO1), _("<- Copy <-"));
			Button_SetText(GetDlgItem(hW, IDC_PASTE),   _("Paste"));
			Button_SetText(GetDlgItem(hW, IDC_DELETE1), _("<- Un/Delete"));
			Button_SetText(GetDlgItem(hW, IDC_DELETE2), _("Un/Delete ->"));

			Static_SetText(GetDlgItem(hW, IDC_FRAMEMCD1), _("Memory Card 1"));
			Static_SetText(GetDlgItem(hW, IDC_FRAMEMCD2), _("Memory Card 2"));

			lpA=lpAND=(LPBYTE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(16*16));
			lpX=lpXOR=(LPBYTE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(16*16));

			for(i=0;i<16;i++)
			{
				for(j=0;j<16;j++)
				{
					*lpA++=0xff;
					*lpX++=0;
				}
			}
			eICON=CreateIcon(gApp.hInstance,16,16,1,1,lpAND,lpXOR);

			HeapFree(GetProcessHeap(),0,lpAND);
			HeapFree(GetProcessHeap(),0,lpXOR);

			if (!strlen(Config.Mcd1)) strcpy(Config.Mcd1, "memcards\\Mcd001.mcr");
			if (!strlen(Config.Mcd2)) strcpy(Config.Mcd2, "memcards\\Mcd002.mcr");
			Edit_SetText(GetDlgItem(hW,IDC_MCD1), Config.Mcd1);
			Edit_SetText(GetDlgItem(hW,IDC_MCD2), Config.Mcd2);

			CreateListView(IDC_LIST1);
			CreateListView(IDC_LIST2);

            Iiml[0] = ImageList_Create(16, 16, ILC_COLOR16, 0, 0);
            Iiml[1] = ImageList_Create(16, 16, ILC_COLOR16, 0, 0);

            ListView_SetImageList(GetDlgItem(mcdDlg, IDC_LIST1), Iiml[0], LVSIL_SMALL);
            ListView_SetImageList(GetDlgItem(mcdDlg, IDC_LIST2), Iiml[1], LVSIL_SMALL);

			Button_Enable(GetDlgItem(hW, IDC_PASTE), FALSE);
			Button_SetCheck(GetDlgItem(hW, IDC_PERGAMEMCD), Config.PerGameMcd);

			LoadMcdDlg();

			SetTimer(hW, 1, 250, NULL);

			return TRUE;

		case WM_COMMAND:
			switch (LOWORD(wParam)) {
				case IDC_PERGAMEMCD:
					if (IDC_PERGAMEMCD)
						if (HIWORD(wParam) == BN_CLICKED)
						{
							Config.PerGameMcd = Button_GetCheck(GetDlgItem(hW, IDC_PERGAMEMCD));
						}
				case IDC_COPYTO1:
					copy = ListView_GetSelectionMark(GetDlgItem(mcdDlg, IDC_LIST2));
					copymcd = 1;

					Button_Enable(GetDlgItem(hW, IDC_PASTE), TRUE);
					return TRUE;
				case IDC_COPYTO2:
					copy = ListView_GetSelectionMark(GetDlgItem(mcdDlg, IDC_LIST1));
					copymcd = 2;

					Button_Enable(GetDlgItem(hW, IDC_PASTE), TRUE);
					return TRUE;
				case IDC_PASTE:
					if (MessageBox(hW, _("Are you sure you want to paste this selection?"), _("Confirmation"), MB_YESNO) == IDNO) return TRUE;

					if (copymcd == 1) {
						Edit_GetText(GetDlgItem(hW,IDC_MCD1), str, 256);
						i = ListView_GetSelectionMark(GetDlgItem(mcdDlg, IDC_LIST1));

						// save dir data + save data
						memcpy(Mcd1Data + (i+1) * 128, Mcd2Data + (copy+1) * 128, 128);
						SaveMcd(0, str, Mcd1Data, (i+1) * 128, 128);
						memcpy(Mcd1Data + (i+1) * 1024 * 8, Mcd2Data + (copy+1) * 1024 * 8, 1024 * 8);
						SaveMcd(0, str, Mcd1Data, (i+1) * 1024 * 8, 1024 * 8);
					} else { // 2
						Edit_GetText(GetDlgItem(hW,IDC_MCD2), str, 256);
						i = ListView_GetSelectionMark(GetDlgItem(mcdDlg, IDC_LIST2));

						// save dir data + save data
						memcpy(Mcd2Data + (i+1) * 128, Mcd1Data + (copy+1) * 128, 128);
						SaveMcd(0, str, Mcd2Data, (i+1) * 128, 128);
						memcpy(Mcd2Data + (i+1) * 1024 * 8, Mcd1Data + (copy+1) * 1024 * 8, 1024 * 8);
						SaveMcd(0, str, Mcd2Data, (i+1) * 1024 * 8, 1024 * 8);
					}

					UpdateMcdDlg();

					return TRUE;
				case IDC_DELETE1:
				{
					McdBlock *Info;
					int mcd = 1;
					int i, xor = 0, j;
					unsigned char *data, *ptr;

					Edit_GetText(GetDlgItem(hW,IDC_MCD1), str, 256);
					i = ListView_GetSelectionMark(GetDlgItem(mcdDlg, IDC_LIST1));
					data = Mcd1Data;

					i++;

					ptr = data + i * 128;

					Info = &Blocks[mcd-1][i-1];

					if ((Info->Flags & 0xF0) == 0xA0) {
						if ((Info->Flags & 0xF) >= 1 &&
							(Info->Flags & 0xF) <= 3) { // deleted
							*ptr = 0x50 | (Info->Flags & 0xF);
						} else return TRUE;
					} else if ((Info->Flags & 0xF0) == 0x50) { // used
						*ptr = 0xA0 | (Info->Flags & 0xF);
					} else { return TRUE; }

					for (j=0; j<127; j++) xor^=*ptr++;
					*ptr = xor;

					SaveMcd(0, str, data, i * 128, 128);
					UpdateMcdDlg();
				}

					return TRUE;
				case IDC_DELETE2:
				{
					McdBlock *Info;
					int mcd = 2;
					int i, xor = 0, j;
					unsigned char *data, *ptr;

					Edit_GetText(GetDlgItem(hW,IDC_MCD2), str, 256);
					i = ListView_GetSelectionMark(GetDlgItem(mcdDlg, IDC_LIST2));
					data = Mcd2Data;

					i++;

					ptr = data + i * 128;

					Info = &Blocks[mcd-1][i-1];

					if ((Info->Flags & 0xF0) == 0xA0) {
						if ((Info->Flags & 0xF) >= 1 &&
							(Info->Flags & 0xF) <= 3) { // deleted
							*ptr = 0x50 | (Info->Flags & 0xF);
						} else return TRUE;
					} else if ((Info->Flags & 0xF0) == 0x50) { // used
						*ptr = 0xA0 | (Info->Flags & 0xF);
					} else { return TRUE; }

					for (j=0; j<127; j++) xor^=*ptr++;
					*ptr = xor;

					SaveMcd(0, str, data, i * 128, 128);
					UpdateMcdDlg();
				}

					return TRUE;

				case IDC_MCDSEL1:
					Open_Mcd_Proc(hW, 1);
					return TRUE;
				case IDC_MCDSEL2:
					Open_Mcd_Proc(hW, 2);
					return TRUE;
				case IDC_RELOAD1:
					Edit_GetText(GetDlgItem(hW,IDC_MCD1), str, 256);
					LoadMcd(1, str);
					UpdateMcdDlg();
					return TRUE;
				case IDC_RELOAD2:
					Edit_GetText(GetDlgItem(hW,IDC_MCD2), str, 256);
					LoadMcd(2, str);
					UpdateMcdDlg();
					return TRUE;
				case IDC_FORMAT1:
					if (MessageBox(hW, _("Are you sure you want to format this Memory Card?"), _("Confirmation"), MB_YESNO) == IDNO) return TRUE;
					Edit_GetText(GetDlgItem(hW,IDC_MCD1), str, 256);
					CreateMcd(str);
					LoadMcd(1, str);
					UpdateMcdDlg();
					return TRUE;
				case IDC_FORMAT2:
					if (MessageBox(hW, _("Are you sure you want to format this Memory Card?"), _("Confirmation"), MB_YESNO) == IDNO) return TRUE;
					Edit_GetText(GetDlgItem(hW,IDC_MCD2), str, 256);
					CreateMcd(str);
					LoadMcd(2, str);
					UpdateMcdDlg();
					return TRUE;
       			case IDCANCEL:
					LoadMcds(Config.Mcd1, Config.Mcd2);

					EndDialog(hW,FALSE);

					return TRUE;
       			case IDOK:
					Edit_GetText(GetDlgItem(hW,IDC_MCD1), Config.Mcd1, 256);
					Edit_GetText(GetDlgItem(hW,IDC_MCD2), Config.Mcd2, 256);

					LoadMcds(Config.Mcd1, Config.Mcd2);
					SaveConfig();

					EndDialog(hW,TRUE);

					return TRUE;
			}
		case WM_NOTIFY:
			switch (wParam) {
				case IDC_LIST1: McdListNotify(1, IDC_LIST1, (LPNMHDR)lParam); break;
				case IDC_LIST2: McdListNotify(2, IDC_LIST2, (LPNMHDR)lParam); break;
			}
			return TRUE;
		case WM_TIMER:
			UpdateMcdIcon(1, IDC_LIST1);
			UpdateMcdIcon(2, IDC_LIST2);
			return TRUE;
		case WM_DESTROY:
			DestroyIcon(eICON);
			//KillTimer(hW, 1);
			return TRUE;
	}
	return FALSE;
}


BOOL CALLBACK ConfigurePGXPDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	long tmp;
	RECT rect;

	switch (uMsg)
	{
	case WM_INITDIALOG:
		SetWindowText(hW, _("PGXP Config"));

		Button_SetCheck(GetDlgItem(hW, IDC_PGXP_GTE), Config.PGXP_GTE);
		Button_SetCheck(GetDlgItem(hW, IDC_PGXP_CACHE), Config.PGXP_Cache);
		Button_SetCheck(GetDlgItem(hW, IDC_PGXP_PERSP), Config.PGXP_Texture);

		ComboBox_InsertString(GetDlgItem(hW, IDC_PGXP_MODE), 0, "Disabled");
		ComboBox_InsertString(GetDlgItem(hW, IDC_PGXP_MODE), 1, "Memory only");
		ComboBox_InsertString(GetDlgItem(hW, IDC_PGXP_MODE), 2, "Mem + CPU Logic");
		ComboBox_SetCurSel(GetDlgItem(hW, IDC_PGXP_MODE), Config.PGXP_Mode);

		switch (ComboBox_GetCurSel(GetDlgItem(hW, IDC_PGXP_MODE)))
		{
		case 0:
			Static_SetText(GetDlgItem(hW, IDC_PGXP_MODETEXT), _("Disabled\n\nPGXP is no longer mirroring any functions."));
			break;
		case 1:
			Static_SetText(GetDlgItem(hW, IDC_PGXP_MODETEXT), _("Memory operations only\n\nPGXP is mirroring load, store and processor transfer operations of the CPU and GTE."));
			break;
		case 2:
			Static_SetText(GetDlgItem(hW, IDC_PGXP_MODETEXT), _("Memory and CPU arithmetic operations\n\nPGXP is mirroring load, store and transfer operations of the CPU and GTE and arithmetic/logic functions of the PSX CPU.\n\n(WARNING: This mode is currently unfinished and may cause incorrect behaviour in some games)"));
			break;
		default:
			Static_SetText(GetDlgItem(hW, IDC_PGXP_MODETEXT), _("Error: Uknown mode"));
		}

	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDCANCEL:
			EndDialog(hW, FALSE);
			return TRUE;
		case IDOK:
			Config.PGXP_GTE		= Button_GetCheck(GetDlgItem(hW, IDC_PGXP_GTE));
			Config.PGXP_Cache	= Button_GetCheck(GetDlgItem(hW, IDC_PGXP_CACHE));
			Config.PGXP_Texture = Button_GetCheck(GetDlgItem(hW, IDC_PGXP_PERSP));
			Config.PGXP_Mode	= ComboBox_GetCurSel(GetDlgItem(hW, IDC_PGXP_MODE));

			EmuSetPGXPMode(Config.PGXP_Mode);


			if (Config.SaveWindowPos)
			{
				GetWindowRect(gApp.hWnd, &rect);
				Config.WindowPos[0] = rect.left;
				Config.WindowPos[1] = rect.top;
			}

			SaveConfig();

			EndDialog(hW, TRUE);

			if (Config.PsxOut) OpenConsole();
			else CloseConsole();

			return TRUE;
		case IDC_PGXP_MODE:
			switch (ComboBox_GetCurSel(GetDlgItem(hW, IDC_PGXP_MODE)))
			{
			case 0:
				Static_SetText(GetDlgItem(hW, IDC_PGXP_MODETEXT), _("Disabled\n\nPGXP is no longer mirroring any functions."));
				break;
			case 1:
				Static_SetText(GetDlgItem(hW, IDC_PGXP_MODETEXT), _("Memory operations only\n\nPGXP is mirroring load, store and processor transfer operations of the CPU and GTE."));
				break;
			case 2:
				Static_SetText(GetDlgItem(hW, IDC_PGXP_MODETEXT), _("Memory and CPU arithmetic operations\n\nPGXP is mirroring load, store and transfer operations of the CPU and GTE and arithmetic/logic functions of the PSX CPU.\n\n(WARNING: This mode is currently unfinished and may cause incorrect behaviour in some games)"));
				break;
			default:
				Static_SetText(GetDlgItem(hW, IDC_PGXP_MODETEXT), _("Error: Uknown mode"));
			}

			return TRUE;
		}
	}

	return FALSE;
}

BOOL CALLBACK ConfigureCpuDlgProc(HWND hW, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	long tmp;
	RECT rect;
	char cs[256];

	switch(uMsg) {
		case WM_INITDIALOG:
			SetWindowText(hW, _("Cpu Config"));

			Button_SetText(GetDlgItem(hW,IDOK),        _("OK"));
			Button_SetText(GetDlgItem(hW,IDCANCEL),    _("Cancel"));

			Button_SetText(GetDlgItem(hW,IDC_XA),      _("Disable Xa Decoding"));
			Button_SetText(GetDlgItem(hW,IDC_SIO),     _("Sio Irq Always Enabled"));
			Button_SetText(GetDlgItem(hW,IDC_MDEC),    _("Black && White Movies"));
			Button_SetText(GetDlgItem(hW,IDC_CDDA),    _("Disable Cd audio"));
			Button_SetText(GetDlgItem(hW,IDC_SLOWBOOT),_("Slow Boot"));
			Button_SetText(GetDlgItem(hW,IDC_PSXAUTO), _("Autodetect"));
			Button_SetText(GetDlgItem(hW,IDC_CPU),     _("Enable Interpreter Cpu"));
			Button_SetText(GetDlgItem(hW,IDC_PSXOUT),  _("Enable Console Output"));
			Button_SetText(GetDlgItem(hW,IDC_DEBUG),   _("Enable Debugger"));
			Button_SetText(GetDlgItem(hW,IDC_SPUIRQ),  _("Spu Irq Always Enabled"));
			Button_SetText(GetDlgItem(hW,IDC_RCNTFIX), _("Parasite Eve 2, Vandal Hearts 1/2 Fix"));
			Button_SetText(GetDlgItem(hW,IDC_VSYNCWA), _("InuYasha Sengoku Battle Fix"));
			Button_SetText(GetDlgItem(hW,IDC_WIDESCREEN), _("Widescreen (GTE Hack)"));
			Button_SetText(GetDlgItem(hW,IDC_HIDECURSOR), _("Hide cursor"));
			Button_SetText(GetDlgItem(hW,IDC_SAVEWINDOWPOS), _("Save window position"));
			Button_SetText(GetDlgItem(hW,IDC_HACKFIX), _("Compatibility hacks (Raystorm/VH-D/MML/Cart World/...)"));
			Button_SetText(GetDlgItem(hW,IDC_MEMHACK), _("Wipeout MemHack"));
			Button_SetText(GetDlgItem(hW,IDC_OVRCLOCK), _("CPU Overclocking"));

			Static_SetText(GetDlgItem(hW,IDC_MISCOPT), _("Options"));
			Static_SetText(GetDlgItem(hW,IDC_SELPSX),  _("Psx System Type"));
			Static_SetText(GetDlgItem(hW,IDC_SELPSXCLOCK), _("CPU Overclocking"));

			Button_SetCheck(GetDlgItem(hW,IDC_XA),      Config.Xa);
			Button_SetCheck(GetDlgItem(hW,IDC_SIO),     Config.SioIrq);
			Button_SetCheck(GetDlgItem(hW,IDC_MDEC),    Config.Mdec);
			Button_SetCheck(GetDlgItem(hW,IDC_CDDA),    Config.Cdda);
			Button_SetCheck(GetDlgItem(hW,IDC_SLOWBOOT),Config.SlowBoot);
			Button_SetCheck(GetDlgItem(hW,IDC_PSXAUTO), Config.PsxAuto);
			Button_SetCheck(GetDlgItem(hW,IDC_CPU),     (Config.Cpu == CPU_INTERPRETER));
			Button_SetCheck(GetDlgItem(hW,IDC_PSXOUT),  Config.PsxOut);
			Button_SetCheck(GetDlgItem(hW,IDC_DEBUG),   Config.Debug);
			Button_SetCheck(GetDlgItem(hW,IDC_SPUIRQ),  Config.SpuIrq);
			Button_SetCheck(GetDlgItem(hW,IDC_RCNTFIX), Config.RCntFix);
			Button_SetCheck(GetDlgItem(hW,IDC_VSYNCWA), Config.VSyncWA);
			Button_SetCheck(GetDlgItem(hW,IDC_WIDESCREEN), Config.Widescreen);
			Button_SetCheck(GetDlgItem(hW,IDC_HIDECURSOR), Config.HideCursor);
			Button_SetCheck(GetDlgItem(hW,IDC_SAVEWINDOWPOS), Config.SaveWindowPos);
			Button_SetCheck(GetDlgItem(hW,IDC_HACKFIX), Config.HackFix);
			Button_SetCheck(GetDlgItem(hW,IDC_MEMHACK), Config.MemHack);
			Button_SetCheck(GetDlgItem(hW,IDC_OVRCLOCK), Config.OverClock);

			ComboBox_AddString(GetDlgItem(hW,IDC_PSXTYPES), "NTSC");
			ComboBox_AddString(GetDlgItem(hW,IDC_PSXTYPES), "PAL");
			ComboBox_SetCurSel(GetDlgItem(hW,IDC_PSXTYPES),Config.PsxType);

			ComboBox_AddString(GetDlgItem(hW,IDC_PSXCLOCK), "0.5");
			ComboBox_AddString(GetDlgItem(hW,IDC_PSXCLOCK), "0.75");
			ComboBox_AddString(GetDlgItem(hW,IDC_PSXCLOCK), "1.5");
			ComboBox_AddString(GetDlgItem(hW,IDC_PSXCLOCK), "2.0");
			ComboBox_AddString(GetDlgItem(hW,IDC_PSXCLOCK), "3.0");
			ComboBox_AddString(GetDlgItem(hW,IDC_PSXCLOCK), "4.0");
			ComboBox_AddString(GetDlgItem(hW,IDC_PSXCLOCK), "5.0");
			//ComboBox_SetCurSel(GetDlgItem(hW,IDC_PSXCLOCK), Config.PsxClock);
			sprintf(cs, "%.2f", Config.PsxClock);
			SetDlgItemText(hW, IDC_PSXCLOCK, cs);

			if (Config.Cpu == CPU_DYNAREC) {
				Config.Debug = 0;
				Button_SetCheck(GetDlgItem(hW, IDC_DEBUG), FALSE);
				EnableWindow(GetDlgItem(hW, IDC_DEBUG), FALSE);
			}

			EnableWindow(GetDlgItem(hW,IDC_PSXTYPES), !Config.PsxAuto);

			if (Config.OverClock)
				EnableWindow(GetDlgItem(hW, IDC_PSXCLOCK), TRUE);
			else
				EnableWindow(GetDlgItem(hW, IDC_PSXCLOCK), FALSE);
			break;

		case WM_COMMAND: {
			switch (LOWORD(wParam)) {
				case IDCANCEL: EndDialog(hW, FALSE); return TRUE;
				case IDOK:
					tmp = ComboBox_GetCurSel(GetDlgItem(hW,IDC_PSXTYPES));
					if (tmp == 0) Config.PsxType = 0;
					else Config.PsxType = 1;

					//Config.PsxClock= ComboBox_GetCurSel(GetDlgItem(hW, IDC_PSXCLOCK));

					GetDlgItemText(hW, IDC_PSXCLOCK, cs, 255);
					Config.PsxClock = (float)atof(cs);
					//if (Config.PsxClock<0.0f)   Config.PsxClock = 0.0f;
					//if (Config.PsxClock>100.0f) Config.PsxClock = 100.0f;


					Config.Xa      = Button_GetCheck(GetDlgItem(hW,IDC_XA));
					Config.SioIrq  = Button_GetCheck(GetDlgItem(hW,IDC_SIO));
					Config.Mdec    = Button_GetCheck(GetDlgItem(hW,IDC_MDEC));
					Config.Cdda    = Button_GetCheck(GetDlgItem(hW,IDC_CDDA));
					Config.SlowBoot= Button_GetCheck(GetDlgItem(hW,IDC_SLOWBOOT));
					Config.PsxAuto = Button_GetCheck(GetDlgItem(hW,IDC_PSXAUTO));
					tmp = Config.Cpu;
					Config.Cpu     = (Button_GetCheck(GetDlgItem(hW,IDC_CPU)) ? CPU_INTERPRETER : CPU_DYNAREC);
					if (tmp != Config.Cpu) {
						psxCpu->Shutdown();
						if (Config.Cpu == CPU_INTERPRETER) psxCpu = &psxInt;
						else psxCpu = &psxRec;
						if (psxCpu->Init() == -1) {
							SysClose();
							exit(1);
						}
						psxCpu->SetPGXPMode(Config.PGXP_Mode);
						psxCpu->Reset();
					}
					Config.PsxOut  = Button_GetCheck(GetDlgItem(hW,IDC_PSXOUT));
					Config.SpuIrq  = Button_GetCheck(GetDlgItem(hW,IDC_SPUIRQ));
					Config.RCntFix = Button_GetCheck(GetDlgItem(hW,IDC_RCNTFIX));
					Config.VSyncWA = Button_GetCheck(GetDlgItem(hW,IDC_VSYNCWA));
					Config.Widescreen = Button_GetCheck(GetDlgItem(hW,IDC_WIDESCREEN));
					Config.HideCursor = Button_GetCheck(GetDlgItem(hW,IDC_HIDECURSOR));
					Config.SaveWindowPos = Button_GetCheck(GetDlgItem(hW,IDC_SAVEWINDOWPOS));
					Config.HackFix = Button_GetCheck(GetDlgItem(hW, IDC_HACKFIX));
					Config.MemHack = Button_GetCheck(GetDlgItem(hW, IDC_MEMHACK));
					Config.OverClock = Button_GetCheck(GetDlgItem(hW, IDC_OVRCLOCK));


					if(Config.SaveWindowPos) {
						GetWindowRect(gApp.hWnd, &rect);
						Config.WindowPos[0] = rect.left;
						Config.WindowPos[1] = rect.top;
					}
					tmp = Config.Debug;
					Config.Debug   = Button_GetCheck(GetDlgItem(hW,IDC_DEBUG));
					if (tmp != Config.Debug) {
						if (Config.Debug) StartDebugger();
						else StopDebugger();
					}

					if (Config.GdbServer) {
						GdbStartServer();
					}

					SaveConfig();

					EndDialog(hW,TRUE);

					if (Config.PsxOut) OpenConsole();
					else CloseConsole();

					return TRUE;

				case IDC_OVRCLOCK:
					if (Button_GetCheck(GetDlgItem(hW, IDC_OVRCLOCK)))
						EnableWindow(GetDlgItem(hW, IDC_PSXCLOCK), TRUE);
					else
						EnableWindow(GetDlgItem(hW, IDC_PSXCLOCK), FALSE);
					break;

				case IDC_CPU:
					if (Button_GetCheck(GetDlgItem(hW,IDC_CPU))) {
						EnableWindow(GetDlgItem(hW,IDC_DEBUG), TRUE);
					} else {
						Button_SetCheck(GetDlgItem(hW,IDC_DEBUG), FALSE);
						EnableWindow(GetDlgItem(hW,IDC_DEBUG), FALSE);
					}
					break;

				case IDC_PSXAUTO:
					if (Button_GetCheck(GetDlgItem(hW,IDC_PSXAUTO))) {
						EnableWindow(GetDlgItem(hW,IDC_PSXTYPES), FALSE);
					} else {
						EnableWindow(GetDlgItem(hW,IDC_PSXTYPES), TRUE);
					}
					break;
			}
		}
	}
	return FALSE;
}

void Open_Mcd_Proc(HWND hW, int mcd) {
	OPENFILENAME ofn;
	char szFileName[MAXPATHLEN];
	char szFileTitle[MAXPATHLEN];
	char szFilter[1024];
	char *str;

	memset(&szFileName,  0, sizeof(szFileName));
	memset(&szFileTitle, 0, sizeof(szFileTitle));
	memset(&szFilter,    0, sizeof(szFilter));

	strcpy(szFilter, _("Psx Mcd Format (*.mcr;*.mc;*.mem;*.vgs;*.mcd;*.gme;*.ddf)"));
	str = szFilter + strlen(szFilter) + 1;
	strcpy(str, "*.mcr;*.mcd;*.mem;*.gme;*.mc;*.ddf");

	str+= strlen(str) + 1;
	strcpy(str, _("Psx Memory Card (*.mcr;*.mc)"));
	str+= strlen(str) + 1;
	strcpy(str, "*.mcr;0*.mc");

	str+= strlen(str) + 1;
	strcpy(str, _("CVGS Memory Card (*.mem;*.vgs)"));
	str+= strlen(str) + 1;
	strcpy(str, "*.mem;*.vgs");

	str+= strlen(str) + 1;
	strcpy(str, _("Bleem Memory Card (*.mcd)"));
	str+= strlen(str) + 1;
	strcpy(str, "*.mcd");

	str+= strlen(str) + 1;
	strcpy(str, _("DexDrive Memory Card (*.gme)"));
	str+= strlen(str) + 1;
	strcpy(str, "*.gme");

	str+= strlen(str) + 1;
	strcpy(str, _("DataDeck Memory Card (*.ddf)"));
	str+= strlen(str) + 1;
	strcpy(str, "*.ddf");

	str+= strlen(str) + 1;
	strcpy(str, _("All Files"));
	str+= strlen(str) + 1;
	strcpy(str, "*.*");

    ofn.lStructSize			= sizeof(OPENFILENAME);
    ofn.hwndOwner			= hW;
    ofn.lpstrFilter			= szFilter;
	ofn.lpstrCustomFilter	= NULL;
    ofn.nMaxCustFilter		= 0;
    ofn.nFilterIndex		= 1;
    ofn.lpstrFile			= szFileName;
    ofn.nMaxFile			= MAXPATHLEN;
    ofn.lpstrInitialDir		= "memcards";
    ofn.lpstrFileTitle		= szFileTitle;
    ofn.nMaxFileTitle		= MAXPATHLEN;
    ofn.lpstrTitle			= NULL;
    ofn.lpstrDefExt			= "MCR";
    ofn.Flags				= OFN_HIDEREADONLY | OFN_NOCHANGEDIR;

	if (GetOpenFileName ((LPOPENFILENAME)&ofn)) {
		Edit_SetText(GetDlgItem(hW,mcd == 1 ? IDC_MCD1 : IDC_MCD2), szFileName);
		LoadMcd(mcd, szFileName);
		UpdateMcdDlg();
	}
}

int Open_File_Proc(char *file) {
	OPENFILENAME ofn;
	char szFileName[MAXPATHLEN];
	char szFileTitle[MAXPATHLEN];
	char szFilter[256];

	memset(&szFileName,  0, sizeof(szFileName));
	memset(&szFileTitle, 0, sizeof(szFileTitle));
	memset(&szFilter,    0, sizeof(szFilter));

    ofn.lStructSize			= sizeof(OPENFILENAME);
    ofn.hwndOwner			= gApp.hWnd;

	strcpy(szFilter, _("Psx Exe Format"));
	strcatz(szFilter, "*.*");

    ofn.lpstrFilter			= szFilter;
	ofn.lpstrCustomFilter	= NULL;
    ofn.nMaxCustFilter		= 0;
    ofn.nFilterIndex		= 1;
    ofn.lpstrFile			= szFileName;
    ofn.nMaxFile			= MAXPATHLEN;
    ofn.lpstrInitialDir		= NULL;
    ofn.lpstrFileTitle		= szFileTitle;
    ofn.nMaxFileTitle		= MAXPATHLEN;
    ofn.lpstrTitle			= NULL;
    ofn.lpstrDefExt			= "EXE";
    ofn.Flags				= OFN_HIDEREADONLY | OFN_NOCHANGEDIR;

	if (GetOpenFileName ((LPOPENFILENAME)&ofn)) {
		strcpy(file, szFileName);
		return 1;
	} else
		return 0;
}

int Open_Iso_Proc(char *file) {
	OPENFILENAME ofn;
	char szFileName[MAXPATHLEN];
	char szFileTitle[MAXPATHLEN];
	char szFilter[256];
	char *str;

	memset(&szFileName,  0, sizeof(szFileName));
	memset(&szFileTitle, 0, sizeof(szFileTitle));
	memset(&szFilter,    0, sizeof(szFilter));

    ofn.lStructSize			= sizeof(OPENFILENAME);
    ofn.hwndOwner			= gApp.hWnd;

	strcpy(szFilter, _("Psx Isos (*.iso;*.mdf;*.img;*.bin;*.cue;*.pbp;*.cbn)"));
	str = szFilter + strlen(szFilter) + 1;
	strcpy(str, "*.iso;*.mdf;*.img;*.bin;*.cue;*.pbp;*.cbn");

	str += strlen(str) + 1;
	strcpy(str, _("All Files"));
	str += strlen(str) + 1;
	strcpy(str, "*.*");

    ofn.lpstrFilter			= szFilter;
	ofn.lpstrCustomFilter	= NULL;
    ofn.nMaxCustFilter		= 0;
    ofn.nFilterIndex		= 1;
    ofn.lpstrFile			= szFileName;
    ofn.nMaxFile			= MAXPATHLEN;
    ofn.lpstrInitialDir		= NULL;
    ofn.lpstrFileTitle		= szFileTitle;
    ofn.nMaxFileTitle		= MAXPATHLEN;
    ofn.lpstrTitle			= NULL;
    ofn.lpstrDefExt			= "ISO";
    ofn.Flags				= OFN_HIDEREADONLY | OFN_NOCHANGEDIR;

	if (GetOpenFileName ((LPOPENFILENAME)&ofn)) {
		strcpy(file, szFileName);
		return 1;
	} else
		return 0;
}

#define _ADDSUBMENU(menu, menun, string) \
	submenu[menun] = CreatePopupMenu(); \
	AppendMenu(menu, MF_STRING | MF_POPUP, (UINT)submenu[menun], string);

#define ADDSUBMENU(menun, string) \
	_ADDSUBMENU(gApp.hMenu, menun, string);

#define ADDSUBMENUS(submn, menun, string) \
	submenu[menun] = CreatePopupMenu(); \
	InsertMenu(submenu[submn], 0, MF_BYPOSITION | MF_STRING | MF_POPUP, (UINT)submenu[menun], string);

#define ADDMENUITEM(menun, string, id) \
	item.fType = MFT_STRING; \
	item.fMask = MIIM_STATE | MIIM_TYPE | MIIM_ID; \
	item.fState = MFS_ENABLED; \
	item.wID = id; \
	sprintf(buf, string); \
	InsertMenuItem(submenu[menun], 0, TRUE, &item);

#define ADDMENUITEMC(menun, string, id) \
	item.fType = MFT_STRING; \
	item.fMask = MIIM_STATE | MIIM_TYPE | MIIM_ID; \
	item.fState = MFS_ENABLED | MFS_CHECKED; \
	item.wID = id; \
	sprintf(buf, string); \
	InsertMenuItem(submenu[menun], 0, TRUE, &item);

#define ADDSEPARATOR(menun) \
	item.fMask = MIIM_TYPE; \
	item.fType = MFT_SEPARATOR; \
	InsertMenuItem(submenu[menun], 0, TRUE, &item);

void CreateMainMenu() {
	MENUITEMINFO item;
	HMENU submenu[256];
	char buf[256];
#ifdef ENABLE_NLS
	char *lang;
	int i;
#endif

	item.cbSize = sizeof(MENUITEMINFO);
	item.dwTypeData = buf;
	item.cch = 256;

	gApp.hMenu = CreateMenu();

	ADDSUBMENU(0, _("&File"));
	ADDMENUITEM(0, _("E&xit"), ID_FILE_EXIT);
	ADDSEPARATOR(0);
	ADDMENUITEM(0, _("Run &EXE..."), ID_FILE_RUN_EXE);
	ADDMENUITEM(0, _("Run &BIOS"), ID_FILE_RUNBIOS);
	ADDMENUITEM(0, _("Run &ISO..."), ID_FILE_RUN_ISO);
	ADDMENUITEM(0, _("Run &CD"), ID_FILE_RUN_CD);

	ADDSUBMENU(0, _("&Emulator"));
	ADDSUBMENUS(0, 1, _("&States"));
	ADDSEPARATOR(0);
	ADDMENUITEM(0, _("S&witch ISO..."), ID_EMULATOR_SWITCH_ISO);
	ADDSEPARATOR(0);
	ADDMENUITEM(0, _("S&hutdown"), ID_EMULATOR_SHUTDOWN);
	ADDMENUITEM(0, _("Re&set"), ID_EMULATOR_RESET);
	ADDMENUITEM(0, _("&Run"), ID_EMULATOR_RUN);
	ADDSUBMENUS(1, 3, _("&Save"));
	ADDSUBMENUS(1, 2, _("&Load"));
	ADDMENUITEM(2, _("&Other..."), ID_FILE_STATES_LOAD_OTHER);
	ADDMENUITEM(2, _("Slot &9"), ID_FILE_STATES_LOAD_SLOT9);
	ADDMENUITEM(2, _("Slot &8"), ID_FILE_STATES_LOAD_SLOT8);
	ADDMENUITEM(2, _("Slot &7"), ID_FILE_STATES_LOAD_SLOT7);
	ADDMENUITEM(2, _("Slot &6"), ID_FILE_STATES_LOAD_SLOT6);
	ADDMENUITEM(2, _("Slot &5"), ID_FILE_STATES_LOAD_SLOT5);
	ADDMENUITEM(2, _("Slot &4"), ID_FILE_STATES_LOAD_SLOT4);
	ADDMENUITEM(2, _("Slot &3"), ID_FILE_STATES_LOAD_SLOT3);
	ADDMENUITEM(2, _("Slot &2"), ID_FILE_STATES_LOAD_SLOT2);
	ADDMENUITEM(2, _("Slot &1"), ID_FILE_STATES_LOAD_SLOT1);
	ADDMENUITEM(3, _("&Other..."), ID_FILE_STATES_SAVE_OTHER);
	ADDMENUITEM(3, _("Slot &9"), ID_FILE_STATES_SAVE_SLOT9);
	ADDMENUITEM(3, _("Slot &8"), ID_FILE_STATES_SAVE_SLOT8);
	ADDMENUITEM(3, _("Slot &7"), ID_FILE_STATES_SAVE_SLOT7);
	ADDMENUITEM(3, _("Slot &6"), ID_FILE_STATES_SAVE_SLOT6);
	ADDMENUITEM(3, _("Slot &5"), ID_FILE_STATES_SAVE_SLOT5);
	ADDMENUITEM(3, _("Slot &4"), ID_FILE_STATES_SAVE_SLOT4);
	ADDMENUITEM(3, _("Slot &3"), ID_FILE_STATES_SAVE_SLOT3);
	ADDMENUITEM(3, _("Slot &2"), ID_FILE_STATES_SAVE_SLOT2);
	ADDMENUITEM(3, _("Slot &1"), ID_FILE_STATES_SAVE_SLOT1);

	ADDSUBMENU(0, _("&Configuration"));
	ADDMENUITEM(0, _("Cheat &Search..."), ID_CONFIGURATION_CHEATSEARCH);
	ADDMENUITEM(0, _("Ch&eat Code..."), ID_CONFIGURATION_CHEATLIST);
	ADDSEPARATOR(0);
#ifdef ENABLE_NLS
	ADDSUBMENUS(0, 1, _("&Language"));

	if (langs) free(langs);
	langs = (_langs*)malloc(sizeof(_langs));
	strcpy(langs[0].lang, "English");
	InitLanguages(); i=1;
	while ((lang = GetLanguageNext()) != NULL) {
		langs = (_langs*)realloc(langs, sizeof(_langs)*(i+1));
		strcpy(langs[i].lang, lang);
		if (!strcmp(Config.Lang, lang)) {
			ADDMENUITEMC(1, ParseLang(langs[i].lang), ID_LANGS + i);
		} else {
			ADDMENUITEM(1, ParseLang(langs[i].lang), ID_LANGS + i);
		}
		i++;
	}
	CloseLanguages();
	langsMax = i;
	if (!strcmp(Config.Lang, "English")) {
		ADDMENUITEMC(1, _("English"), ID_LANGS);
	} else {
		ADDMENUITEM(1, _("English"), ID_LANGS);
	}
	ADDSEPARATOR(0);
#endif
	ADDMENUITEM(0, _("&Memory cards..."), ID_CONFIGURATION_MEMORYCARDMANAGER);
	ADDMENUITEM(0, _("C&PU..."), ID_CONFIGURATION_CPU);
	ADDSEPARATOR(0);
	ADDMENUITEM(0, _("&PGXP..."), ID_CONFIGURATION_PGXP);
	ADDSEPARATOR(0);
	ADDMENUITEM(0, _("&NetPlay..."), ID_CONFIGURATION_NETPLAY);
	ADDSEPARATOR(0);
	ADDMENUITEM(0, _("&Link cable..."), ID_CONFIGURATION_LINKCABLE);
	ADDMENUITEM(0, _("&Controllers..."), ID_CONFIGURATION_CONTROLLERS);
	ADDMENUITEM(0, _("CD-&ROM..."), ID_CONFIGURATION_CDROM);
	ADDMENUITEM(0, _("&Sound..."), ID_CONFIGURATION_SOUND);
	ADDMENUITEM(0, _("&Graphics..."), ID_CONFIGURATION_GRAPHICS);
	ADDSEPARATOR(0);
	ADDMENUITEM(0, _("&Plugins && Bios..."), ID_CONFIGURATION);

	ADDSUBMENU(0, _("&Help"));
	ADDMENUITEM(0, _("&About..."), ID_HELP_ABOUT);

	UpdateMenuItems();
}

void CreateMainWindow(int nCmdShow) {
	WNDCLASS wc;
	HWND hWnd;

	wc.lpszClassName = "PCSXR Main";
	wc.lpfnWndProc = MainWndProc;
	wc.style = 0;
	wc.hInstance = gApp.hInstance;
	wc.hIcon = LoadIcon(gApp.hInstance, MAKEINTRESOURCE(IDI_APP_ICON));
	wc.hCursor = NULL;
	wc.hbrBackground = (HBRUSH)(COLOR_MENUTEXT);
	wc.lpszMenuName = 0;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;

	RegisterClass(&wc);

	hWnd = CreateWindow("PCSXR Main",
						"PCSXR",
						WS_CAPTION | WS_POPUPWINDOW | WS_MINIMIZEBOX,
						CW_USEDEFAULT,
						0,
						426,
						314,
						NULL,
						NULL,
						gApp.hInstance,
						NULL);

	gApp.hWnd = hWnd;

	CreateMainMenu();
	SetMenu(gApp.hWnd, gApp.hMenu);

	if(Config.SaveWindowPos)
		SetWindowPos(hWnd, 0, Config.WindowPos[0], Config.WindowPos[1], 0, 0, SWP_NOSIZE | SWP_NOZORDER);

	ShowWindow(hWnd, nCmdShow);
}

#ifdef ENABLE_NLS

WIN32_FIND_DATA lFindData;
HANDLE lFind;
int lFirst;

void InitLanguages() {
	lFind = FindFirstFile("Langs\\*", &lFindData);
	lFirst = 1;
}

char *GetLanguageNext() {
	if (lFind == INVALID_HANDLE_VALUE)
		return NULL;

	for (;;) {
		if (lFirst == 0) {
			if (FindNextFile(lFind, &lFindData) == FALSE)
				return NULL;
		}
		else
			lFirst = 0;

		if (!strcmp(lFindData.cFileName, ".") ||
			!strcmp(lFindData.cFileName, ".."))
			continue;
		break;
	}

	return lFindData.cFileName;
}

void CloseLanguages() {
	if (lFind != INVALID_HANDLE_VALUE) FindClose(lFind);
}

void ChangeLanguage(char *lang) {
	strcpy(Config.Lang, lang);
	SaveConfig();
	LoadConfig();
}

#endif

int SysInit() {
	if (Config.PsxOut) OpenConsole();

	if (EmuInit() == -1) return -1;

#ifdef EMU_LOG
	emuLog = fopen("emuLog.txt","w");
	setvbuf(emuLog, NULL, _IONBF, 0);
#endif

	while (LoadPlugins(0) == -1) {
		CancelQuit = 1;
		ConfigurePlugins(gApp.hWnd);
		CancelQuit = 0;
	}
	LoadMcds(Config.Mcd1, Config.Mcd2);

	if (Config.Debug) StartDebugger();

	if (Config.GdbServer) GdbStartServer();

	return 0;
}

void SysReset() {
	EmuReset();
}

void SysClose() {
	EmuShutdown();
	ReleasePlugins();

	StopDebugger();

	if (Config.PsxOut) CloseConsole();

	if (emuLog != NULL) fclose(emuLog);
}

void SysPrintf(const char *fmt, ...) {
	va_list list;
	char msg[512];
	DWORD tmp;

	if (!hConsole) return;

	va_start(list,fmt);
	vsprintf(msg,fmt,list);
	va_end(list);

	WriteConsole(hConsole, msg, (DWORD)strlen(msg), &tmp, 0);
#ifdef EMU_LOG
#ifndef LOG_STDOUT
	if (emuLog != NULL) fprintf(emuLog, "%s", msg);
#endif
#endif
}

void SysMessage(const char *fmt, ...) {
	va_list list;
	char tmp[512];

	va_start(list,fmt);
	vsprintf(tmp,fmt,list);
	va_end(list);
	MessageBox(0, tmp, _("Pcsxr Msg"), 0);
}

static char *err = N_("Error Loading Symbol");
static int errval;

void *SysLoadLibrary(const char *lib) {
	return LoadLibrary(lib);
}

void *SysLoadSym(void *lib, const char *sym) {
	void *tmp = GetProcAddress((HINSTANCE)lib, sym);
	if (tmp == NULL) errval = 1;
	else errval = 0;
	return tmp;
}

const char *SysLibError() {
	if (errval) { errval = 0; return err; }
	return NULL;
}

void SysCloseLibrary(void *lib) {
	FreeLibrary((HINSTANCE)lib);
}

void SysUpdate() {
	MSG msg;

	while (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE)) {
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
}

void SysRunGui() {
	RestoreWindow();
	RunGui();
}

void UpdateMenuItems() {
	if (CdromId[0] != '\0') { // Emulating...
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_NETPLAY, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_LINKCABLE, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_CONTROLLERS, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_CDROM, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_SOUND, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_GRAPHICS, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION, MF_BYCOMMAND | MF_GRAYED);
		if (!UsingIso()) {
			EnableMenuItem(gApp.hMenu, ID_EMULATOR_SWITCH_ISO, MF_BYCOMMAND | MF_GRAYED);
		}

		ResetMenuSlots();
	} else { // GUI...
		EnableMenuItem(gApp.hMenu, ID_EMULATOR_RESET, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_EMULATOR_RUN, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_EMULATOR_SHUTDOWN, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_EMULATOR_SWITCH_ISO, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_SLOT1, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_SLOT2, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_SLOT3, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_SLOT4, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_SLOT5, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_SLOT6, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_SLOT7, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_SLOT8, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_SLOT9, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_LOAD_OTHER, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_SAVE_SLOT1, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_SAVE_SLOT2, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_SAVE_SLOT3, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_SAVE_SLOT4, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_SAVE_SLOT5, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_SAVE_SLOT6, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_SAVE_SLOT7, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_SAVE_SLOT8, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_SAVE_SLOT9, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_FILE_STATES_SAVE_OTHER, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_CHEATSEARCH, MF_BYCOMMAND | MF_GRAYED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_NETPLAY, MF_BYCOMMAND | MF_ENABLED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_LINKCABLE, MF_BYCOMMAND | MF_ENABLED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_CONTROLLERS, MF_BYCOMMAND | MF_ENABLED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_CDROM, MF_BYCOMMAND | ( Config.Cdr[0] != '\0' ? MF_ENABLED : MF_GRAYED ));
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_SOUND, MF_BYCOMMAND | MF_ENABLED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_GRAPHICS, MF_BYCOMMAND | MF_ENABLED);
		EnableMenuItem(gApp.hMenu, ID_CONFIGURATION, MF_BYCOMMAND | MF_ENABLED);
	}

#ifndef ENABLE_SIO1API
	EnableMenuItem(gApp.hMenu, ID_CONFIGURATION_LINKCABLE, MF_BYCOMMAND | MF_GRAYED);
#endif
}