{

// Always zero for now.

int flags;

// This is the pointer (always passed as 64 bits.)

unsigned long long addr;

// Write the name here.

wchar_t name[256];

#ifdef THEMES

WTL::CTheme::IsThemingSupported();

#endif

//Register classes

WNDCLASSEX wcex;

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.style = CS_PARENTDC;

wcex.lpfnWndProc = (WNDPROC)WndProc;

wcex.cbClsExtra = 0;

wcex.cbWndExtra = 0;

wcex.hInstance = hInstance;

wcex.hIcon = LoadIcon(hInstance, (LPCTSTR)IDI_PPSSPP);

wcex.hCursor = LoadCursor(NULL, IDC_ARROW);

wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);

wcex.lpszMenuName = (LPCWSTR)IDR_MENU1;

wcex.lpszClassName = szWindowClass;

wcex.hIconSm = (HICON)LoadImage(hInstance, (LPCTSTR)IDI_PPSSPP, IMAGE_ICON, 16, 16, LR_SHARED);

RegisterClassEx(&wcex);

wcex.style = CS_HREDRAW | CS_VREDRAW;

wcex.lpfnWndProc = (WNDPROC)DisplayProc;

wcex.hIcon = 0;

wcex.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);

wcex.lpszMenuName = 0;

wcex.lpszClassName = szDisplayClass;

wcex.hIconSm = 0;

RegisterClassEx(&wcex);

if (g_Config.bFullScreen)

return;

WINDOWPLACEMENT placement;

GetWindowPlacement(hwndMain, &placement);

if (placement.showCmd == SW_SHOWNORMAL) {

RECT rc;

GetWindowRect(hwndMain, &rc);

g_Config.iWindowX = rc.left;

g_Config.iWindowY = rc.top;

g_Config.iWindowWidth = rc.right - rc.left;

g_Config.iWindowHeight = rc.bottom - rc.top;

}

rcInner.left = 0;

rcInner.top = 0;

rcInner.right = xres;

rcInner.bottom = yres;

rcOuter = rcInner;

AdjustWindowRect(&rcOuter, WS_OVERLAPPEDWINDOW, TRUE);

rcOuter.right += g_Config.iWindowX - rcOuter.left;

rcOuter.bottom += g_Config.iWindowY - rcOuter.top;

rcOuter.left = g_Config.iWindowX;

rcOuter.top = g_Config.iWindowY;

I18NCategory *g = GetI18NCategory("Graphics");

std::ostringstream messageStream;

messageStream << g->T("Internal Resolution") << ": ";

messageStream << PSP_CoreParameter().renderWidth << "x" << PSP_CoreParameter().renderHeight << " ";

messageStream << g->T("Window Size") << ": ";

messageStream << PSP_CoreParameter().pixelWidth << "x" << PSP_CoreParameter().pixelHeight;

osm.Show(messageStream.str(), 2.0f);

RECT rc;

GetClientRect(hwndMain, &rc);

// Round up to a zoom factor for the render size.

int zoom = g_Config.iInternalResolution;

if (zoom == 0) // auto mode

zoom = (rc.right - rc.left + 479) / 480;

if (zoom <= 1)

zoom = 1;

// Actually, auto mode should be more granular...

PSP_CoreParameter().renderWidth = 480 * zoom;

PSP_CoreParameter().renderHeight = 272 * zoom;

AssertCurrentThreadName("Main");

int width = 0, height = 0;

RECT rc;

GetClientRect(hwndMain, &rc);

if (!noWindowMovement) {

width = rc.right - rc.left;

height = rc.bottom - rc.top;

// Moves the internal window, not the frame. TODO: Get rid of the internal window.

MoveWindow(hwndDisplay, 0, 0, width, height, TRUE);

// This is taken care of anyway later, but makes sure that ShowScreenResolution gets the right numbers.

// Need to clean all of this up...

PSP_CoreParameter().pixelWidth = width;

PSP_CoreParameter().pixelHeight = height;

}

UpdateRenderResolution();

if (!noWindowMovement) {

if (UpdateScreenScale(width, height)) {

NativeMessageReceived("gpu resized", "");

}

}

AssertCurrentThreadName("Main");

RECT rc, rcOuter;

GetWindowRectAtResolution(480 * (int)zoom, 272 * (int)zoom, rc, rcOuter);

