ShuriZma
/
project64
mirror of https://github.com/project64/project64.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

{Project64] Convert internal strings to be utf8 instead of utf16

This commit is contained in:
zilmar 2015-12-24 07:04:36 +11:00
parent 45166a5824
commit 73549ee72f
47 changed files with 992 additions and 986 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Source/Project64-core/3rdParty/7zip.cpp vendored
View File

@ -5,6 +5,7 @@ typedef const char * LPCSTR;
#include <stdlib.h> #include <stdlib.h>
#include <memory.h> #include <memory.h>
#include "7zip.h" #include "7zip.h"
#include <Common/StdString.h>
C7zip::C7zip(LPCSTR FileName) : C7zip::C7zip(LPCSTR FileName) :
m_FileSize(0), m_FileSize(0),
@ -126,9 +127,9 @@ bool C7zip::GetFile(int index, Byte * Data, size_t DataLen)
size_t offset; size_t offset;
size_t outSizeProcessed; size_t outSizeProcessed;
wchar_t Msg[200]; char Msg[200];
std::wstring FileName = FileNameIndex(index); std::wstring FileName = FileNameIndex(index);
_snwprintf(Msg, sizeof(Msg) / sizeof(Msg[0]), L"extracting %s", FileName.c_str()); _snprintf(Msg, sizeof(Msg) / sizeof(Msg[0]), "extracting %s", stdstr().FromUTF16(FileName.c_str()));
m_NotfyCallback(Msg, m_NotfyCallbackInfo); m_NotfyCallback(Msg, m_NotfyCallbackInfo);
SRes res = SzArEx_Extract(m_db, &m_archiveLookStream.s, index, SRes res = SzArEx_Extract(m_db, &m_archiveLookStream.s, index,
@ -146,7 +147,7 @@ bool C7zip::GetFile(int index, Byte * Data, size_t DataLen)
outSizeProcessed = DataLen; outSizeProcessed = DataLen;
} }
memcpy(Data, m_outBuffer + offset, outSizeProcessed); memcpy(Data, m_outBuffer + offset, outSizeProcessed);
m_NotfyCallback(L"", m_NotfyCallbackInfo); m_NotfyCallback("", m_NotfyCallbackInfo);
m_CurrentFile = -1; m_CurrentFile = -1;
return true; return true;
} }

4
Source/Project64-core/3rdParty/7zip.h vendored
View File

@ -21,7 +21,7 @@ public:
C7zip(LPCSTR FileName); C7zip(LPCSTR FileName);
~C7zip(); ~C7zip();
typedef void(__stdcall *LP7ZNOTIFICATION)(LPCWSTR Status, void * CBInfo); typedef void (*LP7ZNOTIFICATION)(const char * Status, void * CBInfo);
inline int NumFiles(void) const { return m_db ? m_db->db.NumFiles : 0; } inline int NumFiles(void) const { return m_db ? m_db->db.NumFiles : 0; }
inline CSzFileItem * FileItem(int index) const { return m_db ? &m_db->db.Files[index] : NULL; } inline CSzFileItem * FileItem(int index) const { return m_db ? &m_db->db.Files[index] : NULL; }
@ -68,7 +68,7 @@ private:
//static void __stdcall StatusUpdate(_7Z_STATUS status, int Value1, int Value2, C7zip * _this); //static void __stdcall StatusUpdate(_7Z_STATUS status, int Value1, int Value2, C7zip * _this);
static void __stdcall NotfyCallbackDefault(LPCWSTR /*Status*/, void * /*CBInfo*/) { } static void NotfyCallbackDefault(const char * /*Status*/, void * /*CBInfo*/) { }
LP7ZNOTIFICATION m_NotfyCallback; LP7ZNOTIFICATION m_NotfyCallback;
void * m_NotfyCallbackInfo; void * m_NotfyCallbackInfo;

2
Source/Project64-core/AppInit.cpp
View File

@ -179,7 +179,7 @@ void AppInit(CNotification * Notify)
} }
catch (...) catch (...)
{ {
g_Notify->DisplayError(stdstr_f("Exception caught\nFile: %s\nLine: %d", __FILE__, __LINE__).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Exception caught\nFile: %s\nLine: %d", __FILE__, __LINE__).c_str());
} }
} }

759
Source/Project64-core/Multilanguage/LanguageClass.cpp
View File

