void FeTextureContainer::load_from_archive( const char *a, const char *n )
{
std::string path, filename = clean_path( n );
if ( filename.empty() )
{
clear();
notify_texture_change();
return;
}
if ( a && ( strlen( a ) > 0 ))
path = clean_path( a );
// If it is a relative path we assume it is in the
// layout/screensaver/intro directory
//
else if ( is_relative_path( filename ) )
path = FePresent::script_get_base_path();
bool is_image=false;
int i=0;
while ( FE_ART_EXTENSIONS[i] )
{
if ( tail_compare( filename, FE_ART_EXTENSIONS[i] ) )
{
is_image=true;
break;
}
i++;
}
try_to_load( path, filename, is_image );
notify_texture_change();
}
bool get_basename_from_extension(
std::vector<std::string> &list,
const std::string &path,
const std::string &extension,
bool strip_extension )
{
#ifdef SFML_SYSTEM_WINDOWS
std::string temp = path + "*" + extension;
struct _finddata_t t;
intptr_t srch = _findfirst( temp.c_str(), &t );
if ( srch < 0 )
return false;
do
{
std::string what;
str_from_c( what, t.name );
// I don't know why but the search filespec we are using
// "path/*.ext"seems to also match "path/*.ext*"... so we
// do the tail comparison below on purpose to catch this...
#else
DIR *dir;
struct dirent *ent;
if ( (dir = opendir( path.c_str() )) == NULL )
return false;
while ((ent = readdir( dir )) != NULL )
{
std::string what;
str_from_c( what, ent->d_name );
#endif
if ( ( what.compare( "." ) == 0 ) || ( what.compare( ".." ) == 0 ) )
continue;
if ( tail_compare( what, extension ) )
{
if ( strip_extension && ( what.size() > extension.size() ))
{
std::string bname = what.substr( 0,
what.size() - extension.size() );
// don't add duplicates if we are stripping extension
// example: if there is both foo.zip and foo.7z
//
if ( list.empty() || ( bname.compare( list.back() ) != 0 ))
list.push_back( bname );
}
else
list.push_back( what );
}
#ifdef SFML_SYSTEM_WINDOWS
} while ( _findnext( srch, &t ) == 0 );
_findclose( srch );
#else
}
closedir( dir );
#endif
std::sort( list.begin(), list.end() );
return !(list.empty());
}
bool FeSettings::build_romlist( const std::vector< FeImportTask > &task_list,
const std::string &output_name,
FeFilter &filter,
bool full )
{
FeRomInfoListType total_romlist;
std::string best_name, list_name, path;
for ( std::vector<FeImportTask>::const_iterator itr=task_list.begin();
itr < task_list.end(); ++itr )
{
if ( (*itr).task_type == FeImportTask::BuildRomlist )
{
// Build romlist task
std::cout << "*** Generating Collection/Rom List" << std::endl;
FeEmulatorInfo *emu = m_rl.get_emulator( (*itr).emulator_name );
if ( emu == NULL )
{
std::cout << "Error: Invalid -build-rom-list target: " << (*itr).emulator_name
<< std::endl;
}
else
{
FeRomInfoListType romlist;
best_name = emu->get_info( FeEmulatorInfo::Name );
FeImporterContext ctx( *emu, romlist );
build_basic_romlist( ctx );
apply_xml_import( ctx );
apply_import_extras( ctx );
apply_emulator_name( best_name, romlist );
total_romlist.splice( total_romlist.end(), romlist );
}
}
else if ( (*itr).task_type == FeImportTask::ImportRomlist )
{
// import romlist from file task
std::cout << "*** Importing Collection/Rom List" << std::endl;
FeRomInfoListType romlist;
std::string emu_name;
if ( (*itr).emulator_name.empty() )
{
// deduce the emulator name from the filename provided
size_t my_start = (*itr).file_name.find_last_of( "\\/" );
if ( my_start == std::string::npos ) // if there is no / we start at the beginning
my_start = 0;
else
my_start += 1;
size_t my_end = (*itr).file_name.find_last_of( "." );
if ( my_end != std::string::npos )
emu_name = (*itr).file_name.substr( my_start, my_end - my_start );
}
else
emu_name = (*itr).emulator_name;
best_name = emu_name;
if ( tail_compare( (*itr).file_name, ".txt" ) )
{
// Attract-Mode format list
//
FeRomList temp_list( m_config_path );
temp_list.load_from_file( (*itr).file_name, ";" );
FeRomInfoListType &entries = temp_list.get_list();
for ( FeRomInfoListType::iterator itr = entries.begin(); itr != entries.end(); ++itr )
romlist.push_back( *itr );
}
else if ( tail_compare( (*itr).file_name, ".lst" ) )
{
// Mamewah/Wahcade! format list
//
import_mamewah( (*itr).file_name, emu_name, romlist );
}
else if ( tail_compare( (*itr).file_name, ".xml" ) )
{
// HyperSpin format list
//
FeHyperSpinXMLParser my_parser( romlist );
if ( my_parser.parse( (*itr).file_name ) )
apply_emulator_name( emu_name, romlist );
}
else
{
std::cerr << "Error: Unsupported --import-rom-list file: "
<< (*itr).file_name << std::endl;
}
std::cout << "[Import " << (*itr).file_name << "] - Imported " << romlist.size() << " entries."
<< std::endl;
FeEmulatorInfo *emu = m_rl.get_emulator( emu_name );
if ( emu == NULL )
{
std::cout << "Warning: The emulator specified with --import-rom-list was not found: "
<< emu_name << std::endl;
}
else
{
FeImporterContext ctx( *emu, romlist );
apply_import_extras( ctx );
}
total_romlist.splice( total_romlist.end(), romlist );
}
else // scrape artwork
{
FeEmulatorInfo *emu = m_rl.get_emulator( (*itr).emulator_name );
if ( emu == NULL )
return false;
std::cout << "*** Scraping artwork for: " << (*itr).emulator_name << std::endl;
FeRomInfoListType romlist;
std::string fn = get_config_dir() + FE_ROMLIST_SUBDIR + (*itr).emulator_name + FE_ROMLIST_FILE_EXTENSION;
FeImporterContext ctx( *emu, romlist );
if ( file_exists( fn ) )
{
FeRomList loader( get_config_dir() );
loader.load_from_file( fn, ";" );
ctx.romlist.swap( loader.get_list() );
}
else
{
build_basic_romlist( ctx );
apply_xml_import( ctx );
}
ctx.scrape_art = true;
confirm_directory( get_config_dir(), FE_SCRAPER_SUBDIR );
// do the mamedb scraper first (which only does anything for mame) followed
// by the more general thegamesdb scraper.
mamedb_scraper( ctx );
thegamesdb_scraper( ctx );
std::cout << "*** Scraping done." << std::endl;
}
}
// return now if all we did was scrape artwork
if ( total_romlist.empty() )
return true;
total_romlist.sort( FeRomListSorter() );
// strip duplicate entries
std::cout << " - Removing any duplicate entries..." << std::endl;
total_romlist.unique();
// Apply the specified filter
if ( filter.get_rule_count() > 0 )
{
std::cout << " - Applying filter..." << std::endl;
filter.init();
FeRomInfoListType::iterator last_it=total_romlist.begin();
for ( FeRomInfoListType::iterator it=total_romlist.begin(); it!=total_romlist.end(); )
{
if ( filter.apply_filter( *it ) )
{
if ( last_it != it )
it = total_romlist.erase( last_it, it );
else
++it;
last_it = it;
}
else
++it;
}
if ( last_it != total_romlist.end() )
total_romlist.erase( last_it, total_romlist.end() );
}
if ( task_list.size() > 1 )
best_name = "multi";
path = get_config_dir();
confirm_directory( path, FE_ROMLIST_SUBDIR );
path += FE_ROMLIST_SUBDIR;
// if we weren't given a specific output name, then we come up with a name
// that doesn't exist already
//
if ( output_name.empty() )
get_available_filename( path, best_name, FE_ROMLIST_FILE_EXTENSION, list_name );
else
list_name = path + output_name + FE_ROMLIST_FILE_EXTENSION;
write_romlist( list_name, total_romlist );
return true;
}
bool FeTextureContainer::try_to_load(
const std::string &path,
const std::string &filename,
bool is_image )
{
std::string loaded_name;
#ifndef NO_SWF
if ( !is_image && tail_compare( filename, FE_SWF_EXT ) )
{
if ( is_supported_archive( path ) )
{
loaded_name = path + "|" + filename;
if ( loaded_name.compare( m_file_name ) == 0 )
return true;
m_swf = new FeSwf();
if (!m_swf->open_from_archive( path, filename ))
{
std::cout << " ! ERROR loading SWF from archive: "
<< path << " (" << filename << ")" << std::endl;
delete m_swf;
m_swf = NULL;
return false;
}
}
else
{
loaded_name = path + filename;
if ( loaded_name.compare( m_file_name ) == 0 )
return true;
m_swf = new FeSwf();
if (!m_swf->open_from_file( loaded_name ))
{
std::cout << " ! ERROR loading SWF: "
<< loaded_name << std::endl;
delete m_swf;
m_swf = NULL;
return false;
}
}
m_file_name = loaded_name;
return true;
}
#endif
#ifndef NO_MOVIE
if ( !is_image && FeMedia::is_supported_media_file( filename ) )
return load_with_ffmpeg( path, filename, false );
#endif
if ( is_supported_archive( path ) )
{
loaded_name = path + "|" + filename;
if ( loaded_name.compare( m_file_name ) == 0 )
return true;
clear();
FeZipStream zs( path );
if ( !zs.open( filename ) )
{
// Error opening specified filename. Try to correct
// in case filename is in a subdir of the archive
std::string temp;
if ( get_archive_filename_with_base(
temp, path, filename ) )
{
zs.open( temp );
loaded_name = path + "|" + temp;
}
}
if ( m_texture.loadFromStream( zs ) )
{
m_file_name = loaded_name;
return true;
}
}
else
{
loaded_name = path + filename;
if ( loaded_name.compare( m_file_name ) == 0 )
return true;
clear();
if ( m_texture.loadFromFile( loaded_name ) )
{
m_file_name = loaded_name;
return true;
}
}
#ifndef NO_MOVIE
//
// we should only get here if we failed to load an image with SFML
// try loading it with ffmpeg instead, which can handle more image
// formats...
//
return load_with_ffmpeg( path, filename, is_image );
#else
return false;
#endif
}