MoveWindow(hwndMain, rcOuter.left, rcOuter.top, rcOuter.right - rcOuter.left, rcOuter.bottom - rcOuter.top, TRUE);

ResizeDisplay(false);

ShowScreenResolution();

if (res >= 0 && res <= RESOLUTION_MAX)

g_Config.iInternalResolution = res;

else {

if (++g_Config.iInternalResolution > RESOLUTION_MAX)

g_Config.iInternalResolution = 0;

}

// Taking auto-texture scaling into account

if (g_Config.iTexScalingLevel == TEXSCALING_AUTO)

setTexScalingMultiplier(0);

if (gpu)

gpu->Resized();

UpdateRenderResolution();

ShowScreenResolution();

bool autoHide = g_Config.bFullScreen && !mouseButtonDown && GetUIState() == UISTATE_INGAME;

if (autoHide && hideCursor) {

while (cursorCounter >= 0) {

cursorCounter = ShowCursor(FALSE);

}

} else {

hideCursor = !autoHide;

if (cursorCounter < 0) {

cursorCounter = ShowCursor(TRUE);

SetCursor(LoadCursor(NULL, IDC_ARROW));

}

}

// Make sure no rendering is happening during the switch.

Core_NotifyWindowHidden(true);

g_inModeSwitch = true; // Make sure WM_SIZE doesn't call Core_NotifyWindowHidden(false)...

DWORD dwOldStyle;

DWORD dwNewStyle;

if (!goingFullscreen) {

// Put caption and border styles back.

dwOldStyle = ::GetWindowLong(hWnd, GWL_STYLE);

dwOldStyle &= ~WS_POPUP;

dwNewStyle = dwOldStyle | WS_CAPTION | WS_THICKFRAME | WS_SYSMENU;

// Put back the menu bar.

::SetMenu(hWnd, menu);

} else {

// If the window was maximized before going fullscreen, make sure to restore first

// in order not to have the taskbar show up on top of PPSSPP.

if (g_WindowState == SIZE_MAXIMIZED) {

ShowWindow(hwndMain, SW_RESTORE);

}

// Remember the normal window rectangle.

::GetWindowRect(hWnd, &g_normalRC);

// Remove caption and border styles.

dwOldStyle = ::GetWindowLong(hWnd, GWL_STYLE);

dwNewStyle = dwOldStyle & ~(WS_CAPTION | WS_THICKFRAME | WS_SYSMENU);

// Add WS_POPUP

dwNewStyle |= WS_POPUP;

}

::SetWindowLong(hWnd, GWL_STYLE, dwNewStyle);

// Remove the menu bar.

::SetMenu(hWnd, goingFullscreen ? NULL : menu);

// Resize to the appropriate view.

// If we're returning to window mode, re-apply the appropriate size setting.

if (goingFullscreen) {

ShowWindow(hwndMain, SW_MAXIMIZE);

} else {

ShowWindow(hwndMain, g_WindowState == SIZE_MAXIMIZED ? SW_MAXIMIZE : SW_RESTORE);

}

g_Config.bFullScreen = goingFullscreen;

CorrectCursor();

bool showOSM = (g_Config.iInternalResolution == RESOLUTION_AUTO);

ResizeDisplay(false);

if (showOSM) {

ShowScreenResolution();

}

ShowOwnedPopups(hwndMain, goingFullscreen ? FALSE : TRUE);

W32Util::MakeTopMost(hwndMain, g_Config.bTopMost);

g_inModeSwitch = false;

Core_NotifyWindowHidden(false);

WindowsRawInput::NotifyMenu();

RECT rc;

const int screenWidth = GetSystemMetrics(SM_CXVIRTUALSCREEN);

const int screenHeight = GetSystemMetrics(SM_CYVIRTUALSCREEN);

const int screenX = GetSystemMetrics(SM_XVIRTUALSCREEN);

const int screenY = GetSystemMetrics(SM_YVIRTUALSCREEN);

if (!g_Config.bFullScreen) {

bool visibleHorizontally = ((g_Config.iWindowX + g_Config.iWindowWidth) >= screenX) &&

((g_Config.iWindowX + g_Config.iWindowWidth) < (screenWidth + g_Config.iWindowWidth));

bool visibleVertically = ((g_Config.iWindowY + g_Config.iWindowHeight) >= screenY) &&

((g_Config.iWindowY + g_Config.iWindowHeight) < (screenHeight + g_Config.iWindowHeight));

if (!visibleHorizontally)

g_Config.iWindowX = -1;

if (!visibleVertically)

g_Config.iWindowY = -1;

}