@ -19,492 +19,492 @@ void CLanguage::LoadDefaultStrings(void)
{ {
#define DEF_STR(ID,str) m_DefaultStrings.insert(LANG_STRINGS::value_type(ID,str)) #define DEF_STR(ID,str) m_DefaultStrings.insert(LANG_STRINGS::value_type(ID,str))
DEF_STR(EMPTY_STRING, L""); DEF_STR(EMPTY_STRING, "");
/********************************************************************************* /*********************************************************************************
* Meta Information * * Meta Information *
*********************************************************************************/ *********************************************************************************/
//About DLL //About DLL
DEF_STR(LANGUAGE_NAME, L""); DEF_STR(LANGUAGE_NAME, "");
DEF_STR(LANGUAGE_AUTHOR, L""); DEF_STR(LANGUAGE_AUTHOR, "");
DEF_STR(LANGUAGE_VERSION, L""); DEF_STR(LANGUAGE_VERSION, "");
DEF_STR(LANGUAGE_DATE, L""); DEF_STR(LANGUAGE_DATE, "");
//About DLL Dialog //About DLL Dialog
DEF_STR(INI_CURRENT_LANG, L"Current Language"); DEF_STR(INI_CURRENT_LANG, "Current Language");
DEF_STR(INI_AUTHOR, L"Author"); DEF_STR(INI_AUTHOR, "Author");
DEF_STR(INI_VERSION, L"Version"); DEF_STR(INI_VERSION, "Version");
DEF_STR(INI_DATE, L"Date"); DEF_STR(INI_DATE, "Date");
DEF_STR(INI_HOMEPAGE, L"Visit Home Page"); DEF_STR(INI_HOMEPAGE, "Visit Home Page");
DEF_STR(INI_CURRENT_RDB, L"ROM Database (.RDB)"); DEF_STR(INI_CURRENT_RDB, "ROM Database (.RDB)");
DEF_STR(INI_CURRENT_CHT, L"Cheat Code File (.CHT)"); DEF_STR(INI_CURRENT_CHT, "Cheat Code File (.CHT)");
DEF_STR(INI_CURRENT_RDX, L"Extended ROM Info (.RDX)"); DEF_STR(INI_CURRENT_RDX, "Extended ROM Info (.RDX)");
//About INI title //About INI title
DEF_STR(INI_TITLE, L"About Config Files"); DEF_STR(INI_TITLE, "About Config Files");
/********************************************************************************* /*********************************************************************************
* Numbers * * Numbers *
*********************************************************************************/ *********************************************************************************/
DEF_STR(NUMBER_0, L"0"); DEF_STR(NUMBER_0, "0");
DEF_STR(NUMBER_1, L"1"); DEF_STR(NUMBER_1, "1");
DEF_STR(NUMBER_2, L"2"); DEF_STR(NUMBER_2, "2");
DEF_STR(NUMBER_3, L"3"); DEF_STR(NUMBER_3, "3");
DEF_STR(NUMBER_4, L"4"), DEF_STR(NUMBER_4, "4");
DEF_STR(NUMBER_5, L"5"); DEF_STR(NUMBER_5, "5");
DEF_STR(NUMBER_6, L"6"); DEF_STR(NUMBER_6, "6");
DEF_STR(NUMBER_7, L"7"); DEF_STR(NUMBER_7, "7");
DEF_STR(NUMBER_8, L"8"); DEF_STR(NUMBER_8, "8");
DEF_STR(NUMBER_9, L"9"); DEF_STR(NUMBER_9, "9");
/********************************************************************************* /*********************************************************************************
* Menu * * Menu *
*********************************************************************************/ *********************************************************************************/
//File Menu //File Menu
DEF_STR(MENU_FILE, L"&File"); DEF_STR(MENU_FILE, "&File");
DEF_STR(MENU_OPEN, L"&Open ROM"); DEF_STR(MENU_OPEN, "&Open ROM");
DEF_STR(MENU_ROM_INFO, L"ROM &Info...."); DEF_STR(MENU_ROM_INFO, "ROM &Info....");
DEF_STR(MENU_START, L"Start Emulation"); DEF_STR(MENU_START, "Start Emulation");
DEF_STR(MENU_END, L"&End Emulation"); DEF_STR(MENU_END, "&End Emulation");
DEF_STR(MENU_CHOOSE_ROM, L"Choose ROM Directory..."); DEF_STR(MENU_CHOOSE_ROM, "Choose ROM Directory...");
DEF_STR(MENU_REFRESH, L"Refresh ROM List"); DEF_STR(MENU_REFRESH, "Refresh ROM List");
DEF_STR(MENU_RECENT_ROM, L"Recent ROM"); DEF_STR(MENU_RECENT_ROM, "Recent ROM");
DEF_STR(MENU_RECENT_DIR, L"Recent ROM Directories"); DEF_STR(MENU_RECENT_DIR, "Recent ROM Directories");
DEF_STR(MENU_EXIT, L"E&xit"); DEF_STR(MENU_EXIT, "E&xit");
//System Menu //System Menu
DEF_STR(MENU_SYSTEM, L"&System"); DEF_STR(MENU_SYSTEM, "&System");
DEF_STR(MENU_RESET, L"&Reset"); DEF_STR(MENU_RESET, "&Reset");
DEF_STR(MENU_PAUSE, L"&Pause"); DEF_STR(MENU_PAUSE, "&Pause");
DEF_STR(MENU_BITMAP, L"Generate Bitmap"); DEF_STR(MENU_BITMAP, "Generate Bitmap");
DEF_STR(MENU_LIMIT_FPS, L"Limit FPS"); DEF_STR(MENU_LIMIT_FPS, "Limit FPS");
DEF_STR(MENU_SAVE, L"&Save State"); DEF_STR(MENU_SAVE, "&Save State");
DEF_STR(MENU_SAVE_AS, L"Save As..."); DEF_STR(MENU_SAVE_AS, "Save As...");
DEF_STR(MENU_RESTORE, L"&Load State"); DEF_STR(MENU_RESTORE, "&Load State");
DEF_STR(MENU_LOAD, L"Load..."); DEF_STR(MENU_LOAD, "Load...");
DEF_STR(MENU_CURRENT_SAVE, L"Current Save S&tate"); DEF_STR(MENU_CURRENT_SAVE, "Current Save S&tate");
DEF_STR(MENU_CHEAT, L"Cheats..."); DEF_STR(MENU_CHEAT, "Cheats...");
DEF_STR(MENU_GS_BUTTON, L"GS Button"); DEF_STR(MENU_GS_BUTTON, "GS Button");
DEF_STR(MENU_RESUME, L"R&esume"); DEF_STR(MENU_RESUME, "R&esume");
DEF_STR(MENU_RESET_SOFT, L"&Soft Reset"); DEF_STR(MENU_RESET_SOFT, "&Soft Reset");
DEF_STR(MENU_RESET_HARD, L"&Hard Reset"); DEF_STR(MENU_RESET_HARD, "&Hard Reset");
//Options Menu //Options Menu
DEF_STR(MENU_OPTIONS, L"&Options"); DEF_STR(MENU_OPTIONS, "&Options");
DEF_STR(MENU_FULL_SCREEN, L"&Full Screen"); DEF_STR(MENU_FULL_SCREEN, "&Full Screen");
DEF_STR(MENU_ON_TOP, L"&Always on &Top"); DEF_STR(MENU_ON_TOP, "&Always on &Top");
DEF_STR(MENU_CONFG_GFX, L"Configure Graphics Plugin..."); DEF_STR(MENU_CONFG_GFX, "Configure Graphics Plugin...");
DEF_STR(MENU_CONFG_AUDIO, L"Configure Audio Plugin..."); DEF_STR(MENU_CONFG_AUDIO, "Configure Audio Plugin...");
DEF_STR(MENU_CONFG_CTRL, L"Configure Controller Plugin..."); DEF_STR(MENU_CONFG_CTRL, "Configure Controller Plugin...");
DEF_STR(MENU_CONFG_RSP, L"Configure RSP Plugin..."); DEF_STR(MENU_CONFG_RSP, "Configure RSP Plugin...");
DEF_STR(MENU_SHOW_CPU, L"Show CPU Usage"); DEF_STR(MENU_SHOW_CPU, "Show CPU Usage");
DEF_STR(MENU_SETTINGS, L"&Settings..."); DEF_STR(MENU_SETTINGS, "&Settings...");
//Debugger Menu //Debugger Menu
DEF_STR(MENU_DEBUGGER, L"&Debugger"); DEF_STR(MENU_DEBUGGER, "&Debugger");
//Language Menu //Language Menu
DEF_STR(MENU_LANGUAGE, L"&Language"); DEF_STR(MENU_LANGUAGE, "&Language");
//Help Menu //Help Menu
DEF_STR(MENU_HELP, L"&Help"); DEF_STR(MENU_HELP, "&Help");
DEF_STR(MENU_ABOUT_INI, L"About Conf&ig Files"); DEF_STR(MENU_ABOUT_INI, "About Conf&ig Files");
DEF_STR(MENU_ABOUT_PJ64, L"&About Project64"); DEF_STR(MENU_ABOUT_PJ64, "&About Project64");
DEF_STR(MENU_FORUM, L"Support &Forum"); DEF_STR(MENU_FORUM, "Support &Forum");
DEF_STR(MENU_HOMEPAGE, L"&Homepage"); DEF_STR(MENU_HOMEPAGE, "&Homepage");
//Current Save Slot menu //Current Save Slot menu
DEF_STR(MENU_SLOT_DEFAULT, L"Default"); DEF_STR(MENU_SLOT_DEFAULT, "Default");
DEF_STR(MENU_SLOT_1, L"Slot 1"); DEF_STR(MENU_SLOT_1, "Slot 1");
DEF_STR(MENU_SLOT_2, L"Slot 2"); DEF_STR(MENU_SLOT_2, "Slot 2");
DEF_STR(MENU_SLOT_3, L"Slot 3"); DEF_STR(MENU_SLOT_3, "Slot 3");
DEF_STR(MENU_SLOT_4, L"Slot 4"); DEF_STR(MENU_SLOT_4, "Slot 4");
DEF_STR(MENU_SLOT_5, L"Slot 5"); DEF_STR(MENU_SLOT_5, "Slot 5");
DEF_STR(MENU_SLOT_6, L"Slot 6"); DEF_STR(MENU_SLOT_6, "Slot 6");
DEF_STR(MENU_SLOT_7, L"Slot 7"); DEF_STR(MENU_SLOT_7, "Slot 7");
DEF_STR(MENU_SLOT_8, L"Slot 8"); DEF_STR(MENU_SLOT_8, "Slot 8");
DEF_STR(MENU_SLOT_9, L"Slot 9"); DEF_STR(MENU_SLOT_9, "Slot 9");
DEF_STR(MENU_SLOT_10, L"Slot 10"); DEF_STR(MENU_SLOT_10, "Slot 10");
DEF_STR(MENU_SLOT_SAVE, L"Save slot (%ws) selected"); DEF_STR(MENU_SLOT_SAVE, "Save slot (%s) selected");
//Pop up Menu //Pop up Menu
DEF_STR(POPUP_PLAY, L"Play Game"); DEF_STR(POPUP_PLAY, "Play Game");
DEF_STR(POPUP_INFO, L"ROM Information"); DEF_STR(POPUP_INFO, "ROM Information");
DEF_STR(POPUP_SETTINGS, L"Edit Game Settings"); DEF_STR(POPUP_SETTINGS, "Edit Game Settings");
DEF_STR(POPUP_CHEATS, L"Edit Cheats"); DEF_STR(POPUP_CHEATS, "Edit Cheats");
DEF_STR(POPUP_GFX_PLUGIN, L"Graphics Plugin"); DEF_STR(POPUP_GFX_PLUGIN, "Graphics Plugin");
//Alternate Name to save Slot //Alternate Name to save Slot
DEF_STR(SAVE_SLOT_DEFAULT, L"Save Slot - Default"); DEF_STR(SAVE_SLOT_DEFAULT, "Save Slot - Default");
DEF_STR(SAVE_SLOT_1, L"Save Slot - 1"); DEF_STR(SAVE_SLOT_1, "Save Slot - 1");
DEF_STR(SAVE_SLOT_2, L"Save Slot - 2"); DEF_STR(SAVE_SLOT_2, "Save Slot - 2");
DEF_STR(SAVE_SLOT_3, L"Save Slot - 3"); DEF_STR(SAVE_SLOT_3, "Save Slot - 3");
DEF_STR(SAVE_SLOT_4, L"Save Slot - 4"); DEF_STR(SAVE_SLOT_4, "Save Slot - 4");
DEF_STR(SAVE_SLOT_5, L"Save Slot - 5"); DEF_STR(SAVE_SLOT_5, "Save Slot - 5");
DEF_STR(SAVE_SLOT_6, L"Save Slot - 6"); DEF_STR(SAVE_SLOT_6, "Save Slot - 6");
DEF_STR(SAVE_SLOT_7, L"Save Slot - 7"); DEF_STR(SAVE_SLOT_7, "Save Slot - 7");
DEF_STR(SAVE_SLOT_8, L"Save Slot - 8"); DEF_STR(SAVE_SLOT_8, "Save Slot - 8");
DEF_STR(SAVE_SLOT_9, L"Save Slot - 9"); DEF_STR(SAVE_SLOT_9, "Save Slot - 9");
DEF_STR(SAVE_SLOT_10, L"Save Slot - 10"); DEF_STR(SAVE_SLOT_10, "Save Slot - 10");
/********************************************************************************* /*********************************************************************************
* ROM Browser * * ROM Browser *
*********************************************************************************/ *********************************************************************************/
//ROM Browser Fields //ROM Browser Fields
DEF_STR(RB_FILENAME, L"File Name"); DEF_STR(RB_FILENAME, "File Name");
DEF_STR(RB_INTERNALNAME, L"Internal Name"); DEF_STR(RB_INTERNALNAME, "Internal Name");
DEF_STR(RB_GOODNAME, L"Good Name"); DEF_STR(RB_GOODNAME, "Good Name");
DEF_STR(RB_STATUS, L"Status"); DEF_STR(RB_STATUS, "Status");
DEF_STR(RB_ROMSIZE, L"ROM Size"); DEF_STR(RB_ROMSIZE, "ROM Size");
DEF_STR(RB_NOTES_CORE, L"Notes (core)"); DEF_STR(RB_NOTES_CORE, "Notes (core)");
DEF_STR(RB_NOTES_PLUGIN, L"Notes (default plugins)"); DEF_STR(RB_NOTES_PLUGIN, "Notes (default plugins)");
DEF_STR(RB_NOTES_USER, L"Notes (user)"); DEF_STR(RB_NOTES_USER, "Notes (user)");
DEF_STR(RB_CART_ID, L"Cartridge ID"); DEF_STR(RB_CART_ID, "Cartridge ID");
DEF_STR(RB_MANUFACTUER, L"Manufacturer"); DEF_STR(RB_MANUFACTUER, "Manufacturer");
DEF_STR(RB_COUNTRY, L"Country"); DEF_STR(RB_COUNTRY, "Country");
DEF_STR(RB_DEVELOPER, L"Developer"); DEF_STR(RB_DEVELOPER, "Developer");
DEF_STR(RB_CRC1, L"CRC1"); DEF_STR(RB_CRC1, "CRC1");
DEF_STR(RB_CRC2, L"CRC2"); DEF_STR(RB_CRC2, "CRC2");
DEF_STR(RB_CICCHIP, L"CIC Chip"); DEF_STR(RB_CICCHIP, "CIC Chip");
DEF_STR(RB_RELEASE_DATE, L"Release Date"); DEF_STR(RB_RELEASE_DATE, "Release Date");
DEF_STR(RB_GENRE, L"Genre"); DEF_STR(RB_GENRE, "Genre");
DEF_STR(RB_PLAYERS, L"Players"); DEF_STR(RB_PLAYERS, "Players");
DEF_STR(RB_FORCE_FEEDBACK, L"Force Feedback"); DEF_STR(RB_FORCE_FEEDBACK, "Force Feedback");
DEF_STR(RB_FILE_FORMAT, L"File Format"); DEF_STR(RB_FILE_FORMAT, "File Format");
//Select ROM //Select ROM
DEF_STR(SELECT_ROM_DIR, L"Select current ROM directory"); DEF_STR(SELECT_ROM_DIR, "Select current ROM directory");
//Messages //Messages
DEF_STR(RB_NOT_GOOD_FILE, L"Bad ROM? Use GoodN64 & check that the RDB is up-to-date."); DEF_STR(RB_NOT_GOOD_FILE, "Bad ROM? Use GoodN64 & check that the RDB is up-to-date.");
/********************************************************************************* /*********************************************************************************
* Options * * Options *
*********************************************************************************/ *********************************************************************************/
//Options Title //Options Title
DEF_STR(OPTIONS_TITLE, L"Settings"); DEF_STR(OPTIONS_TITLE, "Settings");
//Tabs //Tabs
DEF_STR(TAB_PLUGIN, L"Plugins"); DEF_STR(TAB_PLUGIN, "Plugins");
DEF_STR(TAB_DIRECTORY, L"Directories"); DEF_STR(TAB_DIRECTORY, "Directories");
DEF_STR(TAB_OPTIONS, L"Options"); DEF_STR(TAB_OPTIONS, "Options");
DEF_STR(TAB_ROMSELECTION, L"ROM Selection"); DEF_STR(TAB_ROMSELECTION, "ROM Selection");
DEF_STR(TAB_ADVANCED, L"Advanced"); DEF_STR(TAB_ADVANCED, "Advanced");
DEF_STR(TAB_ROMSETTINGS, L"General Settings"); DEF_STR(TAB_ROMSETTINGS, "General Settings");
DEF_STR(TAB_SHELLINTERGATION, L"Shell Integration"); DEF_STR(TAB_SHELLINTERGATION, "Shell Integration");
DEF_STR(TAB_ROMNOTES, L"Notes"); DEF_STR(TAB_ROMNOTES, "Notes");
DEF_STR(TAB_SHORTCUTS, L"Keyboard Shortcuts"); DEF_STR(TAB_SHORTCUTS, "Keyboard Shortcuts");
DEF_STR(TAB_ROMSTATUS, L"Status"); DEF_STR(TAB_ROMSTATUS, "Status");
DEF_STR(TAB_RECOMPILER, L"Recompiler"); DEF_STR(TAB_RECOMPILER, "Recompiler");
//Plugin Dialog //Plugin Dialog
DEF_STR(PLUG_ABOUT, L"About"); DEF_STR(PLUG_ABOUT, "About");
DEF_STR(PLUG_RSP, L" RSP (Reality Signal Processor) plugin: "); DEF_STR(PLUG_RSP, " RSP (Reality Signal Processor) plugin: ");
DEF_STR(PLUG_GFX, L" Video (graphics) plugin: "); DEF_STR(PLUG_GFX, " Video (graphics) plugin: ");
DEF_STR(PLUG_AUDIO, L" Audio (sound) plugin: "); DEF_STR(PLUG_AUDIO, " Audio (sound) plugin: ");
DEF_STR(PLUG_CTRL, L" Input (controller) plugin: "); DEF_STR(PLUG_CTRL, " Input (controller) plugin: ");
DEF_STR(PLUG_HLE_GFX, L"Graphics HLE"); DEF_STR(PLUG_HLE_GFX, "Graphics HLE");
DEF_STR(PLUG_HLE_AUDIO, L"Audio HLE"); DEF_STR(PLUG_HLE_AUDIO, "Audio HLE");
DEF_STR(PLUG_DEFAULT, L"** Use System Plugin **"); DEF_STR(PLUG_DEFAULT, "** Use System Plugin **");
//Directory Dialog //Directory Dialog
DEF_STR(DIR_PLUGIN, L" Plugin directory: "); DEF_STR(DIR_PLUGIN, " Plugin directory: ");
DEF_STR(DIR_ROM, L" ROM directory: "); DEF_STR(DIR_ROM, " ROM directory: ");
DEF_STR(DIR_AUTO_SAVE, L" N64 native saves directory: "); DEF_STR(DIR_AUTO_SAVE, " N64 native saves directory: ");
DEF_STR(DIR_INSTANT_SAVE, L" Saved states directory: "); DEF_STR(DIR_INSTANT_SAVE, " Saved states directory: ");
DEF_STR(DIR_SCREEN_SHOT, L" Screenshot directory: "); DEF_STR(DIR_SCREEN_SHOT, " Screenshot directory: ");
DEF_STR(DIR_ROM_DEFAULT, L"Last folder that a ROM was open from"); DEF_STR(DIR_ROM_DEFAULT, "Last folder that a ROM was open from");
DEF_STR(DIR_SELECT_PLUGIN, L"Select plugin directory"); DEF_STR(DIR_SELECT_PLUGIN, "Select plugin directory");
DEF_STR(DIR_SELECT_ROM, L"Select ROM directory"); DEF_STR(DIR_SELECT_ROM, "Select ROM directory");
DEF_STR(DIR_SELECT_AUTO, L"Select N64 native saves directory"); DEF_STR(DIR_SELECT_AUTO, "Select N64 native saves directory");
DEF_STR(DIR_SELECT_INSTANT, L"Select saved states directory"); DEF_STR(DIR_SELECT_INSTANT, "Select saved states directory");
DEF_STR(DIR_SELECT_SCREEN, L"Select screenshot directory"); DEF_STR(DIR_SELECT_SCREEN, "Select screenshot directory");
DEF_STR(DIR_TEXTURE, L" Texture pack directory: "); DEF_STR(DIR_TEXTURE, " Texture pack directory: ");
DEF_STR(DIR_SELECT_TEXTURE, L"Select texture pack directory"); DEF_STR(DIR_SELECT_TEXTURE, "Select texture pack directory");
//Options (general) Tab //Options (general) Tab
DEF_STR(OPTION_AUTO_SLEEP, L"Pause emulation when window is not active"); DEF_STR(OPTION_AUTO_SLEEP, "Pause emulation when window is not active");
DEF_STR(OPTION_AUTO_FULLSCREEN, L"Enter full-screen mode when loading a ROM"); DEF_STR(OPTION_AUTO_FULLSCREEN, "Enter full-screen mode when loading a ROM");
DEF_STR(OPTION_BASIC_MODE, L"Hide advanced settings"); DEF_STR(OPTION_BASIC_MODE, "Hide advanced settings");
DEF_STR(OPTION_REMEMBER_CHEAT, L"Remember selected cheats"); DEF_STR(OPTION_REMEMBER_CHEAT, "Remember selected cheats");
DEF_STR(OPTION_DISABLE_SS, L"Disable screen saver when running a ROM"); DEF_STR(OPTION_DISABLE_SS, "Disable screen saver when running a ROM");
DEF_STR(OPTION_DISPLAY_FR, L"Display speed"); DEF_STR(OPTION_DISPLAY_FR, "Display speed");
DEF_STR(OPTION_CHECK_RUNNING, L"Check if Project64 is already running"); DEF_STR(OPTION_CHECK_RUNNING, "Check if Project64 is already running");
DEF_STR(OPTION_CHANGE_FR, L"Speed display:"); DEF_STR(OPTION_CHANGE_FR, "Speed display:");
//ROM Browser Tab //ROM Browser Tab
DEF_STR(RB_MAX_ROMS, L"Max # of ROMs remembered (0-10):"); DEF_STR(RB_MAX_ROMS, "Max # of ROMs remembered (0-10):");
DEF_STR(RB_ROMS, L"ROMs"); DEF_STR(RB_ROMS, "ROMs");
DEF_STR(RB_MAX_DIRS, L"Max # of ROM dirs remembered (0-10):"); DEF_STR(RB_MAX_DIRS, "Max # of ROM dirs remembered (0-10):");
DEF_STR(RB_DIRS, L"dirs"); DEF_STR(RB_DIRS, "dirs");
DEF_STR(RB_USE, L"Use ROM browser"); DEF_STR(RB_USE, "Use ROM browser");
DEF_STR(RB_DIR_RECURSION, L"Use directory recursion"); DEF_STR(RB_DIR_RECURSION, "Use directory recursion");
DEF_STR(RB_AVALIABLE_FIELDS, L"Available fields:"); DEF_STR(RB_AVALIABLE_FIELDS, "Available fields:");
DEF_STR(RB_SHOW_FIELDS, L"Order of fields:"); DEF_STR(RB_SHOW_FIELDS, "Order of fields:");
DEF_STR(RB_ADD, L"Add ->"); DEF_STR(RB_ADD, "Add ->");
DEF_STR(RB_REMOVE, L"<- Remove"); DEF_STR(RB_REMOVE, "<- Remove");
DEF_STR(RB_UP, L"Up"); DEF_STR(RB_UP, "Up");
DEF_STR(RB_DOWN, L"Down"); DEF_STR(RB_DOWN, "Down");
DEF_STR(RB_REFRESH, L"Automatically refresh browser"); DEF_STR(RB_REFRESH, "Automatically refresh browser");
//Advanced Options //Advanced Options
DEF_STR(ADVANCE_INFO, L"Most of these changes will not take effect until a new ROM is opened or current ROM is reset."); DEF_STR(ADVANCE_INFO, "Most of these changes will not take effect until a new ROM is opened or current ROM is reset.");
DEF_STR(ADVANCE_DEFAULTS, L"Core Defaults"); DEF_STR(ADVANCE_DEFAULTS, "Core Defaults");
DEF_STR(ADVANCE_CPU_STYLE, L"CPU core style:"); DEF_STR(ADVANCE_CPU_STYLE, "CPU core style:");
DEF_STR(ADVANCE_SMCM, L"Self-mod methods:"); DEF_STR(ADVANCE_SMCM, "Self-mod methods:");
DEF_STR(ADVANCE_MEM_SIZE, L"Default memory size:"); DEF_STR(ADVANCE_MEM_SIZE, "Default memory size:");
DEF_STR(ADVANCE_ABL, L"Advanced block linking"); DEF_STR(ADVANCE_ABL, "Advanced block linking");
DEF_STR(ADVANCE_AUTO_START, L"Start emulation when ROM is opened"); DEF_STR(ADVANCE_AUTO_START, "Start emulation when ROM is opened");
DEF_STR(ADVANCE_OVERWRITE, L"Always override default settings with ones from RDB"); DEF_STR(ADVANCE_OVERWRITE, "Always override default settings with ones from RDB");
DEF_STR(ADVANCE_COMPRESS, L"Automatically compress saved states"); DEF_STR(ADVANCE_COMPRESS, "Automatically compress saved states");
DEF_STR(ADVANCE_DEBUGGER, L"Enable debugger"); DEF_STR(ADVANCE_DEBUGGER, "Enable debugger");
DEF_STR(ADVANCE_SMM_CACHE, L"Cache"); DEF_STR(ADVANCE_SMM_CACHE, "Cache");
DEF_STR(ADVANCE_SMM_PIDMA, L"PI DMA"); DEF_STR(ADVANCE_SMM_PIDMA, "PI DMA");
DEF_STR(ADVANCE_SMM_VALIDATE, L"Start changed"); DEF_STR(ADVANCE_SMM_VALIDATE, "Start changed");
DEF_STR(ADVANCE_SMM_PROTECT, L"Protect memory"); DEF_STR(ADVANCE_SMM_PROTECT, "Protect memory");
DEF_STR(ADVANCE_SMM_TLB, L"TLB unmapping"); DEF_STR(ADVANCE_SMM_TLB, "TLB unmapping");
//ROM Options //ROM Options
DEF_STR(ROM_CPU_STYLE, L"CPU core style:"); DEF_STR(ROM_CPU_STYLE, "CPU core style:");
DEF_STR(ROM_VIREFRESH, L"VI refresh rate:"); DEF_STR(ROM_VIREFRESH, "VI refresh rate:");
DEF_STR(ROM_MEM_SIZE, L"Memory size:"); DEF_STR(ROM_MEM_SIZE, "Memory size:");
DEF_STR(ROM_ABL, L"Advanced block linking"); DEF_STR(ROM_ABL, "Advanced block linking");
DEF_STR(ROM_SAVE_TYPE, L"Default save type:"); DEF_STR(ROM_SAVE_TYPE, "Default save type:");
DEF_STR(ROM_COUNTER_FACTOR, L"Counter factor:"); DEF_STR(ROM_COUNTER_FACTOR, "Counter factor:");
DEF_STR(ROM_LARGE_BUFFER, L"Larger compile buffer"); DEF_STR(ROM_LARGE_BUFFER, "Larger compile buffer");
DEF_STR(ROM_USE_TLB, L"Use TLB"); DEF_STR(ROM_USE_TLB, "Use TLB");
DEF_STR(ROM_REG_CACHE, L"Register caching"); DEF_STR(ROM_REG_CACHE, "Register caching");
DEF_STR(ROM_DELAY_SI, L"Delay SI interrupt"); DEF_STR(ROM_DELAY_SI, "Delay SI interrupt");
DEF_STR(ROM_FAST_SP, L"Fast SP"); DEF_STR(ROM_FAST_SP, "Fast SP");
DEF_STR(ROM_DEFAULT, L"Default"); DEF_STR(ROM_DEFAULT, "Default");
DEF_STR(ROM_AUDIO_SIGNAL, L"RSP audio signal"); DEF_STR(ROM_AUDIO_SIGNAL, "RSP audio signal");
DEF_STR(ROM_FIXED_AUDIO, L"Fixed audio timing"); DEF_STR(ROM_FIXED_AUDIO, "Fixed audio timing");
DEF_STR(ROM_FUNC_FIND, L"Function lookup method:"); DEF_STR(ROM_FUNC_FIND, "Function lookup method:");
DEF_STR(ROM_CUSTOM_SMM, L"Custom self mod Method"); DEF_STR(ROM_CUSTOM_SMM, "Custom self mod Method");
DEF_STR(ROM_SYNC_AUDIO, L"Sync using audio"); DEF_STR(ROM_SYNC_AUDIO, "Sync using audio");
DEF_STR(ROM_COUNTPERBYTE, L"AI count per byte:"); DEF_STR(ROM_COUNTPERBYTE, "AI count per byte:");
DEF_STR(ROM_32BIT, L"32-bit engine:"); DEF_STR(ROM_32BIT, "32-bit engine:");
DEF_STR(ROM_DELAY_DP, L"Delay DP interrupt:"); DEF_STR(ROM_DELAY_DP, "Delay DP interrupt:");
//Core Styles //Core Styles
DEF_STR(CORE_INTERPTER, L"Interpreter"); DEF_STR(CORE_INTERPTER, "Interpreter");
DEF_STR(CORE_RECOMPILER, L"Recompiler"); DEF_STR(CORE_RECOMPILER, "Recompiler");
DEF_STR(CORE_SYNC, L"Synchronize cores"); DEF_STR(CORE_SYNC, "Synchronize cores");
//Self Mod Methods //Self Mod Methods
DEF_STR(SMCM_NONE, L"None"); DEF_STR(SMCM_NONE, "None");
DEF_STR(SMCM_CACHE, L"Cache"); DEF_STR(SMCM_CACHE, "Cache");
DEF_STR(SMCM_PROECTED, L"Protect memory"); DEF_STR(SMCM_PROECTED, "Protect memory");
DEF_STR(SMCM_CHECK_MEM, L"Check memory & cache"); DEF_STR(SMCM_CHECK_MEM, "Check memory & cache");
DEF_STR(SMCM_CHANGE_MEM, L"Change memory & cache"); DEF_STR(SMCM_CHANGE_MEM, "Change memory & cache");
DEF_STR(SMCM_CHECK_ADV, L"Check memory advance"); DEF_STR(SMCM_CHECK_ADV, "Check memory advance");
DEF_STR(SMCM_CACHE2, L"Clear code on cache"); DEF_STR(SMCM_CACHE2, "Clear code on cache");
//Function Lookup method //Function Lookup method
DEF_STR(FLM_PLOOKUP, L"Physical lookup table"); DEF_STR(FLM_PLOOKUP, "Physical lookup table");
DEF_STR(FLM_VLOOKUP, L"Virtual lookup table"); DEF_STR(FLM_VLOOKUP, "Virtual lookup table");
DEF_STR(FLM_CHANGEMEM, L"Change memory"); DEF_STR(FLM_CHANGEMEM, "Change memory");
//RDRAM Size //RDRAM Size
DEF_STR(RDRAM_4MB, L"4 MB"); DEF_STR(RDRAM_4MB, "4 MB");
DEF_STR(RDRAM_8MB, L"8 MB"); DEF_STR(RDRAM_8MB, "8 MB");
//Advanced Block Linking //Advanced Block Linking
DEF_STR(ABL_ON, L"On"); DEF_STR(ABL_ON, "On");
DEF_STR(ABL_OFF, L"Off"); DEF_STR(ABL_OFF, "Off");
//Save Type //Save Type
DEF_STR(SAVE_FIRST_USED, L"Use first-used save type"); DEF_STR(SAVE_FIRST_USED, "Use first-used save type");
DEF_STR(SAVE_4K_EEPROM, L"4-kbit EEPROM"); DEF_STR(SAVE_4K_EEPROM, "4-kbit EEPROM");
DEF_STR(SAVE_16K_EEPROM, L"16-kbit EEPROM"); DEF_STR(SAVE_16K_EEPROM, "16-kbit EEPROM");
DEF_STR(SAVE_SRAM, L"SRAM"); DEF_STR(SAVE_SRAM, "SRAM");
DEF_STR(SAVE_FLASHRAM, L"Flash RAM"); DEF_STR(SAVE_FLASHRAM, "Flash RAM");
//Shell Integration Tab //Shell Integration Tab
DEF_STR(SHELL_TEXT, L"File extension association:"); DEF_STR(SHELL_TEXT, "File extension association:");
//ROM Notes //ROM Notes
DEF_STR(NOTE_STATUS, L"ROM status:"); DEF_STR(NOTE_STATUS, "ROM status:");
DEF_STR(NOTE_CORE, L"Core note:"); DEF_STR(NOTE_CORE, "Core note:");
DEF_STR(NOTE_PLUGIN, L"Plugin note:"); DEF_STR(NOTE_PLUGIN, "Plugin note:");
// Accelerator Selector // Accelerator Selector
DEF_STR(ACCEL_CPUSTATE_TITLE, L"CPU state:"); DEF_STR(ACCEL_CPUSTATE_TITLE, "CPU state:");
DEF_STR(ACCEL_MENUITEM_TITLE, L"Menu item:"); DEF_STR(ACCEL_MENUITEM_TITLE, "Menu item:");
DEF_STR(ACCEL_CURRENTKEYS_TITLE, L"Current keys:"); DEF_STR(ACCEL_CURRENTKEYS_TITLE, "Current keys:");
DEF_STR(ACCEL_SELKEY_TITLE, L"Select new shortcut key:"); DEF_STR(ACCEL_SELKEY_TITLE, "Select new shortcut key:");
DEF_STR(ACCEL_ASSIGNEDTO_TITLE, L"Currently assigned to:"); DEF_STR(ACCEL_ASSIGNEDTO_TITLE, "Currently assigned to:");
DEF_STR(ACCEL_ASSIGN_BTN, L"Assign"); DEF_STR(ACCEL_ASSIGN_BTN, "Assign");
DEF_STR(ACCEL_REMOVE_BTN, L"Remove"); DEF_STR(ACCEL_REMOVE_BTN, "Remove");
DEF_STR(ACCEL_RESETALL_BTN, L"Reset all"); DEF_STR(ACCEL_RESETALL_BTN, "Reset all");
DEF_STR(ACCEL_CPUSTATE_1, L"Game not playing"); DEF_STR(ACCEL_CPUSTATE_1, "Game not playing");
DEF_STR(ACCEL_CPUSTATE_2, L"Game playing"); DEF_STR(ACCEL_CPUSTATE_2, "Game playing");
DEF_STR(ACCEL_CPUSTATE_3, L"Game playing (windowed)"); DEF_STR(ACCEL_CPUSTATE_3, "Game playing (windowed)");
DEF_STR(ACCEL_CPUSTATE_4, L"Game playing (full-screen)"); DEF_STR(ACCEL_CPUSTATE_4, "Game playing (full-screen)");
DEF_STR(ACCEL_DETECTKEY, L"Detect Key"); DEF_STR(ACCEL_DETECTKEY, "Detect Key");
// Frame Rate Option // Frame Rate Option
DEF_STR(STR_FR_VIS, L"Vertical interrupts per second"); DEF_STR(STR_FR_VIS, "Vertical interrupts per second");
DEF_STR(STR_FR_DLS, L"Display lists per second"); DEF_STR(STR_FR_DLS, "Display lists per second");
DEF_STR(STR_FR_PERCENT, L"Percentage of full speed"); DEF_STR(STR_FR_PERCENT, "Percentage of full speed");
// Increase speed // Increase speed
DEF_STR(STR_INSREASE_SPEED, L"Increase Game Speed"); DEF_STR(STR_INSREASE_SPEED, "Increase Game Speed");
DEF_STR(STR_DECREASE_SPEED, L"Decrease Game Speed"); DEF_STR(STR_DECREASE_SPEED, "Decrease Game Speed");
//Bottom page buttons //Bottom page buttons
DEF_STR(BOTTOM_RESET_PAGE, L"Reset Page"); DEF_STR(BOTTOM_RESET_PAGE, "Reset Page");
DEF_STR(BOTTOM_RESET_ALL, L"Reset All"); DEF_STR(BOTTOM_RESET_ALL, "Reset All");
DEF_STR(BOTTOM_APPLY, L"Apply"); DEF_STR(BOTTOM_APPLY, "Apply");
DEF_STR(BOTTOM_CLOSE, L"Close"); DEF_STR(BOTTOM_CLOSE, "Close");
/********************************************************************************* /*********************************************************************************
* ROM Information * * ROM Information *
*********************************************************************************/ *********************************************************************************/
//ROM Info Title //ROM Info Title
DEF_STR(INFO_TITLE, L"ROM Information"); DEF_STR(INFO_TITLE, "ROM Information");
//ROM Info Text //ROM Info Text
DEF_STR(INFO_ROM_NAME_TEXT, L"ROM name:"); DEF_STR(INFO_ROM_NAME_TEXT, "ROM name:");
DEF_STR(INFO_FILE_NAME_TEXT, L"File name:"); DEF_STR(INFO_FILE_NAME_TEXT, "File name:");
DEF_STR(INFO_LOCATION_TEXT, L"Location:"); DEF_STR(INFO_LOCATION_TEXT, "Location:");
DEF_STR(INFO_SIZE_TEXT, L"ROM size:"); DEF_STR(INFO_SIZE_TEXT, "ROM size:");
DEF_STR(INFO_CART_ID_TEXT, L"Cartridge ID:"); DEF_STR(INFO_CART_ID_TEXT, "Cartridge ID:");
DEF_STR(INFO_MANUFACTURER_TEXT, L"Manufacturer:"); DEF_STR(INFO_MANUFACTURER_TEXT, "Manufacturer:");
DEF_STR(INFO_COUNTRY_TEXT, L"Country:"); DEF_STR(INFO_COUNTRY_TEXT, "Country:");
DEF_STR(INFO_CRC1_TEXT, L"CRC1:"); DEF_STR(INFO_CRC1_TEXT, "CRC1:");
DEF_STR(INFO_CRC2_TEXT, L"CRC2:"); DEF_STR(INFO_CRC2_TEXT, "CRC2:");
DEF_STR(INFO_CIC_CHIP_TEXT, L"CIC chip:"); DEF_STR(INFO_CIC_CHIP_TEXT, "CIC chip:");
DEF_STR(INFO_MD5_TEXT, L"MD5:"); DEF_STR(INFO_MD5_TEXT, "MD5:");
/********************************************************************************* /*********************************************************************************
* Cheats * * Cheats *
*********************************************************************************/ *********************************************************************************/
//Cheat List //Cheat List
DEF_STR(CHEAT_TITLE, L"Cheats"); DEF_STR(CHEAT_TITLE, "Cheats");
DEF_STR(CHEAT_LIST_FRAME, L"Cheats:"); DEF_STR(CHEAT_LIST_FRAME, "Cheats:");
DEF_STR(CHEAT_NOTES_FRAME, L" Notes: "); DEF_STR(CHEAT_NOTES_FRAME, " Notes: ");
DEF_STR(CHEAT_MARK_ALL, L"Mark All"); DEF_STR(CHEAT_MARK_ALL, "Mark All");
DEF_STR(CHEAT_MARK_NONE, L"Unmark All"); DEF_STR(CHEAT_MARK_NONE, "Unmark All");
//Add Cheat //Add Cheat
DEF_STR(CHEAT_ADDCHEAT_FRAME, L"Add Cheat"); DEF_STR(CHEAT_ADDCHEAT_FRAME, "Add Cheat");
DEF_STR(CHEAT_ADDCHEAT_NAME, L"Name:"); DEF_STR(CHEAT_ADDCHEAT_NAME, "Name:");
DEF_STR(CHEAT_ADDCHEAT_CODE, L"Code:"); DEF_STR(CHEAT_ADDCHEAT_CODE, "Code:");
DEF_STR(CHEAT_ADDCHEAT_INSERT, L"Insert"); DEF_STR(CHEAT_ADDCHEAT_INSERT, "Insert");
DEF_STR(CHEAT_ADDCHEAT_CLEAR, L"Clear"); DEF_STR(CHEAT_ADDCHEAT_CLEAR, "Clear");
DEF_STR(CHEAT_ADDCHEAT_NOTES, L" Cheat Notes: "); DEF_STR(CHEAT_ADDCHEAT_NOTES, " Cheat Notes: ");
DEF_STR(CHEAT_ADD_TO_DB, L"Add to DB"); DEF_STR(CHEAT_ADD_TO_DB, "Add to DB");
//Code extension //Code extension
DEF_STR(CHEAT_CODE_EXT_TITLE, L"Code Extensions"); DEF_STR(CHEAT_CODE_EXT_TITLE, "Code Extensions");
DEF_STR(CHEAT_CODE_EXT_TXT, L"Please choose a value to be used for:"); DEF_STR(CHEAT_CODE_EXT_TXT, "Please choose a value to be used for:");
DEF_STR(CHEAT_OK, L"OK"); DEF_STR(CHEAT_OK, "OK");
DEF_STR(CHEAT_CANCEL, L"Cancel"); DEF_STR(CHEAT_CANCEL, "Cancel");
//Digital Value //Digital Value
DEF_STR(CHEAT_QUANTITY_TITLE, L"Quantity Digit"); DEF_STR(CHEAT_QUANTITY_TITLE, "Quantity Digit");
DEF_STR(CHEAT_CHOOSE_VALUE, L"Please choose a value for:"); DEF_STR(CHEAT_CHOOSE_VALUE, "Please choose a value for:");
DEF_STR(CHEAT_VALUE, L"&Value"); DEF_STR(CHEAT_VALUE, "&Value");
DEF_STR(CHEAT_FROM, L"from"); DEF_STR(CHEAT_FROM, "from");
DEF_STR(CHEAT_TO, L"to"); DEF_STR(CHEAT_TO, "to");
DEF_STR(CHEAT_NOTES, L"&Notes:"); DEF_STR(CHEAT_NOTES, "&Notes:");
DEF_STR(CHEAT_ADDCHEAT_ADD, L"Add Cheat"); DEF_STR(CHEAT_ADDCHEAT_ADD, "Add Cheat");
DEF_STR(CHEAT_ADDCHEAT_NEW, L"New Cheat"); DEF_STR(CHEAT_ADDCHEAT_NEW, "New Cheat");
DEF_STR(CHEAT_ADDCHEAT_CODEDES, L"<address> <value>"); DEF_STR(CHEAT_ADDCHEAT_CODEDES, "<address> <value>");
DEF_STR(CHEAT_ADDCHEAT_OPT, L"Options:"); DEF_STR(CHEAT_ADDCHEAT_OPT, "Options:");
DEF_STR(CHEAT_ADDCHEAT_OPTDES, L"<value> <label>"); DEF_STR(CHEAT_ADDCHEAT_OPTDES, "<value> <label>");
//Edit Cheat //Edit Cheat
DEF_STR(CHEAT_EDITCHEAT_WINDOW, L"Edit Cheat"); DEF_STR(CHEAT_EDITCHEAT_WINDOW, "Edit Cheat");
DEF_STR(CHEAT_EDITCHEAT_UPDATE, L"Update Cheat"); DEF_STR(CHEAT_EDITCHEAT_UPDATE, "Update Cheat");
DEF_STR(CHEAT_CHANGED_MSG, L"Cheat has been changed.\n\nDo you want to update?"); DEF_STR(CHEAT_CHANGED_MSG, "Cheat has been changed.\n\nDo you want to update?");
DEF_STR(CHEAT_CHANGED_TITLE, L"Cheat updated"); DEF_STR(CHEAT_CHANGED_TITLE, "Cheat updated");
//Cheat Popup Menu //Cheat Popup Menu
DEF_STR(CHEAT_ADDNEW, L"Add New Cheat..."); DEF_STR(CHEAT_ADDNEW, "Add New Cheat...");
DEF_STR(CHEAT_EDIT, L"Edit"); DEF_STR(CHEAT_EDIT, "Edit");
DEF_STR(CHEAT_DELETE, L"Delete"); DEF_STR(CHEAT_DELETE, "Delete");
// short-cut editor // short-cut editor
DEF_STR(STR_SHORTCUT_RESET_TITLE, L"Reset short-cuts"); DEF_STR(STR_SHORTCUT_RESET_TITLE, "Reset short-cuts");
DEF_STR(STR_SHORTCUT_RESET_TEXT, L"Are you sure you want to reset the short-cuts?\n\nThis action cannot be undone."); DEF_STR(STR_SHORTCUT_RESET_TEXT, "Are you sure you want to reset the short-cuts?\n\nThis action cannot be undone.");
DEF_STR(STR_SHORTCUT_FILEMENU, L"File Menu"); DEF_STR(STR_SHORTCUT_FILEMENU, "File Menu");
DEF_STR(STR_SHORTCUT_SYSTEMMENU, L"System Menu"); DEF_STR(STR_SHORTCUT_SYSTEMMENU, "System Menu");
DEF_STR(STR_SHORTCUT_OPTIONS, L"Options"); DEF_STR(STR_SHORTCUT_OPTIONS, "Options");
DEF_STR(STR_SHORTCUT_SAVESLOT, L"Save Slots"); DEF_STR(STR_SHORTCUT_SAVESLOT, "Save Slots");
/********************************************************************************* /*********************************************************************************
* Messages * * Messages *
*********************************************************************************/ *********************************************************************************/
DEF_STR(MSG_CPU_PAUSED, L"*** CPU PAUSED ***"); DEF_STR(MSG_CPU_PAUSED, "*** CPU PAUSED ***");
DEF_STR(MSG_CPU_RESUMED, L"CPU resumed"); DEF_STR(MSG_CPU_RESUMED, "CPU resumed");
DEF_STR(MSG_PERM_LOOP, L"In a permanent loop that cannot be exited.\nEmulation will now stop.\n\nVerify ROM and its settings."); DEF_STR(MSG_PERM_LOOP, "In a permanent loop that cannot be exited.\nEmulation will now stop.\n\nVerify ROM and its settings.");
DEF_STR(MSG_MEM_ALLOC_ERROR, L"Failed to allocate memory"); DEF_STR(MSG_MEM_ALLOC_ERROR, "Failed to allocate memory");
DEF_STR(MSG_FAIL_INIT_GFX, L"The default or selected video plugin is missing or invalid.\n\nYou need to go into Settings and select a video (graphics) plugin.\nCheck that you have at least one compatible plugin file in your plugin folder."); DEF_STR(MSG_FAIL_INIT_GFX, "The default or selected video plugin is missing or invalid.\n\nYou need to go into Settings and select a video (graphics) plugin.\nCheck that you have at least one compatible plugin file in your plugin folder.");
DEF_STR(MSG_FAIL_INIT_AUDIO, L"The default or selected audio plugin is missing or invalid.\n\nYou need to go into Settings and select a audio (sound) plugin.\nCheck that you have at least one compatible plugin file in your plugin folder."); DEF_STR(MSG_FAIL_INIT_AUDIO, "The default or selected audio plugin is missing or invalid.\n\nYou need to go into Settings and select a audio (sound) plugin.\nCheck that you have at least one compatible plugin file in your plugin folder.");
DEF_STR(MSG_FAIL_INIT_RSP, L"The default or selected RSP plugin is missing or invalid.\n\nYou need to go into Settings and select a RSP (Reality Signal Processor) plugin.\nCheck that you have at least one compatible plugin file in your plugin folder."); DEF_STR(MSG_FAIL_INIT_RSP, "The default or selected RSP plugin is missing or invalid.\n\nYou need to go into Settings and select a RSP (Reality Signal Processor) plugin.\nCheck that you have at least one compatible plugin file in your plugin folder.");
DEF_STR(MSG_FAIL_INIT_CONTROL, L"The default or selected input plugin is missing or invalid.\n\nYou need to go into Settings and select an input (controller) plugin.\nCheck that you have at least one compatible plugin file in your plugin folder."); DEF_STR(MSG_FAIL_INIT_CONTROL, "The default or selected input plugin is missing or invalid.\n\nYou need to go into Settings and select an input (controller) plugin.\nCheck that you have at least one compatible plugin file in your plugin folder.");
DEF_STR(MSG_FAIL_LOAD_PLUGIN, L"Failed to load plugin:"); DEF_STR(MSG_FAIL_LOAD_PLUGIN, "Failed to load plugin:");
DEF_STR(MSG_FAIL_LOAD_WORD, L"Failed to load word.\n\nVerify ROM and its settings."); DEF_STR(MSG_FAIL_LOAD_WORD, "Failed to load word.\n\nVerify ROM and its settings.");
DEF_STR(MSG_FAIL_OPEN_SAVE, L"Failed to open save file"); DEF_STR(MSG_FAIL_OPEN_SAVE, "Failed to open save file");
DEF_STR(MSG_FAIL_OPEN_EEPROM, L"Failed to open EEPROM"); DEF_STR(MSG_FAIL_OPEN_EEPROM, "Failed to open EEPROM");
DEF_STR(MSG_FAIL_OPEN_FLASH, L"Failed to open flash RAM"); DEF_STR(MSG_FAIL_OPEN_FLASH, "Failed to open flash RAM");
DEF_STR(MSG_FAIL_OPEN_MEMPAK, L"Failed to open mempak"); DEF_STR(MSG_FAIL_OPEN_MEMPAK, "Failed to open mempak");
DEF_STR(MSG_FAIL_OPEN_ZIP, L"Attempt to open zip file failed.\n\nProbably a corrupt zip file - try unzipping ROM manually."); DEF_STR(MSG_FAIL_OPEN_ZIP, "Attempt to open zip file failed.\n\nProbably a corrupt zip file - try unzipping ROM manually.");
DEF_STR(MSG_FAIL_OPEN_IMAGE, L"Attempt to open file failed."); DEF_STR(MSG_FAIL_OPEN_IMAGE, "Attempt to open file failed.");
DEF_STR(MSG_FAIL_ZIP, L"Error occurred when trying to open zip file."); DEF_STR(MSG_FAIL_ZIP, "Error occurred when trying to open zip file.");
DEF_STR(MSG_FAIL_IMAGE, L"File loaded does not appear to be a valid N64 ROM.\n\nVerify your ROMs with GoodN64."); DEF_STR(MSG_FAIL_IMAGE, "File loaded does not appear to be a valid N64 ROM.\n\nVerify your ROMs with GoodN64.");
DEF_STR(MSG_UNKNOWN_COUNTRY, L"Unknown country"); DEF_STR(MSG_UNKNOWN_COUNTRY, "Unknown country");
DEF_STR(MSG_UNKNOWN_CIC_CHIP, L"Unknown CIC chip"); DEF_STR(MSG_UNKNOWN_CIC_CHIP, "Unknown CIC chip");
DEF_STR(MSG_UNKNOWN_FILE_FORMAT, L"Unknown file format"); DEF_STR(MSG_UNKNOWN_FILE_FORMAT, "Unknown file format");
DEF_STR(MSG_UNKNOWN_MEM_ACTION, L"Unknown memory action\n\nEmulation stopped"); DEF_STR(MSG_UNKNOWN_MEM_ACTION, "Unknown memory action\n\nEmulation stopped");
DEF_STR(MSG_UNHANDLED_OP, L"Unhandled R4300i opcode at"); DEF_STR(MSG_UNHANDLED_OP, "Unhandled R4300i opcode at");
DEF_STR(MSG_NONMAPPED_SPACE, L"Executing from non-mapped space.\n\nVerify ROM and its settings."); DEF_STR(MSG_NONMAPPED_SPACE, "Executing from non-mapped space.\n\nVerify ROM and its settings.");
DEF_STR(MSG_SAVE_STATE_HEADER, L"This saved state does not appear to match the running ROM.\n\nStates must be saved & loaded between 100% identical ROMs.\nIn particular, the REGION and VERSION need to be the same.\nLoading this state is likely to cause the game and/or emulator to crash.\n\nAre you sure you want to continue loading?"); DEF_STR(MSG_SAVE_STATE_HEADER, "This saved state does not appear to match the running ROM.\n\nStates must be saved & loaded between 100% identical ROMs.\nIn particular, the REGION and VERSION need to be the same.\nLoading this state is likely to cause the game and/or emulator to crash.\n\nAre you sure you want to continue loading?");
DEF_STR(MSG_MSGBOX_TITLE, L"Error"); DEF_STR(MSG_MSGBOX_TITLE, "Error");
DEF_STR(MSG_PIF2_ERROR, L"Copyright sequence not found in LUT. Game will no longer function."); DEF_STR(MSG_PIF2_ERROR, "Copyright sequence not found in LUT. Game will no longer function.");
DEF_STR(MSG_PIF2_TITLE, L"Copy Protection Failure"); DEF_STR(MSG_PIF2_TITLE, "Copy Protection Failure");
DEF_STR(MSG_PLUGIN_CHANGE, L"Changing a plugin requires Project64 to reset a running ROM.\nIf you don't want to lose your place, answer No and save the current state first.\n\nChange plugins and reset ROM now?"); DEF_STR(MSG_PLUGIN_CHANGE, "Changing a plugin requires Project64 to reset a running ROM.\nIf you don't want to lose your place, answer No and save the current state first.\n\nChange plugins and reset ROM now?");
DEF_STR(MSG_PLUGIN_CHANGE_TITLE, L"Change Plugins"); DEF_STR(MSG_PLUGIN_CHANGE_TITLE, "Change Plugins");
DEF_STR(MSG_EMULATION_ENDED, L"Emulation ended"); DEF_STR(MSG_EMULATION_ENDED, "Emulation ended");
DEF_STR(MSG_EMULATION_STARTED, L"Emulation started"); DEF_STR(MSG_EMULATION_STARTED, "Emulation started");
DEF_STR(MSG_UNABLED_LOAD_STATE, L"Unable to load state"); DEF_STR(MSG_UNABLED_LOAD_STATE, "Unable to load state");
DEF_STR(MSG_LOADED_STATE, L"Loaded state"); DEF_STR(MSG_LOADED_STATE, "Loaded state");
DEF_STR(MSG_SAVED_STATE, L"Saved current state to"); DEF_STR(MSG_SAVED_STATE, "Saved current state to");
DEF_STR(MSG_SAVE_SLOT, L"State slot"); DEF_STR(MSG_SAVE_SLOT, "State slot");
DEF_STR(MSG_BYTESWAP, L"Byte-swapping image"); DEF_STR(MSG_BYTESWAP, "Byte-swapping image");
DEF_STR(MSG_CHOOSE_IMAGE, L"Choosing N64 image"); DEF_STR(MSG_CHOOSE_IMAGE, "Choosing N64 image");
DEF_STR(MSG_LOADED, L"Loaded"); DEF_STR(MSG_LOADED, "Loaded");
DEF_STR(MSG_LOADING, L"Loading image"); DEF_STR(MSG_LOADING, "Loading image");
DEF_STR(MSG_PLUGIN_NOT_INIT, L"Cannot open a ROM because plugins have not successfully initialized."); DEF_STR(MSG_PLUGIN_NOT_INIT, "Cannot open a ROM because plugins have not successfully initialized.");
DEF_STR(MSG_DEL_SURE, L"Are you sure you really want to delete this?"); DEF_STR(MSG_DEL_SURE, "Are you sure you really want to delete this?");
DEF_STR(MSG_DEL_TITLE, L"Delete Cheat"); DEF_STR(MSG_DEL_TITLE, "Delete Cheat");
DEF_STR(MSG_CHEAT_NAME_IN_USE, L"Cheat name is already in use."); DEF_STR(MSG_CHEAT_NAME_IN_USE, "Cheat name is already in use.");
DEF_STR(MSG_MAX_CHEATS, L"You have reached the maximum amount of cheats for this ROM."); DEF_STR(MSG_MAX_CHEATS, "You have reached the maximum amount of cheats for this ROM.");
DEF_STR(MSG_PLUGIN_INIT, L"Plugin initializing"); DEF_STR(MSG_PLUGIN_INIT, "Plugin initializing");
DEF_STR(MSG_NO_SHORTCUT_SEL, L"You have not selected a virtual key to assign to the menu item."); DEF_STR(MSG_NO_SHORTCUT_SEL, "You have not selected a virtual key to assign to the menu item.");
DEF_STR(MSG_NO_MENUITEM_SEL, L"You need to select a menu item to assign this key to."); DEF_STR(MSG_NO_MENUITEM_SEL, "You need to select a menu item to assign this key to.");
DEF_STR(MSG_MENUITEM_ASSIGNED, L"Short-cut has already been assigned to another menu item."); DEF_STR(MSG_MENUITEM_ASSIGNED, "Short-cut has already been assigned to another menu item.");
DEF_STR(MSG_NO_SEL_SHORTCUT, L"No shortcut has been selected to be removed."); DEF_STR(MSG_NO_SEL_SHORTCUT, "No shortcut has been selected to be removed.");
DEF_STR(MSG_WAITING_FOR_START, L"ROM loaded. Waiting for emulation to start."); DEF_STR(MSG_WAITING_FOR_START, "ROM loaded. Waiting for emulation to start.");
DEF_STR(MSG_INVALID_EXE, L"Project64 beta versions are for members only.\n\nIf you have an account at www.pj64-emu.com, you should not be seeing this error!!\nPlease contact us on the site."); DEF_STR(MSG_INVALID_EXE, "Project64 beta versions are for members only.\n\nIf you have an account at www.pj64-emu.com, you should not be seeing this error!!\nPlease contact us on the site.");
DEF_STR(MSG_INVALID_EXE_TITLE, L"Program Error"); DEF_STR(MSG_INVALID_EXE_TITLE, "Program Error");
DEF_STR(MSG_7Z_FILE_NOT_FOUND, L"Failed to find filename in 7z file"); DEF_STR(MSG_7Z_FILE_NOT_FOUND, "Failed to find filename in 7z file");
DEF_STR(MSG_SET_LLE_GFX_TITLE, L"Graphics Low-Level Emulation"); DEF_STR(MSG_SET_LLE_GFX_TITLE, "Graphics Low-Level Emulation");
DEF_STR(MSG_SET_LLE_GFX_MSG, L"Graphics LLE is not for general use!!!\nIt is advisable that you only use this for testing and not for playing games.\n\nChange to graphics LLE?"); DEF_STR(MSG_SET_LLE_GFX_MSG, "Graphics LLE is not for general use!!!\nIt is advisable that you only use this for testing and not for playing games.\n\nChange to graphics LLE?");
DEF_STR(MSG_SET_HLE_AUD_TITLE, L"Audio High-Level Emulation"); DEF_STR(MSG_SET_HLE_AUD_TITLE, "Audio High-Level Emulation");
DEF_STR(MSG_SET_HLE_AUD_MSG, L"Audio HLE requires a third-party plugin!!!\nIf you do not use a third-party audio plugin that supports HLE, you will hear no sound.\n\nChange to audio HLE?"); DEF_STR(MSG_SET_HLE_AUD_MSG, "Audio HLE requires a third-party plugin!!!\nIf you do not use a third-party audio plugin that supports HLE, you will hear no sound.\n\nChange to audio HLE?");
} }
CLanguage::CLanguage() : CLanguage::CLanguage() :
m_emptyString(L""), m_emptyString(""),
m_LanguageLoaded(false) m_LanguageLoaded(false)
{ {
LoadDefaultStrings(); LoadDefaultStrings();
if (g_Settings) if (g_Settings)
{ {
m_SelectedLanguage = g_Settings->LoadStringVal(Setting_CurrentLanguage).ToUTF16(); m_SelectedLanguage = g_Settings->LoadStringVal(Setting_CurrentLanguage);
} }
} }
@ -588,7 +588,7 @@ LanguageList & CLanguage::GetLangList(void)
return m_LanguageList; return m_LanguageList;
} }
const std::wstring & CLanguage::GetString(LanguageStringID StringID) const std::string & CLanguage::GetString(LanguageStringID StringID)
{ {
LANG_STRINGS::iterator CurrentString = m_CurrentStrings.find(StringID); LANG_STRINGS::iterator CurrentString = m_CurrentStrings.find(StringID);
if (CurrentString != m_CurrentStrings.end()) if (CurrentString != m_CurrentStrings.end())
@ -607,12 +607,12 @@ const std::wstring & CLanguage::GetString(LanguageStringID StringID)
return m_emptyString; return m_emptyString;
} }
std::wstring CLanguage::GetLangString(const char * FileName, LanguageStringID ID) std::string CLanguage::GetLangString(const char * FileName, LanguageStringID ID)
{ {
FILE *file = fopen(FileName, "rb"); FILE *file = fopen(FileName, "rb");
if (file == NULL) if (file == NULL)
{ {
return L""; return "";
} }
//Search for utf8 file marker //Search for utf8 file marker
@ -623,7 +623,7 @@ std::wstring CLanguage::GetLangString(const char * FileName, LanguageStringID ID
utf_bom[2] != 0xBF) utf_bom[2] != 0xBF)
{ {
fclose(file); fclose(file);
return L""; return "";
} }
//String; //String;
@ -637,7 +637,7 @@ std::wstring CLanguage::GetLangString(const char * FileName, LanguageStringID ID
} }
} }
fclose(file); fclose(file);
return L""; return "";
} }
LANG_STR CLanguage::GetNextLangString(void * OpenFile) LANG_STR CLanguage::GetNextLangString(void * OpenFile)
@ -651,7 +651,7 @@ LANG_STR CLanguage::GetNextLangString(void * OpenFile)
//while(token!='#' && !feof(file)) { fread(&token, 1, 1, file); } //while(token!='#' && !feof(file)) { fread(&token, 1, 1, file); }
if (feof(file)) if (feof(file))
{ {
return LANG_STR(0, L""); return LANG_STR(0, "");
} }
//Search for token # //Search for token #
@ -662,7 +662,7 @@ LANG_STR CLanguage::GetNextLangString(void * OpenFile)
} }
if (feof(file)) if (feof(file))
{ {
return LANG_STR(0, L""); return LANG_STR(0, "");
} }
//get StringID after token //get StringID after token
@ -675,7 +675,7 @@ LANG_STR CLanguage::GetNextLangString(void * OpenFile)
} }
if (feof(file)) if (feof(file))
{ {
StringID = EMPTY_STRING; return LANG_STR(0, L""); StringID = EMPTY_STRING; return LANG_STR(0, "");
} }
//Search for start of string '"' //Search for start of string '"'
@ -685,7 +685,7 @@ LANG_STR CLanguage::GetNextLangString(void * OpenFile)
} }
if (feof(file)) if (feof(file))
{ {
StringID = EMPTY_STRING; return LANG_STR(0, L""); StringID = EMPTY_STRING; return LANG_STR(0, "");
} }
int32_t pos = 0; int32_t pos = 0;
@ -702,17 +702,15 @@ LANG_STR CLanguage::GetNextLangString(void * OpenFile)
szString[pos++] = 0; szString[pos++] = 0;
stdstr text(szString); stdstr text(szString);
text.Replace("\\n", "\n"); text.Replace("\\n", "\n");
return LANG_STR(StringID, text.ToUTF16()); return LANG_STR(StringID, text);
} }
void CLanguage::SetLanguage(const wchar_t * LanguageName) void CLanguage::SetLanguage(const char * LanguageName)
{ {
m_SelectedLanguage = LanguageName; m_SelectedLanguage = LanguageName;
if (LoadCurrentStrings()) if (LoadCurrentStrings())
{ {
stdstr Language; g_Settings->SaveString(Setting_CurrentLanguage, LanguageName);
Language.FromUTF16(LanguageName);
g_Settings->SaveString(Setting_CurrentLanguage, Language);
} }
} }
@ -724,3 +722,8 @@ bool CLanguage::IsCurrentLang(LanguageFile & File)
} }
return false; return false;
} }
const std::wstring wGS(LanguageStringID StringID)
{
return stdstr(g_Lang->GetString(StringID)).ToUTF16();
}

18
Source/Project64-core/Multilanguage/LanguageClass.h
View File

@ -16,13 +16,13 @@
#include <list> //stl list #include <list> //stl list
#include <Common/stdtypes.h> #include <Common/stdtypes.h>
typedef std::map<int32_t, std::wstring, std::less<int32_t> > LANG_STRINGS; typedef std::map<int32_t, std::string, std::less<int32_t> > LANG_STRINGS;
typedef LANG_STRINGS::value_type LANG_STR; typedef LANG_STRINGS::value_type LANG_STR;
struct LanguageFile struct LanguageFile
{ {
std::string Filename; std::string Filename;
std::wstring LanguageName; std::string LanguageName;
}; };
typedef std::list<LanguageFile> LanguageList; typedef std::list<LanguageFile> LanguageList;
@ -32,9 +32,9 @@ class CLanguage
public: public:
CLanguage(); CLanguage();
const std::wstring & GetString(LanguageStringID StringID); const std::string & GetString(LanguageStringID StringID);
LanguageList & GetLangList(void); LanguageList & GetLangList(void);
void SetLanguage(const wchar_t * LanguageName); void SetLanguage(const char * LanguageName);
bool LoadCurrentStrings(void); bool LoadCurrentStrings(void);
bool IsCurrentLang(LanguageFile & File); bool IsCurrentLang(LanguageFile & File);
bool IsLanguageLoaded(void) const { return m_LanguageLoaded; } bool IsLanguageLoaded(void) const { return m_LanguageLoaded; }
@ -43,13 +43,13 @@ private:
CLanguage(const CLanguage&); // Disable copy constructor CLanguage(const CLanguage&); // Disable copy constructor
CLanguage& operator=(const CLanguage&); // Disable assignment CLanguage& operator=(const CLanguage&); // Disable assignment
std::wstring m_SelectedLanguage; std::string m_SelectedLanguage;
const std::wstring m_emptyString; const std::string m_emptyString;
LANG_STRINGS m_CurrentStrings, m_DefaultStrings; LANG_STRINGS m_CurrentStrings, m_DefaultStrings;
LanguageList m_LanguageList; LanguageList m_LanguageList;
std::wstring GetLangString(const char * FileName, LanguageStringID ID); std::string GetLangString(const char * FileName, LanguageStringID ID);
LANG_STR GetNextLangString(void * OpenFile); LANG_STR GetNextLangString(void * OpenFile);
void LoadDefaultStrings(void); void LoadDefaultStrings(void);
@ -58,7 +58,9 @@ private:
extern CLanguage * g_Lang; extern CLanguage * g_Lang;
inline const wchar_t * GS(LanguageStringID StringID) const std::wstring wGS(LanguageStringID StringID);
inline const char * GS(LanguageStringID StringID)
{ {
return g_Lang->GetString(StringID).c_str(); return g_Lang->GetString(StringID).c_str();
} }

18
Source/Project64-core/N64System/FramePerSecondClass.cpp
View File

