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 <memory.h>
#include "7zip.h"
#include <Common/StdString.h>
C7zip::C7zip(LPCSTR FileName) :
m_FileSize(0),
@ -126,9 +127,9 @@ bool C7zip::GetFile(int index, Byte * Data, size_t DataLen)
size_t offset;
size_t outSizeProcessed;
wchar_t Msg[200];
char Msg[200];
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);
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;
}
memcpy(Data, m_outBuffer + offset, outSizeProcessed);
m_NotfyCallback(L"", m_NotfyCallbackInfo);
m_NotfyCallback("", m_NotfyCallbackInfo);
m_CurrentFile = -1;
return true;
}

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

@ -21,7 +21,7 @@ public:
C7zip(LPCSTR FileName);
~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 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 NotfyCallbackDefault(LPCWSTR /*Status*/, void * /*CBInfo*/) { }
static void NotfyCallbackDefault(const char * /*Status*/, void * /*CBInfo*/) { }
LP7ZNOTIFICATION m_NotfyCallback;
void * m_NotfyCallbackInfo;

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

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

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

@ -48,7 +48,7 @@ void CFramePerSecond::Reset(bool ClearDisplay)
}
if (ClearDisplay)
{
g_Notify->DisplayMessage2(L"");
g_Notify->DisplayMessage2("");
return;
}
@ -81,7 +81,7 @@ void CFramePerSecond::DisplayViCounter(uint32_t FrameRate)
{
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
{
@ -94,11 +94,11 @@ void CFramePerSecond::DisplayViCounter(uint32_t FrameRate)
{
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
{
g_Notify->DisplayMessage2(L"VI/s: -.--");
g_Notify->DisplayMessage2("VI/s: -.--");
}
}
}
@ -124,11 +124,11 @@ void CFramePerSecond::DisplayViCounter(uint32_t FrameRate)
}
else
{
g_Notify->DisplayMessage2(L"");
g_Notify->DisplayMessage2("");
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)
{
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
{
@ -181,11 +181,11 @@ void CFramePerSecond::DisplayDlCounter(uint32_t FrameRate)
{
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
{
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))
{
//g_Notify->DisplayError(L"Failed to load word 2");
//g_Notify->DisplayError("Failed to load word 2");
//ExitThread(0);
return true;
}
@ -96,7 +96,7 @@ bool DelaySlotEffectsCompare(uint32_t PC, uint32_t Reg1, uint32_t Reg2)
default:
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;
}
@ -127,7 +127,7 @@ bool DelaySlotEffectsCompare(uint32_t PC, uint32_t Reg1, uint32_t Reg2)
default:
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;
}
@ -136,7 +136,7 @@ bool DelaySlotEffectsCompare(uint32_t PC, uint32_t Reg1, uint32_t Reg2)
{
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;
}
@ -165,7 +165,7 @@ bool DelaySlotEffectsCompare(uint32_t PC, uint32_t Reg1, uint32_t Reg2)
default:
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;
}
@ -213,7 +213,7 @@ bool DelaySlotEffectsCompare(uint32_t PC, uint32_t Reg1, uint32_t Reg2)
default:
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;
}

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

