196 lines
7 KiB
C++
196 lines
7 KiB
C++
#include "stdafx.h"
|
|
#include "MessageManager.h"
|
|
|
|
std::unordered_map<string, string> MessageManager::_enResources = {
|
|
{ "Cheats", u8"Cheats" },
|
|
{ "Debug", u8"Debug" },
|
|
{ "EmulationSpeed", u8"Emulation Speed" },
|
|
{ "ClockRate", u8"Clock Rate" },
|
|
{ "Error", u8"Error" },
|
|
{ "GameInfo", u8"Game Info" },
|
|
{ "GameLoaded", u8"Game loaded" },
|
|
{ "Input", u8"Input" },
|
|
{ "Patch", u8"Patch" },
|
|
{ "Movies", u8"Movies" },
|
|
{ "NetPlay", u8"Net Play" },
|
|
{ "Overclock", u8"Overclock" },
|
|
{ "Region", u8"Region" },
|
|
{ "SaveStates", u8"Save States" },
|
|
{ "ScreenshotSaved", u8"Screenshot Saved" },
|
|
{ "SoundRecorder", u8"Sound Recorder" },
|
|
{ "Test", u8"Test" },
|
|
{ "VideoRecorder", u8"Video Recorder" },
|
|
|
|
{ "ApplyingPatch", u8"Applying patch: %1" },
|
|
{ "CheatApplied", u8"1 cheat applied." },
|
|
{ "CheatsApplied", u8"%1 cheats applied." },
|
|
{ "CheatsDisabled", u8"All cheats disabled." },
|
|
{ "CoinInsertedSlot", u8"Coin inserted (slot %1)" },
|
|
{ "ConnectedToServer", u8"Connected to server." },
|
|
{ "ConnectedAsPlayer", u8"Connected as player %1" },
|
|
{ "ConnectedAsSpectator", u8"Connected as spectator." },
|
|
{ "ConnectionLost", u8"Connection to server lost." },
|
|
{ "CouldNotConnect", u8"Could not connect to the server." },
|
|
{ "CouldNotInitializeAudioSystem", u8"Could not initialize audio system" },
|
|
{ "CouldNotFindRom", u8"Could not find matching game ROM. (%1)" },
|
|
{ "CouldNotWriteToFile", u8"Could not write to file: %1" },
|
|
{ "CouldNotLoadFile", u8"Could not load file: %1" },
|
|
{ "EmulationMaximumSpeed", u8"Maximum speed" },
|
|
{ "EmulationSpeedPercent", u8"%1%" },
|
|
{ "FdsDiskInserted", u8"Disk %1 Side %2 inserted." },
|
|
{ "Frame", u8"Frame" },
|
|
{ "GameCrash", u8"Game has crashed (%1)" },
|
|
{ "KeyboardModeDisabled", u8"Keyboard mode disabled." },
|
|
{ "KeyboardModeEnabled", u8"Keyboard mode enabled." },
|
|
{ "Lag", u8"Lag" },
|
|
{ "Mapper", u8"Mapper: %1, SubMapper: %2" },
|
|
{ "MovieEnded", u8"Movie ended." },
|
|
{ "MovieInvalid", u8"Invalid movie file." },
|
|
{ "MovieMissingRom", u8"Missing ROM required (%1) to play movie." },
|
|
{ "MovieNewerVersion", u8"Cannot load movies created by a more recent version of Mesen-S. Please download the latest version." },
|
|
{ "MovieIncompatibleVersion", u8"This movie is incompatible with this version of Mesen-S." },
|
|
{ "MoviePlaying", u8"Playing movie: %1" },
|
|
{ "MovieRecordingTo", u8"Recording to: %1" },
|
|
{ "MovieSaved", u8"Movie saved to file: %1" },
|
|
{ "NetplayVersionMismatch", u8"%1 is not running the same version of Mesen-S and has been disconnected." },
|
|
{ "NetplayNotAllowed", u8"This action is not allowed while connected to a server." },
|
|
{ "OverclockEnabled", u8"Overclocking enabled." },
|
|
{ "OverclockDisabled", u8"Overclocking disabled." },
|
|
{ "PrgSizeWarning", u8"PRG size is smaller than 32kb" },
|
|
{ "SaveStateEmpty", u8"Slot is empty." },
|
|
{ "SaveStateIncompatibleVersion", u8"Save state is incompatible with this version of Mesen-S." },
|
|
{ "SaveStateInvalidFile", u8"Invalid save state file." },
|
|
{ "SaveStateWrongSystemSnes", u8"Error: State cannot be loaded (wrong console type: SNES)" },
|
|
{ "SaveStateWrongSystemGb", u8"Error: State cannot be loaded (wrong console type: Game Boy)" },
|
|
{ "SaveStateLoaded", u8"State #%1 loaded." },
|
|
{ "SaveStateMissingRom", u8"Missing ROM required (%1) to load save state." },
|
|
{ "SaveStateNewerVersion", u8"Cannot load save states created by a more recent version of Mesen-S. Please download the latest version." },
|
|
{ "SaveStateSaved", u8"State #%1 saved." },
|
|
{ "SaveStateSlotSelected", u8"Slot #%1 selected." },
|
|
{ "ScanlineTimingWarning", u8"PPU timing has been changed." },
|
|
{ "ServerStarted", u8"Server started (Port: %1)" },
|
|
{ "ServerStopped", u8"Server stopped" },
|
|
{ "SoundRecorderStarted", u8"Recording to: %1" },
|
|
{ "SoundRecorderStopped", u8"Recording saved to: %1" },
|
|
{ "TestFileSavedTo", u8"Test file saved to: %1" },
|
|
{ "UnsupportedMapper", u8"Unsupported mapper (%1), cannot load game." },
|
|
{ "VideoRecorderStarted", u8"Recording to: %1" },
|
|
{ "VideoRecorderStopped", u8"Recording saved to: %1" },
|
|
};
|
|
|
|
std::list<string> MessageManager::_log;
|
|
SimpleLock MessageManager::_logLock;
|
|
SimpleLock MessageManager::_messageLock;
|
|
bool MessageManager::_osdEnabled = true;
|
|
IMessageManager* MessageManager::_messageManager = nullptr;
|
|
|
|
void MessageManager::RegisterMessageManager(IMessageManager* messageManager)
|
|
{
|
|
auto lock = _messageLock.AcquireSafe();
|
|
MessageManager::_messageManager = messageManager;
|
|
}
|
|
|
|
void MessageManager::UnregisterMessageManager(IMessageManager* messageManager)
|
|
{
|
|
auto lock = _messageLock.AcquireSafe();
|
|
if(MessageManager::_messageManager == messageManager) {
|
|
MessageManager::_messageManager = nullptr;
|
|
}
|
|
}
|
|
|
|
void MessageManager::SetOsdState(bool enabled)
|
|
{
|
|
_osdEnabled = enabled;
|
|
}
|
|
|
|
string MessageManager::Localize(string key)
|
|
{
|
|
std::unordered_map<string, string> *resources = &_enResources;
|
|
/*switch(EmulationSettings::GetDisplayLanguage()) {
|
|
case Language::English: resources = &_enResources; break;
|
|
case Language::French: resources = &_frResources; break;
|
|
case Language::Japanese: resources = &_jaResources; break;
|
|
case Language::Russian: resources = &_ruResources; break;
|
|
case Language::Spanish: resources = &_esResources; break;
|
|
case Language::Ukrainian: resources = &_ukResources; break;
|
|
case Language::Portuguese: resources = &_ptResources; break;
|
|
case Language::Catalan: resources = &_caResources; break;
|
|
case Language::Chinese: resources = &_zhResources; break;
|
|
}*/
|
|
if(resources) {
|
|
if(resources->find(key) != resources->end()) {
|
|
return (*resources)[key];
|
|
}/* else if(EmulationSettings::GetDisplayLanguage() != Language::English) {
|
|
//Fallback on English if resource key is missing another language
|
|
resources = &_enResources;
|
|
if(resources->find(key) != resources->end()) {
|
|
return (*resources)[key];
|
|
}
|
|
}*/
|
|
}
|
|
|
|
return key;
|
|
}
|
|
|
|
void MessageManager::DisplayMessage(string title, string message, string param1, string param2)
|
|
{
|
|
if(MessageManager::_messageManager) {
|
|
auto lock = _messageLock.AcquireSafe();
|
|
if(!MessageManager::_messageManager) {
|
|
return;
|
|
}
|
|
|
|
title = Localize(title);
|
|
message = Localize(message);
|
|
|
|
size_t startPos = message.find(u8"%1");
|
|
if(startPos != std::string::npos) {
|
|
message.replace(startPos, 2, param1);
|
|
}
|
|
|
|
startPos = message.find(u8"%2");
|
|
if(startPos != std::string::npos) {
|
|
message.replace(startPos, 2, param2);
|
|
}
|
|
|
|
if(_osdEnabled) {
|
|
MessageManager::_messageManager->DisplayMessage(title, message);
|
|
} else {
|
|
MessageManager::Log("[" + title + "] " + message);
|
|
}
|
|
}
|
|
}
|
|
|
|
void MessageManager::Log(string message)
|
|
{
|
|
#ifndef LIBRETRO
|
|
auto lock = _logLock.AcquireSafe();
|
|
if(message.empty()) {
|
|
message = "------------------------------------------------------";
|
|
}
|
|
if(_log.size() >= 1000) {
|
|
_log.pop_front();
|
|
}
|
|
_log.push_back(message);
|
|
#else
|
|
if(MessageManager::_messageManager) {
|
|
MessageManager::_messageManager->DisplayMessage("", message + "\n");
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void MessageManager::ClearLog()
|
|
{
|
|
auto lock = _logLock.AcquireSafe();
|
|
_log.clear();
|
|
}
|
|
|
|
string MessageManager::GetLog()
|
|
{
|
|
auto lock = _logLock.AcquireSafe();
|
|
stringstream ss;
|
|
for(string &msg : _log) {
|
|
ss << msg << "\n";
|
|
}
|
|
return ss.str();
|
|
}
|