@ -48,7 +48,7 @@ void CFramePerSecond::Reset(bool ClearDisplay)
} }
if (ClearDisplay) if (ClearDisplay)
{ {
g_Notify->DisplayMessage2(L""); g_Notify->DisplayMessage2("");
return; return;
} }
@ -81,7 +81,7 @@ void CFramePerSecond::DisplayViCounter(uint32_t FrameRate)
{ {
if (FrameRate != 0) if (FrameRate != 0)
{ {
g_Notify->DisplayMessage2(stdstr_f("VI/s: %d.00", FrameRate).ToUTF16().c_str()); g_Notify->DisplayMessage2(stdstr_f("VI/s: %d.00", FrameRate).c_str());
} }
else else
{ {
@ -94,11 +94,11 @@ void CFramePerSecond::DisplayViCounter(uint32_t FrameRate)
{ {
Total += m_Frames[count]; Total += m_Frames[count];
} }
g_Notify->DisplayMessage2(stdstr_f("VI/s: %.2f", m_Frequency / ((double)Total / (NoOfFrames << 3))).ToUTF16().c_str()); g_Notify->DisplayMessage2(stdstr_f("VI/s: %.2f", m_Frequency / ((double)Total / (NoOfFrames << 3))).c_str());
} }
else else
{ {
g_Notify->DisplayMessage2(L"VI/s: -.--"); g_Notify->DisplayMessage2("VI/s: -.--");
} }
} }
} }
@ -124,11 +124,11 @@ void CFramePerSecond::DisplayViCounter(uint32_t FrameRate)
} }
else else
{ {
g_Notify->DisplayMessage2(L""); g_Notify->DisplayMessage2("");
return; return;
} }
} }
g_Notify->DisplayMessage2(stdstr_f("%.1f %%", Percent * 100).ToUTF16().c_str()); g_Notify->DisplayMessage2(stdstr_f("%.1f %%", Percent * 100).c_str());
} }
} }
@ -168,7 +168,7 @@ void CFramePerSecond::DisplayDlCounter(uint32_t FrameRate)
} }
if (FrameRate != 0) if (FrameRate != 0)
{ {
g_Notify->DisplayMessage2(stdstr_f("DL/s: %d.00", FrameRate).ToUTF16().c_str()); g_Notify->DisplayMessage2(stdstr_f("DL/s: %d.00", FrameRate).c_str());
} }
else else
{ {
@ -181,11 +181,11 @@ void CFramePerSecond::DisplayDlCounter(uint32_t FrameRate)
{ {
Total += m_Frames[count]; Total += m_Frames[count];
} }
g_Notify->DisplayMessage2(stdstr_f("DL/s: %.1f", m_Frequency / ((double)Total / (NoOfFrames << 2))).ToUTF16().c_str()); g_Notify->DisplayMessage2(stdstr_f("DL/s: %.1f", m_Frequency / ((double)Total / (NoOfFrames << 2))).c_str());
} }
else else
{ {
g_Notify->DisplayMessage2(L"DL/s: -.--"); g_Notify->DisplayMessage2("DL/s: -.--");
} }
} }
} }

12
Source/Project64-core/N64System/Interpreter/InterpreterCPU.cpp
View File

@ -32,7 +32,7 @@ bool DelaySlotEffectsCompare(uint32_t PC, uint32_t Reg1, uint32_t Reg2)
if (!g_MMU->LW_VAddr(PC + 4, Command.Hex)) if (!g_MMU->LW_VAddr(PC + 4, Command.Hex))
{ {
//g_Notify->DisplayError(L"Failed to load word 2"); //g_Notify->DisplayError("Failed to load word 2");
//ExitThread(0); //ExitThread(0);
return true; return true;
} }
@ -96,7 +96,7 @@ bool DelaySlotEffectsCompare(uint32_t PC, uint32_t Reg1, uint32_t Reg2)
default: default:
if (g_Settings->LoadBool(Debugger_Enabled)) if (g_Settings->LoadBool(Debugger_Enabled))
{ {
g_Notify->DisplayError(stdstr_f("Does %s effect Delay slot at %X?", R4300iOpcodeName(Command.Hex, PC + 4), PC).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Does %s effect Delay slot at %X?", R4300iOpcodeName(Command.Hex, PC + 4), PC).c_str());
} }
return true; return true;
} }
@ -127,7 +127,7 @@ bool DelaySlotEffectsCompare(uint32_t PC, uint32_t Reg1, uint32_t Reg2)
default: default:
if (g_Settings->LoadBool(Debugger_Enabled)) if (g_Settings->LoadBool(Debugger_Enabled))
{ {
g_Notify->DisplayError(stdstr_f("Does %s effect Delay slot at %X?\n6", R4300iOpcodeName(Command.Hex, PC + 4), PC).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Does %s effect Delay slot at %X?\n6", R4300iOpcodeName(Command.Hex, PC + 4), PC).c_str());
} }
return true; return true;
} }
@ -136,7 +136,7 @@ bool DelaySlotEffectsCompare(uint32_t PC, uint32_t Reg1, uint32_t Reg2)
{ {
if (g_Settings->LoadBool(Debugger_Enabled)) if (g_Settings->LoadBool(Debugger_Enabled))
{ {
g_Notify->DisplayError(stdstr_f("Does %s effect Delay slot at %X?\n7", R4300iOpcodeName(Command.Hex, PC + 4), PC).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Does %s effect Delay slot at %X?\n7", R4300iOpcodeName(Command.Hex, PC + 4), PC).c_str());
} }
return true; return true;
} }
@ -165,7 +165,7 @@ bool DelaySlotEffectsCompare(uint32_t PC, uint32_t Reg1, uint32_t Reg2)
default: default:
if (g_Settings->LoadBool(Debugger_Enabled)) if (g_Settings->LoadBool(Debugger_Enabled))
{ {
g_Notify->DisplayError(stdstr_f("Does %s effect Delay slot at %X?", R4300iOpcodeName(Command.Hex, PC + 4), PC).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Does %s effect Delay slot at %X?", R4300iOpcodeName(Command.Hex, PC + 4), PC).c_str());
} }
return true; return true;
} }
@ -213,7 +213,7 @@ bool DelaySlotEffectsCompare(uint32_t PC, uint32_t Reg1, uint32_t Reg2)
default: default:
if (g_Settings->LoadBool(Debugger_Enabled)) if (g_Settings->LoadBool(Debugger_Enabled))
{ {
g_Notify->DisplayError(stdstr_f("Does %s effect Delay slot at %X?", R4300iOpcodeName(Command.Hex, PC + 4), PC).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Does %s effect Delay slot at %X?", R4300iOpcodeName(Command.Hex, PC + 4), PC).c_str());
} }
return true; return true;
} }

92
Source/Project64-core/N64System/Interpreter/InterpreterOps.cpp
View File

@ -1021,7 +1021,7 @@ void R4300iOp::LDL()
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
return; return;
} }
@ -1048,7 +1048,7 @@ void R4300iOp::LDR()
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
return; return;
} }
@ -1064,7 +1064,7 @@ void R4300iOp::LB()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1085,7 +1085,7 @@ void R4300iOp::LH()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1107,7 +1107,7 @@ void R4300iOp::LWL()
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
return; return;
} }
@ -1133,7 +1133,7 @@ void R4300iOp::LW()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1150,7 +1150,7 @@ void R4300iOp::LBU()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1171,7 +1171,7 @@ void R4300iOp::LHU()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1193,7 +1193,7 @@ void R4300iOp::LWR()
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
return; return;
} }
@ -1214,7 +1214,7 @@ void R4300iOp::LWU()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1235,7 +1235,7 @@ void R4300iOp::SB()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1255,7 +1255,7 @@ void R4300iOp::SH()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1275,7 +1275,7 @@ void R4300iOp::SWL()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
return; return;
} }
@ -1291,7 +1291,7 @@ void R4300iOp::SWL()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1315,7 +1315,7 @@ void R4300iOp::SW()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1346,7 +1346,7 @@ void R4300iOp::SDL()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
return; return;
} }
@ -1362,7 +1362,7 @@ void R4300iOp::SDL()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1394,7 +1394,7 @@ void R4300iOp::SDR()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
return; return;
} }
@ -1410,7 +1410,7 @@ void R4300iOp::SDR()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1430,7 +1430,7 @@ void R4300iOp::SWR()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
return; return;
} }
@ -1446,7 +1446,7 @@ void R4300iOp::SWR()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1472,7 +1472,7 @@ void R4300iOp::LL()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1495,7 +1495,7 @@ void R4300iOp::LWC1()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1516,7 +1516,7 @@ void R4300iOp::SC()
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1538,7 +1538,7 @@ void R4300iOp::LD()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
return; return;
} }
@ -1567,7 +1567,7 @@ void R4300iOp::LDC1()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1589,7 +1589,7 @@ void R4300iOp::SWC1()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1611,7 +1611,7 @@ void R4300iOp::SDC1()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1631,7 +1631,7 @@ void R4300iOp::SD()
} }
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
} }
} }
@ -1759,7 +1759,7 @@ void R4300iOp::SPECIAL_DIV()
{ {
if (bShowDivByZero()) if (bShowDivByZero())
{ {
g_Notify->DisplayError(L"DIV by 0 ???"); g_Notify->DisplayError("DIV by 0 ???");
} }
_RegLO->DW = 0; _RegLO->DW = 0;
_RegHI->DW = 0; _RegHI->DW = 0;
@ -1777,7 +1777,7 @@ void R4300iOp::SPECIAL_DIVU()
{ {
if (bShowDivByZero()) if (bShowDivByZero())
{ {
g_Notify->DisplayError(L"DIVU by 0 ???"); g_Notify->DisplayError("DIVU by 0 ???");
} }
_RegLO->DW = 0; _RegLO->DW = 0;
_RegHI->DW = 0; _RegHI->DW = 0;
@ -1823,7 +1823,7 @@ void R4300iOp::SPECIAL_DDIV()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(L"DDIV by 0 ???"); g_Notify->DisplayError("DDIV by 0 ???");
} }
} }
} }
@ -1839,7 +1839,7 @@ void R4300iOp::SPECIAL_DDIVU()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(L"DDIVU by 0 ???"); g_Notify->DisplayError("DDIVU by 0 ???");
} }
} }
} }
@ -1938,7 +1938,7 @@ void R4300iOp::SPECIAL_TEQ()
{ {
if (_GPR[m_Opcode.rs].DW == _GPR[m_Opcode.rt].DW && bHaveDebugger()) if (_GPR[m_Opcode.rs].DW == _GPR[m_Opcode.rt].DW && bHaveDebugger())
{ {
g_Notify->DisplayError(L"Should trap this ???"); g_Notify->DisplayError("Should trap this ???");
} }
} }
@ -2168,7 +2168,7 @@ void R4300iOp::COP0_MT()
} }
if ((_CP0[m_Opcode.rd] & 0x18) != 0 && bHaveDebugger()) if ((_CP0[m_Opcode.rd] & 0x18) != 0 && bHaveDebugger())
{ {
g_Notify->DisplayError(L"Left kernel mode ??"); g_Notify->DisplayError("Left kernel mode ??");
} }
g_Reg->CheckInterrupts(); g_Reg->CheckInterrupts();
break; break;
@ -2176,7 +2176,7 @@ void R4300iOp::COP0_MT()
_CP0[m_Opcode.rd] &= 0xFFFFCFF; _CP0[m_Opcode.rd] &= 0xFFFFCFF;
if ((_GPR[m_Opcode.rt].UW[0] & 0x300) != 0 && bHaveDebugger()) if ((_GPR[m_Opcode.rt].UW[0] & 0x300) != 0 && bHaveDebugger())
{ {
g_Notify->DisplayError(L"Set IP0 or IP1"); g_Notify->DisplayError("Set IP0 or IP1");
} }
break; break;
default: default:
@ -2259,7 +2259,7 @@ void R4300iOp::COP1_CF()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(L"CFC1 what register are you writing to ?"); g_Notify->DisplayError("CFC1 what register are you writing to ?");
} }
return; return;
} }
@ -2294,7 +2294,7 @@ void R4300iOp::COP1_CT()
} }
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(L"CTC1 what register are you writing to ?"); g_Notify->DisplayError("CTC1 what register are you writing to ?");
} }
} }
@ -2554,7 +2554,7 @@ void R4300iOp::COP1_S_CMP()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(__FUNCTIONW__ L": Nan ?"); g_Notify->DisplayError(__FUNCTION__ ": Nan ?");
} }
less = false; less = false;
equal = false; equal = false;
@ -2563,7 +2563,7 @@ void R4300iOp::COP1_S_CMP()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("Signal InvalidOperationException\nin r4300i_COP1_S_CMP\n%X %ff\n%X %ff", Temp0, Temp0, Temp1, Temp1).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Signal InvalidOperationException\nin r4300i_COP1_S_CMP\n%X %ff\n%X %ff", Temp0, Temp0, Temp1, Temp1).c_str());
} }
} }
} }
@ -2765,7 +2765,7 @@ void R4300iOp::COP1_D_CMP()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(__FUNCTIONW__ L": Nan ?"); g_Notify->DisplayError(__FUNCTION__ ": Nan ?");
} }
less = false; less = false;
equal = false; equal = false;
@ -2774,7 +2774,7 @@ void R4300iOp::COP1_D_CMP()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(L"Signal InvalidOperationException\nin " __FUNCTIONW__); g_Notify->DisplayError("Signal InvalidOperationException\nin " __FUNCTION__);
} }
} }
} }
@ -2832,7 +2832,7 @@ void R4300iOp::COP1_L_CVT_D()
void R4300iOp::UnknownOpcode() void R4300iOp::UnknownOpcode()
{ {
g_Notify->DisplayError(stdstr_f("%s: %08X\n%s\n\nStopping Emulation !", GS(MSG_UNHANDLED_OP), (*_PROGRAM_COUNTER), g_Notify->DisplayError(stdstr_f("%s: %08X\n%s\n\nStopping Emulation !", GS(MSG_UNHANDLED_OP), (*_PROGRAM_COUNTER),
R4300iOpcodeName(m_Opcode.Hex, (*_PROGRAM_COUNTER))).ToUTF16().c_str()); R4300iOpcodeName(m_Opcode.Hex, (*_PROGRAM_COUNTER))).c_str());
g_System->m_EndEmulation = true; g_System->m_EndEmulation = true;
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
@ -2841,12 +2841,12 @@ void R4300iOp::UnknownOpcode()
{ {
int32_t response; int32_t response;
strcat(Message,"\n\nDo you wish to enter the debugger ?"); strcat(Message, "\n\nDo you wish to enter the debugger ?");
response = MessageBox(NULL,Message,GS(MSG_MSGBOX_TITLE), MB_YESNO | MB_ICONERROR ); response = MessageBox(NULL, Message, GS(MSG_MSGBOX_TITLE), MB_YESNO | MB_ICONERROR);
if (response == IDYES) if (response == IDYES)
{ {
Enter_R4300i_Commands_Window (); Enter_R4300i_Commands_Window();
} }
ExitThread(0); ExitThread(0);
} }

26
Source/Project64-core/N64System/Interpreter/InterpreterOps32.cpp
View File

@ -895,7 +895,7 @@ void R4300iOp32::LB()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -916,7 +916,7 @@ void R4300iOp32::LH()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -937,7 +937,7 @@ void R4300iOp32::LWL()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
return; return;
@ -964,7 +964,7 @@ void R4300iOp32::LW()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -981,7 +981,7 @@ void R4300iOp32::LBU()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1002,7 +1002,7 @@ void R4300iOp32::LHU()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1024,7 +1024,7 @@ void R4300iOp32::LWR()
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
return; return;
} }
@ -1045,7 +1045,7 @@ void R4300iOp32::LWU()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1067,7 +1067,7 @@ void R4300iOp32::LL()
{ {
if (bShowTLBMisses()) if (bShowTLBMisses())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
} }
TLB_READ_EXCEPTION(Address); TLB_READ_EXCEPTION(Address);
} }
@ -1186,7 +1186,7 @@ void R4300iOp32::SPECIAL_TEQ()
{ {
if (_GPR[m_Opcode.rs].W[0] == _GPR[m_Opcode.rt].W[0] && g_Settings->LoadBool(Debugger_Enabled)) if (_GPR[m_Opcode.rs].W[0] == _GPR[m_Opcode.rt].W[0] && g_Settings->LoadBool(Debugger_Enabled))
{ {
g_Notify->DisplayError(L"Should trap this ???"); g_Notify->DisplayError("Should trap this ???");
} }
} }
@ -1397,7 +1397,7 @@ void R4300iOp32::COP0_MT()
} }
if ((_CP0[m_Opcode.rd] & 0x18) != 0 && g_Settings->LoadBool(Debugger_Enabled)) if ((_CP0[m_Opcode.rd] & 0x18) != 0 && g_Settings->LoadBool(Debugger_Enabled))
{ {
g_Notify->DisplayError(L"Left kernel mode ??"); g_Notify->DisplayError("Left kernel mode ??");
} }
g_Reg->CheckInterrupts(); g_Reg->CheckInterrupts();
break; break;
@ -1405,7 +1405,7 @@ void R4300iOp32::COP0_MT()
_CP0[m_Opcode.rd] &= 0xFFFFCFF; _CP0[m_Opcode.rd] &= 0xFFFFCFF;
if ((_GPR[m_Opcode.rt].UW[0] & 0x300) != 0 && g_Settings->LoadBool(Debugger_Enabled)) if ((_GPR[m_Opcode.rt].UW[0] & 0x300) != 0 && g_Settings->LoadBool(Debugger_Enabled))
{ {
g_Notify->DisplayError(L"Set IP0 or IP1"); g_Notify->DisplayError("Set IP0 or IP1");
} }
break; break;
default: default:
@ -1425,7 +1425,7 @@ void R4300iOp32::COP1_CF()
TEST_COP1_USABLE_EXCEPTION TEST_COP1_USABLE_EXCEPTION
if (m_Opcode.fs != 31 && m_Opcode.fs != 0) if (m_Opcode.fs != 31 && m_Opcode.fs != 0)
{ {
if (g_Settings->LoadBool(Debugger_Enabled)) { g_Notify->DisplayError(L"CFC1 what register are you writing to ?"); } if (g_Settings->LoadBool(Debugger_Enabled)) { g_Notify->DisplayError("CFC1 what register are you writing to ?"); }
return; return;
} }
_GPR[m_Opcode.rt].W[0] = (int32_t)_FPCR[m_Opcode.fs]; _GPR[m_Opcode.rt].W[0] = (int32_t)_FPCR[m_Opcode.fs];

22
Source/Project64-core/N64System/Mips/Dma.cpp
View File

@ -39,9 +39,7 @@ void CDMA::OnFirstDMA()
case CIC_NUS_6105: offset = +0x03F0; break; case CIC_NUS_6105: offset = +0x03F0; break;
case CIC_NUS_6106: offset = +0x0318; break; case CIC_NUS_6106: offset = +0x0318; break;
default: default:
g_Notify->DisplayError( g_Notify->DisplayError(stdstr_f("Unhandled CicChip(%d) in first DMA", g_Rom->CicChipID()).c_str());
stdstr_f("Unhandled CicChip(%d) in first DMA", g_Rom->CicChipID()).ToUTF16().c_str()
);
return; return;
} }
g_MMU->SW_PAddr(base + offset, rt); g_MMU->SW_PAddr(base + offset, rt);
@ -61,7 +59,7 @@ void CDMA::PI_DMA_READ()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("PI_DMA_READ not in Memory: %08X", g_Reg->PI_DRAM_ADDR_REG + PI_RD_LEN_REG).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("PI_DMA_READ not in Memory: %08X", g_Reg->PI_DRAM_ADDR_REG + PI_RD_LEN_REG).c_str());
} }
g_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY; g_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
g_Reg->MI_INTR_REG |= MI_INTR_PI; g_Reg->MI_INTR_REG |= MI_INTR_PI;
@ -149,7 +147,7 @@ void CDMA::PI_DMA_READ()
} }
if (g_System->m_SaveUsing == SaveChip_FlashRam) if (g_System->m_SaveUsing == SaveChip_FlashRam)
{ {
g_Notify->DisplayError(stdstr_f("**** FLashRam DMA Read address %08X *****", g_Reg->PI_CART_ADDR_REG).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("**** FLashRam DMA Read address %08X *****", g_Reg->PI_CART_ADDR_REG).c_str());
g_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY; g_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
g_Reg->MI_INTR_REG |= MI_INTR_PI; g_Reg->MI_INTR_REG |= MI_INTR_PI;
g_Reg->CheckInterrupts(); g_Reg->CheckInterrupts();
@ -157,7 +155,7 @@ void CDMA::PI_DMA_READ()
} }
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("PI_DMA_READ where are you dmaing to ? : %08X", g_Reg->PI_CART_ADDR_REG).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("PI_DMA_READ where are you dmaing to ? : %08X", g_Reg->PI_CART_ADDR_REG).c_str());
} }
g_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY; g_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
g_Reg->MI_INTR_REG |= MI_INTR_PI; g_Reg->MI_INTR_REG |= MI_INTR_PI;
@ -177,7 +175,7 @@ void CDMA::PI_DMA_WRITE()
g_Reg->PI_STATUS_REG |= PI_STATUS_DMA_BUSY; g_Reg->PI_STATUS_REG |= PI_STATUS_DMA_BUSY;
if (g_Reg->PI_DRAM_ADDR_REG + PI_WR_LEN_REG > g_MMU->RdramSize()) if (g_Reg->PI_DRAM_ADDR_REG + PI_WR_LEN_REG > g_MMU->RdramSize())
{ {
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(stdstr_f("PI_DMA_WRITE not in Memory: %08X", g_Reg->PI_DRAM_ADDR_REG + PI_WR_LEN_REG).ToUTF16().c_str()); } if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(stdstr_f("PI_DMA_WRITE not in Memory: %08X", g_Reg->PI_DRAM_ADDR_REG + PI_WR_LEN_REG).c_str()); }
g_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY; g_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
g_Reg->MI_INTR_REG |= MI_INTR_PI; g_Reg->MI_INTR_REG |= MI_INTR_PI;
g_Reg->CheckInterrupts(); g_Reg->CheckInterrupts();
@ -286,7 +284,7 @@ void CDMA::PI_DMA_WRITE()
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f("PI_DMA_WRITE not in ROM: %08X", g_Reg->PI_CART_ADDR_REG).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("PI_DMA_WRITE not in ROM: %08X", g_Reg->PI_CART_ADDR_REG).c_str());
} }
g_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY; g_Reg->PI_STATUS_REG &= ~PI_STATUS_DMA_BUSY;
g_Reg->MI_INTR_REG |= MI_INTR_PI; g_Reg->MI_INTR_REG |= MI_INTR_PI;
@ -301,7 +299,7 @@ void CDMA::SP_DMA_READ()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nSP_DRAM_ADDR_REG not in RDRam space : % 08X", g_Reg->SP_DRAM_ADDR_REG).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nSP_DRAM_ADDR_REG not in RDRam space : % 08X", g_Reg->SP_DRAM_ADDR_REG).c_str());
} }
g_Reg->SP_DMA_BUSY_REG = 0; g_Reg->SP_DMA_BUSY_REG = 0;
g_Reg->SP_STATUS_REG &= ~SP_STATUS_DMA_BUSY; g_Reg->SP_STATUS_REG &= ~SP_STATUS_DMA_BUSY;
@ -312,7 +310,7 @@ void CDMA::SP_DMA_READ()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(__FUNCTIONW__ L"\nCould not fit copy in memory segment"); g_Notify->DisplayError(__FUNCTION__ "\nCould not fit copy in memory segment");
} }
return; return;
} }
@ -343,7 +341,7 @@ void CDMA::SP_DMA_WRITE()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nSP_DRAM_ADDR_REG not in RDRam space : % 08X", g_Reg->SP_DRAM_ADDR_REG).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nSP_DRAM_ADDR_REG not in RDRam space : % 08X", g_Reg->SP_DRAM_ADDR_REG).c_str());
} }
return; return;
} }
@ -352,7 +350,7 @@ void CDMA::SP_DMA_WRITE()
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(L"SP DMA WRITE\ncould not fit copy in memory segement"); g_Notify->DisplayError("SP DMA WRITE\ncould not fit copy in memory segement");
} }
return; return;
} }

12
Source/Project64-core/N64System/Mips/Eeprom.cpp
View File

@ -75,22 +75,22 @@ void CEeprom::EepromCommand(uint8_t * Command)
case 4: // Read from Eeprom case 4: // Read from Eeprom
if (Command[0] != 2 && bHaveDebugger()) if (Command[0] != 2 && bHaveDebugger())
{ {
g_Notify->DisplayError(L"What am I meant to do with this Eeprom Command"); g_Notify->DisplayError("What am I meant to do with this Eeprom Command");
} }
if (Command[1] != 8 && bHaveDebugger()) if (Command[1] != 8 && bHaveDebugger())
{ {
g_Notify->DisplayError(L"What am I meant to do with this Eeprom Command"); g_Notify->DisplayError("What am I meant to do with this Eeprom Command");
} }
ReadFrom(&Command[4], Command[3]); ReadFrom(&Command[4], Command[3]);
break; break;
case 5: //Write to Eeprom case 5: //Write to Eeprom
if (Command[0] != 10 && bHaveDebugger()) if (Command[0] != 10 && bHaveDebugger())
{ {
g_Notify->DisplayError(L"What am I meant to do with this Eeprom Command"); g_Notify->DisplayError("What am I meant to do with this Eeprom Command");
} }
if (Command[1] != 1 && bHaveDebugger()) if (Command[1] != 1 && bHaveDebugger())
{ {
g_Notify->DisplayError(L"What am I meant to do with this Eeprom Command"); g_Notify->DisplayError("What am I meant to do with this Eeprom Command");
} }
WriteTo(&Command[4], Command[3]); WriteTo(&Command[4], Command[3]);
break; break;
@ -129,13 +129,13 @@ void CEeprom::EepromCommand(uint8_t * Command)
//Write RTC, unimplemented //Write RTC, unimplemented
if (g_Settings->LoadDword(Debugger_ShowPifErrors)) if (g_Settings->LoadDword(Debugger_ShowPifErrors))
{ {
g_Notify->DisplayError(L"Write RTC, unimplemented"); g_Notify->DisplayError("Write RTC, unimplemented");
} }
break; break;
default: default:
if (g_Settings->LoadDword(Debugger_ShowPifErrors)) if (g_Settings->LoadDword(Debugger_ShowPifErrors))
{ {
g_Notify->DisplayError(stdstr_f("Unknown EepromCommand %d", Command[2]).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Unknown EepromCommand %d", Command[2]).c_str());
} }
} }
} }

16
Source/Project64-core/N64System/Mips/FlashRam.cpp
View File

@ -53,7 +53,7 @@ void CFlashram::DmaFromFlashram(uint8_t * dest, int StartOffset, int len)
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ ": DmaFromFlashram FlipBuffer to small (len: %d)", len).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ ": DmaFromFlashram FlipBuffer to small (len: %d)", len).c_str());
} }
len = 0x10000; len = 0x10000;
} }
@ -61,7 +61,7 @@ void CFlashram::DmaFromFlashram(uint8_t * dest, int StartOffset, int len)
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(__FUNCTIONW__ L": Unaligned flash ram read ???"); g_Notify->DisplayError(__FUNCTION__ ": Unaligned flash ram read ???");
} }
return; return;
} }
@ -89,7 +89,7 @@ void CFlashram::DmaFromFlashram(uint8_t * dest, int StartOffset, int len)
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ ": Reading m_FlashStatus not being handled correctly\nStart: %X len: %X", StartOffset, len).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ ": Reading m_FlashStatus not being handled correctly\nStart: %X len: %X", StartOffset, len).c_str());
} }
} }
*((uint32_t *)(dest)) = (uint32_t)((m_FlashStatus >> 32) & 0xFFFFFFFF); *((uint32_t *)(dest)) = (uint32_t)((m_FlashStatus >> 32) & 0xFFFFFFFF);
@ -98,7 +98,7 @@ void CFlashram::DmaFromFlashram(uint8_t * dest, int StartOffset, int len)
default: default:
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__": Start: %X, Offset: %X len: %X", dest - g_MMU->Rdram(), StartOffset, len).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__": Start: %X, Offset: %X len: %X", dest - g_MMU->Rdram(), StartOffset, len).c_str());
} }
} }
} }
@ -113,7 +113,7 @@ void CFlashram::DmaToFlashram(uint8_t * Source, int StartOffset, int len)
default: default:
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ ": Start: %X, Offset: %X len: %X", Source - g_MMU->Rdram(), StartOffset, len).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ ": Start: %X, Offset: %X len: %X", Source - g_MMU->Rdram(), StartOffset, len).c_str());
} }
} }
} }
@ -126,7 +126,7 @@ uint32_t CFlashram::ReadFromFlashStatus(uint32_t PAddr)
default: default:
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ ": PAddr (%X)", PAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ ": PAddr (%X)", PAddr).c_str());
} }
break; break;
} }
@ -209,7 +209,7 @@ void CFlashram::WriteToFlashCommand(uint32_t FlashRAM_Command)
} }
break; break;
default: default:
g_Notify->DisplayError(stdstr_f("Writing %X to flash ram command register\nm_FlashFlag: %d", FlashRAM_Command, m_FlashFlag).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Writing %X to flash ram command register\nm_FlashFlag: %d", FlashRAM_Command, m_FlashFlag).c_str());
} }
m_FlashFlag = FLASHRAM_MODE_NOPES; m_FlashFlag = FLASHRAM_MODE_NOPES;
break; break;
@ -238,7 +238,7 @@ void CFlashram::WriteToFlashCommand(uint32_t FlashRAM_Command)
default: default:
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("Writing %X to flash ram command register", FlashRAM_Command).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Writing %X to flash ram command register", FlashRAM_Command).c_str());
} }
} }
} }

128
Source/Project64-core/N64System/Mips/MemoryVirtualMem.cpp
View File