@ -1021,7 +1021,7 @@ void R4300iOp::LDL()
g_Notify->BreakPoint(__FILE__, __LINE__);
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;
}
@ -1048,7 +1048,7 @@ void R4300iOp::LDR()
g_Notify->BreakPoint(__FILE__, __LINE__);
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;
}
@ -1064,7 +1064,7 @@ void R4300iOp::LB()
{
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);
}
@ -1085,7 +1085,7 @@ void R4300iOp::LH()
{
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);
}
@ -1107,7 +1107,7 @@ void R4300iOp::LWL()
g_Notify->BreakPoint(__FILE__, __LINE__);
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;
}
@ -1133,7 +1133,7 @@ void R4300iOp::LW()
{
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);
}
@ -1150,7 +1150,7 @@ void R4300iOp::LBU()
{
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);
}
@ -1171,7 +1171,7 @@ void R4300iOp::LHU()
{
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);
}
@ -1193,7 +1193,7 @@ void R4300iOp::LWR()
g_Notify->BreakPoint(__FILE__, __LINE__);
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;
}
@ -1214,7 +1214,7 @@ void R4300iOp::LWU()
{
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);
}
@ -1235,7 +1235,7 @@ void R4300iOp::SB()
}
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())
{
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())
{
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str());
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
}
return;
}
@ -1291,7 +1291,7 @@ void R4300iOp::SWL()
}
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())
{
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())
{
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str());
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
}
return;
}
@ -1362,7 +1362,7 @@ void R4300iOp::SDL()
}
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())
{
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str());
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
}
return;
}
@ -1410,7 +1410,7 @@ void R4300iOp::SDR()
}
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())
{
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str());
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
}
return;
}
@ -1446,7 +1446,7 @@ void R4300iOp::SWR()
}
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())
{
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);
}
@ -1495,7 +1495,7 @@ void R4300iOp::LWC1()
{
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);
}
@ -1516,7 +1516,7 @@ void R4300iOp::SC()
g_Notify->BreakPoint(__FILE__, __LINE__);
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())
{
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).ToUTF16().c_str());
g_Notify->DisplayError(stdstr_f(__FUNCTION__ " TLB: %X", Address).c_str());
}
return;
}
@ -1567,7 +1567,7 @@ void R4300iOp::LDC1()
}
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())
{
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())
{
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())
{
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())
{
g_Notify->DisplayError(L"DIV by 0 ???");
g_Notify->DisplayError("DIV by 0 ???");
}
_RegLO->DW = 0;
_RegHI->DW = 0;
@ -1777,7 +1777,7 @@ void R4300iOp::SPECIAL_DIVU()
{
if (bShowDivByZero())
{
g_Notify->DisplayError(L"DIVU by 0 ???");
g_Notify->DisplayError("DIVU by 0 ???");
}
_RegLO->DW = 0;
_RegHI->DW = 0;
@ -1823,7 +1823,7 @@ void R4300iOp::SPECIAL_DDIV()
{
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())
{
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())
{
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())
{
g_Notify->DisplayError(L"Left kernel mode ??");
g_Notify->DisplayError("Left kernel mode ??");
}
g_Reg->CheckInterrupts();
break;
@ -2176,7 +2176,7 @@ void R4300iOp::COP0_MT()
_CP0[m_Opcode.rd] &= 0xFFFFCFF;
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;
default:
@ -2259,7 +2259,7 @@ void R4300iOp::COP1_CF()
{
if (bHaveDebugger())
{
g_Notify->DisplayError(L"CFC1 what register are you writing to ?");
g_Notify->DisplayError("CFC1 what register are you writing to ?");
}
return;
}
@ -2294,7 +2294,7 @@ void R4300iOp::COP1_CT()
}
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())
{
g_Notify->DisplayError(__FUNCTIONW__ L": Nan ?");
g_Notify->DisplayError(__FUNCTION__ ": Nan ?");
}
less = false;
equal = false;
@ -2563,7 +2563,7 @@ void R4300iOp::COP1_S_CMP()
{
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())
{
g_Notify->DisplayError(__FUNCTIONW__ L": Nan ?");
g_Notify->DisplayError(__FUNCTION__ ": Nan ?");
}
less = false;
equal = false;
@ -2774,7 +2774,7 @@ void R4300iOp::COP1_D_CMP()
{
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()
{
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_Notify->BreakPoint(__FILE__, __LINE__);

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

@ -895,7 +895,7 @@ void R4300iOp32::LB()
{
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);
}
@ -916,7 +916,7 @@ void R4300iOp32::LH()
{
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);
}
@ -937,7 +937,7 @@ void R4300iOp32::LWL()
{
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);
return;
@ -964,7 +964,7 @@ void R4300iOp32::LW()
{
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);
}
@ -981,7 +981,7 @@ void R4300iOp32::LBU()
{
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);
}
@ -1002,7 +1002,7 @@ void R4300iOp32::LHU()
{
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);
}
@ -1024,7 +1024,7 @@ void R4300iOp32::LWR()
g_Notify->BreakPoint(__FILE__, __LINE__);
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;
}
@ -1045,7 +1045,7 @@ void R4300iOp32::LWU()
{
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);
}
@ -1067,7 +1067,7 @@ void R4300iOp32::LL()
{
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);
}
@ -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))
{
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))
{
g_Notify->DisplayError(L"Left kernel mode ??");
g_Notify->DisplayError("Left kernel mode ??");
}
g_Reg->CheckInterrupts();
break;
@ -1405,7 +1405,7 @@ void R4300iOp32::COP0_MT()
_CP0[m_Opcode.rd] &= 0xFFFFCFF;
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;
default:
@ -1425,7 +1425,7 @@ void R4300iOp32::COP1_CF()
TEST_COP1_USABLE_EXCEPTION
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;
}
_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_6106: offset = +0x0318; break;
default:
g_Notify->DisplayError(
stdstr_f("Unhandled CicChip(%d) in first DMA", g_Rom->CicChipID()).ToUTF16().c_str()
);
g_Notify->DisplayError(stdstr_f("Unhandled CicChip(%d) in first DMA", g_Rom->CicChipID()).c_str());
return;
}
g_MMU->SW_PAddr(base + offset, rt);
@ -61,7 +59,7 @@ void CDMA::PI_DMA_READ()
{
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->MI_INTR_REG |= MI_INTR_PI;
@ -149,7 +147,7 @@ void CDMA::PI_DMA_READ()
}
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->MI_INTR_REG |= MI_INTR_PI;
g_Reg->CheckInterrupts();
@ -157,7 +155,7 @@ void CDMA::PI_DMA_READ()
}
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->MI_INTR_REG |= MI_INTR_PI;
@ -177,7 +175,7 @@ void CDMA::PI_DMA_WRITE()
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_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->MI_INTR_REG |= MI_INTR_PI;
g_Reg->CheckInterrupts();
@ -286,7 +284,7 @@ void CDMA::PI_DMA_WRITE()
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->MI_INTR_REG |= MI_INTR_PI;
@ -301,7 +299,7 @@ void CDMA::SP_DMA_READ()
{
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_STATUS_REG &= ~SP_STATUS_DMA_BUSY;
@ -312,7 +310,7 @@ void CDMA::SP_DMA_READ()
{
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;
}
@ -343,7 +341,7 @@ void CDMA::SP_DMA_WRITE()
{
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;
}
@ -352,7 +350,7 @@ void CDMA::SP_DMA_WRITE()
{
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;
}

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
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())
{
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]);
break;
case 5: //Write to Eeprom
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())
{
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]);
break;
@ -129,13 +129,13 @@ void CEeprom::EepromCommand(uint8_t * Command)
//Write RTC, unimplemented
if (g_Settings->LoadDword(Debugger_ShowPifErrors))
{
g_Notify->DisplayError(L"Write RTC, unimplemented");
g_Notify->DisplayError("Write RTC, unimplemented");
}
break;
default:
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())
{
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;
}
@ -61,7 +61,7 @@ void CFlashram::DmaFromFlashram(uint8_t * dest, int StartOffset, int len)
{
if (bHaveDebugger())
{
g_Notify->DisplayError(__FUNCTIONW__ L": Unaligned flash ram read ???");
g_Notify->DisplayError(__FUNCTION__ ": Unaligned flash ram read ???");
}
return;
}
@ -89,7 +89,7 @@ void CFlashram::DmaFromFlashram(uint8_t * dest, int StartOffset, int len)
{
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);
@ -98,7 +98,7 @@ void CFlashram::DmaFromFlashram(uint8_t * dest, int StartOffset, int len)
default:
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:
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:
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;
}
@ -209,7 +209,7 @@ void CFlashram::WriteToFlashCommand(uint32_t FlashRAM_Command)
}
break;
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;
break;
@ -238,7 +238,7 @@ void CFlashram::WriteToFlashCommand(uint32_t FlashRAM_Command)
default:
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);
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;
}
@ -638,7 +638,7 @@ void CMipsMemoryVM::Compile_LB(x86Reg Reg, uint32_t VAddr, bool SignExtend)
MoveConstToX86reg(0, Reg);
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);
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;
}
@ -709,7 +709,7 @@ void CMipsMemoryVM::Compile_LH(x86Reg Reg, uint32_t VAddr, bool SignExtend)
MoveConstToX86reg(0, Reg);
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);
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;
@ -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;
default:
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;
case 0x04400000:
@ -821,7 +821,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
MoveConstToX86reg(0, Reg);
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;
@ -876,7 +876,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
MoveConstToX86reg(0, Reg);
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;
@ -896,7 +896,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
MoveConstToX86reg(0, Reg);
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;
@ -909,7 +909,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
MoveConstToX86reg(0, Reg);
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;
@ -921,7 +921,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
MoveConstToX86reg(0, Reg);
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;
@ -942,7 +942,7 @@ void CMipsMemoryVM::Compile_LW(x86Reg Reg, uint32_t VAddr)
if (g_Settings->LoadBool(Debugger_ShowUnhandledMemory))
{
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))
{
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;
}
@ -990,7 +990,7 @@ void CMipsMemoryVM::Compile_SB_Const(uint8_t Value, uint32_t VAddr)
default:
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);
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;
}
@ -1041,7 +1041,7 @@ void CMipsMemoryVM::Compile_SB_Register(x86Reg Reg, uint32_t VAddr)
default:
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);
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;
}
@ -1089,7 +1089,7 @@ void CMipsMemoryVM::Compile_SH_Const(uint16_t Value, uint32_t VAddr)
default:
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);
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;
}
@ -1139,7 +1139,7 @@ void CMipsMemoryVM::Compile_SH_Register(x86Reg Reg, uint32_t VAddr)
default:
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);
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;
}
@ -1208,7 +1208,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default:
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;
@ -1249,7 +1249,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default:
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;
@ -1267,7 +1267,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default:
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;
@ -1385,7 +1385,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default:
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;
@ -1443,7 +1443,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default:
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;
@ -1486,7 +1486,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
MoveConstToVariable(Value, PAddr + m_RDRAM, VarName);
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;
@ -1526,7 +1526,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default:
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;
@ -1540,7 +1540,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default:
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;
@ -1579,7 +1579,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default:
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;
@ -1600,7 +1600,7 @@ void CMipsMemoryVM::Compile_SW_Const(uint32_t Value, uint32_t VAddr)
default:
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());
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);
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;
}
@ -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);
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);
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;
@ -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);
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;
@ -1848,7 +1848,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
MoveX86regToVariable(Reg, PAddr + m_RDRAM, VarName);
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;
@ -1874,7 +1874,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
case 0x04600010:
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");
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);
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;
@ -1913,7 +1913,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
default:
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;
@ -1946,7 +1946,7 @@ void CMipsMemoryVM::Compile_SW_Register(x86Reg Reg, uint32_t VAddr)
default:
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;
@ -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);
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",
(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;
@ -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",
(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;
@ -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",
(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;
@ -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",
(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;
@ -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",
(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;
@ -2265,7 +2265,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory))
{
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;
@ -2283,7 +2283,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory))
{
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);
@ -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",
(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;
@ -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",
(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;
@ -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",
(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;
@ -2338,7 +2338,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory))
{
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;
@ -2357,7 +2357,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory))
{
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);
@ -2376,7 +2376,7 @@ int32_t CMipsMemoryVM::MemoryFilter(uint32_t dwExptCode, void * lpExceptionPoint
if (g_Settings->LoadDword(Debugger_ShowUnhandledMemory))
{
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);
@ -2534,7 +2534,7 @@ bool CMipsMemoryVM::SB_NonMemory(uint32_t PAddr, uint8_t Value)
VirtualProtect(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, PAGE_READWRITE, &OldProtect);
*(uint8_t *)(m_RDRAM + PAddr) = Value;
VirtualProtect(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, OldProtect, &OldProtect);
g_Notify->DisplayError(L"FrameBufferWrite");
g_Notify->DisplayError("FrameBufferWrite");
if (FrameBufferWrite) { FrameBufferWrite(PAddr, 1); }
break;
}
@ -2575,7 +2575,7 @@ bool CMipsMemoryVM::SH_NonMemory(uint32_t PAddr, uint16_t Value)
if (FrameBufferWrite) { FrameBufferWrite(PAddr & ~0xFFF, 2); }
//*(uint16_t *)(m_RDRAM+PAddr) = 0xFFFF;
//VirtualProtect(m_RDRAM+(PAddr & ~0xFFF),0xFFC,PAGE_NOACCESS, &OldProtect);
g_Notify->DisplayError(L"PAddr = %x", PAddr);
g_Notify->DisplayError("PAddr = %x", PAddr);
break;
}
#endif
@ -2636,7 +2636,7 @@ bool CMipsMemoryVM::SW_NonMemory(uint32_t PAddr, uint32_t Value)
VirtualProtect(m_RDRAM + (PAddr & ~0xFFF), 0xFFC, PAGE_READWRITE, &OldProtect);
*(uint32_t *)(m_RDRAM + PAddr) = Value;
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); }
break;
}
@ -4725,7 +4725,7 @@ void CMipsMemoryVM::ChangeSpStatus()
}
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)
{
@ -5246,7 +5246,7 @@ void CMipsMemoryVM::Write32SPRegisters(void)
}
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)
{
@ -5422,19 +5422,19 @@ void CMipsMemoryVM::Write32DPCommandRegisters(void)
{
//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)
//{
// 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)
//{
// 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)
//{
// g_Notify->DisplayError(L"RSP: DPC_STATUS_REG: DPC_CLR_CLOCK_CTR");
// g_Notify->DisplayError("RSP: DPC_STATUS_REG: DPC_CLR_CLOCK_CTR");
//}
}
#endif
@ -5662,7 +5662,7 @@ void CMipsMemoryVM::Write32PeripheralInterface(void)
case 0x04600010:
//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)
{

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

@ -145,7 +145,7 @@ void CPifRam::PifRamRead()
{
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;
}
@ -210,7 +210,7 @@ void CPifRam::PifRamWrite()
default:
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;
@ -255,7 +255,7 @@ void CPifRam::PifRamWrite()
{
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;
@ -265,7 +265,7 @@ void CPifRam::PifRamWrite()
{
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;
}
@ -289,7 +289,7 @@ void CPifRam::SI_DMA_READ()
{
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;
}
@ -375,7 +375,7 @@ void CPifRam::SI_DMA_WRITE()
{
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;
}
@ -471,11 +471,11 @@ void CPifRam::ProcessControllerCommand(int Control, uint8_t * Command)
{
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)
{
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)
@ -502,11 +502,11 @@ void CPifRam::ProcessControllerCommand(int Control, uint8_t * Command)
{
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)
{
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)
@ -523,11 +523,11 @@ void CPifRam::ProcessControllerCommand(int Control, uint8_t * Command)
{
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)
{
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)
@ -565,11 +565,11 @@ void CPifRam::ProcessControllerCommand(int Control, uint8_t * Command)
{
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)
{
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)
@ -599,7 +599,7 @@ void CPifRam::ProcessControllerCommand(int Control, uint8_t * Command)
default:
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 (Command[0] != 1) { g_Notify->DisplayError(L"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[0] != 1) { g_Notify->DisplayError("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);

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())
{
g_Notify->DisplayError(L"AddressError");
g_Notify->DisplayError("AddressError");
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)
{
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)
{
g_Notify->DisplayError(L"EXL set in Break Exception");
g_Notify->DisplayError("EXL set in Break Exception");
}
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)
{
g_Notify->DisplayError(L"EXL set in Break Exception");
g_Notify->DisplayError("EXL set in Break Exception");
}
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())
{
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;
}
@ -524,11 +524,11 @@ void CRegisters::DoSysCallException(bool DelaySlot)
{
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)
{
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 (...)
{
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
{
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);
bRes = false;
}
@ -306,7 +306,7 @@ void CN64System::StartEmulation2(bool NewThread)
{
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));
m_SyncPlugins = new CPlugins(g_Settings->LoadStringVal(Directory_PluginSync));
m_SyncPlugins->SetRenderWindows(g_Plugins->SyncWindow(), NULL);
@ -356,8 +356,8 @@ void CN64System::StartEmulation(bool NewThread)
}
__except (g_MMU->MemoryFilter(GetExceptionCode(), GetExceptionInformation()))
{
wchar_t message[400];
swprintf(message, sizeof(message), L"Exception caught\nFile: %s\nLine: %d", __FILEW__, __LINE__);
char message[400];
sprintf(message, "Exception caught\nFile: %s\nLine: %d", __FILE__, __LINE__);
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__);
}
@ -1387,11 +1387,11 @@ bool CN64System::SaveState()
}
m_Reg.MI_INTR_REG = MiInterReg;
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);
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();
WriteTrace(TraceN64System, TraceDebug, "Done");
return true;
@ -1504,12 +1504,13 @@ bool CN64System::LoadState(const char * FileName)
if (memcmp(LoadHeader, g_Rom->GetRomAddress(), 0x40) != 0)
{
//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)
{
return false;
}
}
Reset(false, true);
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);
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;
}
@ -1565,7 +1566,9 @@ bool CN64System::LoadState(const char * FileName)
DWORD dwRead;
ReadFile(hSaveFile, &Value, sizeof(Value), &dwRead, NULL);
if (Value != 0x23D8A6C8)
{
return false;
}
ReadFile(hSaveFile, &SaveRDRAMSize, sizeof(SaveRDRAMSize), &dwRead, NULL);
//Check header
@ -1574,7 +1577,7 @@ bool CN64System::LoadState(const char * FileName)
if (memcmp(LoadHeader, g_Rom->GetRomAddress(), 0x40) != 0)
{
//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)
{
@ -1686,15 +1689,15 @@ bool CN64System::LoadState(const char * FileName)
}
}
WriteTrace(TraceN64System, TraceDebug, "13");
std::wstring 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());
std::string LoadMsg = g_Lang->GetString(MSG_LOADED_STATE);
g_Notify->DisplayMessage(5, stdstr_f("%s %s", LoadMsg.c_str(), stdstr(CPath(FileNameStr).GetNameExtension()).c_str()).c_str());
WriteTrace(TraceN64System, TraceDebug, "Done");
return true;
}
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()
@ -1757,7 +1760,7 @@ void CN64System::RunRSP()
__except (g_MMU->MemoryFilter(GetExceptionCode(), GetExceptionInformation()))
{
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))

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

