std::unique_ptr<CRepository> CRepository::FromExtension(CAddonInfo addonInfo, const cp_extension_t* ext)
{
DirList dirs;
AddonVersion version("0.0.0");
AddonPtr addonver;
if (CServiceBroker::GetAddonMgr().GetAddon("xbmc.addon", addonver))
version = addonver->Version();
for (size_t i = 0; i < ext->configuration->num_children; ++i)
{
cp_cfg_element_t* element = &ext->configuration->children[i];
if(element->name && strcmp(element->name, "dir") == 0)
{
DirInfo dir = ParseDirConfiguration(element);
if (dir.version <= version)
{
dirs.push_back(std::move(dir));
}
}
}
if (!CServiceBroker::GetAddonMgr().GetExtValue(ext->configuration, "info").empty())
{
dirs.push_back(ParseDirConfiguration(ext->configuration));
}
return std::unique_ptr<CRepository>(new CRepository(std::move(addonInfo), std::move(dirs)));
}
// ------------------------------------------------------------------------------------------------
//
//
void CUI_Savescreen::update()
{
FileList *fl;
DirList *dl;
DriveList *dr;
int key=0;
UI->update();
fl = (FileList *)UI->get_element(0);
dl = (DirList *)UI->get_element(1);
dr = (DriveList *)UI->get_element(2);
if (dl->updated || dr->updated) {
dl->OnChange();
fl->OnChange();
}
if (Keys.size()) {
key = Keys.getkey();
switch(key)
{
case DIK_RETURN:
begin_save();
need_refresh++;
break;
} ;
}
}
void DemoCollection::PopulateList( void ) {
std::string fullPath = std::string( PATH_ROOT ) + ( IsRoot() ? "" : "/" + path );
// populate the list of directories and demo files
demoList.clear();
if( !IsRoot() ) {
// back dir ".."
demoList.push_back( PATH_PARENT );
}
DirList dirList;
dirList.clear();
getFileList( dirList, fullPath, "/", true );
for( DirList::iterator it = dirList.begin(); it != dirList.end(); ++it ) {
std::string fullName = *it + "/";
demoList.push_back( fullName );
}
// populate directories
numDirectories = demoList.size();
getFileList( demoList, fullPath, demoExtension.c_str(), true );
}
static void handleSingleFile(const String &fileName, FileNameHandler &nameHandler) {
DirList list = scandir(fileName,SELECTALLBUTDOT,SORTDIRLASTALPHA);
for(size_t i = 0; i < list.size(); i++) {
DirListEntry &e = list[i];
nameHandler.handleFileName(fileName.cstr(),e);
}
}
bool findDir(DirList::iterator &it, const string &dir)
{
it = dirs.find(dir);
if(it == dirs.end())
return false;
return true;
}
// ------------------------------------------------------------------------------------------------
//
//
void CUI_Loadscreen::enter(void)
{
need_refresh = 1;
is_loading = 0;
cur_state = STATE_LOAD;
FileList *fl;
DirList *dl;
fl = (FileList *)UI->get_element(0);
dl = (DirList *)UI->get_element(1);
dl->OnChange();
fl->OnChange();
if (song->filename[0] && song->filename[0]!=' ') strcpy(load_filename, (const char *)song->filename);
// fl->set_cursor(load_filename);
fl->setCursor(fl->findItem(load_filename));
}
void MiiAllTools::CreateMiiList(std::string devPath)
{
DirList * dirList = new DirList(devPath, ".miigx", DirList::Files);
for(int i = 0; i < dirList->GetFilecount(); i++)
{
std::string miipath = dirList->GetFilepath(i);
miiPath.push_back(miipath);
GetMiiName(miipath);
GetMiiCreator(miipath);
GetMiiInfos(miipath);
}
delete dirList;
}
std::vector<std::string> CSettingsLanguages::LoadLanguages(int *languageSelect)
{
DirList dirList;
std::string appLanguage(CSettings::getValueAsString(CSettings::AppLanguage));
std::vector<std::string> languageName;
//typedef std::map<std::string, std::map<std::string, std::string > > languagesMap;
//languagesMap languagesNames;
enumLanguages.insert(std::pair<int, std::string>(languageName.size(), "default"));
languageName.push_back("Default");
if (appLanguage == "")
*languageSelect = 0;
if(dirList.LoadPath(languagesPath, filter))
{
for(int i = 0; i < dirList.GetFilecount(); i++)
{
std::vector<std::string> languageNameID = stringSplit(dirList.GetFilename(i), ".lang");
std::string languageNameUpper = languageNameID[0];
languageNameUpper[0] = ::toupper( languageNameUpper[0] );
for ( std::string::iterator it = languageNameUpper.begin(); it != languageNameUpper.end(); it++ )
if ( *it == ' ' )
*( it+1 ) = ::toupper( *( it+1 ) );
Languages.push_back ({dirList.GetFilename(i), languageNameID[0], trNOOP(languageNameUpper)});
if (appLanguage == Languages[i].languageID)
*languageSelect = languageName.size();
enumLanguages.insert(std::pair<int, std::string>(languageName.size(), Languages[i].languageID.c_str()));
languageName.push_back(Languages[i].languageName.c_str());
}
}
else
*languageSelect = 0;
return languageName;
}
static void traverseDir(const String &path, FileNameHandler &nameHandler, WildCardRegex *filter, bool recurse) {
DirList list = scandir(FileNameSplitter::getChildName(path,_T("*.*")),SELECTALLBUTDOT,SORTDIRLASTALPHA);
nameHandler.handleStartDir(path.cstr());
for(size_t i = 0; i < list.size(); i++) {
DirListEntry &e = list[i];
if(e.attrib & _A_SUBDIR) {
if(recurse) {
traverseDir(FileNameSplitter::getChildName(path,e.name), nameHandler, filter, recurse);
}
} else {
if(filter && !filter->match(e.name)) {
continue;
}
nameHandler.handleFileName(FileNameSplitter::getChildName(path,e.name).cstr(),e);
}
}
nameHandler.handleEndDir(path.cstr());
}
std::unique_ptr<CRepository> CRepository::FromExtension(CAddonInfo addonInfo, const cp_extension_t* ext)
{
DirList dirs;
AddonVersion version("0.0.0");
AddonPtr addonver;
if (CServiceBroker::GetAddonMgr().GetAddon("xbmc.addon", addonver))
version = addonver->Version();
for (size_t i = 0; i < ext->configuration->num_children; ++i)
{
if(ext->configuration->children[i].name &&
strcmp(ext->configuration->children[i].name, "dir") == 0)
{
AddonVersion min_version(CServiceBroker::GetAddonMgr().GetExtValue(&ext->configuration->children[i], "@minversion"));
if (min_version <= version)
{
DirInfo dir;
dir.version = min_version;
dir.checksum = CServiceBroker::GetAddonMgr().GetExtValue(&ext->configuration->children[i], "checksum");
dir.info = CServiceBroker::GetAddonMgr().GetExtValue(&ext->configuration->children[i], "info");
dir.datadir = CServiceBroker::GetAddonMgr().GetExtValue(&ext->configuration->children[i], "datadir");
dir.hashes = CServiceBroker::GetAddonMgr().GetExtValue(&ext->configuration->children[i], "hashes") == "true";
dirs.push_back(std::move(dir));
}
}
}
if (!CServiceBroker::GetAddonMgr().GetExtValue(ext->configuration, "info").empty())
{
DirInfo info;
info.checksum = CServiceBroker::GetAddonMgr().GetExtValue(ext->configuration, "checksum");
info.info = CServiceBroker::GetAddonMgr().GetExtValue(ext->configuration, "info");
info.datadir = CServiceBroker::GetAddonMgr().GetExtValue(ext->configuration, "datadir");
info.hashes = CServiceBroker::GetAddonMgr().GetExtValue(ext->configuration, "hashes") == "true";
dirs.push_back(std::move(info));
}
return std::unique_ptr<CRepository>(new CRepository(std::move(addonInfo), std::move(dirs)));
}
AttrList::AttrList (PropertyName n) : (n) {
value = nil;
type = nil;
}
boolean AttrList::FindAttr (register PropertyDef& p) {
register AttrList* a;
for (a = (AttrList*)next; a != this; a = (AttrList*)a->next) {
if (a->name == p.name) {
p.type = a->type;
p.value = a->value;
return true;
}
}
return false;
}
/*
* class DirList
*/
DirList::DirList () {
info = nil;
}
DirList::DirList (PropertyName n) : (n) {
info = new PropDir;
}
boolean DirList::FindSubDir (PropertyName n, PropDir*& subdir) {
register DirList* d;
for (d = (DirList*)next; d != this; d = (DirList*)d->next) {
if (d->name == n) {
subdir = d->info;
return true;
}
}
return false;
}
DirList::~DirList () {
delete info;
}
/*
* class PropDir
*/
PropDir::PropDir () {
parent = nil;
attrs = new AttrList;
dirs = new DirList;
vattrs = new AttrList;
vdirs = new DirList;
}
PropDir::~PropDir () {
dirs->DeleteAll();
delete dirs;
vdirs->DeleteAll();
delete vdirs;
attrs->DeleteAll();
delete attrs;
vattrs->DeleteAll();
delete vattrs;
}
PropDir* PropDir::MakeDirs (const char*& name) {
register const char* p;
PropDir* dir;
DirList* cur, * sub;
PropertyName n;
int c;
dir = this;
c = '.';
for (p = name; *p != '\0'; p++) {
if (*p == '.' || *p == '*') {
if (p > name) {
n = nameTable->Id(name, p - name);
cur = (c == '*') ? dir->vdirs : dir->dirs;
if (!cur->FindSubDir(n, dir)) {
sub = new DirList(n);
sub->info->parent = dir;
cur->Append(sub);
dir = sub->info;
}
}
c = *p;
name = p + 1;
}
}
return dir;
}
/*
* class PropPath
*/
PropPath::PropPath () {
top = &element[0];
next = nil;
prev = nil;
}
/*
* class PropertySheet
*/
PropertySheet::PropertySheet () {
cur = new PropDir;
head = new PropPath;
tail = head;
head->element[0].dir = cur;
head->element[0].sibling = false;
if (propvalues == nil) {
propvalues = new StringPool;
}
}
PropertySheet::~PropertySheet () {
register PropPath* p, * pnext;
delete cur;
for (p = head; p != nil; p = pnext) {
pnext = p->next;
delete p;
}
}
boolean PropertySheet::Get (PropertyDef& prop) {
register PropPath* p;
register PropPathElement* i;
/* look for instance.attr */
p = tail;
i = tail->top;
if (i->dir->attrs->FindAttr(prop)) {
return true;
}
/* look for class.attr (if prev path element is class for instance) */
if (i->sibling) {
/* prev path element is class -- look for class.attr */
--i;
if (i < &p->element[0]) {
i = p->prev->top;
}
if (i->dir->attrs->FindAttr(prop)) {
return true;
}
}
/* look for path*attr */
for (p = tail; p != nil; p = p->prev) {
for (i = p->top; i >= &p->element[0]; i--) {
if (i->dir->vattrs->FindAttr(prop)) {
return true;
}
}
}
prop.value = nil;
return false;
}
/*
* Special lookup under current directory for .attr or *attr.
*/
boolean PropertySheet::GetLocal (PropDir* dir, PropertyDef& prop) {
if (dir->attrs->FindAttr(prop) || dir->vattrs->FindAttr(prop)) {
return true;
}
prop.value = nil;
return false;
}
/*
* Add an empty directory to the property sheet.
*/
PropDir* PropertySheet::MakeDir (const char* path) {
const char* name = path;
PropDir* dir = cur;
DirList* d = (name > path && *(name-1) == '*') ? dir->vdirs : dir->dirs;
PropertyName n = nameTable->Id(name);
if (!d->FindSubDir(n, dir)) {
DirList* sub = new DirList(n);
sub->info->parent = dir;
d->Append(sub);
dir = sub->info;
}
return dir;
}
/*
* Put an attribute in the property sheet, starting the path search
* at a given directory (typically the root). If the name is already
* defined and the "override" parameter is false, then do nothing.
*/
void PropertySheet::DoPut (
PropDir* root, const char* path, const char* value, const char* type,
boolean override
) {
const char* name = path;
boolean newvalue = override;
PropDir* dir = root->MakeDirs(name);
AttrList* alist =
(name > path && *(name-1) == '*') ? dir->vattrs : dir->attrs;
PropertyName n = nameTable->Id(name);
register AttrList* a = (AttrList*)alist->Find(n);
if (a == nil) {
a = new AttrList(n);
alist->Append(a);
newvalue = true;
}
if (newvalue) {
register const char* v;
for (v = value; isspace(*v); v++);
a->value = propvalues->Append(v, (int)(strlen(v) + 1));
a->type = type;
}
}
/*
* Look up the path for a subdirectory matching the given name.
*/
PropDir* PropertySheet::Find (PropertyName name) {
register PropPath* p;
register PropPathElement* e;
PropDir* dir;
dir = nil;
/* look for path.name */
if (tail->top->dir->dirs->FindSubDir(name, dir)) {
return dir;
}
/* look for path*name */
for (p = tail; p != nil; p = p->prev) {
for (e = p->top; e >= &p->element[0]; e--) {
if (e->dir->vdirs->FindSubDir(name, dir)) {
return dir;
}
}
}
return nil;
}
void PropertySheet::Push (PropDir* dir, boolean b) {
register PropPath* p;
register PropPathElement* e;
p = tail;
e = p->top + 1;
if (e >= &p->element[pathClusterSize]) {
p = new PropPath;
p->prev = tail;
tail->next = p;
tail = p;
e = p->top;
} else {
p->top = e;
}
e->dir = dir;
e->sibling = b;
}
void PropertySheet::Pop () {
register PropPath* p = tail;
if (p == nil) {
/* ignore underflow */
} else if (p->top > &p->element[0]) {
p->top -= 1;
} else {
tail = p->prev;
tail->next = nil;
delete p;
}
}
PropDir* PropertySheet::Root () {
return cur;
}
static int line; /* for error handling */
/*
* Load a single property from a string containing
* the name and value, terminated by either a newline or null.
*/
class PropSheetBuf {
public:
PropSheetBuf(int);
~PropSheetBuf();
char* data() { return _data; }
private:
char* _data;
char _smallbuf[256];
};
PropSheetBuf::PropSheetBuf(int n) {
_data = (n < sizeof(_smallbuf)) ? _smallbuf : new char[n + 1];
}
PropSheetBuf::~PropSheetBuf() {
if (_data != _smallbuf) {
delete _data;
}
}
void PropertySheet::LoadProperty (const char* s) {
register const char* src;
register char* dst;
const char* value;
for (src = s; *src == ' ' || *src == '\t'; src++);
if (*src == '#' || *src == '\n' || *src == '\0') {
return;
}
PropSheetBuf buf(strlen(src));
dst = buf.data();
value = nil;
for (; *src != '\n' && *src != '\0'; src++) {
if (*src == '\\') {
++src;
if (*src == 'n') {
*dst++ = '\n';
} else if (*src == '\n') {
++line;
} else {
*dst++ = *src;
}
} else if (value == nil && *src == ':') {
if (dst == buf.data()) {
fprintf(stderr, "%d: empty path\n", line);
return;
}
*dst++ = '\0';
value = dst;
} else {
*dst++ = *src;
}
}
*dst = '\0';
if (value == nil) {
fprintf(stderr, "%d: missing value for %s\n", line, buf.data());
return;
}
PutLower(buf.data(), value);
}
/*
* Parse property sheet information from a string.
*/
void PropertySheet::LoadList (const char* data) {
register const char* p, * start;
start = data;
for (p = strchr(data, '\n'); p != nil; p = strchr(p+1, '\n')) {
if (p > start && *(p-1) != '\\') {
LoadProperty(start);
}
start = p+1;
}
}
/*
* Read a property sheet from a file (e.g., Xdefaults).
*/
boolean PropertySheet::LoadFile (const char* filename) {
FILE* f;
char buf[4096];
register int i;
if (filename == nil) {
f = stdin;
} else {
f = fopen(filename, "r");
if (f == nil) {
return false;
}
}
line = 0;
i = 0;
while (fgets(&buf[i], (int)(sizeof(buf) - i), f) != nil) {
i = strlen(buf);
if (buf[i-1] == '\n' && buf[i-2] != '\\') {
LoadProperty(buf);
i = 0;
} else {
if (i == sizeof(buf)) {
fprintf(stderr, "%s: %d: line too long\n", filename, line);
return true;
}
}
}
return true;
}
int WiiSave::Download(std::string ID)
{
if(ID.empty())
return -1;
//! Check Network
if (!IsNetworkInit())
{
ManageProgressStop();
ManageButtons * connect = new ManageButtons(tr("No network connection"),
tr("Do you want to connect?"),
tr("Yes"),
tr("Cancel"));
connect->SetAlignment(ALIGN_CENTRE, ALIGN_MIDDLE);
connect->SetPosition(-6, 75);
connect->SetEffect(EFFECT_FADE, 20);
mainWindow->Append(connect);
ResumeGui();
while (connect->GetEffect()) usleep(50);
while(!connect->GetChoice()) usleep(50);
connect->SetEffect(EFFECT_FADE, -20);
while (connect->GetEffect()) usleep(50);
HaltGui();
mainWindow->Remove(connect);
ResumeGui();
if(connect->GetChoice() == 1)
{
StartManageProgress(tr("Initializing Network"));
Initialize_Network();
ManageProgressStop();
}
delete connect;
if (!IsNetworkInit())
return -2;
StartManageProgress(tr("Downloading saveslist:"), "www.wiisave.com");
}
//! Generate gameUrl
std:: string WiiSaveListURL("http://wiisave.com/savegamecode_xml.php?gamecode=");
WiiSaveListURL += ID.substr(0, 3);
//! Check Connection
if(!CheckConnection(WiiSaveListURL.c_str()))
{
ManageProgressStop();
return -3;
}
//! Check Region
std::string Region;
switch (ID[3])
{
case 'E':
Region = "E - USA / Canada";
break;
case 'J':
Region = "J - Japanese";
break;
case 'W':
Region = "J - Japanese";//Region = "NTSC T";
break;
case 'K':
Region = "J - Japanese";//Region = "NTSC K";
break;
default:
case 'P':
case 'D':
case 'F':
case 'I':
case 'S':
case 'H':
case 'U':
case 'X':
case 'Y':
case 'Z':
Region = "P - European / Other / PAL";
break;
}
//! Get list
WiiSave_List * SaveList = new WiiSave_List(WiiSaveListURL.c_str());
ManageProgressStop();
if (!SaveList->GetCount())
{
delete SaveList;
return -4;
}
if (!SaveList->FilterList(Region))
{
delete SaveList;
return -5;
}
//! open browser & select save
WiiSaveBrowser * SaveBrowser = new WiiSaveBrowser(SaveList);
mainWindow->Append(SaveBrowser);
SaveBrowser->Show();
int selected = SaveBrowser->GetSelectedSave();
delete SaveBrowser;
if (selected < 0)
{
delete SaveList;
return -10;
}
//! select download destination
ManageButtons * path = new ManageButtons(tr("Select a target path."),
tr("Be carrefull, present files can be overwritten"),
tr("OK"));
path->SetAlignment(ALIGN_CENTRE, ALIGN_MIDDLE);
path->SetPosition(-6, 75);
path->SetEffect(EFFECT_FADE, 20);
mainWindow->Append(path);
ResumeGui();
while (path->GetEffect()) usleep(50);
while(!path->GetChoice()) usleep(50);
path->SetEffect(EFFECT_FADE, -20);
while (path->GetEffect()) usleep(50);
HaltGui();
mainWindow->Remove(path);
delete path;
ResumeGui();
if( selectBrowser(Settings.BrowserPath.c_str(), PATH) != 2 )
{
delete SaveList;
return -10;
}
//! download file
std::string filepath = Settings.TmpPath;
filepath += "/";
filepath += SaveList->GetFilteredFilename(selected);
if( WiiSave::InternalDownload(SaveList->GetFilteredDownloadLink(selected), filepath) < 0)
{
delete SaveList;
return -6;
}
delete SaveList;
//! check file type
char destID[5];
std::string srcfilepath;
bool isSgmgxSave = false;
bool isDataBin = false;
std::string tmpDest = filepath.substr(0, filepath.rfind("/")+1);
tmpDest += "tmpExtract";
std::string fileext = filepath.substr(filepath.rfind("."));
if( !Settings.FileExtensions.CompareArchive(fileext.c_str()) ) //! Archive
{
StartManageProgress(tr("Extracting files..."));
//! extract files
ArchiveHandle * Archive = new ArchiveHandle(filepath.c_str());
Archive->ExtractAll(tmpDest.c_str());
delete Archive;
RemoveFile(filepath.c_str());
//! check save type
DirList * dirList = new DirList(tmpDest.c_str(), ".bin" , DirList::Files | DirList::Dirs | DirList::CheckSubfolders);
for(int i = 0; i < dirList->GetFilecount(); i++)
{
if(!strcmp(dirList->GetFilename(i), "banner.bin"))
{
isSgmgxSave = true;
srcfilepath = dirList->GetFilepath(i);
break;
}
std::string name(dirList->GetFilename(i));
fileext = name.substr(name.rfind("."));
if( !Settings.FileExtensions.CompareBinaryFiles(fileext.c_str()) )
{
SaveInfos * infos = GetSaveInfos(dirList->GetFilepath(i));
if(infos)
{
isDataBin = true;
srcfilepath = dirList->GetFilepath(i);
memcpy(destID, infos->ID, 5);
delete infos;
break;
}
}
}
delete dirList;
ManageProgressStop();
}
else //! check for data.bin file
{
StartManageProgress(tr("Verifying file..."));
SaveInfos * infos = GetSaveInfos(filepath);
if(infos)
{
isDataBin = true;
srcfilepath = filepath;
memcpy(destID, infos->ID, 5);
delete infos;
}
ManageProgressStop();
}
if(!isDataBin && !isSgmgxSave) //! supported files not found
{
RemoveFile(filepath.c_str());
RemoveDirectory(tmpDest.c_str());
return -7;
}
//! write files
StartManageProgress(tr("Writing files..."));
if(isSgmgxSave)
{
std::string srcfolder = srcfilepath.substr(0, srcfilepath.rfind("/"));
DirList * dirList = new DirList(srcfolder.c_str(), NULL , DirList::Files | DirList::Dirs);
srcfolder = srcfolder.substr(srcfolder.rfind("/"));
std::string finaldest = Settings.TmpPath;
finaldest += srcfolder;
CreateSubfolder(finaldest.c_str());
for(int i = 0; i < dirList->GetFilecount(); i++)
{
if(IsDir(i))
CopyDirectory(dirList->GetFilepath(i), finaldest.c_str());
else
CopyFile(dirList->GetFilepath(i), fmt("%s/%s", finaldest.c_str(), dirList->GetFilename(i)));
}
delete dirList;
}
else if(isDataBin)
{
std::string finaldest = Settings.TmpPath;
finaldest += "/";
finaldest += destID;
CreateSubfolder(finaldest.c_str());
finaldest += "/data.bin";
CopyFile(srcfilepath.c_str(), finaldest.c_str());
}
RemoveFile(filepath.c_str());
RemoveDirectory(tmpDest.c_str());
ManageProgressStop();
return 1;
}