@ -608,7 +608,7 @@ void CMipsMemoryVM::Compile_LB(x86Reg Reg, uint32_t VAddr, bool SignExtend)
CPU_Message("Compile_LB\nFailed to translate address %08X", VAddr); CPU_Message("Compile_LB\nFailed to translate address %08X", VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address %08X", VAddr).c_str());
} }
return; return;
} }
@ -638,7 +638,7 @@ void CMipsMemoryVM::Compile_LB(x86Reg Reg, uint32_t VAddr, bool SignExtend)
MoveConstToX86reg(0, Reg); MoveConstToX86reg(0, Reg);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to compile address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to compile address: %08X", VAddr).c_str());
} }
} }
} }
@ -679,7 +679,7 @@ void CMipsMemoryVM::Compile_LH(x86Reg Reg, uint32_t VAddr, bool SignExtend)
CPU_Message("Compile_LH\nFailed to translate address %08X", VAddr); CPU_Message("Compile_LH\nFailed to translate address %08X", VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address %08X", VAddr).c_str());
} }
return; return;
} }
@ -709,7 +709,7 @@ void CMipsMemoryVM::Compile_LH(x86Reg Reg, uint32_t VAddr, bool SignExtend)
MoveConstToX86reg(0, Reg); MoveConstToX86reg(0, Reg);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to compile address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to compile address: %08X", VAddr).c_str());
} }
} }
} }
@ -776,7 +776,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
MoveConstToX86reg(0, Reg); MoveConstToX86reg(0, Reg);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
} }
break; break;
@ -801,7 +801,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
case 0x0430000C: MoveVariableToX86reg(&g_Reg->MI_INTR_MASK_REG, "MI_INTR_MASK_REG", Reg); break; case 0x0430000C: MoveVariableToX86reg(&g_Reg->MI_INTR_MASK_REG, "MI_INTR_MASK_REG", Reg); break;
default: default:
MoveConstToX86reg(0, Reg); MoveConstToX86reg(0, Reg);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); } if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str()); }
} }
break; break;
case 0x04400000: case 0x04400000:
@ -821,7 +821,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
MoveConstToX86reg(0, Reg); MoveConstToX86reg(0, Reg);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
} }
break; break;
@ -876,7 +876,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
MoveConstToX86reg(0, Reg); MoveConstToX86reg(0, Reg);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
} }
break; break;
@ -896,7 +896,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
MoveConstToX86reg(0, Reg); MoveConstToX86reg(0, Reg);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
} }
break; break;
@ -909,7 +909,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
MoveConstToX86reg(0, Reg); MoveConstToX86reg(0, Reg);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
} }
break; break;
@ -921,7 +921,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
MoveConstToX86reg(0, Reg); MoveConstToX86reg(0, Reg);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
} }
break; break;
@ -942,7 +942,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
CPU_Message(__FUNCTION__ "\nFailed to translate address: %08X", VAddr); CPU_Message(__FUNCTION__ "\nFailed to translate address: %08X", VAddr);
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
} }
} }
@ -970,7 +970,7 @@ void CMipsMemoryVM::Compile_SB_Const(uint8_t Value, uint32_t VAddr)
if (!TranslateVaddr(VAddr, PAddr)) if (!TranslateVaddr(VAddr, PAddr))
{ {
CPU_Message("Compile_SB\nFailed to translate address: %08X", VAddr); CPU_Message("Compile_SB\nFailed to translate address: %08X", VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); } if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) { g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str()); }
return; return;
} }
@ -990,7 +990,7 @@ void CMipsMemoryVM::Compile_SB_Const(uint8_t Value, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %02X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %02X in %08X?", Value, VAddr).c_str());
} }
} }
} }
@ -1020,7 +1020,7 @@ void CMipsMemoryVM::Compile_SB_Register(x86Reg Reg, uint32_t VAddr)
CPU_Message("Compile_SB\nFailed to translate address: %08X", VAddr); CPU_Message("Compile_SB\nFailed to translate address: %08X", VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
return; return;
} }
@ -1041,7 +1041,7 @@ void CMipsMemoryVM::Compile_SB_Register(x86Reg Reg, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).c_str());
} }
} }
} }
@ -1068,7 +1068,7 @@ void CMipsMemoryVM::Compile_SH_Const(uint16_t Value, uint32_t VAddr)
CPU_Message("Compile_SH\nFailed to translate address: %08X", VAddr); CPU_Message("Compile_SH\nFailed to translate address: %08X", VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
return; return;
} }
@ -1089,7 +1089,7 @@ void CMipsMemoryVM::Compile_SH_Const(uint16_t Value, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %04X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %04X in %08X?", Value, VAddr).c_str());
} }
} }
} }
@ -1118,7 +1118,7 @@ void CMipsMemoryVM::Compile_SH_Register(x86Reg Reg, uint32_t VAddr)
CPU_Message("Compile_SH\nFailed to translate address: %08X", VAddr); CPU_Message("Compile_SH\nFailed to translate address: %08X", VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
return; return;
} }
@ -1139,7 +1139,7 @@ void CMipsMemoryVM::Compile_SH_Register(x86Reg Reg, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", PAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", PAddr).c_str());
} }
} }
} }
@ -1168,7 +1168,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
CPU_Message("Compile_SW\nFailed to translate address: %08X", VAddr); CPU_Message("Compile_SW\nFailed to translate address: %08X", VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
return; return;
} }
@ -1208,7 +1208,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).c_str());
} }
} }
break; break;
@ -1249,7 +1249,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).c_str());
} }
} }
break; break;
@ -1267,7 +1267,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).c_str());
} }
} }
break; break;
@ -1385,7 +1385,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).c_str());
} }
} }
break; break;
@ -1443,7 +1443,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).c_str());
} }
} }
break; break;
@ -1486,7 +1486,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
MoveConstToVariable(Value, PAddr + m_RDRAM, VarName); MoveConstToVariable(Value, PAddr + m_RDRAM, VarName);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).c_str());
} }
} }
break; break;
@ -1526,7 +1526,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).c_str());
} }
} }
break; break;
@ -1540,7 +1540,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).c_str());
} }
} }
break; break;
@ -1579,7 +1579,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).c_str());
} }
} }
break; break;
@ -1600,7 +1600,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store %08X in %08X?", Value, VAddr).c_str());
} }
m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp()); m_RegWorkingSet.SetBlockCycleCount(m_RegWorkingSet.GetBlockCycleCount() - g_System->CountPerOp());
UpdateCounters(m_RegWorkingSet, false, true); UpdateCounters(m_RegWorkingSet, false, true);
@ -1641,7 +1641,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
CPU_Message("Compile_SW_Register\nFailed to translate address: %08X", VAddr); CPU_Message("Compile_SW_Register\nFailed to translate address: %08X", VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nFailed to translate address: %08X", VAddr).c_str());
} }
return; return;
} }
@ -1703,7 +1703,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
CPU_Message(" Should be moving %s in to %08X ?!?", x86_Name(Reg), VAddr); CPU_Message(" Should be moving %s in to %08X ?!?", x86_Name(Reg), VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).c_str());
} }
} }
} }
@ -1741,7 +1741,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
CPU_Message(" Should be moving %s in to %08X ?!?", x86_Name(Reg), VAddr); CPU_Message(" Should be moving %s in to %08X ?!?", x86_Name(Reg), VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).c_str());
} }
} }
break; break;
@ -1802,7 +1802,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
CPU_Message(" Should be moving %s in to %08X ?!?", x86_Name(Reg), VAddr); CPU_Message(" Should be moving %s in to %08X ?!?", x86_Name(Reg), VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).c_str());
} }
} }
break; break;
@ -1848,7 +1848,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
MoveX86regToVariable(Reg, PAddr + m_RDRAM, VarName); MoveX86regToVariable(Reg, PAddr + m_RDRAM, VarName);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).c_str());
} }
} }
break; break;
@ -1874,7 +1874,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
case 0x04600010: case 0x04600010:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).c_str());
} }
AndConstToVariable((uint32_t)~MI_INTR_PI, &g_Reg->MI_INTR_REG, "MI_INTR_REG"); AndConstToVariable((uint32_t)~MI_INTR_PI, &g_Reg->MI_INTR_REG, "MI_INTR_REG");
BeforeCallDirect(m_RegWorkingSet); BeforeCallDirect(m_RegWorkingSet);
@ -1902,7 +1902,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
CPU_Message(" Should be moving %s in to %08X ?!?", x86_Name(Reg), VAddr); CPU_Message(" Should be moving %s in to %08X ?!?", x86_Name(Reg), VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).c_str());
} }
} }
break; break;
@ -1913,7 +1913,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).c_str());
} }
} }
break; break;
@ -1946,7 +1946,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
default: default:
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).c_str());
} }
} }
break; break;
@ -1958,7 +1958,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
CPU_Message(" Should be moving %s in to %08X ?!?", x86_Name(Reg), VAddr); CPU_Message(" Should be moving %s in to %08X ?!?", x86_Name(Reg), VAddr);
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\ntrying to store in %08X?", VAddr).c_str());
} }
} }
} }
@ -2195,7 +2195,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
{ {
g_Notify->DisplayError(stdstr_f("Failed to load byte\n\nMIPS Address: %08X\nX86 Address: %08X", g_Notify->DisplayError(stdstr_f("Failed to load byte\n\nMIPS Address: %08X\nX86 Address: %08X",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM, (char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)ReadPos; lpEP->ContextRecord->Eip = (uint32_t)ReadPos;
@ -2207,7 +2207,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
{ {
g_Notify->DisplayError(stdstr_f("Failed to load half word\n\nMIPS Address: %08X\nX86 Address: %08X", g_Notify->DisplayError(stdstr_f("Failed to load half word\n\nMIPS Address: %08X\nX86 Address: %08X",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM, (char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)ReadPos; lpEP->ContextRecord->Eip = (uint32_t)ReadPos;
@ -2219,7 +2219,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
{ {
g_Notify->DisplayError(stdstr_f("Failed to load byte\n\nMIPS Address: %08X\nX86 Address: %08X", g_Notify->DisplayError(stdstr_f("Failed to load byte\n\nMIPS Address: %08X\nX86 Address: %08X",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM, (char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)ReadPos; lpEP->ContextRecord->Eip = (uint32_t)ReadPos;
@ -2231,7 +2231,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
{ {
g_Notify->DisplayError(stdstr_f("Failed to load half word\n\nMIPS Address: %08X\nX86 Address: %08X", g_Notify->DisplayError(stdstr_f("Failed to load half word\n\nMIPS Address: %08X\nX86 Address: %08X",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM, (char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)ReadPos; lpEP->ContextRecord->Eip = (uint32_t)ReadPos;
@ -2254,7 +2254,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
{ {
g_Notify->DisplayError(stdstr_f("Failed to half word\n\nMIPS Address: %08X\nX86 Address: %08X", g_Notify->DisplayError(stdstr_f("Failed to half word\n\nMIPS Address: %08X\nX86 Address: %08X",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM, (char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)ReadPos; lpEP->ContextRecord->Eip = (uint32_t)ReadPos;
@ -2265,7 +2265,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f("Failed to store half word\n\nMIPS Address: %08X\nX86 Address: %08X", MemAddress, g_Notify->DisplayError(stdstr_f("Failed to store half word\n\nMIPS Address: %08X\nX86 Address: %08X", MemAddress,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)ReadPos; lpEP->ContextRecord->Eip = (uint32_t)ReadPos;
@ -2283,7 +2283,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f("Failed to store half word\n\nMIPS Address: %08X\nX86 Address: %08X", MemAddress, g_Notify->DisplayError(stdstr_f("Failed to store half word\n\nMIPS Address: %08X\nX86 Address: %08X", MemAddress,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)(ReadPos + 2); lpEP->ContextRecord->Eip = (uint32_t)(ReadPos + 2);
@ -2303,7 +2303,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
{ {
g_Notify->DisplayError(stdstr_f("Failed to store byte\n\nMIPS Address: %08X\nX86 Address: %08X", g_Notify->DisplayError(stdstr_f("Failed to store byte\n\nMIPS Address: %08X\nX86 Address: %08X",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM, (char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)ReadPos; lpEP->ContextRecord->Eip = (uint32_t)ReadPos;
@ -2315,7 +2315,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
{ {
g_Notify->DisplayError(stdstr_f("Failed to load byte\n\nMIPS Address: %08X\nX86 Address: %08X", g_Notify->DisplayError(stdstr_f("Failed to load byte\n\nMIPS Address: %08X\nX86 Address: %08X",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM, (char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)ReadPos; lpEP->ContextRecord->Eip = (uint32_t)ReadPos;
@ -2327,7 +2327,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
{ {
g_Notify->DisplayError(stdstr_f("Failed to load word\n\nMIPS Address: %08X\nX86 Address: %08X", g_Notify->DisplayError(stdstr_f("Failed to load word\n\nMIPS Address: %08X\nX86 Address: %08X",
(char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM, (char *)exRec.ExceptionInformation[1] - (char *)m_RDRAM,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)ReadPos; lpEP->ContextRecord->Eip = (uint32_t)ReadPos;
@ -2338,7 +2338,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f("Failed to store word\n\nMIPS Address: %08X\nX86 Address: %08X", MemAddress, g_Notify->DisplayError(stdstr_f("Failed to store word\n\nMIPS Address: %08X\nX86 Address: %08X", MemAddress,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)ReadPos; lpEP->ContextRecord->Eip = (uint32_t)ReadPos;
@ -2357,7 +2357,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f("Failed to store byte\n\nMIPS Address: %08X\nX86 Address: %08X", MemAddress, g_Notify->DisplayError(stdstr_f("Failed to store byte\n\nMIPS Address: %08X\nX86 Address: %08X", MemAddress,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)(ReadPos + 1); lpEP->ContextRecord->Eip = (uint32_t)(ReadPos + 1);
@ -2376,7 +2376,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory)) if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory))
{ {
g_Notify->DisplayError(stdstr_f("Failed to store word\n\nMIPS Address: %08X\nX86 Address: %08X", MemAddress, g_Notify->DisplayError(stdstr_f("Failed to store word\n\nMIPS Address: %08X\nX86 Address: %08X", MemAddress,
(uint8_t *)lpEP->ContextRecord->Eip).ToUTF16().c_str()); (uint8_t *)lpEP->ContextRecord->Eip).c_str());
} }
} }
lpEP->ContextRecord->Eip = (uint32_t)(ReadPos + 4); lpEP->ContextRecord->Eip = (uint32_t)(ReadPos + 4);
@ -2534,7 +2534,7 @@ bool CMipsMemoryVM::SB_NonMemory(uint32_t PAddr, uint8_t Value)
VirtualProtect(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, PAGE_READWRITE, &OldProtect); VirtualProtect(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, PAGE_READWRITE, &OldProtect);
*(uint8_t *)(m_RDRAM + PAddr) = Value; *(uint8_t *)(m_RDRAM + PAddr) = Value;
VirtualProtect(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, OldProtect, &OldProtect); VirtualProtect(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, OldProtect, &OldProtect);
g_Notify->DisplayError(L"FrameBufferWrite"); g_Notify->DisplayError("FrameBufferWrite");
if (FrameBufferWrite) { FrameBufferWrite(PAddr, 1); } if (FrameBufferWrite) { FrameBufferWrite(PAddr, 1); }
break; break;
} }
@ -2575,7 +2575,7 @@ bool CMipsMemoryVM::SH_NonMemory(uint32_t PAddr, uint16_t Value)
if (FrameBufferWrite) { FrameBufferWrite(PAddr & ~0xFFF, 2); } if (FrameBufferWrite) { FrameBufferWrite(PAddr & ~0xFFF, 2); }
//*(uint16_t *)(m_RDRAM+PAddr) = 0xFFFF; //*(uint16_t *)(m_RDRAM+PAddr) = 0xFFFF;
//VirtualProtect(m_RDRAM+(PAddr & ~0xFFF),0xFFC,PAGE_NOACCESS, &OldProtect); //VirtualProtect(m_RDRAM+(PAddr & ~0xFFF),0xFFC,PAGE_NOACCESS, &OldProtect);
g_Notify->DisplayError(L"PAddr = %x", PAddr); g_Notify->DisplayError("PAddr = %x", PAddr);
break; break;
} }
#endif #endif
@ -2636,7 +2636,7 @@ bool CMipsMemoryVM::SW_NonMemory(uint32_t PAddr, uint32_t Value)
VirtualProtect(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, PAGE_READWRITE, &OldProtect); VirtualProtect(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, PAGE_READWRITE, &OldProtect);
*(uint32_t *)(m_RDRAM + PAddr) = Value; *(uint32_t *)(m_RDRAM + PAddr) = Value;
VirtualProtect(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, OldProtect, &OldProtect); VirtualProtect(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, OldProtect, &OldProtect);
g_Notify->DisplayError(L"FrameBufferWrite %X", PAddr); g_Notify->DisplayError("FrameBufferWrite %X", PAddr);
if (FrameBufferWrite) { FrameBufferWrite(PAddr, 4); } if (FrameBufferWrite) { FrameBufferWrite(PAddr, 4); }
break; break;
} }
@ -4725,7 +4725,7 @@ void CMipsMemoryVM::ChangeSpStatus()
} }
if ((RegModValue & SP_SET_INTR) != 0 && bHaveDebugger()) if ((RegModValue & SP_SET_INTR) != 0 && bHaveDebugger())
{ {
g_Notify->DisplayError(L"SP_SET_INTR"); g_Notify->DisplayError("SP_SET_INTR");
} }
if ((RegModValue & SP_CLR_SSTEP) != 0) if ((RegModValue & SP_CLR_SSTEP) != 0)
{ {
@ -5246,7 +5246,7 @@ void CMipsMemoryVM::Write32SPRegisters(void)
} }
if ((m_MemLookupValue.UW[0] & SP_SET_INTR) != 0) if ((m_MemLookupValue.UW[0] & SP_SET_INTR) != 0)
{ {
g_Notify->DisplayError(L"SP_SET_INTR"); g_Notify->DisplayError("SP_SET_INTR");
} }
if ((m_MemLookupValue.UW[0] & SP_CLR_SSTEP) != 0) if ((m_MemLookupValue.UW[0] & SP_CLR_SSTEP) != 0)
{ {
@ -5422,19 +5422,19 @@ void CMipsMemoryVM::Write32DPCommandRegisters(void)
{ {
//if ( ( m_MemLookupValue.UW[0] & DPC_CLR_TMEM_CTR ) != 0) //if ( ( m_MemLookupValue.UW[0] & DPC_CLR_TMEM_CTR ) != 0)
//{ //{
// g_Notify->DisplayError(L"RSP: DPC_STATUS_REG: DPC_CLR_TMEM_CTR"); // g_Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_TMEM_CTR");
//} //}
//if ( ( m_MemLookupValue.UW[0] & DPC_CLR_PIPE_CTR ) != 0) //if ( ( m_MemLookupValue.UW[0] & DPC_CLR_PIPE_CTR ) != 0)
//{ //{
// g_Notify->DisplayError(L"RSP: DPC_STATUS_REG: DPC_CLR_PIPE_CTR"); // g_Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_PIPE_CTR");
//} //}
//if ( ( m_MemLookupValue.UW[0] & DPC_CLR_CMD_CTR ) != 0) //if ( ( m_MemLookupValue.UW[0] & DPC_CLR_CMD_CTR ) != 0)
//{ //{
// g_Notify->DisplayError(L"RSP: DPC_STATUS_REG: DPC_CLR_CMD_CTR"); // g_Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_CMD_CTR");
//} //}
//if ( ( m_MemLookupValue.UW[0] & DPC_CLR_CLOCK_CTR ) != 0) //if ( ( m_MemLookupValue.UW[0] & DPC_CLR_CLOCK_CTR ) != 0)
//{ //{
// g_Notify->DisplayError(L"RSP: DPC_STATUS_REG: DPC_CLR_CLOCK_CTR"); // g_Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_CLOCK_CTR");
//} //}
} }
#endif #endif
@ -5662,7 +5662,7 @@ void CMipsMemoryVM::Write32PeripheralInterface(void)
case 0x04600010: case 0x04600010:
//if ((Value & PI_SET_RESET) != 0 ) //if ((Value & PI_SET_RESET) != 0 )
//{ //{
// g_Notify->DisplayError(L"reset Controller"); // g_Notify->DisplayError("reset Controller");
//} //}
if ((m_MemLookupValue.UW[0] & PI_CLR_INTR) != 0) if ((m_MemLookupValue.UW[0] & PI_CLR_INTR) != 0)
{ {

34
Source/Project64-core/N64System/Mips/PifRam.cpp
View File

@ -145,7 +145,7 @@ void CPifRam::PifRamRead()
{ {
if (bShowPifRamErrors()) if (bShowPifRamErrors())
{ {
g_Notify->DisplayError(stdstr_f("Unknown Command in PifRamRead(%X)", m_PifRam[CurPos]).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Unknown Command in PifRamRead(%X)", m_PifRam[CurPos]).c_str());
} }
CurPos = 0x40; CurPos = 0x40;
} }
@ -210,7 +210,7 @@ void CPifRam::PifRamWrite()
default: default:
if (bShowPifRamErrors()) if (bShowPifRamErrors())
{ {
g_Notify->DisplayError(stdstr_f("Unkown PifRam control: %d", m_PifRam[0x3F]).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Unkown PifRam control: %d", m_PifRam[0x3F]).c_str());
} }
} }
return; return;
@ -255,7 +255,7 @@ void CPifRam::PifRamWrite()
{ {
if (bShowPifRamErrors()) if (bShowPifRamErrors())
{ {
g_Notify->DisplayError(L"Command on channel 5?"); g_Notify->DisplayError("Command on channel 5?");
} }
} }
CurPos += m_PifRam[CurPos] + (m_PifRam[CurPos + 1] & 0x3F) + 1; CurPos += m_PifRam[CurPos] + (m_PifRam[CurPos + 1] & 0x3F) + 1;
@ -265,7 +265,7 @@ void CPifRam::PifRamWrite()
{ {
if (bShowPifRamErrors()) if (bShowPifRamErrors())
{ {
g_Notify->DisplayError(stdstr_f("Unknown Command in PifRamWrite(%X)", m_PifRam[CurPos]).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Unknown Command in PifRamWrite(%X)", m_PifRam[CurPos]).c_str());
} }
CurPos = 0x40; CurPos = 0x40;
} }
@ -289,7 +289,7 @@ void CPifRam::SI_DMA_READ()
{ {
if (bShowPifRamErrors()) if (bShowPifRamErrors())
{ {
g_Notify->DisplayError(__FUNCTIONW__ L"\nSI_DRAM_ADDR_REG not in RDRam space"); g_Notify->DisplayError(__FUNCTION__ "\nSI_DRAM_ADDR_REG not in RDRam space");
} }
return; return;
} }
@ -375,7 +375,7 @@ void CPifRam::SI_DMA_WRITE()
{ {
if (bShowPifRamErrors()) if (bShowPifRamErrors())
{ {
g_Notify->DisplayError(L"SI DMA\nSI_DRAM_ADDR_REG not in RDRam space"); g_Notify->DisplayError("SI DMA\nSI_DRAM_ADDR_REG not in RDRam space");
} }
return; return;
} }
@ -471,11 +471,11 @@ void CPifRam::ProcessControllerCommand(int Control, uint8_t * Command)
{ {
if (Command[0] != 1) if (Command[0] != 1)
{ {
g_Notify->DisplayError(L"What am I meant to do with this Controller Command"); g_Notify->DisplayError("What am I meant to do with this Controller Command");
} }
if (Command[1] != 3) if (Command[1] != 3)
{ {
g_Notify->DisplayError(L"What am I meant to do with this Controller Command"); g_Notify->DisplayError("What am I meant to do with this Controller Command");
} }
} }
if (Controllers[Control].Present == true) if (Controllers[Control].Present == true)
@ -502,11 +502,11 @@ void CPifRam::ProcessControllerCommand(int Control, uint8_t * Command)
{ {
if (Command[0] != 1) if (Command[0] != 1)
{ {
g_Notify->DisplayError(L"What am I meant to do with this Controller Command"); g_Notify->DisplayError("What am I meant to do with this Controller Command");
} }
if (Command[1] != 4) if (Command[1] != 4)
{ {
g_Notify->DisplayError(L"What am I meant to do with this Controller Command"); g_Notify->DisplayError("What am I meant to do with this Controller Command");
} }
} }
if (Controllers[Control].Present == false) if (Controllers[Control].Present == false)
@ -523,11 +523,11 @@ void CPifRam::ProcessControllerCommand(int Control, uint8_t * Command)
{ {
if (Command[0] != 3) if (Command[0] != 3)
{ {
g_Notify->DisplayError(L"What am I meant to do with this Controller Command"); g_Notify->DisplayError("What am I meant to do with this Controller Command");
} }
if (Command[1] != 33) if (Command[1] != 33)
{ {
g_Notify->DisplayError(L"What am I meant to do with this Controller Command"); g_Notify->DisplayError("What am I meant to do with this Controller Command");
} }
} }
if (Controllers[Control].Present == true) if (Controllers[Control].Present == true)
@ -565,11 +565,11 @@ void CPifRam::ProcessControllerCommand(int Control, uint8_t * Command)
{ {
if (Command[0] != 35) if (Command[0] != 35)
{ {
g_Notify->DisplayError(L"What am I meant to do with this Controller Command"); g_Notify->DisplayError("What am I meant to do with this Controller Command");
} }
if (Command[1] != 1) if (Command[1] != 1)
{ {
g_Notify->DisplayError(L"What am I meant to do with this Controller Command"); g_Notify->DisplayError("What am I meant to do with this Controller Command");
} }
} }
if (Controllers[Control].Present == true) if (Controllers[Control].Present == true)
@ -599,7 +599,7 @@ void CPifRam::ProcessControllerCommand(int Control, uint8_t * Command)
default: default:
if (bShowPifRamErrors()) if (bShowPifRamErrors())
{ {
g_Notify->DisplayError(stdstr_f("Unknown ControllerCommand %d", Command[2]).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Unknown ControllerCommand %d", Command[2]).c_str());
} }
} }
} }
@ -614,8 +614,8 @@ void CPifRam::ReadControllerCommand(int Control, uint8_t * Command) {
{ {
if (bShowPifRamErrors()) if (bShowPifRamErrors())
{ {
if (Command[0] != 1) { g_Notify->DisplayError(L"What am I meant to do with this Controller Command"); } if (Command[0] != 1) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
if (Command[1] != 4) { g_Notify->DisplayError(L"What am I meant to do with this Controller Command"); } if (Command[1] != 4) { g_Notify->DisplayError("What am I meant to do with this Controller Command"); }
} }
const uint32_t buttons = g_BaseSystem->GetButtons(Control); const uint32_t buttons = g_BaseSystem->GetButtons(Control);

20
Source/Project64-core/N64System/Mips/RegisterClass.cpp
View File

@ -328,14 +328,14 @@ void CRegisters::DoAddressError(bool DelaySlot, uint32_t BadVaddr, bool FromRead
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(L"AddressError"); g_Notify->DisplayError("AddressError");
if ((STATUS_REGISTER & STATUS_EXL) != 0) if ((STATUS_REGISTER & STATUS_EXL) != 0)
{ {
g_Notify->DisplayError(L"EXL set in AddressError Exception"); g_Notify->DisplayError("EXL set in AddressError Exception");
} }
if ((STATUS_REGISTER & STATUS_ERL) != 0) if ((STATUS_REGISTER & STATUS_ERL) != 0)
{ {
g_Notify->DisplayError(L"ERL set in AddressError Exception"); g_Notify->DisplayError("ERL set in AddressError Exception");
} }
} }
@ -386,11 +386,11 @@ void CRegisters::DoBreakException(bool DelaySlot)
{ {
if ((STATUS_REGISTER & STATUS_EXL) != 0) if ((STATUS_REGISTER & STATUS_EXL) != 0)
{ {
g_Notify->DisplayError(L"EXL set in Break Exception"); g_Notify->DisplayError("EXL set in Break Exception");
} }
if ((STATUS_REGISTER & STATUS_ERL) != 0) if ((STATUS_REGISTER & STATUS_ERL) != 0)
{ {
g_Notify->DisplayError(L"ERL set in Break Exception"); g_Notify->DisplayError("ERL set in Break Exception");
} }
} }
@ -414,11 +414,11 @@ void CRegisters::DoCopUnusableException(bool DelaySlot, int Coprocessor)
{ {
if ((STATUS_REGISTER & STATUS_EXL) != 0) if ((STATUS_REGISTER & STATUS_EXL) != 0)
{ {
g_Notify->DisplayError(L"EXL set in Break Exception"); g_Notify->DisplayError("EXL set in Break Exception");
} }
if ((STATUS_REGISTER & STATUS_ERL) != 0) if ((STATUS_REGISTER & STATUS_ERL) != 0)
{ {
g_Notify->DisplayError(L"ERL set in Break Exception"); g_Notify->DisplayError("ERL set in Break Exception");
} }
} }
@ -512,7 +512,7 @@ void CRegisters::DoTLBReadMiss(bool DelaySlot, uint32_t BadVaddr)
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("TLBMiss - EXL Set\nBadVaddr = %X\nAddress Defined: %s", BadVaddr, g_TLB->AddressDefined(BadVaddr) ? "true" : "false").ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("TLBMiss - EXL Set\nBadVaddr = %X\nAddress Defined: %s", BadVaddr, g_TLB->AddressDefined(BadVaddr) ? "true" : "false").c_str());
} }
m_PROGRAM_COUNTER = 0x80000180; m_PROGRAM_COUNTER = 0x80000180;
} }
@ -524,11 +524,11 @@ void CRegisters::DoSysCallException(bool DelaySlot)
{ {
if ((STATUS_REGISTER & STATUS_EXL) != 0) if ((STATUS_REGISTER & STATUS_EXL) != 0)
{ {
g_Notify->DisplayError(L"EXL set in SysCall Exception"); g_Notify->DisplayError("EXL set in SysCall Exception");
} }
if ((STATUS_REGISTER & STATUS_ERL) != 0) if ((STATUS_REGISTER & STATUS_ERL) != 0)
{ {
g_Notify->DisplayError(L"ERL set in SysCall Exception"); g_Notify->DisplayError("ERL set in SysCall Exception");
} }
} }

35
Source/Project64-core/N64System/N64Class.cpp
View File

@ -267,13 +267,13 @@ bool CN64System::EmulationStarting(void * hThread, uint32_t ThreadId)
} }
catch (...) catch (...)
{ {
g_Notify->DisplayError(stdstr_f(__FUNCTION__ ": Exception caught\nFile: %s\nLine: %d", __FILE__, __LINE__).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f(__FUNCTION__ ": Exception caught\nFile: %s\nLine: %d", __FILE__, __LINE__).c_str());
} }
} }
else else
{ {
WriteTrace(TraceN64System, TraceError, "SetActiveSystem failed"); WriteTrace(TraceN64System, TraceError, "SetActiveSystem failed");
g_Notify->DisplayError(__FUNCTIONW__ L": Failed to Initialize N64 System"); g_Notify->DisplayError(__FUNCTION__ ": Failed to Initialize N64 System");
g_Settings->SaveBool(GameRunning_LoadingInProgress, false); g_Settings->SaveBool(GameRunning_LoadingInProgress, false);
bRes = false; bRes = false;
} }
@ -306,7 +306,7 @@ void CN64System::StartEmulation2(bool NewThread)
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
} }
g_Notify->DisplayMessage(5, L"Copy Plugins"); g_Notify->DisplayMessage(5, "Copy Plugins");
g_Plugins->CopyPlugins(g_Settings->LoadStringVal(Directory_PluginSync)); g_Plugins->CopyPlugins(g_Settings->LoadStringVal(Directory_PluginSync));
m_SyncPlugins = new CPlugins(g_Settings->LoadStringVal(Directory_PluginSync)); m_SyncPlugins = new CPlugins(g_Settings->LoadStringVal(Directory_PluginSync));
m_SyncPlugins->SetRenderWindows(g_Plugins->SyncWindow(), NULL); m_SyncPlugins->SetRenderWindows(g_Plugins->SyncWindow(), NULL);
@ -356,8 +356,8 @@ void CN64System::StartEmulation(bool NewThread)
} }
__except (g_MMU->MemoryFilter(GetExceptionCode(), GetExceptionInformation())) __except (g_MMU->MemoryFilter(GetExceptionCode(), GetExceptionInformation()))
{ {
wchar_t message[400]; char message[400];
swprintf(message, sizeof(message), L"Exception caught\nFile: %s\nLine: %d", __FILEW__, __LINE__); sprintf(message, "Exception caught\nFile: %s\nLine: %d", __FILE__, __LINE__);
g_Notify->DisplayError(message); g_Notify->DisplayError(message);
} }
} }
@ -1232,7 +1232,7 @@ void CN64System::DumpSyncErrors(CN64System * SecondCPU)
} }
} }
g_Notify->DisplayError(L"Sync Error"); g_Notify->DisplayError("Sync Error");
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
} }
@ -1387,11 +1387,11 @@ bool CN64System::SaveState()
} }
m_Reg.MI_INTR_REG = MiInterReg; m_Reg.MI_INTR_REG = MiInterReg;
g_Settings->SaveString(GameRunning_InstantSaveFile, ""); g_Settings->SaveString(GameRunning_InstantSaveFile, "");
std::wstring SaveMessage = g_Lang->GetString(MSG_SAVED_STATE); std::string SaveMessage = g_Lang->GetString(MSG_SAVED_STATE);
CPath SavedFileName(FileName); CPath SavedFileName(FileName);
g_Notify->DisplayMessage(5, stdwstr_f(L"%ws %ws", SaveMessage.c_str(), stdstr(SavedFileName.GetNameExtension()).ToUTF16().c_str()).c_str()); g_Notify->DisplayMessage(5, stdstr_f("%s %s", SaveMessage.c_str(), stdstr(SavedFileName.GetNameExtension()).c_str()).c_str());
//Notify().RefreshMenu(); //Notify().RefreshMenu();
WriteTrace(TraceN64System, TraceDebug, "Done"); WriteTrace(TraceN64System, TraceDebug, "Done");
return true; return true;
@ -1504,12 +1504,13 @@ bool CN64System::LoadState(const char * FileName)
if (memcmp(LoadHeader, g_Rom->GetRomAddress(), 0x40) != 0) if (memcmp(LoadHeader, g_Rom->GetRomAddress(), 0x40) != 0)
{ {
//if (inFullScreen) { return false; } //if (inFullScreen) { return false; }
int result = MessageBoxW(NULL, GS(MSG_SAVE_STATE_HEADER), GS(MSG_MSGBOX_TITLE), int result = MessageBoxW(NULL, wGS(MSG_SAVE_STATE_HEADER).c_str(), wGS(MSG_MSGBOX_TITLE).c_str(), MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2);
MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2);
if (result == IDNO) if (result == IDNO)
{
return false; return false;
} }
}
Reset(false, true); Reset(false, true);
g_MMU->UnProtectMemory(0x80000000, 0x80000000 + g_Settings->LoadDword(Game_RDRamSize) - 4); g_MMU->UnProtectMemory(0x80000000, 0x80000000 + g_Settings->LoadDword(Game_RDRamSize) - 4);
@ -1557,7 +1558,7 @@ bool CN64System::LoadState(const char * FileName)
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL); OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, NULL);
if (hSaveFile == INVALID_HANDLE_VALUE) if (hSaveFile == INVALID_HANDLE_VALUE)
{ {
g_Notify->DisplayMessage(5, stdwstr_f(L"%ws %ws", GS(MSG_UNABLED_LOAD_STATE), FileNameStr.ToUTF16().c_str()).c_str()); g_Notify->DisplayMessage(5, stdstr_f("%s %s", GS(MSG_UNABLED_LOAD_STATE), FileNameStr.c_str()).c_str());
return false; return false;
} }
@ -1565,7 +1566,9 @@ bool CN64System::LoadState(const char * FileName)
DWORD dwRead; DWORD dwRead;
ReadFile(hSaveFile, &Value, sizeof(Value), &dwRead, NULL); ReadFile(hSaveFile, &Value, sizeof(Value), &dwRead, NULL);
if (Value != 0x23D8A6C8) if (Value != 0x23D8A6C8)
{
return false; return false;
}
ReadFile(hSaveFile, &SaveRDRAMSize, sizeof(SaveRDRAMSize), &dwRead, NULL); ReadFile(hSaveFile, &SaveRDRAMSize, sizeof(SaveRDRAMSize), &dwRead, NULL);
//Check header //Check header
@ -1574,7 +1577,7 @@ bool CN64System::LoadState(const char * FileName)
if (memcmp(LoadHeader, g_Rom->GetRomAddress(), 0x40) != 0) if (memcmp(LoadHeader, g_Rom->GetRomAddress(), 0x40) != 0)
{ {
//if (inFullScreen) { return false; } //if (inFullScreen) { return false; }
int result = MessageBoxW(NULL, GS(MSG_SAVE_STATE_HEADER), GS(MSG_MSGBOX_TITLE), MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2); int result = MessageBoxW(NULL, wGS(MSG_SAVE_STATE_HEADER).c_str(), wGS(MSG_MSGBOX_TITLE).c_str(), MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2);
if (result == IDNO) if (result == IDNO)
{ {
@ -1686,15 +1689,15 @@ bool CN64System::LoadState(const char * FileName)
} }
} }
WriteTrace(TraceN64System, TraceDebug, "13"); WriteTrace(TraceN64System, TraceDebug, "13");
std::wstring LoadMsg = g_Lang->GetString(MSG_LOADED_STATE); std::string LoadMsg = g_Lang->GetString(MSG_LOADED_STATE);
g_Notify->DisplayMessage(5, stdwstr_f(L"%ws %ws", LoadMsg.c_str(), stdstr(CPath(FileNameStr).GetNameExtension()).ToUTF16().c_str()).c_str()); g_Notify->DisplayMessage(5, stdstr_f("%s %s", LoadMsg.c_str(), stdstr(CPath(FileNameStr).GetNameExtension()).c_str()).c_str());
WriteTrace(TraceN64System, TraceDebug, "Done"); WriteTrace(TraceN64System, TraceDebug, "Done");
return true; return true;
} }
void CN64System::DisplayRSPListCount() void CN64System::DisplayRSPListCount()
{ {
g_Notify->DisplayMessage(0, stdstr_f("Dlist: %d Alist: %d Unknown: %d", m_DlistCount, m_AlistCount, m_UnknownCount).ToUTF16().c_str()); g_Notify->DisplayMessage(0, stdstr_f("Dlist: %d Alist: %d Unknown: %d", m_DlistCount, m_AlistCount, m_UnknownCount).c_str());
} }
void CN64System::RunRSP() void CN64System::RunRSP()
@ -1757,7 +1760,7 @@ void CN64System::RunRSP()
__except (g_MMU->MemoryFilter(GetExceptionCode(), GetExceptionInformation())) __except (g_MMU->MemoryFilter(GetExceptionCode(), GetExceptionInformation()))
{ {
WriteTrace(TraceRSP, TraceError, "exception generated"); WriteTrace(TraceRSP, TraceError, "exception generated");
g_Notify->FatalError(__FUNCTIONW__ L"\nUnknown memory action\n\nEmulation stop"); g_Notify->FatalError(__FUNCTION__ "\nUnknown memory action\n\nEmulation stop");
} }
if (Task == 1 && bDelayDP() && ((m_Reg.m_GfxIntrReg & MI_INTR_DP) != 0)) if (Task == 1 && bDelayDP() && ((m_Reg.m_GfxIntrReg & MI_INTR_DP) != 0))

16
Source/Project64-core/N64System/N64RomClass.cpp
View File

@ -86,7 +86,7 @@ bool CN64Rom::AllocateAndLoadN64Image(const char * FileLoc, bool LoadBootCodeOnl
TotalRead += dwRead; TotalRead += dwRead;
//Show Message of how much % wise of the rom has been loaded //Show Message of how much % wise of the rom has been loaded
g_Notify->DisplayMessage(0, stdstr_f("%s: %.2f%c", GS(MSG_LOADED), ((float)TotalRead / (float)RomFileSize) * 100.0f, '%').ToUTF16().c_str()); g_Notify->DisplayMessage(0, stdstr_f("%s: %.2f%c", GS(MSG_LOADED), ((float)TotalRead / (float)RomFileSize) * 100.0f, '%').c_str());
} }
dwRead = TotalRead; dwRead = TotalRead;
@ -182,7 +182,7 @@ bool CN64Rom::AllocateAndLoadZipImage(const char * FileLoc, bool LoadBootCodeOnl
TotalRead += dwRead; TotalRead += dwRead;
//Show Message of how much % wise of the rom has been loaded //Show Message of how much % wise of the rom has been loaded
g_Notify->DisplayMessage(5, stdstr_f("%s: %.2f%c", GS(MSG_LOADED), ((float)TotalRead / (float)RomFileSize) * 100.0f, '%').ToUTF16().c_str()); g_Notify->DisplayMessage(5, stdstr_f("%s: %.2f%c", GS(MSG_LOADED), ((float)TotalRead / (float)RomFileSize) * 100.0f, '%').c_str());
} }
dwRead = TotalRead + 4; dwRead = TotalRead + 4;
@ -191,7 +191,7 @@ bool CN64Rom::AllocateAndLoadZipImage(const char * FileLoc, bool LoadBootCodeOnl
VirtualFree(Image, 0, MEM_RELEASE); VirtualFree(Image, 0, MEM_RELEASE);
unzCloseCurrentFile(file); unzCloseCurrentFile(file);
SetError(MSG_FAIL_ZIP); SetError(MSG_FAIL_ZIP);
g_Notify->DisplayMessage(1, L""); g_Notify->DisplayMessage(1, "");
break; break;
} }
@ -207,7 +207,7 @@ bool CN64Rom::AllocateAndLoadZipImage(const char * FileLoc, bool LoadBootCodeOnl
//Protect the memory so that it can not be written to. //Protect the memory so that it can not be written to.
DWORD OldProtect; DWORD OldProtect;
VirtualProtect(m_ROMImage, m_RomFileSize, PAGE_READONLY, &OldProtect); VirtualProtect(m_ROMImage, m_RomFileSize, PAGE_READONLY, &OldProtect);
g_Notify->DisplayMessage(1, L""); g_Notify->DisplayMessage(1, "");
} }
unzCloseCurrentFile(file); unzCloseCurrentFile(file);
@ -252,7 +252,7 @@ void CN64Rom::ByteSwapRom()
break; break;
case 0x80371240: break; case 0x80371240: break;
default: default:
g_Notify->DisplayError(stdstr_f("ByteSwapRom: %X", m_ROMImage[0]).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("ByteSwapRom: %X", m_ROMImage[0]).c_str());
} }
} }
@ -282,7 +282,7 @@ void CN64Rom::CalculateCicChip()
default: default:
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("Unknown CIC checksum:\n%I64X.", CRC).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Unknown CIC checksum:\n%I64X.", CRC).c_str());
} }
m_CicChip = CIC_UNKNOWN; break; m_CicChip = CIC_UNKNOWN; break;
} }
@ -390,9 +390,9 @@ bool CN64Rom::IsValidRomImage(uint8_t Test[4])
return false; return false;
} }
void CN64Rom::NotificationCB(LPCWSTR Status, CN64Rom * /*_this*/) void CN64Rom::NotificationCB(const char * Status, CN64Rom * /*_this*/)
{ {
g_Notify->DisplayMessage(5, stdstr_f("%s", Status).ToUTF16().c_str()); g_Notify->DisplayMessage(5, stdstr_f("%s", Status).c_str());
} }
bool CN64Rom::LoadN64Image(const char * FileLoc, bool LoadBootCodeOnly) bool CN64Rom::LoadN64Image(const char * FileLoc, bool LoadBootCodeOnly)

2
Source/Project64-core/N64System/N64RomClass.h
View File

@ -32,7 +32,7 @@ class CN64Rom :
bool AllocateAndLoadZipImage(const char * FileLoc, bool LoadBootCodeOnly); bool AllocateAndLoadZipImage(const char * FileLoc, bool LoadBootCodeOnly);
void ByteSwapRom(); void ByteSwapRom();
void SetError(LanguageStringID ErrorMsg); void SetError(LanguageStringID ErrorMsg);
static void __stdcall NotificationCB(const wchar_t * Status, CN64Rom * _this); static void NotificationCB(const char * Status, CN64Rom * _this);
void CalculateCicChip(); void CalculateCicChip();
void CalculateRomCrc(); void CalculateRomCrc();

2
Source/Project64-core/N64System/ProfilingClass.cpp
View File

@ -110,7 +110,7 @@ void CProfiling::ShowCPU_Usage() {
(float)(((double)CPU / (double)TotalTime) * 100), '%', (float)(((double)CPU / (double)TotalTime) * 100), '%',
(float)(((double)Dlist / (double)TotalTime) * 100), '%', (float)(((double)Dlist / (double)TotalTime) * 100), '%',
(float)(((double)Alist / (double)TotalTime) * 100), '%', (float)(((double)Alist / (double)TotalTime) * 100), '%',
(float)(((double)Idle / (double)TotalTime) * 100), '%').ToUTF16().c_str()); (float)(((double)Idle / (double)TotalTime) * 100), '%').c_str());
ResetCounters(); ResetCounters();
} }