@ -86,7 +86,7 @@ bool CN64Rom::AllocateAndLoadN64Image(const char * FileLoc, bool LoadBootCodeOnl
TotalRead += dwRead;
//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;
@ -182,7 +182,7 @@ bool CN64Rom::AllocateAndLoadZipImage(const char * FileLoc, bool LoadBootCodeOnl
TotalRead += dwRead;
//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;
@ -191,7 +191,7 @@ bool CN64Rom::AllocateAndLoadZipImage(const char * FileLoc, bool LoadBootCodeOnl
VirtualFree(Image, 0, MEM_RELEASE);
unzCloseCurrentFile(file);
SetError(MSG_FAIL_ZIP);
g_Notify->DisplayMessage(1, L"");
g_Notify->DisplayMessage(1, "");
break;
}
@ -207,7 +207,7 @@ bool CN64Rom::AllocateAndLoadZipImage(const char * FileLoc, bool LoadBootCodeOnl
//Protect the memory so that it can not be written to.
DWORD OldProtect;
VirtualProtect(m_ROMImage, m_RomFileSize, PAGE_READONLY, &OldProtect);
g_Notify->DisplayMessage(1, L"");
g_Notify->DisplayMessage(1, "");
}
unzCloseCurrentFile(file);
@ -252,7 +252,7 @@ void CN64Rom::ByteSwapRom()
break;
case 0x80371240: break;
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:
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;
}
@ -390,9 +390,9 @@ bool CN64Rom::IsValidRomImage(uint8_t Test[4])
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)

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

@ -32,7 +32,7 @@ class CN64Rom :
bool AllocateAndLoadZipImage(const char * FileLoc, bool LoadBootCodeOnly);
void ByteSwapRom();
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 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)Dlist / (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();
}

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

@ -243,7 +243,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
g_Notify->BreakPoint(__FILE__, __LINE__);
#ifdef legacycode
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));
#endif
m_NextInstruction = END_BLOCK;
@ -334,7 +334,8 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
if (m_Reg.Is32Bit(m_Command.rs))
{
Value = m_Reg.GetMipsRegLo_S(m_Command.rs);
} else {
}
else {
Value = m_Reg.GetMipsReg_S(m_Command.rs);
}
if (Value >= 0)
@ -370,7 +371,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
g_Notify->BreakPoint(__FILE__, __LINE__);
#ifdef legacycode
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));
m_NextInstruction = END_BLOCK;
m_PC -= 4;
@ -546,14 +547,14 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
case R4300i_COP0_CO_TLBP: break;
case R4300i_COP0_CO_ERET: m_NextInstruction = END_BLOCK; break;
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_PC -= 4;
}
}
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_PC -= 4;
}
@ -631,7 +632,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
case R4300i_COP1_W: break;
case R4300i_COP1_L: break;
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_PC -= 4;
}
@ -731,7 +732,7 @@ bool LoopAnalysis::CheckLoopRegisterUsage(CCodeSection * Section)
if (m_Command.Hex == 0xF1F3F5F7) { break; }
if (m_Command.Hex == 0xC1200000) { 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));

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

@ -117,7 +117,7 @@ void CRecompiler::RecompilerMain_VirtualTable()
m_Registers.DoTLBReadMiss(false, 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;
}
continue;
@ -182,7 +182,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
NextInstruction = NORMAL;
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;
}
continue;
@ -242,7 +242,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
NextInstruction = NORMAL;
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;
}
}
@ -264,7 +264,7 @@ void CRecompiler::RecompilerMain_VirtualTable_validate()
NextInstruction = NORMAL;
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;
}
}
@ -390,7 +390,7 @@ void CRecompiler::RecompilerMain_Lookup()
DoTLBMiss(NextInstruction == DELAY_SLOT,PROGRAM_COUNTER);
NextInstruction = NORMAL;
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;
}
}
@ -537,7 +537,7 @@ void CRecompiler::RecompilerMain_Lookup_TLB()
m_Registers.DoTLBReadMiss(false, PROGRAM_COUNTER);
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;
}
continue;
@ -643,7 +643,7 @@ void CRecompiler::RecompilerMain_Lookup_validate_TLB()
m_Registers.DoTLBReadMiss(false, PROGRAM_COUNTER);
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;
}
continue;
@ -750,7 +750,7 @@ void CRecompiler::RecompilerMain_ChangeMemory()
NextInstruction = NORMAL;
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);
}
}
@ -766,7 +766,7 @@ void CRecompiler::RecompilerMain_ChangeMemory()
}
__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);
}
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;
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());
}

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

@ -94,7 +94,7 @@ void CRecompilerOps::Compile_Branch(CRecompilerOps::BranchFunction CompareFunc,
}
break;
default:
if (bHaveDebugger()) { g_Notify->DisplayError(L"Unknown branch type"); }
if (bHaveDebugger()) { g_Notify->DisplayError("Unknown branch type"); }
}
}
else
@ -360,7 +360,7 @@ void CRecompilerOps::Compile_Branch(CRecompilerOps::BranchFunction CompareFunc,
{
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())
{
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())
{
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:
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())
{
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())
{
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());
}
}
@ -3881,7 +3881,7 @@ void CRecompilerOps::SPECIAL_XOR()
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();
}
else
@ -4199,7 +4199,7 @@ void CRecompilerOps::SPECIAL_SLT()
{
if (Is64Bit(m_Opcode.rt) || Is64Bit(m_Opcode.rs))
{
g_Notify->DisplayError(L"1");
g_Notify->DisplayError("1");
CRecompilerOps::UnknownOpcode();
}
else
@ -4515,7 +4515,7 @@ void CRecompilerOps::SPECIAL_SLTU()
{
if (Is64Bit(m_Opcode.rt) || Is64Bit(m_Opcode.rs))
{
g_Notify->DisplayError(L"1");
g_Notify->DisplayError("1");
CRecompilerOps::UnknownOpcode();
}
else
@ -5470,7 +5470,7 @@ void CRecompilerOps::COP0_MT()
if (IsConst(m_Opcode.rt))
{
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
{

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 RoundUp: OrConstToX86Reg(0x0800, reg); break;
default:
g_Notify->DisplayError(L"Unknown Rounding model");
g_Notify->DisplayError("Unknown Rounding model");
}
}
MoveX86regToVariable(reg, &m_fpuControl, "m_fpuControl");
@ -209,7 +209,7 @@ void CRegInfo::ChangeFPURegFormat(int32_t Reg, FPU_STATE OldFormat, FPU_STATE Ne
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())));
int32_t i;
if (RegToLoad < 0) { g_Notify->DisplayError(L"Load_FPR_ToTop\nRegToLoad < 0 ???"); return; }
if (Reg < 0) { g_Notify->DisplayError(L"Load_FPR_ToTop\nReg < 0 ???"); return; }
if (RegToLoad < 0) { g_Notify->DisplayError("Load_FPR_ToTop\nRegToLoad < 0 ???"); return; }
if (Reg < 0) { g_Notify->DisplayError("Load_FPR_ToTop\nReg < 0 ???"); return; }
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);
break;
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);
FpuRoundingModel(StackTopPos()) = RoundDefault;
@ -575,7 +575,7 @@ CRegInfo::x86Reg CRegInfo::Map_MemoryStack(x86Reg Reg, bool bMapRegister, bool L
Reg = FreeX86Reg();
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__);
}
SetX86Mapped(Reg, CRegInfo::Stack_Mapped);
@ -624,7 +624,7 @@ void CRegInfo::Map_GPR_32bit(int32_t MipsReg, bool SignValue, int32_t MipsRegToL
Reg = FreeX86Reg();
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__);
return;
}
@ -687,7 +687,7 @@ void CRegInfo::Map_GPR_64bit(int32_t MipsReg, int32_t MipsRegToLoad)
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;
}
@ -697,13 +697,13 @@ void CRegInfo::Map_GPR_64bit(int32_t MipsReg, int32_t MipsRegToLoad)
x86Hi = FreeX86Reg();
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;
}
SetX86Protected(x86Hi, true);
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);
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);
break;
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);
FpuRoundingModel(RegPos) = RoundDefault;
@ -1140,7 +1140,7 @@ void CRegInfo::UnMap_GPR(uint32_t Reg, bool WriteBackValue)
{
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;
}

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