rc.left = g_Config.iWindowX;

rc.top = g_Config.iWindowY;

// First, get the w/h right.

if (g_Config.iWindowWidth <= 0 || g_Config.iWindowHeight <= 0) {

RECT rcInner = rc, rcOuter;

GetWindowRectAtResolution(2 * 480, 2 * 272, rcInner, rcOuter);

rc.right = rc.left + (rcOuter.right - rcOuter.left);

rc.bottom = rc.top + (rcOuter.bottom - rcOuter.top);

g_Config.iWindowWidth = rc.right - rc.left;

g_Config.iWindowHeight = rc.bottom - rc.top;

} else {

rc.right = rc.left + g_Config.iWindowWidth;

rc.bottom = rc.top + g_Config.iWindowHeight;

}

// Then center if necessary.

if (g_Config.iWindowX == -1 && g_Config.iWindowY == -1) {

// Center the window.

const int primaryScreenWidth = GetSystemMetrics(SM_CXSCREEN);

const int primaryScreenHeight = GetSystemMetrics(SM_CYSCREEN);

g_Config.iWindowX = (primaryScreenWidth - g_Config.iWindowWidth) / 2;

g_Config.iWindowY = (primaryScreenHeight - g_Config.iWindowHeight) / 2;

rc.left = g_Config.iWindowX;

rc.top = g_Config.iWindowY;

rc.right = rc.left + g_Config.iWindowWidth;

rc.bottom = rc.top + g_Config.iWindowHeight;

}

return rc;

UINT menuEnable = state == UISTATE_INGAME ? MF_ENABLED : MF_GRAYED;

UINT umdSwitchEnable = state == UISTATE_INGAME && getUMDReplacePermit()? MF_ENABLED : MF_GRAYED;

EnableMenuItem(menu, ID_FILE_SAVESTATEFILE, menuEnable);

EnableMenuItem(menu, ID_FILE_LOADSTATEFILE, menuEnable);

EnableMenuItem(menu, ID_FILE_QUICKSAVESTATE, menuEnable);

EnableMenuItem(menu, ID_FILE_QUICKLOADSTATE, menuEnable);

EnableMenuItem(menu, ID_TOGGLE_PAUSE, menuEnable);

EnableMenuItem(menu, ID_EMULATION_STOP, menuEnable);

EnableMenuItem(menu, ID_EMULATION_RESET, menuEnable);

EnableMenuItem(menu, ID_EMULATION_SWITCH_UMD, umdSwitchEnable);

EnableMenuItem(menu, ID_DEBUG_LOADMAPFILE, menuEnable);

EnableMenuItem(menu, ID_DEBUG_SAVEMAPFILE, menuEnable);

EnableMenuItem(menu, ID_DEBUG_LOADSYMFILE, menuEnable);

EnableMenuItem(menu, ID_DEBUG_SAVESYMFILE, menuEnable);

EnableMenuItem(menu, ID_DEBUG_RESETSYMBOLTABLE, menuEnable);

EnableMenuItem(menu, ID_DEBUG_EXTRACTFILE, menuEnable);

// Main menus

MENU_FILE = 0,

MENU_EMULATION = 1,

MENU_DEBUG = 2,

MENU_OPTIONS = 3,

MENU_HELP = 4,

// File submenus

SUBMENU_FILE_SAVESTATE_SLOT = 6,

// Game Settings submenus

SUBMENU_CUSTOM_SHADERS = 10,

SUBMENU_RENDERING_RESOLUTION = 11,

SUBMENU_WINDOW_SIZE = 12,

SUBMENU_RENDERING_BACKEND = 13,

SUBMENU_RENDERING_MODE = 14,

SUBMENU_FRAME_SKIPPING = 15,

SUBMENU_TEXTURE_FILTERING = 16,

SUBMENU_BUFFER_FILTER = 17,

SUBMENU_TEXTURE_SCALING = 18,

MENUITEMINFO menuInfo;

memset(&menuInfo, 0, sizeof(menuInfo));

menuInfo.cbSize = sizeof(MENUITEMINFO);

