std::string SystemData::getConfigPath()
{
std::string home = getHomePath();
if(home.empty())
{
LOG(LogError) << "$HOME environment variable empty or nonexistant!";
exit(1);
return "";
}
return(home + "/.emulationstation/es_systems.cfg");
}
std::string SystemData::getGamelistPath(){
std::string filePath;
filePath = mRootFolder->getPath() + "/gamelist.xml";
if(fs::exists(filePath))
return filePath;
filePath = getHomePath();
filePath += "/.emulationstation/"+ getName() + "/gamelist.xml";
if(fs::exists(filePath))
return filePath;
return "";
}
std::string SystemData::getGamelistPath(bool forWrite) const
{
fs::path filePath;
filePath = mRootFolder->getPath() / "gamelist.xml";
if(fs::exists(filePath))
return filePath.generic_string();
filePath = getHomePath() + "/.emulationstation/gamelists/" + mName + "/gamelist.xml";
if(forWrite) // make sure the directory exists if we're going to write to it, or crashes will happen
fs::create_directories(filePath.parent_path());
if(forWrite || fs::exists(filePath))
return filePath.generic_string();
return "/etc/emulationstation/gamelists/" + mName + "/gamelist.xml";
}
void Settings::saveFile() {
const std::string path = getHomePath() + "/.emulationstation/es_settings.cfg";
pugi::xml_document doc;
saveMap<std::string, bool>(doc, mBoolMap, "bool");
saveMap<std::string, int>(doc, mIntMap, "int");
saveMap<std::string, float>(doc, mFloatMap, "float");
//saveMap<std::string, std::string>(doc, mStringMap, "string");
for (auto iter = mStringMap.begin(); iter != mStringMap.end(); iter++) {
pugi::xml_node node = doc.append_child("string");
node.append_attribute("name").set_value(iter->first.c_str());
node.append_attribute("value").set_value(iter->second.c_str());
}
doc.save_file(path.c_str());
}
bool verifyHomeFolderExists()
{
//make sure the config directory exists
std::string home = getHomePath();
std::string configDir = home + "/.emulationstation";
if(!fs::exists(configDir))
{
std::cout << "Creating config directory \"" << configDir << "\"\n";
fs::create_directory(configDir);
if(!fs::exists(configDir))
{
std::cerr << "Config directory could not be created!\n";
return false;
}
}
return true;
}
/**
* @brief generateChain creates the chain of genes
* @param length the specified length of genes
* @param name the name of the file were it is going to be saved
*/
void generateChain(unsigned int length, const char* name)
{
//init file
static const FILE* fp;
char path[MAX_NAME_LENGTH+2];
strcpy(path,getHomePath()); strcat(path,"/Desktop/"); strcat(path,name); strcat(path, extension);
printf("%s\n",path);
fp=fopen(path, "w");
const char *homedir;
int i = 0;
char genes[] = {'A','G','C', 'T'};
for (i = 0; i < length; ++i) {
char randomChar = genes[getRandomNumber()];
printf("%c", randomChar);
fputc(randomChar,fp);
}
fclose(fp);
}
void Settings::loadFile() {
const std::string path = getHomePath() + "/.emulationstation/es_settings.cfg";
if (!boost::filesystem::exists(path))
return;
pugi::xml_document doc;
pugi::xml_parse_result result = doc.load_file(path.c_str());
if (!result) {
LOG(LogError) << "Could not parse Settings file!\n " << result.description();
return;
}
for (pugi::xml_node node = doc.child("bool"); node; node = node.next_sibling("bool"))
setBool(node.attribute("name").as_string(), node.attribute("value").as_bool());
for (pugi::xml_node node = doc.child("int"); node; node = node.next_sibling("int"))
setInt(node.attribute("name").as_string(), node.attribute("value").as_int());
for (pugi::xml_node node = doc.child("float"); node; node = node.next_sibling("float"))
setFloat(node.attribute("name").as_string(), node.attribute("value").as_float());
for (pugi::xml_node node = doc.child("string"); node; node = node.next_sibling("string"))
setString(node.attribute("name").as_string(), node.attribute("value").as_string());
}
std::string getSaveAsPath(const ScraperSearchParams& params, const std::string& suffix, const std::string& url)
{
const std::string subdirectory = params.system->getName();
const std::string name = params.game->getPath().stem().generic_string() + "-" + suffix;
// default dir in rom directory
std::string path = params.system->getRootFolder()->getPath().generic_string() + "/downloaded_images/";
if(!boost::filesystem::exists(path) && !boost::filesystem::create_directory(path)){
// Unable to create the directory in system rom dir, fallback on ~
path = getHomePath() + "/.emulationstation/downloaded_images/" + subdirectory + "/";
}
if(!boost::filesystem::exists(path))
boost::filesystem::create_directories(path);
size_t dot = url.find_last_of('.');
std::string ext;
if(dot != std::string::npos)
ext = url.substr(dot, std::string::npos);
path += name + ext;
return path;
}
std::string getSaveAsPath(const ScraperSearchParams& params, const std::string& suffix, const std::string& url)
{
const std::string subdirectory = params.system->getName();
const std::string name = params.game->getPath().stem().generic_string() + "-" + suffix;
std::string path = getHomePath() + "/.emulationstation/downloaded_images/";
if(!boost::filesystem::exists(path))
boost::filesystem::create_directory(path);
path += subdirectory + "/";
if(!boost::filesystem::exists(path))
boost::filesystem::create_directory(path);
size_t dot = url.find_last_of('.');
std::string ext;
if(dot != std::string::npos)
ext = url.substr(dot, std::string::npos);
path += name + ext;
return path;
}
// expands "./my/path.sfc" to "[relativeTo]/my/path.sfc"
// if allowHome is true, also expands "~/my/path.sfc" to "/home/pi/my/path.sfc"
fs::path resolvePath(const fs::path& path, const fs::path& relativeTo, bool allowHome)
{
// nothing here
if(path.begin() == path.end())
return path;
if(*path.begin() == ".")
{
fs::path ret = relativeTo;
for(auto it = ++path.begin(); it != path.end(); ++it)
ret /= *it;
return ret;
}
if(allowHome && *path.begin() == "~")
{
fs::path ret = getHomePath();
for(auto it = ++path.begin(); it != path.end(); ++it)
ret /= *it;
return ret;
}
return path;
}
"sword",
"shield",
0
};
TServer::TServer(CString pName)
#ifdef UPNP
: running(false), doRestart(false), name(pName), wordFilter(this), mNpcServer(0), mPluginManager(this), upnp(this)
#else
: running(false), doRestart(false), name(pName), wordFilter(this), mNpcServer(0), mPluginManager(this)
#endif
{
lastTimer = lastNWTimer = last1mTimer = last5mTimer = last3mTimer = time(0);
// This has the full path to the server directory.
serverpath = CString() << getHomePath() << "servers/" << name << "/";
CFileSystem::fixPathSeparators(&serverpath);
// Set up the log files.
CString logpath = serverpath.remove(0, getHomePath().length());
CString npcPath = CString() << logpath << "logs/npclog.txt";
CString rcPath = CString() << logpath << "logs/rclog.txt";
CString serverPath = CString() << logpath << "logs/serverlog.txt";
CFileSystem::fixPathSeparators(&npcPath);
CFileSystem::fixPathSeparators(&rcPath);
CFileSystem::fixPathSeparators(&serverPath);
npclog.setFilename(npcPath);
rclog.setFilename(rcPath);
serverlog.setFilename(serverPath);
// Announce ourself to other classes.
std::string InputManager::getTemporaryConfigPath()
{
std::string path = getHomePath();
path += "/.emulationstation/es_temporaryinput.cfg";
return path;
}
void deleteLock()
{
std::string filepath=getHomePath();
filepath+="/.potatimelock";
LinuxApi::unlink(filepath.c_str());
}
bool
ScriptablePluginObject::Invoke(NPIdentifier name, const NPVariant *args,
uint32_t argCount, NPVariant *result)
/*
name : method name
args : arguments
argCount : number of arguments
result : return value
*/
{
NPIdentifier test_id = NPN_GetStringIdentifier("test");
if (name == test_id) {
printf("temp = %s\n",getTemporaryPath());
printf("home = %s\n",getHomePath());
printf("firefox = %s\n",getFirefoxPath());
printf("conf = %s\n",getConfPath());
printf("classpath = %s\n",getClassPath());
printf("spawn = %s\n",getSpawnPath());
VOID_TO_NPVARIANT(*result);
return true;
}
NPError err;
if (!this->HasMethod(name))
return false;
VOID_TO_NPVARIANT(*result);
//login.jsp test
NPIdentifier doSignature_id = NPN_GetStringIdentifier("doSignature");
NPIdentifier getPublicKeyContent_id = NPN_GetStringIdentifier("getPublicKeyContent");
NPObject* sWindowNPObj;
if ((err = NPN_GetValue(mNpp, NPNVWindowNPObject, &sWindowNPObj)) != NPERR_NO_ERROR) {
printf("Error in getting NPNVWindowNPObject: %d\n",err);
return false;
}
const char *tmpdir = getTemporaryPath();
const char *classpath = getClassPath();
const char *spawnpath = getSpawnPath();
if (name == doSignature_id) {
if ((argCount == 2) && (NPVARIANT_IS_STRING(args[0])) && (NPVARIANT_IS_STRING(args[1]))) {
char *randomStr = NULL;
char *tpmPass = NULL;
NPString n_randomStr = NPVARIANT_TO_STRING(args[0]);
NPString n_tpmPass = NPVARIANT_TO_STRING(args[1]);
m_strFromNP(&randomStr,n_randomStr);
m_strFromNP(&tpmPass,n_tpmPass);
printf("input = %s, %s",randomStr, tpmPass);
char* ret = NULL;
char *fname = tempnam(tmpdir,"jni");
if (fname == NULL)
fname = "tmp";
char* margs[12];
margs[0] = (char*) spawn_file;
margs[1] = "--file";
margs[2] = fname;
margs[3] = "--method";
margs[4] = "doSignature";
margs[5] = "--classpath";
margs[6] = (char*) classpath;
margs[7] = "--args";
margs[8] = "2";
margs[9] = randomStr;
margs[10] = tpmPass;
margs[11] = NULL;
// in windows use registry to find Firefox directory
// in other OS, use path _spawnvp
int rval = _spawnv(_P_WAIT,spawnpath,margs);
if (rval) {
fprintf(stderr,"error = %d\n",rval);
}
else {
ret = getFileContent(fname);
if (ret) {
STRINGZ_TO_NPVARIANT(ret,*result);
}
else {
fprintf(stderr,"cannot read output file");
}
unlink(fname);
}
free(fname);
}
else {
NPString str;
str.UTF8Characters = "alert('usage: doSignature(String, String)');";
str.UTF8Length = strlen(str.UTF8Characters);
NPN_Evaluate(this->mNpp, sWindowNPObj, &str, NULL);
}
}
else if (name == getPublicKeyContent_id) {
if (argCount == 0) {
char *ret = NULL;
char *fname = tempnam(tmpdir,"jni");
if (fname == NULL)
fname = "tmp";
char* margs[8];
margs[0] = (char*) spawn_file;
margs[1] = "--file";
margs[2] = fname;
margs[3] = "--method";
margs[4] = "getPublicKeyContent";
margs[5] = "--classpath";
margs[6] = (char*) classpath;
margs[7] = NULL;
int rval = _spawnv(_P_WAIT,spawnpath,margs);
if (rval) {
fprintf(stderr,"error = %d\n",rval);
}
else {
ret = getFileContent(fname);
if (ret) {
STRINGZ_TO_NPVARIANT(ret,*result);
}
else {
fprintf(stderr,"cannot read output file");
}
unlink(fname);
}
free(fname);
}
else {
NPString str;
str.UTF8Characters = "alert('usage: getPublicKeyContent()');";
str.UTF8Length = strlen(str.UTF8Characters);
NPN_Evaluate(this->mNpp, sWindowNPObj, &str, NULL);
}
}
NPN_ReleaseObject(sWindowNPObj);
return true;
}
int main(int argc, char* argv[])
{
unsigned int width = 0;
unsigned int height = 0;
std::locale::global(boost::locale::generator().generate(""));
boost::filesystem::path::imbue(std::locale());
if(!parseArgs(argc, argv, &width, &height))
return 0;
// only show the console on Windows if HideConsole is false
#ifdef WIN32
// MSVC has a "SubSystem" option, with two primary options: "WINDOWS" and "CONSOLE".
// In "WINDOWS" mode, no console is automatically created for us. This is good,
// because we can choose to only create the console window if the user explicitly
// asks for it, preventing it from flashing open and then closing.
// In "CONSOLE" mode, a console is always automatically created for us before we
// enter main. In this case, we can only hide the console after the fact, which
// will leave a brief flash.
// TL;DR: You should compile ES under the "WINDOWS" subsystem.
// I have no idea how this works with non-MSVC compilers.
if(!Settings::getInstance()->getBool("HideConsole"))
{
// we want to show the console
// if we're compiled in "CONSOLE" mode, this is already done.
// if we're compiled in "WINDOWS" mode, no console is created for us automatically;
// the user asked for one, so make one and then hook stdin/stdout/sterr up to it
if(AllocConsole()) // should only pass in "WINDOWS" mode
{
freopen("CONIN$", "r", stdin);
freopen("CONOUT$", "wb", stdout);
freopen("CONOUT$", "wb", stderr);
}
}else{
// we want to hide the console
// if we're compiled with the "WINDOWS" subsystem, this is already done.
// if we're compiled with the "CONSOLE" subsystem, a console is already created;
// it'll flash open, but we hide it nearly immediately
if(GetConsoleWindow()) // should only pass in "CONSOLE" mode
ShowWindow(GetConsoleWindow(), SW_HIDE);
}
#endif
if(Settings::getInstance()->getString("ConfigDirectory") == ""){
if(checkForOldConfigDirectory()){
std::cerr << "Using old config directory, please migrate your files to \"" << getDefaultConfigDirectory() << "\" and delete the .emulationstation folder.";
Settings::getInstance()->setString("ConfigDirectory", getHomePath() + "/.emulationstation");
} else {
if(!createNewConfigDirectory())
return 1;
Settings::getInstance()->setString("ConfigDirectory", getDefaultConfigDirectory());
}
}
if(!Settings::getInstance()->loadFile()){
std::cerr << "Couldn't load settings from \"" << getConfigDirectory();
return 1;
}
Log::open();
LOG(LogInfo) << "EmulationStation - v" << PROGRAM_VERSION_STRING << ", built " << PROGRAM_BUILT_STRING;
//always close the log on exit
atexit(&onExit);
Window window;
ViewController::init(&window);
window.pushGui(ViewController::get());
if(!scrape_cmdline)
{
if(!window.init(width, height))
{
LOG(LogError) << "Window failed to initialize!";
return 1;
}
std::string glExts = (const char*)glGetString(GL_EXTENSIONS);
LOG(LogInfo) << "Checking available OpenGL extensions...";
LOG(LogInfo) << " ARB_texture_non_power_of_two: " << (glExts.find("ARB_texture_non_power_of_two") != std::string::npos ? "ok" : "MISSING");
if(Settings::getInstance()->getBool("SplashScreen"))
window.renderLoadingScreen();
}
const char* errorMsg = NULL;
if(!loadSystemConfigFile(&errorMsg))
{
// something went terribly wrong
if(errorMsg == NULL)
{
LOG(LogError) << "Unknown error occured while parsing system config file.";
if(!scrape_cmdline)
Renderer::deinit();
return 1;
}
// we can't handle es_systems.cfg file problems inside ES itself, so display the error message then quit
window.pushGui(new GuiMsgBox(&window,
errorMsg,
"QUIT", [] {
SDL_Event* quit = new SDL_Event();
quit->type = SDL_QUIT;
SDL_PushEvent(quit);
}));
}
//run the command line scraper then quit
if(scrape_cmdline)
{
return run_scraper_cmdline();
}
//dont generate joystick events while we're loading (hopefully fixes "automatically started emulator" bug)
SDL_JoystickEventState(SDL_DISABLE);
// preload what we can right away instead of waiting for the user to select it
// this makes for no delays when accessing content, but a longer startup time
ViewController::get()->preload();
//choose which GUI to open depending on if an input configuration already exists
if(errorMsg == NULL)
{
if(fs::exists(InputManager::getConfigPath()) && InputManager::getInstance()->getNumConfiguredDevices() > 0)
{
ViewController::get()->goToStart();
}else{
window.pushGui(new GuiDetectDevice(&window, true, [] { ViewController::get()->goToStart(); }));
}
}
//generate joystick events since we're done loading
SDL_JoystickEventState(SDL_ENABLE);
int lastTime = SDL_GetTicks();
bool running = true;
Uint32 CecEventType = InputManager::getInstance()->getCecEventType();
while(running)
{
SDL_Event event;
while(SDL_PollEvent(&event))
{
if(CecEventType != ((Uint32)-1) && event.type == CecEventType)
{
InputManager::getInstance()->parseEvent(event, &window);
}else{
switch(event.type)
{
case SDL_JOYHATMOTION:
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
case SDL_KEYDOWN:
case SDL_KEYUP:
case SDL_JOYAXISMOTION:
case SDL_TEXTINPUT:
case SDL_TEXTEDITING:
case SDL_JOYDEVICEADDED:
case SDL_JOYDEVICEREMOVED:
InputManager::getInstance()->parseEvent(event, &window);
break;
case SDL_QUIT:
running = false;
break;
}
}
}
if(window.isSleeping())
{
lastTime = SDL_GetTicks();
SDL_Delay(1); // this doesn't need to be accurate, we're just giving up our CPU time until something wakes us up
continue;
}
int curTime = SDL_GetTicks();
int deltaTime = curTime - lastTime;
lastTime = curTime;
// cap deltaTime at 1000
if(deltaTime > 1000 || deltaTime < 0)
deltaTime = 1000;
window.update(deltaTime);
window.render();
Renderer::swapBuffers();
Log::flush();
}
while(window.peekGui() != ViewController::get())
delete window.peekGui();
window.deinit();
SystemData::deleteSystems();
LOG(LogInfo) << "EmulationStation cleanly shutting down.";
return 0;
}
wxString FRConfig::getImagesPath() const
{
return getHomePath() + "images" + wxFileName::GetPathSeparator();
}
wxString FRConfig::getConfDefsPath() const
{
return getHomePath() + "conf-defs" + wxFileName::GetPathSeparator();
}
wxString FRConfig::getDocsPath() const
{
return getHomePath() + "docs" + wxFileName::GetPathSeparator();
}
wxString FRConfig::getSysTemplatesPath() const
{
return getHomePath() + "sys-templates"
+ wxFileName::GetPathSeparator();
}
std::string Log::getLogPath()
{
std::string home = getHomePath();
return home + "/.emulationstation/es_log.txt";
}
int main(int argc, char* argv[])
{
unsigned int width = 0;
unsigned int height = 0;
if(argc > 1)
{
for(int i = 1; i < argc; i++)
{
if(strcmp(argv[i], "-w") == 0)
{
width = atoi(argv[i + 1]);
i++; //skip the argument value
}else if(strcmp(argv[i], "-h") == 0)
{
height = atoi(argv[i + 1]);
i++; //skip the argument value
}else if(strcmp(argv[i], "--gamelist-only") == 0)
{
PARSEGAMELISTONLY = true;
}else if(strcmp(argv[i], "--ignore-gamelist") == 0)
{
IGNOREGAMELIST = true;
}else if(strcmp(argv[i], "--draw-framerate") == 0)
{
DRAWFRAMERATE = true;
}else if(strcmp(argv[i], "--no-exit") == 0)
{
DONTSHOWEXIT = true;
}else if(strcmp(argv[i], "--debug") == 0)
{
DEBUG = true;
Log::setReportingLevel(LogDebug);
}else if(strcmp(argv[i], "--dimtime") == 0)
{
DIMTIME = atoi(argv[i + 1]) * 1000;
i++; //skip the argument value
}else if(strcmp(argv[i], "--windowed") == 0)
{
WINDOWED = true;
}else if(strcmp(argv[i], "--help") == 0)
{
std::cout << "EmulationStation, a graphical front-end for ROM browsing.\n";
std::cout << "Command line arguments:\n";
std::cout << "-w [width in pixels] set screen width\n";
std::cout << "-h [height in pixels] set screen height\n";
std::cout << "--gamelist-only skip automatic game detection, only read from gamelist.xml\n";
std::cout << "--ignore-gamelist ignore the gamelist (useful for troubleshooting)\n";
std::cout << "--draw-framerate display the framerate\n";
std::cout << "--no-exit don't show the exit option in the menu\n";
std::cout << "--debug even more logging\n";
std::cout << "--dimtime [seconds] time to wait before dimming the screen (default 30, use 0 for never)\n";
#ifdef _DESKTOP_
std::cout << "--windowed not fullscreen\n";
#endif
std::cout << "--help summon a sentient, angry tuba\n\n";
std::cout << "More information available in README.md.\n";
return 0;
}
}
}
#ifdef _RPI_
bcm_host_init();
#endif
bool running = true;
//make sure the config directory exists
std::string home = getHomePath();
std::string configDir = home + "/.emulationstation";
if(!fs::exists(configDir))
{
std::cout << "Creating config directory \"" << configDir << "\"\n";
fs::create_directory(configDir);
}
//start the logger
Log::open();
//the renderer also takes care of setting up SDL for input and sound
bool renderInit = Renderer::init(width, height);
if(!renderInit)
{
std::cerr << "Error initializing renderer!\n";
Log::close();
return 1;
}
//initialize audio
AudioManager::init();
Window window; //don't call Window.init() because we manually pass the resolution to Renderer::init
window.getInputManager()->init();
//try loading the system config file
if(!fs::exists(SystemData::getConfigPath())) //if it doesn't exist, create the example and quit
{
std::cerr << "A system config file in " << SystemData::getConfigPath() << " was not found. An example will be created.\n";
SystemData::writeExampleConfig();
std::cerr << "Set it up, then re-run EmulationStation.\n";
running = false;
}else{
SystemData::loadConfig();
if(SystemData::sSystemVector.size() == 0) //if it exists but was empty, notify the user and quit
{
std::cerr << "A system config file in " << SystemData::getConfigPath() << " was found, but contained no systems.\n";
std::cerr << "Does at least one system have a game presesnt?\n";
running = false;
}else{
//choose which GUI to open depending on Input configuration
if(fs::exists(InputManager::getConfigPath()))
{
//an input config already exists - we have input, proceed to the gamelist as usual.
GuiGameList::create(&window);
}else{
window.pushGui(new GuiDetectDevice(&window));
}
}
}
bool sleeping = false;
unsigned int timeSinceLastEvent = 0;
int lastTime = 0;
while(running)
{
SDL_Event event;
while(SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_JOYHATMOTION:
case SDL_JOYBUTTONDOWN:
case SDL_JOYBUTTONUP:
case SDL_KEYDOWN:
case SDL_KEYUP:
case SDL_JOYAXISMOTION:
if(window.getInputManager()->parseEvent(event))
{
sleeping = false;
timeSinceLastEvent = 0;
}
break;
case SDL_QUIT:
running = false;
break;
}
}
if(sleeping)
{
lastTime = SDL_GetTicks();
sleep(1); //this doesn't need to accurate
continue;
}
int curTime = SDL_GetTicks();
int deltaTime = curTime - lastTime;
lastTime = curTime;
window.update(deltaTime);
window.render();
if(DRAWFRAMERATE)
{
float framerate = 1/((float)deltaTime)*1000;
std::stringstream ss;
ss << framerate;
std::string fps;
ss >> fps;
Renderer::drawText(fps, 50, 50, 0x00FF00FF, Renderer::getDefaultFont(Renderer::MEDIUM));
}
//sleep if we're past our threshold
//sleeping entails setting a flag to start skipping frames
//and initially drawing a black semi-transparent rect to dim the screen
timeSinceLastEvent += deltaTime;
if(timeSinceLastEvent >= DIMTIME && DIMTIME != 0)
{
sleeping = true;
timeSinceLastEvent = 0;
Renderer::drawRect(0, 0, Renderer::getScreenWidth(), Renderer::getScreenHeight(), 0x000000A0);
}
Renderer::swapBuffers();
Log::flush();
}
AudioManager::deinit();
Renderer::deinit();
SystemData::deleteSystems();
std::cout << "EmulationStation cleanly shutting down...\n";
Log::close();
#ifdef _RPI_
bcm_host_deinit();
#endif
return 0;
}
bool checkForOldConfigDirectory()
{
std::string home = getHomePath();
std::string configDir = home + "/.emulationstation";
return(fs::exists(configDir));
}