@ -28,7 +28,7 @@ CSpeedLimiter::CSpeedLimiter()
timeGetDevCaps(&Caps, sizeof(Caps));
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:
//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 FatalError(const wchar_t * Message) const = 0;
virtual void FatalError(const char * Message) const = 0;
virtual void FatalError(LanguageStringID StringID) const = 0;
//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 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
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;

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++)
{
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);
}
@ -144,7 +144,7 @@ LRESULT CALLBACK CLanguageSelector::LangSelectProc(HWND hDlg, UINT uMsg, WPARAM
{
wchar_t String[255];
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));
if (strlen(FileName) == 0)
{
g_Notify->DisplayError(L"Please Choose target file");
g_Notify->DisplayError("Please Choose target file");
::SetFocus(GetDlgItem(IDC_FILENAME));
return false;
}
@ -132,7 +132,7 @@ bool CDumpMemory::DumpMemory(LPCSTR FileName, DumpFormat Format, DWORD StartPC,
CLog LogFile;
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;
}
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);
SetWindowLongPtrW(hDlg, GWLP_WNDPROC, (LONG_PTR)DefWindowProcW);
SetWindowTextW(hDlg, GS(INFO_TITLE));
SetWindowTextW(hDlg, wGS(INFO_TITLE).c_str());
SetWindowLongPtrW(hDlg, GWLP_WNDPROC, originalWndProc);
SetDlgItemTextW(hDlg, IDC_ROM_NAME, GS(INFO_ROM_NAME_TEXT));
SetDlgItemTextW(hDlg, IDC_FILE_NAME, GS(INFO_FILE_NAME_TEXT));
SetDlgItemTextW(hDlg, IDC_LOCATION, GS(INFO_LOCATION_TEXT));
SetDlgItemTextW(hDlg, IDC_ROM_MD5, GS(INFO_MD5_TEXT));
SetDlgItemTextW(hDlg, IDC_ROM_SIZE, GS(INFO_SIZE_TEXT));
SetDlgItemTextW(hDlg, IDC_CART_ID, GS(INFO_CART_ID_TEXT));
SetDlgItemTextW(hDlg, IDC_MANUFACTURER, GS(INFO_MANUFACTURER_TEXT));
SetDlgItemTextW(hDlg, IDC_COUNTRY, GS(INFO_COUNTRY_TEXT));
SetDlgItemTextW(hDlg, IDC_CRC1, GS(INFO_CRC1_TEXT));
SetDlgItemTextW(hDlg, IDC_CRC2, GS(INFO_CRC2_TEXT));
SetDlgItemTextW(hDlg, IDC_CIC_CHIP, GS(INFO_CIC_CHIP_TEXT));
SetDlgItemTextW(hDlg, IDC_CLOSE_BUTTON, GS(BOTTOM_CLOSE));
SetDlgItemTextW(hDlg, IDC_ROM_NAME, wGS(INFO_ROM_NAME_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_FILE_NAME, wGS(INFO_FILE_NAME_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_LOCATION, wGS(INFO_LOCATION_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_ROM_MD5, wGS(INFO_MD5_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_ROM_SIZE, wGS(INFO_SIZE_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_CART_ID, wGS(INFO_CART_ID_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_MANUFACTURER, wGS(INFO_MANUFACTURER_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_COUNTRY, wGS(INFO_COUNTRY_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_CRC1, wGS(INFO_CRC1_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_CRC2, wGS(INFO_CRC2_TEXT).c_str());
SetDlgItemTextW(hDlg, IDC_CIC_CHIP, wGS(INFO_CIC_CHIP_TEXT).c_str());
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());

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

@ -159,7 +159,7 @@ bool CCheatsUI::CheatChanged(HWND hDlg)
{
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)
{
return true;
@ -188,15 +188,15 @@ int CALLBACK CCheatsUI::CheatAddProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
CCheatsUI * _this = (CCheatsUI *)lParam;
SetProp(hDlg, "Class", _this);
SetWindowTextW(hDlg, GS(CHEAT_ADDCHEAT_FRAME));
SetWindowTextW(GetDlgItem(hDlg, IDC_NAME), GS(CHEAT_ADDCHEAT_NAME));
SetWindowTextW(GetDlgItem(hDlg, IDC_CODE), GS(CHEAT_ADDCHEAT_CODE));
SetWindowTextW(GetDlgItem(hDlg, IDC_LABEL_OPTIONS), GS(CHEAT_ADDCHEAT_OPT));
SetWindowTextW(GetDlgItem(hDlg, IDC_CODE_DES), GS(CHEAT_ADDCHEAT_CODEDES));
SetWindowTextW(GetDlgItem(hDlg, IDC_LABEL_OPTIONS_FORMAT), GS(CHEAT_ADDCHEAT_OPTDES));
SetWindowTextW(GetDlgItem(hDlg, IDC_CHEATNOTES), GS(CHEAT_ADDCHEAT_NOTES));
SetWindowTextW(GetDlgItem(hDlg, IDC_NEWCHEAT), GS(CHEAT_ADDCHEAT_NEW));
SetWindowTextW(GetDlgItem(hDlg, IDC_ADD), GS(CHEAT_ADDCHEAT_ADD));
SetWindowTextW(hDlg, wGS(CHEAT_ADDCHEAT_FRAME).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_NAME), wGS(CHEAT_ADDCHEAT_NAME).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_CODE), wGS(CHEAT_ADDCHEAT_CODE).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_LABEL_OPTIONS), wGS(CHEAT_ADDCHEAT_OPT).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_CODE_DES), wGS(CHEAT_ADDCHEAT_CODEDES).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_LABEL_OPTIONS_FORMAT), wGS(CHEAT_ADDCHEAT_OPTDES).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_CHEATNOTES), wGS(CHEAT_ADDCHEAT_NOTES).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_NEWCHEAT), wGS(CHEAT_ADDCHEAT_NEW).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_ADD), wGS(CHEAT_ADDCHEAT_ADD).c_str());
SetProp(hDlg, "validcodes", false);
_this->RecordCheatValues(hDlg);
}
@ -341,7 +341,7 @@ int CALLBACK CCheatsUI::CheatAddProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
SetDlgItemText(hDlg, IDC_NOTES, "");
EnableWindow(GetDlgItem(hDlg, IDC_ADD), 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);
}
break;
@ -428,7 +428,7 @@ int CALLBACK CCheatsUI::CheatAddProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
SetDlgItemText(hDlg, IDC_NOTES, CheatNotesStr.c_str());
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);
}
@ -452,9 +452,9 @@ int CALLBACK CCheatsUI::CheatListProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
RECT rcList;
RECT rcButton;
SetWindowTextW(GetDlgItem(hDlg, IDC_CHEATSFRAME), GS(CHEAT_LIST_FRAME));
SetWindowTextW(GetDlgItem(hDlg, IDC_NOTESFRAME), GS(CHEAT_NOTES_FRAME));
SetWindowTextW(GetDlgItem(hDlg, IDC_UNMARK), GS(CHEAT_MARK_NONE));
SetWindowTextW(GetDlgItem(hDlg, IDC_CHEATSFRAME), wGS(CHEAT_LIST_FRAME).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_NOTESFRAME), wGS(CHEAT_NOTES_FRAME).c_str());
SetWindowTextW(GetDlgItem(hDlg, IDC_UNMARK), wGS(CHEAT_MARK_NONE).c_str());
GetWindowRect(GetDlgItem(hDlg, IDC_CHEATSFRAME), &rcList);
GetWindowRect(GetDlgItem(hDlg, IDC_UNMARK), &rcButton);
@ -491,7 +491,7 @@ int CALLBACK CCheatsUI::CheatListProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
{
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; }
//Delete selected cheat
@ -546,7 +546,7 @@ int CALLBACK CCheatsUI::CheatListProc(HWND hDlg, uint32_t uMsg, uint32_t wParam,
GetCursorPos(&Mouse);
MenuSetText(hPopupMenu, 0, GS(CHEAT_DELETE), NULL);
MenuSetText(hPopupMenu, 0, wGS(CHEAT_DELETE).c_str(), NULL);
if (_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);
//Set up language support for dialog
SetWindowTextW(hDlg, GS(CHEAT_CODE_EXT_TITLE));
SetDlgItemTextW(hDlg, IDC_NOTE, GS(CHEAT_CODE_EXT_TXT));
SetDlgItemTextW(hDlg, IDOK, GS(CHEAT_OK));
SetDlgItemTextW(hDlg, IDCANCEL, GS(CHEAT_CANCEL));
SetWindowTextW(hDlg, wGS(CHEAT_CODE_EXT_TITLE).c_str());
SetDlgItemTextW(hDlg, IDC_NOTE, wGS(CHEAT_CODE_EXT_TXT).c_str());
SetDlgItemTextW(hDlg, IDOK, wGS(CHEAT_OK).c_str());
SetDlgItemTextW(hDlg, IDCANCEL, wGS(CHEAT_CANCEL).c_str());
SetDlgItemText(hDlg, IDC_CHEAT_NAME, CheatName.c_str());
//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));
//Set up language support for dialog
SetWindowTextW(hDlg, GS(CHEAT_CODE_EXT_TITLE));
SetDlgItemTextW(hDlg, IDC_DIGITAL_TEXT, GS(CHEAT_CHOOSE_VALUE));
SetDlgItemTextW(hDlg, IDC_VALUE_TEXT, GS(CHEAT_VALUE));
SetDlgItemTextW(hDlg, IDC_NOTES_TEXT, GS(CHEAT_NOTES));
SetWindowTextW(hDlg, wGS(CHEAT_CODE_EXT_TITLE).c_str());
SetDlgItemTextW(hDlg, IDC_DIGITAL_TEXT, wGS(CHEAT_CHOOSE_VALUE).c_str());
SetDlgItemTextW(hDlg, IDC_VALUE_TEXT, wGS(CHEAT_VALUE).c_str());
SetDlgItemTextW(hDlg, IDC_NOTES_TEXT, wGS(CHEAT_NOTES).c_str());
SetDlgItemText(hDlg, IDC_NOTES, RangeNote.c_str());
SetDlgItemText(hDlg, IDC_CHEAT_NAME, CheatName.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);
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);
SetWindowPos(_this->m_hSelectCheat, HWND_TOP, 5, 8, 0, 0, SWP_NOSIZE);
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];
//Title
SetWindowTextW(hDlg, GS(INI_TITLE));
SetWindowTextW(hDlg, wGS(INI_TITLE).c_str());
//Language
SetDlgItemTextW(hDlg, IDC_LAN, GS(INI_CURRENT_LANG));
set_about_field(hDlg, IDC_LAN_AUTHOR, GS(INI_AUTHOR), GS(LANGUAGE_AUTHOR));
set_about_field(hDlg, IDC_LAN_VERSION, GS(INI_VERSION), GS(LANGUAGE_VERSION));
set_about_field(hDlg, IDC_LAN_DATE, GS(INI_DATE), GS(LANGUAGE_DATE));
if (wcslen(GS(LANGUAGE_NAME)) == 0)
SetDlgItemTextW(hDlg, IDC_LAN, wGS(INI_CURRENT_LANG).c_str());
set_about_field(hDlg, IDC_LAN_AUTHOR, wGS(INI_AUTHOR).c_str(), wGS(LANGUAGE_AUTHOR).c_str());
set_about_field(hDlg, IDC_LAN_VERSION, wGS(INI_VERSION).c_str(), wGS(LANGUAGE_VERSION).c_str());
set_about_field(hDlg, IDC_LAN_DATE, wGS(INI_DATE).c_str(), wGS(LANGUAGE_DATE).c_str());
if (wcslen(wGS(LANGUAGE_NAME).c_str()) == 0)
{
EnableWindow(GetDlgItem(hDlg, IDC_LAN), 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);
}
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]));
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]));
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]));
SetDlgItemTextW(hDlg, IDC_RDB_HOME, GS(INI_HOMEPAGE));
SetDlgItemTextW(hDlg, IDC_RDB_HOME, wGS(INI_HOMEPAGE).c_str());
if (wcslen(RDBHomePage) == 0)
{
EnableWindow(GetDlgItem(hDlg, IDC_RDB_HOME), FALSE);
}
//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());
wcsncpy(String, CheatIniFile.GetString("Meta", "Author", "").ToUTF16().c_str(), sizeof(String) / sizeof(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_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]));
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]));
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]));
SetDlgItemTextW(hDlg, IDC_CHT_HOME, GS(INI_HOMEPAGE));
SetDlgItemTextW(hDlg, IDC_CHT_HOME, wGS(INI_HOMEPAGE).c_str());
if (wcslen(CHTHomePage) == 0)
{
EnableWindow(GetDlgItem(hDlg, IDC_CHT_HOME), FALSE);
}
//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());
wcsncpy(String, RdxIniFile.GetString("Meta", "Author", "").ToUTF16().c_str(), sizeof(String) / sizeof(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_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]));
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]));
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]));
SetDlgItemTextW(hDlg, IDC_RDX_HOME, GS(INI_HOMEPAGE));
SetDlgItemTextW(hDlg, IDC_RDX_HOME, wGS(INI_HOMEPAGE).c_str());
if (wcslen(RDXHomePage) == 0)
{
EnableWindow(GetDlgItem(hDlg, IDC_RDX_HOME), FALSE);
}
SetDlgItemTextW(hDlg, IDOK, GS(CHEAT_OK));
SetDlgItemTextW(hDlg, IDOK, wGS(CHEAT_OK).c_str());
}
break;
case WM_COMMAND:
@ -1044,7 +1044,7 @@ LRESULT CALLBACK CMainGui::MainGui_Proc(HWND hWnd, DWORD uMsg, DWORD wParam, DWO
break;
}
Rom.SaveRomSettingID(true);
g_Notify->DisplayMessage(0, L"");
g_Notify->DisplayMessage(0, "");
BYTE * RomHeader = Rom.GetRomAddress();
WriteTrace(TraceGFXPlugin, TraceDebug, "OnRomBrowserMenuItem - Starting");
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:
{
//Title
SetWindowTextW(hWnd, GS(PLUG_ABOUT));
SetWindowTextW(hWnd, wGS(PLUG_ABOUT).c_str());
// Use the size of the image
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))
{
g_Settings->SaveBool(UserInterface_ShowCPUPer, false);
g_Notify->DisplayMessage(0, L"");
g_Notify->DisplayMessage(0, "");
}
else
{
@ -400,11 +400,11 @@ bool CMainMenu::ProcessMessage(HWND hWnd, DWORD /*FromAccelerator*/, DWORD MenuI
g_Settings->SaveBool(Debugger_ShowPifErrors, !g_Settings->LoadBool(Debugger_ShowPifErrors));
break;
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));
break;
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));
break;
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_DP: g_BaseSystem->ExternalEvent(SysEvent_Interrupt_DP); break;
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));
break;
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_9:
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));
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);
GetMenuItemInfoW((HMENU)m_MenuHandle, MenuID, FALSE, &menuinfo);
g_Lang->SetLanguage(String);
g_Lang->SetLanguage(stdstr().FromUTF16(String).c_str());
m_Gui->ResetRomBrowserColomuns();
break;
}
@ -546,7 +546,7 @@ stdstr CMainMenu::GetFileLastMod(stdstr FileName)
std::wstring CMainMenu::GetSaveSlotString(int Slot)
{
std::wstring SlotName;
stdstr SlotName;
switch (Slot)
{
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;
}
if (!g_Settings->LoadBool(GameRunning_CPU_Running)) { return SlotName; }
if (!g_Settings->LoadBool(GameRunning_CPU_Running)) { return SlotName.ToUTF16(); }
stdstr LastSaveTime;
@ -613,8 +613,8 @@ std::wstring CMainMenu::GetSaveSlotString(int Slot)
LastSaveTime = GetFileLastMod(FileName);
}
}
SlotName += LastSaveTime.ToUTF16();
return SlotName;
SlotName += LastSaveTime;
return SlotName.ToUTF16();
}
void CMainMenu::FillOutMenu(HMENU hMenu)
@ -643,7 +643,7 @@ void CMainMenu::FillOutMenu(HMENU hMenu)
int Offset = 0;
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))
{
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();
uFlags = MF_STRING;
Text = g_Lang->GetString(MenuItem->Title()).c_str();
Text = wGS(MenuItem->Title());
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());
}
void CNotificationImp::DisplayError(const wchar_t * Message) const
void CNotificationImp::DisplayError(const char * Message) const
{
if (this == NULL) { return; }
stdstr TraceMessage;
TraceMessage.FromUTF16(Message);
WriteTrace(TraceUserInterface, TraceError, TraceMessage.c_str());
WriteTrace(TraceUserInterface, TraceError, Message);
WindowMode();
HWND Parent = NULL;
@ -67,7 +65,7 @@ void CNotificationImp::DisplayError(const wchar_t * Message) const
{
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
@ -75,7 +73,7 @@ void CNotificationImp::DisplayMessage(int DisplayTime, LanguageStringID StringID
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; }
@ -101,30 +99,28 @@ void CNotificationImp::DisplayMessage(int DisplayTime, const wchar_t * Message)
if (m_gfxPlugin && m_gfxPlugin->DrawStatus)
{
WriteTrace(TraceGFXPlugin, TraceDebug, "DrawStatus - Starting");
stdstr PluginMessage;
PluginMessage.FromUTF16(Message);
m_gfxPlugin->DrawStatus(PluginMessage.c_str(), FALSE);
m_gfxPlugin->DrawStatus(Message, FALSE);
WriteTrace(TraceGFXPlugin, TraceDebug, "DrawStatus - Done");
}
}
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; }
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; }
WriteTrace(TraceUserInterface, TraceError, stdstr().FromUTF16(Question).c_str());
WriteTrace(TraceUserInterface, TraceError, Question);
WindowMode();
HWND Parent = NULL;
@ -132,7 +128,7 @@ bool CNotificationImp::AskYesNoQuestion(const wchar_t * Question) const
{
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;
}
@ -146,13 +142,14 @@ void CNotificationImp::FatalError(LanguageStringID StringID) const
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();
HWND Parent = NULL;
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);
}
@ -254,7 +251,7 @@ void CNotificationImp::BreakPoint(const char * FileName, int LineNumber)
{
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)
{
DebugBreak();
@ -266,7 +263,7 @@ void CNotificationImp::BreakPoint(const char * FileName, int LineNumber)
}
else
{
DisplayError(L"Fatal Error: Stopping emulation");
DisplayError("Fatal Error: Stopping emulation");
g_BaseSystem->CloseCpu();
}
}

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