menuInfo.fMask = MIIM_STRING;

menuInfo.dwTypeData = 0;

std::string retVal;

if (GetMenuItemInfo(menu, menuID, MF_BYCOMMAND, &menuInfo) != FALSE) {

wchar_t *buffer = new wchar_t[++menuInfo.cch];

menuInfo.dwTypeData = buffer;

GetMenuItemInfo(menu, menuID, MF_BYCOMMAND, &menuInfo);

retVal = ConvertWStringToUTF8(menuInfo.dwTypeData);

delete [] buffer;

}

return retVal;

I18NCategory *des = GetI18NCategory("DesktopUI");

const std::wstring help = ConvertUTF8ToWString(des->T("Help"));

const std::wstring visitMainWebsite = ConvertUTF8ToWString(des->T("www.ppsspp.org"));

const std::wstring visitForum = ConvertUTF8ToWString(des->T("PPSSPP Forums"));

const std::wstring buyGold = ConvertUTF8ToWString(des->T("Buy Gold"));

const std::wstring aboutPPSSPP = ConvertUTF8ToWString(des->T("About PPSSPP..."));

// Simply remove the old help menu and create a new one.

RemoveMenu(menu, MENU_HELP, MF_BYPOSITION);

HMENU helpMenu = CreatePopupMenu();

InsertMenu(menu, MENU_HELP, MF_POPUP | MF_STRING | MF_BYPOSITION, (UINT_PTR)helpMenu, help.c_str());

AppendMenu(helpMenu, MF_STRING | MF_BYCOMMAND, ID_HELP_OPENWEBSITE, visitMainWebsite.c_str());

AppendMenu(helpMenu, MF_STRING | MF_BYCOMMAND, ID_HELP_OPENFORUM, visitForum.c_str());

// Repeat the process for other languages, if necessary.

AppendMenu(helpMenu, MF_STRING | MF_BYCOMMAND, ID_HELP_BUYGOLD, buyGold.c_str());

AppendMenu(helpMenu, MF_SEPARATOR, 0, 0);

AppendMenu(helpMenu, MF_STRING | MF_BYCOMMAND, ID_HELP_ABOUT, aboutPPSSPP.c_str());

int item = ID_SHADERS_BASE + 1;

for (size_t i = 0; i < availableShaders.size(); i++)

CheckMenuItem(menu, item++, ((g_Config.sPostShaderName == availableShaders[i]) ? MF_CHECKED : MF_UNCHECKED));

I18NCategory *des = GetI18NCategory("DesktopUI");

I18NCategory *ps = GetI18NCategory("PostShaders");

const std::wstring key = ConvertUTF8ToWString(des->T("Postprocessing Shader"));

HMENU optionsMenu = GetSubMenu(menu, MENU_OPTIONS);

HMENU shaderMenu = CreatePopupMenu();

RemoveMenu(optionsMenu, SUBMENU_CUSTOM_SHADERS, MF_BYPOSITION);

InsertMenu(optionsMenu, SUBMENU_CUSTOM_SHADERS, MF_POPUP | MF_STRING | MF_BYPOSITION, (UINT_PTR)shaderMenu, key.c_str());

std::vector<ShaderInfo> info = GetAllPostShaderInfo();

availableShaders.clear();

int item = ID_SHADERS_BASE + 1;

int checkedStatus = -1;

const char *translatedShaderName = nullptr;

for (auto i = info.begin(); i != info.end(); ++i) {

checkedStatus = MF_UNCHECKED;

availableShaders.push_back(i->section);

if (g_Config.sPostShaderName == i->section) {

checkedStatus = MF_CHECKED;

}

translatedShaderName = ps->T(i->section.c_str());

AppendMenu(shaderMenu, MF_STRING | MF_BYPOSITION | checkedStatus, item++, ConvertUTF8ToWString(translatedShaderName).c_str());

}

I18NCategory *des = GetI18NCategory("DesktopUI");

std::wstring translated = ConvertUTF8ToWString(des->T(key));

translated.append(accelerator);

u32 flags = MF_STRING | (byCommand ? MF_BYCOMMAND : MF_BYPOSITION);

ModifyMenu(hMenu, menuIDOrPosition, flags, menuIDOrPosition, translated.c_str());

if(key == nullptr || !strcmp(key, ""))

