thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Renamed FilesystemNode -> FSNode

Browse source 
svn-id: r34716
This commit is contained in:
Max Horn 2008-10-02 16:58:59 +00:00
parent 31be8a6b3f
commit c7fde102e3
87 changed files with 435 additions and 434 deletions
Download patch file Download diff file Expand all files Collapse all files

2
backends/fs/abstract-fs.cpp
View file

@ -24,7 +24,7 @@
#include "backends/fs/abstract-fs.h"
const char *AbstractFilesystemNode::lastPathComponent(const Common::String &str, const char sep) {
const char *AbstractFSNode::lastPathComponent(const Common::String &str, const char sep) {
// TODO: Get rid of this eventually! Use Common::lastPathComponent instead
if(str.empty())
return "";

20
backends/fs/abstract-fs.h
View file

@ -29,22 +29,22 @@
#include "common/str.h"
#include "common/fs.h"
class AbstractFilesystemNode;
class AbstractFSNode;
typedef Common::Array<AbstractFilesystemNode *> AbstractFSList;
typedef Common::Array<AbstractFSNode *> AbstractFSList;
/**
* Abstract file system node. Private subclasses implement the actual
* functionality.
*
* Most of the methods correspond directly to methods in class FilesystemNode,
* Most of the methods correspond directly to methods in class FSNode,
* so if they are not documented here, look there for more information about
* the semantics.
*/
class AbstractFilesystemNode {
class AbstractFSNode {
protected:
friend class Common::FilesystemNode;
typedef Common::FilesystemNode::ListMode ListMode;
friend class Common::FSNode;
typedef Common::FSNode::ListMode ListMode;
/**
* Returns the child node with the given name. When called on a non-directory
@ -63,13 +63,13 @@ protected:
*
* @param name String containing the name of the child to create a new node.
*/
virtual AbstractFilesystemNode *getChild(const Common::String &name) const = 0;
virtual AbstractFSNode *getChild(const Common::String &name) const = 0;
/**
* The parent node of this directory.
* The parent of the root is the root itself.
*/
virtual AbstractFilesystemNode *getParent() const = 0;
virtual AbstractFSNode *getParent() const = 0;
/**
* Returns the last component of a given path.
@ -88,7 +88,7 @@ public:
/**
* Destructor.
*/
virtual ~AbstractFilesystemNode() {}
virtual ~AbstractFSNode() {}
/*
* Indicates whether the object referred by this path exists in the filesystem or not.
@ -115,7 +115,7 @@ public:
virtual Common::String getDisplayName() const { return getName(); }
/**
* Returns the last component of the path pointed by this FilesystemNode.
* Returns the last component of the path pointed by this FSNode.
*
* Examples (POSIX):
* /foo/bar.txt would return /bar.txt

6
backends/fs/amigaos4/amigaos4-fs-factory.cpp
View file

@ -26,15 +26,15 @@
#include "backends/fs/amigaos4/amigaos4-fs-factory.h"
#include "backends/fs/amigaos4/amigaos4-fs.cpp"
AbstractFilesystemNode *AmigaOSFilesystemFactory::makeRootFileNode() const {
AbstractFSNode *AmigaOSFilesystemFactory::makeRootFileNode() const {
return new AmigaOSFilesystemNode();
}
AbstractFilesystemNode *AmigaOSFilesystemFactory::makeCurrentDirectoryFileNode() const {
AbstractFSNode *AmigaOSFilesystemFactory::makeCurrentDirectoryFileNode() const {
return new AmigaOSFilesystemNode();
}
AbstractFilesystemNode *AmigaOSFilesystemFactory::makeFileNodePath(const Common::String &path) const {
AbstractFSNode *AmigaOSFilesystemFactory::makeFileNodePath(const Common::String &path) const {
return new AmigaOSFilesystemNode(path);
}
#endif

6
backends/fs/amigaos4/amigaos4-fs-factory.h
View file

@ -34,9 +34,9 @@
*/
class AmigaOSFilesystemFactory : public FilesystemFactory {
public:
virtual AbstractFilesystemNode *makeRootFileNode() const;
virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
virtual AbstractFSNode *makeRootFileNode() const;
virtual AbstractFSNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFSNode *makeFileNodePath(const Common::String &path) const;
};
#endif /*AMIGAOS_FILESYSTEM_FACTORY_H*/

24
backends/fs/amigaos4/amigaos4-fs.cpp
View file

@ -47,9 +47,9 @@ const uint32 kExAllBufferSize = 40960; // TODO: is this okay for sure?
/**
* Implementation of the ScummVM file system API.
*
* Parts of this class are documented in the base interface class, AbstractFilesystemNode.
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class AmigaOSFilesystemNode : public AbstractFilesystemNode {
class AmigaOSFilesystemNode : public AbstractFSNode {
protected:
BPTR _pFileLock;
Common::String _sDisplayName;
@ -58,7 +58,7 @@ protected:
bool _bIsValid;
/**
* Obtain the FileInfoBlock protection value for this FilesystemNode,
* Obtain the FileInfoBlock protection value for this FSNode,
* as defined in the <proto/dos.h> header.
*
* @return -1 if there were errors, 0 or a positive integer otherwise.
@ -103,9 +103,9 @@ public:
virtual bool isReadable() const;
virtual bool isWritable() const;
virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
virtual AbstractFSNode *getChild(const Common::String &n) const;
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
virtual AbstractFilesystemNode *getParent() const;
virtual AbstractFSNode *getParent() const;
virtual Common::SeekableReadStream *openForReading();
virtual Common::WriteStream *openForWriting();
@ -302,7 +302,7 @@ bool AmigaOSFilesystemNode::exists() const {
return nodeExists;
}
AbstractFilesystemNode *AmigaOSFilesystemNode::getChild(const Common::String &n) const {
AbstractFSNode *AmigaOSFilesystemNode::getChild(const Common::String &n) const {
ENTER();
if (!_bIsDirectory) {
debug(6, "Not a directory");
@ -371,9 +371,9 @@ bool AmigaOSFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, b
struct ExAllData *ead = data;
do {
if ((mode == Common::FilesystemNode::kListAll) ||
(EAD_IS_DRAWER(ead) && (mode == Common::FilesystemNode::kListDirectoriesOnly)) ||
(EAD_IS_FILE(ead) && (mode == Common::FilesystemNode::kListFilesOnly))) {
if ((mode == Common::FSNode::kListAll) ||
(EAD_IS_DRAWER(ead) && (mode == Common::FSNode::kListDirectoriesOnly)) ||
(EAD_IS_FILE(ead) && (mode == Common::FSNode::kListFilesOnly))) {
Common::String full_path = _sPath;
full_path += (char*)ead->ed_Name;
@ -381,7 +381,7 @@ bool AmigaOSFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, b
if (lock) {
AmigaOSFilesystemNode *entry = new AmigaOSFilesystemNode(lock, (char *)ead->ed_Name);
if (entry) {
//FIXME: since the isValid() function is no longer part of the AbstractFilesystemNode
//FIXME: since the isValid() function is no longer part of the AbstractFSNode
// specification, the following call had to be changed:
// if (entry->isValid())
// Please verify that the logic of the code remains coherent. Also, remember
@ -433,7 +433,7 @@ int AmigaOSFilesystemNode::getFibProtection() const {
return fibProt;
}
AbstractFilesystemNode *AmigaOSFilesystemNode::getParent() const {
AbstractFSNode *AmigaOSFilesystemNode::getParent() const {
ENTER();
if (!_bIsDirectory) {
@ -543,7 +543,7 @@ AbstractFSList AmigaOSFilesystemNode::listVolumes() const {
AmigaOSFilesystemNode *entry = new AmigaOSFilesystemNode(volumeLock, buffer);
if (entry) {
//FIXME: since the isValid() function is no longer part of the AbstractFilesystemNode
//FIXME: since the isValid() function is no longer part of the AbstractFSNode
// specification, the following call had to be changed:
// if (entry->isValid())
// Please verify that the logic of the code remains coherent. Also, remember

6
backends/fs/ds/ds-fs-factory.cpp
View file

@ -29,7 +29,7 @@
DECLARE_SINGLETON(DSFilesystemFactory);
AbstractFilesystemNode *DSFilesystemFactory::makeRootFileNode() const {
AbstractFSNode *DSFilesystemFactory::makeRootFileNode() const {
if (DS::isGBAMPAvailable()) {
return new DS::GBAMPFileSystemNode();
} else {
@ -37,7 +37,7 @@ AbstractFilesystemNode *DSFilesystemFactory::makeRootFileNode() const {
}
}
AbstractFilesystemNode *DSFilesystemFactory::makeCurrentDirectoryFileNode() const {
AbstractFSNode *DSFilesystemFactory::makeCurrentDirectoryFileNode() const {
if (DS::isGBAMPAvailable()) {
return new DS::GBAMPFileSystemNode();
} else {
@ -45,7 +45,7 @@ AbstractFilesystemNode *DSFilesystemFactory::makeCurrentDirectoryFileNode() cons
}
}
AbstractFilesystemNode *DSFilesystemFactory::makeFileNodePath(const Common::String &path) const {
AbstractFSNode *DSFilesystemFactory::makeFileNodePath(const Common::String &path) const {
if (DS::isGBAMPAvailable()) {
return new DS::GBAMPFileSystemNode(path);
} else {

6
backends/fs/ds/ds-fs-factory.h
View file

@ -35,9 +35,9 @@
*/
class DSFilesystemFactory : public FilesystemFactory, public Common::Singleton<DSFilesystemFactory> {
public:
virtual AbstractFilesystemNode *makeRootFileNode() const;
virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
virtual AbstractFSNode *makeRootFileNode() const;
virtual AbstractFSNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFSNode *makeFileNodePath(const Common::String &path) const;
protected:
DSFilesystemFactory() {};

16
backends/fs/ds/ds-fs.cpp
View file

@ -125,7 +125,7 @@ DSFileSystemNode::DSFileSystemNode(const DSFileSystemNode* node) {
//TODO: not implemented?
}
AbstractFilesystemNode *DSFileSystemNode::getChild(const Common::String& n) const {
AbstractFSNode *DSFileSystemNode::getChild(const Common::String& n) const {
if (_path.lastChar() == '\\') {
return new DSFileSystemNode(_path + n);
} else {
@ -168,8 +168,8 @@ bool DSFileSystemNode::getChildren(AbstractFSList &dirList, ListMode mode, bool
_zipFile->getFileName(n);
// consolePrintf("file: %s\n", n);
if ( (_zipFile->isDirectory() && ((mode == Common::FilesystemNode::kListDirectoriesOnly) || (mode == Common::FilesystemNode::kListAll)) )
|| (!_zipFile->isDirectory() && ((mode == Common::FilesystemNode::kListFilesOnly) || (mode == Common::FilesystemNode::kListAll)) ) )
if ( (_zipFile->isDirectory() && ((mode == Common::FSNode::kListDirectoriesOnly) || (mode == Common::FSNode::kListAll)) )
|| (!_zipFile->isDirectory() && ((mode == Common::FSNode::kListFilesOnly) || (mode == Common::FSNode::kListAll)) ) )
{
DSFileSystemNode* dsfsn = new DSFileSystemNode("ds:/" + Common::String(n), _zipFile->isDirectory());
dsfsn->_isDirectory = _zipFile->isDirectory();
@ -182,7 +182,7 @@ bool DSFileSystemNode::getChildren(AbstractFSList &dirList, ListMode mode, bool
return true;
}
AbstractFilesystemNode* DSFileSystemNode::getParent() const {
AbstractFSNode* DSFileSystemNode::getParent() const {
// consolePrintf("parent\n");
DSFileSystemNode *p;
@ -285,7 +285,7 @@ GBAMPFileSystemNode::GBAMPFileSystemNode(const GBAMPFileSystemNode* node) {
//TODO: not implemented?
}
AbstractFilesystemNode *GBAMPFileSystemNode::getChild(const Common::String& n) const {
AbstractFSNode *GBAMPFileSystemNode::getChild(const Common::String& n) const {
if (_path.lastChar() == '\\') {
return new DSFileSystemNode(_path + n);
} else {
@ -322,8 +322,8 @@ bool GBAMPFileSystemNode::getChildren(AbstractFSList& dirList, ListMode mode, bo
while (entryType != TYPE_NO_MORE) {
if ( ((entryType == TYPE_DIR) && ((mode == Common::FilesystemNode::kListDirectoriesOnly) || (mode == Common::FilesystemNode::kListAll)))
|| ((entryType == TYPE_FILE) && ((mode == Common::FilesystemNode::kListFilesOnly) || (mode == Common::FilesystemNode::kListAll))) ) {
if ( ((entryType == TYPE_DIR) && ((mode == Common::FSNode::kListDirectoriesOnly) || (mode == Common::FSNode::kListAll)))
|| ((entryType == TYPE_FILE) && ((mode == Common::FSNode::kListFilesOnly) || (mode == Common::FSNode::kListAll))) ) {
GBAMPFileSystemNode* dsfsn;
consolePrintf("Fname: %s\n", fname);
@ -353,7 +353,7 @@ bool GBAMPFileSystemNode::getChildren(AbstractFSList& dirList, ListMode mode, bo
return true;
}
AbstractFilesystemNode* GBAMPFileSystemNode::getParent() const {
AbstractFSNode* GBAMPFileSystemNode::getParent() const {
// consolePrintf("parent\n");
GBAMPFileSystemNode *p;

20
backends/fs/ds/ds-fs.h
View file

@ -37,9 +37,9 @@ namespace DS {
* Implementation of the ScummVM file system API.
* This class is used when a Flash cart is in use.
*
* Parts of this class are documented in the base interface class, AbstractFilesystemNode.
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class DSFileSystemNode : public AbstractFilesystemNode {
class DSFileSystemNode : public AbstractFSNode {
protected:
static ZipFile* _zipFile;
@ -85,10 +85,10 @@ public:
/**
* Returns a copy of this node.
*/
virtual AbstractFilesystemNode *clone() const { return new DSFileSystemNode(this); }
virtual AbstractFilesystemNode *getChild(const Common::String& name) const;
virtual AbstractFSNode *clone() const { return new DSFileSystemNode(this); }
virtual AbstractFSNode *getChild(const Common::String& name) const;
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
virtual AbstractFilesystemNode *getParent() const;
virtual AbstractFSNode *getParent() const;
virtual Common::SeekableReadStream *openForReading();
virtual Common::WriteStream *openForWriting();
@ -104,9 +104,9 @@ public:
* Implementation of the ScummVM file system API.
* This class is used when the GBAMP (GBA Movie Player) is used with a CompactFlash card.
*
* Parts of this class are documented in the base interface class, AbstractFilesystemNode.
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class GBAMPFileSystemNode : public AbstractFilesystemNode {
class GBAMPFileSystemNode : public AbstractFSNode {
protected:
Common::String _displayName;
Common::String _path;
@ -150,10 +150,10 @@ public:
/**
* Returns a copy of this node.
*/
virtual AbstractFilesystemNode *clone() const { return new GBAMPFileSystemNode(this); }
virtual AbstractFilesystemNode *getChild(const Common::String& name) const;
virtual AbstractFSNode *clone() const { return new GBAMPFileSystemNode(this); }
virtual AbstractFSNode *getChild(const Common::String& name) const;
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
virtual AbstractFilesystemNode *getParent() const;
virtual AbstractFSNode *getParent() const;
virtual Common::SeekableReadStream *openForReading();
virtual Common::WriteStream *openForWriting();

10
backends/fs/fs-factory.h
View file

@ -29,7 +29,7 @@
#include "backends/fs/abstract-fs.h"
/**
* Creates concrete FilesystemNode objects depending on the current architecture.
* Creates concrete FSNode objects depending on the current architecture.
*/
class FilesystemFactory {
public:
@ -44,7 +44,7 @@ public:
* emulate it or simply return some "sensible" default directory node,
* e.g. the same value as getRoot() returns.
*/
virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const = 0;
virtual AbstractFSNode *makeCurrentDirectoryFileNode() const = 0;
/**
* Construct a node based on a path; the path is in the same format as it
@ -54,9 +54,9 @@ public:
* identical to oldNode. Hence, we can use the "path" value for persistent
* storage e.g. in the config file.
*
* @param path The path string to create a FilesystemNode for.
* @param path The path string to create a FSNode for.
*/
virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const = 0;
virtual AbstractFSNode *makeFileNodePath(const Common::String &path) const = 0;
/**
* Returns a special node representing the filesystem root.
@ -65,7 +65,7 @@ public:
* On Unix, this will be simply the node for / (the root directory).
* On Windows, it will be a special node which "contains" all drives (C:, D:, E:).
*/
virtual AbstractFilesystemNode *makeRootFileNode() const = 0;
virtual AbstractFSNode *makeRootFileNode() const = 0;
};
#endif /*FILESYSTEM_FACTORY_H*/

6
backends/fs/palmos/palmos-fs-factory.cpp
View file

@ -28,15 +28,15 @@
DECLARE_SINGLETON(PalmOSFilesystemFactory);
AbstractFilesystemNode *PalmOSFilesystemFactory::makeRootFileNode() const {
AbstractFSNode *PalmOSFilesystemFactory::makeRootFileNode() const {
return new PalmOSFilesystemNode();
}
AbstractFilesystemNode *PalmOSFilesystemFactory::makeCurrentDirectoryFileNode() const {
AbstractFSNode *PalmOSFilesystemFactory::makeCurrentDirectoryFileNode() const {
return new PalmOSFilesystemNode();
}
AbstractFilesystemNode *PalmOSFilesystemFactory::makeFileNodePath(const Common::String &path) const {
AbstractFSNode *PalmOSFilesystemFactory::makeFileNodePath(const Common::String &path) const {
return new PalmOSFilesystemNode(path);
}
#endif

6
backends/fs/palmos/palmos-fs-factory.h
View file

@ -35,9 +35,9 @@
*/
class PalmOSFilesystemFactory : public FilesystemFactory, public Common::Singleton<PalmOSFilesystemFactory> {
public:
virtual AbstractFilesystemNode *makeRootFileNode() const;
virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
virtual AbstractFSNode *makeRootFileNode() const;
virtual AbstractFSNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFSNode *makeFileNodePath(const Common::String &path) const;
protected:
PalmOSFilesystemFactory() {};

16
backends/fs/palmos/palmos-fs.cpp
View file

@ -33,9 +33,9 @@
/**
* Implementation of the ScummVM file system API based on PalmOS VFS API.
*
* Parts of this class are documented in the base interface class, AbstractFilesystemNode.
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class PalmOSFilesystemNode : public AbstractFilesystemNode {
class PalmOSFilesystemNode : public AbstractFSNode {
protected:
Common::String _displayName;
Common::String _path;
@ -64,9 +64,9 @@ public:
virtual bool isReadable() const { return true; } //FIXME: this is just a stub
virtual bool isWritable() const { return true; } //FIXME: this is just a stub
virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
virtual AbstractFSNode *getChild(const Common::String &n) const;
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
virtual AbstractFilesystemNode *getParent() const;
virtual AbstractFSNode *getParent() const;
virtual Common::SeekableReadStream *openForReading();
virtual Common::WriteStream *openForWriting();
@ -90,8 +90,8 @@ void PalmOSFilesystemNode::addFile(AbstractFSList &list, ListMode mode, const ch
isDir = (find_data->attributes & vfsFileAttrDirectory);
if ((!isDir && mode == Common::FilesystemNode::kListDirectoriesOnly) ||
(isDir && mode == Common::FilesystemNode::kListFilesOnly))
if ((!isDir && mode == Common::FSNode::kListDirectoriesOnly) ||
(isDir && mode == Common::FSNode::kListFilesOnly))
return;
entry._isDirectory = isDir;
@ -139,7 +139,7 @@ PalmOSFilesystemNode::PalmOSFilesystemNode(const Common::String &p) {
_isPseudoRoot = false;
}
AbstractFilesystemNode *PalmOSFilesystemNode::getChild(const Common::String &n) const {
AbstractFSNode *PalmOSFilesystemNode::getChild(const Common::String &n) const {
assert(_isDirectory);
Common::String newPath(_path);
@ -190,7 +190,7 @@ bool PalmOSFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bo
return true;
}
AbstractFilesystemNode *PalmOSFilesystemNode::getParent() const {
AbstractFSNode *PalmOSFilesystemNode::getParent() const {
PalmOSFilesystemNode *p = 0;
if (!_isPseudoRoot) {

6
backends/fs/posix/posix-fs-factory.cpp
View file

@ -26,17 +26,17 @@
#include "backends/fs/posix/posix-fs-factory.h"
#include "backends/fs/posix/posix-fs.cpp"
AbstractFilesystemNode *POSIXFilesystemFactory::makeRootFileNode() const {
AbstractFSNode *POSIXFilesystemFactory::makeRootFileNode() const {
return new POSIXFilesystemNode("/");
}
AbstractFilesystemNode *POSIXFilesystemFactory::makeCurrentDirectoryFileNode() const {
AbstractFSNode *POSIXFilesystemFactory::makeCurrentDirectoryFileNode() const {
char buf[MAXPATHLEN];
getcwd(buf, MAXPATHLEN);
return new POSIXFilesystemNode(buf);
}
AbstractFilesystemNode *POSIXFilesystemFactory::makeFileNodePath(const Common::String &path) const {
AbstractFSNode *POSIXFilesystemFactory::makeFileNodePath(const Common::String &path) const {
assert(!path.empty());
return new POSIXFilesystemNode(path);
}

6
backends/fs/posix/posix-fs-factory.h
View file

@ -33,9 +33,9 @@
* Parts of this class are documented in the base interface class, FilesystemFactory.
*/
class POSIXFilesystemFactory : public FilesystemFactory {
virtual AbstractFilesystemNode *makeRootFileNode() const;
virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
virtual AbstractFSNode *makeRootFileNode() const;
virtual AbstractFSNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFSNode *makeFileNodePath(const Common::String &path) const;
};
#endif /*POSIX_FILESYSTEM_FACTORY_H*/

8
backends/fs/posix/posix-fs.cpp
View file

@ -92,7 +92,7 @@ POSIXFilesystemNode::POSIXFilesystemNode(const Common::String &p) {
setFlags();
}
AbstractFilesystemNode *POSIXFilesystemNode::getChild(const Common::String &n) const {
AbstractFSNode *POSIXFilesystemNode::getChild(const Common::String &n) const {
assert(!_path.empty());
assert(_isDirectory);
@ -197,8 +197,8 @@ bool POSIXFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, boo
continue;
// Honor the chosen mode
if ((mode == Common::FilesystemNode::kListFilesOnly && entry._isDirectory) ||
(mode == Common::FilesystemNode::kListDirectoriesOnly && !entry._isDirectory))
if ((mode == Common::FSNode::kListFilesOnly && entry._isDirectory) ||
(mode == Common::FSNode::kListDirectoriesOnly && !entry._isDirectory))
continue;
myList.push_back(new POSIXFilesystemNode(entry));
@ -208,7 +208,7 @@ bool POSIXFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, boo
return true;
}
AbstractFilesystemNode *POSIXFilesystemNode::getParent() const {
AbstractFSNode *POSIXFilesystemNode::getParent() const {
if (_path == "/")
return 0; // The filesystem root has no parent

10
backends/fs/posix/posix-fs.h
View file

@ -35,16 +35,16 @@
/**
* Implementation of the ScummVM file system API based on POSIX.
*
* Parts of this class are documented in the base interface class, AbstractFilesystemNode.
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class POSIXFilesystemNode : public AbstractFilesystemNode {
class POSIXFilesystemNode : public AbstractFSNode {
protected:
Common::String _displayName;
Common::String _path;
bool _isDirectory;
bool _isValid;
virtual AbstractFilesystemNode *makeNode(const Common::String &path) const {
virtual AbstractFSNode *makeNode(const Common::String &path) const {
return new POSIXFilesystemNode(path);
}
@ -69,9 +69,9 @@ public:
virtual bool isReadable() const { return access(_path.c_str(), R_OK) == 0; }
virtual bool isWritable() const { return access(_path.c_str(), W_OK) == 0; }
virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
virtual AbstractFSNode *getChild(const Common::String &n) const;
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
virtual AbstractFilesystemNode *getParent() const;
virtual AbstractFSNode *getParent() const;
virtual Common::SeekableReadStream *openForReading();
virtual Common::WriteStream *openForWriting();

6
backends/fs/ps2/ps2-fs-factory.cpp
View file

@ -28,15 +28,15 @@
DECLARE_SINGLETON(Ps2FilesystemFactory);
AbstractFilesystemNode *Ps2FilesystemFactory::makeRootFileNode() const {
AbstractFSNode *Ps2FilesystemFactory::makeRootFileNode() const {
return new Ps2FilesystemNode();
}
AbstractFilesystemNode *Ps2FilesystemFactory::makeCurrentDirectoryFileNode() const {
AbstractFSNode *Ps2FilesystemFactory::makeCurrentDirectoryFileNode() const {
return new Ps2FilesystemNode();
}
AbstractFilesystemNode *Ps2FilesystemFactory::makeFileNodePath(const Common::String &path) const {
AbstractFSNode *Ps2FilesystemFactory::makeFileNodePath(const Common::String &path) const {
// return new Ps2FilesystemNode(path);
Ps2FilesystemNode *nf = new Ps2FilesystemNode(path, true);

6
backends/fs/ps2/ps2-fs-factory.h
View file

@ -35,9 +35,9 @@
*/
class Ps2FilesystemFactory : public FilesystemFactory, public Common::Singleton<Ps2FilesystemFactory> {
public:
virtual AbstractFilesystemNode *makeRootFileNode() const;
virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
virtual AbstractFSNode *makeRootFileNode() const;
virtual AbstractFSNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFSNode *makeFileNodePath(const Common::String &path) const;
protected:
Ps2FilesystemFactory() {};

20
backends/fs/ps2/ps2-fs.cpp
View file

@ -41,9 +41,9 @@ extern OSystem_PS2 *g_systemPs2;
/**
* Implementation of the ScummVM file system API based on the Ps2SDK.
*
* Parts of this class are documented in the base interface class, AbstractFilesystemNode.
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class Ps2FilesystemNode : public AbstractFilesystemNode {
class Ps2FilesystemNode : public AbstractFSNode {
friend class Ps2FilesystemFactory;
@ -95,10 +95,10 @@ public:
return false;
}
virtual AbstractFilesystemNode *clone() const { return new Ps2FilesystemNode(this); }
virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
virtual AbstractFSNode *clone() const { return new Ps2FilesystemNode(this); }
virtual AbstractFSNode *getChild(const Common::String &n) const;
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
virtual AbstractFilesystemNode *getParent() const;
virtual AbstractFSNode *getParent() const;
virtual Common::SeekableReadStream *openForReading();
virtual Common::WriteStream *openForWriting();
@ -210,7 +210,7 @@ bool Ps2FilesystemNode::getDirectoryFlag(const char *path) {
return false;
}
AbstractFilesystemNode *Ps2FilesystemNode::getChild(const Common::String &n) const {
AbstractFSNode *Ps2FilesystemNode::getChild(const Common::String &n) const {
if (!_isDirectory)
return NULL;
@ -288,9 +288,9 @@ bool Ps2FilesystemNode::getChildren(AbstractFSList &list, ListMode mode, bool hi
while ((dreadRes = fio.dread(fd, &dirent)) > 0) {
if (dirent.name[0] == '.')
continue; // ignore '.' and '..'
if (((mode == Common::FilesystemNode::kListDirectoriesOnly) && (dirent.stat.mode & FIO_S_IFDIR)) ||
((mode == Common::FilesystemNode::kListFilesOnly) && !(dirent.stat.mode & FIO_S_IFDIR)) ||
(mode == Common::FilesystemNode::kListAll)) {
if (((mode == Common::FSNode::kListDirectoriesOnly) && (dirent.stat.mode & FIO_S_IFDIR)) ||
((mode == Common::FSNode::kListFilesOnly) && !(dirent.stat.mode & FIO_S_IFDIR)) ||
(mode == Common::FSNode::kListAll)) {
dirEntry._isDirectory = (bool)(dirent.stat.mode & FIO_S_IFDIR);
dirEntry._isRoot = false;
@ -312,7 +312,7 @@ bool Ps2FilesystemNode::getChildren(AbstractFSList &list, ListMode mode, bool hi
}
}
AbstractFilesystemNode *Ps2FilesystemNode::getParent() const {
AbstractFSNode *Ps2FilesystemNode::getParent() const {
if (_isRoot)
return new Ps2FilesystemNode(this);

6
backends/fs/psp/psp-fs-factory.cpp
View file

@ -28,15 +28,15 @@
DECLARE_SINGLETON(PSPFilesystemFactory);
AbstractFilesystemNode *PSPFilesystemFactory::makeRootFileNode() const {
AbstractFSNode *PSPFilesystemFactory::makeRootFileNode() const {
return new PSPFilesystemNode();
}
AbstractFilesystemNode *PSPFilesystemFactory::makeCurrentDirectoryFileNode() const {
AbstractFSNode *PSPFilesystemFactory::makeCurrentDirectoryFileNode() const {
return new PSPFilesystemNode();
}
AbstractFilesystemNode *PSPFilesystemFactory::makeFileNodePath(const Common::String &path) const {
AbstractFSNode *PSPFilesystemFactory::makeFileNodePath(const Common::String &path) const {
return new PSPFilesystemNode(path, true);
}
#endif

6
backends/fs/psp/psp-fs-factory.h
View file

@ -35,9 +35,9 @@
*/
class PSPFilesystemFactory : public FilesystemFactory, public Common::Singleton<PSPFilesystemFactory> {
public:
virtual AbstractFilesystemNode *makeRootFileNode() const;
virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
virtual AbstractFSNode *makeRootFileNode() const;
virtual AbstractFSNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFSNode *makeFileNodePath(const Common::String &path) const;
protected:
PSPFilesystemFactory() {};

16
backends/fs/psp/psp-fs.cpp
View file

@ -36,9 +36,9 @@
/**
* Implementation of the ScummVM file system API based on PSPSDK API.
*
* Parts of this class are documented in the base interface class, AbstractFilesystemNode.
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class PSPFilesystemNode : public AbstractFilesystemNode {
class PSPFilesystemNode : public AbstractFSNode {
protected:
Common::String _displayName;
Common::String _path;
@ -67,9 +67,9 @@ public:
virtual bool isReadable() const { return access(_path.c_str(), R_OK) == 0; }
virtual bool isWritable() const { return access(_path.c_str(), W_OK) == 0; }
virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
virtual AbstractFSNode *getChild(const Common::String &n) const;
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
virtual AbstractFilesystemNode *getParent() const;
virtual AbstractFSNode *getParent() const;
virtual Common::SeekableReadStream *openForReading();
virtual Common::WriteStream *openForWriting();
@ -97,7 +97,7 @@ PSPFilesystemNode::PSPFilesystemNode(const Common::String &p, bool verify) {
}
}
AbstractFilesystemNode *PSPFilesystemNode::getChild(const Common::String &n) const {
AbstractFSNode *PSPFilesystemNode::getChild(const Common::String &n) const {
// FIXME: Pretty lame implementation! We do no error checking to speak
// of, do not check if this is a special node, etc.
assert(_isDirectory);
@ -137,8 +137,8 @@ bool PSPFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool
entry._path += "/";
// Honor the chosen mode
if ((mode == Common::FilesystemNode::kListFilesOnly && entry._isDirectory) ||
(mode == Common::FilesystemNode::kListDirectoriesOnly && !entry._isDirectory))
if ((mode == Common::FSNode::kListFilesOnly && entry._isDirectory) ||
(mode == Common::FSNode::kListDirectoriesOnly && !entry._isDirectory))
continue;
myList.push_back(new PSPFilesystemNode(entry));
@ -151,7 +151,7 @@ bool PSPFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool
}
}
AbstractFilesystemNode *PSPFilesystemNode::getParent() const {
AbstractFSNode *PSPFilesystemNode::getParent() const {
if (_path == ROOT_PATH)
return 0;

6
backends/fs/symbian/symbian-fs-factory.cpp
View file

@ -26,17 +26,17 @@
#include "backends/fs/symbian/symbian-fs-factory.h"
#include "backends/fs/symbian/symbian-fs.cpp"
AbstractFilesystemNode *SymbianFilesystemFactory::makeRootFileNode() const {
AbstractFSNode *SymbianFilesystemFactory::makeRootFileNode() const {
return new SymbianFilesystemNode(true);
}
AbstractFilesystemNode *SymbianFilesystemFactory::makeCurrentDirectoryFileNode() const {
AbstractFSNode *SymbianFilesystemFactory::makeCurrentDirectoryFileNode() const {
char path[MAXPATHLEN];
getcwd(path, MAXPATHLEN);
return new SymbianFilesystemNode(path);
}
AbstractFilesystemNode *SymbianFilesystemFactory::makeFileNodePath(const Common::String &path) const {
AbstractFSNode *SymbianFilesystemFactory::makeFileNodePath(const Common::String &path) const {
return new SymbianFilesystemNode(path);
}
#endif

6
backends/fs/symbian/symbian-fs-factory.h
View file

@ -34,9 +34,9 @@
*/
class SymbianFilesystemFactory : public FilesystemFactory {
public:
virtual AbstractFilesystemNode *makeRootFileNode() const;
virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
virtual AbstractFSNode *makeRootFileNode() const;
virtual AbstractFSNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFSNode *makeFileNodePath(const Common::String &path) const;
};
#endif /*SYMBIAN_FILESYSTEM_FACTORY_H*/

16
backends/fs/symbian/symbian-fs.cpp
View file

@ -37,9 +37,9 @@
/**
* Implementation of the ScummVM file system API based on POSIX.
*
* Parts of this class are documented in the base interface class, AbstractFilesystemNode.
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class SymbianFilesystemNode : public AbstractFilesystemNode {
class SymbianFilesystemNode : public AbstractFSNode {
protected:
Common::String _displayName;
Common::String _path;
@ -75,9 +75,9 @@ public:
virtual bool isReadable() const { return access(_path.c_str(), R_OK) == 0; } //FIXME: this is just a stub
virtual bool isWritable() const { return access(_path.c_str(), W_OK) == 0; } //FIXME: this is just a stub
virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
virtual AbstractFSNode *getChild(const Common::String &n) const;
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
virtual AbstractFilesystemNode *getParent() const;
virtual AbstractFSNode *getParent() const;
virtual Common::SeekableReadStream *openForReading();
virtual Common::WriteStream *openForWriting();
@ -133,7 +133,7 @@ SymbianFilesystemNode::SymbianFilesystemNode(const Common::String &path) {
}
}
AbstractFilesystemNode *SymbianFilesystemNode::getChild(const Common::String &n) const {
AbstractFSNode *SymbianFilesystemNode::getChild(const Common::String &n) const {
assert(_isDirectory);
Common::String newPath(_path);
@ -216,8 +216,8 @@ bool SymbianFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, b
entry._isDirectory = fileentry.IsDir();
// Honor the chosen mode
if ((mode == Common::FilesystemNode::kListFilesOnly && entry._isDirectory) ||
(mode == Common::FilesystemNode::kListDirectoriesOnly && !entry._isDirectory))
if ((mode == Common::FSNode::kListFilesOnly && entry._isDirectory) ||
(mode == Common::FSNode::kListDirectoriesOnly && !entry._isDirectory))
continue;
myList.push_back(new SymbianFilesystemNode(entry));
@ -229,7 +229,7 @@ bool SymbianFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, b
return true;
}
AbstractFilesystemNode *SymbianFilesystemNode::getParent() const {
AbstractFSNode *SymbianFilesystemNode::getParent() const {
SymbianFilesystemNode *p =NULL;
// Root node is its own parent. Still we can't just return this

6
backends/fs/wii/wii-fs-factory.cpp
View file

@ -29,11 +29,11 @@
DECLARE_SINGLETON(WiiFilesystemFactory);
AbstractFilesystemNode *WiiFilesystemFactory::makeRootFileNode() const {
AbstractFSNode *WiiFilesystemFactory::makeRootFileNode() const {
return new WiiFilesystemNode();
}
AbstractFilesystemNode *WiiFilesystemFactory::makeCurrentDirectoryFileNode() const {
AbstractFSNode *WiiFilesystemFactory::makeCurrentDirectoryFileNode() const {
char buf[MAXPATHLEN];
if (getcwd(buf, MAXPATHLEN))
@ -42,7 +42,7 @@ AbstractFilesystemNode *WiiFilesystemFactory::makeCurrentDirectoryFileNode() con
return new WiiFilesystemNode();
}
AbstractFilesystemNode *WiiFilesystemFactory::makeFileNodePath(const Common::String &path) const {
AbstractFSNode *WiiFilesystemFactory::makeFileNodePath(const Common::String &path) const {
return new WiiFilesystemNode(path, true);
}
#endif

6
backends/fs/wii/wii-fs-factory.h
View file

@ -33,9 +33,9 @@
*/
class WiiFilesystemFactory : public FilesystemFactory, public Common::Singleton<WiiFilesystemFactory> {
public:
virtual AbstractFilesystemNode *makeRootFileNode() const;
virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
virtual AbstractFSNode *makeRootFileNode() const;
virtual AbstractFSNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFSNode *makeFileNodePath(const Common::String &path) const;
protected:
WiiFilesystemFactory() {};

16
backends/fs/wii/wii-fs.cpp
View file

@ -34,9 +34,9 @@
/**
* Implementation of the ScummVM file system API based on Wii.
*
* Parts of this class are documented in the base interface class, AbstractFilesystemNode.
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class WiiFilesystemNode : public AbstractFilesystemNode {
class WiiFilesystemNode : public AbstractFSNode {
protected:
Common::String _displayName;
Common::String _path;
@ -64,9 +64,9 @@ public:
virtual bool isReadable() const { return _isReadable; }
virtual bool isWritable() const { return _isWritable; }
virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
virtual AbstractFSNode *getChild(const Common::String &n) const;
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
virtual AbstractFilesystemNode *getParent() const;
virtual AbstractFSNode *getParent() const;
virtual Common::SeekableReadStream *openForReading();
virtual Common::WriteStream *openForWriting();
@ -114,7 +114,7 @@ bool WiiFilesystemNode::exists() const {
return stat(_path.c_str (), &st) == 0;
}
AbstractFilesystemNode *WiiFilesystemNode::getChild(const Common::String &n) const {
AbstractFSNode *WiiFilesystemNode::getChild(const Common::String &n) const {
assert(_isDirectory);
Common::String newPath(_path);
@ -147,8 +147,8 @@ bool WiiFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool
bool isDir = S_ISDIR(st.st_mode);
if ((mode == Common::FilesystemNode::kListFilesOnly && isDir) ||
(mode == Common::FilesystemNode::kListDirectoriesOnly && !isDir))
if ((mode == Common::FSNode::kListFilesOnly && isDir) ||
(mode == Common::FSNode::kListDirectoriesOnly && !isDir))
continue;
if (isDir)
@ -162,7 +162,7 @@ bool WiiFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, bool
return true;
}
AbstractFilesystemNode *WiiFilesystemNode::getParent() const {
AbstractFSNode *WiiFilesystemNode::getParent() const {
if (_path == "/")
return 0;

6
backends/fs/windows/windows-fs-factory.cpp
View file

@ -26,15 +26,15 @@
#include "backends/fs/windows/windows-fs-factory.h"
#include "backends/fs/windows/windows-fs.cpp"
AbstractFilesystemNode *WindowsFilesystemFactory::makeRootFileNode() const {
AbstractFSNode *WindowsFilesystemFactory::makeRootFileNode() const {
return new WindowsFilesystemNode();
}
AbstractFilesystemNode *WindowsFilesystemFactory::makeCurrentDirectoryFileNode() const {
AbstractFSNode *WindowsFilesystemFactory::makeCurrentDirectoryFileNode() const {
return new WindowsFilesystemNode("", true);
}
AbstractFilesystemNode *WindowsFilesystemFactory::makeFileNodePath(const Common::String &path) const {
AbstractFSNode *WindowsFilesystemFactory::makeFileNodePath(const Common::String &path) const {
return new WindowsFilesystemNode(path, false);
}
#endif

6
backends/fs/windows/windows-fs-factory.h
View file

@ -34,9 +34,9 @@
*/
class WindowsFilesystemFactory : public FilesystemFactory {
public:
virtual AbstractFilesystemNode *makeRootFileNode() const;
virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
virtual AbstractFSNode *makeRootFileNode() const;
virtual AbstractFSNode *makeCurrentDirectoryFileNode() const;
virtual AbstractFSNode *makeFileNodePath(const Common::String &path) const;
};
#endif /*WINDOWS_FILESYSTEM_FACTORY_H*/

16
backends/fs/windows/windows-fs.cpp
View file

@ -55,9 +55,9 @@
/**
* Implementation of the ScummVM file system API based on Windows API.
*
* Parts of this class are documented in the base interface class, AbstractFilesystemNode.
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class WindowsFilesystemNode : public AbstractFilesystemNode {
class WindowsFilesystemNode : public AbstractFSNode {
protected:
Common::String _displayName;
Common::String _path;
@ -95,9 +95,9 @@ public:
virtual bool isReadable() const { return _access(_path.c_str(), R_OK) == 0; }
virtual bool isWritable() const { return _access(_path.c_str(), W_OK) == 0; }
virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
virtual AbstractFSNode *getChild(const Common::String &n) const;
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
virtual AbstractFilesystemNode *getParent() const;
virtual AbstractFSNode *getParent() const;
virtual Common::SeekableReadStream *openForReading();
virtual Common::WriteStream *openForWriting();
@ -142,8 +142,8 @@ void WindowsFilesystemNode::addFile(AbstractFSList &list, ListMode mode, const c
isDirectory = (find_data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ? true : false);
if ((!isDirectory && mode == Common::FilesystemNode::kListDirectoriesOnly) ||
(isDirectory && mode == Common::FilesystemNode::kListFilesOnly))
if ((!isDirectory && mode == Common::FSNode::kListDirectoriesOnly) ||
(isDirectory && mode == Common::FSNode::kListFilesOnly))
return;
entry._isDirectory = isDirectory;
@ -223,7 +223,7 @@ WindowsFilesystemNode::WindowsFilesystemNode(const Common::String &p, const bool
_isPseudoRoot = false;
}
AbstractFilesystemNode *WindowsFilesystemNode::getChild(const Common::String &n) const {
AbstractFSNode *WindowsFilesystemNode::getChild(const Common::String &n) const {
assert(_isDirectory);
Common::String newPath(_path);
@ -285,7 +285,7 @@ bool WindowsFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode, b
return true;
}
AbstractFilesystemNode *WindowsFilesystemNode::getParent() const {
AbstractFSNode *WindowsFilesystemNode::getParent() const {
assert(_isValid || _isPseudoRoot);
if (_isPseudoRoot)

30
backends/platform/dc/dc-fs.cpp
View file

@ -33,9 +33,9 @@
/**
* Implementation of the ScummVM file system API based on Ronin.
*
* Parts of this class are documented in the base interface class, AbstractFilesystemNode.
* Parts of this class are documented in the base interface class, AbstractFSNode.
*/
class RoninCDFileNode : public AbstractFilesystemNode {
class RoninCDFileNode : public AbstractFSNode {
protected:
Common::String _path;
@ -49,14 +49,14 @@ public:
virtual bool isReadable() const { return true; }
virtual bool isWritable() const { return false; }
virtual AbstractFilesystemNode *getChild(const Common::String &n) const { return NULL; }
virtual AbstractFSNode *getChild(const Common::String &n) const { return NULL; }
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const { return false; }
virtual AbstractFilesystemNode *getParent() const;
virtual AbstractFSNode *getParent() const;
virtual Common::SeekableReadStream *openForReading();
virtual Common::WriteStream *openForWriting() { return 0; }
static AbstractFilesystemNode *makeFileNodePath(const Common::String &path);
static AbstractFSNode *makeFileNodePath(const Common::String &path);
};
/* A directory */
@ -65,7 +65,7 @@ public:
RoninCDDirectoryNode(const Common::String &path) : RoninCDFileNode(path) {};
virtual bool isDirectory() const { return true; }
virtual AbstractFilesystemNode *getChild(const Common::String &n) const;
virtual AbstractFSNode *getChild(const Common::String &n) const;
virtual bool getChildren(AbstractFSList &list, ListMode mode, bool hidden) const;
virtual Common::SeekableReadStream *openForReading() { return 0; }
};
@ -80,7 +80,7 @@ public:
virtual Common::SeekableReadStream *openForReading() { return 0; }
};
AbstractFilesystemNode *RoninCDFileNode::makeFileNodePath(const Common::String &path) {
AbstractFSNode *RoninCDFileNode::makeFileNodePath(const Common::String &path) {
assert(path.size() > 0);
int fd;
@ -96,7 +96,7 @@ AbstractFilesystemNode *RoninCDFileNode::makeFileNodePath(const Common::String &
}
}
AbstractFilesystemNode *RoninCDDirectoryNode::getChild(const Common::String &n) const {
AbstractFSNode *RoninCDDirectoryNode::getChild(const Common::String &n) const {
Common::String newPath(_path);
if (_path.lastChar() != '/')
newPath += '/';
@ -122,13 +122,13 @@ bool RoninCDDirectoryNode::getChildren(AbstractFSList &myList, ListMode mode, bo
if (dp->d_size < 0) {
// Honor the chosen mode
if (mode == Common::FilesystemNode::kListFilesOnly)
if (mode == Common::FSNode::kListFilesOnly)
continue;
myList.push_back(new RoninCDDirectoryNode(newPath+"/"));
} else {
// Honor the chosen mode
if (mode == Common::FilesystemNode::kListDirectoriesOnly)
if (mode == Common::FSNode::kListDirectoriesOnly)
continue;
myList.push_back(new RoninCDFileNode(newPath));
@ -139,7 +139,7 @@ bool RoninCDDirectoryNode::getChildren(AbstractFSList &myList, ListMode mode, bo
return true;
}
AbstractFilesystemNode *RoninCDFileNode::getParent() const {
AbstractFSNode *RoninCDFileNode::getParent() const {
if (_path == "/")
return 0;
@ -154,16 +154,16 @@ Common::SeekableReadStream *RoninCDFileNode::openForReading() {
return StdioStream::makeFromPath(getPath().c_str(), false);
}
AbstractFilesystemNode *OSystem_Dreamcast::makeRootFileNode() const {
AbstractFSNode *OSystem_Dreamcast::makeRootFileNode() const {
return new RoninCDDirectoryNode("/");
}
AbstractFilesystemNode *OSystem_Dreamcast::makeCurrentDirectoryFileNode() const {
AbstractFSNode *OSystem_Dreamcast::makeCurrentDirectoryFileNode() const {
return makeRootFileNode();
}
AbstractFilesystemNode *OSystem_Dreamcast::makeFileNodePath(const Common::String &path) const {
AbstractFilesystemNode *node = RoninCDFileNode::makeFileNodePath(path);
AbstractFSNode *OSystem_Dreamcast::makeFileNodePath(const Common::String &path) const {
AbstractFSNode *node = RoninCDFileNode::makeFileNodePath(path);
return (node? node : new RoninCDNonexistingNode(path));
}

6
backends/platform/dc/dc.h
View file

@ -189,9 +189,9 @@ class OSystem_Dreamcast : public OSystem, public FilesystemFactory {
// Filesystem
FilesystemFactory *getFilesystemFactory() { return this; }
AbstractFilesystemNode *makeRootFileNode() const;
AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
AbstractFilesystemNode *makeFileNodePath(const Common::String &path) const;
AbstractFSNode *makeRootFileNode() const;
AbstractFSNode *makeCurrentDirectoryFileNode() const;
AbstractFSNode *makeFileNodePath(const Common::String &path) const;
private:

8
backends/platform/dc/selector.cpp
View file

@ -146,12 +146,12 @@ struct Dir
{
char name[252];
char deficon[256];
Common::FilesystemNode node;
Common::FSNode node;
};
static Game the_game;
static bool isIcon(const Common::FilesystemNode &entry)
static bool isIcon(const Common::FSNode &entry)
{
int l = entry.getDisplayName().size();
if (l>4 && !strcasecmp(entry.getDisplayName().c_str()+l-4, ".ICO"))
@ -198,13 +198,13 @@ static int findGames(Game *games, int max)
{
Dir *dirs = new Dir[MAX_DIR];
int curr_game = 0, curr_dir = 0, num_dirs = 1;
dirs[0].node = Common::FilesystemNode("");
dirs[0].node = Common::FSNode("");
while (curr_game < max && curr_dir < num_dirs) {
strncpy(dirs[curr_dir].name, dirs[curr_dir].node.getPath().c_str(), 252);
dirs[curr_dir].name[251] = '\0';
dirs[curr_dir].deficon[0] = '\0';
Common::FSList files, fslist;
dirs[curr_dir++].node.getChildren(fslist, Common::FilesystemNode::kListAll);
dirs[curr_dir++].node.getChildren(fslist, Common::FSNode::kListAll);
for (Common::FSList::const_iterator entry = fslist.begin(); entry != fslist.end();
++entry) {
if (entry->isDirectory()) {

6
backends/platform/sdl/sdl.cpp
View file

@ -280,7 +280,7 @@ void OSystem_SDL::addSysArchivesToSearchSet(Common::SearchSet &s, int priority)
#ifdef DATA_PATH
// Add the global DATA_PATH to the directory search list
// FIXME: We use depth = 4 for now, to match the old code. May want to change that
Common::FilesystemNode dataNode(DATA_PATH);
Common::FSNode dataNode(DATA_PATH);
if (dataNode.exists() && dataNode.isDirectory()) {
Common::ArchivePtr dataArchive(new Common::FSDirectory(dataNode, 4));
s.add(DATA_PATH, dataArchive, priority);
@ -373,12 +373,12 @@ static Common::String getDefaultConfigFileName() {
}
Common::SeekableReadStream *OSystem_SDL::openConfigFileForReading() {
Common::FilesystemNode file(getDefaultConfigFileName());
Common::FSNode file(getDefaultConfigFileName());
return file.openForReading();
}
Common::WriteStream *OSystem_SDL::openConfigFileForWriting() {
Common::FilesystemNode file(getDefaultConfigFileName());
Common::FSNode file(getDefaultConfigFileName());
return file.openForWriting();
}

4
backends/platform/symbian/src/SymbianOS.cpp
View file

@ -124,12 +124,12 @@ static Common::String getDefaultConfigFileName() {
}
Common::SeekableReadStream *OSystem_SDL_Symbian::openConfigFileForReading() {
Common::FilesystemNode file(getDefaultConfigFileName());
Common::FSNode file(getDefaultConfigFileName());
return file.openForReading();
}
Common::WriteStream *OSystem_SDL_Symbian::openConfigFileForWriting() {
Common::FilesystemNode file(getDefaultConfigFileName());
Common::FSNode file(getDefaultConfigFileName());
return file.openForWriting();
}

6
backends/platform/wince/CELauncherDialog.cpp
View file

@ -72,10 +72,10 @@ void CELauncherDialog::handleCommand(CommandSender *sender, uint32 cmd, uint32 d
}
}
void CELauncherDialog::automaticScanDirectory(const Common::FilesystemNode &node) {
void CELauncherDialog::automaticScanDirectory(const Common::FSNode &node) {
// First check if we have a recognized game in the current directory
Common::FSList files;
node.getChildren(files, Common::FilesystemNode::kListFilesOnly);
node.getChildren(files, Common::FSNode::kListFilesOnly);
// detect
GameList candidates(EngineMan.detectGames(files));
// insert
@ -86,7 +86,7 @@ void CELauncherDialog::automaticScanDirectory(const Common::FilesystemNode &node
}
// Then recurse on the subdirectories
Common::FSList dirs;
node.getChildren(dirs, Common::FilesystemNode::kListDirectoriesOnly);
node.getChildren(dirs, Common::FSNode::kListDirectoriesOnly);
for (Common::FSList::const_iterator currentDir = dirs.begin(); currentDir != dirs.end(); ++currentDir)
automaticScanDirectory(*currentDir);

2
backends/platform/wince/CELauncherDialog.h
View file

@ -36,7 +36,7 @@ public:
virtual void handleCommand(GUI::CommandSender *sender, uint32 cmd, uint32 data);
protected:
void addGame();
void automaticScanDirectory(const Common::FilesystemNode &node);
void automaticScanDirectory(const Common::FSNode &node);
};
typedef GUI::LauncherDialog GUILauncherDialog;

4
backends/plugins/dc/dc-provider.cpp
View file

@ -84,11 +84,11 @@ public:
};
Plugin* DCPluginProvider::createPlugin(const Common::FilesystemNode &node) const {
Plugin* DCPluginProvider::createPlugin(const Common::FSNode &node) const {
return new DCPlugin(node.getPath());
}
bool DCPluginProvider::isPluginFilename(const Common::FilesystemNode &node) const {
bool DCPluginProvider::isPluginFilename(const Common::FSNode &node) const {
// Check the plugin suffix
Common::String filename = node.getName();
if (!filename.hasSuffix(".PLG"))

4
backends/plugins/dc/dc-provider.h
View file

@ -32,9 +32,9 @@
class DCPluginProvider : public FilePluginProvider {
protected:
Plugin* createPlugin(const Common::FilesystemNode &node) const;
Plugin* createPlugin(const Common::FSNode &node) const;
bool isPluginFilename(const Common::FilesystemNode &node) const;
bool isPluginFilename(const Common::FSNode &node) const;
virtual void addCustomDirectories(Common::StringList &dirs) const {
dirs.push_back("/");

2
backends/plugins/posix/posix-provider.cpp
View file

@ -79,7 +79,7 @@ public:
};
Plugin* POSIXPluginProvider::createPlugin(const Common::FilesystemNode &node) const {
Plugin* POSIXPluginProvider::createPlugin(const Common::FSNode &node) const {
return new POSIXPlugin(node.getPath());
}

2
backends/plugins/posix/posix-provider.h
View file

@ -32,7 +32,7 @@
class POSIXPluginProvider : public FilePluginProvider {
protected:
Plugin* createPlugin(const Common::FilesystemNode &node) const;
Plugin* createPlugin(const Common::FSNode &node) const;
};
#endif // defined(DYNAMIC_MODULES) && defined(UNIX)

2
backends/plugins/sdl/sdl-provider.cpp
View file

@ -79,7 +79,7 @@ public:
};
Plugin* SDLPluginProvider::createPlugin(const Common::FilesystemNode &node) const {
Plugin* SDLPluginProvider::createPlugin(const Common::FSNode &node) const {
return new SDLPlugin(node.getPath());
}

2
backends/plugins/sdl/sdl-provider.h
View file

@ -32,7 +32,7 @@
class SDLPluginProvider : public FilePluginProvider {
protected:
Plugin* createPlugin(const Common::FilesystemNode &node) const;
Plugin* createPlugin(const Common::FSNode &node) const;
};
#endif // defined(DYNAMIC_MODULES) && defined(UNIX)

4
backends/plugins/win32/win32-provider.cpp
View file

@ -97,11 +97,11 @@ public:
};
Plugin* Win32PluginProvider::createPlugin(const Common::FilesystemNode &node) const {
Plugin* Win32PluginProvider::createPlugin(const Common::FSNode &node) const {
return new Win32Plugin(node.getPath());
}
bool Win32PluginProvider::isPluginFilename(const Common::FilesystemNode &node) const {
bool Win32PluginProvider::isPluginFilename(const Common::FSNode &node) const {
// Check the plugin suffix
Common::String filename = node.getName();
if (!filename.hasSuffix(".dll"))

4
backends/plugins/win32/win32-provider.h
View file

@ -32,9 +32,9 @@
class Win32PluginProvider : public FilePluginProvider {
protected:
Plugin* createPlugin(const Common::FilesystemNode &node) const;
Plugin* createPlugin(const Common::FSNode &node) const;
bool isPluginFilename(const Common::FilesystemNode &node) const;
bool isPluginFilename(const Common::FSNode &node) const;
virtual void addCustomDirectories(Common::StringList &dirs) const {}
};

20
backends/saves/default/default-saves.cpp
View file

@ -71,7 +71,7 @@ DefaultSaveFileManager::DefaultSaveFileManager(const Common::String &defaultSave
Common::StringList DefaultSaveFileManager::listSavefiles(const char *pattern) {
Common::FilesystemNode savePath(getSavePath());
Common::FSNode savePath(getSavePath());
Common::FSList savefiles;
Common::StringList results;
Common::String search(pattern);
@ -85,7 +85,7 @@ Common::StringList DefaultSaveFileManager::listSavefiles(const char *pattern) {
return results;
}
void DefaultSaveFileManager::checkPath(const Common::FilesystemNode &dir) {
void DefaultSaveFileManager::checkPath(const Common::FSNode &dir) {
const Common::String path = dir.getPath();
clearError();
@ -152,7 +152,7 @@ void DefaultSaveFileManager::checkPath(const Common::FilesystemNode &dir) {
#else
if (!dir.exists()) {
// TODO: We could try to mkdir the directory here; or rather, we could
// add a mkdir method to FilesystemNode and invoke that here.
// add a mkdir method to FSNode and invoke that here.
setError(SFM_DIR_NOENT, "A component of the path does not exist, or the path is an empty string: "+path);
} else if (!dir.isDirectory()) {
setError(SFM_DIR_NOTDIR, "The given savepath is not a directory: "+path);
@ -162,11 +162,11 @@ void DefaultSaveFileManager::checkPath(const Common::FilesystemNode &dir) {
Common::InSaveFile *DefaultSaveFileManager::openForLoading(const char *filename) {
// Ensure that the savepath is valid. If not, generate an appropriate error.
Common::FilesystemNode savePath(getSavePath());
Common::FSNode savePath(getSavePath());
checkPath(savePath);
if (getError() == SFM_NO_ERROR) {
Common::FilesystemNode file = savePath.getChild(filename);
Common::FSNode file = savePath.getChild(filename);
// Open the file for reading
Common::SeekableReadStream *sf = file.openForReading();
@ -179,11 +179,11 @@ Common::InSaveFile *DefaultSaveFileManager::openForLoading(const char *filename)
Common::OutSaveFile *DefaultSaveFileManager::openForSaving(const char *filename) {
// Ensure that the savepath is valid. If not, generate an appropriate error.
Common::FilesystemNode savePath(getSavePath());
Common::FSNode savePath(getSavePath());
checkPath(savePath);
if (getError() == SFM_NO_ERROR) {
Common::FilesystemNode file = savePath.getChild(filename);
Common::FSNode file = savePath.getChild(filename);
// Open the file for saving
Common::WriteStream *sf = file.openForWriting();
@ -197,10 +197,10 @@ Common::OutSaveFile *DefaultSaveFileManager::openForSaving(const char *filename)
bool DefaultSaveFileManager::removeSavefile(const char *filename) {
clearError();
Common::FilesystemNode savePath(getSavePath());
Common::FilesystemNode file = savePath.getChild(filename);
Common::FSNode savePath(getSavePath());
Common::FSNode file = savePath.getChild(filename);
// TODO: Add new method FilesystemNode::remove()
// TODO: Add new method FSNode::remove()
if (remove(file.getPath().c_str()) != 0) {
#ifndef _WIN32_WCE
if (errno == EACCES)

2
backends/saves/default/default-saves.h
View file

@ -55,7 +55,7 @@ protected:
* Checks the given path for read access, existence, etc.
* Sets the internal error and error message accordingly.
*/
void checkPath(const Common::FilesystemNode &dir);
void checkPath(const Common::FSNode &dir);
};
#endif

16
base/commandLine.cpp
View file

@ -365,7 +365,7 @@ Common::String parseCommandLine(Common::StringMap &settings, int argc, char **ar
END_OPTION
DO_OPTION('p', "path")
Common::FilesystemNode path(option);
Common::FSNode path(option);
if (!path.exists()) {
usage("Non-existent game path '%s'", option);
} else if (!path.isReadable()) {
@ -408,7 +408,7 @@ Common::String parseCommandLine(Common::StringMap &settings, int argc, char **ar
END_OPTION
DO_LONG_OPTION("soundfont")
Common::FilesystemNode path(option);
Common::FSNode path(option);
if (!path.exists()) {
usage("Non-existent soundfont path '%s'", option);
} else if (!path.isReadable()) {
@ -438,7 +438,7 @@ Common::String parseCommandLine(Common::StringMap &settings, int argc, char **ar
END_OPTION
DO_LONG_OPTION("savepath")
Common::FilesystemNode path(option);
Common::FSNode path(option);
if (!path.exists()) {
usage("Non-existent savegames path '%s'", option);
} else if (!path.isWritable()) {
@ -447,7 +447,7 @@ Common::String parseCommandLine(Common::StringMap &settings, int argc, char **ar
END_OPTION
DO_LONG_OPTION("extrapath")
Common::FilesystemNode path(option);
Common::FSNode path(option);
if (!path.exists()) {
usage("Non-existent extra path '%s'", option);
} else if (!path.isReadable()) {
@ -465,7 +465,7 @@ Common::String parseCommandLine(Common::StringMap &settings, int argc, char **ar
END_OPTION
DO_LONG_OPTION("themepath")
Common::FilesystemNode path(option);
Common::FSNode path(option);
if (!path.exists()) {
usage("Non-existent theme path '%s'", option);
} else if (!path.isReadable()) {
@ -623,9 +623,9 @@ static void runDetectorTest() {
gameid = name;
}
Common::FilesystemNode dir(path);
Common::FSNode dir(path);
Common::FSList files;
if (!dir.getChildren(files, Common::FilesystemNode::kListAll)) {
if (!dir.getChildren(files, Common::FSNode::kListAll)) {
printf(" ... invalid path, skipping\n");
continue;
}
@ -736,7 +736,7 @@ bool processSettings(Common::String &command, Common::StringMap &settings) {
if (!settings.contains("savepath")) {
const char *dir = getenv("SCUMMVM_SAVEPATH");
if (dir && *dir && strlen(dir) < MAXPATHLEN) {
Common::FilesystemNode saveDir(dir);
Common::FSNode saveDir(dir);
if (!saveDir.exists()) {
warning("Non-existent SCUMMVM_SAVEPATH save path. It will be ignored.");
} else if (!saveDir.isWritable()) {

12
base/plugins.cpp
View file

@ -207,8 +207,8 @@ PluginList FilePluginProvider::getPlugins() {
Common::FSList pluginDirs;
// Add the default directories
pluginDirs.push_back(Common::FilesystemNode("."));
pluginDirs.push_back(Common::FilesystemNode("plugins"));
pluginDirs.push_back(Common::FSNode("."));
pluginDirs.push_back(Common::FSNode("plugins"));
// Add the provider's custom directories
addCustomDirectories(pluginDirs);
@ -216,14 +216,14 @@ PluginList FilePluginProvider::getPlugins() {
// Add the user specified directory
Common::String pluginsPath(ConfMan.get("pluginspath"));
if (!pluginsPath.empty())
pluginDirs.push_back(Common::FilesystemNode(pluginsPath));
pluginDirs.push_back(Common::FSNode(pluginsPath));
Common::FSList::const_iterator dir;
for (dir = pluginDirs.begin(); dir != pluginDirs.end(); dir++) {
// Load all plugins.
// Scan for all plugins in this directory
Common::FSList files;
if (!dir->getChildren(files, Common::FilesystemNode::kListFilesOnly)) {
if (!dir->getChildren(files, Common::FSNode::kListFilesOnly)) {
debug(1, "Couldn't open plugin directory '%s'", dir->getPath().c_str());
continue;
} else {
@ -240,7 +240,7 @@ PluginList FilePluginProvider::getPlugins() {
return pl;
}
bool FilePluginProvider::isPluginFilename(const Common::FilesystemNode &node) const {
bool FilePluginProvider::isPluginFilename(const Common::FSNode &node) const {
Common::String filename = node.getName();
#ifdef PLUGIN_PREFIX
@ -260,7 +260,7 @@ bool FilePluginProvider::isPluginFilename(const Common::FilesystemNode &node) co
void FilePluginProvider::addCustomDirectories(Common::FSList &dirs) const {
#ifdef PLUGIN_DIRECTORY
dirs.push_back(Common::FilesystemNode(PLUGIN_DIRECTORY));
dirs.push_back(Common::FSNode(PLUGIN_DIRECTORY));
#endif
}

6
base/plugins.h
View file

@ -32,7 +32,7 @@
namespace Common {
class FSList;
class FilesystemNode;
class FSNode;
}
@ -242,7 +242,7 @@ protected:
* @param node the FSNode of the loadable code module
* @return a pointer to a Plugin instance, or 0 if an error occurred.
*/
virtual Plugin *createPlugin(const Common::FilesystemNode &node) const = 0;
virtual Plugin *createPlugin(const Common::FSNode &node) const = 0;
/**
* Check if the supplied file corresponds to a loadable plugin file in
@ -251,7 +251,7 @@ protected:
* @param node the FSNode of the file to check
* @return true if the filename corresponds to a plugin, false otherwise
*/
virtual bool isPluginFilename(const Common::FilesystemNode &node) const;
virtual bool isPluginFilename(const Common::FSNode &node) const;
/**
* Optionally add to the list of directories to be searched for

6
common/advancedDetector.cpp
View file

@ -246,9 +246,9 @@ PluginError AdvancedMetaEngine::createInstance(OSystem *syst, Engine **engine) c
path = ".";
warning("No path was provided. Assuming the data files are in the current directory");
}
FilesystemNode dir(path);
FSNode dir(path);
FSList files;
if (!dir.isDirectory() || !dir.getChildren(files, FilesystemNode::kListAll)) {
if (!dir.isDirectory() || !dir.getChildren(files, FSNode::kListAll)) {
warning("Game data path does not exist or is not a directory (%s)", path.c_str());
return kNoGameDataFoundError;
}
@ -290,7 +290,7 @@ PluginError AdvancedMetaEngine::createInstance(OSystem *syst, Engine **engine) c
typedef HashMap<String, bool, IgnoreCase_Hash, IgnoreCase_EqualTo> StringSet;
typedef HashMap<String, int32, IgnoreCase_Hash, IgnoreCase_EqualTo> IntMap;
typedef HashMap<String, FilesystemNode, IgnoreCase_Hash, IgnoreCase_EqualTo> FileMap;
typedef HashMap<String, FSNode, IgnoreCase_Hash, IgnoreCase_EqualTo> FileMap;
static void reportUnknown(const StringMap &filesMD5, const IntMap &filesSize) {
// TODO: This message should be cleaned up / made more specific.

22
common/archive.cpp
View file

@ -54,7 +54,7 @@ int Archive::matchPattern(StringList &list, const String &pattern) {
}
FSDirectory::FSDirectory(const FilesystemNode &node, int depth)
FSDirectory::FSDirectory(const FSNode &node, int depth)
: _node(node), _cached(false), _depth(depth) {
}
@ -65,11 +65,11 @@ FSDirectory::FSDirectory(const String &name, int depth)
FSDirectory::~FSDirectory() {
}
FilesystemNode FSDirectory::getFSNode() const {
FSNode FSDirectory::getFSNode() const {
return _node;
}
FilesystemNode FSDirectory::lookupCache(NodeCache &cache, const String &name) {
FSNode FSDirectory::lookupCache(NodeCache &cache, const String &name) {
// make caching as lazy as possible
if (!name.empty()) {
if (!_cached) {
@ -81,7 +81,7 @@ FilesystemNode FSDirectory::lookupCache(NodeCache &cache, const String &name) {
return cache[name];
}
return FilesystemNode();
return FSNode();
}
bool FSDirectory::hasFile(const String &name) {
@ -89,7 +89,7 @@ bool FSDirectory::hasFile(const String &name) {
return false;
}
FilesystemNode node = lookupCache(_fileCache, name);
FSNode node = lookupCache(_fileCache, name);
return node.exists();
}
@ -98,13 +98,13 @@ SeekableReadStream *FSDirectory::openFile(const String &name) {
return 0;
}
FilesystemNode node = lookupCache(_fileCache, name);
FSNode node = lookupCache(_fileCache, name);
if (!node.exists()) {
warning("FSDirectory::openFile: FilesystemNode does not exist");
warning("FSDirectory::openFile: FSNode does not exist");
return 0;
} else if (node.isDirectory()) {
warning("FSDirectory::openFile: FilesystemNode is a directory");
warning("FSDirectory::openFile: FSNode is a directory");
return 0;
}
@ -121,17 +121,17 @@ FSDirectory *FSDirectory::getSubDirectory(const String &name) {
return 0;
}
FilesystemNode node = lookupCache(_subDirCache, name);
FSNode node = lookupCache(_subDirCache, name);
return new FSDirectory(node);
}
void FSDirectory::cacheDirectoryRecursive(FilesystemNode node, int depth, const String& prefix) {
void FSDirectory::cacheDirectoryRecursive(FSNode node, int depth, const String& prefix) {
if (depth <= 0) {
return;
}
FSList list;
node.getChildren(list, FilesystemNode::kListAll, false);
node.getChildren(list, FSNode::kListAll, false);
FSList::iterator it = list.begin();
for ( ; it != list.end(); it++) {

14
common/archive.h
View file

@ -93,21 +93,21 @@ typedef SharedPtr<Archive> ArchivePtr;
* Searching is case-insensitive, as the main intended goal is supporting
* retrieval of game data. First case-insensitive match is returned when
* searching, thus making FSDirectory heavily dependant on the underlying
* FilesystemNode implementation.
* FSNode implementation.
*/
class FSDirectory : public Archive {
FilesystemNode _node;
FSNode _node;
// Caches are case insensitive, clashes are dealt with when creating
// Key is stored in lowercase.
typedef HashMap<String, FilesystemNode, IgnoreCase_Hash, IgnoreCase_EqualTo> NodeCache;
typedef HashMap<String, FSNode, IgnoreCase_Hash, IgnoreCase_EqualTo> NodeCache;
NodeCache _fileCache, _subDirCache;
// look for a match
FilesystemNode lookupCache(NodeCache &cache, const String &name);
FSNode lookupCache(NodeCache &cache, const String &name);
// cache management
void cacheDirectoryRecursive(FilesystemNode node, int depth, const String& prefix);
void cacheDirectoryRecursive(FSNode node, int depth, const String& prefix);
bool _cached;
int _depth;
@ -122,14 +122,14 @@ public:
* Create a FSDirectory representing a tree with the specified depth. Will result in an
* unbound FSDirectory if node does not exist or is not a directory.
*/
FSDirectory(const FilesystemNode &node, int depth = 1);
FSDirectory(const FSNode &node, int depth = 1);
virtual ~FSDirectory();
/**
* This return the underlying FSNode of the FSDirectory.
*/
FilesystemNode getFSNode() const;
FSNode getFSNode() const;
/**
* Create a new FSDirectory pointing to a sub directory of the instance.

2
common/config-manager.cpp
View file

@ -77,7 +77,7 @@ void ConfigManager::loadDefaultConfigFile() {
void ConfigManager::loadConfigFile(const String &filename) {
_filename = filename;
FilesystemNode node(filename);
FSNode node(filename);
File cfg_file;
if (!cfg_file.open(node)) {
printf("Creating configuration file: %s\n", filename.c_str());

16
common/file.cpp
View file

@ -32,20 +32,20 @@
namespace Common {
void File::addDefaultDirectory(const String &directory) {
FilesystemNode dir(directory);
FSNode dir(directory);
addDefaultDirectoryRecursive(dir, 1);
}
void File::addDefaultDirectoryRecursive(const String &directory, int level) {
FilesystemNode dir(directory);
FSNode dir(directory);
addDefaultDirectoryRecursive(dir, level);
}
void File::addDefaultDirectory(const FilesystemNode &directory) {
void File::addDefaultDirectory(const FSNode &directory) {
addDefaultDirectoryRecursive(directory, 1);
}
void File::addDefaultDirectoryRecursive(const FilesystemNode &dir, int level) {
void File::addDefaultDirectoryRecursive(const FSNode &dir, int level) {
if (level <= 0 || !dir.exists() || !dir.isDirectory())
return;
@ -89,7 +89,7 @@ bool File::open(const String &filename, Archive &archive) {
return open(stream, filename);
}
bool File::open(const FilesystemNode &node) {
bool File::open(const FSNode &node) {
assert(!_handle);
if (!node.exists()) {
@ -196,15 +196,15 @@ bool DumpFile::open(const String &filename) {
assert(!filename.empty());
assert(!_handle);
FilesystemNode node(filename);
FSNode node(filename);
return open(node);
}
bool DumpFile::open(const FilesystemNode &node) {
bool DumpFile::open(const FSNode &node) {
assert(!_handle);
if (node.isDirectory()) {
warning("DumpFile::open: FilesystemNode is a directory");
warning("DumpFile::open: FSNode is a directory");
return false;
}

10
common/file.h
View file

@ -34,7 +34,7 @@
namespace Common {
class FilesystemNode;
class FSNode;
/**
* TODO: vital to document this core class properly!!! For both users and implementors
@ -52,8 +52,8 @@ public:
static void addDefaultDirectory(const String &directory);
static void addDefaultDirectoryRecursive(const String &directory, int level = 4);
static void addDefaultDirectory(const FilesystemNode &directory);
static void addDefaultDirectoryRecursive(const FilesystemNode &directory, int level = 4);
static void addDefaultDirectory(const FSNode &directory);
static void addDefaultDirectoryRecursive(const FSNode &directory, int level = 4);
static void resetDefaultDirectories();
@ -100,7 +100,7 @@ public:
* @param archive the archive in which to search for the file
* @return true if file was opened successfully, false otherwise
*/
virtual bool open(const FilesystemNode &node);
virtual bool open(const FSNode &node);
/**
* Try to 'open' the given stream. That is, we just wrap around it, and if stream
@ -161,7 +161,7 @@ public:
virtual ~DumpFile();
virtual bool open(const String &filename);
virtual bool open(const FilesystemNode &node);
virtual bool open(const FSNode &node);
virtual void close();

58
common/fs.cpp
View file

@ -29,48 +29,48 @@
namespace Common {
FilesystemNode::FilesystemNode() {
FSNode::FSNode() {
}
FilesystemNode::FilesystemNode(AbstractFilesystemNode *realNode)
FSNode::FSNode(AbstractFSNode *realNode)
: _realNode(realNode) {
}
FilesystemNode::FilesystemNode(const Common::String &p) {
FSNode::FSNode(const Common::String &p) {
FilesystemFactory *factory = g_system->getFilesystemFactory();
AbstractFilesystemNode *tmp = 0;
AbstractFSNode *tmp = 0;
if (p.empty() || p == ".")
tmp = factory->makeCurrentDirectoryFileNode();
else
tmp = factory->makeFileNodePath(p);
_realNode = Common::SharedPtr<AbstractFilesystemNode>(tmp);
_realNode = Common::SharedPtr<AbstractFSNode>(tmp);
}
bool FilesystemNode::operator<(const FilesystemNode& node) const {
bool FSNode::operator<(const FSNode& node) const {
if (isDirectory() != node.isDirectory())
return isDirectory();
return getDisplayName().compareToIgnoreCase(node.getDisplayName()) < 0;
}
bool FilesystemNode::exists() const {
bool FSNode::exists() const {
if (_realNode == 0)
return false;
return _realNode->exists();
}
FilesystemNode FilesystemNode::getChild(const Common::String &n) const {
FSNode FSNode::getChild(const Common::String &n) const {
// If this node is invalid or not a directory, return an invalid node
if (_realNode == 0 || !_realNode->isDirectory())
return FilesystemNode();
return FSNode();
AbstractFilesystemNode *node = _realNode->getChild(n);
return FilesystemNode(node);
AbstractFSNode *node = _realNode->getChild(n);
return FSNode(node);
}
bool FilesystemNode::getChildren(FSList &fslist, ListMode mode, bool hidden) const {
bool FSNode::getChildren(FSList &fslist, ListMode mode, bool hidden) const {
if (!_realNode || !_realNode->isDirectory())
return false;
@ -81,61 +81,61 @@ bool FilesystemNode::getChildren(FSList &fslist, ListMode mode, bool hidden) con
fslist.clear();
for (AbstractFSList::iterator i = tmp.begin(); i != tmp.end(); ++i) {
fslist.push_back(FilesystemNode(*i));
fslist.push_back(FSNode(*i));
}
return true;
}
Common::String FilesystemNode::getDisplayName() const {
Common::String FSNode::getDisplayName() const {
assert(_realNode);
return _realNode->getDisplayName();
}
Common::String FilesystemNode::getName() const {
Common::String FSNode::getName() const {
assert(_realNode);
return _realNode->getName();
}
FilesystemNode FilesystemNode::getParent() const {
FSNode FSNode::getParent() const {
if (_realNode == 0)
return *this;
AbstractFilesystemNode *node = _realNode->getParent();
AbstractFSNode *node = _realNode->getParent();
if (node == 0) {
return *this;
} else {
return FilesystemNode(node);
return FSNode(node);
}
}
Common::String FilesystemNode::getPath() const {
Common::String FSNode::getPath() const {
assert(_realNode);
return _realNode->getPath();
}
bool FilesystemNode::isDirectory() const {
bool FSNode::isDirectory() const {
if (_realNode == 0)
return false;
return _realNode->isDirectory();
}
bool FilesystemNode::isReadable() const {
bool FSNode::isReadable() const {
if (_realNode == 0)
return false;
return _realNode->isReadable();
}
bool FilesystemNode::isWritable() const {
bool FSNode::isWritable() const {
if (_realNode == 0)
return false;
return _realNode->isWritable();
}
bool FilesystemNode::lookupFile(FSList &results, const Common::String &p, bool hidden, bool exhaustive, int depth) const {
bool FSNode::lookupFile(FSList &results, const Common::String &p, bool hidden, bool exhaustive, int depth) const {
if (!isDirectory())
return false;
@ -146,7 +146,7 @@ bool FilesystemNode::lookupFile(FSList &results, const Common::String &p, bool h
pattern.toUppercase();
// First match all files on this level
getChildren(children, FilesystemNode::kListAll, hidden);
getChildren(children, FSNode::kListAll, hidden);
for (FSList::iterator entry = children.begin(); entry != children.end(); ++entry) {
if (entry->isDirectory()) {
if (depth != 0)
@ -173,27 +173,27 @@ bool FilesystemNode::lookupFile(FSList &results, const Common::String &p, bool h
return !results.empty();
}
Common::SeekableReadStream *FilesystemNode::openForReading() const {
Common::SeekableReadStream *FSNode::openForReading() const {
if (_realNode == 0)
return 0;
if (!_realNode->exists()) {
warning("FilesystemNode::openForReading: FilesystemNode does not exist");
warning("FSNode::openForReading: FSNode does not exist");
return false;
} else if (_realNode->isDirectory()) {
warning("FilesystemNode::openForReading: FilesystemNode is a directory");
warning("FSNode::openForReading: FSNode is a directory");
return false;
}
return _realNode->openForReading();
}
Common::WriteStream *FilesystemNode::openForWriting() const {
Common::WriteStream *FSNode::openForWriting() const {
if (_realNode == 0)
return 0;
if (_realNode->isDirectory()) {
warning("FilesystemNode::openForWriting: FilesystemNode is a directory");
warning("FSNode::openForWriting: FSNode is a directory");
return 0;
}

35
common/fs.h
View file

@ -29,11 +29,11 @@
#include "common/ptr.h"
#include "common/str.h"
class AbstractFilesystemNode;
class AbstractFSNode;
namespace Common {
class FilesystemNode;
class FSNode;
class SeekableReadStream;
class WriteStream;
@ -42,21 +42,22 @@ class WriteStream;
* This is subclass instead of just a typedef so that we can use forward
* declarations of it in other places.
*/
class FSList : public Common::Array<FilesystemNode> {};
class FSList : public Common::Array<FSNode> {};
/**
* FilesystemNode provides an abstraction for file paths, allowing for portable
* file system browsing. To this ends, multiple or single roots have to be supported
* (compare Unix with a single root, Windows with multiple roots C:, D:, ...).
* FSNode, short for "File System Node", provides an abstraction for file
* paths, allowing for portable file system browsing. This means for example,
* that multiple or single roots have to be supported (compare Unix with a
* single root, Windows with multiple roots C:, D:, ...).
*
* To this end, we abstract away from paths; implementations can be based on
* paths (and it's left to them whether / or \ or : is the path separator :-);
* but it is also possible to use inodes or vrefs (MacOS 9) or anything else.
*/
class FilesystemNode {
class FSNode {
private:
Common::SharedPtr<AbstractFilesystemNode> _realNode;
FilesystemNode(AbstractFilesystemNode *realNode);
Common::SharedPtr<AbstractFSNode> _realNode;
FSNode(AbstractFSNode *realNode);
public:
/**
@ -69,14 +70,14 @@ public:
};
/**
* Create a new pathless FilesystemNode. Since there's no path associated
* Create a new pathless FSNode. Since there's no path associated
* with this node, path-related operations (i.e. exists(), isDirectory(),
* getPath()) will always return false or raise an assertion.
*/
FilesystemNode();
FSNode();
/**
* Create a new FilesystemNode referring to the specified path. This is
* Create a new FSNode referring to the specified path. This is
* the counterpart to the path() method.
*
* If path is empty or equals ".", then a node representing the "current
@ -84,15 +85,15 @@ public:
* operating system doesn't support the concept), some other directory is
* used (usually the root directory).
*/
explicit FilesystemNode(const Common::String &path);
explicit FSNode(const Common::String &path);
virtual ~FilesystemNode() {}
virtual ~FSNode() {}
/**
* Compare the name of this node to the name of another. Directories
* go before normal files.
*/
bool operator<(const FilesystemNode& node) const;
bool operator<(const FSNode& node) const;
/**
* Indicates whether the object referred by this node exists in the filesystem or not.
@ -118,7 +119,7 @@ public:
* @param name the name of a child of this directory
* @return the node referring to the child with the given name
*/
FilesystemNode getChild(const Common::String &name) const;
FSNode getChild(const Common::String &name) const;
/**
* Return a list of all child nodes of this directory node. If called on a node
@ -165,7 +166,7 @@ public:
* Get the parent node of this node. If this node has no parent node,
* then it returns a duplicate of this node.
*/
FilesystemNode getParent() const;
FSNode getParent() const;
/**
* Indicates whether the node refers to a directory or not.

10
common/md5.cpp
View file

@ -246,15 +246,15 @@ void md5_finish(md5_context *ctx, uint8 digest[16]) {
PUT_UINT32(ctx->state[3], digest, 12);
}
bool md5_file(const FilesystemNode &file, uint8 digest[16], uint32 length) {
bool md5_file(const FSNode &file, uint8 digest[16], uint32 length) {
if (!file.exists()) {
warning("md5_file: using an inexistent FilesystemNode");
warning("md5_file: using an inexistent FSNode");
return false;
} else if (!file.isReadable()) {
warning("md5_file: using an unreadable FilesystemNode");
warning("md5_file: using an unreadable FSNode");
return false;
} else if (file.isDirectory()) {
warning("md5_file: using a directory FilesystemNode");
warning("md5_file: using a directory FSNode");
return false;
}
@ -316,7 +316,7 @@ bool md5_file(ReadStream &stream, uint8 digest[16], uint32 length) {
return true;
}
bool md5_file_string(const FilesystemNode &file, char *md5str, uint32 length) {
bool md5_file_string(const FSNode &file, char *md5str, uint32 length) {
uint8 digest[16];
if (!md5_file(file, digest, length))
return false;

6
common/md5.h
View file

@ -29,11 +29,11 @@
namespace Common {
class FilesystemNode;
class FSNode;
class ReadStream;
bool md5_file(const char *name, uint8 digest[16], uint32 length = 0);
bool md5_file(const FilesystemNode &file, uint8 digest[16], uint32 length = 0);
bool md5_file(const FSNode &file, uint8 digest[16], uint32 length = 0);
bool md5_file(ReadStream &stream, uint8 digest[16], uint32 length = 0);
// The following two methods work similar to the above two, but
@ -41,7 +41,7 @@ bool md5_file(ReadStream &stream, uint8 digest[16], uint32 length = 0);
// a human readable lowercase hexstring representing the digest.
// The md5str parameter must point to a buffer of 32+1 chars.
bool md5_file_string(const char *name, char *md5str, uint32 length = 0);
bool md5_file_string(const FilesystemNode &file, char *md5str, uint32 length = 0);
bool md5_file_string(const FSNode &file, char *md5str, uint32 length = 0);
bool md5_file_string(ReadStream &stream, char *md5str, uint32 length = 0);

4
common/system.cpp
View file

@ -163,7 +163,7 @@ static Common::String getDefaultConfigFileName() {
}
Common::SeekableReadStream *OSystem::openConfigFileForReading() {
Common::FilesystemNode file(getDefaultConfigFileName());
Common::FSNode file(getDefaultConfigFileName());
return file.openForReading();
}
@ -171,7 +171,7 @@ Common::WriteStream *OSystem::openConfigFileForWriting() {
#ifdef __DC__
return 0;
#else
Common::FilesystemNode file(getDefaultConfigFileName());
Common::FSNode file(getDefaultConfigFileName());
return file.openForWriting();
#endif
}

2
common/unzip.cpp
View file

@ -1363,7 +1363,7 @@ class ZipArchiveMember : public ArchiveMember {
unzFile _zipFile;
public:
ZipArchiveMember(FilesystemNode &node) : _node(node) {
ZipArchiveMember(FSNode &node) : _node(node) {
}
String getName() const {

6
engines/agi/detection.cpp
View file

@ -2207,7 +2207,7 @@ const Common::ADGameDescription *AgiMetaEngine::fallbackDetect(const Common::FSL
bool matchedUsingWag = false;
int wagFileCount = 0;
WagFileParser wagFileParser;
Common::FilesystemNode wagFileNode;
Common::FSNode wagFileNode;
Common::String description;
Common::FSList fslistCurrentDir; // Only used if fslist == NULL
@ -2222,8 +2222,8 @@ const Common::ADGameDescription *AgiMetaEngine::fallbackDetect(const Common::FSL
if (path.empty())
path = ".";
Common::FilesystemNode fsCurrentDir(path);
fsCurrentDir.getChildren(fslistCurrentDir, Common::FilesystemNode::kListFilesOnly);
Common::FSNode fsCurrentDir(path);
fsCurrentDir.getChildren(fslistCurrentDir, Common::FSNode::kListFilesOnly);
fslist = &fslistCurrentDir;
}

4
engines/agi/loader_v3.cpp
View file

@ -48,9 +48,9 @@ int AgiLoader_v3::detectGame() {
bool found = false;
Common::FSList fslist;
Common::FilesystemNode dir(ConfMan.get("path"));
Common::FSNode dir(ConfMan.get("path"));
if (!dir.getChildren(fslist, Common::FilesystemNode::kListFilesOnly)) {
if (!dir.getChildren(fslist, Common::FSNode::kListFilesOnly)) {
warning("AgiEngine: invalid game path '%s'", dir.getPath().c_str());
return errInvalidAGIFile;
}

14
engines/agi/sound.cpp
View file

@ -1007,7 +1007,7 @@ const IIgsExeInfo *SoundMgr::getIIgsExeInfo(enum AgiGameID gameid) const {
return NULL;
}
bool IIgsSoundMgr::loadInstrumentHeaders(const Common::FilesystemNode &exePath, const IIgsExeInfo &exeInfo) {
bool IIgsSoundMgr::loadInstrumentHeaders(const Common::FSNode &exePath, const IIgsExeInfo &exeInfo) {
bool loadedOk = false; // Was loading successful?
Common::File file;
@ -1078,7 +1078,7 @@ bool SoundMgr::convertWave(Common::SeekableReadStream &source, int8 *dest, uint
return !source.ioFailed();
}
bool IIgsSoundMgr::loadWaveFile(const Common::FilesystemNode &wavePath, const IIgsExeInfo &exeInfo) {
bool IIgsSoundMgr::loadWaveFile(const Common::FSNode &wavePath, const IIgsExeInfo &exeInfo) {
Common::File file;
// Open the wave file and read it into memory
@ -1107,14 +1107,14 @@ bool IIgsSoundMgr::loadWaveFile(const Common::FilesystemNode &wavePath, const II
}
/**
* A function object (i.e. a functor) for testing if a Common::FilesystemNode
* A function object (i.e. a functor) for testing if a Common::FSNode
* object's name is equal (Ignoring case) to a string or to at least
* one of the strings in a list of strings. Can be used e.g. with find_if().
*/
struct fsnodeNameEqualsIgnoreCase : public Common::UnaryFunction<const Common::FilesystemNode&, bool> {
struct fsnodeNameEqualsIgnoreCase : public Common::UnaryFunction<const Common::FSNode&, bool> {
fsnodeNameEqualsIgnoreCase(const Common::StringList &str) : _str(str) {}
fsnodeNameEqualsIgnoreCase(const Common::String str) { _str.push_back(str); }
bool operator()(const Common::FilesystemNode &param) const {
bool operator()(const Common::FSNode &param) const {
for (Common::StringList::const_iterator iter = _str.begin(); iter != _str.end(); iter++)
if (param.getName().equalsIgnoreCase(*iter))
return true;
@ -1140,8 +1140,8 @@ bool SoundMgr::loadInstruments() {
// List files in the game path
Common::FSList fslist;
Common::FilesystemNode dir(ConfMan.get("path"));
if (!dir.getChildren(fslist, Common::FilesystemNode::kListFilesOnly)) {
Common::FSNode dir(ConfMan.get("path"));
if (!dir.getChildren(fslist, Common::FSNode::kListFilesOnly)) {
warning("Invalid game path (\"%s\"), not loading Apple IIGS instruments", dir.getPath().c_str());
return false;
}

4
engines/agi/sound.h
View file

@ -402,8 +402,8 @@ public:
// For initializing
IIgsSoundMgr();
void setProgramChangeMapping(const MidiProgramChangeMapping *mapping);
bool loadInstrumentHeaders(const Common::FilesystemNode &exePath, const IIgsExeInfo &exeInfo);
bool loadWaveFile(const Common::FilesystemNode &wavePath, const IIgsExeInfo &exeInfo);
bool loadInstrumentHeaders(const Common::FSNode &exePath, const IIgsExeInfo &exeInfo);
bool loadWaveFile(const Common::FSNode &wavePath, const IIgsExeInfo &exeInfo);
// Miscellaneous methods
uint activeSounds() const; ///< How many active sounds are playing?
void stopSounds(); ///< Stops all sounds

2
engines/agi/wagparser.cpp
View file

@ -173,7 +173,7 @@ bool WagFileParser::checkWagVersion(Common::SeekableReadStream &stream) {
}
}
bool WagFileParser::parse(const Common::FilesystemNode &node) {
bool WagFileParser::parse(const Common::FSNode &node) {
WagProperty property; // Temporary property used for reading
Common::SeekableReadStream *stream = NULL; // The file stream

2
engines/agi/wagparser.h
View file

@ -223,7 +223,7 @@ public:
* @param filename Name of the file to be parsed.
* @return True if parsed successfully, false otherwise.
*/
bool parse(const Common::FilesystemNode &node);
bool parse(const Common::FSNode &node);
/**
* Get list of the loaded properties.

2
engines/engine.h
View file

@ -62,7 +62,7 @@ protected:
const Common::String _targetName; // target name for saves
const Common::FilesystemNode _gameDataDir;
const Common::FSNode _gameDataDir;
private:
/**

4
engines/kyra/resource.cpp
View file

@ -57,7 +57,7 @@ Resource::~Resource() {
bool Resource::reset() {
unloadAllPakFiles();
Common::FilesystemNode dir(ConfMan.get("path"));
Common::FSNode dir(ConfMan.get("path"));
if (!dir.exists() || !dir.isDirectory())
error("invalid game path '%s'", dir.getPath().c_str());
@ -103,7 +103,7 @@ bool Resource::reset() {
}
Common::FSList fslist;
if (!dir.getChildren(fslist, Common::FilesystemNode::kListFilesOnly))
if (!dir.getChildren(fslist, Common::FSNode::kListFilesOnly))
error("can't list files inside game path '%s'", dir.getPath().c_str());
if (_vm->game() == GI_KYRA1 && _vm->gameFlags().isTalkie) {

40
engines/parallaction/disk.h
View file

@ -211,21 +211,21 @@ protected:
Parallaction *_vm;
Common::FilesystemNode _baseDir;
Common::FilesystemNode _partDir;
Common::FSNode _baseDir;
Common::FSNode _partDir;
Common::FilesystemNode _aniDir;
Common::FilesystemNode _bkgDir;
Common::FilesystemNode _mscDir;
Common::FilesystemNode _mskDir;
Common::FilesystemNode _pthDir;
Common::FilesystemNode _rasDir;
Common::FilesystemNode _scrDir;
Common::FilesystemNode _sfxDir;
Common::FilesystemNode _talDir;
Common::FSNode _aniDir;
Common::FSNode _bkgDir;
Common::FSNode _mscDir;
Common::FSNode _mskDir;
Common::FSNode _pthDir;
Common::FSNode _rasDir;
Common::FSNode _scrDir;
Common::FSNode _sfxDir;
Common::FSNode _talDir;
protected:
void errorFileNotFound(const Common::FilesystemNode &dir, const Common::String &filename);
void errorFileNotFound(const Common::FSNode &dir, const Common::String &filename);
Font *createFont(const char *name, Common::ReadStream &stream);
Sprites* createSprites(Common::ReadStream &stream);
void loadBitmap(Common::SeekableReadStream &stream, Graphics::Surface &surf, byte *palette);
@ -273,14 +273,14 @@ protected:
Font *createFont(const char *name, Common::SeekableReadStream &stream);
void loadBackground(BackgroundInfo& info, Common::SeekableReadStream &stream);
Common::FilesystemNode _baseBkgDir;
Common::FilesystemNode _fntDir;
Common::FilesystemNode _commonAniDir;
Common::FilesystemNode _commonBkgDir;
Common::FilesystemNode _commonMscDir;
Common::FilesystemNode _commonMskDir;
Common::FilesystemNode _commonPthDir;
Common::FilesystemNode _commonTalDir;
Common::FSNode _baseBkgDir;
Common::FSNode _fntDir;
Common::FSNode _commonAniDir;
Common::FSNode _commonBkgDir;
Common::FSNode _commonMscDir;
Common::FSNode _commonMskDir;
Common::FSNode _commonPthDir;
Common::FSNode _commonTalDir;
public:
AmigaDisk_br(Parallaction *vm);

48
engines/parallaction/disk_br.cpp
View file

@ -91,7 +91,7 @@ struct Sprites : public Frames {
void DosDisk_br::errorFileNotFound(const Common::FilesystemNode &dir, const Common::String &filename) {
void DosDisk_br::errorFileNotFound(const Common::FSNode &dir, const Common::String &filename) {
error("File '%s' not found in directory '%s'", filename.c_str(), dir.getDisplayName().c_str());
}
@ -134,7 +134,7 @@ GfxObj* DosDisk_br::loadTalk(const char *name) {
debugC(5, kDebugDisk, "DosDisk_br::loadTalk(%s)", name);
Common::String path(name);
Common::FilesystemNode node = _talDir.getChild(path);
Common::FSNode node = _talDir.getChild(path);
if (!node.exists()) {
path += ".tal";
node = _talDir.getChild(path);
@ -160,11 +160,11 @@ Script* DosDisk_br::loadLocation(const char *name) {
debugC(5, kDebugDisk, "DosDisk_br::loadLocation");
Common::String langs[4] = { "it", "fr", "en", "ge" };
Common::FilesystemNode locDir = _partDir.getChild(langs[_language]);
Common::FSNode locDir = _partDir.getChild(langs[_language]);
Common::String path(name);
path += ".slf";
Common::FilesystemNode node = locDir.getChild(path);
Common::FSNode node = locDir.getChild(path);
if (!node.exists()) {
path = Common::String(name) + ".loc";
node = locDir.getChild(path);
@ -183,7 +183,7 @@ Script* DosDisk_br::loadScript(const char* name) {
Common::String path(name);
path += ".scr";
Common::FilesystemNode node = _scrDir.getChild(path);
Common::FSNode node = _scrDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_scrDir, path);
}
@ -221,7 +221,7 @@ Frames* DosDisk_br::loadPointer(const char *name) {
Common::String path(name);
path += ".ras";
Common::FilesystemNode node = _baseDir.getChild(path);
Common::FSNode node = _baseDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_baseDir, path);
}
@ -240,7 +240,7 @@ Font* DosDisk_br::loadFont(const char* name) {
Common::String path(name);
path += ".fnt";
Common::FilesystemNode node = _baseDir.getChild(path);
Common::FSNode node = _baseDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_baseDir, path);
}
@ -255,7 +255,7 @@ GfxObj* DosDisk_br::loadObjects(const char *name) {
debugC(5, kDebugDisk, "DosDisk_br::loadObjects");
Common::String path(name);
Common::FilesystemNode node = _partDir.getChild(path);
Common::FSNode node = _partDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_partDir, path);
}
@ -274,7 +274,7 @@ GfxObj* DosDisk_br::loadStatic(const char* name) {
debugC(5, kDebugDisk, "DosDisk_br::loadStatic");
Common::String path(name);
Common::FilesystemNode node = _rasDir.getChild(path);
Common::FSNode node = _rasDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_rasDir, path);
}
@ -312,7 +312,7 @@ Frames* DosDisk_br::loadFrames(const char* name) {
debugC(5, kDebugDisk, "DosDisk_br::loadFrames");
Common::String path(name);
Common::FilesystemNode node = _aniDir.getChild(path);
Common::FSNode node = _aniDir.getChild(path);
if (!node.exists()) {
path += ".ani";
node = _aniDir.getChild(path);
@ -336,7 +336,7 @@ void DosDisk_br::loadSlide(BackgroundInfo& info, const char *name) {
Common::String path(name);
path += ".bmp";
Common::FilesystemNode node = _baseDir.getChild(path);
Common::FSNode node = _baseDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_baseDir, path);
}
@ -363,7 +363,7 @@ void DosDisk_br::loadMask(const char *name, MaskBuffer &buffer) {
}
Common::String filepath;
Common::FilesystemNode node;
Common::FSNode node;
Common::File stream;
filepath = Common::String(name) + ".msk";
@ -384,7 +384,7 @@ void DosDisk_br::loadScenery(BackgroundInfo& info, const char *name, const char
debugC(5, kDebugDisk, "DosDisk_br::loadScenery");
Common::String filepath;
Common::FilesystemNode node;
Common::FSNode node;
Common::File stream;
if (name) {
@ -447,7 +447,7 @@ Table* DosDisk_br::loadTable(const char* name) {
Common::String path(name);
path += ".tab";
Common::FilesystemNode node = _partDir.getChild(path);
Common::FSNode node = _partDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_partDir, path);
}
@ -518,7 +518,7 @@ AmigaDisk_br::AmigaDisk_br(Parallaction *vm) : DosDisk_br(vm) {
_baseBkgDir = _baseDir.getChild("backs");
Common::FilesystemNode commonDir = _baseDir.getChild("common");
Common::FSNode commonDir = _baseDir.getChild("common");
_commonAniDir = commonDir.getChild("anims");
_commonBkgDir = commonDir.getChild("backs");
_commonMscDir = commonDir.getChild("msc");
@ -566,7 +566,7 @@ void AmigaDisk_br::loadScenery(BackgroundInfo& info, const char* name, const cha
debugC(1, kDebugDisk, "AmigaDisk_br::loadScenery '%s', '%s' '%s'", name, mask, path);
Common::String filepath;
Common::FilesystemNode node;
Common::FSNode node;
Common::File stream;
if (name) {
@ -630,7 +630,7 @@ void AmigaDisk_br::loadSlide(BackgroundInfo& info, const char *name) {
Common::String path(name);
path += ".bkg";
Common::FilesystemNode node = _baseBkgDir.getChild(path);
Common::FSNode node = _baseBkgDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_baseBkgDir, path);
}
@ -644,7 +644,7 @@ GfxObj* AmigaDisk_br::loadStatic(const char* name) {
debugC(1, kDebugDisk, "AmigaDisk_br::loadStatic '%s'", name);
Common::String path(name);
Common::FilesystemNode node = _rasDir.getChild(path);
Common::FSNode node = _rasDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_rasDir, path);
}
@ -687,7 +687,7 @@ Frames* AmigaDisk_br::loadFrames(const char* name) {
debugC(1, kDebugDisk, "AmigaDisk_br::loadFrames '%s'", name);
Common::String path(name);
Common::FilesystemNode node = _aniDir.getChild(path);
Common::FSNode node = _aniDir.getChild(path);
if (!node.exists()) {
path += ".ani";
node = _aniDir.getChild(path);
@ -713,7 +713,7 @@ GfxObj* AmigaDisk_br::loadTalk(const char *name) {
debugC(1, kDebugDisk, "AmigaDisk_br::loadTalk '%s'", name);
Common::String path(name);
Common::FilesystemNode node = _talDir.getChild(path);
Common::FSNode node = _talDir.getChild(path);
if (!node.exists()) {
path += ".tal";
node = _talDir.getChild(path);
@ -740,7 +740,7 @@ Font* AmigaDisk_br::loadFont(const char* name) {
Common::String path(name);
path += ".font";
Common::FilesystemNode node = _fntDir.getChild(path);
Common::FSNode node = _fntDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_fntDir, path);
}
@ -773,7 +773,7 @@ Common::SeekableReadStream* AmigaDisk_br::loadMusic(const char* name) {
debugC(5, kDebugDisk, "AmigaDisk_br::loadMusic");
Common::String path(name);
Common::FilesystemNode node = _mscDir.getChild(path);
Common::FSNode node = _mscDir.getChild(path);
if (!node.exists()) {
// TODO (Kirben): error out when music file is not found?
return 0;
@ -789,7 +789,7 @@ Common::ReadStream* AmigaDisk_br::loadSound(const char* name) {
debugC(5, kDebugDisk, "AmigaDisk_br::loadSound");
Common::String path(name);
Common::FilesystemNode node = _sfxDir.getChild(path);
Common::FSNode node = _sfxDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_sfxDir, path);
}
@ -803,7 +803,7 @@ GfxObj* AmigaDisk_br::loadObjects(const char *name) {
debugC(5, kDebugDisk, "AmigaDisk_br::loadObjects");
Common::String path(name);
Common::FilesystemNode node = _partDir.getChild(path);
Common::FSNode node = _partDir.getChild(path);
if (!node.exists()) {
errorFileNotFound(_partDir, path);
}

14
engines/scumm/detection.cpp
View file

@ -178,7 +178,7 @@ static Common::String generateFilenameForDetection(const char *pattern, Filename
}
struct DetectorDesc {
Common::FilesystemNode node;
Common::FSNode node;
Common::String md5;
const MD5Table *md5Entry; // Entry of the md5 table corresponding to this file, if any.
};
@ -192,7 +192,7 @@ static bool testGame(const GameSettings *g, const DescMap &fileMD5Map, const Com
// when performing the matching. The first match is returned, so if you
// search for "resource" and two nodes "RESOURE and "resource" are present,
// the first match is used.
static bool searchFSNode(const Common::FSList &fslist, const Common::String &name, Common::FilesystemNode &result) {
static bool searchFSNode(const Common::FSList &fslist, const Common::String &name, Common::FSNode &result) {
for (Common::FSList::const_iterator file = fslist.begin(); file != fslist.end(); ++file) {
if (!scumm_stricmp(file->getName().c_str(), name.c_str())) {
result = *file;
@ -213,16 +213,16 @@ static Common::Language detectLanguage(const Common::FSList &fslist, byte id) {
// switch to MD5 based detection).
const char *filename = (id == GID_CMI) ? "LANGUAGE.TAB" : "LANGUAGE.BND";
Common::FilePtr tmp;
Common::FilesystemNode langFile;
Common::FSNode langFile;
if (searchFSNode(fslist, filename, langFile))
tmp = Common::FilePtr(langFile.openForReading());
if (!tmp) {
// try loading in RESOURCE sub dir...
Common::FilesystemNode resDir;
Common::FSNode resDir;
Common::FSList tmpList;
if (searchFSNode(fslist, "RESOURCE", resDir)
&& resDir.isDirectory()
&& resDir.getChildren(tmpList, Common::FilesystemNode::kListFilesOnly)
&& resDir.getChildren(tmpList, Common::FSNode::kListFilesOnly)
&& searchFSNode(tmpList, filename, langFile)) {
tmp = Common::FilePtr(langFile.openForReading());
}
@ -787,8 +787,8 @@ PluginError ScummMetaEngine::createInstance(OSystem *syst, Engine **engine) cons
// Fetch the list of files in the current directory
Common::FSList fslist;
Common::FilesystemNode dir(ConfMan.get("path"));
if (!dir.getChildren(fslist, Common::FilesystemNode::kListFilesOnly)) {
Common::FSNode dir(ConfMan.get("path"));
if (!dir.getChildren(fslist, Common::FSNode::kListFilesOnly)) {
return kInvalidPathError;
}

2
engines/scumm/he/resource_he.cpp
View file

@ -166,7 +166,7 @@ int Win32ResExtractor::extractResource_(const char *resType, char *resName, byte
}
/* get file size */
Common::FilesystemNode node(_fileName);
Common::FSNode node(_fileName);
fi.file = node.openForReading();
if (!fi.file) {
error("Cannot open file %s", _fileName.c_str());

2
engines/scumm/he/script_v60he.cpp
View file

@ -1010,7 +1010,7 @@ void ScummEngine_v60he::o60_openFile() {
// TODO / FIXME: Consider using listSavefiles to avoid unneccessary openForLoading calls
_hInFileTable[slot] = _saveFileMan->openForLoading(filename);
if (_hInFileTable[slot] == 0) {
Common::FilesystemNode node(filename);
Common::FSNode node(filename);
_hInFileTable[slot] = node.openForReading();
}
break;

2
engines/sword1/sword1.cpp
View file

@ -143,7 +143,7 @@ void Sword1CheckDirectory(const Common::FSList &fslist, bool *filesFound) {
for (int cnt = 0; cnt < ARRAYSIZE(g_dirNames); cnt++)
if (scumm_stricmp(file->getName().c_str(), g_dirNames[cnt]) == 0) {
Common::FSList fslist2;
if (file->getChildren(fslist2, Common::FilesystemNode::kListFilesOnly))
if (file->getChildren(fslist2, Common::FSNode::kListFilesOnly))
Sword1CheckDirectory(fslist2, filesFound);
}
}

6
engines/sword2/sword2.cpp
View file

@ -152,7 +152,7 @@ GameList Sword2MetaEngine::detectGames(const Common::FSList &fslist) const {
if (0 == scumm_stricmp("clusters", fileName)) {
Common::FSList recList;
if (file->getChildren(recList, Common::FilesystemNode::kListAll)) {
if (file->getChildren(recList, Common::FSNode::kListAll)) {
GameList recGames(detectGames(recList));
if (!recGames.empty()) {
detectedGames.push_back(recGames);
@ -212,8 +212,8 @@ PluginError Sword2MetaEngine::createInstance(OSystem *syst, Engine **engine) con
assert(engine);
Common::FSList fslist;
Common::FilesystemNode dir(ConfMan.get("path"));
if (!dir.getChildren(fslist, Common::FilesystemNode::kListAll)) {
Common::FSNode dir(ConfMan.get("path"));
if (!dir.getChildren(fslist, Common::FSNode::kListAll)) {
return kInvalidPathError;
}

12
gui/browser.cpp
View file

@ -107,7 +107,7 @@ int BrowserDialog::runModal() {
err = FSRefMakePath(&ref, (UInt8*)buf, sizeof(buf)-1);
assert(err == noErr);
_choice = Common::FilesystemNode(buf);
_choice = Common::FSNode(buf);
choiceMade = true;
}
@ -160,9 +160,9 @@ BrowserDialog::BrowserDialog(const char *title, bool dirBrowser)
void BrowserDialog::open() {
if (ConfMan.hasKey("browser_lastpath"))
_node = Common::FilesystemNode(ConfMan.get("browser_lastpath"));
_node = Common::FSNode(ConfMan.get("browser_lastpath"));
if (!_node.isDirectory())
_node = Common::FilesystemNode(".");
_node = Common::FSNode(".");
// Alway refresh file list
updateListing();
@ -227,9 +227,9 @@ void BrowserDialog::updateListing() {
ConfMan.set("browser_lastpath", _node.getPath());
// Read in the data from the file system
Common::FilesystemNode::ListMode listMode =
_isDirBrowser ? Common::FilesystemNode::kListDirectoriesOnly
: Common::FilesystemNode::kListAll;
Common::FSNode::ListMode listMode =
_isDirBrowser ? Common::FSNode::kListDirectoriesOnly
: Common::FSNode::kListAll;
if (!_node.getChildren(_nodeContent, listMode)) {
_nodeContent.clear();
} else {

6
gui/browser.h
View file

@ -50,7 +50,7 @@ public:
virtual void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
#endif
const Common::FilesystemNode &getResult() { return _choice; }
const Common::FSNode &getResult() { return _choice; }
protected:
#ifdef MACOSX
@ -58,10 +58,10 @@ protected:
#else
ListWidget *_fileList;
StaticTextWidget *_currentPath;
Common::FilesystemNode _node;
Common::FSNode _node;
Common::FSList _nodeContent;
#endif
Common::FilesystemNode _choice;
Common::FSNode _choice;
bool _isDirBrowser;
#ifndef MACOSX

14
gui/launcher.cpp
View file

@ -395,7 +395,7 @@ void EditGameDialog::handleCommand(CommandSender *sender, uint32 cmd, uint32 dat
if (browser.runModal() > 0) {
// User made this choice...
Common::FilesystemNode file(browser.getResult());
Common::FSNode file(browser.getResult());
_soundFont->setLabel(file.getPath());
if (!file.getPath().empty() && (file.getPath() != "None"))
@ -413,11 +413,11 @@ void EditGameDialog::handleCommand(CommandSender *sender, uint32 cmd, uint32 dat
BrowserDialog browser("Select directory with game data", true);
if (browser.runModal() > 0) {
// User made his choice...
Common::FilesystemNode dir(browser.getResult());
Common::FSNode dir(browser.getResult());
// TODO: Verify the game can be found in the new directory... Best
// done with optional specific gameid to pluginmgr detectgames?
// FSList files = dir.listDir(FilesystemNode::kListFilesOnly);
// FSList files = dir.listDir(FSNode::kListFilesOnly);
_gamePathWidget->setLabel(dir.getPath());
draw();
@ -431,7 +431,7 @@ void EditGameDialog::handleCommand(CommandSender *sender, uint32 cmd, uint32 dat
BrowserDialog browser("Select additional game directory", true);
if (browser.runModal() > 0) {
// User made his choice...
Common::FilesystemNode dir(browser.getResult());
Common::FSNode dir(browser.getResult());
_extraPathWidget->setLabel(dir.getPath());
draw();
}
@ -443,7 +443,7 @@ void EditGameDialog::handleCommand(CommandSender *sender, uint32 cmd, uint32 dat
BrowserDialog browser("Select directory for saved games", true);
if (browser.runModal() > 0) {
// User made his choice...
Common::FilesystemNode dir(browser.getResult());
Common::FSNode dir(browser.getResult());
_savePathWidget->setLabel(dir.getPath());
draw();
}
@ -953,9 +953,9 @@ void LauncherDialog::addGame() {
if (_browser->runModal() > 0) {
// User made his choice...
Common::FilesystemNode dir(_browser->getResult());
Common::FSNode dir(_browser->getResult());
Common::FSList files;
if (!dir.getChildren(files, Common::FilesystemNode::kListAll)) {
if (!dir.getChildren(files, Common::FSNode::kListAll)) {
error("browser returned a node that is not a directory: '%s'",
dir.getPath().c_str());
}

6
gui/massadd.cpp
View file

@ -58,7 +58,7 @@ enum {
MassAddDialog::MassAddDialog(const Common::FilesystemNode &startDir)
MassAddDialog::MassAddDialog(const Common::FSNode &startDir)
: Dialog("massadddialog"),
_dirsScanned(0),
_okButton(0),
@ -156,10 +156,10 @@ void MassAddDialog::handleTickle() {
// Perform a breadth-first scan of the filesystem.
while (!_scanStack.empty() && (g_system->getMillis() - t) < kMaxScanTime) {
Common::FilesystemNode dir = _scanStack.pop();
Common::FSNode dir = _scanStack.pop();
Common::FSList files;
if (!dir.getChildren(files, Common::FilesystemNode::kListAll)) {
if (!dir.getChildren(files, Common::FSNode::kListAll)) {
error("browser returned a node that is not a directory: '%s'",
dir.getPath().c_str());
}

4
gui/massadd.h
View file

@ -38,14 +38,14 @@ class StaticTextWidget;
class MassAddDialog : public Dialog {
public:
MassAddDialog(const Common::FilesystemNode &startDir);
MassAddDialog(const Common::FSNode &startDir);
//void open();
void handleCommand(CommandSender *sender, uint32 cmd, uint32 data);
void handleTickle();
private:
Common::Stack<Common::FilesystemNode> _scanStack;
Common::Stack<Common::FSNode> _scanStack;
GameList _games;
/**

10
gui/options.cpp
View file

@ -835,7 +835,7 @@ void GlobalOptionsDialog::handleCommand(CommandSender *sender, uint32 cmd, uint3
BrowserDialog browser("Select directory for savegames", true);
if (browser.runModal() > 0) {
// User made his choice...
Common::FilesystemNode dir(browser.getResult());
Common::FSNode dir(browser.getResult());
if (dir.isWritable()) {
_savePath->setLabel(dir.getPath());
} else {
@ -851,7 +851,7 @@ void GlobalOptionsDialog::handleCommand(CommandSender *sender, uint32 cmd, uint3
BrowserDialog browser("Select directory for GUI themes", true);
if (browser.runModal() > 0) {
// User made his choice...
Common::FilesystemNode dir(browser.getResult());
Common::FSNode dir(browser.getResult());
_themePath->setLabel(dir.getPath());
draw();
}
@ -861,7 +861,7 @@ void GlobalOptionsDialog::handleCommand(CommandSender *sender, uint32 cmd, uint3
BrowserDialog browser("Select directory for extra files", true);
if (browser.runModal() > 0) {
// User made his choice...
Common::FilesystemNode dir(browser.getResult());
Common::FSNode dir(browser.getResult());
_extraPath->setLabel(dir.getPath());
draw();
}
@ -872,7 +872,7 @@ void GlobalOptionsDialog::handleCommand(CommandSender *sender, uint32 cmd, uint3
BrowserDialog browser("Select directory for plugins", true);
if (browser.runModal() > 0) {
// User made his choice...
Common::FilesystemNode dir(browser.getResult());
Common::FSNode dir(browser.getResult());
_pluginsPath->setLabel(dir.getPath());
draw();
}
@ -883,7 +883,7 @@ void GlobalOptionsDialog::handleCommand(CommandSender *sender, uint32 cmd, uint3
BrowserDialog browser("Select SoundFont", false);
if (browser.runModal() > 0) {
// User made his choice...
Common::FilesystemNode file(browser.getResult());
Common::FSNode file(browser.getResult());
_soundFont->setLabel(file.getPath());
if (!file.getPath().empty() && (file.getPath() != "None"))

16
gui/themebrowser.cpp
View file

@ -101,10 +101,10 @@ void ThemeBrowser::updateListing() {
// files in other places are ignored in this dialog
// TODO: let the user browse the complete FS too/only the FS?
if (ConfMan.hasKey("themepath"))
addDir(_themes, Common::FilesystemNode(ConfMan.get("themepath")), 0);
addDir(_themes, Common::FSNode(ConfMan.get("themepath")), 0);
#ifdef DATA_PATH
addDir(_themes, Common::FilesystemNode(DATA_PATH));
addDir(_themes, Common::FSNode(DATA_PATH));
#endif
#ifdef MACOSX
@ -112,7 +112,7 @@ void ThemeBrowser::updateListing() {
if (resourceUrl) {
char buf[256];
if (CFURLGetFileSystemRepresentation(resourceUrl, true, (UInt8 *)buf, 256)) {
Common::FilesystemNode resourcePath(buf);
Common::FSNode resourcePath(buf);
addDir(_themes, resourcePath, 0);
}
CFRelease(resourceUrl);
@ -120,9 +120,9 @@ void ThemeBrowser::updateListing() {
#endif
if (ConfMan.hasKey("extrapath"))
addDir(_themes, Common::FilesystemNode(ConfMan.get("extrapath")));
addDir(_themes, Common::FSNode(ConfMan.get("extrapath")));
addDir(_themes, Common::FilesystemNode("."), 0);
addDir(_themes, Common::FSNode("."), 0);
// Populate the ListWidget
Common::StringList list;
@ -137,7 +137,7 @@ void ThemeBrowser::updateListing() {
draw();
}
void ThemeBrowser::addDir(ThList &list, const Common::FilesystemNode &node, int level) {
void ThemeBrowser::addDir(ThList &list, const Common::FSNode &node, int level) {
if (level < 0)
return;
@ -145,7 +145,7 @@ void ThemeBrowser::addDir(ThList &list, const Common::FilesystemNode &node, int
return;
Common::FSList fslist;
if (!node.getChildren(fslist, Common::FilesystemNode::kListAll))
if (!node.getChildren(fslist, Common::FSNode::kListAll))
return;
for (Common::FSList::const_iterator i = fslist.begin(); i != fslist.end(); ++i) {
@ -169,7 +169,7 @@ void ThemeBrowser::addDir(ThList &list, const Common::FilesystemNode &node, int
}
}
bool ThemeBrowser::isTheme(const Common::FilesystemNode &node, Entry &out) {
bool ThemeBrowser::isTheme(const Common::FSNode &node, Entry &out) {
Common::ConfigFile cfg;
Common::String type;

4
gui/themebrowser.h
View file

@ -57,8 +57,8 @@ private:
void updateListing();
void addDir(ThList &list, const Common::FilesystemNode &node, int level = 4);
bool isTheme(const Common::FilesystemNode &node, Entry &out);
void addDir(ThList &list, const Common::FSNode &node, int level = 4);
bool isTheme(const Common::FSNode &node, Entry &out);
};
} // end of namespace GUI