@ -28,20 +28,20 @@ public:
void WindowMode(void) const;
//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 FatalError(const wchar_t * Message) const;
virtual void FatalError(const char * Message) const;
virtual void FatalError(LanguageStringID StringID) const;
//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 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
virtual bool AskYesNoQuestion(const wchar_t * Question) const;
virtual bool AskYesNoQuestion(const char * Question) const;
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);
MD5 RomListHash(strlist & FileList);
static void __stdcall NotificationCB(LPCWSTR Status, CRomBrowser * _this);
static void NotificationCB(const char * Status, CRomBrowser * _this);
//Watch Directory Changed function
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;
}
void CRomBrowser::NotificationCB(LPCWSTR Status, CRomBrowser * /*_this*/)
void CRomBrowser::NotificationCB(const char * Status, CRomBrowser * /*_this*/)
{
g_Notify->DisplayMessage(5, Status);
}
@ -1121,7 +1121,7 @@ void CRomBrowser::ResetRomBrowserColomuns(void)
m_FieldType[Coloumn] = m_Fields[index].ID();
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));
}
}
@ -1223,7 +1223,7 @@ bool CRomBrowser::RomListDrawItem(int32_t idCtrl, uint32_t lParam)
std::wstring text = String;
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);
@ -1244,7 +1244,7 @@ bool CRomBrowser::RomListDrawItem(int32_t idCtrl, uint32_t lParam)
text = String;
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);
}
@ -1493,13 +1493,13 @@ void CRomBrowser::RomList_PopupMenu(uint32_t /*pnmh*/)
HMENU hPopupMenu = (HMENU)GetSubMenu(hMenu, 0);
//Fix up menu
MenuSetText(hPopupMenu, 0, GS(POPUP_PLAY), NULL);
MenuSetText(hPopupMenu, 2, GS(MENU_REFRESH), NULL);
MenuSetText(hPopupMenu, 3, GS(MENU_CHOOSE_ROM), NULL);
MenuSetText(hPopupMenu, 5, GS(POPUP_INFO), NULL);
MenuSetText(hPopupMenu, 6, GS(POPUP_GFX_PLUGIN), NULL);
MenuSetText(hPopupMenu, 8, GS(POPUP_SETTINGS), NULL);
MenuSetText(hPopupMenu, 9, GS(POPUP_CHEATS), NULL);
MenuSetText(hPopupMenu, 0, wGS(POPUP_PLAY).c_str(), NULL);
MenuSetText(hPopupMenu, 2, wGS(MENU_REFRESH).c_str(), NULL);
MenuSetText(hPopupMenu, 3, wGS(MENU_CHOOSE_ROM).c_str(), NULL);
MenuSetText(hPopupMenu, 5, wGS(POPUP_INFO).c_str(), NULL);
MenuSetText(hPopupMenu, 6, wGS(POPUP_GFX_PLUGIN).c_str(), NULL);
MenuSetText(hPopupMenu, 8, wGS(POPUP_SETTINGS).c_str(), NULL);
MenuSetText(hPopupMenu, 9, wGS(POPUP_CHEATS).c_str(), NULL);
if (m_SelectedRom.size() == 0)
{
@ -1526,7 +1526,7 @@ void CRomBrowser::RomList_PopupMenu(uint32_t /*pnmh*/)
if (GfxMenu)
{
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.fMask = MIIM_STATE;
lpmii.fState = 0;
@ -1642,7 +1642,7 @@ int32_t CALLBACK CRomBrowser::SelectRomDirCallBack(HWND hwnd, uint32_t uMsg, uin
if (lpData)
{
SendMessage(hwnd, BFFM_SETSELECTION, TRUE, lpData);
SetWindowTextW(hwnd, GS(DIR_SELECT_ROM));
SetWindowTextW(hwnd, wGS(DIR_SELECT_ROM).c_str());
}
break;
}
@ -1655,12 +1655,14 @@ void CRomBrowser::SelectRomDir(void)
LPITEMIDLIST pidl;
BROWSEINFOW bi;
std::wstring title = wGS(SELECT_ROM_DIR);
WriteTrace(TraceUserInterface, TraceDebug, "1");
stdstr RomDir = g_Settings->LoadStringVal(Directory_Game);
bi.hwndOwner = m_MainWindow;
bi.pidlRoot = NULL;
bi.pszDisplayName = SelectedDir;
bi.lpszTitle = GS(SELECT_ROM_DIR);
bi.lpszTitle = title.c_str();
bi.ulFlags = BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
bi.lpfn = (BFFCALLBACK)SelectRomDirCallBack;
bi.lParam = (uint32_t)RomDir.c_str();

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

@ -20,12 +20,12 @@ CAdvancedOptionsPage::CAdvancedOptionsPage (HWND hParent, const RECT & rcDispay
}
//Set the text for all gui Items
SetDlgItemTextW(m_hWnd, IDC_START_ON_ROM_OPEN, GS(ADVANCE_AUTO_START));
SetDlgItemTextW(m_hWnd, IDC_ZIP, GS(ADVANCE_COMPRESS));
SetDlgItemTextW(m_hWnd, IDC_DEBUGGER, GS(ADVANCE_DEBUGGER));
SetDlgItemTextW(m_hWnd, IDC_REMEMBER_CHEAT, GS(OPTION_REMEMBER_CHEAT));
SetDlgItemTextW(m_hWnd, IDC_CHECK_RUNNING, GS(OPTION_CHECK_RUNNING));
SetDlgItemTextW(m_hWnd, IDC_DISPLAY_FRAMERATE, GS(OPTION_CHANGE_FR));
SetDlgItemTextW(m_hWnd, IDC_START_ON_ROM_OPEN, wGS(ADVANCE_AUTO_START).c_str());
SetDlgItemTextW(m_hWnd, IDC_ZIP, wGS(ADVANCE_COMPRESS).c_str());
SetDlgItemTextW(m_hWnd, IDC_DEBUGGER, wGS(ADVANCE_DEBUGGER).c_str());
SetDlgItemTextW(m_hWnd, IDC_REMEMBER_CHEAT, wGS(OPTION_REMEMBER_CHEAT).c_str());
SetDlgItemTextW(m_hWnd, IDC_CHECK_RUNNING, wGS(OPTION_CHECK_RUNNING).c_str());
SetDlgItemTextW(m_hWnd, IDC_DISPLAY_FRAMERATE, wGS(OPTION_CHANGE_FR).c_str());
AddModCheckBox(GetDlgItem(IDC_START_ON_ROM_OPEN), Setting_AutoStart);
AddModCheckBox(GetDlgItem(IDC_ZIP), Setting_AutoZipInstantSave);
@ -38,9 +38,9 @@ CAdvancedOptionsPage::CAdvancedOptionsPage (HWND hParent, const RECT & rcDispay
ComboBox = AddModComboBox(GetDlgItem(IDC_FRAME_DISPLAY_TYPE), UserInterface_FrameDisplayType);
if (ComboBox)
{
ComboBox->AddItemW(GS(STR_FR_VIS), FR_VIs );
ComboBox->AddItemW(GS(STR_FR_DLS), FR_DLs );
ComboBox->AddItemW(GS(STR_FR_PERCENT), FR_PERCENT );
ComboBox->AddItemW(wGS(STR_FR_VIS).c_str(), FR_VIs);
ComboBox->AddItemW(wGS(STR_FR_DLS).c_str(), FR_DLs);
ComboBox->AddItemW(wGS(STR_FR_PERCENT).c_str(), FR_PERCENT);
}
UpdatePageSettings();

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

@ -46,11 +46,11 @@ m_InUpdateSettings(false)
m_TextureSelected.Attach(GetDlgItem(IDC_TEXTURE_OTHER));
//Set Text language for the dialog box
::SetWindowTextW(m_PluginGroup.m_hWnd, GS(DIR_PLUGIN));
::SetWindowTextW(m_AutoSaveGroup.m_hWnd, GS(DIR_AUTO_SAVE));
::SetWindowTextW(m_InstantSaveGroup.m_hWnd, GS(DIR_INSTANT_SAVE));
::SetWindowTextW(m_ScreenShotGroup.m_hWnd, GS(DIR_SCREEN_SHOT));
::SetWindowTextW(m_TextureGroup.m_hWnd, GS(DIR_TEXTURE));
::SetWindowTextW(m_PluginGroup.m_hWnd, wGS(DIR_PLUGIN).c_str());
::SetWindowTextW(m_AutoSaveGroup.m_hWnd, wGS(DIR_AUTO_SAVE).c_str());
::SetWindowTextW(m_InstantSaveGroup.m_hWnd, wGS(DIR_INSTANT_SAVE).c_str());
::SetWindowTextW(m_ScreenShotGroup.m_hWnd, wGS(DIR_SCREEN_SHOT).c_str());
::SetWindowTextW(m_TextureGroup.m_hWnd, wGS(DIR_TEXTURE).c_str());
UpdatePageSettings();
}
@ -78,11 +78,11 @@ void COptionsDirectoriesPage::SelectDirectory(LanguageStringID Title, CModifiedE
BROWSEINFOW bi;
stdstr InitialDir = EditBox.GetWindowText();
std::wstring wTitle = wGS(Title);
bi.hwndOwner = m_hWnd;
bi.pidlRoot = NULL;
bi.pszDisplayName = Buffer;
bi.lpszTitle = GS(Title);
bi.lpszTitle = wTitle.c_str();
bi.ulFlags = BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
bi.lpfn = (BFFCALLBACK)SelectDirCallBack;
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
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_SAVE_TYPE_TEXT, GS(ROM_SAVE_TYPE));
SetDlgItemTextW(m_hWnd, IDC_COUNTFACT_TEXT, GS(ROM_COUNTER_FACTOR));
SetDlgItemTextW(m_hWnd, IDC_VIREFESH_TEXT, GS(ROM_VIREFRESH));
SetDlgItemTextW(m_hWnd, IDC_COUNTPERBYTE_TEXT, GS(ROM_COUNTPERBYTE));
SetDlgItemTextW(m_hWnd, IDC_MEMORY_SIZE_TEXT, wGS(ROM_MEM_SIZE).c_str());
SetDlgItemTextW(m_hWnd, IDC_SAVE_TYPE_TEXT, wGS(ROM_SAVE_TYPE).c_str());
SetDlgItemTextW(m_hWnd, IDC_COUNTFACT_TEXT, wGS(ROM_COUNTER_FACTOR).c_str());
SetDlgItemTextW(m_hWnd, IDC_VIREFESH_TEXT, wGS(ROM_VIREFRESH).c_str());
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_FIXEDAUDIO, GS(ROM_FIXED_AUDIO));
SetDlgItemTextW(m_hWnd, IDC_DELAY_DP, GS(ROM_DELAY_DP));
SetDlgItemTextW(m_hWnd, IDC_SYNC_AUDIO, GS(ROM_SYNC_AUDIO));
SetDlgItemTextW(m_hWnd, IDC_USE_TLB, GS(ROM_USE_TLB));
SetDlgItemTextW(m_hWnd, IDC_DELAY_SI, GS(ROM_DELAY_SI));
SetDlgItemTextW(m_hWnd, IDC_AUDIO_SIGNAL, GS(ROM_AUDIO_SIGNAL));
SetDlgItemTextW(m_hWnd, IDC_ROM_32BIT, wGS(ROM_32BIT).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROM_FIXEDAUDIO, wGS(ROM_FIXED_AUDIO).c_str());
SetDlgItemTextW(m_hWnd, IDC_DELAY_DP, wGS(ROM_DELAY_DP).c_str());
SetDlgItemTextW(m_hWnd, IDC_SYNC_AUDIO, wGS(ROM_SYNC_AUDIO).c_str());
SetDlgItemTextW(m_hWnd, IDC_USE_TLB, wGS(ROM_USE_TLB).c_str());
SetDlgItemTextW(m_hWnd, IDC_DELAY_SI, wGS(ROM_DELAY_SI).c_str());
SetDlgItemTextW(m_hWnd, IDC_AUDIO_SIGNAL, wGS(ROM_AUDIO_SIGNAL).c_str());
AddModCheckBox(GetDlgItem(IDC_ROM_32BIT), Game_32Bit);
AddModCheckBox(GetDlgItem(IDC_SYNC_AUDIO), Game_SyncViaAudio);
@ -50,31 +50,31 @@ CGameGeneralPage::CGameGeneralPage(HWND hParent, const RECT & rcDispay)
if (ComboBox)
{
ComboBox->SetTextField(GetDlgItem(IDC_MEMORY_SIZE_TEXT));
ComboBox->AddItemW(GS(RDRAM_4MB), 0x400000);
ComboBox->AddItemW(GS(RDRAM_8MB), 0x800000);
ComboBox->AddItemW(wGS(RDRAM_4MB).c_str(), 0x400000);
ComboBox->AddItemW(wGS(RDRAM_8MB).c_str(), 0x800000);
}
ComboBox = AddModComboBox(GetDlgItem(IDC_SAVE_TYPE), Game_SaveChip);
if (ComboBox)
{
ComboBox->SetTextField(GetDlgItem(IDC_SAVE_TYPE_TEXT));
ComboBox->AddItemW(GS(SAVE_FIRST_USED), (WPARAM)SaveChip_Auto);
ComboBox->AddItemW(GS(SAVE_4K_EEPROM), SaveChip_Eeprom_4K);
ComboBox->AddItemW(GS(SAVE_16K_EEPROM), SaveChip_Eeprom_16K);
ComboBox->AddItemW(GS(SAVE_SRAM), SaveChip_Sram);
ComboBox->AddItemW(GS(SAVE_FLASHRAM), SaveChip_FlashRam);
ComboBox->AddItemW(wGS(SAVE_FIRST_USED).c_str(), (WPARAM)SaveChip_Auto);
ComboBox->AddItemW(wGS(SAVE_4K_EEPROM).c_str(), SaveChip_Eeprom_4K);
ComboBox->AddItemW(wGS(SAVE_16K_EEPROM).c_str(), SaveChip_Eeprom_16K);
ComboBox->AddItemW(wGS(SAVE_SRAM).c_str(), SaveChip_Sram);
ComboBox->AddItemW(wGS(SAVE_FLASHRAM).c_str(), SaveChip_FlashRam);
}
ComboBox = AddModComboBox(GetDlgItem(IDC_COUNTFACT), Game_CounterFactor);
if (ComboBox)
{
ComboBox->SetTextField(GetDlgItem(IDC_COUNTFACT_TEXT));
ComboBox->AddItemW(GS(NUMBER_1), 1);
ComboBox->AddItemW(GS(NUMBER_2), 2);
ComboBox->AddItemW(GS(NUMBER_3), 3);
ComboBox->AddItemW(GS(NUMBER_4), 4);
ComboBox->AddItemW(GS(NUMBER_5), 5);
ComboBox->AddItemW(GS(NUMBER_6), 6);
ComboBox->AddItemW(wGS(NUMBER_1).c_str(), 1);
ComboBox->AddItemW(wGS(NUMBER_2).c_str(), 2);
ComboBox->AddItemW(wGS(NUMBER_3).c_str(), 3);
ComboBox->AddItemW(wGS(NUMBER_4).c_str(), 4);
ComboBox->AddItemW(wGS(NUMBER_5).c_str(), 5);
ComboBox->AddItemW(wGS(NUMBER_6).c_str(), 6);
}
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
SetDlgItemTextW(m_hWnd, RSP_ABOUT, GS(PLUG_ABOUT));
SetDlgItemTextW(m_hWnd, GFX_ABOUT, GS(PLUG_ABOUT));
SetDlgItemTextW(m_hWnd, AUDIO_ABOUT, GS(PLUG_ABOUT));
SetDlgItemTextW(m_hWnd, CONT_ABOUT, GS(PLUG_ABOUT));
SetDlgItemTextW(m_hWnd, RSP_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, GFX_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, AUDIO_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, CONT_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, IDC_RSP_NAME, GS(PLUG_RSP));
SetDlgItemTextW(m_hWnd, IDC_GFX_NAME, GS(PLUG_GFX));
SetDlgItemTextW(m_hWnd, IDC_AUDIO_NAME, GS(PLUG_AUDIO));
SetDlgItemTextW(m_hWnd, IDC_CONT_NAME, GS(PLUG_CTRL));
SetDlgItemTextW(m_hWnd, IDC_RSP_NAME, wGS(PLUG_RSP).c_str());
SetDlgItemTextW(m_hWnd, IDC_GFX_NAME, wGS(PLUG_GFX).c_str());
SetDlgItemTextW(m_hWnd, IDC_AUDIO_NAME, wGS(PLUG_AUDIO).c_str());
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_AUDIO, GS(PLUG_HLE_AUDIO));
SetDlgItemTextW(m_hWnd, IDC_HLE_GFX, wGS(PLUG_HLE_GFX).c_str());
SetDlgItemTextW(m_hWnd, IDC_HLE_AUDIO, wGS(PLUG_HLE_AUDIO).c_str());
m_GfxGroup.Attach(GetDlgItem(IDC_GFX_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->AddItemW(GS(PLUG_DEFAULT), NULL);
ComboBox->AddItemW(wGS(PLUG_DEFAULT).c_str(), NULL);
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)
{
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)
{
Button->SetCheck(BST_CHECKED);
@ -336,7 +336,7 @@ void CGamePluginPage::HleAudioChanged(UINT /*Code*/, int id, HWND /*ctl*/)
}
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)
{
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
SetDlgItemTextW(m_hWnd, IDC_CPU_TYPE_TEXT, GS(ROM_CPU_STYLE));
SetDlgItemTextW(m_hWnd, IDC_FUNCFIND_TEXT, GS(ROM_FUNC_FIND));
SetDlgItemTextW(m_hWnd, IDC_CPU_TYPE_TEXT, wGS(ROM_CPU_STYLE).c_str());
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_BLOCK_LINKING, GS(ADVANCE_ABL));
SetDlgItemTextW(m_hWnd, IDC_ROM_FASTSP, GS(ROM_FAST_SP));
SetDlgItemTextW(m_hWnd, IDC_ROM_REGCACHE, wGS(ROM_REG_CACHE).c_str());
SetDlgItemTextW(m_hWnd, IDC_BLOCK_LINKING, wGS(ADVANCE_ABL).c_str());
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_CACHE, GS(ADVANCE_SMM_CACHE));
SetDlgItemTextW(m_hWnd, IDC_SMM_DMA, GS(ADVANCE_SMM_PIDMA));
SetDlgItemTextW(m_hWnd, IDC_SMM_VALIDATE, GS(ADVANCE_SMM_VALIDATE));
SetDlgItemTextW(m_hWnd, IDC_SMM_TLB, GS(ADVANCE_SMM_TLB));
SetDlgItemTextW(m_hWnd, IDC_SMM_PROTECT, GS(ADVANCE_SMM_PROTECT));
SetDlgItemTextW(m_hWnd, IDC_SMM_FRAME, wGS(ADVANCE_SMCM).c_str());
SetDlgItemTextW(m_hWnd, IDC_SMM_CACHE, wGS(ADVANCE_SMM_CACHE).c_str());
SetDlgItemTextW(m_hWnd, IDC_SMM_DMA, wGS(ADVANCE_SMM_PIDMA).c_str());
SetDlgItemTextW(m_hWnd, IDC_SMM_VALIDATE, wGS(ADVANCE_SMM_VALIDATE).c_str());
SetDlgItemTextW(m_hWnd, IDC_SMM_TLB, wGS(ADVANCE_SMM_TLB).c_str());
SetDlgItemTextW(m_hWnd, IDC_SMM_PROTECT, wGS(ADVANCE_SMM_PROTECT).c_str());
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);
if (ComboBox)
{
ComboBox->AddItemW(GS(CORE_RECOMPILER), CPU_Recompiler);
ComboBox->AddItemW(GS(CORE_INTERPTER), CPU_Interpreter);
ComboBox->AddItemW(wGS(CORE_RECOMPILER).c_str(), CPU_Recompiler);
ComboBox->AddItemW(wGS(CORE_INTERPTER).c_str(), CPU_Interpreter);
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);
if (ComboBox)
{
ComboBox->AddItemW(GS(FLM_PLOOKUP), FuncFind_PhysicalLookup);
ComboBox->AddItemW(GS(FLM_VLOOKUP), FuncFind_VirtualLookup);
//ComboBox->AddItem(GS(FLM_CHANGEMEM), FuncFind_ChangeMemory);
ComboBox->AddItemW(wGS(FLM_PLOOKUP).c_str(), FuncFind_PhysicalLookup);
ComboBox->AddItemW(wGS(FLM_VLOOKUP).c_str(), FuncFind_VirtualLookup);
//ComboBox->AddItem(wGS(FLM_CHANGEMEM).c_str(), FuncFind_ChangeMemory);
}
UpdatePageSettings();
}

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