_TranslateMenuItem(menuID, GetMenuItemInitialText(menuID).c_str(), true, accelerator, hMenu);

else

_TranslateMenuItem(menuID, key, true, accelerator, hMenu);

// Menu headers and submenu headers don't have resource IDs,

// So we have to hardcode strings here, unfortunately.

TranslateMenu("File", MENU_FILE);

TranslateMenu("Emulation", MENU_EMULATION);

TranslateMenu("Debugging", MENU_DEBUG);

TranslateMenu("Game Settings", MENU_OPTIONS);

TranslateMenu("Help", MENU_HELP);

CreateShadersSubmenu();

// File menu

TranslateMenuItem(ID_FILE_LOAD);

TranslateMenuItem(ID_FILE_LOAD_DIR);

TranslateMenuItem(ID_FILE_LOAD_MEMSTICK);

TranslateMenuItem(ID_FILE_MEMSTICK);

TranslateSubMenu("Savestate Slot", MENU_FILE, SUBMENU_FILE_SAVESTATE_SLOT, L"\tF3");

TranslateMenuItem(ID_FILE_QUICKLOADSTATE, L"\tF4");

TranslateMenuItem(ID_FILE_QUICKSAVESTATE, L"\tF2");

TranslateMenuItem(ID_FILE_LOADSTATEFILE);

TranslateMenuItem(ID_FILE_SAVESTATEFILE);

TranslateMenuItem(ID_FILE_EXIT, L"\tAlt+F4");

// Emulation menu

TranslateMenuItem(ID_TOGGLE_PAUSE, L"\tF8", "Pause");

TranslateMenuItem(ID_EMULATION_STOP, L"\tCtrl+W");

TranslateMenuItem(ID_EMULATION_RESET, L"\tCtrl+B");

TranslateMenuItem(ID_EMULATION_SWITCH_UMD, L"\tCtrl+U", "Switch UMD");

// Debug menu

TranslateMenuItem(ID_DEBUG_LOADMAPFILE);

TranslateMenuItem(ID_DEBUG_SAVEMAPFILE);

TranslateMenuItem(ID_DEBUG_LOADSYMFILE);

TranslateMenuItem(ID_DEBUG_SAVESYMFILE);

TranslateMenuItem(ID_DEBUG_RESETSYMBOLTABLE);

TranslateMenuItem(ID_DEBUG_DUMPNEXTFRAME);

TranslateMenuItem(ID_DEBUG_TAKESCREENSHOT, L"\tF12");

TranslateMenuItem(ID_DEBUG_SHOWDEBUGSTATISTICS);

TranslateMenuItem(ID_DEBUG_IGNOREILLEGALREADS);

TranslateMenuItem(ID_DEBUG_RUNONLOAD);

TranslateMenuItem(ID_DEBUG_DISASSEMBLY, L"\tCtrl+D");

TranslateMenuItem(ID_DEBUG_GEDEBUGGER,L"\tCtrl+G");

TranslateMenuItem(ID_DEBUG_EXTRACTFILE);

TranslateMenuItem(ID_DEBUG_LOG, L"\tCtrl+L");

TranslateMenuItem(ID_DEBUG_MEMORYVIEW, L"\tCtrl+M");

// Options menu

TranslateMenuItem(ID_OPTIONS_LANGUAGE);

TranslateMenuItem(ID_OPTIONS_TOPMOST);

TranslateMenuItem(ID_OPTIONS_PAUSE_FOCUS);

TranslateMenuItem(ID_OPTIONS_IGNOREWINKEY);

TranslateMenuItem(ID_OPTIONS_MORE_SETTINGS);

TranslateMenuItem(ID_OPTIONS_CONTROLS);

TranslateMenuItem(ID_OPTIONS_STRETCHDISPLAY);

TranslateMenuItem(ID_OPTIONS_FULLSCREEN, L"\tAlt+Return, F11");

TranslateMenuItem(ID_OPTIONS_VSYNC);

TranslateSubMenu("Postprocessing Shader", MENU_OPTIONS, SUBMENU_CUSTOM_SHADERS);

TranslateSubMenu("Rendering Resolution", MENU_OPTIONS, SUBMENU_RENDERING_RESOLUTION, L"\tCtrl+1");

TranslateMenuItem(ID_OPTIONS_SCREENAUTO);

// Skip rendering resolution 2x-5x..

