284 lines
6.8 KiB
C++
284 lines
6.8 KiB
C++
//
|
|
// C++ Implementation: PresetLoader
|
|
//
|
|
// Description:
|
|
//
|
|
//
|
|
// Author: Carmelo Piccione <carmelo.piccione@gmail.com>, (C) 2007
|
|
//
|
|
// Copyright: See COPYING file that comes with this distribution
|
|
//
|
|
//
|
|
#include "PresetLoader.hpp"
|
|
#include "Preset.hpp"
|
|
#include "PresetFactory.hpp"
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <set>
|
|
|
|
#ifdef LINUX
|
|
extern "C"
|
|
{
|
|
#include <errno.h>
|
|
}
|
|
#endif
|
|
|
|
#ifdef MACOS
|
|
extern "C"
|
|
{
|
|
#include <errno.h>
|
|
}
|
|
#endif
|
|
|
|
#include <cassert>
|
|
#include "fatal.h"
|
|
|
|
#include "Common.hpp"
|
|
|
|
PresetLoader::PresetLoader (int gx, int gy, std::string dirname = std::string()) :_dirname ( dirname ), _dir ( 0 )
|
|
{
|
|
_presetFactoryManager.initialize(gx,gy);
|
|
// Do one scan
|
|
if ( _dirname != std::string() )
|
|
rescan();
|
|
else
|
|
clear();
|
|
}
|
|
|
|
PresetLoader::~PresetLoader()
|
|
{
|
|
if ( _dir )
|
|
closedir ( _dir );
|
|
}
|
|
|
|
void PresetLoader::setScanDirectory ( std::string dirname )
|
|
{
|
|
_dirname = dirname;
|
|
}
|
|
|
|
|
|
void PresetLoader::rescan()
|
|
{
|
|
// std::cerr << "Rescanning..." << std::endl;
|
|
|
|
// Clear the directory entry collection
|
|
clear();
|
|
|
|
// If directory already opened, close it first
|
|
if ( _dir )
|
|
{
|
|
closedir ( _dir );
|
|
_dir = 0;
|
|
}
|
|
|
|
// Allocate a new a stream given the current directory name
|
|
if ( ( _dir = opendir ( _dirname.c_str() ) ) == NULL )
|
|
{
|
|
handleDirectoryError();
|
|
return; // no files loaded. _entries is empty
|
|
}
|
|
|
|
struct dirent * dir_entry;
|
|
std::set<std::string> alphaSortedFileSet;
|
|
std::set<std::string> alphaSortedPresetNameSet;
|
|
|
|
while ( ( dir_entry = readdir ( _dir ) ) != NULL )
|
|
{
|
|
if (dir_entry->d_name == 0)
|
|
continue;
|
|
|
|
std::ostringstream out;
|
|
// Convert char * to friendly string
|
|
std::string filename ( dir_entry->d_name );
|
|
|
|
// Verify extension is projectm or milkdrop
|
|
if (!_presetFactoryManager.extensionHandled(parseExtension(filename)))
|
|
continue;
|
|
|
|
if ( filename.length() > 0 && filename[0] == '.' )
|
|
continue;
|
|
|
|
// Create full path name
|
|
out << _dirname << PATH_SEPARATOR << filename;
|
|
|
|
// Add to our directory entry collection
|
|
alphaSortedFileSet.insert ( out.str() );
|
|
alphaSortedPresetNameSet.insert ( filename );
|
|
|
|
// the directory entry struct is freed elsewhere
|
|
}
|
|
|
|
// Push all entries in order from the file set to the file entries member (which is an indexed vector)
|
|
for ( std::set<std::string>::iterator pos = alphaSortedFileSet.begin();
|
|
pos != alphaSortedFileSet.end();++pos )
|
|
_entries.push_back ( *pos );
|
|
|
|
// Push all preset names in similar fashion
|
|
for ( std::set<std::string>::iterator pos = alphaSortedPresetNameSet.begin();
|
|
pos != alphaSortedPresetNameSet.end();++pos )
|
|
_presetNames.push_back ( *pos );
|
|
|
|
// Give all presets equal rating of 3 - why 3? I don't know
|
|
_ratings = std::vector<RatingList>(TOTAL_RATING_TYPES, RatingList( _presetNames.size(), 3 ));
|
|
_ratingsSums = std::vector<int>(TOTAL_RATING_TYPES, 3 * _presetNames.size());
|
|
|
|
|
|
assert ( _entries.size() == _presetNames.size() );
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
std::auto_ptr<Preset> PresetLoader::loadPreset ( unsigned int index ) const
|
|
{
|
|
|
|
// Check that index isn't insane
|
|
assert ( index >= 0 );
|
|
assert ( index < _entries.size() );
|
|
|
|
// Return a new autopointer to a preset
|
|
const std::string extension = parseExtension ( _entries[index] );
|
|
|
|
return _presetFactoryManager.factory(extension).allocate
|
|
( _entries[index], _presetNames[index] );
|
|
|
|
}
|
|
|
|
|
|
std::auto_ptr<Preset> PresetLoader::loadPreset ( const std::string & url ) const
|
|
{
|
|
|
|
// Return a new autopointer to a preset
|
|
const std::string extension = parseExtension ( url );
|
|
|
|
/// @bug probably should not use url for preset name
|
|
return _presetFactoryManager.factory(extension).allocate
|
|
(url, url);
|
|
|
|
}
|
|
|
|
void PresetLoader::handleDirectoryError()
|
|
{
|
|
|
|
#ifdef WIN32
|
|
std::cerr << "[PresetLoader] warning: errno unsupported on win32 platforms. fix me" << std::endl;
|
|
#else
|
|
|
|
switch ( errno )
|
|
{
|
|
case ENOENT:
|
|
std::cerr << "[PresetLoader] ENOENT error. The path \"" << this->_dirname << "\" probably does not exist. \"man open\" for more info." << std::endl;
|
|
break;
|
|
case ENOMEM:
|
|
std::cerr << "[PresetLoader] out of memory! Are you running Windows?" << std::endl;
|
|
abort();
|
|
case ENOTDIR:
|
|
std::cerr << "[PresetLoader] directory specified is not a preset directory! Trying to continue..." << std::endl;
|
|
break;
|
|
case ENFILE:
|
|
std::cerr << "[PresetLoader] Your system has reached its open file limit. Trying to continue..." << std::endl;
|
|
break;
|
|
case EMFILE:
|
|
std::cerr << "[PresetLoader] too many files in use by projectM! Bailing!" << std::endl;
|
|
break;
|
|
case EACCES:
|
|
std::cerr << "[PresetLoader] permissions issue reading the specified preset directory." << std::endl;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void PresetLoader::setRating(unsigned int index, int rating, const PresetRatingType ratingType)
|
|
{
|
|
assert ( index >=0 );
|
|
|
|
const unsigned int ratingTypeIndex = static_cast<unsigned int>(ratingType);
|
|
assert (index < _ratings[ratingTypeIndex].size());
|
|
|
|
_ratingsSums[ratingTypeIndex] -= _ratings[ratingTypeIndex][index];
|
|
|
|
_ratings[ratingTypeIndex][index] = rating;
|
|
_ratingsSums[ratingType] += rating;
|
|
|
|
}
|
|
|
|
|
|
unsigned int PresetLoader::addPresetURL ( const std::string & url, const std::string & presetName, const std::vector<int> & ratings)
|
|
{
|
|
_entries.push_back(url);
|
|
_presetNames.push_back ( presetName );
|
|
|
|
assert(ratings.size() == TOTAL_RATING_TYPES);
|
|
assert(ratings.size() == _ratings.size());
|
|
|
|
for (int i = 0; i < _ratings.size(); i++)
|
|
_ratings[i].push_back(ratings[i]);
|
|
|
|
for (int i = 0; i < ratings.size(); i++)
|
|
_ratingsSums[i] += ratings[i];
|
|
|
|
return _entries.size()-1;
|
|
}
|
|
|
|
void PresetLoader::removePreset ( unsigned int index )
|
|
{
|
|
|
|
_entries.erase ( _entries.begin() + index );
|
|
_presetNames.erase ( _presetNames.begin() + index );
|
|
|
|
for (int i = 0; i < _ratingsSums.size(); i++) {
|
|
_ratingsSums[i] -= _ratings[i][index];
|
|
_ratings[i].erase ( _ratings[i].begin() + index );
|
|
}
|
|
|
|
|
|
}
|
|
|
|
const std::string & PresetLoader::getPresetURL ( unsigned int index ) const
|
|
{
|
|
return _entries[index];
|
|
}
|
|
|
|
const std::string & PresetLoader::getPresetName ( unsigned int index ) const
|
|
{
|
|
return _presetNames[index];
|
|
}
|
|
|
|
int PresetLoader::getPresetRating ( unsigned int index, const PresetRatingType ratingType ) const
|
|
{
|
|
return _ratings[ratingType][index];
|
|
}
|
|
|
|
const std::vector<RatingList> & PresetLoader::getPresetRatings () const
|
|
{
|
|
return _ratings;
|
|
}
|
|
|
|
const std::vector<int> & PresetLoader::getPresetRatingsSums() const {
|
|
return _ratingsSums;
|
|
}
|
|
|
|
void PresetLoader::setPresetName(unsigned int index, std::string name) {
|
|
_presetNames[index] = name;
|
|
}
|
|
|
|
void PresetLoader::insertPresetURL ( unsigned int index, const std::string & url, const std::string & presetName, const RatingList & ratings)
|
|
{
|
|
_entries.insert ( _entries.begin() + index, url );
|
|
_presetNames.insert ( _presetNames.begin() + index, presetName );
|
|
|
|
|
|
|
|
for (int i = 0; i < _ratingsSums.size();i++) {
|
|
_ratingsSums[i] += _ratings[i][index];
|
|
_ratings[i].insert ( _ratings[i].begin() + index, ratings[i] );
|
|
}
|
|
|
|
assert ( _entries.size() == _presetNames.size() );
|
|
|
|
|
|
}
|