@ -21,16 +21,16 @@ m_OrderReset(false)
return;
}
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT2, GS(RB_ROMS));
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT4, GS(RB_DIRS));
SetDlgItemTextW(m_hWnd, IDC_USE_ROMBROWSER, GS(RB_USE));
SetDlgItemTextW(m_hWnd, IDC_RECURSION, GS(RB_DIR_RECURSION));
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT5, GS(RB_AVALIABLE_FIELDS));
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT6, GS(RB_SHOW_FIELDS));
SetDlgItemTextW(m_hWnd, IDC_ADD, GS(RB_ADD));
SetDlgItemTextW(m_hWnd, IDC_REMOVE, GS(RB_REMOVE));
SetDlgItemTextW(m_hWnd, IDC_UP, GS(RB_UP));
SetDlgItemTextW(m_hWnd, IDC_DOWN, GS(RB_DOWN));
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT2, wGS(RB_ROMS).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT4, wGS(RB_DIRS).c_str());
SetDlgItemTextW(m_hWnd, IDC_USE_ROMBROWSER, wGS(RB_USE).c_str());
SetDlgItemTextW(m_hWnd, IDC_RECURSION, wGS(RB_DIR_RECURSION).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT5, wGS(RB_AVALIABLE_FIELDS).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT6, wGS(RB_SHOW_FIELDS).c_str());
SetDlgItemTextW(m_hWnd, IDC_ADD, wGS(RB_ADD).c_str());
SetDlgItemTextW(m_hWnd, IDC_REMOVE, wGS(RB_REMOVE).c_str());
SetDlgItemTextW(m_hWnd, IDC_UP, wGS(RB_UP).c_str());
SetDlgItemTextW(m_hWnd, IDC_DOWN, wGS(RB_DOWN).c_str());
AddModCheckBox(GetDlgItem(IDC_USE_ROMBROWSER), RomBrowser_Enabled);
AddModCheckBox(GetDlgItem(IDC_RECURSION), RomBrowser_Recursive);
@ -58,12 +58,12 @@ void COptionsGameBrowserPage::UpdateFieldList(const ROMBROWSER_FIELDS_LIST & Fie
int Pos = Fields[i].Pos();
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;
}
int listCount = m_Using.GetCount();
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);
//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.SetCurSel(index);
@ -137,7 +137,7 @@ void COptionsGameBrowserPage::RemoveFieldClicked(UINT /*Code*/, int /*id*/, HWND
m_Using.SetCurSel(index);
//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.SetCurSel(index);
@ -156,7 +156,7 @@ void COptionsGameBrowserPage::MoveFieldUpClicked(UINT /*Code*/, int /*id*/, HWND
int i = m_Using.GetItemData(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.SetCurSel(index);
@ -175,7 +175,7 @@ void COptionsGameBrowserPage::MoveFieldDownClicked(UINT /*Code*/, int /*id*/, HW
int i = m_Using.GetItemData(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.SetCurSel(index);

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

@ -20,14 +20,14 @@ m_EnableReset(false)
return;
}
SetDlgItemTextW(m_hWnd, IDC_S_CPU_STATE, GS(ACCEL_CPUSTATE_TITLE));
SetDlgItemTextW(m_hWnd, IDC_MENU_ITEM_TEXT, GS(ACCEL_MENUITEM_TITLE));
SetDlgItemTextW(m_hWnd, IDC_S_CURRENT_KEYS, GS(ACCEL_CURRENTKEYS_TITLE));
SetDlgItemTextW(m_hWnd, IDC_S_SELECT_SHORT, GS(ACCEL_SELKEY_TITLE));
SetDlgItemTextW(m_hWnd, IDC_S_CURRENT_ASSIGN, GS(ACCEL_ASSIGNEDTO_TITLE));
SetDlgItemTextW(m_hWnd, IDC_ASSIGN, GS(ACCEL_ASSIGN_BTN));
SetDlgItemTextW(m_hWnd, IDC_REMOVE, GS(ACCEL_REMOVE_BTN));
SetDlgItemTextW(m_hWnd, IDC_KEY_PROMPT, GS(ACCEL_DETECTKEY));
SetDlgItemTextW(m_hWnd, IDC_S_CPU_STATE, wGS(ACCEL_CPUSTATE_TITLE).c_str());
SetDlgItemTextW(m_hWnd, IDC_MENU_ITEM_TEXT, wGS(ACCEL_MENUITEM_TITLE).c_str());
SetDlgItemTextW(m_hWnd, IDC_S_CURRENT_KEYS, wGS(ACCEL_CURRENTKEYS_TITLE).c_str());
SetDlgItemTextW(m_hWnd, IDC_S_SELECT_SHORT, wGS(ACCEL_SELKEY_TITLE).c_str());
SetDlgItemTextW(m_hWnd, IDC_S_CURRENT_ASSIGN, wGS(ACCEL_ASSIGNEDTO_TITLE).c_str());
SetDlgItemTextW(m_hWnd, IDC_ASSIGN, wGS(ACCEL_ASSIGN_BTN).c_str());
SetDlgItemTextW(m_hWnd, IDC_REMOVE, wGS(ACCEL_REMOVE_BTN).c_str());
SetDlgItemTextW(m_hWnd, IDC_KEY_PROMPT, wGS(ACCEL_DETECTKEY).c_str());
m_CreateNewShortCut.AttachToDlgItem(m_hWnd, IDC_S_SELECT_SHORT);
m_CpuState.Attach(GetDlgItem(IDC_C_CPU_STATE));
@ -37,9 +37,9 @@ m_EnableReset(false)
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(GS(ACCEL_CPUSTATE_3)), 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_1).c_str()), CMenuShortCutKey::GAME_NOT_RUNNING);
m_CpuState.SetItemData(m_CpuState.AddStringW(wGS(ACCEL_CPUSTATE_3).c_str()), CMenuShortCutKey::GAME_RUNNING_WINDOW);
m_CpuState.SetItemData(m_CpuState.AddStringW(wGS(ACCEL_CPUSTATE_4).c_str()), CMenuShortCutKey::GAME_RUNNING_FULLSCREEN);
m_CpuState.SetCurSel(0);
int VirtualKeyListSize;
@ -99,10 +99,10 @@ void COptionsShortCutsPage::OnCpuStateChanged(UINT /*Code*/, int /*id*/, HWND /*
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"&");
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());
stdstr str;
str.FromUTF16(GS(m_ShortCuts.GetMenuItemName(key, bCtrl, bAlt, bShift, AccessLevel)));
stdstr str = GS(m_ShortCuts.GetMenuItemName(key, bCtrl, bAlt, bShift, AccessLevel));
if (str.length() > 0)
{
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
SetDlgItemTextW(m_hWnd, IDC_AUTOSLEEP, GS(OPTION_AUTO_SLEEP));
SetDlgItemTextW(m_hWnd, IDC_LOAD_FULLSCREEN, GS(OPTION_AUTO_FULLSCREEN));
SetDlgItemTextW(m_hWnd, IDC_SCREEN_SAVER, GS(OPTION_DISABLE_SS));
SetDlgItemTextW(m_hWnd, IDC_BASIC_MODE, GS(OPTION_BASIC_MODE));
SetDlgItemTextW(m_hWnd, IDC_MAXROMS_TXT, GS(RB_MAX_ROMS));
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT2, GS(RB_ROMS));
SetDlgItemTextW(m_hWnd, IDC_MAXROMDIR_TXT, GS(RB_MAX_DIRS));
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT4, GS(RB_DIRS));
SetDlgItemTextW(m_hWnd, IDC_AUTOSLEEP, wGS(OPTION_AUTO_SLEEP).c_str());
SetDlgItemTextW(m_hWnd, IDC_LOAD_FULLSCREEN, wGS(OPTION_AUTO_FULLSCREEN).c_str());
SetDlgItemTextW(m_hWnd, IDC_SCREEN_SAVER, wGS(OPTION_DISABLE_SS).c_str());
SetDlgItemTextW(m_hWnd, IDC_BASIC_MODE, wGS(OPTION_BASIC_MODE).c_str());
SetDlgItemTextW(m_hWnd, IDC_MAXROMS_TXT, wGS(RB_MAX_ROMS).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT2, wGS(RB_ROMS).c_str());
SetDlgItemTextW(m_hWnd, IDC_MAXROMDIR_TXT, wGS(RB_MAX_DIRS).c_str());
SetDlgItemTextW(m_hWnd, IDC_ROMSEL_TEXT4, wGS(RB_DIRS).c_str());
AddModCheckBox(GetDlgItem(IDC_AUTOSLEEP), Setting_AutoSleep);
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
SetDlgItemTextW(m_hWnd, RSP_ABOUT, GS(PLUG_ABOUT));
SetDlgItemTextW(m_hWnd, GFX_ABOUT, GS(PLUG_ABOUT));
SetDlgItemTextW(m_hWnd, AUDIO_ABOUT, GS(PLUG_ABOUT));
SetDlgItemTextW(m_hWnd, CONT_ABOUT, GS(PLUG_ABOUT));
SetDlgItemTextW(m_hWnd, RSP_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, GFX_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, AUDIO_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, CONT_ABOUT, wGS(PLUG_ABOUT).c_str());
SetDlgItemTextW(m_hWnd, IDC_RSP_NAME, GS(PLUG_RSP));
SetDlgItemTextW(m_hWnd, IDC_GFX_NAME, GS(PLUG_GFX));
SetDlgItemTextW(m_hWnd, IDC_AUDIO_NAME, GS(PLUG_AUDIO));
SetDlgItemTextW(m_hWnd, IDC_CONT_NAME, GS(PLUG_CTRL));
SetDlgItemTextW(m_hWnd, IDC_RSP_NAME, wGS(PLUG_RSP).c_str());
SetDlgItemTextW(m_hWnd, IDC_GFX_NAME, wGS(PLUG_GFX).c_str());
SetDlgItemTextW(m_hWnd, IDC_AUDIO_NAME, wGS(PLUG_AUDIO).c_str());
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_AUDIO, GS(PLUG_HLE_AUDIO));
SetDlgItemTextW(m_hWnd, IDC_HLE_GFX, wGS(PLUG_HLE_GFX).c_str());
SetDlgItemTextW(m_hWnd, IDC_HLE_AUDIO, wGS(PLUG_HLE_AUDIO).c_str());
m_GfxGroup.Attach(GetDlgItem(IDC_GFX_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)
{
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)
{
Button->SetCheck(BST_CHECKED);
@ -320,7 +320,7 @@ void COptionPluginPage::HleAudioChanged(UINT /*Code*/, int id, HWND /*ctl*/)
}
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)
{
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)
{
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;
}
if (UpdateAdvanced(AdvancedMode, m_PagesTreeList.GetChildItem(hItem)))
@ -91,11 +91,11 @@ LRESULT CSettingConfig::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*
CConfigSettingSection * SettingsSection;
//Set the text for all gui Items
SetDlgItemTextW(m_hWnd, IDC_RESET_PAGE, GS(BOTTOM_RESET_PAGE));
SetDlgItemTextW(m_hWnd, IDC_RESET_ALL, GS(BOTTOM_RESET_ALL));
SetDlgItemTextW(m_hWnd, IDOK, GS(CHEAT_OK));
SetDlgItemTextW(m_hWnd, IDCANCEL, GS(CHEAT_CANCEL));
SetDlgItemTextW(m_hWnd, IDAPPLY, GS(BOTTOM_APPLY));
SetDlgItemTextW(m_hWnd, IDC_RESET_PAGE, wGS(BOTTOM_RESET_PAGE).c_str());
SetDlgItemTextW(m_hWnd, IDC_RESET_ALL, wGS(BOTTOM_RESET_ALL).c_str());
SetDlgItemTextW(m_hWnd, IDOK, wGS(CHEAT_OK).c_str());
SetDlgItemTextW(m_hWnd, IDCANCEL, wGS(CHEAT_CANCEL).c_str());
SetDlgItemTextW(m_hWnd, IDAPPLY, wGS(BOTTOM_APPLY).c_str());
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());
}
else {
::SetWindowTextW(m_hWnd, GS(OPTIONS_TITLE));
::SetWindowTextW(m_hWnd, wGS(OPTIONS_TITLE).c_str());
}
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));
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_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_AdvancedPage);
SettingsSection->AddPage(new COptionsDirectoriesPage(this->m_hWnd, rcSettingInfo));
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));
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));
m_Sections.push_back(SettingsSection);
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));
m_Sections.push_back(SettingsSection);
}
@ -190,7 +190,7 @@ LRESULT CSettingConfig::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*
{
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)
{