41
Source/Project64-core/N64System/Recompiler/LoopAnalysis.cpp
View File

@ -243,8 +243,8 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
#ifdef legacycode #ifdef legacycode
if (m_Command.Hex == 0x00000001) { break; } if (m_Command.Hex == 0x00000001) { break; }
g_Notify->DisplayError(L"Unhandled R4300i OpCode in FillSectionInfo 5\n%s", g_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 5\n%s",
R4300iOpcodeName(m_Command.Hex,m_PC)); R4300iOpcodeName(m_Command.Hex, m_PC));
#endif #endif
m_NextInstruction = END_BLOCK; m_NextInstruction = END_BLOCK;
m_PC -= 4; m_PC -= 4;
@ -312,12 +312,12 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
#ifdef legacycode #ifdef legacycode
m_Reg.GetMipsRegLo(31) = m_PC + 8; m_Reg.GetMipsRegLo(31) = m_PC + 8;
m_Reg.SetMipsRegState(31,CRegInfo::STATE_CONST_32_SIGN); m_Reg.SetMipsRegState(31, CRegInfo::STATE_CONST_32_SIGN);
Section->m_Cont.TargetPC = m_PC + 8; Section->m_Cont.TargetPC = m_PC + 8;
Section->m_Jump.TargetPC = m_PC + ((int16_t)m_Command.offset << 2) + 4; Section->m_Jump.TargetPC = m_PC + ((int16_t)m_Command.offset << 2) + 4;
if (m_PC == Section->m_Jump.TargetPC) if (m_PC == Section->m_Jump.TargetPC)
{ {
if (!DelaySlotEffectsCompare(m_PC,m_Command.rs,0)) if (!DelaySlotEffectsCompare(m_PC, m_Command.rs, 0))
{ {
Section->m_Jump.PermLoop = true; Section->m_Jump.PermLoop = true;
} }
@ -334,17 +334,18 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
if (m_Reg.Is32Bit(m_Command.rs)) if (m_Reg.Is32Bit(m_Command.rs))
{ {
Value = m_Reg.GetMipsRegLo_S(m_Command.rs); Value = m_Reg.GetMipsRegLo_S(m_Command.rs);
} else { }
else {
Value = m_Reg.GetMipsReg_S(m_Command.rs); Value = m_Reg.GetMipsReg_S(m_Command.rs);
} }
if (Value >= 0) if (Value >= 0)
{ {
m_Reg.GetMipsRegLo(31) = m_PC + 8; m_Reg.GetMipsRegLo(31) = m_PC + 8;
m_Reg.SetMipsRegState(31,CRegInfo::STATE_CONST_32_SIGN); m_Reg.SetMipsRegState(31, CRegInfo::STATE_CONST_32_SIGN);
Section->m_Jump.TargetPC = m_PC + ((int16_t)m_Command.offset << 2) + 4; Section->m_Jump.TargetPC = m_PC + ((int16_t)m_Command.offset << 2) + 4;
if (m_PC == Section->m_Jump.TargetPC) if (m_PC == Section->m_Jump.TargetPC)
{ {
if (!DelaySlotEffectsCompare(m_PC,31,0)) if (!DelaySlotEffectsCompare(m_PC, 31, 0))
{ {
Section->m_Jump.PermLoop = true; Section->m_Jump.PermLoop = true;
} }
@ -354,12 +355,12 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
} }
m_Reg.GetMipsRegLo(31) = m_PC + 8; m_Reg.GetMipsRegLo(31) = m_PC + 8;
m_Reg.SetMipsRegState(31,CRegInfo::STATE_CONST_32_SIGN); m_Reg.SetMipsRegState(31, CRegInfo::STATE_CONST_32_SIGN);
Section->m_Cont.TargetPC = m_PC + 8; Section->m_Cont.TargetPC = m_PC + 8;
Section->m_Jump.TargetPC = m_PC + ((int16_t)m_Command.offset << 2) + 4; Section->m_Jump.TargetPC = m_PC + ((int16_t)m_Command.offset << 2) + 4;
if (m_PC == Section->m_Jump.TargetPC) if (m_PC == Section->m_Jump.TargetPC)
{ {
if (!DelaySlotEffectsCompare(m_PC,m_Command.rs,0)) if (!DelaySlotEffectsCompare(m_PC, m_Command.rs, 0))
{ {
Section->m_Jump.PermLoop = true; Section->m_Jump.PermLoop = true;
} }
@ -370,8 +371,8 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
#ifdef legacycode #ifdef legacycode
if (m_Command.Hex == 0x0407000D) { break; } if (m_Command.Hex == 0x0407000D) { break; }
g_Notify->DisplayError(L"Unhandled R4300i OpCode in FillSectionInfo 4\n%s", g_Notify->DisplayError("Unhandled R4300i OpCode in FillSectionInfo 4\n%s",
R4300iOpcodeName(m_Command.Hex,m_PC)); R4300iOpcodeName(m_Command.Hex, m_PC));
m_NextInstruction = END_BLOCK; m_NextInstruction = END_BLOCK;
m_PC -= 4; m_PC -= 4;
#endif #endif
@ -382,11 +383,11 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
#ifdef legacycode #ifdef legacycode
m_NextInstruction = DELAY_SLOT; m_NextInstruction = DELAY_SLOT;
m_Reg.GetMipsRegLo(31) = m_PC + 8; m_Reg.GetMipsRegLo(31) = m_PC + 8;
m_Reg.SetMipsRegState(31,CRegInfo::STATE_CONST_32_SIGN); m_Reg.SetMipsRegState(31, CRegInfo::STATE_CONST_32_SIGN);
Section->m_Jump.TargetPC = (m_PC & 0xF0000000) + (m_Command.target << 2); Section->m_Jump.TargetPC = (m_PC & 0xF0000000) + (m_Command.target << 2);
if (m_PC == Section->m_Jump.TargetPC) if (m_PC == Section->m_Jump.TargetPC)
{ {
if (!DelaySlotEffectsCompare(m_PC,31,0)) if (!DelaySlotEffectsCompare(m_PC, 31, 0))
{ {
Section->m_Jump.PermLoop = true; Section->m_Jump.PermLoop = true;
} }
@ -546,14 +547,14 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
case R4300i_COP0_CO_TLBP: break; case R4300i_COP0_CO_TLBP: break;
case R4300i_COP0_CO_ERET: m_NextInstruction = END_BLOCK; break; case R4300i_COP0_CO_ERET: m_NextInstruction = END_BLOCK; break;
default: default:
g_Notify->DisplayError(stdstr_f("Unhandled R4300i OpCode in FillSectionInfo\n%s", R4300iOpcodeName(m_Command.Hex, m_PC)).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Unhandled R4300i OpCode in FillSectionInfo\n%s", R4300iOpcodeName(m_Command.Hex, m_PC)).c_str());
m_NextInstruction = END_BLOCK; m_NextInstruction = END_BLOCK;
m_PC -= 4; m_PC -= 4;
} }
} }
else else
{ {
g_Notify->DisplayError(stdstr_f("Unhandled R4300i OpCode in FillSectionInfo 3\n%s", R4300iOpcodeName(m_Command.Hex, m_PC)).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Unhandled R4300i OpCode in FillSectionInfo 3\n%s", R4300iOpcodeName(m_Command.Hex, m_PC)).c_str());
m_NextInstruction = END_BLOCK; m_NextInstruction = END_BLOCK;
m_PC -= 4; m_PC -= 4;
} }
@ -585,7 +586,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
#ifdef legacycode #ifdef legacycode
if (!DelaySlotEffectsCompare(m_PC,m_Command.rs,m_Command.rt)) if (!DelaySlotEffectsCompare(m_PC, m_Command.rs, m_Command.rt))
{ {
if (!Section->m_Jump.PermLoop) if (!Section->m_Jump.PermLoop)
{ {
@ -614,7 +615,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
{ {
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
#ifdef legacycode #ifdef legacycode
if (!DelaySlotEffectsCompare(m_PC,m_Command.rs,m_Command.rt)) { if (!DelaySlotEffectsCompare(m_PC, m_Command.rs, m_Command.rt)) {
Section->m_Jump.PermLoop = true; Section->m_Jump.PermLoop = true;
} }
#endif #endif
@ -631,7 +632,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
case R4300i_COP1_W: break; case R4300i_COP1_W: break;
case R4300i_COP1_L: break; case R4300i_COP1_L: break;
default: default:
g_Notify->DisplayError(stdstr_f("Unhandled R4300i OpCode in FillSectionInfo 2\n%s", R4300iOpcodeName(m_Command.Hex, m_PC)).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Unhandled R4300i OpCode in FillSectionInfo 2\n%s", R4300iOpcodeName(m_Command.Hex, m_PC)).c_str());
m_NextInstruction = END_BLOCK; m_NextInstruction = END_BLOCK;
m_PC -= 4; m_PC -= 4;
} }
@ -731,7 +732,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
if (m_Command.Hex == 0xF1F3F5F7) { break; } if (m_Command.Hex == 0xF1F3F5F7) { break; }
if (m_Command.Hex == 0xC1200000) { break; } if (m_Command.Hex == 0xC1200000) { break; }
if (m_Command.Hex == 0x4C5A5353) { break; } if (m_Command.Hex == 0x4C5A5353) { break; }
g_Notify->DisplayError(stdstr_f("Unhandled R4300i OpCode in FillSectionInfo 1\n%s\n%X", R4300iOpcodeName(m_Command.Hex, m_PC), m_Command.Hex).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Unhandled R4300i OpCode in FillSectionInfo 1\n%s\n%X", R4300iOpcodeName(m_Command.Hex, m_PC), m_Command.Hex).c_str());
} }
CPU_Message(" %s state: %X value: %X", CRegName::GPR[5], m_Reg.GetMipsRegState(5), m_Reg.GetMipsRegLo(5)); CPU_Message(" %s state: %X value: %X", CRegName::GPR[5], m_Reg.GetMipsRegState(5), m_Reg.GetMipsRegLo(5));
@ -953,7 +954,7 @@ void LoopAnalysis::SPECIAL_JALR()
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
#ifdef legacycode #ifdef legacycode
m_Reg.GetMipsRegLo(m_Command.rd) = m_PC + 8; m_Reg.GetMipsRegLo(m_Command.rd) = m_PC + 8;
m_Reg.SetMipsRegState(m_Command.rd,CRegInfo::STATE_CONST_32_SIGN); m_Reg.SetMipsRegState(m_Command.rd, CRegInfo::STATE_CONST_32_SIGN);
if (m_Reg.IsConst(m_Command.rs)) { if (m_Reg.IsConst(m_Command.rs)) {
Section->m_Jump.TargetPC = m_Reg.GetMipsRegLo(m_Command.rs); Section->m_Jump.TargetPC = m_Reg.GetMipsRegLo(m_Command.rs);
} }

18
Source/Project64-core/N64System/Recompiler/RecompilerClass.cpp
View File

@ -117,7 +117,7 @@ void CRecompiler::RecompilerMain_VirtualTable()
m_Registers.DoTLBReadMiss(false, PC); m_Registers.DoTLBReadMiss(false, PC);
if (!g_TransVaddr->ValidVaddr(PC)) if (!g_TransVaddr->ValidVaddr(PC))
{ {
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PC).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PC).c_str());
return; return;
} }
continue; continue;
@ -182,7 +182,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
NextInstruction = NORMAL; NextInstruction = NORMAL;
if (!g_TLB->ValidVaddr(PROGRAM_COUNTER)) if (!g_TLB->ValidVaddr(PROGRAM_COUNTER))
{ {
g_Notify->DisplayError(L"Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER); g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
return; return;
} }
continue; continue;
@ -242,7 +242,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
NextInstruction = NORMAL; NextInstruction = NORMAL;
if (!g_TLB->ValidVaddr(PROGRAM_COUNTER)) if (!g_TLB->ValidVaddr(PROGRAM_COUNTER))
{ {
g_Notify->DisplayError(L"Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER); g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
return; return;
} }
} }
@ -264,7 +264,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
NextInstruction = NORMAL; NextInstruction = NORMAL;
if (!g_MMU->ValidVaddr(PROGRAM_COUNTER)) if (!g_MMU->ValidVaddr(PROGRAM_COUNTER))
{ {
g_Notify->DisplayError(L"Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER); g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
return; return;
} }
} }
@ -390,7 +390,7 @@ void CRecompiler::RecompilerMain_Lookup()
DoTLBMiss(NextInstruction == DELAY_SLOT,PROGRAM_COUNTER); DoTLBMiss(NextInstruction == DELAY_SLOT,PROGRAM_COUNTER);
NextInstruction = NORMAL; NextInstruction = NORMAL;
if (!TranslateVaddr(PROGRAM_COUNTER, &Addr)) { if (!TranslateVaddr(PROGRAM_COUNTER, &Addr)) {
g_Notify->DisplayError(L"Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER); g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
return; return;
} }
} }
@ -537,7 +537,7 @@ void CRecompiler::RecompilerMain_Lookup_TLB()
m_Registers.DoTLBReadMiss(false, PROGRAM_COUNTER); m_Registers.DoTLBReadMiss(false, PROGRAM_COUNTER);
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr)) if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr))
{ {
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PROGRAM_COUNTER).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PROGRAM_COUNTER).c_str());
m_EndEmulation = true; m_EndEmulation = true;
} }
continue; continue;
@ -643,7 +643,7 @@ void CRecompiler::RecompilerMain_Lookup_validate_TLB()
m_Registers.DoTLBReadMiss(false, PROGRAM_COUNTER); m_Registers.DoTLBReadMiss(false, PROGRAM_COUNTER);
if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr)) if (!g_TransVaddr->TranslateVaddr(PROGRAM_COUNTER, PhysicalAddr))
{ {
g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PROGRAM_COUNTER).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Failed to translate PC to a PAddr: %X\n\nEmulation stopped", PROGRAM_COUNTER).c_str());
m_EndEmulation = true; m_EndEmulation = true;
} }
continue; continue;
@ -750,7 +750,7 @@ void CRecompiler::RecompilerMain_ChangeMemory()
NextInstruction = NORMAL; NextInstruction = NORMAL;
if (!TranslateVaddr(PROGRAM_COUNTER, &Addr)) if (!TranslateVaddr(PROGRAM_COUNTER, &Addr))
{ {
g_Notify->DisplayError(L"Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER); g_Notify->DisplayError("Failed to translate PC to a PAddr: %X\n\nEmulation stopped",PROGRAM_COUNTER);
ExitThread(0); ExitThread(0);
} }
} }
@ -766,7 +766,7 @@ void CRecompiler::RecompilerMain_ChangeMemory()
} }
__except(EXCEPTION_EXECUTE_HANDLER) __except(EXCEPTION_EXECUTE_HANDLER)
{ {
g_Notify->DisplayError(L"Executing Delay Slot from non maped space\nPROGRAM_COUNTER = 0x%X",PROGRAM_COUNTER); g_Notify->DisplayError("Executing Delay Slot from non maped space\nPROGRAM_COUNTER = 0x%X",PROGRAM_COUNTER);
ExitThread(0); ExitThread(0);
} }
if ( (Value >> 16) == 0x7C7C) if ( (Value >> 16) == 0x7C7C)

2
Source/Project64-core/N64System/Recompiler/RecompilerMemory.cpp
View File

@ -91,5 +91,5 @@ void CRecompMemory::ShowMemUsed()
uint32_t TotalAvaliable = m_RecompSize / 0x100000; uint32_t TotalAvaliable = m_RecompSize / 0x100000;
g_Notify->DisplayMessage(0, stdstr_f("Memory used: %d mb %-3d kb %-3d bytes Total Available: %d mb", MB, KB, Size, TotalAvaliable).ToUTF16().c_str()); g_Notify->DisplayMessage(0, stdstr_f("Memory used: %d mb %-3d kb %-3d bytes Total Available: %d mb", MB, KB, Size, TotalAvaliable).c_str());
} }

46
Source/Project64-core/N64System/Recompiler/RecompilerOps.cpp
View File