TranslateSubMenu("Window Size", MENU_OPTIONS, SUBMENU_WINDOW_SIZE);

// Skip window size 1x-4x..

TranslateSubMenu("Backend", MENU_OPTIONS, SUBMENU_RENDERING_BACKEND);

TranslateMenuItem(ID_OPTIONS_DIRECTX);

TranslateMenuItem(ID_OPTIONS_OPENGL);

TranslateSubMenu("Rendering Mode", MENU_OPTIONS, SUBMENU_RENDERING_MODE, L"\tF5");

TranslateMenuItem(ID_OPTIONS_NONBUFFEREDRENDERING);

TranslateMenuItem(ID_OPTIONS_BUFFEREDRENDERING);

TranslateMenuItem(ID_OPTIONS_READFBOTOMEMORYCPU);

TranslateMenuItem(ID_OPTIONS_READFBOTOMEMORYGPU);

TranslateSubMenu("Frame Skipping", MENU_OPTIONS, SUBMENU_FRAME_SKIPPING, L"\tF7");

TranslateMenuItem(ID_OPTIONS_FRAMESKIP_AUTO);

TranslateMenuItem(ID_OPTIONS_FRAMESKIP_0);

// Skip frameskipping 1-8..

TranslateSubMenu("Texture Filtering", MENU_OPTIONS, SUBMENU_TEXTURE_FILTERING);

TranslateMenuItem(ID_OPTIONS_TEXTUREFILTERING_AUTO);

TranslateMenuItem(ID_OPTIONS_NEARESTFILTERING);

TranslateMenuItem(ID_OPTIONS_LINEARFILTERING);

TranslateMenuItem(ID_OPTIONS_LINEARFILTERING_CG);

TranslateSubMenu("Screen Scaling Filter", MENU_OPTIONS, SUBMENU_BUFFER_FILTER);

TranslateMenuItem(ID_OPTIONS_BUFLINEARFILTER);

TranslateMenuItem(ID_OPTIONS_BUFNEARESTFILTER);

TranslateSubMenu("Texture Scaling", MENU_OPTIONS, SUBMENU_TEXTURE_SCALING);

TranslateMenuItem(ID_TEXTURESCALING_OFF);

// Skip texture scaling 2x-5x...

TranslateMenuItem(ID_TEXTURESCALING_XBRZ);

TranslateMenuItem(ID_TEXTURESCALING_HYBRID);

TranslateMenuItem(ID_TEXTURESCALING_BICUBIC);

TranslateMenuItem(ID_TEXTURESCALING_HYBRID_BICUBIC);

TranslateMenuItem(ID_TEXTURESCALING_DEPOSTERIZE);

TranslateMenuItem(ID_OPTIONS_HARDWARETRANSFORM, L"\tF6");

TranslateMenuItem(ID_OPTIONS_VERTEXCACHE);

TranslateMenuItem(ID_OPTIONS_SHOWFPS);

TranslateMenuItem(ID_EMULATION_SOUND);

TranslateMenuItem(ID_EMULATION_CHEATS, L"\tCtrl+T");

// Help menu: it's translated in CreateHelpMenu.

CreateHelpMenu();

// TODO: Urgh! Why do we need this here?

// The menu is supposed to enable/disable this stuff directly afterward.

SetIngameMenuItemStates(GetUIState());

DrawMenuBar(hwndMain);

UpdateMenus();

if (mode >= FB_NON_BUFFERED_MODE)

g_Config.iRenderingMode = mode;

else {

if (++g_Config.iRenderingMode > FB_READFBOMEMORY_GPU)

g_Config.iRenderingMode = FB_NON_BUFFERED_MODE;

}

I18NCategory *g = GetI18NCategory("Graphics");

switch(g_Config.iRenderingMode) {

case FB_NON_BUFFERED_MODE:

osm.Show(g->T("Non-Buffered Rendering"));

g_Config.bAutoFrameSkip = false;

break;

case FB_BUFFERED_MODE:

osm.Show(g->T("Buffered Rendering"));

break;

case FB_READFBOMEMORY_CPU:

osm.Show(g->T("Read Framebuffers To Memory (CPU)"));

break;

case FB_READFBOMEMORY_GPU:

osm.Show(g->T("Read Framebuffers To Memory (GPU)"));

break;

}

NativeMessageReceived("gpu resized", "");

