/**
* Modify (or create) ST desktop configuration files so VDI boots up in
* correct color depth
*/
static void VDI_FixDesktopInf(void)
{
char *szDesktopFileName, *szNewDeskFileName;
if (!GEMDOS_EMU_ON)
{
/* Can't modify DESKTOP.INF when not using GEMDOS hard disk emulation */
return;
}
szDesktopFileName = malloc(2 * FILENAME_MAX);
if (!szDesktopFileName)
{
perror("VDI_FixDesktopInf");
return;
}
szNewDeskFileName = szDesktopFileName + FILENAME_MAX;
/* Create filenames for hard-drive */
GemDOS_CreateHardDriveFileName(2, "\\DESKTOP.INF", szDesktopFileName, FILENAME_MAX);
GemDOS_CreateHardDriveFileName(2, "\\NEWDESK.INF", szNewDeskFileName, FILENAME_MAX);
/* First, check if files exist(ie modify or replace) */
if (!File_Exists(szDesktopFileName))
VDI_SaveDesktopInf(szDesktopFileName,DesktopScript,sizeof(DesktopScript));
VDI_ModifyDesktopInf(szDesktopFileName);
if (!File_Exists(szNewDeskFileName))
VDI_SaveDesktopInf(szNewDeskFileName,NewDeskScript,sizeof(NewDeskScript));
VDI_ModifyDesktopInf(szNewDeskFileName);
free(szDesktopFileName);
}
/**
* Modify (or create) ST desktop configuration files so VDI boots up in
* correct color depth
*/
static void VDI_FixDesktopInf(void)
{
char *szDesktopFileName, *szNewDeskFileName;
/* Modifying DESKTOP.INF only makes sense when we emulate the GEMDOS
* hard disk 'C:' (i.e. the HD we boot from) - if not, simply return */
if (!GemDOS_IsDriveEmulated(2))
{
return;
}
szDesktopFileName = malloc(2 * FILENAME_MAX);
if (!szDesktopFileName)
{
perror("VDI_FixDesktopInf");
return;
}
szNewDeskFileName = szDesktopFileName + FILENAME_MAX;
/* Create filenames for hard-drive */
GemDOS_CreateHardDriveFileName(2, "\\DESKTOP.INF", szDesktopFileName, FILENAME_MAX);
GemDOS_CreateHardDriveFileName(2, "\\NEWDESK.INF", szNewDeskFileName, FILENAME_MAX);
/* First, check if files exist(ie modify or replace) */
if (!File_Exists(szDesktopFileName))
VDI_SaveDesktopInf(szDesktopFileName,DesktopScript,sizeof(DesktopScript));
VDI_ModifyDesktopInf(szDesktopFileName);
if (!File_Exists(szNewDeskFileName))
VDI_SaveDesktopInf(szNewDeskFileName,NewDeskScript,sizeof(NewDeskScript));
VDI_ModifyDesktopInf(szNewDeskFileName);
free(szDesktopFileName);
}
bool cPreferences :: Load( const std::string &filename /* = "" */ )
{
Reset_All();
// if config file is given
if( filename.length() )
{
m_config_filename = filename;
}
// prefer local config file
if( File_Exists( m_config_filename ) )
{
printf( "Using local preferences file : %s\n", m_config_filename.c_str() );
}
// user dir
else
{
m_config_filename.insert( 0, pResource_Manager->user_data_dir );
/* fixme : this crashes in CEGUI::DefaultResourceProvider::loadRawDataContainer because of the é
* The CEGUI string encoding is UTF-8 but std::string seems to be ISO-8859-1 or Code page 1252
*/
//config_filename.insert( 0, "N:/Dokumente und Einstellungen/smc_Invité/Anwendungsdaten/smc/" );
// does not exist in user dir
if( !File_Exists( m_config_filename ) )
{
// only print warning if file is given
if( !filename.empty() )
{
printf( "Couldn't open preferences file : %s\n", m_config_filename.c_str() );
}
return 0;
}
}
try
{
//CEGUI::String str = "N:/Dokumente und Einstellungen/smc_Invité/Anwendungsdaten/smc/config.xml";
CEGUI::System::getSingleton().getXMLParser()->parseXMLFile( *this, m_config_filename, DATA_DIR "/" GAME_SCHEMA_DIR "/Config.xsd", "" );
}
// catch CEGUI Exceptions
catch( CEGUI::Exception &ex )
{
printf( "Preferences Loading CEGUI Exception %s\n", ex.getMessage().c_str() );
pHud_Debug->Set_Text( _("Preferences Loading failed : ") + (const std::string)ex.getMessage().c_str() );
}
// if user data dir is set
if( !m_force_user_data_dir.empty() )
{
pResource_Manager->Set_User_Directory( m_force_user_data_dir );
}
return 1;
}
bool cOverworld :: Load( void )
{
Unload();
// description
m_description->Load();
// world
std::string world_filename = m_description->Get_Full_Path() + "/world.xml";
if( !File_Exists( world_filename ) )
{
printf( "Couldn't find World file : %s from %s\n", world_filename.c_str(), m_description->m_path.c_str() );
return 0;
}
try
{
// parse overworld
// fixme : Workaround for std::string to CEGUI::String utf8 conversion. Check again if CEGUI 0.8 works with std::string utf8
#ifdef _WIN32
CEGUI::System::getSingleton().getXMLParser()->parseXMLFile( *this, (const CEGUI::utf8*)world_filename.c_str(), DATA_DIR "/" GAME_SCHEMA_DIR "/World/World.xsd", "" );
#else
CEGUI::System::getSingleton().getXMLParser()->parseXMLFile( *this, world_filename.c_str(), DATA_DIR "/" GAME_SCHEMA_DIR "/World/World.xsd", "" );
#endif
}
// catch CEGUI Exceptions
catch( CEGUI::Exception &ex )
{
printf( "Loading World %s CEGUI Exception %s\n", world_filename.c_str(), ex.getMessage().c_str() );
pHud_Debug->Set_Text( _("World Loading failed : ") + (const std::string)ex.getMessage().c_str() );
}
// engine version entry not set
if( m_engine_version < 0 )
{
m_engine_version = 0;
}
// layer
std::string layer_filename = m_description->Get_Full_Path() + "/layer.xml";
if( !File_Exists( layer_filename ) )
{
printf( "Couldn't find World Layer file : %s from %s\n", layer_filename.c_str(), m_description->m_path.c_str() );
return 0;
}
m_layer->Load( layer_filename );
// set name
m_hud_world_name->Set_Image( pFont->Render_Text( pFont->m_font_normal, m_description->m_name, yellow ), 1, 1 );
return 1;
}
bool CTileset::ReadTileTypeFile(char * szFile)
{
//Detect if the tiletype file already exists, if not create it
if(File_Exists(szFile)) {
FILE * tsf = fopen(szFile, "rb");
if(tsf == NULL) {
printf("ERROR: couldn't open tileset file: %s\n", szFile);
return false;
}
iTileTypeSize = ReadInt(tsf);
if(iTileTypeSize <= 0 || iTileTypeSize > 1024) {
fclose(tsf);
return false;
}
tiletypes = new TileType[iTileTypeSize];
for(short i = 0; i < iTileTypeSize; i++) {
tiletypes[i] = (TileType)ReadInt(tsf);
}
fclose(tsf);
} else {
iTileTypeSize = iWidth * iHeight;
tiletypes = new TileType[iTileTypeSize];
for(short i = 0; i < iTileTypeSize; i++) {
tiletypes[i] = tile_nonsolid;
}
}
return true;
}
/**
* Save/Restore snapshot of debugging session variables
*/
void DebugUI_MemorySnapShot_Capture(const char *path, bool bSave)
{
char *filename;
filename = malloc(strlen(path) + strlen(".debug") + 1);
assert(filename);
strcpy(filename, path);
strcat(filename, ".debug");
if (bSave)
{
/* save breakpoints as debugger input file */
BreakCond_Save(filename);
}
else
{
/* remove current CPU and DSP breakpoints */
BreakCond_Command("all", false);
BreakCond_Command("all", true);
if (File_Exists(filename))
{
/* and parse back the saved breakpoints */
DebugUI_ParseFile(filename, true);
}
}
free(filename);
}
bool CTileset::ReadTileTypeFile(char * szFile)
{
//Detect if the tiletype file already exists, if not create it
if (File_Exists(szFile)) {
BinaryFile tsf(szFile, "rb");
if (!tsf.is_open()) {
printf("ERROR: couldn't open tileset file: %s\n", szFile);
return false;
}
iTileTypeSize = tsf.read_i32();
if (iTileTypeSize <= 0 || iTileTypeSize > 1024) {
return false;
}
tiletypes = new TileType[iTileTypeSize];
for (short i = 0; i < iTileTypeSize; i++) {
tiletypes[i] = (TileType)tsf.read_i32();
}
} else {
iTileTypeSize = iWidth * iHeight;
tiletypes = new TileType[iTileTypeSize];
for (short i = 0; i < iTileTypeSize; i++) {
tiletypes[i] = tile_nonsolid;
}
}
return true;
}
void cOverworld_Manager::Load_Dir(const fs::path& dir, bool user_dir /* = false */)
{
// set world directory
vector<fs::path> subdirs = Get_Directory_Files(dir, "", true, false);
std::sort(subdirs.begin(), subdirs.end());
for (vector<fs::path>::iterator curdir = subdirs.begin(); curdir != subdirs.end(); ++curdir) {
try {
fs::path current_dir = *curdir;
// only directories with an existing description
if (File_Exists(current_dir / "description.xml")) {
cOverworld* overworld = Get_from_Path(current_dir);
// already available
if (overworld) {
overworld->m_description->m_user = 2; // 2 = available in system *and* in user dir
continue;
}
overworld = cOverworld::Load_From_Directory(current_dir, user_dir);
objects.push_back(overworld);
}
}
catch (const std::exception& ex) {
printf("%s %s\n", path_to_utf8(*curdir).c_str(), ex.what());
}
}
}
static void FillSavegameDesc(bool save)
{
uint8 i;
for (i = 0; i < 5; i++) {
char *desc = g_savegameDesc[i];
char *filename;
uint8 fileId;
*desc = '\0';
if (s_savegameIndexBase - i < 0) continue;
if (s_savegameIndexBase - i == s_savegameCountOnDisk) {
if (!save) continue;
strncpy(desc, String_Get_ByIndex(STR_EMPTY_SLOT_), 50);
continue;
}
filename = GenerateSavegameFilename(s_savegameIndexBase - i);
if (!File_Exists(filename)) continue;
fileId = ChunkFile_Open(filename);
ChunkFile_Read(fileId, HTOBE32(CC_NAME), desc, 50);
ChunkFile_Close(fileId);
continue;
}
}
void cFlyon::Set_Image_Dir(fs::path dir)
{
if (dir.empty()) {
return;
}
// if not image directory
if (!File_Exists(pResource_Manager->Get_Game_Pixmaps_Directory() / dir / utf8_to_path("closed_1.settings")) && !File_Exists(pResource_Manager->Get_Game_Pixmaps_Directory() / dir / utf8_to_path("closed_1.png"))) {
std::cerr << "Warning: Flyon image files not found; does the flyon directory "
<< path_to_utf8(dir) << " exist?" << std::endl;
return;
}
m_img_dir = dir;
// clear images
Clear_Images();
// set images
Add_Image(pVideo->Get_Surface(m_img_dir / utf8_to_path("closed_1.png")));
Add_Image(pVideo->Get_Surface(m_img_dir / utf8_to_path("closed_2.png")));
Add_Image(pVideo->Get_Surface(m_img_dir / utf8_to_path("open_1.png")));
Add_Image(pVideo->Get_Surface(m_img_dir / utf8_to_path("open_2.png")));
// set start image
Set_Image_Num(0, 1);
Set_Animation(1);
Set_Animation_Image_Range(0, 3);
Set_Time_All(130, 1);
Reset_Animation();
}
static const char *
DnDCreateRootStagingDirectory(void)
{
const char *root;
/*
* DnD_GetFileRoot() gives us a pointer to a static string, so there's no
* need to free anything.
*/
root = DnD_GetFileRoot();
if (!root) {
return NULL;
}
if (File_Exists(root)) {
if (!DnDRootDirUsable(root) &&
!DnDSetPermissionsOnRootDir(root)) {
/*
* The directory already exists and its permissions are wrong and
* cannot be set, so there's not much we can do.
*/
return NULL;
}
} else {
if (!File_CreateDirectory(root) ||
!DnDSetPermissionsOnRootDir(root)) {
/* We couldn't create the directory or set the permissions. */
return NULL;
}
}
return root;
}
/**
* Load program setting from configuration file. If psFileName is NULL, use
* the configuration file given in configuration / last selected by user.
*/
void Configuration_Load(const char *psFileName)
{
if (psFileName == NULL)
psFileName = sConfigFileName;
if (!File_Exists(psFileName))
{
Log_Printf(LOG_DEBUG, "Configuration file %s not found.\n", psFileName);
return;
}
Configuration_LoadSection(psFileName, configs_Log, "[Log]");
Configuration_LoadSection(psFileName, configs_ConfigDialog, "[ConfigDialog]");
Configuration_LoadSection(psFileName, configs_Debugger, "[Debugger]");
Configuration_LoadSection(psFileName, configs_Screen, "[Screen]");
Configuration_LoadSection(psFileName, configs_Keyboard, "[Keyboard]");
Configuration_LoadSection(psFileName, configs_ShortCutWithMod, "[ShortcutsWithModifiers]");
Configuration_LoadSection(psFileName, configs_ShortCutWithoutMod, "[ShortcutsWithoutModifiers]");
Configuration_LoadSection(psFileName, configs_Mouse, "[Mouse]");
Configuration_LoadSection(psFileName, configs_Sound, "[Sound]");
Configuration_LoadSection(psFileName, configs_Memory, "[Memory]");
Configuration_LoadSection(psFileName, configs_Boot, "[Boot]");
Configuration_LoadSection(psFileName, configs_SCSI, "[HardDisk]");
Configuration_LoadSection(psFileName, configs_MO, "[MagnetoOptical]");
Configuration_LoadSection(psFileName, configs_Floppy, "[Floppy]");
Configuration_LoadSection(psFileName, configs_Ethernet, "[Ethernet]");
Configuration_LoadSection(psFileName, configs_Rom, "[ROM]");
Configuration_LoadSection(psFileName, configs_Printer, "[Printer]");
Configuration_LoadSection(psFileName, configs_System, "[System]");
Configuration_LoadSection(psFileName, configs_Dimension, "[Dimension]");
}
Bool
DnD_DeleteStagingFiles(const char *stagingDir, // IN:
Bool onReboot) // IN:
{
Bool ret = TRUE;
ASSERT(stagingDir);
if (!File_Exists(stagingDir)) {
/* The stagingDir is already gone. */
return TRUE;
}
if (!File_IsDirectory(stagingDir)) {
return FALSE;
}
if (onReboot) {
if (File_UnlinkDelayed(stagingDir)) {
ret = FALSE;
}
} else {
int i;
int numFiles;
char *base;
char **fileList = NULL;
/* get list of files in current directory */
numFiles = File_ListDirectory(stagingDir, &fileList);
if (numFiles == -1) {
return FALSE;
}
/* delete everything in the directory */
base = Unicode_Append(stagingDir, DIRSEPS);
for (i = 0; i < numFiles; i++) {
char *curPath;
curPath = Unicode_Append(base, fileList[i]);
if (File_IsDirectory(curPath)) {
if (!File_DeleteDirectoryTree(curPath)) {
ret = FALSE;
}
} else {
if (File_Unlink(curPath) == -1) {
ret = FALSE;
}
}
free(curPath);
}
free(base);
}
return ret;
}
/**
* If 'checkexits' is true, assume 'src' is a file and check whether it
* exists before copying 'src' to 'dst'. Otherwise just copy option src
* string to dst.
* If a pointer to (bool) 'option' is given, set that option to true.
* - However, if src is "none", leave dst unmodified & set option to false.
* ("none" is used to disable options related to file arguments)
* Return false if there were errors, otherwise true
*/
static bool Opt_StrCpy(int optid, bool checkexist, char *dst, const char *src, size_t dstlen, bool *option)
{
if (option)
{
*option = false;
if(strcasecmp(src, "none") == 0)
{
return true;
}
}
if (strlen(src) >= dstlen)
{
return Opt_ShowError(optid, src, "File name too long!");
}
if (checkexist && !File_Exists(src))
{
return Opt_ShowError(optid, src, "Given file doesn't exist (or has wrong file permissions)!");
}
if (option)
{
*option = true;
}
strcpy(dst, src);
return true;
}
/**
* Let user browse given disk, insert disk if one selected.
*/
static void DlgDisk_BrowseDisk(char *dlgname, int drive, int diskid)
{
char *selname, *zip_path;
const char *tmpname, *realname;
assert(drive >= 0 && drive < MAX_FLOPPYDRIVES);
if (szDiskFileName[drive][0])
tmpname = szDiskFileName[drive];
else
tmpname = szDiskImageDirectory;
selname = SDLGui_FileSelect(tmpname, &zip_path, false);
if (!selname)
return;
printf("in)d%d:(%s)\n",drive,selname);
if (File_Exists(selname))
{printf("----------Exist)\n");
realname = Floppy_SetDiskFileName(drive, selname, zip_path);
if (realname)
File_ShrinkName(dlgname, realname, floppydlg[diskid].w);
}
else
{printf("---------not found\n");
Floppy_SetDiskFileNameNone(drive);
dlgname[0] = '\0';
}
if (zip_path)
free(zip_path);
free(selname);
}
/**
* Set given floppy drive image file name and handle
* different image extensions.
* Return corrected file name on success and NULL on failure.
*/
const char* Floppy_SetDiskFileName(int Drive, const char *pszFileName, const char *pszZipPath)
{
char *filename;
int i;
/* setting to empty or "none" ejects */
if (!*pszFileName || strcasecmp(pszFileName, "none") == 0)
{
return Floppy_SetDiskFileNameNone(Drive);
}
/* See if file exists, and if not, get/add correct extension */
if (!File_Exists(pszFileName))
filename = File_FindPossibleExtFileName(pszFileName, pszDiskImageNameExts);
else
filename = strdup(pszFileName);
if (!filename)
{
Log_AlertDlg((const char *)LOG_INFO, "Image '%s' not found", pszFileName);
return NULL;
}
#if 0
/* If we insert a disk into Drive A, should we try to put disk 2 into drive B? */
if (Drive == 0 && ConfigureParams.DiskImage.bAutoInsertDiskB)
{
/* Attempt to make up second filename, eg was 'auto_100a' to 'auto_100b' */
char *szDiskBFileName = Floppy_CreateDiskBFileName(filename);
if (szDiskBFileName)
{
/* recurse with Drive B */
Floppy_SetDiskFileName(1, szDiskBFileName, pszZipPath);
free(szDiskBFileName);
}
}
#endif
/* validity checks */
assert(Drive >= 0 && Drive < MAX_FLOPPYDRIVES);
for (i = 0; i < MAX_FLOPPYDRIVES; i++)
{
if (i == Drive)
continue;
/* prevent inserting same image to multiple drives */
if (strcmp(filename, /*ConfigureParams.DiskImage.*/szDiskFileName[i]) == 0)
{
Log_AlertDlg((const char *)LOG_ERROR, "ERROR: Cannot insert same floppy to multiple drives!");
return NULL;
}
}
/* do the changes */
if (pszZipPath)
strcpy(szDiskZipPath[Drive], pszZipPath);
else
szDiskZipPath[Drive][0] = '\0';
strcpy(szDiskFileName[Drive], filename);
free(filename);
//File_MakeAbsoluteName(ConfigureParams.DiskImage.szDiskFileName[Drive]);
return szDiskFileName[Drive];
}
static uint16 GetSavegameCount(void)
{
uint16 i;
for (i = 0;; i++) {
if (!File_Exists(GenerateSavegameFilename(i))) return i;
}
}
bool File_Exists_And_Is_A_Socket(std::string path_to_file){
if (File_Exists(path_to_file)){
if (Is_A_Socket(path_to_file)){
return true;
}
}
return false;
}
bool File_Exists_And_Is_Regular_File(std::string path_to_file){
if (File_Exists(path_to_file)){
if (Is_Regular_File(path_to_file)){
return true;
}
}
return false;
}
bool File_Exists_And_Is_Directory(std::string path_to_file){
if (File_Exists(path_to_file)){
if (Is_Directory(path_to_file)){
return true;
}
}
return false;
}
bool File_Exists_And_Is_Symbolic_Link(std::string path_to_file){
if (File_Exists(path_to_file)){
if (Is_Symbolic_Link(path_to_file)){
return true;
}
}
return false;
}
//+--------------+
//| Transformers |
//+--------------+
void Create_Path_If_It_Doesnt_Already_Exist(std::string const& path){
if (!File_Exists(path)){
execute_quietly(("mkdir -p " + path).c_str());
}
return;
}
bool File_Exists_And_Is_A_Block_Special_File(std::string path_to_file){
if (File_Exists(path_to_file)){
if (Is_A_Block_Special_File(path_to_file)){
return true;
}
}
return false;
}
/**
* Loads the game options.
*
* @return True if loading is successful.
*/
bool GameOptions_Load(void)
{
if (!File_Exists("OPTIONS.CFG")) return false;
File_ReadBlockFile("OPTIONS.CFG", &g_gameConfig, sizeof(g_gameConfig));
return true;
}
static Bool
RecordRoutingInfo(NicInfoV3 *nicInfo)
{
Bool retIPv4 = TRUE;
Bool retIPv6 = TRUE;
if (File_Exists("/proc/net/route") && !RecordRoutingInfoIPv4(nicInfo)) {
g_warning("%s: Unable to collect IPv4 routing table.\n", __func__);
retIPv4 = FALSE;
}
if (File_Exists("/proc/net/ipv6_route") && !RecordRoutingInfoIPv6(nicInfo)) {
g_warning("%s: Unable to collect IPv6 routing table.\n", __func__);
retIPv6 = FALSE;
}
return (retIPv4 || retIPv6);
}
bool Subfolder_Scanner::Make_Sure_The_Necessary_Files_Are_Present_At_Subfolder(Warn_Machine & warn_machine){
for (auto const& file: constant::NEEDED_FILES_FOR_EACH_PSEUDO_SUB_DIRECTORY){
if (!File_Exists(file)){
if (!warn_machine.Record_Missing_File(file)) { return false;}
}
}
return true;
}
/**
* Set debugger commands file during Hatari startup before things
* needed by the debugger are initialized so that it can be parsed
* when debugger itself gets initialized.
* Return true if file exists, false otherwise.
*/
bool DebugUI_SetParseFile(const char *path)
{
if (File_Exists(path))
{
parseFileName = path;
return true;
}
fprintf(stderr, "ERROR: debugger input file '%s' missing.\n", path);
return false;
}
void Driver_Voice_LoadFile(const char *filename, void *buffer, uint32 length)
{
assert(buffer != NULL);
if (filename == NULL) return;
if (g_driverVoice->index == 0xFFFF) return;
if (!File_Exists(filename)) return;
File_ReadBlockFile(filename, buffer, length);
}
/**
* Load keyboard remap file
*/
void Keymap_LoadRemapFile(char *pszFileName)
{
char szString[1024];
int STScanCode, PCKeyCode;
FILE *in;
int idx = 0;
/* Initialize table with default values */
memset(LoadedKeymap, 0, sizeof(LoadedKeymap));
if (!*pszFileName)
return;
/* Attempt to load file */
if (!File_Exists(pszFileName))
{
Log_Printf(LOG_DEBUG, "Keymap_LoadRemapFile: '%s' not a file\n", pszFileName);
return;
}
in = fopen(pszFileName, "r");
if (!in)
{
Log_Printf(LOG_DEBUG, "Keymap_LoadRemapFile: failed to "
" open keymap file '%s'\n", pszFileName);
return;
}
while (!feof(in) && idx < KBD_MAX_SCANCODE)
{
/* Read line from file */
if (fgets(szString, sizeof(szString), in) == NULL)
break;
/* Remove white-space from start of line */
Str_Trim(szString);
if (strlen(szString)>0)
{
/* Is a comment? */
if ( (szString[0]==';') || (szString[0]=='#') )
continue;
/* Read values */
sscanf(szString, "%d,%d", &PCKeyCode, &STScanCode);
/* Store into remap table, check both value within range */
if (STScanCode >= 0 && STScanCode <= KBD_MAX_SCANCODE
&& PCKeyCode >= 8)
{
LoadedKeymap[idx][0] = PCKeyCode;
LoadedKeymap[idx][1] = STScanCode;
idx += 1;
}
}
}
fclose(in);
}
void ENVIRONMENT::SavedFile_FindNext(void) {
savedFileIndex++;
char fileName[100];
sprintf(fileName,"SavedFiles/env%d.dat",savedFileIndex);
if ( !File_Exists(fileName) )
savedFileIndex = 0;
}