@ -94,7 +94,7 @@ void CRecompilerOps::Compile_Branch(CRecompilerOps::BranchFunction CompareFunc,
} }
break; break;
default: default:
if (bHaveDebugger()) { g_Notify->DisplayError(L"Unknown branch type"); } if (bHaveDebugger()) { g_Notify->DisplayError("Unknown branch type"); }
} }
} }
else else
@ -360,7 +360,7 @@ void CRecompilerOps::Compile_Branch(CRecompilerOps::BranchFunction CompareFunc,
{ {
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction).c_str());
} }
} }
} }
@ -509,7 +509,7 @@ void CRecompilerOps::Compile_BranchLikely(BranchFunction CompareFunc, bool Link)
} }
else if (bHaveDebugger()) else if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("WTF\n\nBranchLikely\nNextInstruction = %X", m_NextInstruction).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("WTF\n\nBranchLikely\nNextInstruction = %X", m_NextInstruction).c_str());
} }
} }
@ -1812,7 +1812,7 @@ void CRecompilerOps::J()
} }
else if (bHaveDebugger()) else if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("WTF\n\nJ\nNextInstruction = %X", m_NextInstruction).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("WTF\n\nJ\nNextInstruction = %X", m_NextInstruction).c_str());
} }
} }
@ -2354,7 +2354,7 @@ void CRecompilerOps::CACHE()
default: default:
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("cache: %d", m_Opcode.rt).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("cache: %d", m_Opcode.rt).c_str());
} }
} }
} }
@ -2633,7 +2633,7 @@ void CRecompilerOps::SPECIAL_JR()
} }
else if (bHaveDebugger()) else if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction).c_str());
} }
} }
@ -2716,7 +2716,7 @@ void CRecompilerOps::SPECIAL_JALR()
} }
else if (bHaveDebugger()) else if (bHaveDebugger())
{ {
g_Notify->DisplayError(stdstr_f("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("WTF\n\nBranch\nNextInstruction = %X", m_NextInstruction).c_str());
} }
} }
@ -3210,40 +3210,40 @@ void CRecompilerOps::SPECIAL_DMULTU()
#ifdef toremove #ifdef toremove
/* _RegLO->UDW = (uint64)_GPR[m_Opcode.rs].UW[0] * (uint64)_GPR[m_Opcode.rt].UW[0]; */ /* _RegLO->UDW = (uint64)_GPR[m_Opcode.rs].UW[0] * (uint64)_GPR[m_Opcode.rt].UW[0]; */
X86Protected(x86_EDX) = true; X86Protected(x86_EDX) = true;
Map_TempReg(x86_EAX,m_Opcode.rs,false); Map_TempReg(x86_EAX, m_Opcode.rs, false);
X86Protected(x86_EDX) = false; X86Protected(x86_EDX) = false;
Map_TempReg(x86_EDX,m_Opcode.rt,false); Map_TempReg(x86_EDX, m_Opcode.rt, false);
MulX86reg(x86_EDX); MulX86reg(x86_EDX);
MoveX86regToVariable(x86_EAX, &_RegLO->UW[0], "_RegLO->UW[0]"); MoveX86regToVariable(x86_EAX, &_RegLO->UW[0], "_RegLO->UW[0]");
MoveX86regToVariable(x86_EDX, &_RegLO->UW[1], "_RegLO->UW[1]"); MoveX86regToVariable(x86_EDX, &_RegLO->UW[1], "_RegLO->UW[1]");
/* _RegHI->UDW = (uint64)_GPR[m_Opcode.rs].UW[1] * (uint64)_GPR[m_Opcode.rt].UW[1]; */ /* _RegHI->UDW = (uint64)_GPR[m_Opcode.rs].UW[1] * (uint64)_GPR[m_Opcode.rt].UW[1]; */
Map_TempReg(x86_EAX,m_Opcode.rs,true); Map_TempReg(x86_EAX, m_Opcode.rs, true);
Map_TempReg(x86_EDX,m_Opcode.rt,true); Map_TempReg(x86_EDX, m_Opcode.rt, true);
MulX86reg(x86_EDX); MulX86reg(x86_EDX);
MoveX86regToVariable(x86_EAX, &_RegHI->UW[0], "_RegHI->UW[0]"); MoveX86regToVariable(x86_EAX, &_RegHI->UW[0], "_RegHI->UW[0]");
MoveX86regToVariable(x86_EDX, &_RegHI->UW[1], "_RegHI->UW[1]"); MoveX86regToVariable(x86_EDX, &_RegHI->UW[1], "_RegHI->UW[1]");
/* Tmp[0].UDW = (uint64)_GPR[m_Opcode.rs].UW[1] * (uint64)_GPR[m_Opcode.rt].UW[0]; */ /* Tmp[0].UDW = (uint64)_GPR[m_Opcode.rs].UW[1] * (uint64)_GPR[m_Opcode.rt].UW[0]; */
Map_TempReg(x86_EAX,m_Opcode.rs,true); Map_TempReg(x86_EAX, m_Opcode.rs, true);
Map_TempReg(x86_EDX,m_Opcode.rt,false); Map_TempReg(x86_EDX, m_Opcode.rt, false);
Map_TempReg(x86_EBX,-1,false); Map_TempReg(x86_EBX, -1, false);
Map_TempReg(x86_ECX,-1,false); Map_TempReg(x86_ECX, -1, false);
MulX86reg(x86_EDX); MulX86reg(x86_EDX);
MoveX86RegToX86Reg(x86_EAX, x86_EBX); /* EDX:EAX -> ECX:EBX */ MoveX86RegToX86Reg(x86_EAX, x86_EBX); /* EDX:EAX -> ECX:EBX */
MoveX86RegToX86Reg(x86_EDX, x86_ECX); MoveX86RegToX86Reg(x86_EDX, x86_ECX);
/* Tmp[1].UDW = (uint64)_GPR[m_Opcode.rs].UW[0] * (uint64)_GPR[m_Opcode.rt].UW[1]; */ /* Tmp[1].UDW = (uint64)_GPR[m_Opcode.rs].UW[0] * (uint64)_GPR[m_Opcode.rt].UW[1]; */
Map_TempReg(x86_EAX,m_Opcode.rs,false); Map_TempReg(x86_EAX, m_Opcode.rs, false);
Map_TempReg(x86_EDX,m_Opcode.rt,true); Map_TempReg(x86_EDX, m_Opcode.rt, true);
MulX86reg(x86_EDX); MulX86reg(x86_EDX);
Map_TempReg(x86_ESI,-1,false); Map_TempReg(x86_ESI, -1, false);
Map_TempReg(x86_EDI,-1,false); Map_TempReg(x86_EDI, -1, false);
MoveX86RegToX86Reg(x86_EAX, x86_ESI); /* EDX:EAX -> EDI:ESI */ MoveX86RegToX86Reg(x86_EAX, x86_ESI); /* EDX:EAX -> EDI:ESI */
MoveX86RegToX86Reg(x86_EDX, x86_EDI); MoveX86RegToX86Reg(x86_EDX, x86_EDI);
@ -3881,7 +3881,7 @@ void CRecompilerOps::SPECIAL_XOR()
if (Is64Bit(m_Opcode.rt) || Is64Bit(m_Opcode.rs)) if (Is64Bit(m_Opcode.rt) || Is64Bit(m_Opcode.rs))
{ {
if (bHaveDebugger()) { g_Notify->DisplayError(L"XOR 1"); } if (bHaveDebugger()) { g_Notify->DisplayError("XOR 1"); }
CRecompilerOps::UnknownOpcode(); CRecompilerOps::UnknownOpcode();
} }
else else
@ -4199,7 +4199,7 @@ void CRecompilerOps::SPECIAL_SLT()
{ {
if (Is64Bit(m_Opcode.rt) || Is64Bit(m_Opcode.rs)) if (Is64Bit(m_Opcode.rt) || Is64Bit(m_Opcode.rs))
{ {
g_Notify->DisplayError(L"1"); g_Notify->DisplayError("1");
CRecompilerOps::UnknownOpcode(); CRecompilerOps::UnknownOpcode();
} }
else else
@ -4515,7 +4515,7 @@ void CRecompilerOps::SPECIAL_SLTU()
{ {
if (Is64Bit(m_Opcode.rt) || Is64Bit(m_Opcode.rs)) if (Is64Bit(m_Opcode.rt) || Is64Bit(m_Opcode.rs))
{ {
g_Notify->DisplayError(L"1"); g_Notify->DisplayError("1");
CRecompilerOps::UnknownOpcode(); CRecompilerOps::UnknownOpcode();
} }
else else
@ -5470,7 +5470,7 @@ void CRecompilerOps::COP0_MT()
if (IsConst(m_Opcode.rt)) if (IsConst(m_Opcode.rt))
{ {
AndConstToVariable(0xFFFFCFF, &_CP0[m_Opcode.rd], CRegName::Cop0[m_Opcode.rd]); AndConstToVariable(0xFFFFCFF, &_CP0[m_Opcode.rd], CRegName::Cop0[m_Opcode.rd]);
if ((GetMipsRegLo(m_Opcode.rt) & 0x300) != 0 && bHaveDebugger()){ g_Notify->DisplayError(L"Set IP0 or IP1"); } if ((GetMipsRegLo(m_Opcode.rt) & 0x300) != 0 && bHaveDebugger()){ g_Notify->DisplayError("Set IP0 or IP1"); }
} }
else else
{ {

24
Source/Project64-core/N64System/Recompiler/RegInfo.cpp
View File

@ -175,7 +175,7 @@ void CRegInfo::FixRoundModel(FPU_ROUND RoundMethod)
case RoundDown: OrConstToX86Reg(0x0400, reg); break; case RoundDown: OrConstToX86Reg(0x0400, reg); break;
case RoundUp: OrConstToX86Reg(0x0800, reg); break; case RoundUp: OrConstToX86Reg(0x0800, reg); break;
default: default:
g_Notify->DisplayError(L"Unknown Rounding model"); g_Notify->DisplayError("Unknown Rounding model");
} }
} }
MoveX86regToVariable(reg, &m_fpuControl, "m_fpuControl"); MoveX86regToVariable(reg, &m_fpuControl, "m_fpuControl");
@ -209,7 +209,7 @@ void CRegInfo::ChangeFPURegFormat(int32_t Reg, FPU_STATE OldFormat, FPU_STATE Ne
if (bHaveDebugger()) if (bHaveDebugger())
{ {
g_Notify->DisplayError(L"ChangeFormat: Register not on stack!!"); g_Notify->DisplayError("ChangeFormat: Register not on stack!!");
} }
} }
@ -222,8 +222,8 @@ void CRegInfo::Load_FPR_ToTop(int32_t Reg, int32_t RegToLoad, FPU_STATE Format)
CPU_Message("CurrentRoundingModel: %s FpuRoundingModel(StackTopPos()): %s", RoundingModelName(GetRoundingModel()), RoundingModelName(FpuRoundingModel(StackTopPos()))); CPU_Message("CurrentRoundingModel: %s FpuRoundingModel(StackTopPos()): %s", RoundingModelName(GetRoundingModel()), RoundingModelName(FpuRoundingModel(StackTopPos())));
int32_t i; int32_t i;
if (RegToLoad < 0) { g_Notify->DisplayError(L"Load_FPR_ToTop\nRegToLoad < 0 ???"); return; } if (RegToLoad < 0) { g_Notify->DisplayError("Load_FPR_ToTop\nRegToLoad < 0 ???"); return; }
if (Reg < 0) { g_Notify->DisplayError(L"Load_FPR_ToTop\nReg < 0 ???"); return; } if (Reg < 0) { g_Notify->DisplayError("Load_FPR_ToTop\nReg < 0 ???"); return; }
if (Format == FPU_Double || Format == FPU_Qword) if (Format == FPU_Double || Format == FPU_Qword)
{ {
@ -384,7 +384,7 @@ void CRegInfo::Load_FPR_ToTop(int32_t Reg, int32_t RegToLoad, FPU_STATE Format)
fpuLoadQwordFromX86Reg(&StackTopPos(), TempReg); fpuLoadQwordFromX86Reg(&StackTopPos(), TempReg);
break; break;
default: default:
if (bHaveDebugger()) { g_Notify->DisplayError(stdstr_f("Load_FPR_ToTop\nUnkown format to load %d", Format).ToUTF16().c_str()); } if (bHaveDebugger()) { g_Notify->DisplayError(stdstr_f("Load_FPR_ToTop\nUnkown format to load %d", Format).c_str()); }
} }
SetX86Protected(TempReg, false); SetX86Protected(TempReg, false);
FpuRoundingModel(StackTopPos()) = RoundDefault; FpuRoundingModel(StackTopPos()) = RoundDefault;
@ -575,7 +575,7 @@ CRegInfo::x86Reg CRegInfo::Map_MemoryStack(x86Reg Reg, bool bMapRegister, bool L
Reg = FreeX86Reg(); Reg = FreeX86Reg();
if (Reg == x86_Unknown) if (Reg == x86_Unknown)
{ {
g_Notify->DisplayError(L"Map_MemoryStack\n\nOut of registers"); g_Notify->DisplayError("Map_MemoryStack\n\nOut of registers");
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
} }
SetX86Mapped(Reg, CRegInfo::Stack_Mapped); SetX86Mapped(Reg, CRegInfo::Stack_Mapped);
@ -624,7 +624,7 @@ void CRegInfo::Map_GPR_32bit(int32_t MipsReg, bool SignValue, int32_t MipsRegToL
Reg = FreeX86Reg(); Reg = FreeX86Reg();
if (Reg < 0) if (Reg < 0)
{ {
if (bHaveDebugger()) { g_Notify->DisplayError(L"Map_GPR_32bit\n\nOut of registers"); } if (bHaveDebugger()) { g_Notify->DisplayError("Map_GPR_32bit\n\nOut of registers"); }
g_Notify->BreakPoint(__FILE__, __LINE__); g_Notify->BreakPoint(__FILE__, __LINE__);
return; return;
} }
@ -687,7 +687,7 @@ void CRegInfo::Map_GPR_64bit(int32_t MipsReg, int32_t MipsRegToLoad)
if (MipsReg == 0) if (MipsReg == 0)
{ {
if (bHaveDebugger()) { g_Notify->DisplayError(L"Map_GPR_32bit\n\nWhy are you trying to map reg 0"); } if (bHaveDebugger()) { g_Notify->DisplayError("Map_GPR_32bit\n\nWhy are you trying to map reg 0"); }
return; return;
} }
@ -697,13 +697,13 @@ void CRegInfo::Map_GPR_64bit(int32_t MipsReg, int32_t MipsRegToLoad)
x86Hi = FreeX86Reg(); x86Hi = FreeX86Reg();
if (x86Hi < 0) if (x86Hi < 0)
{ {
if (bHaveDebugger()) { g_Notify->DisplayError(L"Map_GPR_64bit\n\nOut of registers"); } if (bHaveDebugger()) { g_Notify->DisplayError("Map_GPR_64bit\n\nOut of registers"); }
return; return;
} }
SetX86Protected(x86Hi, true); SetX86Protected(x86Hi, true);
x86lo = FreeX86Reg(); x86lo = FreeX86Reg();
if (x86lo < 0) { g_Notify->DisplayError(L"Map_GPR_64bit\n\nOut of registers"); return; } if (x86lo < 0) { g_Notify->DisplayError("Map_GPR_64bit\n\nOut of registers"); return; }
SetX86Protected(x86lo, true); SetX86Protected(x86lo, true);
CPU_Message(" regcache: allocate %s to hi word of %s", x86_Name(x86Hi), CRegName::GPR[MipsReg]); CPU_Message(" regcache: allocate %s to hi word of %s", x86_Name(x86Hi), CRegName::GPR[MipsReg]);
@ -1116,7 +1116,7 @@ void CRegInfo::UnMap_FPR(int32_t Reg, bool WriteBackValue)
fpuStoreQwordFromX86Reg(&StackTopPos(), TempReg, true); fpuStoreQwordFromX86Reg(&StackTopPos(), TempReg, true);
break; break;
default: default:
if (bHaveDebugger()) { g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nUnknown format to load %d", m_x86fpu_State[StackTopPos()]).ToUTF16().c_str()); } if (bHaveDebugger()) { g_Notify->DisplayError(stdstr_f(__FUNCTION__ "\nUnknown format to load %d", m_x86fpu_State[StackTopPos()]).c_str()); }
} }
SetX86Protected(TempReg, false); SetX86Protected(TempReg, false);
FpuRoundingModel(RegPos) = RoundDefault; FpuRoundingModel(RegPos) = RoundDefault;
@ -1140,7 +1140,7 @@ void CRegInfo::UnMap_GPR(uint32_t Reg, bool WriteBackValue)
{ {
if (Reg == 0) if (Reg == 0)
{ {
if (bHaveDebugger()) { g_Notify->DisplayError(__FUNCTIONW__ L"\n\nWhy are you trying to unmap reg 0"); } if (bHaveDebugger()) { g_Notify->DisplayError(__FUNCTION__ "\n\nWhy are you trying to unmap reg 0"); }
return; return;
} }

2
Source/Project64-core/N64System/SpeedLimiterClass.cpp
View File

@ -28,7 +28,7 @@ CSpeedLimiter::CSpeedLimiter()
timeGetDevCaps(&Caps, sizeof(Caps)); timeGetDevCaps(&Caps, sizeof(Caps));
if (timeBeginPeriod(Caps.wPeriodMin) == TIMERR_NOCANDO) if (timeBeginPeriod(Caps.wPeriodMin) == TIMERR_NOCANDO)
{ {
g_Notify->DisplayError(L"Error during timer begin"); g_Notify->DisplayError("Error during timer begin");
} }
} }

10
Source/Project64-core/Notification.h
View File

@ -10,19 +10,19 @@ __interface CNotification
{ {
public: public:
//Error Messages //Error Messages
virtual void DisplayError(const wchar_t * Message) const = 0; virtual void DisplayError(const char * Message) const = 0;
virtual void DisplayError(LanguageStringID StringID) const = 0; virtual void DisplayError(LanguageStringID StringID) const = 0;
virtual void FatalError(const wchar_t * Message) const = 0; virtual void FatalError(const char * Message) const = 0;
virtual void FatalError(LanguageStringID StringID) const = 0; virtual void FatalError(LanguageStringID StringID) const = 0;
//User Feedback //User Feedback
virtual void DisplayMessage(int DisplayTime, const wchar_t * Message) const = 0; virtual void DisplayMessage(int DisplayTime, const char * Message) const = 0;
virtual void DisplayMessage(int DisplayTime, LanguageStringID StringID) const = 0; virtual void DisplayMessage(int DisplayTime, LanguageStringID StringID) const = 0;
virtual void DisplayMessage2(const wchar_t * Message) const = 0; virtual void DisplayMessage2(const char * Message) const = 0;
// Ask a Yes/No Question to the user, yes = true, no = false // Ask a Yes/No Question to the user, yes = true, no = false
virtual bool AskYesNoQuestion(const wchar_t * Question) const = 0; virtual bool AskYesNoQuestion(const char * Question) const = 0;
virtual void BreakPoint(const char * FileName, int32_t LineNumber) = 0; virtual void BreakPoint(const char * FileName, int32_t LineNumber) = 0;

4
Source/Project64/Multilanguage/LanguageSelector.cpp
View File

@ -40,7 +40,7 @@ LRESULT CALLBACK CLanguageSelector::LangSelectProc(HWND hDlg, UINT uMsg, WPARAM
for (LanguageList::iterator Language = LangList.begin(); Language != LangList.end(); Language++) for (LanguageList::iterator Language = LangList.begin(); Language != LangList.end(); Language++)
{ {
int index = SendMessageW(GetDlgItem(hDlg, IDC_LANG_SEL), CB_ADDSTRING, 0, (WPARAM)Language->LanguageName.c_str()); int index = SendMessageW(GetDlgItem(hDlg, IDC_LANG_SEL), CB_ADDSTRING, 0, (WPARAM)Language->LanguageName.c_str());
if (_wcsicmp(Language->LanguageName.c_str(), L"English") == 0) if (_stricmp(Language->LanguageName.c_str(), "English") == 0)
{ {
SendMessage(GetDlgItem(hDlg, IDC_LANG_SEL), CB_SETCURSEL, index, 0); SendMessage(GetDlgItem(hDlg, IDC_LANG_SEL), CB_SETCURSEL, index, 0);
} }
@ -144,7 +144,7 @@ LRESULT CALLBACK CLanguageSelector::LangSelectProc(HWND hDlg, UINT uMsg, WPARAM
{ {
wchar_t String[255]; wchar_t String[255];
SendMessageW(GetDlgItem(hDlg, IDC_LANG_SEL), CB_GETLBTEXT, Index, (LPARAM)String); SendMessageW(GetDlgItem(hDlg, IDC_LANG_SEL), CB_GETLBTEXT, Index, (LPARAM)String);
g_Lang->SetLanguage(String); g_Lang->SetLanguage(stdstr().FromUTF16(String).c_str());
} }
} }

4
Source/Project64/N64System/Debugger/Debugger-MemoryDump.cpp
View File

@ -90,7 +90,7 @@ LRESULT CDumpMemory::OnClicked(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/,
GetDlgItemText(IDC_FILENAME, FileName, sizeof(FileName)); GetDlgItemText(IDC_FILENAME, FileName, sizeof(FileName));
if (strlen(FileName) == 0) if (strlen(FileName) == 0)
{ {
g_Notify->DisplayError(L"Please Choose target file"); g_Notify->DisplayError("Please Choose target file");
::SetFocus(GetDlgItem(IDC_FILENAME)); ::SetFocus(GetDlgItem(IDC_FILENAME));
return false; return false;
} }
@ -132,7 +132,7 @@ bool CDumpMemory::DumpMemory(LPCSTR FileName, DumpFormat Format, DWORD StartPC,
CLog LogFile; CLog LogFile;
if (!LogFile.Open(FileName)) if (!LogFile.Open(FileName))
{ {
g_Notify->DisplayError(stdstr_f("Failed to open\n%s", FileName).ToUTF16().c_str()); g_Notify->DisplayError(stdstr_f("Failed to open\n%s", FileName).c_str());
return false; return false;
} }
LogFile.SetFlush(false); LogFile.SetFlush(false);

26
Source/Project64/N64System/RomInformationClass.cpp
View File

@ -55,21 +55,21 @@ DWORD CALLBACK RomInfoProc(HWND hDlg, DWORD uMsg, DWORD wParam, DWORD lParam) {
LONG_PTR originalWndProc = GetWindowLongPtrW(hDlg, GWLP_WNDPROC); LONG_PTR originalWndProc = GetWindowLongPtrW(hDlg, GWLP_WNDPROC);
SetWindowLongPtrW(hDlg, GWLP_WNDPROC, (LONG_PTR)DefWindowProcW); SetWindowLongPtrW(hDlg, GWLP_WNDPROC, (LONG_PTR)DefWindowProcW);
SetWindowTextW(hDlg, GS(INFO_TITLE)); SetWindowTextW(hDlg, wGS(INFO_TITLE).c_str());
SetWindowLongPtrW(hDlg, GWLP_WNDPROC, originalWndProc); SetWindowLongPtrW(hDlg, GWLP_WNDPROC, originalWndProc);
SetDlgItemTextW(hDlg, IDC_ROM_NAME, GS(INFO_ROM_NAME_TEXT)); SetDlgItemTextW(hDlg, IDC_ROM_NAME, wGS(INFO_ROM_NAME_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_FILE_NAME, GS(INFO_FILE_NAME_TEXT)); SetDlgItemTextW(hDlg, IDC_FILE_NAME, wGS(INFO_FILE_NAME_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_LOCATION, GS(INFO_LOCATION_TEXT)); SetDlgItemTextW(hDlg, IDC_LOCATION, wGS(INFO_LOCATION_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_ROM_MD5, GS(INFO_MD5_TEXT)); SetDlgItemTextW(hDlg, IDC_ROM_MD5, wGS(INFO_MD5_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_ROM_SIZE, GS(INFO_SIZE_TEXT)); SetDlgItemTextW(hDlg, IDC_ROM_SIZE, wGS(INFO_SIZE_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_CART_ID, GS(INFO_CART_ID_TEXT)); SetDlgItemTextW(hDlg, IDC_CART_ID, wGS(INFO_CART_ID_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_MANUFACTURER, GS(INFO_MANUFACTURER_TEXT)); SetDlgItemTextW(hDlg, IDC_MANUFACTURER, wGS(INFO_MANUFACTURER_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_COUNTRY, GS(INFO_COUNTRY_TEXT)); SetDlgItemTextW(hDlg, IDC_COUNTRY, wGS(INFO_COUNTRY_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_CRC1, GS(INFO_CRC1_TEXT)); SetDlgItemTextW(hDlg, IDC_CRC1, wGS(INFO_CRC1_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_CRC2, GS(INFO_CRC2_TEXT)); SetDlgItemTextW(hDlg, IDC_CRC2, wGS(INFO_CRC2_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_CIC_CHIP, GS(INFO_CIC_CHIP_TEXT)); SetDlgItemTextW(hDlg, IDC_CIC_CHIP, wGS(INFO_CIC_CHIP_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_CLOSE_BUTTON, GS(BOTTOM_CLOSE)); SetDlgItemTextW(hDlg, IDC_CLOSE_BUTTON, wGS(BOTTOM_CLOSE).c_str());
SetDlgItemTextW(hDlg, IDC_INFO_ROMNAME, _this->m_pRomInfo->GetRomName().ToUTF16(stdstr::CODEPAGE_932).c_str()); SetDlgItemTextW(hDlg, IDC_INFO_ROMNAME, _this->m_pRomInfo->GetRomName().ToUTF16(stdstr::CODEPAGE_932).c_str());

52
Source/Project64/UserInterface/CheatClassUI.cpp
View File

@ -159,7 +159,7 @@ bool CCheatsUI::CheatChanged(HWND hDlg)
{ {
return false; return false;
} }
int Result = MessageBoxW(hDlg, GS(CHEAT_CHANGED_MSG), GS(CHEAT_CHANGED_TITLE), MB_YESNOCANCEL); int Result = MessageBoxW(hDlg, wGS(CHEAT_CHANGED_MSG).c_str(), wGS(CHEAT_CHANGED_TITLE).c_str(), MB_YESNOCANCEL);
if (Result == IDCANCEL) if (Result == IDCANCEL)
{ {
return true; return true;
@ -188,15 +188,15 @@ int CALLBACK CCheatsUI::CheatAddProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
CCheatsUI * _this = (CCheatsUI *)lParam; CCheatsUI * _this = (CCheatsUI *)lParam;
SetProp(hDlg, "Class", _this); SetProp(hDlg, "Class", _this);
SetWindowTextW(hDlg, GS(CHEAT_ADDCHEAT_FRAME)); SetWindowTextW(hDlg, wGS(CHEAT_ADDCHEAT_FRAME).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_NAME), GS(CHEAT_ADDCHEAT_NAME)); SetWindowTextW(GetDlgItem(hDlg, IDC_NAME), wGS(CHEAT_ADDCHEAT_NAME).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_CODE), GS(CHEAT_ADDCHEAT_CODE)); SetWindowTextW(GetDlgItem(hDlg, IDC_CODE), wGS(CHEAT_ADDCHEAT_CODE).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_LABEL_OPTIONS), GS(CHEAT_ADDCHEAT_OPT)); SetWindowTextW(GetDlgItem(hDlg, IDC_LABEL_OPTIONS), wGS(CHEAT_ADDCHEAT_OPT).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_CODE_DES), GS(CHEAT_ADDCHEAT_CODEDES)); SetWindowTextW(GetDlgItem(hDlg, IDC_CODE_DES), wGS(CHEAT_ADDCHEAT_CODEDES).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_LABEL_OPTIONS_FORMAT), GS(CHEAT_ADDCHEAT_OPTDES)); SetWindowTextW(GetDlgItem(hDlg, IDC_LABEL_OPTIONS_FORMAT), wGS(CHEAT_ADDCHEAT_OPTDES).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_CHEATNOTES), GS(CHEAT_ADDCHEAT_NOTES)); SetWindowTextW(GetDlgItem(hDlg, IDC_CHEATNOTES), wGS(CHEAT_ADDCHEAT_NOTES).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_NEWCHEAT), GS(CHEAT_ADDCHEAT_NEW)); SetWindowTextW(GetDlgItem(hDlg, IDC_NEWCHEAT), wGS(CHEAT_ADDCHEAT_NEW).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_ADD), GS(CHEAT_ADDCHEAT_ADD)); SetWindowTextW(GetDlgItem(hDlg, IDC_ADD), wGS(CHEAT_ADDCHEAT_ADD).c_str());
SetProp(hDlg, "validcodes", false); SetProp(hDlg, "validcodes", false);
_this->RecordCheatValues(hDlg); _this->RecordCheatValues(hDlg);
} }
@ -341,7 +341,7 @@ int CALLBACK CCheatsUI::CheatAddProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
SetDlgItemText(hDlg, IDC_NOTES, ""); SetDlgItemText(hDlg, IDC_NOTES, "");
EnableWindow(GetDlgItem(hDlg, IDC_ADD), false); EnableWindow(GetDlgItem(hDlg, IDC_ADD), false);
EnableWindow(GetDlgItem(hDlg, IDC_CHEAT_OPTIONS), false); EnableWindow(GetDlgItem(hDlg, IDC_CHEAT_OPTIONS), false);
SetDlgItemTextW(hDlg, IDC_ADD, GS(CHEAT_ADDNEW)); SetDlgItemTextW(hDlg, IDC_ADD, wGS(CHEAT_ADDNEW).c_str());
_this->RecordCheatValues(hDlg); _this->RecordCheatValues(hDlg);
} }
break; break;
@ -428,7 +428,7 @@ int CALLBACK CCheatsUI::CheatAddProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
SetDlgItemText(hDlg, IDC_NOTES, CheatNotesStr.c_str()); SetDlgItemText(hDlg, IDC_NOTES, CheatNotesStr.c_str());
SendMessage(hDlg, WM_COMMAND, MAKELPARAM(IDC_CHEAT_CODES, EN_CHANGE), (LPARAM)GetDlgItem(hDlg, IDC_CHEAT_CODES)); SendMessage(hDlg, WM_COMMAND, MAKELPARAM(IDC_CHEAT_CODES, EN_CHANGE), (LPARAM)GetDlgItem(hDlg, IDC_CHEAT_CODES));
SetDlgItemTextW(hDlg, IDC_ADD, GS(CHEAT_EDITCHEAT_UPDATE)); SetDlgItemTextW(hDlg, IDC_ADD, wGS(CHEAT_EDITCHEAT_UPDATE).c_str());
_this->RecordCheatValues(hDlg); _this->RecordCheatValues(hDlg);
} }
@ -452,9 +452,9 @@ int CALLBACK CCheatsUI::CheatListProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
RECT rcList; RECT rcList;
RECT rcButton; RECT rcButton;
SetWindowTextW(GetDlgItem(hDlg, IDC_CHEATSFRAME), GS(CHEAT_LIST_FRAME)); SetWindowTextW(GetDlgItem(hDlg, IDC_CHEATSFRAME), wGS(CHEAT_LIST_FRAME).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_NOTESFRAME), GS(CHEAT_NOTES_FRAME)); SetWindowTextW(GetDlgItem(hDlg, IDC_NOTESFRAME), wGS(CHEAT_NOTES_FRAME).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_UNMARK), GS(CHEAT_MARK_NONE)); SetWindowTextW(GetDlgItem(hDlg, IDC_UNMARK), wGS(CHEAT_MARK_NONE).c_str());
GetWindowRect(GetDlgItem(hDlg, IDC_CHEATSFRAME), &rcList); GetWindowRect(GetDlgItem(hDlg, IDC_CHEATSFRAME), &rcList);
GetWindowRect(GetDlgItem(hDlg, IDC_UNMARK), &rcButton); GetWindowRect(GetDlgItem(hDlg, IDC_UNMARK), &rcButton);
@ -491,7 +491,7 @@ int CALLBACK CCheatsUI::CheatListProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
{ {
TVITEM item; TVITEM item;
int Response = MessageBoxW(hDlg, GS(MSG_DEL_SURE), GS(MSG_DEL_TITLE), MB_YESNO | MB_ICONQUESTION); int Response = MessageBoxW(hDlg, wGS(MSG_DEL_SURE).c_str(), wGS(MSG_DEL_TITLE).c_str(), MB_YESNO | MB_ICONQUESTION);
if (Response != IDYES) { break; } if (Response != IDYES) { break; }
//Delete selected cheat //Delete selected cheat
@ -546,7 +546,7 @@ int CALLBACK CCheatsUI::CheatListProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
GetCursorPos(&Mouse); GetCursorPos(&Mouse);
MenuSetText(hPopupMenu, 0, GS(CHEAT_DELETE), NULL); MenuSetText(hPopupMenu, 0, wGS(CHEAT_DELETE).c_str(), NULL);
if (_this->m_hSelectedItem != NULL && if (_this->m_hSelectedItem != NULL &&
TreeView_GetChild(_this->m_hCheatTree, _this->m_hSelectedItem) == NULL) TreeView_GetChild(_this->m_hCheatTree, _this->m_hSelectedItem) == NULL)
@ -731,10 +731,10 @@ int CALLBACK CCheatsUI::CheatsCodeExProc(HWND hDlg, uint32_t uMsg, uint32_t wPar
stdstr CheatName = _this->GetCheatName(item.lParam, false); stdstr CheatName = _this->GetCheatName(item.lParam, false);
//Set up language support for dialog //Set up language support for dialog
SetWindowTextW(hDlg, GS(CHEAT_CODE_EXT_TITLE)); SetWindowTextW(hDlg, wGS(CHEAT_CODE_EXT_TITLE).c_str());
SetDlgItemTextW(hDlg, IDC_NOTE, GS(CHEAT_CODE_EXT_TXT)); SetDlgItemTextW(hDlg, IDC_NOTE, wGS(CHEAT_CODE_EXT_TXT).c_str());
SetDlgItemTextW(hDlg, IDOK, GS(CHEAT_OK)); SetDlgItemTextW(hDlg, IDOK, wGS(CHEAT_OK).c_str());
SetDlgItemTextW(hDlg, IDCANCEL, GS(CHEAT_CANCEL)); SetDlgItemTextW(hDlg, IDCANCEL, wGS(CHEAT_CANCEL).c_str());
SetDlgItemText(hDlg, IDC_CHEAT_NAME, CheatName.c_str()); SetDlgItemText(hDlg, IDC_CHEAT_NAME, CheatName.c_str());
//Read through and add all options to the list box //Read through and add all options to the list box
@ -821,10 +821,10 @@ int CALLBACK CCheatsUI::CheatsCodeQuantProc(HWND hDlg, uint32_t uMsg, uint32_t w
stdstr Value(g_Settings->LoadStringIndex(Cheat_Extension, item.lParam)); stdstr Value(g_Settings->LoadStringIndex(Cheat_Extension, item.lParam));
//Set up language support for dialog //Set up language support for dialog
SetWindowTextW(hDlg, GS(CHEAT_CODE_EXT_TITLE)); SetWindowTextW(hDlg, wGS(CHEAT_CODE_EXT_TITLE).c_str());
SetDlgItemTextW(hDlg, IDC_DIGITAL_TEXT, GS(CHEAT_CHOOSE_VALUE)); SetDlgItemTextW(hDlg, IDC_DIGITAL_TEXT, wGS(CHEAT_CHOOSE_VALUE).c_str());
SetDlgItemTextW(hDlg, IDC_VALUE_TEXT, GS(CHEAT_VALUE)); SetDlgItemTextW(hDlg, IDC_VALUE_TEXT, wGS(CHEAT_VALUE).c_str());
SetDlgItemTextW(hDlg, IDC_NOTES_TEXT, GS(CHEAT_NOTES)); SetDlgItemTextW(hDlg, IDC_NOTES_TEXT, wGS(CHEAT_NOTES).c_str());
SetDlgItemText(hDlg, IDC_NOTES, RangeNote.c_str()); SetDlgItemText(hDlg, IDC_NOTES, RangeNote.c_str());
SetDlgItemText(hDlg, IDC_CHEAT_NAME, CheatName.c_str()); SetDlgItemText(hDlg, IDC_CHEAT_NAME, CheatName.c_str());
SetDlgItemText(hDlg, IDC_VALUE, Value.c_str()); SetDlgItemText(hDlg, IDC_VALUE, Value.c_str());
@ -935,7 +935,7 @@ int CALLBACK CCheatsUI::ManageCheatsProc(HWND hDlg, uint32_t uMsg, uint32_t wPar
WndPlac.length = sizeof(WndPlac); WndPlac.length = sizeof(WndPlac);
GetWindowPlacement(hDlg, &WndPlac); GetWindowPlacement(hDlg, &WndPlac);
SetWindowTextW(hDlg, GS(CHEAT_TITLE)); SetWindowTextW(hDlg, wGS(CHEAT_TITLE).c_str());
_this->m_hSelectCheat = CreateDialogParamW(GetModuleHandle(NULL), MAKEINTRESOURCEW(IDD_Cheats_List), hDlg, (DLGPROC)CheatListProc, (LPARAM)_this); _this->m_hSelectCheat = CreateDialogParamW(GetModuleHandle(NULL), MAKEINTRESOURCEW(IDD_Cheats_List), hDlg, (DLGPROC)CheatListProc, (LPARAM)_this);
SetWindowPos(_this->m_hSelectCheat, HWND_TOP, 5, 8, 0, 0, SWP_NOSIZE); SetWindowPos(_this->m_hSelectCheat, HWND_TOP, 5, 8, 0, 0, SWP_NOSIZE);
ShowWindow(_this->m_hSelectCheat, SW_SHOW); ShowWindow(_this->m_hSelectCheat, SW_SHOW);

46
Source/Project64/UserInterface/GuiClass.cpp
View File

@ -292,14 +292,14 @@ DWORD CALLBACK AboutIniBoxProc(HWND hDlg, DWORD uMsg, DWORD wParam, DWORD /*lPar
wchar_t String[200]; wchar_t String[200];
//Title //Title
SetWindowTextW(hDlg, GS(INI_TITLE)); SetWindowTextW(hDlg, wGS(INI_TITLE).c_str());
//Language //Language
SetDlgItemTextW(hDlg, IDC_LAN, GS(INI_CURRENT_LANG)); SetDlgItemTextW(hDlg, IDC_LAN, wGS(INI_CURRENT_LANG).c_str());
set_about_field(hDlg, IDC_LAN_AUTHOR, GS(INI_AUTHOR), GS(LANGUAGE_AUTHOR)); set_about_field(hDlg, IDC_LAN_AUTHOR, wGS(INI_AUTHOR).c_str(), wGS(LANGUAGE_AUTHOR).c_str());
set_about_field(hDlg, IDC_LAN_VERSION, GS(INI_VERSION), GS(LANGUAGE_VERSION)); set_about_field(hDlg, IDC_LAN_VERSION, wGS(INI_VERSION).c_str(), wGS(LANGUAGE_VERSION).c_str());
set_about_field(hDlg, IDC_LAN_DATE, GS(INI_DATE), GS(LANGUAGE_DATE)); set_about_field(hDlg, IDC_LAN_DATE, wGS(INI_DATE).c_str(), wGS(LANGUAGE_DATE).c_str());
if (wcslen(GS(LANGUAGE_NAME)) == 0) if (wcslen(wGS(LANGUAGE_NAME).c_str()) == 0)
{ {
EnableWindow(GetDlgItem(hDlg, IDC_LAN), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_LAN), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_LAN_AUTHOR), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_LAN_AUTHOR), FALSE);
@ -318,21 +318,21 @@ DWORD CALLBACK AboutIniBoxProc(HWND hDlg, DWORD uMsg, DWORD wParam, DWORD /*lPar
EnableWindow(GetDlgItem(hDlg, IDC_RDB_HOME), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_RDB_HOME), FALSE);
} }
set_about_field(hDlg, IDC_RDB_AUTHOR, GS(INI_AUTHOR), String); set_about_field(hDlg, IDC_RDB_AUTHOR, wGS(INI_AUTHOR).c_str(), String);
wcsncpy(String, RdbIniFile.GetString("Meta", "Version", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0])); wcsncpy(String, RdbIniFile.GetString("Meta", "Version", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0]));
set_about_field(hDlg, IDC_RDB_VERSION, GS(INI_VERSION), String); set_about_field(hDlg, IDC_RDB_VERSION, wGS(INI_VERSION).c_str(), String);
wcsncpy(String, RdbIniFile.GetString("Meta", "Date", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0])); wcsncpy(String, RdbIniFile.GetString("Meta", "Date", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0]));
set_about_field(hDlg, IDC_RDB_DATE, GS(INI_DATE), String); set_about_field(hDlg, IDC_RDB_DATE, wGS(INI_DATE).c_str(), String);
wcsncpy(RDBHomePage, RdbIniFile.GetString("Meta", "Homepage", "").ToUTF16().c_str(), sizeof(RDBHomePage) / sizeof(RDBHomePage[0])); wcsncpy(RDBHomePage, RdbIniFile.GetString("Meta", "Homepage", "").ToUTF16().c_str(), sizeof(RDBHomePage) / sizeof(RDBHomePage[0]));
SetDlgItemTextW(hDlg, IDC_RDB_HOME, GS(INI_HOMEPAGE)); SetDlgItemTextW(hDlg, IDC_RDB_HOME, wGS(INI_HOMEPAGE).c_str());
if (wcslen(RDBHomePage) == 0) if (wcslen(RDBHomePage) == 0)
{ {
EnableWindow(GetDlgItem(hDlg, IDC_RDB_HOME), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_RDB_HOME), FALSE);
} }
//Cheat //Cheat
SetDlgItemTextW(hDlg, IDC_CHT, GS(INI_CURRENT_CHT)); SetDlgItemTextW(hDlg, IDC_CHT, wGS(INI_CURRENT_CHT).c_str());
CIniFile CheatIniFile(g_Settings->LoadStringVal(SupportFile_Cheats).c_str()); CIniFile CheatIniFile(g_Settings->LoadStringVal(SupportFile_Cheats).c_str());
wcsncpy(String, CheatIniFile.GetString("Meta", "Author", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0])); wcsncpy(String, CheatIniFile.GetString("Meta", "Author", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0]));
if (wcslen(String) == 0) if (wcslen(String) == 0)
@ -343,20 +343,20 @@ DWORD CALLBACK AboutIniBoxProc(HWND hDlg, DWORD uMsg, DWORD wParam, DWORD /*lPar
EnableWindow(GetDlgItem(hDlg, IDC_CHT_DATE), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_CHT_DATE), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_CHT_HOME), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_CHT_HOME), FALSE);
} }
set_about_field(hDlg, IDC_CHT_AUTHOR, GS(INI_AUTHOR), String); set_about_field(hDlg, IDC_CHT_AUTHOR, wGS(INI_AUTHOR).c_str(), String);
wcsncpy(String, CheatIniFile.GetString("Meta", "Version", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0])); wcsncpy(String, CheatIniFile.GetString("Meta", "Version", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0]));
set_about_field(hDlg, IDC_CHT_VERSION, GS(INI_VERSION), String); set_about_field(hDlg, IDC_CHT_VERSION, wGS(INI_VERSION).c_str(), String);
wcsncpy(String, CheatIniFile.GetString("Meta", "Date", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0])); wcsncpy(String, CheatIniFile.GetString("Meta", "Date", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0]));
set_about_field(hDlg, IDC_CHT_DATE, GS(INI_DATE), String); set_about_field(hDlg, IDC_CHT_DATE, wGS(INI_DATE).c_str(), String);
wcsncpy(CHTHomePage, CheatIniFile.GetString("Meta", "Homepage", "").ToUTF16().c_str(), sizeof(CHTHomePage) / sizeof(CHTHomePage[0])); wcsncpy(CHTHomePage, CheatIniFile.GetString("Meta", "Homepage", "").ToUTF16().c_str(), sizeof(CHTHomePage) / sizeof(CHTHomePage[0]));
SetDlgItemTextW(hDlg, IDC_CHT_HOME, GS(INI_HOMEPAGE)); SetDlgItemTextW(hDlg, IDC_CHT_HOME, wGS(INI_HOMEPAGE).c_str());
if (wcslen(CHTHomePage) == 0) if (wcslen(CHTHomePage) == 0)
{ {
EnableWindow(GetDlgItem(hDlg, IDC_CHT_HOME), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_CHT_HOME), FALSE);
} }
//Extended Info //Extended Info
SetDlgItemTextW(hDlg, IDC_RDX, GS(INI_CURRENT_RDX)); SetDlgItemTextW(hDlg, IDC_RDX, wGS(INI_CURRENT_RDX).c_str());
CIniFile RdxIniFile(g_Settings->LoadStringVal(SupportFile_ExtInfo).c_str()); CIniFile RdxIniFile(g_Settings->LoadStringVal(SupportFile_ExtInfo).c_str());
wcsncpy(String, RdxIniFile.GetString("Meta", "Author", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0])); wcsncpy(String, RdxIniFile.GetString("Meta", "Author", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0]));
if (wcslen(String) == 0) if (wcslen(String) == 0)
@ -367,18 +367,18 @@ DWORD CALLBACK AboutIniBoxProc(HWND hDlg, DWORD uMsg, DWORD wParam, DWORD /*lPar
EnableWindow(GetDlgItem(hDlg, IDC_RDX_DATE), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_RDX_DATE), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_RDX_HOME), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_RDX_HOME), FALSE);
} }
set_about_field(hDlg, IDC_RDX_AUTHOR, GS(INI_AUTHOR), String); set_about_field(hDlg, IDC_RDX_AUTHOR, wGS(INI_AUTHOR).c_str(), String);
wcsncpy(String, RdxIniFile.GetString("Meta", "Version", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0])); wcsncpy(String, RdxIniFile.GetString("Meta", "Version", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0]));
set_about_field(hDlg, IDC_RDX_VERSION, GS(INI_VERSION), String); set_about_field(hDlg, IDC_RDX_VERSION, wGS(INI_VERSION).c_str(), String);
wcsncpy(String, RdxIniFile.GetString("Meta", "Date", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0])); wcsncpy(String, RdxIniFile.GetString("Meta", "Date", "").ToUTF16().c_str(), sizeof(String) / sizeof(String[0]));
set_about_field(hDlg, IDC_RDX_DATE, GS(INI_DATE), String); set_about_field(hDlg, IDC_RDX_DATE, wGS(INI_DATE).c_str(), String);
wcsncpy(RDXHomePage, RdxIniFile.GetString("Meta", "Homepage", "").ToUTF16().c_str(), sizeof(RDXHomePage) / sizeof(RDXHomePage[0])); wcsncpy(RDXHomePage, RdxIniFile.GetString("Meta", "Homepage", "").ToUTF16().c_str(), sizeof(RDXHomePage) / sizeof(RDXHomePage[0]));
SetDlgItemTextW(hDlg, IDC_RDX_HOME, GS(INI_HOMEPAGE)); SetDlgItemTextW(hDlg, IDC_RDX_HOME, wGS(INI_HOMEPAGE).c_str());
if (wcslen(RDXHomePage) == 0) if (wcslen(RDXHomePage) == 0)
{ {
EnableWindow(GetDlgItem(hDlg, IDC_RDX_HOME), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_RDX_HOME), FALSE);
} }
SetDlgItemTextW(hDlg, IDOK, GS(CHEAT_OK)); SetDlgItemTextW(hDlg, IDOK, wGS(CHEAT_OK).c_str());
} }
break; break;
case WM_COMMAND: case WM_COMMAND:
@ -1044,7 +1044,7 @@ LRESULT CALLBACK CMainGui::MainGui_Proc(HWND hWnd, DWORD uMsg, DWORD wParam, DWO
break; break;
} }
Rom.SaveRomSettingID(true); Rom.SaveRomSettingID(true);
g_Notify->DisplayMessage(0, L""); g_Notify->DisplayMessage(0, "");
BYTE * RomHeader = Rom.GetRomAddress(); BYTE * RomHeader = Rom.GetRomAddress();
WriteTrace(TraceGFXPlugin, TraceDebug, "OnRomBrowserMenuItem - Starting"); WriteTrace(TraceGFXPlugin, TraceDebug, "OnRomBrowserMenuItem - Starting");
g_Plugins->Gfx()->OnRomBrowserMenuItem(LOWORD(wParam), hWnd, RomHeader); g_Plugins->Gfx()->OnRomBrowserMenuItem(LOWORD(wParam), hWnd, RomHeader);
@ -1118,7 +1118,7 @@ DWORD CALLBACK AboutBoxProc(HWND hWnd, DWORD uMsg, DWORD wParam, DWORD lParam)
case WM_INITDIALOG: case WM_INITDIALOG:
{ {
//Title //Title
SetWindowTextW(hWnd, GS(PLUG_ABOUT)); SetWindowTextW(hWnd, wGS(PLUG_ABOUT).c_str());
// Use the size of the image // Use the size of the image
hbmpBackgroundTop = LoadBitmap(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_ABOUT_LOGO)); hbmpBackgroundTop = LoadBitmap(GetModuleHandle(NULL), MAKEINTRESOURCE(IDB_ABOUT_LOGO));

22
Source/Project64/UserInterface/MainMenuClass.cpp
View File

@ -371,7 +371,7 @@ bool CMainMenu::ProcessMessage(HWND hWnd, DWORD /*FromAccelerator*/, DWORD MenuI
if (g_Settings->LoadBool(UserInterface_ShowCPUPer)) if (g_Settings->LoadBool(UserInterface_ShowCPUPer))
{ {
g_Settings->SaveBool(UserInterface_ShowCPUPer, false); g_Settings->SaveBool(UserInterface_ShowCPUPer, false);
g_Notify->DisplayMessage(0, L""); g_Notify->DisplayMessage(0, "");
} }
else else
{ {
@ -400,11 +400,11 @@ bool CMainMenu::ProcessMessage(HWND hWnd, DWORD /*FromAccelerator*/, DWORD MenuI
g_Settings->SaveBool(Debugger_ShowPifErrors, !g_Settings->LoadBool(Debugger_ShowPifErrors)); g_Settings->SaveBool(Debugger_ShowPifErrors, !g_Settings->LoadBool(Debugger_ShowPifErrors));
break; break;
case ID_DEBUG_SHOW_DLIST_COUNT: case ID_DEBUG_SHOW_DLIST_COUNT:
g_Notify->DisplayMessage(0, L""); g_Notify->DisplayMessage(0, "");
g_Settings->SaveBool(Debugger_ShowDListAListCount, !g_Settings->LoadBool(Debugger_ShowDListAListCount)); g_Settings->SaveBool(Debugger_ShowDListAListCount, !g_Settings->LoadBool(Debugger_ShowDListAListCount));
break; break;
case ID_DEBUG_SHOW_RECOMP_MEM_SIZE: case ID_DEBUG_SHOW_RECOMP_MEM_SIZE:
g_Notify->DisplayMessage(0, L""); g_Notify->DisplayMessage(0, "");
g_Settings->SaveBool(Debugger_ShowRecompMemSize, !g_Settings->LoadBool(Debugger_ShowRecompMemSize)); g_Settings->SaveBool(Debugger_ShowRecompMemSize, !g_Settings->LoadBool(Debugger_ShowRecompMemSize));
break; break;
case ID_DEBUG_SHOW_DIV_BY_ZERO: case ID_DEBUG_SHOW_DIV_BY_ZERO:
@ -453,7 +453,7 @@ bool CMainMenu::ProcessMessage(HWND hWnd, DWORD /*FromAccelerator*/, DWORD MenuI
case ID_DEBUGGER_INTERRUPT_PI: g_BaseSystem->ExternalEvent(SysEvent_Interrupt_PI); break; case ID_DEBUGGER_INTERRUPT_PI: g_BaseSystem->ExternalEvent(SysEvent_Interrupt_PI); break;
case ID_DEBUGGER_INTERRUPT_DP: g_BaseSystem->ExternalEvent(SysEvent_Interrupt_DP); break; case ID_DEBUGGER_INTERRUPT_DP: g_BaseSystem->ExternalEvent(SysEvent_Interrupt_DP); break;
case ID_CURRENT_SAVE_DEFAULT: case ID_CURRENT_SAVE_DEFAULT:
g_Notify->DisplayMessage(3, stdwstr_f(GS(MENU_SLOT_SAVE), GetSaveSlotString(MenuID - ID_CURRENT_SAVE_DEFAULT).c_str()).c_str()); g_Notify->DisplayMessage(3, stdstr_f(GS(MENU_SLOT_SAVE), GetSaveSlotString(MenuID - ID_CURRENT_SAVE_DEFAULT).c_str()).c_str());
g_Settings->SaveDword(Game_CurrentSaveState, (DWORD)(MenuID - ID_CURRENT_SAVE_DEFAULT)); g_Settings->SaveDword(Game_CurrentSaveState, (DWORD)(MenuID - ID_CURRENT_SAVE_DEFAULT));
break; break;
case ID_CURRENT_SAVE_1: case ID_CURRENT_SAVE_1:
@ -466,7 +466,7 @@ bool CMainMenu::ProcessMessage(HWND hWnd, DWORD /*FromAccelerator*/, DWORD MenuI
case ID_CURRENT_SAVE_8: case ID_CURRENT_SAVE_8:
case ID_CURRENT_SAVE_9: case ID_CURRENT_SAVE_9:
case ID_CURRENT_SAVE_10: case ID_CURRENT_SAVE_10:
g_Notify->DisplayMessage(3, stdwstr_f(GS(MENU_SLOT_SAVE), GetSaveSlotString((MenuID - ID_CURRENT_SAVE_1) + 1).c_str()).c_str()); g_Notify->DisplayMessage(3, stdstr_f(GS(MENU_SLOT_SAVE), GetSaveSlotString((MenuID - ID_CURRENT_SAVE_1) + 1).c_str()).c_str());
g_Settings->SaveDword(Game_CurrentSaveState, (DWORD)((MenuID - ID_CURRENT_SAVE_1) + 1)); g_Settings->SaveDword(Game_CurrentSaveState, (DWORD)((MenuID - ID_CURRENT_SAVE_1) + 1));
break; break;
case ID_HELP_SUPPORTFORUM: ShellExecute(NULL, "open", "http://forum.pj64-emu.com/", NULL, NULL, SW_SHOWMAXIMIZED); break; case ID_HELP_SUPPORTFORUM: ShellExecute(NULL, "open", "http://forum.pj64-emu.com/", NULL, NULL, SW_SHOWMAXIMIZED); break;
@ -510,7 +510,7 @@ bool CMainMenu::ProcessMessage(HWND hWnd, DWORD /*FromAccelerator*/, DWORD MenuI
menuinfo.cch = sizeof(String); menuinfo.cch = sizeof(String);
GetMenuItemInfoW((HMENU)m_MenuHandle, MenuID, FALSE, &menuinfo); GetMenuItemInfoW((HMENU)m_MenuHandle, MenuID, FALSE, &menuinfo);
g_Lang->SetLanguage(String); g_Lang->SetLanguage(stdstr().FromUTF16(String).c_str());
m_Gui->ResetRomBrowserColomuns(); m_Gui->ResetRomBrowserColomuns();
break; break;
} }
@ -546,7 +546,7 @@ stdstr CMainMenu::GetFileLastMod(stdstr FileName)
std::wstring CMainMenu::GetSaveSlotString(int Slot) std::wstring CMainMenu::GetSaveSlotString(int Slot)
{ {
std::wstring SlotName; stdstr SlotName;
switch (Slot) switch (Slot)
{ {
case 0: SlotName = GS(MENU_SLOT_DEFAULT); break; case 0: SlotName = GS(MENU_SLOT_DEFAULT); break;
@ -562,7 +562,7 @@ std::wstring CMainMenu::GetSaveSlotString(int Slot)
case 10: SlotName = GS(MENU_SLOT_10); break; case 10: SlotName = GS(MENU_SLOT_10); break;
} }
if (!g_Settings->LoadBool(GameRunning_CPU_Running)) { return SlotName; } if (!g_Settings->LoadBool(GameRunning_CPU_Running)) { return SlotName.ToUTF16(); }
stdstr LastSaveTime; stdstr LastSaveTime;
@ -613,8 +613,8 @@ std::wstring CMainMenu::GetSaveSlotString(int Slot)
LastSaveTime = GetFileLastMod(FileName); LastSaveTime = GetFileLastMod(FileName);
} }
} }
SlotName += LastSaveTime.ToUTF16(); SlotName += LastSaveTime;
return SlotName; return SlotName.ToUTF16();
} }
void CMainMenu::FillOutMenu(HMENU hMenu) void CMainMenu::FillOutMenu(HMENU hMenu)
@ -643,7 +643,7 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
int Offset = 0; int Offset = 0;
for (LanguageList::iterator Language = LangList.begin(); Language != LangList.end(); Language++) for (LanguageList::iterator Language = LangList.begin(); Language != LangList.end(); Language++)
{ {
Item.Reset(ID_LANG_START + Offset++, EMPTY_STRING, EMPTY_STDSTR, NULL, Language->LanguageName.c_str()); Item.Reset(ID_LANG_START + Offset++, EMPTY_STRING, EMPTY_STDSTR, NULL, stdstr(Language->LanguageName).ToUTF16().c_str());
if (g_Lang->IsCurrentLang(*Language)) if (g_Lang->IsCurrentLang(*Language))
{ {
Item.SetItemTicked(true); Item.SetItemTicked(true);

2
Source/Project64/UserInterface/MenuClass.cpp
View File

@ -15,7 +15,7 @@ bool CBaseMenu::AddMenu(HMENU hMenu, MenuItemList Items)
{ {
ItemID = MenuItem->ID(); ItemID = MenuItem->ID();
uFlags = MF_STRING; uFlags = MF_STRING;
Text = g_Lang->GetString(MenuItem->Title()).c_str(); Text = wGS(MenuItem->Title());
if (MenuItem->Title() == EMPTY_STRING && MenuItem->ManualString().length() > 0) if (MenuItem->Title() == EMPTY_STRING && MenuItem->ManualString().length() > 0)
{ {

35
Source/Project64/UserInterface/NotificationClass.cpp
View File

@ -53,13 +53,11 @@ void CNotificationImp::DisplayError(LanguageStringID StringID) const
DisplayError(g_Lang->GetString(StringID).c_str()); DisplayError(g_Lang->GetString(StringID).c_str());
} }
void CNotificationImp::DisplayError(const wchar_t * Message) const void CNotificationImp::DisplayError(const char * Message) const
{ {
if (this == NULL) { return; } if (this == NULL) { return; }
stdstr TraceMessage; WriteTrace(TraceUserInterface, TraceError, Message);
TraceMessage.FromUTF16(Message);
WriteTrace(TraceUserInterface, TraceError, TraceMessage.c_str());
WindowMode(); WindowMode();
HWND Parent = NULL; HWND Parent = NULL;
@ -67,7 +65,7 @@ void CNotificationImp::DisplayError(const wchar_t * Message) const
{ {
Parent = reinterpret_cast<HWND>(m_hWnd->GetWindowHandle()); Parent = reinterpret_cast<HWND>(m_hWnd->GetWindowHandle());
} }
MessageBoxW(Parent, Message, GS(MSG_MSGBOX_TITLE), MB_OK | MB_ICONERROR | MB_SETFOREGROUND); MessageBoxW(Parent, stdstr(Message).ToUTF16().c_str(), wGS(MSG_MSGBOX_TITLE).c_str(), MB_OK | MB_ICONERROR | MB_SETFOREGROUND);
} }
void CNotificationImp::DisplayMessage(int DisplayTime, LanguageStringID StringID) const void CNotificationImp::DisplayMessage(int DisplayTime, LanguageStringID StringID) const
@ -75,7 +73,7 @@ void CNotificationImp::DisplayMessage(int DisplayTime, LanguageStringID StringID
DisplayMessage(DisplayTime, g_Lang->GetString(StringID).c_str()); DisplayMessage(DisplayTime, g_Lang->GetString(StringID).c_str());
} }
void CNotificationImp::DisplayMessage(int DisplayTime, const wchar_t * Message) const void CNotificationImp::DisplayMessage(int DisplayTime, const char * Message) const
{ {
if (!m_hWnd) { return; } if (!m_hWnd) { return; }
@ -101,30 +99,28 @@ void CNotificationImp::DisplayMessage(int DisplayTime, const wchar_t * Message)
if (m_gfxPlugin && m_gfxPlugin->DrawStatus) if (m_gfxPlugin && m_gfxPlugin->DrawStatus)
{ {
WriteTrace(TraceGFXPlugin, TraceDebug, "DrawStatus - Starting"); WriteTrace(TraceGFXPlugin, TraceDebug, "DrawStatus - Starting");
stdstr PluginMessage; m_gfxPlugin->DrawStatus(Message, FALSE);
PluginMessage.FromUTF16(Message);
m_gfxPlugin->DrawStatus(PluginMessage.c_str(), FALSE);
WriteTrace(TraceGFXPlugin, TraceDebug, "DrawStatus - Done"); WriteTrace(TraceGFXPlugin, TraceDebug, "DrawStatus - Done");
} }
} }
else else
{ {
m_hWnd->SetStatusText(0, Message); m_hWnd->SetStatusText(0, stdstr(Message).ToUTF16().c_str());
} }
} }
void CNotificationImp::DisplayMessage2(const wchar_t * Message) const void CNotificationImp::DisplayMessage2(const char * Message) const
{ {
if (!m_hWnd) { return; } if (!m_hWnd) { return; }
m_hWnd->SetStatusText(1, Message); m_hWnd->SetStatusText(1, stdstr(Message).ToUTF16().c_str());
} }
bool CNotificationImp::AskYesNoQuestion(const wchar_t * Question) const bool CNotificationImp::AskYesNoQuestion(const char * Question) const
{ {
if (this == NULL) { return false; } if (this == NULL) { return false; }
WriteTrace(TraceUserInterface, TraceError, stdstr().FromUTF16(Question).c_str()); WriteTrace(TraceUserInterface, TraceError, Question);
WindowMode(); WindowMode();
HWND Parent = NULL; HWND Parent = NULL;
@ -132,7 +128,7 @@ bool CNotificationImp::AskYesNoQuestion(const wchar_t * Question) const
{ {
Parent = reinterpret_cast<HWND>(m_hWnd->GetWindowHandle()); Parent = reinterpret_cast<HWND>(m_hWnd->GetWindowHandle());
} }
int result = MessageBoxW(Parent, Question, GS(MSG_MSGBOX_TITLE), MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2 | MB_SETFOREGROUND); int result = MessageBoxW(Parent, stdstr(Question).ToUTF16().c_str(), wGS(MSG_MSGBOX_TITLE).c_str(), MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2 | MB_SETFOREGROUND);
return result == IDYES; return result == IDYES;
} }
@ -146,13 +142,14 @@ void CNotificationImp::FatalError(LanguageStringID StringID) const
FatalError(g_Lang->GetString(StringID).c_str()); FatalError(g_Lang->GetString(StringID).c_str());
} }
void CNotificationImp::FatalError(const wchar_t * Message) const void CNotificationImp::FatalError(const char * Message) const
{ {
WriteTrace(TraceUserInterface, TraceError, Message);
WindowMode(); WindowMode();
HWND Parent = NULL; HWND Parent = NULL;
if (m_hWnd) { Parent = reinterpret_cast<HWND>(m_hWnd->GetWindowHandle()); } if (m_hWnd) { Parent = reinterpret_cast<HWND>(m_hWnd->GetWindowHandle()); }
MessageBoxW(Parent, Message, L"Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND); MessageBoxW(Parent, stdstr(Message).ToUTF16().c_str(), L"Error", MB_OK | MB_ICONERROR | MB_SETFOREGROUND);
ExitThread(0); ExitThread(0);
} }
@ -254,7 +251,7 @@ void CNotificationImp::BreakPoint(const char * FileName, int LineNumber)
{ {
if (g_Settings->LoadBool(Debugger_Enabled)) if (g_Settings->LoadBool(Debugger_Enabled))
{ {
DisplayError(stdstr_f("Break point found at\n%s\n%d", FileName, LineNumber).ToUTF16().c_str()); DisplayError(stdstr_f("Break point found at\n%s\n%d", FileName, LineNumber).c_str());
if (IsDebuggerPresent() != 0) if (IsDebuggerPresent() != 0)
{ {
DebugBreak(); DebugBreak();
@ -266,7 +263,7 @@ void CNotificationImp::BreakPoint(const char * FileName, int LineNumber)
} }
else else
{ {
DisplayError(L"Fatal Error: Stopping emulation"); DisplayError("Fatal Error: Stopping emulation");
g_BaseSystem->CloseCpu(); g_BaseSystem->CloseCpu();
} }
} }

10
Source/Project64/UserInterface/NotificationClass.h
View File

@ -28,20 +28,20 @@ public:
void WindowMode(void) const; void WindowMode(void) const;
//Error Messages //Error Messages
virtual void DisplayError(const wchar_t * Message) const; virtual void DisplayError(const char * Message) const;
virtual void DisplayError(LanguageStringID StringID) const; virtual void DisplayError(LanguageStringID StringID) const;
virtual void FatalError(const wchar_t * Message) const; virtual void FatalError(const char * Message) const;
virtual void FatalError(LanguageStringID StringID) const; virtual void FatalError(LanguageStringID StringID) const;
//User Feedback //User Feedback
virtual void DisplayMessage(int DisplayTime, const wchar_t * Message) const; virtual void DisplayMessage(int DisplayTime, const char * Message) const;
virtual void DisplayMessage(int DisplayTime, LanguageStringID StringID) const; virtual void DisplayMessage(int DisplayTime, LanguageStringID StringID) const;
virtual void DisplayMessage2(const wchar_t * Message) const; virtual void DisplayMessage2(const char * Message) const;
// Ask a Yes/No Question to the user, yes = true, no = false // Ask a Yes/No Question to the user, yes = true, no = false
virtual bool AskYesNoQuestion(const wchar_t * Question) const; virtual bool AskYesNoQuestion(const char * Question) const;
virtual void BreakPoint(const char * FileName, int32_t LineNumber); virtual void BreakPoint(const char * FileName, int32_t LineNumber);

2
Source/Project64/UserInterface/RomBrowser.h
View File

@ -178,7 +178,7 @@ class CRomBrowser
bool GetRomFileNames(strlist & FileList, const CPath & BaseDirectory, const stdstr & Directory, bool InWatchThread); bool GetRomFileNames(strlist & FileList, const CPath & BaseDirectory, const stdstr & Directory, bool InWatchThread);
MD5 RomListHash(strlist & FileList); MD5 RomListHash(strlist & FileList);
static void __stdcall NotificationCB(LPCWSTR Status, CRomBrowser * _this); static void NotificationCB(const char * Status, CRomBrowser * _this);
//Watch Directory Changed function //Watch Directory Changed function
HANDLE m_WatchThread, m_WatchStopEvent; HANDLE m_WatchThread, m_WatchStopEvent;

30
Source/Project64/UserInterface/RomBrowserClass.cpp
View File

@ -537,7 +537,7 @@ bool CRomBrowser::GetRomFileNames(strlist & FileList, const CPath & BaseDirector
return true; return true;
} }
void CRomBrowser::NotificationCB(LPCWSTR Status, CRomBrowser * /*_this*/) void CRomBrowser::NotificationCB(const char * Status, CRomBrowser * /*_this*/)
{ {
g_Notify->DisplayMessage(5, Status); g_Notify->DisplayMessage(5, Status);
} }
@ -1121,7 +1121,7 @@ void CRomBrowser::ResetRomBrowserColomuns(void)
m_FieldType[Coloumn] = m_Fields[index].ID(); m_FieldType[Coloumn] = m_Fields[index].ID();
lvColumn.cx = m_Fields[index].ColWidth(); lvColumn.cx = m_Fields[index].ColWidth();
wcsncpy(szString, GS(m_Fields[index].LangID()), sizeof(szString) / sizeof(szString[0])); wcsncpy(szString, wGS(m_Fields[index].LangID()).c_str(), sizeof(szString) / sizeof(szString[0]));
SendMessage(m_hRomList, LVM_INSERTCOLUMNW, (WPARAM)(int32_t)(Coloumn), (LPARAM)(const LV_COLUMNW *)(&lvColumn)); SendMessage(m_hRomList, LVM_INSERTCOLUMNW, (WPARAM)(int32_t)(Coloumn), (LPARAM)(const LV_COLUMNW *)(&lvColumn));
} }
} }
@ -1223,7 +1223,7 @@ bool CRomBrowser::RomListDrawItem(int32_t idCtrl, uint32_t lParam)
std::wstring text = String; std::wstring text = String;
if (wcscmp(L"#340#", text.c_str()) == 0) if (wcscmp(L"#340#", text.c_str()) == 0)
{ {
text = GS(RB_NOT_GOOD_FILE); text = wGS(RB_NOT_GOOD_FILE);
} }
DrawTextW(ditem->hDC, text.c_str(), text.length(), &rcDraw, DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_WORD_ELLIPSIS); DrawTextW(ditem->hDC, text.c_str(), text.length(), &rcDraw, DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_WORD_ELLIPSIS);
@ -1244,7 +1244,7 @@ bool CRomBrowser::RomListDrawItem(int32_t idCtrl, uint32_t lParam)
text = String; text = String;
if (wcscmp(L"#340#", text.c_str()) == 0) if (wcscmp(L"#340#", text.c_str()) == 0)
{ {
text = GS(RB_NOT_GOOD_FILE); text = wGS(RB_NOT_GOOD_FILE);
} }
DrawTextW(ditem->hDC, text.c_str(), text.length(), &rcDraw, DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_WORD_ELLIPSIS); DrawTextW(ditem->hDC, text.c_str(), text.length(), &rcDraw, DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER | DT_WORD_ELLIPSIS);
} }
@ -1493,13 +1493,13 @@ void CRomBrowser::RomList_PopupMenu(uint32_t /*pnmh*/)
HMENU hPopupMenu = (HMENU)GetSubMenu(hMenu, 0); HMENU hPopupMenu = (HMENU)GetSubMenu(hMenu, 0);
//Fix up menu //Fix up menu
MenuSetText(hPopupMenu, 0, GS(POPUP_PLAY), NULL); MenuSetText(hPopupMenu, 0, wGS(POPUP_PLAY).c_str(), NULL);
MenuSetText(hPopupMenu, 2, GS(MENU_REFRESH), NULL); MenuSetText(hPopupMenu, 2, wGS(MENU_REFRESH).c_str(), NULL);
MenuSetText(hPopupMenu, 3, GS(MENU_CHOOSE_ROM), NULL); MenuSetText(hPopupMenu, 3, wGS(MENU_CHOOSE_ROM).c_str(), NULL);
MenuSetText(hPopupMenu, 5, GS(POPUP_INFO), NULL); MenuSetText(hPopupMenu, 5, wGS(POPUP_INFO).c_str(), NULL);
MenuSetText(hPopupMenu, 6, GS(POPUP_GFX_PLUGIN), NULL); MenuSetText(hPopupMenu, 6, wGS(POPUP_GFX_PLUGIN).c_str(), NULL);
MenuSetText(hPopupMenu, 8, GS(POPUP_SETTINGS), NULL); MenuSetText(hPopupMenu, 8, wGS(POPUP_SETTINGS).c_str(), NULL);
MenuSetText(hPopupMenu, 9, GS(POPUP_CHEATS), NULL); MenuSetText(hPopupMenu, 9, wGS(POPUP_CHEATS).c_str(), NULL);
if (m_SelectedRom.size() == 0) if (m_SelectedRom.size() == 0)
{ {
@ -1526,7 +1526,7 @@ void CRomBrowser::RomList_PopupMenu(uint32_t /*pnmh*/)
if (GfxMenu) if (GfxMenu)
{ {
MENUITEMINFO lpmii; MENUITEMINFO lpmii;
InsertMenuW(hPopupMenu, 6, MF_POPUP | MF_BYPOSITION, (uint32_t)GfxMenu, GS(POPUP_GFX_PLUGIN)); InsertMenuW(hPopupMenu, 6, MF_POPUP | MF_BYPOSITION, (uint32_t)GfxMenu, wGS(POPUP_GFX_PLUGIN).c_str());
lpmii.cbSize = sizeof(MENUITEMINFO); lpmii.cbSize = sizeof(MENUITEMINFO);
lpmii.fMask = MIIM_STATE; lpmii.fMask = MIIM_STATE;
lpmii.fState = 0; lpmii.fState = 0;
@ -1642,7 +1642,7 @@ int32_t CALLBACK CRomBrowser::SelectRomDirCallBack(HWND hwnd, uint32_t uMsg, uin
if (lpData) if (lpData)
{ {
SendMessage(hwnd, BFFM_SETSELECTION, TRUE, lpData); SendMessage(hwnd, BFFM_SETSELECTION, TRUE, lpData);
SetWindowTextW(hwnd, GS(DIR_SELECT_ROM)); SetWindowTextW(hwnd, wGS(DIR_SELECT_ROM).c_str());
} }
break; break;
} }
@ -1655,12 +1655,14 @@ void CRomBrowser::SelectRomDir(void)
LPITEMIDLIST pidl; LPITEMIDLIST pidl;
BROWSEINFOW bi; BROWSEINFOW bi;
std::wstring title = wGS(SELECT_ROM_DIR);
WriteTrace(TraceUserInterface, TraceDebug, "1"); WriteTrace(TraceUserInterface, TraceDebug, "1");
stdstr RomDir = g_Settings->LoadStringVal(Directory_Game); stdstr RomDir = g_Settings->LoadStringVal(Directory_Game);
bi.hwndOwner = m_MainWindow; bi.hwndOwner = m_MainWindow;
bi.pidlRoot = NULL; bi.pidlRoot = NULL;
bi.pszDisplayName = SelectedDir; bi.pszDisplayName = SelectedDir;
bi.lpszTitle = GS(SELECT_ROM_DIR); bi.lpszTitle = title.c_str();
bi.ulFlags = BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS; bi.ulFlags = BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
bi.lpfn = (BFFCALLBACK)SelectRomDirCallBack; bi.lpfn = (BFFCALLBACK)SelectRomDirCallBack;
bi.lParam = (uint32_t)RomDir.c_str(); bi.lParam = (uint32_t)RomDir.c_str();

40
Source/Project64/UserInterface/Settings/SettingsPage-AdvancedOptions.cpp
View File

@ -12,35 +12,35 @@
#include "SettingsPage.h" #include "SettingsPage.h"
CAdvancedOptionsPage::CAdvancedOptionsPage (HWND hParent, const RECT & rcDispay ) CAdvancedOptionsPage::CAdvancedOptionsPage(HWND hParent, const RECT & rcDispay)
{ {
if (!Create(hParent,rcDispay)) if (!Create(hParent, rcDispay))
{ {
return; return;
} }
//Set the text for all gui Items //Set the text for all gui Items
SetDlgItemTextW(m_hWnd, IDC_START_ON_ROM_OPEN, GS(ADVANCE_AUTO_START)); SetDlgItemTextW(m_hWnd, IDC_START_ON_ROM_OPEN, wGS(ADVANCE_AUTO_START).c_str());
SetDlgItemTextW(m_hWnd, IDC_ZIP, GS(ADVANCE_COMPRESS)); SetDlgItemTextW(m_hWnd, IDC_ZIP, wGS(ADVANCE_COMPRESS).c_str());
SetDlgItemTextW(m_hWnd, IDC_DEBUGGER, GS(ADVANCE_DEBUGGER)); SetDlgItemTextW(m_hWnd, IDC_DEBUGGER, wGS(ADVANCE_DEBUGGER).c_str());
SetDlgItemTextW(m_hWnd, IDC_REMEMBER_CHEAT, GS(OPTION_REMEMBER_CHEAT)); SetDlgItemTextW(m_hWnd, IDC_REMEMBER_CHEAT, wGS(OPTION_REMEMBER_CHEAT).c_str());
SetDlgItemTextW(m_hWnd, IDC_CHECK_RUNNING, GS(OPTION_CHECK_RUNNING)); SetDlgItemTextW(m_hWnd, IDC_CHECK_RUNNING, wGS(OPTION_CHECK_RUNNING).c_str());
SetDlgItemTextW(m_hWnd, IDC_DISPLAY_FRAMERATE, GS(OPTION_CHANGE_FR)); SetDlgItemTextW(m_hWnd, IDC_DISPLAY_FRAMERATE, wGS(OPTION_CHANGE_FR).c_str());
AddModCheckBox(GetDlgItem(IDC_START_ON_ROM_OPEN),Setting_AutoStart); AddModCheckBox(GetDlgItem(IDC_START_ON_ROM_OPEN), Setting_AutoStart);
AddModCheckBox(GetDlgItem(IDC_ZIP),Setting_AutoZipInstantSave); AddModCheckBox(GetDlgItem(IDC_ZIP), Setting_AutoZipInstantSave);
AddModCheckBox(GetDlgItem(IDC_DEBUGGER),Debugger_Enabled); AddModCheckBox(GetDlgItem(IDC_DEBUGGER), Debugger_Enabled);
AddModCheckBox(GetDlgItem(IDC_REMEMBER_CHEAT),Setting_RememberCheats); AddModCheckBox(GetDlgItem(IDC_REMEMBER_CHEAT), Setting_RememberCheats);
AddModCheckBox(GetDlgItem(IDC_CHECK_RUNNING),Setting_CheckEmuRunning); AddModCheckBox(GetDlgItem(IDC_CHECK_RUNNING), Setting_CheckEmuRunning);
AddModCheckBox(GetDlgItem(IDC_DISPLAY_FRAMERATE),UserInterface_DisplayFrameRate); AddModCheckBox(GetDlgItem(IDC_DISPLAY_FRAMERATE), UserInterface_DisplayFrameRate);
CModifiedComboBox * ComboBox; CModifiedComboBox * ComboBox;
ComboBox = AddModComboBox(GetDlgItem(IDC_FRAME_DISPLAY_TYPE),UserInterface_FrameDisplayType); ComboBox = AddModComboBox(GetDlgItem(IDC_FRAME_DISPLAY_TYPE), UserInterface_FrameDisplayType);
if (ComboBox) if (ComboBox)
{ {
ComboBox->AddItemW(GS(STR_FR_VIS), FR_VIs ); ComboBox->AddItemW(wGS(STR_FR_VIS).c_str(), FR_VIs);
ComboBox->AddItemW(GS(STR_FR_DLS), FR_DLs ); ComboBox->AddItemW(wGS(STR_FR_DLS).c_str(), FR_DLs);
ComboBox->AddItemW(GS(STR_FR_PERCENT), FR_PERCENT ); ComboBox->AddItemW(wGS(STR_FR_PERCENT).c_str(), FR_PERCENT);
} }
UpdatePageSettings(); UpdatePageSettings();
@ -56,12 +56,12 @@ void CAdvancedOptionsPage::ShowPage()
ShowWindow(SW_SHOW); ShowWindow(SW_SHOW);
} }
void CAdvancedOptionsPage::ApplySettings( bool UpdateScreen ) void CAdvancedOptionsPage::ApplySettings(bool UpdateScreen)
{ {
CSettingsPageImpl<CAdvancedOptionsPage>::ApplySettings(UpdateScreen); CSettingsPageImpl<CAdvancedOptionsPage>::ApplySettings(UpdateScreen);
} }
bool CAdvancedOptionsPage::EnableReset ( void ) bool CAdvancedOptionsPage::EnableReset(void)
{ {
if (CSettingsPageImpl<CAdvancedOptionsPage>::EnableReset()) { return true; } if (CSettingsPageImpl<CAdvancedOptionsPage>::EnableReset()) { return true; }
return false; return false;

14
Source/Project64/UserInterface/Settings/SettingsPage-Directories.cpp
View File

@ -46,11 +46,11 @@ m_InUpdateSettings(false)
m_TextureSelected.Attach(GetDlgItem(IDC_TEXTURE_OTHER)); m_TextureSelected.Attach(GetDlgItem(IDC_TEXTURE_OTHER));
//Set Text language for the dialog box //Set Text language for the dialog box
::SetWindowTextW(m_PluginGroup.m_hWnd, GS(DIR_PLUGIN)); ::SetWindowTextW(m_PluginGroup.m_hWnd, wGS(DIR_PLUGIN).c_str());
::SetWindowTextW(m_AutoSaveGroup.m_hWnd, GS(DIR_AUTO_SAVE)); ::SetWindowTextW(m_AutoSaveGroup.m_hWnd, wGS(DIR_AUTO_SAVE).c_str());
::SetWindowTextW(m_InstantSaveGroup.m_hWnd, GS(DIR_INSTANT_SAVE)); ::SetWindowTextW(m_InstantSaveGroup.m_hWnd, wGS(DIR_INSTANT_SAVE).c_str());
::SetWindowTextW(m_ScreenShotGroup.m_hWnd, GS(DIR_SCREEN_SHOT)); ::SetWindowTextW(m_ScreenShotGroup.m_hWnd, wGS(DIR_SCREEN_SHOT).c_str());
::SetWindowTextW(m_TextureGroup.m_hWnd, GS(DIR_TEXTURE)); ::SetWindowTextW(m_TextureGroup.m_hWnd, wGS(DIR_TEXTURE).c_str());
UpdatePageSettings(); UpdatePageSettings();
} }
@ -78,11 +78,11 @@ void COptionsDirectoriesPage::SelectDirectory(LanguageStringID Title, CModifiedE
BROWSEINFOW bi; BROWSEINFOW bi;
stdstr InitialDir = EditBox.GetWindowText(); stdstr InitialDir = EditBox.GetWindowText();
std::wstring wTitle = wGS(Title);
bi.hwndOwner = m_hWnd; bi.hwndOwner = m_hWnd;
bi.pidlRoot = NULL; bi.pidlRoot = NULL;
bi.pszDisplayName = Buffer; bi.pszDisplayName = Buffer;
bi.lpszTitle = GS(Title); bi.lpszTitle = wTitle.c_str();
bi.ulFlags = BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS; bi.ulFlags = BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
bi.lpfn = (BFFCALLBACK)SelectDirCallBack; bi.lpfn = (BFFCALLBACK)SelectDirCallBack;
bi.lParam = (DWORD)InitialDir.c_str(); bi.lParam = (DWORD)InitialDir.c_str();

52
Source/Project64/UserInterface/Settings/SettingsPage-Game-General.cpp
View File

@ -21,21 +21,21 @@ CGameGeneralPage::CGameGeneralPage(HWND hParent, const RECT & rcDispay)
} }
//Set the text for all gui Items //Set the text for all gui Items
SetDlgItemTextW(m_hWnd, IDC_GOOD_NAME_TEXT, GS(RB_GOODNAME)); SetDlgItemTextW(m_hWnd, IDC_GOOD_NAME_TEXT, wGS(RB_GOODNAME).c_str());
SetDlgItemTextW(m_hWnd, IDC_MEMORY_SIZE_TEXT, GS(ROM_MEM_SIZE)); SetDlgItemTextW(m_hWnd, IDC_MEMORY_SIZE_TEXT, wGS(ROM_MEM_SIZE).c_str());
SetDlgItemTextW(m_hWnd, IDC_SAVE_TYPE_TEXT, GS(ROM_SAVE_TYPE)); SetDlgItemTextW(m_hWnd, IDC_SAVE_TYPE_TEXT, wGS(ROM_SAVE_TYPE).c_str());
SetDlgItemTextW(m_hWnd, IDC_COUNTFACT_TEXT, GS(ROM_COUNTER_FACTOR)); SetDlgItemTextW(m_hWnd, IDC_COUNTFACT_TEXT, wGS(ROM_COUNTER_FACTOR).c_str());
SetDlgItemTextW(m_hWnd, IDC_VIREFESH_TEXT, GS(ROM_VIREFRESH)); SetDlgItemTextW(m_hWnd, IDC_VIREFESH_TEXT, wGS(ROM_VIREFRESH).c_str());
SetDlgItemTextW(m_hWnd, IDC_COUNTPERBYTE_TEXT, GS(ROM_COUNTPERBYTE)); SetDlgItemTextW(m_hWnd, IDC_COUNTPERBYTE_TEXT, wGS(ROM_COUNTPERBYTE).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROM_32BIT, GS(ROM_32BIT)); SetDlgItemTextW(m_hWnd, IDC_ROM_32BIT, wGS(ROM_32BIT).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROM_FIXEDAUDIO, GS(ROM_FIXED_AUDIO)); SetDlgItemTextW(m_hWnd, IDC_ROM_FIXEDAUDIO, wGS(ROM_FIXED_AUDIO).c_str());
SetDlgItemTextW(m_hWnd, IDC_DELAY_DP, GS(ROM_DELAY_DP)); SetDlgItemTextW(m_hWnd, IDC_DELAY_DP, wGS(ROM_DELAY_DP).c_str());
SetDlgItemTextW(m_hWnd, IDC_SYNC_AUDIO, GS(ROM_SYNC_AUDIO)); SetDlgItemTextW(m_hWnd, IDC_SYNC_AUDIO, wGS(ROM_SYNC_AUDIO).c_str());
SetDlgItemTextW(m_hWnd, IDC_USE_TLB, GS(ROM_USE_TLB)); SetDlgItemTextW(m_hWnd, IDC_USE_TLB, wGS(ROM_USE_TLB).c_str());
SetDlgItemTextW(m_hWnd, IDC_DELAY_SI, GS(ROM_DELAY_SI)); SetDlgItemTextW(m_hWnd, IDC_DELAY_SI, wGS(ROM_DELAY_SI).c_str());
SetDlgItemTextW(m_hWnd, IDC_AUDIO_SIGNAL, GS(ROM_AUDIO_SIGNAL)); SetDlgItemTextW(m_hWnd, IDC_AUDIO_SIGNAL, wGS(ROM_AUDIO_SIGNAL).c_str());
AddModCheckBox(GetDlgItem(IDC_ROM_32BIT), Game_32Bit); AddModCheckBox(GetDlgItem(IDC_ROM_32BIT), Game_32Bit);
AddModCheckBox(GetDlgItem(IDC_SYNC_AUDIO), Game_SyncViaAudio); AddModCheckBox(GetDlgItem(IDC_SYNC_AUDIO), Game_SyncViaAudio);
@ -50,31 +50,31 @@ CGameGeneralPage::CGameGeneralPage(HWND hParent, const RECT & rcDispay)
if (ComboBox) if (ComboBox)
{ {
ComboBox->SetTextField(GetDlgItem(IDC_MEMORY_SIZE_TEXT)); ComboBox->SetTextField(GetDlgItem(IDC_MEMORY_SIZE_TEXT));
ComboBox->AddItemW(GS(RDRAM_4MB), 0x400000); ComboBox->AddItemW(wGS(RDRAM_4MB).c_str(), 0x400000);
ComboBox->AddItemW(GS(RDRAM_8MB), 0x800000); ComboBox->AddItemW(wGS(RDRAM_8MB).c_str(), 0x800000);
} }
ComboBox = AddModComboBox(GetDlgItem(IDC_SAVE_TYPE), Game_SaveChip); ComboBox = AddModComboBox(GetDlgItem(IDC_SAVE_TYPE), Game_SaveChip);
if (ComboBox) if (ComboBox)
{ {
ComboBox->SetTextField(GetDlgItem(IDC_SAVE_TYPE_TEXT)); ComboBox->SetTextField(GetDlgItem(IDC_SAVE_TYPE_TEXT));
ComboBox->AddItemW(GS(SAVE_FIRST_USED), (WPARAM)SaveChip_Auto); ComboBox->AddItemW(wGS(SAVE_FIRST_USED).c_str(), (WPARAM)SaveChip_Auto);
ComboBox->AddItemW(GS(SAVE_4K_EEPROM), SaveChip_Eeprom_4K); ComboBox->AddItemW(wGS(SAVE_4K_EEPROM).c_str(), SaveChip_Eeprom_4K);
ComboBox->AddItemW(GS(SAVE_16K_EEPROM), SaveChip_Eeprom_16K); ComboBox->AddItemW(wGS(SAVE_16K_EEPROM).c_str(), SaveChip_Eeprom_16K);
ComboBox->AddItemW(GS(SAVE_SRAM), SaveChip_Sram); ComboBox->AddItemW(wGS(SAVE_SRAM).c_str(), SaveChip_Sram);
ComboBox->AddItemW(GS(SAVE_FLASHRAM), SaveChip_FlashRam); ComboBox->AddItemW(wGS(SAVE_FLASHRAM).c_str(), SaveChip_FlashRam);
} }
ComboBox = AddModComboBox(GetDlgItem(IDC_COUNTFACT), Game_CounterFactor); ComboBox = AddModComboBox(GetDlgItem(IDC_COUNTFACT), Game_CounterFactor);
if (ComboBox) if (ComboBox)
{ {
ComboBox->SetTextField(GetDlgItem(IDC_COUNTFACT_TEXT)); ComboBox->SetTextField(GetDlgItem(IDC_COUNTFACT_TEXT));
ComboBox->AddItemW(GS(NUMBER_1), 1); ComboBox->AddItemW(wGS(NUMBER_1).c_str(), 1);
ComboBox->AddItemW(GS(NUMBER_2), 2); ComboBox->AddItemW(wGS(NUMBER_2).c_str(), 2);
ComboBox->AddItemW(GS(NUMBER_3), 3); ComboBox->AddItemW(wGS(NUMBER_3).c_str(), 3);
ComboBox->AddItemW(GS(NUMBER_4), 4); ComboBox->AddItemW(wGS(NUMBER_4).c_str(), 4);
ComboBox->AddItemW(GS(NUMBER_5), 5); ComboBox->AddItemW(wGS(NUMBER_5).c_str(), 5);
ComboBox->AddItemW(GS(NUMBER_6), 6); ComboBox->AddItemW(wGS(NUMBER_6).c_str(), 6);
} }
SetDlgItemText(IDC_GOOD_NAME, g_Settings->LoadStringVal(Game_GoodName).c_str()); SetDlgItemText(IDC_GOOD_NAME, g_Settings->LoadStringVal(Game_GoodName).c_str());

26
Source/Project64/UserInterface/Settings/SettingsPage-Game-Plugin.cpp
View File

@ -21,18 +21,18 @@ CGamePluginPage::CGamePluginPage(HWND hParent, const RECT & rcDispay)
} }
//Set the text for all gui Items //Set the text for all gui Items
SetDlgItemTextW(m_hWnd, RSP_ABOUT, GS(PLUG_ABOUT)); SetDlgItemTextW(m_hWnd, RSP_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, GFX_ABOUT, GS(PLUG_ABOUT)); SetDlgItemTextW(m_hWnd, GFX_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, AUDIO_ABOUT, GS(PLUG_ABOUT)); SetDlgItemTextW(m_hWnd, AUDIO_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, CONT_ABOUT, GS(PLUG_ABOUT)); SetDlgItemTextW(m_hWnd, CONT_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, IDC_RSP_NAME, GS(PLUG_RSP)); SetDlgItemTextW(m_hWnd, IDC_RSP_NAME, wGS(PLUG_RSP).c_str());
SetDlgItemTextW(m_hWnd, IDC_GFX_NAME, GS(PLUG_GFX)); SetDlgItemTextW(m_hWnd, IDC_GFX_NAME, wGS(PLUG_GFX).c_str());
SetDlgItemTextW(m_hWnd, IDC_AUDIO_NAME, GS(PLUG_AUDIO)); SetDlgItemTextW(m_hWnd, IDC_AUDIO_NAME, wGS(PLUG_AUDIO).c_str());
SetDlgItemTextW(m_hWnd, IDC_CONT_NAME, GS(PLUG_CTRL)); SetDlgItemTextW(m_hWnd, IDC_CONT_NAME, wGS(PLUG_CTRL).c_str());
SetDlgItemTextW(m_hWnd, IDC_HLE_GFX, GS(PLUG_HLE_GFX)); SetDlgItemTextW(m_hWnd, IDC_HLE_GFX, wGS(PLUG_HLE_GFX).c_str());
SetDlgItemTextW(m_hWnd, IDC_HLE_AUDIO, GS(PLUG_HLE_AUDIO)); SetDlgItemTextW(m_hWnd, IDC_HLE_AUDIO, wGS(PLUG_HLE_AUDIO).c_str());
m_GfxGroup.Attach(GetDlgItem(IDC_GFX_NAME)); m_GfxGroup.Attach(GetDlgItem(IDC_GFX_NAME));
m_AudioGroup.Attach(GetDlgItem(IDC_AUDIO_NAME)); m_AudioGroup.Attach(GetDlgItem(IDC_AUDIO_NAME));
@ -61,7 +61,7 @@ void CGamePluginPage::AddPlugins(int ListId, SettingID Type, PLUGIN_TYPE PluginT
{ {
ComboBox->SetDefault(NULL); ComboBox->SetDefault(NULL);
} }
ComboBox->AddItemW(GS(PLUG_DEFAULT), NULL); ComboBox->AddItemW(wGS(PLUG_DEFAULT).c_str(), NULL);
for (int i = 0, n = m_PluginList.GetPluginCount(); i < n; i++) for (int i = 0, n = m_PluginList.GetPluginCount(); i < n; i++)
{ {
@ -312,7 +312,7 @@ void CGamePluginPage::HleGfxChanged(UINT /*Code*/, int id, HWND /*ctl*/)
} }
if ((Button->GetCheck() & BST_CHECKED) == 0) if ((Button->GetCheck() & BST_CHECKED) == 0)
{ {
int res = MessageBoxW(m_hWnd, GS(MSG_SET_LLE_GFX_MSG), GS(MSG_SET_LLE_GFX_TITLE), MB_YESNO | MB_ICONWARNING); int res = MessageBoxW(m_hWnd, wGS(MSG_SET_LLE_GFX_MSG).c_str(), wGS(MSG_SET_LLE_GFX_TITLE).c_str(), MB_YESNO | MB_ICONWARNING);
if (res != IDYES) if (res != IDYES)
{ {
Button->SetCheck(BST_CHECKED); Button->SetCheck(BST_CHECKED);
@ -336,7 +336,7 @@ void CGamePluginPage::HleAudioChanged(UINT /*Code*/, int id, HWND /*ctl*/)
} }
if ((Button->GetCheck() & BST_CHECKED) != 0) if ((Button->GetCheck() & BST_CHECKED) != 0)
{ {
int res = MessageBoxW(m_hWnd, GS(MSG_SET_HLE_AUD_MSG), GS(MSG_SET_HLE_AUD_TITLE), MB_ICONWARNING | MB_YESNO); int res = MessageBoxW(m_hWnd, wGS(MSG_SET_HLE_AUD_MSG).c_str(), wGS(MSG_SET_HLE_AUD_TITLE).c_str(), MB_ICONWARNING | MB_YESNO);
if (res != IDYES) if (res != IDYES)
{ {
Button->SetCheck(BST_UNCHECKED); Button->SetCheck(BST_UNCHECKED);

34
Source/Project64/UserInterface/Settings/SettingsPage-Game-Recompiler.cpp
View File

@ -21,19 +21,19 @@ CGameRecompilePage::CGameRecompilePage(HWND hParent, const RECT & rcDispay)
} }
//Set the text for all gui Items //Set the text for all gui Items
SetDlgItemTextW(m_hWnd, IDC_CPU_TYPE_TEXT, GS(ROM_CPU_STYLE)); SetDlgItemTextW(m_hWnd, IDC_CPU_TYPE_TEXT, wGS(ROM_CPU_STYLE).c_str());
SetDlgItemTextW(m_hWnd, IDC_FUNCFIND_TEXT, GS(ROM_FUNC_FIND)); SetDlgItemTextW(m_hWnd, IDC_FUNCFIND_TEXT, wGS(ROM_FUNC_FIND).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROM_REGCACHE, GS(ROM_REG_CACHE)); SetDlgItemTextW(m_hWnd, IDC_ROM_REGCACHE, wGS(ROM_REG_CACHE).c_str());
SetDlgItemTextW(m_hWnd, IDC_BLOCK_LINKING, GS(ADVANCE_ABL)); SetDlgItemTextW(m_hWnd, IDC_BLOCK_LINKING, wGS(ADVANCE_ABL).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROM_FASTSP, GS(ROM_FAST_SP)); SetDlgItemTextW(m_hWnd, IDC_ROM_FASTSP, wGS(ROM_FAST_SP).c_str());
SetDlgItemTextW(m_hWnd, IDC_SMM_FRAME, GS(ADVANCE_SMCM)); SetDlgItemTextW(m_hWnd, IDC_SMM_FRAME, wGS(ADVANCE_SMCM).c_str());
SetDlgItemTextW(m_hWnd, IDC_SMM_CACHE, GS(ADVANCE_SMM_CACHE)); SetDlgItemTextW(m_hWnd, IDC_SMM_CACHE, wGS(ADVANCE_SMM_CACHE).c_str());
SetDlgItemTextW(m_hWnd, IDC_SMM_DMA, GS(ADVANCE_SMM_PIDMA)); SetDlgItemTextW(m_hWnd, IDC_SMM_DMA, wGS(ADVANCE_SMM_PIDMA).c_str());
SetDlgItemTextW(m_hWnd, IDC_SMM_VALIDATE, GS(ADVANCE_SMM_VALIDATE)); SetDlgItemTextW(m_hWnd, IDC_SMM_VALIDATE, wGS(ADVANCE_SMM_VALIDATE).c_str());
SetDlgItemTextW(m_hWnd, IDC_SMM_TLB, GS(ADVANCE_SMM_TLB)); SetDlgItemTextW(m_hWnd, IDC_SMM_TLB, wGS(ADVANCE_SMM_TLB).c_str());
SetDlgItemTextW(m_hWnd, IDC_SMM_PROTECT, GS(ADVANCE_SMM_PROTECT)); SetDlgItemTextW(m_hWnd, IDC_SMM_PROTECT, wGS(ADVANCE_SMM_PROTECT).c_str());
m_SelfModGroup.Attach(GetDlgItem(IDC_SMM_FRAME)); m_SelfModGroup.Attach(GetDlgItem(IDC_SMM_FRAME));
@ -52,20 +52,20 @@ CGameRecompilePage::CGameRecompilePage(HWND hParent, const RECT & rcDispay)
ComboBox = AddModComboBox(GetDlgItem(IDC_CPU_TYPE), Game_CpuType); ComboBox = AddModComboBox(GetDlgItem(IDC_CPU_TYPE), Game_CpuType);
if (ComboBox) if (ComboBox)
{ {
ComboBox->AddItemW(GS(CORE_RECOMPILER), CPU_Recompiler); ComboBox->AddItemW(wGS(CORE_RECOMPILER).c_str(), CPU_Recompiler);
ComboBox->AddItemW(GS(CORE_INTERPTER), CPU_Interpreter); ComboBox->AddItemW(wGS(CORE_INTERPTER).c_str(), CPU_Interpreter);
if (g_Settings->LoadBool(Debugger_Enabled)) if (g_Settings->LoadBool(Debugger_Enabled))
{ {
ComboBox->AddItemW(GS(CORE_SYNC), CPU_SyncCores); ComboBox->AddItemW(wGS(CORE_SYNC).c_str(), CPU_SyncCores);
} }
} }
ComboBox = AddModComboBox(GetDlgItem(IDC_FUNCFIND), Game_FuncLookupMode); ComboBox = AddModComboBox(GetDlgItem(IDC_FUNCFIND), Game_FuncLookupMode);
if (ComboBox) if (ComboBox)
{ {
ComboBox->AddItemW(GS(FLM_PLOOKUP), FuncFind_PhysicalLookup); ComboBox->AddItemW(wGS(FLM_PLOOKUP).c_str(), FuncFind_PhysicalLookup);
ComboBox->AddItemW(GS(FLM_VLOOKUP), FuncFind_VirtualLookup); ComboBox->AddItemW(wGS(FLM_VLOOKUP).c_str(), FuncFind_VirtualLookup);
//ComboBox->AddItem(GS(FLM_CHANGEMEM), FuncFind_ChangeMemory); //ComboBox->AddItem(wGS(FLM_CHANGEMEM).c_str(), FuncFind_ChangeMemory);
} }
UpdatePageSettings(); UpdatePageSettings();
} }

32
Source/Project64/UserInterface/Settings/SettingsPage-GameBrowser.cpp
View File

@ -21,16 +21,16 @@ m_OrderReset(false)
return; return;
} }
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT2, GS(RB_ROMS)); SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT2, wGS(RB_ROMS).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT4, GS(RB_DIRS)); SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT4, wGS(RB_DIRS).c_str());
SetDlgItemTextW(m_hWnd, IDC_USE_ROMBROWSER, GS(RB_USE)); SetDlgItemTextW(m_hWnd, IDC_USE_ROMBROWSER, wGS(RB_USE).c_str());
SetDlgItemTextW(m_hWnd, IDC_RECURSION, GS(RB_DIR_RECURSION)); SetDlgItemTextW(m_hWnd, IDC_RECURSION, wGS(RB_DIR_RECURSION).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT5, GS(RB_AVALIABLE_FIELDS)); SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT5, wGS(RB_AVALIABLE_FIELDS).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT6, GS(RB_SHOW_FIELDS)); SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT6, wGS(RB_SHOW_FIELDS).c_str());
SetDlgItemTextW(m_hWnd, IDC_ADD, GS(RB_ADD)); SetDlgItemTextW(m_hWnd, IDC_ADD, wGS(RB_ADD).c_str());
SetDlgItemTextW(m_hWnd, IDC_REMOVE, GS(RB_REMOVE)); SetDlgItemTextW(m_hWnd, IDC_REMOVE, wGS(RB_REMOVE).c_str());
SetDlgItemTextW(m_hWnd, IDC_UP, GS(RB_UP)); SetDlgItemTextW(m_hWnd, IDC_UP, wGS(RB_UP).c_str());
SetDlgItemTextW(m_hWnd, IDC_DOWN, GS(RB_DOWN)); SetDlgItemTextW(m_hWnd, IDC_DOWN, wGS(RB_DOWN).c_str());
AddModCheckBox(GetDlgItem(IDC_USE_ROMBROWSER), RomBrowser_Enabled); AddModCheckBox(GetDlgItem(IDC_USE_ROMBROWSER), RomBrowser_Enabled);
AddModCheckBox(GetDlgItem(IDC_RECURSION), RomBrowser_Recursive); AddModCheckBox(GetDlgItem(IDC_RECURSION), RomBrowser_Recursive);
@ -58,12 +58,12 @@ void COptionsGameBrowserPage::UpdateFieldList(const ROMBROWSER_FIELDS_LIST & Fie
int Pos = Fields[i].Pos(); int Pos = Fields[i].Pos();
if (Pos < 0) if (Pos < 0)
{ {
m_Avaliable.SetItemData(m_Avaliable.AddStringW(GS(Fields[i].LangID())), i); m_Avaliable.SetItemData(m_Avaliable.AddStringW(wGS(Fields[i].LangID()).c_str()), i);
continue; continue;
} }
int listCount = m_Using.GetCount(); int listCount = m_Using.GetCount();
if (Pos > listCount) { Pos = listCount; } if (Pos > listCount) { Pos = listCount; }
m_Using.SetItemData(m_Using.InsertStringW(Pos, GS(Fields[i].LangID())), i); m_Using.SetItemData(m_Using.InsertStringW(Pos, wGS(Fields[i].LangID()).c_str()), i);
} }
} }
@ -111,7 +111,7 @@ void COptionsGameBrowserPage::AddFieldClicked(UINT /*Code*/, int /*id*/, HWND /*
m_Avaliable.SetCurSel(index); m_Avaliable.SetCurSel(index);
//Add to list //Add to list
index = m_Using.AddStringW(GS(m_Fields[i].LangID())); index = m_Using.AddStringW(wGS(m_Fields[i].LangID()).c_str());
m_Using.SetItemData(index, i); m_Using.SetItemData(index, i);
m_Using.SetCurSel(index); m_Using.SetCurSel(index);
@ -137,7 +137,7 @@ void COptionsGameBrowserPage::RemoveFieldClicked(UINT /*Code*/, int /*id*/, HWND
m_Using.SetCurSel(index); m_Using.SetCurSel(index);
//Add to list //Add to list
index = m_Avaliable.AddStringW(GS(m_Fields[i].LangID())); index = m_Avaliable.AddStringW(wGS(m_Fields[i].LangID()).c_str());
m_Avaliable.SetItemData(index, i); m_Avaliable.SetItemData(index, i);
m_Avaliable.SetCurSel(index); m_Avaliable.SetCurSel(index);
@ -156,7 +156,7 @@ void COptionsGameBrowserPage::MoveFieldUpClicked(UINT /*Code*/, int /*id*/, HWND
int i = m_Using.GetItemData(index); int i = m_Using.GetItemData(index);
m_Using.DeleteString(index); m_Using.DeleteString(index);
index = m_Using.InsertStringW(index - 1, GS(m_Fields[i].LangID())); index = m_Using.InsertStringW(index - 1, wGS(m_Fields[i].LangID()).c_str());
m_Using.SetItemData(index, i); m_Using.SetItemData(index, i);
m_Using.SetCurSel(index); m_Using.SetCurSel(index);
@ -175,7 +175,7 @@ void COptionsGameBrowserPage::MoveFieldDownClicked(UINT /*Code*/, int /*id*/, HW
int i = m_Using.GetItemData(index); int i = m_Using.GetItemData(index);
m_Using.DeleteString(index); m_Using.DeleteString(index);
index = m_Using.InsertStringW(index + 1, GS(m_Fields[i].LangID())); index = m_Using.InsertStringW(index + 1, wGS(m_Fields[i].LangID()).c_str());
m_Using.SetItemData(index, i); m_Using.SetItemData(index, i);
m_Using.SetCurSel(index); m_Using.SetCurSel(index);

29
Source/Project64/UserInterface/Settings/SettingsPage-KeyboardShortcuts.cpp
View File

@ -20,14 +20,14 @@ m_EnableReset(false)
return; return;
} }
SetDlgItemTextW(m_hWnd, IDC_S_CPU_STATE, GS(ACCEL_CPUSTATE_TITLE)); SetDlgItemTextW(m_hWnd, IDC_S_CPU_STATE, wGS(ACCEL_CPUSTATE_TITLE).c_str());
SetDlgItemTextW(m_hWnd, IDC_MENU_ITEM_TEXT, GS(ACCEL_MENUITEM_TITLE)); SetDlgItemTextW(m_hWnd, IDC_MENU_ITEM_TEXT, wGS(ACCEL_MENUITEM_TITLE).c_str());
SetDlgItemTextW(m_hWnd, IDC_S_CURRENT_KEYS, GS(ACCEL_CURRENTKEYS_TITLE)); SetDlgItemTextW(m_hWnd, IDC_S_CURRENT_KEYS, wGS(ACCEL_CURRENTKEYS_TITLE).c_str());
SetDlgItemTextW(m_hWnd, IDC_S_SELECT_SHORT, GS(ACCEL_SELKEY_TITLE)); SetDlgItemTextW(m_hWnd, IDC_S_SELECT_SHORT, wGS(ACCEL_SELKEY_TITLE).c_str());
SetDlgItemTextW(m_hWnd, IDC_S_CURRENT_ASSIGN, GS(ACCEL_ASSIGNEDTO_TITLE)); SetDlgItemTextW(m_hWnd, IDC_S_CURRENT_ASSIGN, wGS(ACCEL_ASSIGNEDTO_TITLE).c_str());
SetDlgItemTextW(m_hWnd, IDC_ASSIGN, GS(ACCEL_ASSIGN_BTN)); SetDlgItemTextW(m_hWnd, IDC_ASSIGN, wGS(ACCEL_ASSIGN_BTN).c_str());
SetDlgItemTextW(m_hWnd, IDC_REMOVE, GS(ACCEL_REMOVE_BTN)); SetDlgItemTextW(m_hWnd, IDC_REMOVE, wGS(ACCEL_REMOVE_BTN).c_str());
SetDlgItemTextW(m_hWnd, IDC_KEY_PROMPT, GS(ACCEL_DETECTKEY)); SetDlgItemTextW(m_hWnd, IDC_KEY_PROMPT, wGS(ACCEL_DETECTKEY).c_str());
m_CreateNewShortCut.AttachToDlgItem(m_hWnd, IDC_S_SELECT_SHORT); m_CreateNewShortCut.AttachToDlgItem(m_hWnd, IDC_S_SELECT_SHORT);
m_CpuState.Attach(GetDlgItem(IDC_C_CPU_STATE)); m_CpuState.Attach(GetDlgItem(IDC_C_CPU_STATE));
@ -37,9 +37,9 @@ m_EnableReset(false)
m_MenuItems.ModifyStyle(0, TVS_SHOWSELALWAYS); m_MenuItems.ModifyStyle(0, TVS_SHOWSELALWAYS);
m_CpuState.SetItemData(m_CpuState.AddStringW(GS(ACCEL_CPUSTATE_1)), CMenuShortCutKey::GAME_NOT_RUNNING); m_CpuState.SetItemData(m_CpuState.AddStringW(wGS(ACCEL_CPUSTATE_1).c_str()), CMenuShortCutKey::GAME_NOT_RUNNING);
m_CpuState.SetItemData(m_CpuState.AddStringW(GS(ACCEL_CPUSTATE_3)), CMenuShortCutKey::GAME_RUNNING_WINDOW); m_CpuState.SetItemData(m_CpuState.AddStringW(wGS(ACCEL_CPUSTATE_3).c_str()), CMenuShortCutKey::GAME_RUNNING_WINDOW);
m_CpuState.SetItemData(m_CpuState.AddStringW(GS(ACCEL_CPUSTATE_4)), CMenuShortCutKey::GAME_RUNNING_FULLSCREEN); m_CpuState.SetItemData(m_CpuState.AddStringW(wGS(ACCEL_CPUSTATE_4).c_str()), CMenuShortCutKey::GAME_RUNNING_FULLSCREEN);
m_CpuState.SetCurSel(0); m_CpuState.SetCurSel(0);
int VirtualKeyListSize; int VirtualKeyListSize;
@ -99,10 +99,10 @@ void COptionsShortCutsPage::OnCpuStateChanged(UINT /*Code*/, int /*id*/, HWND /*
if (hParent == NULL) if (hParent == NULL)
{ {
hParent = m_MenuItems.InsertItemW(TVIF_TEXT | TVIF_PARAM, GS(Item->second.Section()), 0, 0, 0, 0, Item->second.Section(), TVI_ROOT, TVI_LAST); hParent = m_MenuItems.InsertItemW(TVIF_TEXT | TVIF_PARAM, wGS(Item->second.Section()).c_str(), 0, 0, 0, 0, Item->second.Section(), TVI_ROOT, TVI_LAST);
} }
wstring str = GS(Item->second.Title()); wstring str = wGS(Item->second.Title());
std::wstring::size_type pos = str.find(L"&"); std::wstring::size_type pos = str.find(L"&");
while (pos != std::wstring::npos) while (pos != std::wstring::npos)
{ {
@ -229,8 +229,7 @@ void COptionsShortCutsPage::OnShortCutChanged(UINT /*Code*/, int /*id*/, HWND /*
ACCESS_MODE AccessLevel = (ACCESS_MODE)m_CpuState.GetItemData(m_CpuState.GetCurSel()); ACCESS_MODE AccessLevel = (ACCESS_MODE)m_CpuState.GetItemData(m_CpuState.GetCurSel());
stdstr str; stdstr str = GS(m_ShortCuts.GetMenuItemName(key, bCtrl, bAlt, bShift, AccessLevel));
str.FromUTF16(GS(m_ShortCuts.GetMenuItemName(key, bCtrl, bAlt, bShift, AccessLevel)));
if (str.length() > 0) if (str.length() > 0)
{ {
str.resize(std::remove(str.begin(), str.end(), '&') - str.begin()); str.resize(std::remove(str.begin(), str.end(), '&') - str.begin());

16
Source/Project64/UserInterface/Settings/SettingsPage-Options.cpp
View File

@ -21,14 +21,14 @@ m_SettingsConfig(SettingsConfig)
} }
//Set the text for all gui Items //Set the text for all gui Items
SetDlgItemTextW(m_hWnd, IDC_AUTOSLEEP, GS(OPTION_AUTO_SLEEP)); SetDlgItemTextW(m_hWnd, IDC_AUTOSLEEP, wGS(OPTION_AUTO_SLEEP).c_str());
SetDlgItemTextW(m_hWnd, IDC_LOAD_FULLSCREEN, GS(OPTION_AUTO_FULLSCREEN)); SetDlgItemTextW(m_hWnd, IDC_LOAD_FULLSCREEN, wGS(OPTION_AUTO_FULLSCREEN).c_str());
SetDlgItemTextW(m_hWnd, IDC_SCREEN_SAVER, GS(OPTION_DISABLE_SS)); SetDlgItemTextW(m_hWnd, IDC_SCREEN_SAVER, wGS(OPTION_DISABLE_SS).c_str());
SetDlgItemTextW(m_hWnd, IDC_BASIC_MODE, GS(OPTION_BASIC_MODE)); SetDlgItemTextW(m_hWnd, IDC_BASIC_MODE, wGS(OPTION_BASIC_MODE).c_str());
SetDlgItemTextW(m_hWnd, IDC_MAXROMS_TXT, GS(RB_MAX_ROMS)); SetDlgItemTextW(m_hWnd, IDC_MAXROMS_TXT, wGS(RB_MAX_ROMS).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT2, GS(RB_ROMS)); SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT2, wGS(RB_ROMS).c_str());
SetDlgItemTextW(m_hWnd, IDC_MAXROMDIR_TXT, GS(RB_MAX_DIRS)); SetDlgItemTextW(m_hWnd, IDC_MAXROMDIR_TXT, wGS(RB_MAX_DIRS).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT4, GS(RB_DIRS)); SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT4, wGS(RB_DIRS).c_str());
AddModCheckBox(GetDlgItem(IDC_AUTOSLEEP), Setting_AutoSleep); AddModCheckBox(GetDlgItem(IDC_AUTOSLEEP), Setting_AutoSleep);
AddModCheckBox(GetDlgItem(IDC_LOAD_FULLSCREEN), Setting_AutoFullscreen); AddModCheckBox(GetDlgItem(IDC_LOAD_FULLSCREEN), Setting_AutoFullscreen);

24
Source/Project64/UserInterface/Settings/SettingsPage-Plugin.cpp
View File

@ -20,18 +20,18 @@ COptionPluginPage::COptionPluginPage(HWND hParent, const RECT & rcDispay)
} }
//Set the text for all gui Items //Set the text for all gui Items
SetDlgItemTextW(m_hWnd, RSP_ABOUT, GS(PLUG_ABOUT)); SetDlgItemTextW(m_hWnd, RSP_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, GFX_ABOUT, GS(PLUG_ABOUT)); SetDlgItemTextW(m_hWnd, GFX_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, AUDIO_ABOUT, GS(PLUG_ABOUT)); SetDlgItemTextW(m_hWnd, AUDIO_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, CONT_ABOUT, GS(PLUG_ABOUT)); SetDlgItemTextW(m_hWnd, CONT_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, IDC_RSP_NAME, GS(PLUG_RSP)); SetDlgItemTextW(m_hWnd, IDC_RSP_NAME, wGS(PLUG_RSP).c_str());
SetDlgItemTextW(m_hWnd, IDC_GFX_NAME, GS(PLUG_GFX)); SetDlgItemTextW(m_hWnd, IDC_GFX_NAME, wGS(PLUG_GFX).c_str());
SetDlgItemTextW(m_hWnd, IDC_AUDIO_NAME, GS(PLUG_AUDIO)); SetDlgItemTextW(m_hWnd, IDC_AUDIO_NAME, wGS(PLUG_AUDIO).c_str());
SetDlgItemTextW(m_hWnd, IDC_CONT_NAME, GS(PLUG_CTRL)); SetDlgItemTextW(m_hWnd, IDC_CONT_NAME, wGS(PLUG_CTRL).c_str());
SetDlgItemTextW(m_hWnd, IDC_HLE_GFX, GS(PLUG_HLE_GFX)); SetDlgItemTextW(m_hWnd, IDC_HLE_GFX, wGS(PLUG_HLE_GFX).c_str());
SetDlgItemTextW(m_hWnd, IDC_HLE_AUDIO, GS(PLUG_HLE_AUDIO)); SetDlgItemTextW(m_hWnd, IDC_HLE_AUDIO, wGS(PLUG_HLE_AUDIO).c_str());
m_GfxGroup.Attach(GetDlgItem(IDC_GFX_NAME)); m_GfxGroup.Attach(GetDlgItem(IDC_GFX_NAME));
m_AudioGroup.Attach(GetDlgItem(IDC_AUDIO_NAME)); m_AudioGroup.Attach(GetDlgItem(IDC_AUDIO_NAME));
@ -296,7 +296,7 @@ void COptionPluginPage::HleGfxChanged(UINT /*Code*/, int id, HWND /*ctl*/)
} }
if ((Button->GetCheck() & BST_CHECKED) == 0) if ((Button->GetCheck() & BST_CHECKED) == 0)
{ {
int res = MessageBoxW(m_hWnd, GS(MSG_SET_LLE_GFX_MSG), GS(MSG_SET_LLE_GFX_TITLE), MB_YESNO | MB_ICONWARNING); int res = MessageBoxW(m_hWnd, wGS(MSG_SET_LLE_GFX_MSG).c_str(), wGS(MSG_SET_LLE_GFX_TITLE).c_str(), MB_YESNO | MB_ICONWARNING);
if (res != IDYES) if (res != IDYES)
{ {
Button->SetCheck(BST_CHECKED); Button->SetCheck(BST_CHECKED);
@ -320,7 +320,7 @@ void COptionPluginPage::HleAudioChanged(UINT /*Code*/, int id, HWND /*ctl*/)
} }
if ((Button->GetCheck() & BST_CHECKED) != 0) if ((Button->GetCheck() & BST_CHECKED) != 0)
{ {
int res = MessageBoxW(m_hWnd, GS(MSG_SET_HLE_AUD_MSG), GS(MSG_SET_HLE_AUD_TITLE), MB_ICONWARNING | MB_YESNO); int res = MessageBoxW(m_hWnd, wGS(MSG_SET_HLE_AUD_MSG).c_str(), wGS(MSG_SET_HLE_AUD_TITLE).c_str(), MB_ICONWARNING | MB_YESNO);
if (res != IDYES) if (res != IDYES)
{ {
Button->SetCheck(BST_UNCHECKED); Button->SetCheck(BST_UNCHECKED);

26
Source/Project64/UserInterface/SettingsConfig.cpp
View File

@ -63,7 +63,7 @@ bool CSettingConfig::UpdateAdvanced(bool AdvancedMode, HTREEITEM hItem)
} }
if (AdvancedMode && Page == m_GeneralOptionsPage) if (AdvancedMode && Page == m_GeneralOptionsPage)
{ {
m_PagesTreeList.InsertItemW(TVIF_TEXT | TVIF_PARAM, GS(m_AdvancedPage->PageTitle()), 0, 0, 0, 0, (ULONG)m_AdvancedPage, hItem, TVI_FIRST); m_PagesTreeList.InsertItemW(TVIF_TEXT | TVIF_PARAM, wGS(m_AdvancedPage->PageTitle()).c_str(), 0, 0, 0, 0, (ULONG)m_AdvancedPage, hItem, TVI_FIRST);
return true; return true;
} }
if (UpdateAdvanced(AdvancedMode, m_PagesTreeList.GetChildItem(hItem))) if (UpdateAdvanced(AdvancedMode, m_PagesTreeList.GetChildItem(hItem)))
@ -91,11 +91,11 @@ LRESULT CSettingConfig::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*
CConfigSettingSection * SettingsSection; CConfigSettingSection * SettingsSection;
//Set the text for all gui Items //Set the text for all gui Items
SetDlgItemTextW(m_hWnd, IDC_RESET_PAGE, GS(BOTTOM_RESET_PAGE)); SetDlgItemTextW(m_hWnd, IDC_RESET_PAGE, wGS(BOTTOM_RESET_PAGE).c_str());
SetDlgItemTextW(m_hWnd, IDC_RESET_ALL, GS(BOTTOM_RESET_ALL)); SetDlgItemTextW(m_hWnd, IDC_RESET_ALL, wGS(BOTTOM_RESET_ALL).c_str());
SetDlgItemTextW(m_hWnd, IDOK, GS(CHEAT_OK)); SetDlgItemTextW(m_hWnd, IDOK, wGS(CHEAT_OK).c_str());
SetDlgItemTextW(m_hWnd, IDCANCEL, GS(CHEAT_CANCEL)); SetDlgItemTextW(m_hWnd, IDCANCEL, wGS(CHEAT_CANCEL).c_str());
SetDlgItemTextW(m_hWnd, IDAPPLY, GS(BOTTOM_APPLY)); SetDlgItemTextW(m_hWnd, IDAPPLY, wGS(BOTTOM_APPLY).c_str());
if (m_GameConfig) if (m_GameConfig)
{ {
@ -115,12 +115,12 @@ LRESULT CSettingConfig::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*
SetWindowText(stdstr_f("%ws ** RDB Edit Mode **", GS(OPTIONS_TITLE)).c_str()); SetWindowText(stdstr_f("%ws ** RDB Edit Mode **", GS(OPTIONS_TITLE)).c_str());
} }
else { else {
::SetWindowTextW(m_hWnd, GS(OPTIONS_TITLE)); ::SetWindowTextW(m_hWnd, wGS(OPTIONS_TITLE).c_str());
} }
if (g_Settings->LoadBool(Setting_PluginPageFirst)) if (g_Settings->LoadBool(Setting_PluginPageFirst))
{ {
SettingsSection = new CConfigSettingSection(GS(TAB_PLUGIN)); SettingsSection = new CConfigSettingSection(wGS(TAB_PLUGIN).c_str());
SettingsSection->AddPage(new COptionPluginPage(this->m_hWnd, rcSettingInfo)); SettingsSection->AddPage(new COptionPluginPage(this->m_hWnd, rcSettingInfo));
m_Sections.push_back(SettingsSection); m_Sections.push_back(SettingsSection);
} }
@ -128,23 +128,23 @@ LRESULT CSettingConfig::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*
m_GeneralOptionsPage = new CGeneralOptionsPage(this, this->m_hWnd, rcSettingInfo); m_GeneralOptionsPage = new CGeneralOptionsPage(this, this->m_hWnd, rcSettingInfo);
m_AdvancedPage = new CAdvancedOptionsPage(this->m_hWnd, rcSettingInfo); m_AdvancedPage = new CAdvancedOptionsPage(this->m_hWnd, rcSettingInfo);
SettingsSection = new CConfigSettingSection(GS(TAB_OPTIONS)); SettingsSection = new CConfigSettingSection(wGS(TAB_OPTIONS).c_str());
SettingsSection->AddPage(m_GeneralOptionsPage); SettingsSection->AddPage(m_GeneralOptionsPage);
SettingsSection->AddPage(m_AdvancedPage); SettingsSection->AddPage(m_AdvancedPage);
SettingsSection->AddPage(new COptionsDirectoriesPage(this->m_hWnd, rcSettingInfo)); SettingsSection->AddPage(new COptionsDirectoriesPage(this->m_hWnd, rcSettingInfo));
m_Sections.push_back(SettingsSection); m_Sections.push_back(SettingsSection);
SettingsSection = new CConfigSettingSection(GS(TAB_ROMSELECTION)); SettingsSection = new CConfigSettingSection(wGS(TAB_ROMSELECTION).c_str());
SettingsSection->AddPage(new COptionsGameBrowserPage(this->m_hWnd, rcSettingInfo)); SettingsSection->AddPage(new COptionsGameBrowserPage(this->m_hWnd, rcSettingInfo));
m_Sections.push_back(SettingsSection); m_Sections.push_back(SettingsSection);
SettingsSection = new CConfigSettingSection(GS(TAB_SHORTCUTS)); SettingsSection = new CConfigSettingSection(wGS(TAB_SHORTCUTS).c_str());
SettingsSection->AddPage(new COptionsShortCutsPage(this->m_hWnd, rcSettingInfo)); SettingsSection->AddPage(new COptionsShortCutsPage(this->m_hWnd, rcSettingInfo));
m_Sections.push_back(SettingsSection); m_Sections.push_back(SettingsSection);
if (!g_Settings->LoadBool(Setting_PluginPageFirst)) if (!g_Settings->LoadBool(Setting_PluginPageFirst))
{ {
SettingsSection = new CConfigSettingSection(GS(TAB_PLUGIN)); SettingsSection = new CConfigSettingSection(wGS(TAB_PLUGIN).c_str());
SettingsSection->AddPage(new COptionPluginPage(this->m_hWnd, rcSettingInfo)); SettingsSection->AddPage(new COptionPluginPage(this->m_hWnd, rcSettingInfo));
m_Sections.push_back(SettingsSection); m_Sections.push_back(SettingsSection);
} }
@ -190,7 +190,7 @@ LRESULT CSettingConfig::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*
{ {
continue; continue;
} }
m_PagesTreeList.InsertItemW(TVIF_TEXT | TVIF_PARAM, GS(Page->PageTitle()), 0, 0, 0, 0, (ULONG)Page, hSectionItem, TVI_LAST); m_PagesTreeList.InsertItemW(TVIF_TEXT | TVIF_PARAM, wGS(Page->PageTitle()).c_str(), 0, 0, 0, 0, (ULONG)Page, hSectionItem, TVI_LAST);
} }
if (bFirstItem && hSectionItem != NULL) if (bFirstItem && hSectionItem != NULL)
{ {