if (framesToSkip >= FRAMESKIP_OFF)

g_Config.iFrameSkip = framesToSkip;

else {

if (++g_Config.iFrameSkip > FRAMESKIP_MAX)

g_Config.iFrameSkip = FRAMESKIP_OFF;

}

I18NCategory *g = GetI18NCategory("Graphics");

std::ostringstream messageStream;

messageStream << g->T("Frame Skipping") << ":" << " ";

if (g_Config.iFrameSkip == FRAMESKIP_OFF)

messageStream << g->T("Off");

else

messageStream << g_Config.iFrameSkip;

osm.Show(messageStream.str());

hInst = hInstance; // Store instance handle in our global variable.

RECT rc = DetermineWindowRectangle();

u32 style = WS_OVERLAPPEDWINDOW;

hwndMain = CreateWindowEx(0,szWindowClass, L"", style,

rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, hInstance, NULL);

if (!hwndMain)

return FALSE;

RECT rcClient;

GetClientRect(hwndMain, &rcClient);

hwndDisplay = CreateWindowEx(0, szDisplayClass, L"", WS_CHILD | WS_VISIBLE,

0, 0, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top, hwndMain, 0, hInstance, 0);

if (!hwndDisplay)

return FALSE;

menu = GetMenu(hwndMain);

#ifdef FINAL

RemoveMenu(menu,2,MF_BYPOSITION);

RemoveMenu(menu,2,MF_BYPOSITION);

#endif

MENUINFO info;

ZeroMemory(&info,sizeof(MENUINFO));

info.cbSize = sizeof(MENUINFO);

info.cyMax = 0;

info.dwStyle = MNS_CHECKORBMP;

info.fMask = MIM_STYLE;

for (int i = 0; i < GetMenuItemCount(menu); i++) {

SetMenuInfo(GetSubMenu(menu,i),&info);

}

UpdateMenus();

// Accept dragged files.

DragAcceptFiles(hwndMain, TRUE);

hideCursor = true;

SetTimer(hwndMain, TIMER_CURSORUPDATE, CURSORUPDATE_INTERVAL_MS, 0);

ToggleFullscreen(hwndMain, g_Config.bFullScreen);

W32Util::MakeTopMost(hwndMain, g_Config.bTopMost);

touchHandler.registerTouchWindow(hwndDisplay);

WindowsRawInput::Init();

SetFocus(hwndMain);

return TRUE;

disasmWindow[0] = new CDisasm(MainWindow::GetHInstance(), MainWindow::GetHWND(), currentDebugMIPS);

DialogManager::AddDlg(disasmWindow[0]);

disasmWindow[0]->Show(g_Config.bShowDebuggerOnLoad);

geDebuggerWindow = new CGEDebugger(MainWindow::GetHInstance(), MainWindow::GetHWND());

DialogManager::AddDlg(geDebuggerWindow);

memoryWindow[0] = new CMemoryDlg(MainWindow::GetHInstance(), MainWindow::GetHWND(), currentDebugMIPS);

DialogManager::AddDlg(memoryWindow[0]);

DialogManager::RemoveDlg(disasmWindow[0]);

if (disasmWindow[0])

delete disasmWindow[0];

disasmWindow[0] = 0;

DialogManager::RemoveDlg(geDebuggerWindow);

if (geDebuggerWindow)

delete geDebuggerWindow;

geDebuggerWindow = 0;

DialogManager::RemoveDlg(memoryWindow[0]);

if (memoryWindow[0])

delete memoryWindow[0];

memoryWindow[0] = 0;

static std::wstring filter = L"All supported file types (*.iso *.cso *.pbp *.elf *.prx *.zip)|*.pbp;*.elf;*.iso;*.cso;*.prx;*.zip|PSP ROMs (*.iso *.cso *.pbp *.elf *.prx)|*.pbp;*.elf;*.iso;*.cso;*.prx|Homebrew/Demos installers (*.zip)|*.zip|All files (*.*)|*.*||";

for (int i = 0; i < (int)filter.length(); i++) {

if (filter[i] == '|')

filter[i] = '\0';

}

browsePauseAfter = false;

if (GetUIState() == UISTATE_INGAME) {

browsePauseAfter = Core_IsStepping();

if (!browsePauseAfter)

Core_EnableStepping(true);

}

W32Util::MakeTopMost(GetHWND(), false);

if (browseDirectory) {

browseDialog = new W32Util::AsyncBrowseDialog(GetHWND(), WM_USER_BROWSE_BOOT_DONE, L"Choose directory");

} else {

browseDialog = new W32Util::AsyncBrowseDialog(W32Util::AsyncBrowseDialog::OPEN, GetHWND(), WM_USER_BROWSE_BOOT_DONE, L"LoadFile", ConvertUTF8ToWString(defaultPath), filter, L"*.pbp;*.elf;*.iso;*.cso;");

}

std::string filename;

if (!browseDialog->GetResult(filename)) {

if (!browsePauseAfter) {

Core_EnableStepping(false);

}

} else {

if (GetUIState() == UISTATE_INGAME || GetUIState() == UISTATE_PAUSEMENU) {

Core_EnableStepping(false);

}

// TODO: What is this for / what does it fix?

if (browseDialog->GetType() != W32Util::AsyncBrowseDialog::DIR) {

// Decode the filename with fullpath.

char drive[MAX_PATH];

char dir[MAX_PATH];

char fname[MAX_PATH];

char ext[MAX_PATH];

_splitpath(filename.c_str(), drive, dir, fname, ext);

filename = std::string(drive) + std::string(dir) + std::string(fname) + std::string(ext);

}

filename = ReplaceAll(filename, "\\", "/");

NativeMessageReceived("boot", filename.c_str());

}

W32Util::MakeTopMost(GetHWND(), g_Config.bTopMost);

delete browseDialog;

browseDialog = 0;

std::string fn;

std::string filter = "PSP ROMs (*.iso *.cso *.pbp *.elf)|*.pbp;*.elf;*.iso;*.cso;*.prx|All files (*.*)|*.*||";

for (int i=0; i<(int)filter.length(); i++) {

if (filter[i] == '|')

filter[i] = '\0';

}

if (W32Util::BrowseForFileName(true, GetHWND(), L"Switch Umd", 0, ConvertUTF8ToWString(filter).c_str(), L"*.pbp;*.elf;*.iso;*.cso;",fn)) {

fn = ReplaceAll(fn, "\\", "/");

__UmdReplace(fn);

}

// Only apply a factor > 1 in windowed mode.

int factor = !IsZoomed(GetHWND()) && !g_Config.bFullScreen && g_Config.iWindowWidth < (480 + 80) ? 2 : 1;

static bool firstErase = true;

switch (message) {

case WM_ACTIVATE:

if (wParam == WA_ACTIVE || wParam == WA_CLICKACTIVE) {

g_activeWindow = WINDOW_MAINWINDOW;

}

break;

case WM_SETFOCUS:

break;

case WM_ERASEBKGND:

if (firstErase) {

firstErase = false;

// Paint black on first erase while OpenGL stuff is loading

return DefWindowProc(hWnd, message, wParam, lParam);

}

// Then never erase, let the OpenGL drawing take care of everything.

return 1;

// Poor man's touch - mouse input. We send the data both as an input_state pointer,

// and as asynchronous touch events for minimal latency.

case WM_LBUTTONDOWN:

if (!touchHandler.hasTouch() ||

(GetMessageExtraInfo() & MOUSEEVENTF_MASK_PLUS_PENTOUCH) != MOUSEEVENTF_FROMTOUCH_NOPEN)

{

// Hack: Take the opportunity to show the cursor.

mouseButtonDown = true;

{

lock_guard guard(input_state.lock);

input_state.mouse_valid = true;

input_state.pointer_down[0] = true;

input_state.pointer_x[0] = GET_X_LPARAM(lParam) * factor;

input_state.pointer_y[0] = GET_Y_LPARAM(lParam) * factor;

}

TouchInput touch;

touch.id = 0;

touch.flags = TOUCH_DOWN;

touch.x = input_state.pointer_x[0];

touch.y = input_state.pointer_y[0];

NativeTouch(touch);

SetCapture(hWnd);

}

break;

case WM_MOUSEMOVE:

if (!touchHandler.hasTouch() ||

(GetMessageExtraInfo() & MOUSEEVENTF_MASK_PLUS_PENTOUCH) != MOUSEEVENTF_FROMTOUCH_NOPEN)

{

// Hack: Take the opportunity to show the cursor.

mouseButtonDown = (wParam & MK_LBUTTON) != 0;