Use abstract factories to initialize FilesystemNode objects.

svn-id: r26739

backends/fs/AbstractFilesystemFactory.h

@@ -0,0 +1,48 @@
+#ifndef ABSTRACTFILESYSTEMFACTORY_H_
+#define ABSTRACTFILESYSTEMFACTORY_H_
+
+#include "common/str.h"
+
+/**
+ * Creates concrete FilesystemNode objects depending on the current architecture.
+ */
+class AbstractFilesystemFactory {
+public:
+	typedef Common::String String;
+
+	/**
+	 * Destructor.
+	 */
+	virtual ~AbstractFilesystemFactory() {};
+	
+	/**
+	 * Returns a node representing the "current directory".
+	 * If your system does not support this concept, you can either try to
+	 * emulate it or simply return some "sensible" default directory node,
+	 * e.g. the same value as getRoot() returns.
+	 */
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const = 0;
+	
+	/**
+	 * Construct a node based on a path; the path is in the same format as it
+	 * would be for calls to fopen().
+	 *
+	 * Furthermore getNodeForPath(oldNode.path()) should create a new node
+	 * 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.
+	 */
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const = 0;
+	
+	/**
+	 * Returns a special node representing the filesystem root.
+	 * The starting point for any file system browsing.
+	 * 
+	 * 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;
+};
+
+#endif /*ABSTRACTFILESYSTEMFACTORY_H_*/

backends/fs/FilesystemFactoryMaker.cpp

@@ -0,0 +1,113 @@
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/*
+ * All the following includes choose, at compile time, which specific backend will be used
+ * during the execution of the ScummVM.
+ * 
+ * It has to be done this way because not all the necessary libraries will be available in
+ * all build environments. Additionally, this results in smaller binaries.
+ */
+#if defined(__amigaos4__)
+	#include "backends/fs/amigaos4/AmigaOSFilesystemFactory.cpp"
+#endif
+ 
+#if defined(__DC__)
+	#include "backends/fs/dc/RoninCDFilesystemFactory.cpp"
+#endif
+
+#if defined(__DS__)
+	#include "backends/fs/ds/DSFilesystemFactory.cpp"
+#endif
+
+#if defined(__GP32__)
+	#include "backends/fs/gp32/GP32FilesystemFactory.cpp"
+#endif
+
+#if defined(__MORPHOS__)
+	#include "backends/fs/morphos/ABoxFilesystemFactory.cpp"
+#endif
+
+#if defined(PALMOS_MODE)
+	#include "backends/fs/palmos/PalmOSFilesystemFactory.cpp"
+#endif
+
+#if defined(__PLAYSTATION2__)
+	#include "backends/fs/ps2/Ps2FilesystemFactory.cpp"
+#endif
+
+#if defined(__PSP__)
+	#include "backends/fs/psp/PSPFilesystemFactory.cpp"
+#endif
+
+#if defined(__SYMBIAN32__)
+	#include "backends/fs/symbian/SymbianFilesystemFactory.cpp"
+#endif
+
+#if defined(UNIX)
+	#include "backends/fs/posix/POSIXFilesystemFactory.cpp"
+#endif
+
+#if defined(WIN32)
+	#include "backends/fs/windows/WindowsFilesystemFactory.cpp"
+#endif
+
+/**
+ * Creates concrete FilesystemFactory objects depending on the current architecture.
+ */
+class FilesystemFactoryMaker {
+public:
+
+	/**
+	 * Returns the correct concrete factory depending on the current build architecture.
+	 */
+	static AbstractFilesystemFactory *makeFactory();
+	
+protected:
+	FilesystemFactoryMaker() {}; // avoid instances of this class
+};
+
+AbstractFilesystemFactory *FilesystemFactoryMaker::makeFactory(){
+	#if defined(__amigaos4__)
+		return AmigaOSFilesystemFactory::instance();
+	#endif
+	
+	#if defined(__DC__)
+		return RoninCDFilesystemFactory::instance();
+	#endif
+	
+	#if defined(__DS__)
+		return DSFilesystemFactory::instance();
+	#endif
+	
+	#if defined(__GP32__)
+		return GP32FilesystemFactory::instance();
+	#endif
+	
+	#if defined(__MORPHOS__)
+		return ABoxFilesystemFactory::instance();
+	#endif
+	
+	#if defined(PALMOS_MODE)
+		return PalmOSFilesystemFactory::instance();
+	#endif
+	
+	#if defined(__PLAYSTATION2__)
+		return Ps2FilesystemFactory::instance();
+	#endif
+	
+	#if defined(__PSP__)
+		return PSPFilesystemFactory::instance();
+	#endif
+	
+	#if defined(__SYMBIAN32__)
+		return SymbianFilesystemFactory::instance();
+	#endif
+	
+	#if defined(UNIX)
+		return POSIXFilesystemFactory::instance();
+	#endif
+	
+	#if defined(WIN32)
+		return WindowsFilesystemFactory::instance();
+	#endif
+}

backends/fs/abstract-fs.h

@@ -46,75 +46,72 @@ protected:
 	typedef FilesystemNode::ListMode ListMode;
 
 	/**
-	 * The parent node of this directory.
+	 * Returns the child node with the given name. If no child with this name
-	 * The parent of the root is the root itself.
-	 */
-	virtual AbstractFilesystemNode *parent() const = 0;
-
-	/**
-	 * The child node with the given name. If no child with this name
 	 * exists, returns 0. When called on a non-directory node, it should
 	 * handle this gracefully by returning 0.
 	 *
+	 * Example:
+	 * 			Calling getChild() for a node with path "/foo/bar" using name="file.txt",
+	 * 			would produce a new node with "/foo/bar/file.txt" as path.
+	 * 
+	 * @note This function will append a separator char (\ or /) to the end of the
+	 * path if needed.
+	 * 
 	 * @note Handling calls on non-dir nodes gracefully makes it possible to
 	 * switch to a lazy type detection scheme in the future.
+	 * 
+	 * @param name String containing the name of the child to create a new node.
 	 */
-	virtual AbstractFilesystemNode *child(const String &name) const = 0;
+	virtual AbstractFilesystemNode *getChild(const String &name) const = 0;
-
 
 	/**
-	 * Returns a special node representing the FS root. The starting point for
+	 * The parent node of this directory.
-	 * any file system browsing.
+	 * The parent of the root is the root itself.
-	 * 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:).
 	 */
-	static AbstractFilesystemNode *getRoot();
+	virtual AbstractFilesystemNode *getParent() const = 0;
-
-	/**
-	 * Returns a node representing the "current directory". If your system does
-	 * not support this concept, you can either try to emulate it or
-	 * simply return some "sensible" default directory node, e.g. the same
-	 * value as getRoot() returns.
-	 */
-	static AbstractFilesystemNode *getCurrentDirectory();
-
-
-	/**
-	 * Construct a node based on a path; the path is in the same format as it
-	 * would be for calls to fopen().
-	 *
-	 * Furthermore getNodeForPath(oldNode.path()) should create a new node
-	 * identical to oldNode. Hence, we can use the "path" value for persistent
-	 * storage e.g. in the config file.
-	 *
-	 * @todo: This is of course a place where non-portable code easily will sneak
-	 *        in, because the format of the path used here is not well-defined.
-	 *        So we really should reconsider this API and try to come up with
-	 *        something which is more portable but still flexible enough for our
-	 *        purposes.
-	 */
-	static AbstractFilesystemNode *getNodeForPath(const String &path);
-
 
 public:
+	/**
+	 * Destructor.
+	 */
 	virtual ~AbstractFilesystemNode() {}
 
-	virtual String name() const = 0;
+	/**
+	 * Return a list of child nodes of this directory node. If called on a node
+	 * that does not represent a directory, false is returned.
+	 * 
+	 * @param list List to put the contents of the directory in.
+	 * @param mode Mode to use while listing the directory.
+	 * @return true if succesful, false otherwise (e.g. when the directory does not exist).
+	 */
+	virtual bool getChildren(AbstractFSList &list, ListMode mode) const = 0;
+
+	/**
+	 * Returns a human readable path string.
+	 * 
+	 * @note By default, this method returns the value of getName().
+	 */
+	virtual String getDisplayName() const { return getName(); }
+
+	/**
+	 * Returns a string with an architecture dependent path description.
+	 */
+	virtual String getName() const = 0;
 	
-	// By default, we use the actual file name as 'display name'.
+	/**
-	virtual String displayName() const { return name(); }
+	 * Returns the 'path' of the current node, usable in fopen().
-
+	 */
-	virtual bool isValid() const = 0;
+	virtual String getPath() const = 0;
-
+	
+	/**
+	 * Indicates whether this path refers to a directory or not.
+	 */
 	virtual bool isDirectory() const = 0;
 	
 	/**
-	 * Return the 'path' of the current node, usable in fopen(). See also
+	 * Indicates whether this path is valid or not for usage.
-	 * the static getNodeForPath() method.
 	 */
-	virtual String path() const = 0;
+	virtual bool isValid() const = 0;
-	virtual bool listDir(AbstractFSList &list, ListMode mode) const = 0;
-
 
 	/* TODO:
 	bool exists();
@@ -123,9 +120,8 @@ public:
 	bool isFile();
 
 	bool isReadable();
-	bool isWriteable();
+	bool isWritable();
 	*/
 };
 
-
 #endif

backends/fs/amigaos4/AmigaOSFilesystemFactory.cpp

@@ -0,0 +1,23 @@
+#include "backends/fs/amigaos4/AmigaOSFilesystemFactory.h"
+#include "backends/fs/amigaos4/amigaos4-fs.cpp"
+
+AmigaOSFilesystemFactory *AmigaOSFilesystemFactory::_instance = 0;
+
+AmigaOSFilesystemFactory *AmigaOSFilesystemFactory::instance(){
+	if(_instance == 0){
+		_instance = new AmigaOSFilesystemFactory();
+	}
+	return _instance;
+}
+
+AbstractFilesystemNode *AmigaOSFilesystemFactory::makeRootFileNode() const {
+	return new AmigaOSFilesystemNode();
+}
+
+AbstractFilesystemNode *AmigaOSFilesystemFactory::makeCurrentDirectoryFileNode() const {
+	return new AmigaOSFilesystemNode();
+}
+
+AbstractFilesystemNode *AmigaOSFilesystemFactory::makeFileNodePath(const String &path) const {
+	return new AmigaOSFilesystemNode(path);
+}

backends/fs/amigaos4/AmigaOSFilesystemFactory.h

@@ -0,0 +1,38 @@
+#ifndef AMIGAOSFILESYSTEMFACTORY_H_
+#define AMIGAOSFILESYSTEMFACTORY_H_
+
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/**
+ * Creates AmigaOSFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class AmigaOSFilesystemFactory : public AbstractFilesystemFactory {	
+public:
+	typedef Common::String String;
+	
+	/**
+	 * Creates an instance of AmigaOSFilesystemFactory using the Singleton pattern.
+	 * 
+	 * @return A unique instance of AmigaOSFilesytemFactory.
+	 */
+	static AmigaOSFilesystemFactory *instance();
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~AmigaOSFilesystemFactory() {};
+		
+	virtual AbstractFilesystemNode *makeRootFileNode() const;
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	
+protected:
+	AmigaOSFilesystemFactory() {};
+		
+private:
+	static AmigaOSFilesystemFactory *_instance;
+};
+
+#endif /*AMIGAOSFILESYSTEMFACTORY_H_*/

backends/fs/amigaos4/amigaos4-fs.cpp

@@ -1,5 +1,5 @@
 /* ScummVM - Scumm Interpreter
- * Copyright (C) 2005-2006 The ScummVM project, contribution by Hans-Jörg Frieden and Juha Niemimäki
+ * Copyright (C) 2005-2006 The ScummVM project, contribution by Hans-J<EFBFBD>rg Frieden and Juha Niemim<EFBFBD>ki
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -35,58 +35,73 @@
 #include <common/stdafx.h>
 
 #include "common/util.h"
-
 #include "engines/engine.h"
 #include "backends/fs/abstract-fs.h"
 
 #define ENTER() /* debug(6, "Enter") */
 #define LEAVE() /* debug(6, "Leave") */
 
-
 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.
+ */
 class AmigaOSFilesystemNode : public AbstractFilesystemNode {
-	protected:
+protected:
-		BPTR _pFileLock;
+	BPTR _pFileLock;
-		String _sDisplayName;
+	String _sDisplayName;
-		bool _bIsDirectory;
+	String _sPath;
-		bool _bIsValid;
+	bool _bIsDirectory;
-		String _sPath;
+	bool _bIsValid;
 
-	public:
+public:
-		AmigaOSFilesystemNode();
+	/**
-		AmigaOSFilesystemNode(BPTR pLock, const char *pDisplayName = 0);
+	 * Creates a AmigaOSFilesystemNode with the root node as path.
-		AmigaOSFilesystemNode(const String &p);
+	 */
+	AmigaOSFilesystemNode();
+	
+	/**
+	 * Creates a AmigaOSFilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 */
+	AmigaOSFilesystemNode(const String &p);
+	
+	/**
+	 * FIXME: document this constructor.
+	 */
+	AmigaOSFilesystemNode(BPTR pLock, const char *pDisplayName = 0);
 
-	    // Note: Copy constructor is needed because it duplicates the file lock
+    /**
-		AmigaOSFilesystemNode(const AmigaOSFilesystemNode &node);
+     * Copy constructor.
-		
+     * 
-		virtual ~AmigaOSFilesystemNode();
+     * @note Needed because it duplicates the file lock
+     */
+	AmigaOSFilesystemNode(const AmigaOSFilesystemNode &node);
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~AmigaOSFilesystemNode();
 
-		virtual String displayName() const { return _sDisplayName; };
+	virtual String getDisplayName() const { return _sDisplayName; };
-		virtual String name() const { return _sDisplayName; };
+	virtual String getName() const { return _sDisplayName; };
-		virtual bool isValid() const { return _bIsValid; };
+	virtual String getPath() const { return _sPath; };
-		virtual bool isDirectory() const { return _bIsDirectory; };
+	virtual bool isValid() const { return _bIsValid; };
-		virtual String path() const { return _sPath; };
+	virtual bool isDirectory() const { return _bIsDirectory; };
-
+	
-		virtual bool listDir(AbstractFSList &list, ListMode mode) const;
+	virtual AbstractFilesystemNode *getChild(const String &n) const;
-		virtual AbstractFSList listVolumes() const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode) const;
-		virtual AbstractFilesystemNode *parent() const;
+	virtual AbstractFilesystemNode *getParent() const;
-		virtual AbstractFilesystemNode *child(const String &n) const;
+	
+	/**
+	 * Creates a list with all the volumes present in the root node.
+	 */
+	virtual AbstractFSList listVolumes() const;
 };
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-	return AbstractFilesystemNode::getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-	return new AmigaOSFilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String	&path) {
-	return new AmigaOSFilesystemNode(path);
-}
-
 AmigaOSFilesystemNode::AmigaOSFilesystemNode() {
 	ENTER();
 	_sDisplayName = "Available Disks";
@@ -97,7 +112,6 @@ AmigaOSFilesystemNode::AmigaOSFilesystemNode() {
 	LEAVE();
 }
 
-
 AmigaOSFilesystemNode::AmigaOSFilesystemNode(const String &p) {
 	ENTER();
 
@@ -147,7 +161,6 @@ AmigaOSFilesystemNode::AmigaOSFilesystemNode(const String &p) {
 				const char c = _sPath.lastChar();
 				if (c != '/' && c != ':')
 					_sPath += '/';
-
 			}
 			else {
 				//_bIsDirectory = false;
@@ -167,7 +180,7 @@ AmigaOSFilesystemNode::AmigaOSFilesystemNode(BPTR pLock, const char *pDisplayNam
 	int bufSize = MAXPATHLEN;
 	_pFileLock = 0;
 
-	while (1) {
+	while (true) {
 		char *n = new char[bufSize];
 		if (IDOS->NameFromLock(pLock, (STRPTR)n, bufSize) != DOSFALSE) {
 			_sPath = n;
@@ -183,6 +196,7 @@ AmigaOSFilesystemNode::AmigaOSFilesystemNode(BPTR pLock, const char *pDisplayNam
 			delete [] n;
 			return;
 		}
+		
 		bufSize *= 2;
 		delete [] n;
 	}
@@ -235,7 +249,31 @@ AmigaOSFilesystemNode::~AmigaOSFilesystemNode() {
 	LEAVE();
 }
 
-bool AmigaOSFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *AmigaOSFilesystemNode::getChild(const String &n) const {
+	if (!_bIsDirectory) {
+		debug(6, "Not a directory");
+		return 0;
+	}
+
+	String newPath(_sPath);
+
+	if (_sPath.lastChar() != '/')
+		newPath += '/';
+
+	newPath += n;
+	BPTR lock = IDOS->Lock(newPath.c_str(), SHARED_LOCK);
+
+	if (!lock) {
+		debug(6, "Bad path");
+		return 0;
+	}
+
+	IDOS->UnLock(lock);
+
+	return new AmigaOSFilesystemNode(newPath);
+}
+
+bool AmigaOSFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode) const {
 	ENTER();
 
 	if (!_bIsValid) {
@@ -305,10 +343,11 @@ bool AmigaOSFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const
 	}
 
 	LEAVE();
+	
 	return true;
 }
 
-AbstractFilesystemNode *AmigaOSFilesystemNode::parent() const {
+AbstractFilesystemNode *AmigaOSFilesystemNode::getParent() const {
 	ENTER();
 
 	if (!_bIsDirectory) {
@@ -334,33 +373,8 @@ AbstractFilesystemNode *AmigaOSFilesystemNode::parent() const {
 		node = new AmigaOSFilesystemNode();
 
 	LEAVE();
-	return node;
-}
-
-AbstractFilesystemNode *AmigaOSFilesystemNode::child(const String &n) const {
 	
-	if (!_bIsDirectory) {
+	return node;
-		debug(6, "Not a directory");
-		return 0;
-	}
-
-	String newPath(_sPath);
-
-	if (_sPath.lastChar() != '/')
-		newPath += '/';
-
-	newPath += n;
-
-	BPTR lock = IDOS->Lock(newPath.c_str(), SHARED_LOCK);
-
-	if (!lock) {
-		debug(6, "Bad path");
-		return 0;
-	}
-
-	IDOS->UnLock(lock);
-
-	return new AmigaOSFilesystemNode(newPath);
 }
 
 AbstractFSList AmigaOSFilesystemNode::listVolumes()	const {
@@ -428,7 +442,8 @@ AbstractFSList AmigaOSFilesystemNode::listVolumes()	const {
 	IDOS->UnLockDosList(kLockFlags);
 
 	LEAVE();
+	
 	return myList;
 }
 
-#endif
+#endif //defined(__amigaos4__)

backends/fs/dc/RoninCDFilesystemFactory.cpp

@@ -0,0 +1,23 @@
+#include "backends/fs/dc/RoninCDFilesystemFactory.h"
+#include "backends/fs/dc/dc-fs.cpp"
+
+RoninCDFilesystemFactory *RoninCDFilesystemFactory::_instance = 0;
+
+RoninCDFilesystemFactory *RoninCDFilesystemFactory::instance(){
+	if(_instance == 0){
+		_instance = new RoninCDFilesystemFactory();
+	}
+	return _instance;
+}
+
+AbstractFilesystemNode *RoninCDFilesystemFactory::makeRootFileNode() const {
+	return new RoninCDFilesystemNode();
+}
+
+AbstractFilesystemNode *RoninCDFilesystemFactory::makeCurrentDirectoryFileNode() const {
+	return new RoninCDFilesystemNode();
+}
+
+AbstractFilesystemNode *RoninCDFilesystemFactory::makeFileNodePath(const String &path) const {
+	return new RoninCDFilesystemNode(path, true);
+}

backends/fs/dc/RoninCDFilesystemFactory.h

@@ -0,0 +1,38 @@
+#ifndef RONINCDFILESYSTEMFACTORY_H_
+#define RONINCDFILESYSTEMFACTORY_H_
+
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/**
+ * Creates RoninCDFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class RoninCDFilesystemFactory : public AbstractFilesystemFactory {	
+public:
+	typedef Common::String String;
+	
+	/**
+	 * Creates an instance of RoninCDFilesystemFactory using the Singleton pattern.
+	 * 
+	 * @return A unique instance of RoninCDFilesytemFactory.
+	 */
+	static RoninCDFilesystemFactory *instance();
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~RoninCDFilesystemFactory() {};
+		
+	virtual AbstractFilesystemNode *makeRootFileNode() const;
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	
+protected:
+	RoninCDFilesystemFactory() {};
+		
+private:
+	static RoninCDFilesystemFactory *_instance;
+};
+
+#endif /*RONINCDFILESYSTEMFACTORY_H_*/

backends/fs/dc/dc-fs.cpp

@@ -22,40 +22,59 @@
 #if defined(__DC__)
 
 #include "common/stdafx.h"
-
 #include "backends/fs/abstract-fs.h"
 
 #include <ronin/cdfs.h>
 #include <stdio.h>
 #include <unistd.h>
 
-/*
+/**
- * Implementation of the ScummVM file system API based on ronin.
+ * Implementation of the ScummVM file system API based on POSIX.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class RoninCDFilesystemNode : public AbstractFilesystemNode {
 protected:
 	String _displayName;
+	String _path;
 	bool _isDirectory;
 	bool _isValid;
-	String _path;
 
 public:
+	/**
+	 * Creates a RoninCDFilesystemNode with the root node as path.
+	 */
 	RoninCDFilesystemNode();
+	
+	/**
+	 * Creates a RoninCDFilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 * @param verify true if the isValid and isDirectory flags should be verified during the construction.
+	 */
 	RoninCDFilesystemNode(const String &path, bool verify);
 
-	virtual String displayName() const { return _displayName; }
+	virtual String getDisplayName() const { return _displayName; }
-	virtual String name() const { return _displayName; }
+	virtual String getName() const { return _displayName; }
-	virtual bool isValid() const { return _isValid; }
+	virtual String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
-	virtual String path() const { return _path; }
+	virtual bool isValid() const { return _isValid; }
 
-	virtual bool listDir(AbstractFSList &list, ListMode mode) const;
+	virtual AbstractFilesystemNode *getChild(const String &n) const;
-	virtual AbstractFilesystemNode *parent() const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode) const;
-	virtual AbstractFilesystemNode *child(const String &n) const;
+	virtual AbstractFilesystemNode *getParent() const;
 };
 
-
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ * 			/foo/bar.txt would return /bar.txt
+ * 			/foo/bar/    would return /bar/
+ *  
+ * @param str String containing the path.
+ * @return Pointer to the first char of the last component inside str.
+ */
 static const char *lastPathComponent(const Common::String &str) {
 	const char *start = str.c_str();
 	const char *cur = start + str.size() - 2;
@@ -67,22 +86,6 @@ static const char *lastPathComponent(const Common::String &str) {
 	return cur + 1;
 }
 
-
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-	// Since there is no way to _set_ the current directory,
-	// it will always be /...
-
-	return getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-	return new RoninCDFilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-	return new RoninCDFilesystemNode(path, true);
-}
-
 RoninCDFilesystemNode::RoninCDFilesystemNode() {
 	// The root dir.
 	_path = "/";
@@ -115,10 +118,23 @@ RoninCDFilesystemNode::RoninCDFilesystemNode(const String &p, bool verify) {
 	}
 }
 
-bool RoninCDFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *RoninCDFilesystemNode::getChild(const 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);
-	DIR *dirp = opendir(_path.c_str());
+	
+	String newPath(_path);
+	if (_path.lastChar() != '/')
+		newPath += '/';
+	newPath += n;
 
+	return new RoninCDFilesystemNode(newPath, true);
+}
+
+bool RoninCDFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode) const {
+	assert(_isDirectory);
+	
+	DIR *dirp = opendir(_path.c_str());
 	struct dirent *dp;
 
 	if (dirp == NULL)
@@ -147,35 +163,22 @@ bool RoninCDFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const
 
 		if (entry._isDirectory)
 			entry._path += "/";
+			
 		myList.push_back(new RoninCDFilesystemNode(entry));
 	}
 	closedir(dirp);
+	
 	return true;
 }
 
-AbstractFilesystemNode *RoninCDFilesystemNode::parent() const {
+AbstractFilesystemNode *RoninCDFilesystemNode::getParent() const {
 	if (_path == "/")
 		return 0;
 
 	const char *start = _path.c_str();
 	const char *end = lastPathComponent(_path);
 
-	RoninCDFilesystemNode *p = new RoninCDFilesystemNode(String(start, end - start), false);
+	return new RoninCDFilesystemNode(String(start, end - start), false);
-
-	return p;
-}
-
-AbstractFilesystemNode *RoninCDFilesystemNode::child(const 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);
-	String newPath(_path);
-	if (_path.lastChar() != '/')
-		newPath += '/';
-	newPath += n;
-	RoninCDFilesystemNode *p = new RoninCDFilesystemNode(newPath, true);
-
-	return p;
 }
 
 #endif // defined(__DC__)

backends/fs/ds/DSFilesystemFactory.cpp

@@ -0,0 +1,36 @@
+#include "backends/fs/ds/DSFilesystemFactory.h"
+#include "backends/fs/ds/ds-fs.cpp"
+#include "dsmain.h" //for the isGBAMPAvailable() function
+
+DSFilesystemFactory *DSFilesystemFactory::_instance = 0;
+
+DSFilesystemFactory *DSFilesystemFactory::instance(){
+	if(_instance == 0){
+		_instance = new DSFilesystemFactory();
+	}
+	return _instance;
+}
+
+AbstractFilesystemNode *DSFilesystemFactory::makeRootFileNode() const {
+	if (DS::isGBAMPAvailable()) {
+		return new DS::GBAMPFileSystemNode();
+	} else {
+		return new DS::DSFileSystemNode();
+	}
+}
+
+AbstractFilesystemNode *DSFilesystemFactory::makeCurrentDirectoryFileNode() const {
+	if (DS::isGBAMPAvailable()) {
+		return new DS::GBAMPFileSystemNode();
+	} else {
+		return new DS::DSFileSystemNode();
+	}
+}
+
+AbstractFilesystemNode *DSFilesystemFactory::makeFileNodePath(const String &path) const {
+	if (DS::isGBAMPAvailable()) {
+		return new DS::GBAMPFileSystemNode(path);
+	} else {
+		return new DS::DSFileSystemNode(path);
+	}
+}

backends/fs/ds/DSFilesystemFactory.h

@@ -0,0 +1,38 @@
+#ifndef DSFILESYSTEMFACTORY_H_
+#define DSFILESYSTEMFACTORY_H_
+
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/**
+ * Creates DSFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class DSFilesystemFactory : public AbstractFilesystemFactory {	
+public:
+	typedef Common::String String;
+	
+	/**
+	 * Creates an instance of DSFilesystemFactory using the Singleton pattern.
+	 * 
+	 * @return A unique instance of DSFilesytemFactory.
+	 */
+	static DSFilesystemFactory *instance();
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~DSFilesystemFactory() {};
+		
+	virtual AbstractFilesystemNode *makeRootFileNode() const;
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	
+protected:
+	DSFilesystemFactory() {};
+		
+private:
+	static DSFilesystemFactory *_instance;
+};
+
+#endif /*DSFILESYSTEMFACTORY_H_*/

backends/fs/ds/ds-fs.cpp

@@ -17,7 +17,6 @@
  *
  */
 
-
 #include "stdafx.h"
 #include "str.h"
 #include "fs.h"
@@ -27,14 +26,10 @@
 #include "dsmain.h"
 #include "gba_nds_fat.h"
 
-
 namespace DS {
 
-
-
-
 //////////////////////////////////////////////////////////////
-// DSFileSystemNode - Flash ROM file system using Zip files
+// DSFileSystemNode - Flash ROM file system using Zip files //
 //////////////////////////////////////////////////////////////
 
 ZipFile*   	DSFileSystemNode::_zipFile = NULL;
@@ -63,7 +58,6 @@ DSFileSystemNode::DSFileSystemNode(const String& path) {
 	char disp[128];
 	char* pathStr = (char *) path.c_str();
 	
-	
 	int lastSlash = 3;
 	for (int r = 0; r < (int) strlen(pathStr) - 1; r++) {
 		if (path[r] == '\\') {
@@ -78,13 +72,10 @@ DSFileSystemNode::DSFileSystemNode(const String& path) {
 //	_isValid = true;
 //	_isDirectory = false;
 
-
-
 	if (!strncmp(pathStr, "ds:/", 4)) {
 		pathStr += 4;
 	}
 	
-
 	if (*pathStr == '\0') {
 		_isValid = true;
 		_isDirectory = true;
@@ -127,35 +118,10 @@ DSFileSystemNode::DSFileSystemNode(const String& path, bool isDir) {
 }
 
 DSFileSystemNode::DSFileSystemNode(const DSFileSystemNode* node) {
-
+	//TODO: not implemented?
 }
 
-AbstractFilesystemNode* DSFileSystemNode::parent() const {
+AbstractFilesystemNode *DSFileSystemNode::getChild(const Common::String& n) const {
-//	consolePrintf("parent\n");
-	DSFileSystemNode *p;
-
-	if (_path != "ds:/") {  
-		char *path = (char *) _path.c_str();
-		int lastSlash = 4;
-		
-		for (int r = 4; r < (int) strlen((char *) path); r++) {
-			if (path[r] == '\\') {
-				lastSlash = r;
-			}
-		}
-
-		p = new DSFileSystemNode(String(path, lastSlash));
-		((DSFileSystemNode *) (p))->_isDirectory = true;
-	} else {
-		p = new DSFileSystemNode();
-	}
-
-	return p;
-
-}
-
-
-AbstractFilesystemNode *DSFileSystemNode::child(const Common::String& n) const {
 	if (_path.lastChar() == '\\') {
 		return new DSFileSystemNode(_path + n);
 	} else {
@@ -165,14 +131,10 @@ AbstractFilesystemNode *DSFileSystemNode::child(const Common::String& n) const {
 	return NULL;
 }
 
-
+bool DSFileSystemNode::getChildren(AbstractFSList &dirList, ListMode mode) const {
-bool DSFileSystemNode::listDir(AbstractFSList &dirList, ListMode mode) const {
 //	consolePrintf("Listdir\n");
-
-	
 //	consolePrintf("Directory\n");
 
-	
 	char temp[128];
 	strcpy(temp, _path.c_str());
 
@@ -187,14 +149,13 @@ bool DSFileSystemNode::listDir(AbstractFSList &dirList, ListMode mode) const {
 /*			// This is the root dir, so add the RAM folder
 			DSFileSystemNode* dsfsn = new DSFileSystemNode("ds:/ram");
 			dsfsn->_isDirectory = true;
-			dirList->push_back(wrap(dsfsn));*/
+			dirList->push_back(wrap(dsfsn));
+*/
 		}
 	} else {
 		_zipFile->changeDirectory(temp);
 	}
 	
-	
-	
 	if (_zipFile->restartFile()) {
 		do {
 			char n[128];	
@@ -215,12 +176,32 @@ bool DSFileSystemNode::listDir(AbstractFSList &dirList, ListMode mode) const {
 	return true;
 }
 
+AbstractFilesystemNode* DSFileSystemNode::getParent() const {
+//	consolePrintf("parent\n");
+	DSFileSystemNode *p;
 
+	if (_path != "ds:/") {  
+		char *path = (char *) _path.c_str();
+		int lastSlash = 4;
+		
+		for (int r = 4; r < (int) strlen((char *) path); r++) {
+			if (path[r] == '\\') {
+				lastSlash = r;
+			}
+		}
 
+		p = new DSFileSystemNode(String(path, lastSlash));
+		((DSFileSystemNode *) (p))->_isDirectory = true;
+	} else {
+		p = new DSFileSystemNode();
+	}
 
-/////////////////////////////////////////////////////////////////////////
+	return p;
-// GBAMPFileSystemNode - File system using GBA Movie Player and CF card
+}
-/////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////
+// GBAMPFileSystemNode - File system using GBA Movie Player and CF card //
+//////////////////////////////////////////////////////////////////////////
 
 GBAMPFileSystemNode::GBAMPFileSystemNode() {
 	_displayName = "mp:/";
@@ -287,35 +268,10 @@ GBAMPFileSystemNode::GBAMPFileSystemNode(const String& path, bool isDirectory) {
 
 
 GBAMPFileSystemNode::GBAMPFileSystemNode(const GBAMPFileSystemNode* node) {
-
+	//TODO: not implemented?
 }
 
-
+AbstractFilesystemNode *GBAMPFileSystemNode::getChild(const Common::String& n) const {
-AbstractFilesystemNode* GBAMPFileSystemNode::parent() const {
-//	consolePrintf("parent\n");
-	GBAMPFileSystemNode *p;
-
-	if (_path != "mp:/") {  
-		char *path = (char *) _path.c_str();
-		int lastSlash = 4;
-		
-		for (int r = 4; r < (int) strlen((char *) path); r++) {
-			if (path[r] == '/') {
-				lastSlash = r;
-			}
-		}
-
-		p = new GBAMPFileSystemNode(String(path, lastSlash));
-		p->_isDirectory = true;
-	} else {
-		p = new GBAMPFileSystemNode();
-	}
-
-	return p;
-
-}
-
-AbstractFilesystemNode *GBAMPFileSystemNode::child(const Common::String& n) const {
 	if (_path.lastChar() == '\\') {
 		return new DSFileSystemNode(_path + n);
 	} else {
@@ -325,7 +281,7 @@ AbstractFilesystemNode *GBAMPFileSystemNode::child(const Common::String& n) cons
 	return NULL;
 }
 
-bool GBAMPFileSystemNode::listDir(AbstractFSList& dirList, ListMode mode) const {
+bool GBAMPFileSystemNode::getChildren(AbstractFSList& dirList, ListMode mode) const {
 //	consolePrintf("Listdir\n");
 
 	enum { TYPE_NO_MORE = 0, TYPE_FILE = 1, TYPE_DIR = 2 };
@@ -343,7 +299,6 @@ bool GBAMPFileSystemNode::listDir(AbstractFSList& dirList, ListMode mode) const
 		pathTemp++;
 	}
 
-
 //	consolePrintf("This dir: %s\n", path);
 	FAT_chdir(path);
 	
@@ -366,8 +321,6 @@ bool GBAMPFileSystemNode::listDir(AbstractFSList& dirList, ListMode mode) const
 //				dsfsn->_isDirectory = entryType == DIR;
 				dirList.push_back((dsfsn));
 			}
-		
-		
 		} else {
 //			consolePrintf("Skipping %s\n", fname);
 		}
@@ -382,6 +335,28 @@ bool GBAMPFileSystemNode::listDir(AbstractFSList& dirList, ListMode mode) const
 	return true;
 }
 
+AbstractFilesystemNode* GBAMPFileSystemNode::getParent() const {
+//	consolePrintf("parent\n");
+	GBAMPFileSystemNode *p;
+
+	if (_path != "mp:/") {  
+		char *path = (char *) _path.c_str();
+		int lastSlash = 4;
+		
+		for (int r = 4; r < (int) strlen((char *) path); r++) {
+			if (path[r] == '/') {
+				lastSlash = r;
+			}
+		}
+
+		p = new GBAMPFileSystemNode(String(path, lastSlash));
+		p->_isDirectory = true;
+	} else {
+		p = new GBAMPFileSystemNode();
+	}
+
+	return p;
+}
 
 // Stdio replacements
 #define MAX_FILE_HANDLES 32
@@ -390,9 +365,6 @@ bool inited = false;
 DS::fileHandle handle[MAX_FILE_HANDLES];
 
 FILE* std_fopen(const char* name, const char* mode) {
-
-	
-
 	if (!inited) {
 		for (int r = 0; r < MAX_FILE_HANDLES; r++) {
 			handle[r].used = false;
@@ -400,9 +372,6 @@ FILE* std_fopen(const char* name, const char* mode) {
 		inited = true;
 		currentDir[0] = '\0';
 	}
-
-
-	
 	
 	char* realName = (char *) name;
 	
@@ -410,7 +379,7 @@ FILE* std_fopen(const char* name, const char* mode) {
 	if ((name[0] == 'd') && (name[1] == 's') && (name[2] == ':') && (name[3] == '/')) {
 		realName += 4;
 	}
-
+	
 	if ((name[0] == 'm') && (name[1] == 'p') && (name[2] == ':') && (name[3] == '/')) {
 		realName += 4;
 	}
@@ -418,7 +387,6 @@ FILE* std_fopen(const char* name, const char* mode) {
 //	consolePrintf("Open file:");
 //	consolePrintf("'%s', [%s]", realName, mode);
 
-
 	if (DS::isGBAMPAvailable()) {
 		FAT_chdir("/");
 		
@@ -440,10 +408,9 @@ FILE* std_fopen(const char* name, const char* mode) {
 		
 		return (FILE *) result;
 	}
-
 	
 	// Fail to open file for writing.  It's in ROM!
-
+	
 	// Allocate a file handle
 	int r = 0;
 	while (handle[r].used) r++;
@@ -456,7 +423,6 @@ FILE* std_fopen(const char* name, const char* mode) {
 		handle[r].sramFile = (DSSaveFile *) DSSaveFileManager::instance()->openSavefile(realName, false);
 	}
 
-	
 	if (handle[r].sramFile) {
 		handle[r].used = true;
 		handle[r].pos = 0;
@@ -510,6 +476,7 @@ FILE* std_fopen(const char* name, const char* mode) {
 		return NULL;
 	}
 }
+
 void std_fclose(FILE* handle) {
 
 	if (DS::isGBAMPAvailable()) {
@@ -525,14 +492,9 @@ void std_fclose(FILE* handle) {
 }
 
 size_t std_fread(const void* ptr, size_t size, size_t numItems, FILE* handle) {
-
 //	consolePrintf("fread %d,%d %d ", size, numItems, ptr);
-	
-	
 
 	if (DS::isGBAMPAvailable()) {
-	
-		
 		int bytes = FAT_fread((void *) ptr, size, numItems, (FAT_FILE *) handle);
 		if (!std_feof(handle)) {
 			return numItems;
@@ -557,27 +519,24 @@ size_t std_fread(const void* ptr, size_t size, size_t numItems, FILE* handle) {
 		
 		}
 		
-		return item;*/
+		return item;
-
+*/
-
 		int items = 0;
 	
 		//for (int r = 0; r < numItems; r++) {
 			if (!std_feof(handle)) {
-				
-
-				
 /*				for (int t = 0; t < size; t++) {
 					if (feof(handle)) eof = true;
 					*(((char *) (ptr)) + r * size + t) = getc(handle);
 				}*/
 				int left = size * numItems;
 				int bytesRead = -1;
+				
 				while ((left > 0) && (!FAT_feof((FAT_FILE *) handle))) {
 					int amount = left > 8192? 8192: left;
 //					do {
 						bytesRead = FAT_fread((void *) ptr, 1, amount, (FAT_FILE *) handle);
-	/*					if (bytesRead == 0) {
+/*						if (bytesRead == 0) {
 							consolePrintf("Pos:%d items:%d num:%d amount:%d read:%d\n", ftell(handle), items, numItems, amount, bytesRead);
 							left++;
 							
@@ -589,27 +548,24 @@ size_t std_fread(const void* ptr, size_t size, size_t numItems, FILE* handle) {
 							fread(ptr, 1024, 1, handle);
 							swiWaitForVBlank();
 							//while (true);
-						}*/
+						}
-					//} while (bytesRead == 0);
+
+					} while (bytesRead == 0);
+*/
 					left -= bytesRead;
 					ptr = ((char *) (ptr)) + bytesRead;				
 				}
 				
 				items = numItems - (left / size);
-				
+
-			
-		
-				
 //				FAT_fread((void *) ptr, size, 1, ((int) (handle)) - 1);
-	//			ptr = ((char *) (ptr)) + size;
+//				ptr = ((char *) (ptr)) + size;	
-				
 			}
-		//}
+//		}
 		
 //		consolePrintf("...done %d \n", items)
 
 		return items;
-		
 	}
 	
 	if (handle->sramFile) {
@@ -627,7 +583,6 @@ size_t std_fread(const void* ptr, size_t size, size_t numItems, FILE* handle) {
 		return bytes / size;
 	}
 
-
 	if (handle->pos + size * numItems > handle->size) {
 		numItems = (handle->size - handle->pos) / size;
 		if (numItems < 0) numItems = 0;
@@ -636,10 +591,8 @@ size_t std_fread(const void* ptr, size_t size, size_t numItems, FILE* handle) {
 //	consolePrintf("read %d  ", size * numItems);
 
 	memcpy((void *) ptr, handle->data + handle->pos, size * numItems);
-
 	handle->pos += size * numItems;
 
-	
 	return numItems;
 }
 
@@ -654,7 +607,6 @@ size_t std_fwrite(const void* ptr, size_t size, size_t numItems, FILE* handle) {
 	//consolePrintf("fwrite size=%d\n", size * numItems);
 
 	if (DS::isGBAMPAvailable()) {
-
 		FAT_fwrite(((char *) (ptr)), size, numItems, (FAT_FILE *) handle);
 		return numItems;
 		
@@ -672,7 +624,6 @@ size_t std_fwrite(const void* ptr, size_t size, size_t numItems, FILE* handle) {
 		return numItems;
 	}
 
-
 	if (handle->sramFile) {
 		handle->sramFile->write(ptr, size);
 		return size;
@@ -701,6 +652,7 @@ bool std_feof(FILE* handle) {
 }
 
 void std_fflush(FILE* handle) {
+	//FIXME: not implemented?
 //	consolePrintf("fflush ");
 }
 
@@ -708,7 +660,6 @@ char* std_fgets(char* str, int size, FILE* file) {
 //	consolePrintf("fgets file=%d ", file);
 	
 	if (DS::isGBAMPAvailable()) {
-		
 		char* s = str;
 		while ((*s++ = std_getc(file)) >= 32) {
 //			consolePrintf("%d ", *s);
@@ -720,7 +671,6 @@ char* std_fgets(char* str, int size, FILE* file) {
 		return str;
 	}
 	
-	
 	if (file->sramFile) {
 		file->pos--;
 		int p = -1;
@@ -740,7 +690,6 @@ char* std_fgets(char* str, int size, FILE* file) {
 }
 
 long int std_ftell(FILE* handle) {
-
 	if (DS::isGBAMPAvailable()) {
 		return FAT_ftell((FAT_FILE *) handle);
 	}
@@ -755,39 +704,30 @@ int std_fseek(FILE* handle, long int offset, int whence) {
 		return FAT_fseek((FAT_FILE *) handle, offset, whence);
 	}
 
-
 	switch (whence) {
-		case SEEK_CUR: {
+		case SEEK_CUR:
 			handle->pos += offset;
 			break;
-		}
+		case SEEK_SET:
-		
-		case SEEK_SET: {
 			handle->pos = offset;
 			break;
-		}
+		case SEEK_END:
-		
-		case SEEK_END: {
 			handle->pos = handle->size + offset;
 			break;
-		}
+		default:
-		
-		default: {
 			handle->pos = offset;
 			break;
-		}
-		
 	}
 	
 	return 0;
 }
 
 void std_clearerr(FILE* handle) {
+	//FIXME: not implemented?
 //	consolePrintf("clearerr ");
 }
 
 int std_getc(FILE* handle) {
-
 	if (DS::isGBAMPAvailable()) {
 		char c;
 		FAT_fread(&c, 1, 1, (FAT_FILE *) handle);
@@ -849,24 +789,3 @@ int std_ferror(FILE* handle) {
 }
 
 } // namespace DS
-
-// These functions are added to AbstractFileSystemNode and are therefore outside
-// the DS namespace.
-
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-//	consolePrintf("New node");
-        
-	if (DS::isGBAMPAvailable()) {
-		return new DS::GBAMPFileSystemNode();
-	} else {
-		return new DS::DSFileSystemNode();
-	}
-}
-
-AbstractFilesystemNode* AbstractFilesystemNode::getNodeForPath(const String& path) {
-	if (DS::isGBAMPAvailable()) {
-		return new DS::GBAMPFileSystemNode(path);
-	} else {
-		return new DS::DSFileSystemNode(path);
-	}
-}

backends/fs/ds/ds-fs.h

@@ -20,8 +20,6 @@
 #ifndef _DS_FS_H
 #define _DS_FS_H
 
-
-
 //#include <NDS/ARM9/console.h>
 #include "fs.h"
 #include "zipreader.h"
@@ -29,81 +27,131 @@
 #include "scummconsole.h"
 #include "gba_nds_fat.h"
 #include "backends/fs/abstract-fs.h"
-//#include "backends/fs/fs.h"
 
 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.
  */
 class DSFileSystemNode : public AbstractFilesystemNode {
 protected:
-	static ZipFile* _zipFile;
-
 	typedef class Common::String String;
 
+	static ZipFile* _zipFile;
+
 	String _displayName;
+	String _path;
 	bool _isDirectory;
 	bool _isValid;
-	String _path;
 	int _refCountVal;
 	
 public:
+	/**
+	 * Creates a DSFilesystemNode with the root node as path.
+	 */
 	DSFileSystemNode();
+	
+	/**
+	 * Creates a DSFilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 */
 	DSFileSystemNode(const String &path);
-	DSFileSystemNode(const DSFileSystemNode *node);
+	
+	/**
+	 * Creates a DSFilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 * @param path true if path is a directory, false otherwise.
+	 */
 	DSFileSystemNode(const String& path, bool isDir);
 	
-	virtual String displayName() const {  return _displayName; }
+	/**
-	virtual String name() const {  return _displayName; }
+	 * Copy constructor.
-	virtual bool isValid() const { return _isValid; }
+	 */
-	virtual bool isDirectory() const { return _isDirectory; }
+	DSFileSystemNode(const DSFileSystemNode *node);
-	virtual String path() const { return _path; }
 	
-	virtual bool listDir(AbstractFSList &list, ListMode mode = FilesystemNode::kListDirectoriesOnly) const;
+	virtual String getDisplayName() const {  return _displayName; }
-	virtual AbstractFilesystemNode *parent() const;
+	virtual String getName() const {  return _displayName; }
+	virtual String getPath() const { return _path; }
+	virtual bool isDirectory() const { return _isDirectory; }
+	virtual bool isValid() const { return _isValid; }
+	
+	/**
+	 * Returns a copy of this node.
+	 */
 	virtual AbstractFilesystemNode *clone() const { return new DSFileSystemNode(this); }
-	virtual AbstractFilesystemNode *child(const Common::String& name) const;
+	virtual AbstractFilesystemNode *getChild(const Common::String& name) const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode = FilesystemNode::kListDirectoriesOnly) const;
+	virtual AbstractFilesystemNode *getParent() const;
+	
+	/**
+	 * Returns the zip file this node points to.
+	 * TODO: check this documentation.
+	 */
 	static ZipFile* getZip() { return _zipFile; }
 };
 
-
+ /**
-/**
+ * 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.
  */
 class GBAMPFileSystemNode : public AbstractFilesystemNode {
 protected:
 	typedef class Common::String String;
 
 	String _displayName;
+	String _path;
 	bool _isDirectory;
 	bool _isValid;
-	String _path;
-	
 	int _refCountVal;
 	
 public:
+	/**
+	 * Creates a GBAMPFilesystemNode with the root node as path.
+	 */
 	GBAMPFileSystemNode();
+	
+	/**
+	 * Creates a GBAMPFilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 */
 	GBAMPFileSystemNode(const String &path);
+	
+	/**
+	 * Creates a DSFilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 * @param path true if path is a directory, false otherwise.
+	 */
 	GBAMPFileSystemNode(const String &path, bool isDirectory);
+	
+	/**
+	 * Copy constructor.
+	 */
 	GBAMPFileSystemNode(const GBAMPFileSystemNode *node);
 
-	virtual String displayName() const {  return _displayName; }
+	virtual String getDisplayName() const {  return _displayName; }
-	virtual String name() const {  return _displayName; }
+	virtual String getName() const {  return _displayName; }
-	
+	virtual String getPath() const { return _path; }
-	virtual bool isValid() const { return _isValid; }
 	virtual bool isDirectory() const { return _isDirectory; }
-	virtual String path() const { return _path; }
+	virtual bool isValid() const { return _isValid; }
-	virtual bool listDir(AbstractFSList &list, ListMode mode = FilesystemNode::kListDirectoriesOnly) const;
-	virtual AbstractFilesystemNode *parent() const;
-	virtual AbstractFilesystemNode *clone() const { return new GBAMPFileSystemNode(this); }
-	virtual AbstractFilesystemNode *child(const Common::String& name) const;
 	
+	/**
+	 * Returns a copy of this node.
+	 */
+	virtual AbstractFilesystemNode *clone() const { return new GBAMPFileSystemNode(this); }
+	virtual AbstractFilesystemNode *getChild(const Common::String& name) const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode = FilesystemNode::kListDirectoriesOnly) const;
+	virtual AbstractFilesystemNode *getParent() const;
 };
 
-
-
-
 struct fileHandle {
 	int pos;
 	bool used;
@@ -113,7 +161,6 @@ struct fileHandle {
 	DSSaveFile* sramFile;
 };
 
-
 #undef stderr
 #undef stdout
 #undef stdin
@@ -137,6 +184,6 @@ void 	std_clearerr(FILE* handle);
 void 	std_cwd(char* dir);
 void 	std_fflush(FILE* handle);
 
-}
+} //namespace DS
 
-#endif
+#endif //_DS_FS_H

backends/fs/gp32/GP32FilesystemFactory.cpp

@@ -0,0 +1,23 @@
+#include "backends/fs/gp32/GP32FilesystemFactory.h"
+#include "backends/fs/gp32/gp32-fs.cpp"
+
+GP32FilesystemFactory *GP32FilesystemFactory::_instance = 0;
+
+GP32FilesystemFactory *GP32FilesystemFactory::instance(){
+	if(_instance == 0){
+		_instance = new GP32FilesystemFactory();
+	}
+	return _instance;
+}
+
+AbstractFilesystemNode *GP32FilesystemFactory::makeRootFileNode() const {
+	return new GP32FilesystemNode();
+}
+
+AbstractFilesystemNode *GP32FilesystemFactory::makeCurrentDirectoryFileNode() const {
+	return new GP32FilesystemNode();
+}
+
+AbstractFilesystemNode *GP32FilesystemFactory::makeFileNodePath(const String &path) const {
+	return new GP32FilesystemNode(path);
+}

backends/fs/gp32/GP32FilesystemFactory.h

@@ -0,0 +1,38 @@
+#ifndef GP32FILESYSTEMFACTORY_H_
+#define GP32FILESYSTEMFACTORY_H_
+
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/**
+ * Creates GP32FilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class GP32FilesystemFactory : public AbstractFilesystemFactory {	
+public:
+	typedef Common::String String;
+	
+	/**
+	 * Creates an instance of GP32FilesystemFactory using the Singleton pattern.
+	 * 
+	 * @return A unique instance of GP32FilesytemFactory.
+	 */
+	static GP32FilesystemFactory *instance();
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~GP32FilesystemFactory() {};
+		
+	virtual AbstractFilesystemNode *makeRootFileNode() const;
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	
+protected:
+	GP32FilesystemFactory() {};
+		
+private:
+	static GP32FilesystemFactory *_instance;
+};
+
+#endif /*GP32FILESYSTEMFACTORY_H_*/

backends/fs/gp32/gp32-fs.cpp

@@ -24,38 +24,78 @@
  */
 
 #include "stdafx.h"
-
 #include "backends/fs/abstract-fs.h"
 
+#define MAX_PATH_SIZE 256
+
+/**
+ * Implementation of the ScummVM file system API.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
+ */
 class GP32FilesystemNode : public AbstractFilesystemNode {
 protected:
 	String _displayName;
+	String _path;
 	bool _isDirectory;
 	bool _isRoot;
-	String _path;
 
 public:
+	/**
+	 * Creates a GP32FilesystemNode with the root node as path.
+	 */
 	GP32FilesystemNode();
+	
+	/**
+	 * Creates a GP32FilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 */
 	GP32FilesystemNode(const String &path);
 
-	virtual String displayName() const { return _displayName; }
+	virtual String getDisplayName() const { return _displayName; }
-	virtual String name() const { return _displayName; }
+	virtual String getName() const { return _displayName; }
-	// FIXME: isValid should return false if this Node can't be used!
+	virtual String getPath() const { return _path; }
-	// client code can rely on the return value.
-	virtual bool isValid() const { return true; }
 	virtual bool isDirectory() const { return _isDirectory; }
-	virtual String path() const { return _path; }
+	// FIXME: isValid should return false if this Node can't be used!
+	// so client code can rely on the return value.
+	virtual bool isValid() const { return true; }
 
-	virtual bool listDir(AbstractFSList &list, ListMode mode) const;
+	virtual AbstractFilesystemNode *getChild(const String &n) const;
-	virtual AbstractFilesystemNode *parent() const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode) const;
-	virtual AbstractFilesystemNode *child(const String &n) const;
+	virtual AbstractFilesystemNode *getParent() const;
 };
 
-#define MAX_PATH_SIZE 256
-
 const char gpRootPath[] = "gp:\\";
 //char gpCurrentPath[MAX_PATH_SIZE] = "gp:\\";		// must end with '\'
 
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ * 			gp:\foo\bar.txt would return "\bar.txt"
+ * 			gp:\foo\bar\    would return "\bar\"
+ *  
+ * @param str Path to obtain the last component from.
+ * @return Pointer to the first char of the last component inside str.
+ */
+static const char *lastPathComponent(const Common::String &str) {
+	const char *start = str.c_str();
+	const char *cur = start + str.size() - 2;
+
+	while (cur >= start && *cur != '\\') {
+		--cur;
+	}
+
+	return cur + 1;
+}
+
+/**
+ * FIXME: document this function.
+ * 
+ * @param path
+ * @param convPath
+ */
 int gpMakePath(const char *path, char *convPath) {
 	// copy root or current directory
 	const char *p;
@@ -106,18 +146,6 @@ int gpMakePath(const char *path, char *convPath) {
 	return 0;
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-	return AbstractFilesystemNode::getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-	return new GP32FilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-	return new GP32FilesystemNode(path);
-}
-
 GP32FilesystemNode::GP32FilesystemNode() {
 	_isDirectory = true;
 	_isRoot = true;
@@ -132,8 +160,8 @@ GP32FilesystemNode::GP32FilesystemNode(const String &path) {
 	gpMakePath(path.c_str(), convPath);
 
 	_path = convPath;
-
 	pos = convPath;
+	
 	while (*pos)
 		if (*pos++ == '\\')
 			dsplName = pos;
@@ -150,14 +178,25 @@ GP32FilesystemNode::GP32FilesystemNode(const String &path) {
 	_isDirectory = true;
 }
 
-bool GP32FilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *GP32FilesystemNode::getChild(const 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);
+	
+	String newPath(_path);
+	if (_path.lastChar() != '\\')
+		newPath += '\\';
+	newPath += n;
+
+	return new GP32FilesystemNode(newPath);
+}
+
+bool GP32FilesystemNode::getChildren(AbstractFSList &myList, ListMode mode) const {
 	assert(_isDirectory);
 
 	GPDIRENTRY dirEntry;
 	GPFILEATTR attr;
-
 	GP32FilesystemNode entry;
-
 	uint32 read;
 
 	if (mode == FilesystemNode::kListAll)
@@ -168,9 +207,11 @@ bool GP32FilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
 	int startIdx = 0; // current file
 	String listDir(_path);
 	//listDir += "/";
+	
 	while (GpDirEnumList(listDir.c_str(), startIdx++, 1, &dirEntry, &read)  == SM_OK) {
 		if (dirEntry.name[0] == '.')
 			continue;
+			
 		entry._displayName = dirEntry.name;
 		entry._path = _path;
 		entry._path += dirEntry.name;
@@ -194,18 +235,7 @@ bool GP32FilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
 	return true;
 }
 
-static const char *lastPathComponent(const Common::String &str) {
+AbstractFilesystemNode *GP32FilesystemNode::getParent() const {
-	const char *start = str.c_str();
-	const char *cur = start + str.size() - 2;
-
-	while (cur >= start && *cur != '\\') {
-		--cur;
-	}
-
-	return cur + 1;
-}
-
-AbstractFilesystemNode *GP32FilesystemNode::parent() const {
 	if(_isRoot)
 		return 0;
 
@@ -218,16 +248,3 @@ AbstractFilesystemNode *GP32FilesystemNode::parent() const {
 
 	return p;
 }
-
-AbstractFilesystemNode *GP32FilesystemNode::child(const 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);
-	String newPath(_path);
-	if (_path.lastChar() != '\\')
-		newPath += '\\';
-	newPath += n;
-	GP32FilesystemNode *p = new GP32FilesystemNode(newPath);
-
-	return p;
-}

backends/fs/morphos/ABoxFilesystemFactory.cpp

@@ -0,0 +1,23 @@
+#include "backends/fs/morphos/ABoxFilesystemFactory.h"
+#include "backends/fs/morphos/abox-fs.cpp"
+
+ABoxFilesystemFactory *ABoxFilesystemFactory::_instance = 0;
+
+ABoxFilesystemFactory *ABoxFilesystemFactory::instance(){
+	if(_instance == 0){
+		_instance = new ABoxFilesystemFactory();
+	}
+	return _instance;
+}
+
+AbstractFilesystemNode *ABoxFilesystemFactory::makeRootFileNode() const {
+	return new ABoxFilesystemNode();
+}
+
+AbstractFilesystemNode *ABoxFilesystemFactory::makeCurrentDirectoryFileNode() const {
+	return new ABoxFilesystemNode();
+}
+
+AbstractFilesystemNode *ABoxFilesystemFactory::makeFileNodePath(const String &path) const {
+	return new ABoxFilesystemNode(path);
+}

backends/fs/morphos/ABoxFilesystemFactory.h

@@ -0,0 +1,38 @@
+#ifndef ABOXFILESYSTEMFACTORY_H_
+#define ABOXFILESYSTEMFACTORY_H_
+
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/**
+ * Creates ABoxFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class ABoxFilesystemFactory : public AbstractFilesystemFactory {	
+public:
+	typedef Common::String String;
+	
+	/**
+	 * Creates an instance of ABoxFilesystemFactory using the Singleton pattern.
+	 * 
+	 * @return A unique instance of ABoxFilesytemFactory.
+	 */
+	static ABoxFilesystemFactory *instance();
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~ABoxFilesystemFactory() {};
+		
+	virtual AbstractFilesystemNode *makeRootFileNode() const;
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	
+protected:
+	ABoxFilesystemFactory() {};
+		
+private:
+	static ABoxFilesystemFactory *_instance;
+};
+
+#endif /*ABOXFILESYSTEMFACTORY_H_*/

backends/fs/morphos/abox-fs.cpp

@@ -32,52 +32,63 @@
 #include "base/engine.h"
 #include "backends/fs/abstract-fs.h"
 
-/*
+/**
  * Implementation of the ScummVM file system API based on the MorphOS A-Box API.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class ABoxFilesystemNode : public AbstractFilesystemNode {
-	protected:
+protected:
-		BPTR _lock;
+	BPTR _lock;
-		String _displayName;
+	String _displayName;
-		bool _isDirectory;
+	String _path;
-		bool _isValid;
+	bool _isDirectory;
-		String _path;
+	bool _isValid;
 
-	public:
+public:
-		ABoxFilesystemNode();
+	/**
-		ABoxFilesystemNode(BPTR lock, CONST_STRPTR display_name = NULL);
+	 * Creates a ABoxFilesystemNode with the root node as path.
-		ABoxFilesystemNode(const String &p);
+	 */
-		ABoxFilesystemNode(const ABoxFilesystemNode &node);
+	ABoxFilesystemNode();
+	
+	/**
+	 * Creates a ABoxFilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 */
+	ABoxFilesystemNode(const String &p);
+	
+	/**
+	 * FIXME: document this constructor.
+	 */
+	ABoxFilesystemNode(BPTR lock, CONST_STRPTR display_name = NULL);
+	
+	/**
+	 * Copy constructor.
+	 */
+	ABoxFilesystemNode(const ABoxFilesystemNode &node);
 
-		~ABoxFilesystemNode();
+	/**
+	 * Destructor.
+	 */
+	~ABoxFilesystemNode();
 
-		virtual String displayName() const { return _displayName; }
+	virtual String getDisplayName() const { return _displayName; }
-		virtual String name() const { return _displayName; };
+	virtual String getName() const { return _displayName; };
-		virtual bool isValid() const { return _isValid; }
+	virtual String getPath() const { return _path; }
-		virtual bool isDirectory() const { return _isDirectory; }
+	virtual bool isDirectory() const { return _isDirectory; }
-		virtual String path() const { return _path; }
+	virtual bool isValid() const { return _isValid; }
-
+	
-		virtual bool listDir(AbstractFSList &list, ListMode mode) const;
+	virtual AbstractFilesystemNode *getChild(const String &name) const;
-		static  AbstractFSList listRoot();
+	virtual bool getChildren(AbstractFSList &list, ListMode mode) const;
-		virtual AbstractFilesystemNode *parent() const;
+	virtual AbstractFilesystemNode *getParent() const;
-		virtual AbstractFilesystemNode *child(const String &name) const;
+	
+	/**
+	 * Return the list of child nodes for the root node.
+	 */
+	static AbstractFSList getRootChildren();
 };
 
-
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-	return AbstractFilesystemNode::getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String	&path) {
-	return new ABoxFilesystemNode(path);
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot()
-{
-	return new ABoxFilesystemNode();
-}
-
 ABoxFilesystemNode::ABoxFilesystemNode()
 {
 	_displayName = "Mounted Volumes";
@@ -87,6 +98,62 @@ ABoxFilesystemNode::ABoxFilesystemNode()
 	_lock = NULL;
 }
 
+ABoxFilesystemNode::ABoxFilesystemNode(const String &p) {
+	int len = 0, offset = p.size();
+
+	assert(offset > 0);
+
+	_path = p;
+
+	// Extract last component from path
+	const char *str = p.c_str();
+	while (offset > 0 && (str[offset-1] == '/' || str[offset-1] == ':') )
+		offset--;
+	while (offset > 0 && (str[offset-1] != '/' && str[offset-1] != ':')) {
+		len++;
+		offset--;
+	}
+	_displayName = String(str + offset, len);
+	_lock = NULL;
+	_isDirectory = false;
+
+	struct FileInfoBlock *fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL);
+	if (!fib)
+	{
+		debug(6, "FileInfoBlock is NULL");
+		return;
+	}
+
+	// Check whether the node exists and if it is a directory
+	BPTR pLock = Lock((STRPTR)_path.c_str(), SHARED_LOCK);
+	if (pLock)
+	{
+		if (Examine(pLock, fib) != DOSFALSE) {
+			if (fib->fib_EntryType > 0)
+			{
+				_isDirectory = true;
+				_lock = DupLock(pLock);
+				_isValid = (_lock != 0);
+
+				// Add a trailing slash if it is needed
+				const char c = _path.lastChar();
+				if (c != '/' && c != ':')
+					_path += '/';
+
+			}
+			else
+			{
+				_isDirectory = false;
+				_isValid = true;
+			}
+		}
+	
+		UnLock(pLock);
+	}
+
+	FreeDosObject(DOS_FIB, fib);
+}
+
 ABoxFilesystemNode::ABoxFilesystemNode(BPTR lock, CONST_STRPTR display_name)
 {
 	int bufsize = 256;
@@ -135,63 +202,7 @@ ABoxFilesystemNode::ABoxFilesystemNode(BPTR lock, CONST_STRPTR display_name)
 			_isValid = true;
 		}
 	}
-	FreeDosObject(DOS_FIB, fib);
-}
-
-ABoxFilesystemNode::ABoxFilesystemNode(const String &p) {
-	int len = 0, offset = p.size();
-
-	assert(offset > 0);
-
-	_path = p;
-
-	// Extract last component from path
-	const char *str = p.c_str();
-	while (offset > 0 && (str[offset-1] == '/' || str[offset-1] == ':') )
-		offset--;
-	while (offset > 0 && (str[offset-1] != '/' && str[offset-1] != ':')) {
-		len++;
-		offset--;
-	}
-	_displayName = String(str + offset, len);
-	_lock = NULL;
-	_isDirectory = false;
-
-	struct FileInfoBlock *fib = (struct FileInfoBlock *)AllocDosObject(DOS_FIB, NULL);
-	if (!fib)
-	{
-		debug(6, "FileInfoBlock is NULL");
-		return;
-	}
-
-	// Check whether the node exists and if it is a directory
-
-	BPTR pLock = Lock((STRPTR)_path.c_str(), SHARED_LOCK);
-	if (pLock)
-	{
-		if (Examine(pLock, fib) != DOSFALSE) {
-			if (fib->fib_EntryType > 0)
-			{
-				_isDirectory = true;
-				_lock = DupLock(pLock);
-				_isValid = (_lock != 0);
-
-				// Add a trailing slash if it is needed
-				const char c = _path.lastChar();
-				if (c != '/' && c != ':')
-					_path += '/';
-
-			}
-			else
-			{
-				_isDirectory = false;
-				_isValid = true;
-			}
-		}
 	
-		UnLock(pLock);
-	}
-
 	FreeDosObject(DOS_FIB, fib);
 }
 
@@ -213,7 +224,27 @@ ABoxFilesystemNode::~ABoxFilesystemNode()
 	}
 }
 
-bool ABoxFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const
+AbstractFilesystemNode *ABoxFilesystemNode::getChild(const String &name) const {
+	assert(_isDirectory);
+	String newPath(_path);
+
+	if (_path.lastChar() != '/')
+		newPath += '/';
+	newPath += name;
+
+	BPTR lock = Lock(newPath.c_str(), SHARED_LOCK);
+
+	if (!lock)
+	{
+		return 0;
+    }
+
+	UnLock(lock);
+
+	return new ABoxFilesystemNode(newPath);
+}
+
+bool ABoxFilesystemNode::getChildren(AbstractFSList &list, ListMode mode) const
 {
 	if (!_isValid)
 	{
@@ -229,7 +260,7 @@ bool ABoxFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const
 	if (_lock == NULL)
 	{
 		/* This is the root node */
-		myList = listRoot();
+		list = getRootChildren();
 		return true;
 	}
 
@@ -263,7 +294,7 @@ bool ABoxFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const
 					if (entry)
 					{
 						if (entry->isValid())
-							myList.push_back(entry);
+							list.push_back(entry);
 						else
 							delete entry;
 					}
@@ -281,7 +312,7 @@ bool ABoxFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const
 	return true;
 }
 
-AbstractFilesystemNode *ABoxFilesystemNode::parent() const
+AbstractFilesystemNode *ABoxFilesystemNode::getParent() const
 {
 	AbstractFilesystemNode *node = NULL;
 
@@ -306,29 +337,9 @@ AbstractFilesystemNode *ABoxFilesystemNode::parent() const
 	return node;
 }
 
-AbstractFilesystemNode *ABoxFilesystemNode::child(const String &name) const {
+AbstractFSList ABoxFilesystemNode::getRootChildren()
-	assert(_isDirectory);
-	String newPath(_path);
-
-	if (_path.lastChar() != '/')
-		newPath += '/';
-	newPath += name;
-
-	BPTR lock = Lock(newPath.c_str(), SHARED_LOCK);
-
-	if (!lock)
-	{
-		return 0;
-    }
-
-	UnLock(lock);
-
-	return new ABoxFilesystemNode(newPath);
-}
-
-AbstractFSList ABoxFilesystemNode::listRoot()
 {
-	AbstractFSList myList;
+	AbstractFSList list;
 	DosList *dosList;
 	CONST ULONG lockDosListFlags = LDF_READ | LDF_VOLUMES;
 	char name[256];
@@ -336,15 +347,15 @@ AbstractFSList ABoxFilesystemNode::listRoot()
 	dosList = LockDosList(lockDosListFlags);
 	if (dosList == NULL)
 	{
-		return myList;
+		return list;
 	}
 
 	dosList = NextDosEntry(dosList, LDF_VOLUMES);
 	while (dosList)
 	{
-		if (dosList->dol_Type == DLT_VOLUME &&  // Should always be true, but ...
+		if (dosList->dol_Type == DLT_VOLUME &&	// Should always be true, but ...
-			 dosList->dol_Name &&                                   // Same here
+			 dosList->dol_Name &&				// Same here
-			 dosList->dol_Task                                              // Will be NULL if volume is removed from drive but still in use by some program
+			 dosList->dol_Task					// Will be NULL if volume is removed from drive but still in use by some program
 			)
 		{
 			ABoxFilesystemNode *entry;
@@ -362,7 +373,7 @@ AbstractFSList ABoxFilesystemNode::listRoot()
 				if (entry)
 				{
 					if (entry->isValid())
-						myList.push_back(entry);
+						list.push_back(entry);
 					else
 						delete entry;
 				}
@@ -374,9 +385,7 @@ AbstractFSList ABoxFilesystemNode::listRoot()
 
 	UnLockDosList(lockDosListFlags);
 
-	return myList;
+	return list;
 }
 
 #endif // defined(__MORPHOS__)
-
-

backends/fs/palmos/PalmOSFilesystemFactory.cpp

@@ -0,0 +1,23 @@
+#include "backends/fs/palmos/PalmOSFilesystemFactory.h"
+#include "backends/fs/palmos/palmos-fs.cpp"
+
+PalmOSFilesystemFactory *PalmOSFilesystemFactory::_instance = 0;
+
+PalmOSFilesystemFactory *PalmOSFilesystemFactory::instance(){
+	if(_instance == 0){
+		_instance = new PalmOSFilesystemFactory();
+	}
+	return _instance;
+}
+
+AbstractFilesystemNode *PalmOSFilesystemFactory::makeRootFileNode() const {
+	return new PalmOSFilesystemNode();
+}
+
+AbstractFilesystemNode *PalmOSFilesystemFactory::makeCurrentDirectoryFileNode() const {
+	return new PalmOSFilesystemNode();
+}
+
+AbstractFilesystemNode *PalmOSFilesystemFactory::makeFileNodePath(const String &path) const {
+	return new PalmOSFilesystemNode(path);
+}

backends/fs/palmos/PalmOSFilesystemFactory.h

@@ -0,0 +1,38 @@
+#ifndef PALMOSFILESYSTEMFACTORY_H_
+#define PALMOSFILESYSTEMFACTORY_H_
+
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/**
+ * Creates PalmOSFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class PalmOSFilesystemFactory : public AbstractFilesystemFactory {	
+public:
+	typedef Common::String String;
+	
+	/**
+	 * Creates an instance of PalmOSFilesystemFactory using the Singleton pattern.
+	 * 
+	 * @return A unique instance of PalmOSFilesytemFactory.
+	 */
+	static PalmOSFilesystemFactory *instance();
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~PalmOSFilesystemFactory() {};
+		
+	virtual AbstractFilesystemNode *makeRootFileNode() const;
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	
+protected:
+	PalmOSFilesystemFactory() {};
+		
+private:
+	static PalmOSFilesystemFactory *_instance;
+};
+
+#endif /*PALMOSFILESYSTEMFACTORY_H_*/

backends/fs/palmos/palmos-fs.cpp

@@ -27,36 +27,65 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-/*
+/**
  * Implementation of the ScummVM file system API based on PalmOS VFS API.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class PalmOSFilesystemNode : public AbstractFilesystemNode {
 protected:
 	String _displayName;
+	String _path;
 	bool _isDirectory;
 	bool _isValid;
 	bool _isPseudoRoot;
-	String _path;
 	
 public:
+	/**
+	 * Creates a PalmOSFilesystemNode with the root node as path.
+	 */
 	PalmOSFilesystemNode();
+	
+	/**
+	 * Creates a POSIXFilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 */
 	PalmOSFilesystemNode(const String &p);
 
-	virtual String displayName() const { return _displayName; }
+	virtual String getDisplayName() const { return _displayName; }
-	virtual String name() const { return _displayName; }
+	virtual String getName() const { return _displayName; }
-	virtual bool isValid() const { return _isValid; }
+	virtual String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
-	virtual String path() const { return _path; }
+	virtual bool isValid() const { return _isValid; }
 
-	virtual bool listDir(AbstractFSList &list, ListMode mode) const;
+	virtual AbstractFilesystemNode *getChild(const String &n) const;
-	virtual AbstractFilesystemNode *parent() const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode) const;
-	virtual AbstractFilesystemNode *child(const String &n) const;
+	virtual AbstractFilesystemNode *getParent() const;
 
 private:
-	static void addFile (AbstractFSList &list, ListMode mode, const Char *base, FileInfoType* find_data);
+	/**
+	 * Adds a single WindowsFilesystemNode to a given list.
+	 * This method is used by getChildren() to populate the directory entries list. 
+	 * 
+	 * @param list List to put the file entry node in.
+	 * @param mode Mode to use while adding the file entry to the list.
+	 * @param base String with the directory being listed.
+	 * @param find_data Describes a file that the FindFirstFile, FindFirstFileEx, or FindNextFile functions find.
+ 	 */
+	static void addFile(AbstractFSList &list, ListMode mode, const Char *base, FileInfoType* find_data);
 };
 
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ * 			/foo/bar.txt would return /bar.txt
+ * 			/foo/bar/    would return /bar/
+ *  
+ * @param str String containing the path.
+ * @return Pointer to the first char of the last component inside str.
+ */
 static const char *lastPathComponent(const Common::String &str) {
 	const char *start = str.c_str();
 	const char *cur = start + str.size() - 2;
@@ -92,19 +121,6 @@ void PalmOSFilesystemNode::addFile(AbstractFSList &list, ListMode mode, const ch
 	list.push_back(new PalmOSFilesystemNode(entry));
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-	return AbstractFilesystemNode::getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-	return new PalmOSFilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-	return new PalmOSFilesystemNode(path);
-}
-
-
 PalmOSFilesystemNode::PalmOSFilesystemNode() {
 	_isDirectory = true;
 	_displayName = "Root";
@@ -119,13 +135,13 @@ PalmOSFilesystemNode::PalmOSFilesystemNode(const String &p) {
 
 	UInt32 attr;
 	FileRef handle;
-	Err e = VFSFileOpen(gVars->VFS.volRefNum, _path.c_str(), vfsModeRead, &handle);
+	Err error = VFSFileOpen(gVars->VFS.volRefNum, _path.c_str(), vfsModeRead, &handle);
-	if (!e) {
+	if (!error) {
-		e = VFSFileGetAttributes(handle, &attr);
+		error = VFSFileGetAttributes(handle, &attr);
 		VFSFileClose(handle);
 	}
 
-	if (e) {
+	if (error) {
 		_isValid = false;
 		_isDirectory = false;
 
@@ -136,8 +152,31 @@ PalmOSFilesystemNode::PalmOSFilesystemNode(const String &p) {
 	_isPseudoRoot = false;
 }
 
-bool PalmOSFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *PalmOSFilesystemNode::getChild(const String &n) const {
-	Err e;
+	assert(_isDirectory);
+	
+	String newPath(_path);
+	if (_path.lastChar() != '/')
+		newPath += '/';
+	newPath += n;
+
+	FileRef handle;
+	UInt32 attr;
+	Err error = VFSFileOpen(gVars->VFS.volRefNum, newPath.c_str(), vfsModeRead, &handle);
+	if (error)
+		return 0;
+	
+	error = VFSFileGetAttributes(handle, &attr);
+	VFSFileClose(handle);
+
+	if (error || !(attr & vfsFileAttrDirectory))
+		return 0;
+
+	return new PalmOSFilesystemNode(newPath);
+}
+
+bool PalmOSFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode) const {
+	Err error;
 	Char nameP[256];
 	FileInfoType desc;
 	FileRef handle;
@@ -145,14 +184,14 @@ bool PalmOSFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const
 
 	desc.nameP = nameP;
 	desc.nameBufLen = 256;
-	e = VFSFileOpen(gVars->VFS.volRefNum, _path.c_str(), vfsModeRead, &handle);
+	error = VFSFileOpen(gVars->VFS.volRefNum, _path.c_str(), vfsModeRead, &handle);
 
-	if (e)
+	if (error)
 		return false;
 	
 	while(dirIterator != expIteratorStop) {
-		e = VFSDirEntryEnumerate(handle, &dirIterator, &desc);
+		error = VFSDirEntryEnumerate(handle, &dirIterator, &desc);
-		if (!e) {
+		if (!error) {
 			addFile(myList, mode, _path.c_str(), &desc);
 		}
 	}
@@ -162,8 +201,7 @@ bool PalmOSFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const
 	return true;
 }
 
-
+AbstractFilesystemNode *PalmOSFilesystemNode::getParent() const {
-AbstractFilesystemNode *PalmOSFilesystemNode::parent() const {
 	PalmOSFilesystemNode *p = 0;
 	
 	if (!_isPseudoRoot) {
@@ -177,31 +215,7 @@ AbstractFilesystemNode *PalmOSFilesystemNode::parent() const {
 		p->_displayName = lastPathComponent(p->_path);
 		p->_isPseudoRoot =(p->_path == "/");
 	}
-	return p;
-}
-
-
-AbstractFilesystemNode *PalmOSFilesystemNode::child(const String &n) const {
-	assert(_isDirectory);
-	String newPath(_path);
-
-	if (_path.lastChar() != '/')
-		newPath += '/';
-	newPath += n;
-
-	FileRef handle;
-	UInt32 attr;
-	Err e = VFSFileOpen(gVars->VFS.volRefNum, newPath.c_str(), vfsModeRead, &handle);
-	if (e)
-		return 0;
 	
-	e = VFSFileGetAttributes(handle, &attr);
-	VFSFileClose(handle);
-
-	if (e || !(attr & vfsFileAttrDirectory))
-		return 0;
-
-	PalmOSFilesystemNode *p = new PalmOSFilesystemNode(newPath);
 	return p;
 }
 

backends/fs/posix/POSIXFilesystemFactory.cpp

@@ -0,0 +1,25 @@
+#include "backends/fs/posix/POSIXFilesystemFactory.h"
+#include "backends/fs/posix/posix-fs.cpp"
+
+POSIXFilesystemFactory *POSIXFilesystemFactory::_instance = 0;
+
+POSIXFilesystemFactory *POSIXFilesystemFactory::instance(){
+	if(_instance == 0){
+		_instance = new POSIXFilesystemFactory();
+	}
+	return _instance;
+}
+
+AbstractFilesystemNode *POSIXFilesystemFactory::makeRootFileNode() const {
+	return new POSIXFilesystemNode();
+}
+
+AbstractFilesystemNode *POSIXFilesystemFactory::makeCurrentDirectoryFileNode() const {
+	char buf[MAXPATHLEN];
+	getcwd(buf, MAXPATHLEN);
+	return new POSIXFilesystemNode(buf, true);
+}
+
+AbstractFilesystemNode *POSIXFilesystemFactory::makeFileNodePath(const String &path) const {
+	return new POSIXFilesystemNode(path, true);
+}

backends/fs/posix/POSIXFilesystemFactory.h

@@ -0,0 +1,38 @@
+#ifndef POSIXFILESYSTEMFACTORY_H_
+#define POSIXFILESYSTEMFACTORY_H_
+
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/**
+ * Creates POSIXFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class POSIXFilesystemFactory : public AbstractFilesystemFactory {	
+public:
+	typedef Common::String String;
+	
+	/**
+	 * Creates an instance of POSIXFilesystemFactory using the Singleton pattern.
+	 * 
+	 * @return A unique instance of POSIXFilesytemFactory.
+	 */
+	static POSIXFilesystemFactory *instance();
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~POSIXFilesystemFactory() {};
+		
+	virtual AbstractFilesystemNode *makeRootFileNode() const;
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	
+protected:
+	POSIXFilesystemFactory() {};
+		
+private:
+	static POSIXFilesystemFactory *_instance;
+};
+
+#endif /*POSIXFILESYSTEMFACTORY_H_*/

backends/fs/posix/posix-fs.cpp

@@ -22,7 +22,6 @@
 #if defined(UNIX)
 
 #include "common/stdafx.h"
-
 #include "backends/fs/abstract-fs.h"
 
 #ifdef MACOSX
@@ -34,33 +33,59 @@
 #include <stdio.h>
 #include <unistd.h>
 
-/*
+/**
  * Implementation of the ScummVM file system API based on POSIX.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class POSIXFilesystemNode : public AbstractFilesystemNode {
 protected:
 	String _displayName;
+	String _path;
 	bool _isDirectory;
 	bool _isValid;
-	String _path;
 
 public:
+	/**
+	 * Creates a POSIXFilesystemNode with the root node as path.
+	 */
 	POSIXFilesystemNode();
+	
+	/**
+	 * Creates a POSIXFilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 * @param verify true if the isValid and isDirectory flags should be verified during the construction.
+	 */
 	POSIXFilesystemNode(const String &path, bool verify);
-
+	
-	virtual String displayName() const { return _displayName; }
+	virtual String getDisplayName() const { return _displayName; }
-	virtual String name() const { return _displayName; }
+	virtual String getName() const { return _displayName; }
-	virtual bool isValid() const { return _isValid; }
+	virtual String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
-	virtual String path() const { return _path; }
+	virtual bool isValid() const { return _isValid; }
-
+	
-	virtual bool listDir(AbstractFSList &list, ListMode mode) const;
+	virtual AbstractFilesystemNode *getChild(const String &n) const;
-	virtual AbstractFilesystemNode *parent() const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode) const;
-	virtual AbstractFilesystemNode *child(const String &n) const;
+	virtual AbstractFilesystemNode *getParent() const;
+	
+private:
+	/**
+	 * Tests and sets the _isValid and _isDirectory flags, using the stat() function.
+	 */
+	virtual void setFlags();
 };
 
-
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ * 			/foo/bar.txt would return /bar.txt
+ * 			/foo/bar/    would return /bar/
+ *  
+ * @param str String containing the path.
+ * @return Pointer to the first char of the last component inside str.
+ */
 static const char *lastPathComponent(const Common::String &str) {
 	const char *start = str.c_str();
 	const char *cur = start + str.size() - 2;
@@ -72,18 +97,10 @@ static const char *lastPathComponent(const Common::String &str) {
 	return cur + 1;
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
+void POSIXFilesystemNode::setFlags() {
-	char buf[MAXPATHLEN];
+	struct stat st;
-	getcwd(buf, MAXPATHLEN);
+	_isValid = (0 == stat(_path.c_str(), &st));
-	return new POSIXFilesystemNode(buf, true);
+	_isDirectory = _isValid ? S_ISDIR(st.st_mode) : false;	
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-	return new POSIXFilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-	return new POSIXFilesystemNode(path, true);
 }
 
 POSIXFilesystemNode::POSIXFilesystemNode() {
@@ -124,22 +141,33 @@ POSIXFilesystemNode::POSIXFilesystemNode(const String &p, bool verify) {
 	_isDirectory = true;
 
 	if (verify) {
-		struct stat st;
+		setFlags();
-		_isValid = (0 == stat(_path.c_str(), &st));
-		_isDirectory = _isValid ? S_ISDIR(st.st_mode) : false;
 	}
 }
 
-bool POSIXFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *POSIXFilesystemNode::getChild(const 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);
-	DIR *dirp = opendir(_path.c_str());
+	
+	String newPath(_path);
+	if (_path.lastChar() != '/')
+		newPath += '/';
+	newPath += n;
+	
+	return new POSIXFilesystemNode(newPath, true);
+}
 
+bool POSIXFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode) const {
+	assert(_isDirectory);
+	
+	DIR *dirp = opendir(_path.c_str());
 	struct dirent *dp;
 
 	if (dirp == NULL)
 		return false;
 
-	// ... loop over dir entries using readdir
+	// loop over dir entries using readdir
 	while ((dp = readdir(dirp)) != NULL) {
 		// Skip 'invisible' files
 		if (dp->d_name[0] == '.')
@@ -153,18 +181,18 @@ bool POSIXFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
 		POSIXFilesystemNode entry(newPath, false);
 
 #if defined(SYSTEM_NOT_SUPPORTING_D_TYPE)
-		// TODO: d_type is not part of POSIX, so it might not be supported
+		/* TODO: d_type is not part of POSIX, so it might not be supported
-		// on some of our targets. For those systems where it isn't supported,
+		 * on some of our targets. For those systems where it isn't supported,
-		// add this #elif case, which tries to use stat() instead.
+		 * add this #elif case, which tries to use stat() instead.
-		struct stat st;
+		 * 
-		entry._isValid = (0 == stat(entry._path.c_str(), &st));
+		 * The d_type method is used to avoid costly recurrent stat() calls in big
-		entry._isDirectory = entry._isValid ? S_ISDIR(st.st_mode) : false;
+		 * directories.
+		 */
+		entry.setFlags();
 #else
 		if (dp->d_type == DT_UNKNOWN) {
 			// Fall back to stat()
-			struct stat st;
+			entry.setFlags();
-			entry._isValid = (0 == stat(entry._path.c_str(), &st));
-			entry._isDirectory = entry._isValid ? S_ISDIR(st.st_mode) : false;
 		} else {
 			entry._isValid = (dp->d_type == DT_DIR) || (dp->d_type == DT_REG) || (dp->d_type == DT_LNK);
 			if (dp->d_type == DT_LNK) {
@@ -191,35 +219,22 @@ bool POSIXFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
 
 		if (entry._isDirectory)
 			entry._path += "/";
+			
 		myList.push_back(new POSIXFilesystemNode(entry));
 	}
 	closedir(dirp);
+	
 	return true;
 }
 
-AbstractFilesystemNode *POSIXFilesystemNode::parent() const {
+AbstractFilesystemNode *POSIXFilesystemNode::getParent() const {
 	if (_path == "/")
 		return 0;
 
 	const char *start = _path.c_str();
 	const char *end = lastPathComponent(_path);
 
-	POSIXFilesystemNode *p = new POSIXFilesystemNode(String(start, end - start), false);
+	return new POSIXFilesystemNode(String(start, end - start), false);
-
-	return p;
 }
 
-AbstractFilesystemNode *POSIXFilesystemNode::child(const String &n) const {
+#endif //#if defined(UNIX)
-	// FIXME: Pretty lame implementation! We do no error checking to speak
-	// of, do not check if this is a special node, etc.
-	assert(_isDirectory);
-	String newPath(_path);
-	if (_path.lastChar() != '/')
-		newPath += '/';
-	newPath += n;
-	POSIXFilesystemNode *p = new POSIXFilesystemNode(newPath, true);
-
-	return p;
-}
-
-#endif // defined(UNIX)

backends/fs/ps2/Ps2FilesystemFactory.cpp

@@ -0,0 +1,23 @@
+#include "backends/fs/ps2/Ps2FilesystemFactory.h"
+#include "backends/fs/ps2/ps2-fs.cpp"
+
+Ps2FilesystemFactory *Ps2FilesystemFactory::_instance = 0;
+
+Ps2FilesystemFactory *Ps2FilesystemFactory::instance(){
+	if(_instance == 0){
+		_instance = new Ps2FilesystemFactory();
+	}
+	return _instance;
+}
+
+AbstractFilesystemNode *Ps2FilesystemFactory::makeRootFileNode() const {
+	return new Ps2FilesystemNode();
+}
+
+AbstractFilesystemNode *Ps2FilesystemFactory::makeCurrentDirectoryFileNode() const {
+	return new Ps2FilesystemNode();
+}
+
+AbstractFilesystemNode *Ps2FilesystemFactory::makeFileNodePath(const String &path) const {
+	return new Ps2FilesystemNode(path);
+}

backends/fs/ps2/Ps2FilesystemFactory.h

@@ -0,0 +1,38 @@
+#ifndef PS2FILESYSTEMFACTORY_H_
+#define PS2FILESYSTEMFACTORY_H_
+
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/**
+ * Creates PS2FilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class Ps2FilesystemFactory : public AbstractFilesystemFactory {	
+public:
+	typedef Common::String String;
+	
+	/**
+	 * Creates an instance of Ps2FilesystemFactory using the Singleton pattern.
+	 * 
+	 * @return A unique instance of Ps2FilesytemFactory.
+	 */
+	static Ps2FilesystemFactory *instance();
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~Ps2FilesystemFactory() {};
+		
+	virtual AbstractFilesystemNode *makeRootFileNode() const;
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	
+protected:
+	Ps2FilesystemFactory() {};
+		
+private:
+	static Ps2FilesystemFactory *_instance;
+};
+
+#endif /*PS2FILESYSTEMFACTORY_H_*/

backends/fs/ps2/ps2-fs.cpp

@@ -29,44 +29,49 @@
 extern AsyncFio fio;
 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.
+ */
 class Ps2FilesystemNode : public AbstractFilesystemNode {
 protected:
 	String _displayName;
+	String _path;
 	bool _isDirectory;
 	bool _isRoot;
-	String _path;
 
 public:
-	Ps2FilesystemNode(void);
+	/**
-	Ps2FilesystemNode(const Ps2FilesystemNode *node);
+	 * Creates a PS2FilesystemNode with the root node as path.
+	 */
+	Ps2FilesystemNode();
+	
+	/**
+	 * Creates a PS2FilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 */
 	Ps2FilesystemNode(const String &path);
+	
+	/**
+	 * Copy constructor.
+	 */
+	Ps2FilesystemNode(const Ps2FilesystemNode *node);
 
-	virtual String displayName() const { return _displayName; }
+	virtual String getDisplayName() const { return _displayName; }
-	virtual String name() const { return _displayName; }
+	virtual String getName() const { return _displayName; }
-	virtual bool isValid() const { return !_isRoot; }
+	virtual String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
-	virtual String path() const { return _path; }
+	virtual bool isValid() const { return !_isRoot; }
 
-	//virtual FSList listDir(ListMode) const;
-	virtual bool listDir(AbstractFSList &list, ListMode mode) const;
-	virtual AbstractFilesystemNode *parent() const;
 	virtual AbstractFilesystemNode *clone() const { return new Ps2FilesystemNode(this); }
-	virtual AbstractFilesystemNode *child(const String &n) const;
+	virtual AbstractFilesystemNode *getChild(const String &n) const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode) const;
+	virtual AbstractFilesystemNode *getParent() const;
 };
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
+Ps2FilesystemNode::Ps2FilesystemNode() {
-	return AbstractFilesystemNode::getRoot();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot(void) {
-	return new Ps2FilesystemNode();
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-	return new Ps2FilesystemNode(path);
-}
-
-Ps2FilesystemNode::Ps2FilesystemNode(void) {
 	_isDirectory = true;
 	_isRoot = true;
 	_displayName = "PlayStation 2";
@@ -105,7 +110,41 @@ Ps2FilesystemNode::Ps2FilesystemNode(const Ps2FilesystemNode *node) {
 	_isRoot = node->_isRoot;
 }
 
-bool Ps2FilesystemNode::listDir(AbstractFSList &list, ListMode mode) const {
+AbstractFilesystemNode *Ps2FilesystemNode::getChild(const String &n) const {
+	if (!_isDirectory)
+		return NULL;
+
+	char listDir[256];
+	sprintf(listDir, "%s/", _path.c_str());
+	int fd = fio.dopen(listDir);
+	
+	if (fd >= 0) {
+		iox_dirent_t dirent;
+		
+		while (fio.dread(fd, &dirent) > 0) {
+			if (strcmp(n.c_str(), dirent.name) == 0) {
+				Ps2FilesystemNode *dirEntry = new Ps2FilesystemNode();
+
+				dirEntry->_isDirectory = (bool)(dirent.stat.mode & FIO_S_IFDIR);
+				dirEntry->_isRoot = false;
+
+				dirEntry->_path = _path;
+				dirEntry->_path += "/";
+				dirEntry->_path += dirent.name;
+
+				dirEntry->_displayName = dirent.name;
+
+				fio.dclose(fd);
+				return dirEntry;
+			}
+		}
+		fio.dclose(fd);
+	}
+	
+	return NULL;
+}
+
+bool Ps2FilesystemNode::getChildren(AbstractFSList &list, ListMode mode) const {
 	if (!_isDirectory)
 		return false;
 
@@ -132,6 +171,7 @@ bool Ps2FilesystemNode::listDir(AbstractFSList &list, ListMode mode) const {
 	} else {
 		char listDir[256];
 		int fd;
+		
 		if (_path.lastChar() == '/')
 			fd = fio.dopen(_path.c_str());
 		else {
@@ -170,7 +210,7 @@ bool Ps2FilesystemNode::listDir(AbstractFSList &list, ListMode mode) const {
 	}
 }
 
-AbstractFilesystemNode *Ps2FilesystemNode::parent() const {
+AbstractFilesystemNode *Ps2FilesystemNode::getParent() const {
 	if (_isRoot)
 		return new Ps2FilesystemNode(this);
 
@@ -188,36 +228,3 @@ AbstractFilesystemNode *Ps2FilesystemNode::parent() const {
 	else
 		return new Ps2FilesystemNode();
 }
-
-AbstractFilesystemNode *Ps2FilesystemNode::child(const String &n) const {
-	if (!_isDirectory)
-		return NULL;
-
-	char listDir[256];
-	sprintf(listDir, "%s/", _path.c_str());
-	int fd = fio.dopen(listDir);
-	
-	if (fd >= 0) {
-		iox_dirent_t dirent;
-
-		while (fio.dread(fd, &dirent) > 0) {
-			if (strcmp(n.c_str(), dirent.name) == 0) {
-				Ps2FilesystemNode *dirEntry = new Ps2FilesystemNode();
-
-				dirEntry->_isDirectory = (bool)(dirent.stat.mode & FIO_S_IFDIR);
-				dirEntry->_isRoot = false;
-
-				dirEntry->_path = _path;
-				dirEntry->_path += "/";
-				dirEntry->_path += dirent.name;
-
-				dirEntry->_displayName = dirent.name;
-
-				fio.dclose(fd);
-				return dirEntry;
-			}
-		}
-		fio.dclose(fd);
-	}
-	return NULL;
-}

backends/fs/psp/PSPFilesystemFactory.cpp

@@ -0,0 +1,23 @@
+#include "backends/fs/psp/PSPFilesystemFactory.h"
+#include "backends/fs/psp/psp_fs.cpp"
+
+PSPFilesystemFactory *PSPFilesystemFactory::_instance = 0;
+
+PSPFilesystemFactory *PSPFilesystemFactory::instance(){
+	if(_instance == 0){
+		_instance = new PSPFilesystemFactory();
+	}
+	return _instance;
+}
+
+AbstractFilesystemNode *PSPFilesystemFactory::makeRootFileNode() const {
+	return new PSPFilesystemNode();
+}
+
+AbstractFilesystemNode *PSPFilesystemFactory::makeCurrentDirectoryFileNode() const {
+	return new PSPFilesystemNode();
+}
+
+AbstractFilesystemNode *PSPFilesystemFactory::makeFileNodePath(const String &path) const {
+	return new PSPFilesystemNode(path, true);
+}

backends/fs/psp/PSPFilesystemFactory.h

@@ -0,0 +1,38 @@
+#ifndef PSPFILESYSTEMFACTORY_H_
+#define PSPFILESYSTEMFACTORY_H_
+
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/**
+ * Creates PSPFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class PSPFilesystemFactory : public AbstractFilesystemFactory {	
+public:
+	typedef Common::String String;
+	
+	/**
+	 * Creates an instance of PSPFilesystemFactory using the Singleton pattern.
+	 * 
+	 * @return A unique instance of PSPFilesytemFactory.
+	 */
+	static PSPFilesystemFactory *instance();
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~PSPFilesystemFactory() {};
+		
+	virtual AbstractFilesystemNode *makeRootFileNode() const;
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	
+protected:
+	PSPFilesystemFactory() {};
+		
+private:
+	static PSPFilesystemFactory *_instance;
+};
+
+#endif /*PSPFILESYSTEMFACTORY_H_*/

backends/fs/psp/psp_fs.cpp

@@ -23,8 +23,8 @@
  */
 
 #ifdef __PSP__
-#include "engines/engine.h"
 
+#include "engines/engine.h"
 #include "backends/fs/abstract-fs.h"
 
 #include <sys/stat.h>
@@ -32,39 +32,62 @@
 
 #define	ROOT_PATH	"ms0:/"
 
-
+/**
-/*
  * Implementation of the ScummVM file system API based on PSPSDK API.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class PSPFilesystemNode : public AbstractFilesystemNode {
 protected:
 	String _displayName;
+	String _path;
 	bool _isDirectory;
 	bool _isValid;
-	String _path;
 	
 public:
+	/**
+	 * Creates a PSPFilesystemNode with the root node as path.
+	 */
 	PSPFilesystemNode();
+	
+	/**
+	 * Creates a PSPFilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 * @param verify true if the isValid and isDirectory flags should be verified during the construction.
+	 */
 	PSPFilesystemNode(const Common::String &p, bool verify);
 
-	virtual String displayName() const { return _displayName; }
+	virtual String getDisplayName() const { return _displayName; }
-	virtual String name() const { return _displayName; }
+	virtual String getName() const { return _displayName; }
-	virtual bool isValid() const { return _isValid; }
+	virtual String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
-	virtual String path() const { return _path; }
+	virtual bool isValid() const { return _isValid; }
 
-	virtual bool listDir(AbstractFSList &list, ListMode mode) const;
+	virtual AbstractFilesystemNode *getChild(const String &n) const;
-	virtual AbstractFilesystemNode *parent() const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode) const;
-	virtual AbstractFilesystemNode *child(const String &n) const;
+	virtual AbstractFilesystemNode *getParent() const;
 };
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
+/**
-	return AbstractFilesystemNode::getRoot();
+ * Returns the last component of a given path.
-}
+ * 
+ * Examples:
+ * 			/foo/bar.txt would return /bar.txt
+ * 			/foo/bar/    would return /bar/
+ *  
+ * @param str String containing the path.
+ * @return Pointer to the first char of the last component inside str.
+ */
+static const char *lastPathComponent(const Common::String &str) {
+	const char *start = str.c_str();
+	const char *cur = start + str.size() - 2;
 
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
+	while (cur >= start && *cur != '/') {
-	return new PSPFilesystemNode();
+		--cur;
+	}
+
+	return cur + 1;
 }
 
 PSPFilesystemNode::PSPFilesystemNode() {
@@ -89,12 +112,20 @@ PSPFilesystemNode::PSPFilesystemNode(const Common::String &p, bool verify) {
 	}       
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
+AbstractFilesystemNode *PSPFilesystemNode::getChild(const String &n) const {
-	return new PSPFilesystemNode(path, true);
+	// FIXME: Pretty lame implementation! We do no error checking to speak
+	// of, do not check if this is a special node, etc.
+	assert(_isDirectory);
+	
+	String newPath(_path);
+	if (_path.lastChar() != '/')
+		newPath += '/';
+	newPath += n;
+
+	return new PSPFilesystemNode(newPath, true);
 }
 
-
+bool PSPFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode) const {
-bool PSPFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
 	assert(_isDirectory);
 
 	int dfd  = sceIoDopen(_path.c_str());
@@ -133,18 +164,7 @@ bool PSPFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
 	}
 }
 
-static const char *lastPathComponent(const Common::String &str) {
+AbstractFilesystemNode *PSPFilesystemNode::getParent() const {
-	const char *start = str.c_str();
-	const char *cur = start + str.size() - 2;
-
-	while (cur >= start && *cur != '/') {
-		--cur;
-	}
-
-	return cur + 1;
-}
-
-AbstractFilesystemNode *PSPFilesystemNode::parent() const {
 	assert(_isValid);
 	
 	if (_path == ROOT_PATH)
@@ -153,22 +173,7 @@ AbstractFilesystemNode *PSPFilesystemNode::parent() const {
 	const char *start = _path.c_str();
 	const char *end = lastPathComponent(_path);
 	
-	PSPFilesystemNode *p = new PSPFilesystemNode(String(start, end - start), false);
+	return new PSPFilesystemNode(String(start, end - start), false);
-	
-	return p;
 }
 
-AbstractFilesystemNode *PSPFilesystemNode::child(const String &n) const {
+#endif //#ifdef __PSP__
-	// FIXME: Pretty lame implementation! We do no error checking to speak
-	// of, do not check if this is a special node, etc.
-	assert(_isDirectory);
-	String newPath(_path);
-	if (_path.lastChar() != '/')
-		newPath += '/';
-	newPath += n;
-	PSPFilesystemNode *p = new PSPFilesystemNode(newPath, true);
-
-	return p;
-}
-
-#endif // PSP

backends/fs/symbian/SymbianFilesystemFactory.cpp

@@ -0,0 +1,25 @@
+#include "backends/fs/symbian/SymbianFilesystemFactory.h"
+#include "backends/fs/symbian/symbian-fs.cpp"
+
+SymbianFilesystemFactory *SymbianFilesystemFactory::_instance = 0;
+
+SymbianFilesystemFactory *SymbianFilesystemFactory::instance(){
+	if(_instance == 0){
+		_instance = new SymbianFilesystemFactory();
+	}
+	return _instance;
+}
+
+AbstractFilesystemNode *SymbianFilesystemFactory::makeRootFileNode() const {
+	return new SymbianFilesystemNode(true);
+}
+
+AbstractFilesystemNode *SymbianFilesystemFactory::makeCurrentDirectoryFileNode() const {
+	char path[MAXPATHLEN];
+	getcwd(path, MAXPATHLEN);
+	return new SymbianFilesystemNode(path);
+}
+
+AbstractFilesystemNode *SymbianFilesystemFactory::makeFileNodePath(const String &path) const {
+	return new SymbianFilesystemNode(path);
+}

backends/fs/symbian/SymbianFilesystemFactory.h

@@ -0,0 +1,38 @@
+#ifndef SYMBIANFILESYSTEMFACTORY_H_
+#define SYMBIANFILESYSTEMFACTORY_H_
+
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/**
+ * Creates SymbianFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class SymbianFilesystemFactory : public AbstractFilesystemFactory {	
+public:
+	typedef Common::String String;
+	
+	/**
+	 * Creates an instance of SymbianFilesystemFactory using the Singleton pattern.
+	 * 
+	 * @return A unique instance of SymbianFilesytemFactory.
+	 */
+	static SymbianFilesystemFactory *instance();
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~SymbianFilesystemFactory() {};
+		
+	virtual AbstractFilesystemNode *makeRootFileNode() const;
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	
+protected:
+	SymbianFilesystemFactory() {};
+		
+private:
+	static SymbianFilesystemFactory *_instance;
+};
+
+#endif /*SYMBIANFILESYSTEMFACTORY_H_*/

backends/fs/symbian/symbian-fs.cpp

@@ -31,33 +31,55 @@
 #include <f32file.h>
 #include <bautils.h>
 
-/*
+/**
  * Implementation of the ScummVM file system API based on POSIX.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class SymbianFilesystemNode : public AbstractFilesystemNode {
 protected:
 	String _displayName;
+	String _path;
 	bool _isDirectory;
 	bool _isValid;
-	String _path;
 	bool _isPseudoRoot;
 
 public:
+	/**
+	 * Creates a SymbianFilesystemNode with the root node as path.
+	 * 
+	 * @param aIsRoot true if the node will be a pseudo root, false otherwise.
+	 */
 	SymbianFilesystemNode(bool aIsRoot);
+	
+	/**
+	 * Creates a SymbianFilesystemNode for a given path.
+	 * 
+	 * @param path String with the path the new node should point to.
+	 */
 	SymbianFilesystemNode(const String &path);
-	virtual String displayName() const { return _displayName; }
+	
-	virtual String name() const { return _displayName; }
+	virtual String getDisplayName() const { return _displayName; }
-	virtual bool isValid() const { return _isValid; }
+	virtual String getName() const { return _displayName; }
+	virtual String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
-	virtual String path() const { return _path; }
+	virtual bool isValid() const { return _isValid; }
 
-	virtual bool listDir(AbstractFSList &list, ListMode mode) const;
+	virtual AbstractFilesystemNode *getChild(const String &n) const;
-	virtual AbstractFilesystemNode *parent() const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode) const;
-	virtual AbstractFilesystemNode *child(const String &n) const;
+	virtual AbstractFilesystemNode *getParent() const;
 };
 
-
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ * 			c:\foo\bar.txt would return "\bar.txt"
+ * 			c:\foo\bar\    would return "\bar\"
+ *  
+ * @param str Path to obtain the last component from.
+ * @return Pointer to the first char of the last component inside str.
+ */
 static const char *lastPathComponent(const Common::String &str) {
 	const char *start = str.c_str();
 	const char *cur = start + str.size() - 2;
@@ -69,6 +91,11 @@ static const char *lastPathComponent(const Common::String &str) {
 	return cur + 1;
 }
 
+/**
+ * Fixes the path by changing all slashes to backslashes.
+ * 
+ * @param path String with the path to be fixed.
+ */
 static void fixFilePath(Common::String& path) {
 	TInt len = path.size();
 	
@@ -79,20 +106,6 @@ static void fixFilePath(Common::String& path) {
 	}
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
-	char path[MAXPATHLEN];
-	getcwd(path, MAXPATHLEN);
-	return new SymbianFilesystemNode(path);
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
-	return new SymbianFilesystemNode(true);
-}
-
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
-	return new SymbianFilesystemNode(path);
-}
-
 SymbianFilesystemNode::SymbianFilesystemNode(bool aIsRoot) {
 	_path = "";
 	_isValid = true;
@@ -128,7 +141,26 @@ SymbianFilesystemNode::SymbianFilesystemNode(const String &path) {
 	}
 }
 
-bool SymbianFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *SymbianFilesystemNode::getChild(const String &n) const {
+	assert(_isDirectory);
+	String newPath(_path);
+
+	if (_path.lastChar() != '\\')
+		newPath += '\\';
+	newPath += n;
+
+	TPtrC8 ptr((const unsigned char*) newPath.c_str(), newPath.size());
+	TFileName fname;
+	fname.Copy(ptr);
+	TBool isFolder = EFalse;
+	BaflUtils::IsFolder(CEikonEnv::Static()->FsSession(), fname, isFolder);
+	if(!isFolder)
+		return 0;
+
+	return new SymbianFilesystemNode(newPath);
+}
+
+bool SymbianFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode) const {
 	assert(_isDirectory);
 
 	if (_isPseudoRoot) {
@@ -199,18 +231,18 @@ bool SymbianFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const
 			}
 			CleanupStack::PopAndDestroy(dirPtr);
 		}
-
 	}
+	
 	return true;
 }
 
-AbstractFilesystemNode *SymbianFilesystemNode::parent() const {
+AbstractFilesystemNode *SymbianFilesystemNode::getParent() const {
 	SymbianFilesystemNode *p =NULL;
 
 	// Root node is its own parent. Still we can't just return this
 	// as the GUI code will call delete on the old node.
 	if (!_isPseudoRoot && _path.size() > 3) {
-		p=new SymbianFilesystemNode(false);
+		p = new SymbianFilesystemNode(false);
 		const char *start = _path.c_str();
 		const char *end = lastPathComponent(_path);
 
@@ -221,29 +253,10 @@ AbstractFilesystemNode *SymbianFilesystemNode::parent() const {
 	}
 	else
 	{
-		p=new SymbianFilesystemNode(true);
+		p = new SymbianFilesystemNode(true);
 	}
+	
 	return p;
 }
 
-AbstractFilesystemNode *SymbianFilesystemNode::child(const String &n) const {
+#endif //#if defined (__SYMBIAN32__)
-	assert(_isDirectory);
-	String newPath(_path);
-
-	if (_path.lastChar() != '\\')
-		newPath += '\\';
-	newPath += n;
-
-	TPtrC8 ptr((const unsigned char*) newPath.c_str(), newPath.size());
-	TFileName fname;
-	fname.Copy(ptr);
-	TBool isFolder = EFalse;
-	BaflUtils::IsFolder(CEikonEnv::Static()->FsSession(), fname, isFolder);
-	if(!isFolder)
-		return 0;
-
-	SymbianFilesystemNode *p = new SymbianFilesystemNode(newPath);
-	return p;
-}
-
-#endif // defined(__SYMBIAN32__)

backends/fs/windows/WindowsFilesystemFactory.cpp

@@ -0,0 +1,23 @@
+#include "backends/fs/windows/WindowsFilesystemFactory.h"
+#include "backends/fs/windows/windows-fs.cpp"
+
+WindowsFilesystemFactory *WindowsFilesystemFactory::_instance = 0;
+
+WindowsFilesystemFactory *WindowsFilesystemFactory::instance(){
+	if(_instance == 0){
+		_instance = new WindowsFilesystemFactory();
+	}
+	return _instance;
+}
+
+AbstractFilesystemNode *WindowsFilesystemFactory::makeRootFileNode() const {
+	return new WindowsFilesystemNode();
+}
+
+AbstractFilesystemNode *WindowsFilesystemFactory::makeCurrentDirectoryFileNode() const {
+	return new WindowsFilesystemNode(NULL, true);
+}
+
+AbstractFilesystemNode *WindowsFilesystemFactory::makeFileNodePath(const String &path) const {
+	return new WindowsFilesystemNode(path, false);
+}

backends/fs/windows/WindowsFilesystemFactory.h

@@ -0,0 +1,38 @@
+#ifndef WINDOWSFILESYSTEMFACTORY_H_
+#define WINDOWSFILESYSTEMFACTORY_H_
+
+#include "backends/fs/AbstractFilesystemFactory.h"
+
+/**
+ * Creates WindowsFilesystemNode objects.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemFactory.
+ */
+class WindowsFilesystemFactory : public AbstractFilesystemFactory {	
+public:
+	typedef Common::String String;
+	
+	/**
+	 * Creates an instance of WindowsFilesystemFactory using the Singleton pattern.
+	 * 
+	 * @return A unique instance of WindowsFilesytemFactory.
+	 */
+	static WindowsFilesystemFactory *instance();
+	
+	/**
+	 * Destructor.
+	 */
+	virtual ~WindowsFilesystemFactory() {};
+	
+	virtual AbstractFilesystemNode *makeRootFileNode() const;
+	virtual AbstractFilesystemNode *makeCurrentDirectoryFileNode() const;
+	virtual AbstractFilesystemNode *makeFileNodePath(const String &path) const;
+	
+protected:
+	WindowsFilesystemFactory() {};
+		
+private:
+	static WindowsFilesystemFactory *_instance;
+};
+
+#endif /*WINDOWSFILESYSTEMFACTORY_H_*/

backends/fs/windows/windows-fs.cpp

@@ -33,39 +33,90 @@
 #endif
 #include <tchar.h>
 
-/*
+/**
  * Implementation of the ScummVM file system API based on Windows API.
+ * 
+ * Parts of this class are documented in the base interface class, AbstractFilesystemNode.
  */
-
 class WindowsFilesystemNode : public AbstractFilesystemNode {
 protected:
 	String _displayName;
-	bool _isDirectory;
-	bool _isValid;
-	bool _isPseudoRoot;
 	String _path;
+	bool _isDirectory;
+	bool _isPseudoRoot;
+	bool _isValid;
 
 public:
+	/**
+	 * Creates a WindowsFilesystemNode with the root node as path.
+	 * 
+	 * In regular windows systems, a virtual root path is used "".
+	 * In windows CE, the "\" root is used instead.
+	 */
 	WindowsFilesystemNode();
-	WindowsFilesystemNode(const String &path);
+	
+	/**
+	 * Creates a WindowsFilesystemNode for a given path.
+	 * 
+	 * Examples:
+	 *			path=c:\foo\bar.txt, currentDir=false -> c:\foo\bar.txt
+	 * 			path=c:\foo\bar.txt, currentDir=true -> current directory
+	 * 			path=NULL, currentDir=true -> current directory
+	 * 
+	 * @param path String with the path the new node should point to.
+	 * @param currentDir if true, the path parameter will be ignored and the resulting node will point to the current directory.
+	 */
+	WindowsFilesystemNode(const String &path, const bool currentDir);
 
-	virtual String displayName() const { return _displayName; }
+	virtual String getDisplayName() const { return _displayName; }
-	virtual String name() const { return _displayName; }
+	virtual String getName() const { return _displayName; }
-	virtual bool isValid() const { return _isValid; }
+	virtual String getPath() const { return _path; }
 	virtual bool isDirectory() const { return _isDirectory; }
-	virtual String path() const { return _path; }
+	virtual bool isValid() const { return _isValid; }
 
-	virtual bool listDir(AbstractFSList &list, ListMode mode) const;
+	virtual AbstractFilesystemNode *getChild(const String &n) const;
-	virtual AbstractFilesystemNode *parent() const;
+	virtual bool getChildren(AbstractFSList &list, ListMode mode) const;
-	virtual AbstractFilesystemNode *child(const String &n) const;
+	virtual AbstractFilesystemNode *getParent() const;
 
 private:
-	static char *toAscii(TCHAR *x);
+	/**
-	static const TCHAR* toUnicode(const char *x);
+	 * Adds a single WindowsFilesystemNode to a given list.
-	static void addFile (AbstractFSList &list, ListMode mode, const char *base, WIN32_FIND_DATA* find_data);
+	 * This method is used by getChildren() to populate the directory entries list. 
+	 * 
+	 * @param list List to put the file entry node in.
+	 * @param mode Mode to use while adding the file entry to the list.
+	 * @param base String with the directory being listed.
+	 * @param find_data Describes a file that the FindFirstFile, FindFirstFileEx, or FindNextFile functions find.
+ 	 */
+	static void addFile(AbstractFSList &list, ListMode mode, const char *base, WIN32_FIND_DATA* find_data);
+	
+	/**
+	 * Converts a Unicode string to Ascii format.
+	 * 
+	 * @param str String to convert from Unicode to Ascii.
+	 * @return str in Ascii format.
+ 	 */
+	static char *toAscii(TCHAR *str);
+	
+	/**
+	 * Converts an Ascii string to Unicode format.
+	 * 
+	 * @param str String to convert from Ascii to Unicode.
+	 * @return str in Unicode format.
+ 	 */
+	static const TCHAR* toUnicode(const char *str);
 };
 
-
+/**
+ * Returns the last component of a given path.
+ * 
+ * Examples:
+ * 			c:\foo\bar.txt would return "\bar.txt"
+ * 			c:\foo\bar\    would return "\bar\"
+ *  
+ * @param str Path to obtain the last component from.
+ * @return Pointer to the first char of the last component inside str.
+ */
 static const char *lastPathComponent(const Common::String &str) {
 	const char *start = str.c_str();
 	const char *cur = start + str.size() - 2;
@@ -77,27 +128,6 @@ static const char *lastPathComponent(const Common::String &str) {
 	return cur + 1;
 }
 
-char* WindowsFilesystemNode::toAscii(TCHAR *x) {
-
-#ifndef UNICODE
-	return (char*)x;
-#else
-	static char asciiString[MAX_PATH];
-	WideCharToMultiByte(CP_ACP, 0, x, _tcslen(x) + 1, asciiString, sizeof(asciiString), NULL, NULL);
-	return asciiString;
-#endif
-}
-
-const TCHAR* WindowsFilesystemNode::toUnicode(const char *x) {
-#ifndef UNICODE
-	return (const TCHAR *)x;
-#else
-	static TCHAR unicodeString[MAX_PATH];
-	MultiByteToWideChar(CP_ACP, 0, x, strlen(x) + 1, unicodeString, sizeof(unicodeString) / sizeof(TCHAR));
-	return unicodeString;
-#endif
-}
-
 void WindowsFilesystemNode::addFile(AbstractFSList &list, ListMode mode, const char *base, WIN32_FIND_DATA* find_data) {
 	WindowsFilesystemNode entry;
 	char *asciiName = toAscii(find_data->cFileName);
@@ -125,25 +155,24 @@ void WindowsFilesystemNode::addFile(AbstractFSList &list, ListMode mode, const c
 	list.push_back(new WindowsFilesystemNode(entry));
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getCurrentDirectory() {
+char* WindowsFilesystemNode::toAscii(TCHAR *str) {
-	char path[MAX_PATH];
+#ifndef UNICODE
-	GetCurrentDirectory(MAX_PATH, path);
+	return (char*)str;
-
+#else
-	// Add a trailing slash, if necessary.
+	static char asciiString[MAX_PATH];
-	if (path[0] != 0) {
+	WideCharToMultiByte(CP_ACP, 0, str, _tcslen(str) + 1, asciiString, sizeof(asciiString), NULL, NULL);
-		if (path[strlen(path) - 1] != '\\')
+	return asciiString;
-			strcat(path, "\\");
+#endif
-	}
-
-	return new WindowsFilesystemNode(path);
 }
 
-AbstractFilesystemNode *AbstractFilesystemNode::getRoot() {
+const TCHAR* WindowsFilesystemNode::toUnicode(const char *str) {
-	return new WindowsFilesystemNode();
+#ifndef UNICODE
-}
+	return (const TCHAR *)str;
-
+#else
-AbstractFilesystemNode *AbstractFilesystemNode::getNodeForPath(const String &path) {
+	static TCHAR unicodeString[MAX_PATH];
-	return new WindowsFilesystemNode(path);
+	MultiByteToWideChar(CP_ACP, 0, str, strlen(str) + 1, unicodeString, sizeof(unicodeString) / sizeof(TCHAR));
+	return unicodeString;
+#endif
 }
 
 WindowsFilesystemNode::WindowsFilesystemNode() {
@@ -162,10 +191,23 @@ WindowsFilesystemNode::WindowsFilesystemNode() {
 #endif
 }
 
-WindowsFilesystemNode::WindowsFilesystemNode(const String &p) {
+WindowsFilesystemNode::WindowsFilesystemNode(const String &p, const bool currentDir) {
-	assert(p.size() > 0);
+	if (currentDir) {
+		char path[MAX_PATH];
+		GetCurrentDirectory(MAX_PATH, path);
 
-	_path = p;
+		// Add a trailing slash, if necessary.
+		if (path[0] != 0) {
+			if (path[strlen(path) - 1] != '\\')
+				strcat(path, "\\");
+		}
+		_path = path;
+	}
+	else {
+		assert(p.size() > 0);
+		_path = p;
+	}
+	
 	_displayName = lastPathComponent(_path);
 
 	// Check whether it is a directory, and whether the file actually exists
@@ -181,7 +223,23 @@ WindowsFilesystemNode::WindowsFilesystemNode(const String &p) {
 	_isPseudoRoot = false;
 }
 
-bool WindowsFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const {
+AbstractFilesystemNode *WindowsFilesystemNode::getChild(const String &n) const {
+	assert(_isDirectory);
+	
+	String newPath(_path);
+	if (_path.lastChar() != '\\')
+		newPath += '\\';
+	newPath += n;
+
+	// Check whether the directory actually exists
+	DWORD fileAttribs = GetFileAttributes(toUnicode(newPath.c_str()));
+	if (fileAttribs == INVALID_FILE_ATTRIBUTES)
+		return 0;
+
+	return new WindowsFilesystemNode(newPath, false);
+}
+
+bool WindowsFilesystemNode::getChildren(AbstractFSList &myList, ListMode mode) const {
 	assert(_isDirectory);
 
 	if (_isPseudoRoot) {
@@ -227,10 +285,12 @@ bool WindowsFilesystemNode::listDir(AbstractFSList &myList, ListMode mode) const
 	return true;
 }
 
-AbstractFilesystemNode *WindowsFilesystemNode::parent() const {
+AbstractFilesystemNode *WindowsFilesystemNode::getParent() const {
 	assert(_isValid || _isPseudoRoot);
+	
 	if (_isPseudoRoot)
 		return 0;
+		
 	WindowsFilesystemNode *p = new WindowsFilesystemNode();
 	if (_path.size() > 3) {
 		const char *start = _path.c_str();
@@ -243,23 +303,8 @@ AbstractFilesystemNode *WindowsFilesystemNode::parent() const {
 		p->_displayName = lastPathComponent(p->_path);
 		p->_isPseudoRoot = false;
 	}
+	
 	return p;
 }
 
-AbstractFilesystemNode *WindowsFilesystemNode::child(const String &n) const {
+#endif //#ifdef WIN32
-	assert(_isDirectory);
-	String newPath(_path);
-	if (_path.lastChar() != '\\')
-		newPath += '\\';
-	newPath += n;
-
-	// Check whether the directory actually exists
-	DWORD fileAttribs = GetFileAttributes(toUnicode(newPath.c_str()));
-	if (fileAttribs == INVALID_FILE_ATTRIBUTES)
-		return 0;
-
-	WindowsFilesystemNode *p = new WindowsFilesystemNode(newPath);
-	return p;
-}
-
-#endif // WIN32

common/fs.cpp

@@ -23,7 +23,7 @@
 
 #include "backends/fs/abstract-fs.h"
 #include "common/util.h"
-
+#include "backends/fs/FilesystemFactoryMaker.cpp"
 
 FilesystemNode::FilesystemNode(AbstractFilesystemNode *realNode) {
 	_realNode = realNode;
@@ -43,10 +43,12 @@ FilesystemNode::FilesystemNode(const FilesystemNode &node) {
 }
 
 FilesystemNode::FilesystemNode(const Common::String &p) {
+	AbstractFilesystemFactory *factory = FilesystemFactoryMaker::makeFactory();
+	
 	if (p.empty() || p == ".")
-		_realNode = AbstractFilesystemNode::getCurrentDirectory();
+		_realNode = factory->makeCurrentDirectoryFileNode();
 	else
-		_realNode = AbstractFilesystemNode::getNodeForPath(p);
+		_realNode = factory->makeFileNodePath(p);
 	_refCount = new int(1);
 }
 
@@ -65,7 +67,7 @@ void FilesystemNode::decRefCount() {
 	}
 }
 
-FilesystemNode &FilesystemNode::operator  =(const FilesystemNode &node) {
+FilesystemNode &FilesystemNode::operator= (const FilesystemNode &node) {
 	if (node._refCount)
 		++(*node._refCount);
 
@@ -87,7 +89,7 @@ FilesystemNode FilesystemNode::getParent() const {
 	if (_realNode == 0)
 		return *this;
 
-	AbstractFilesystemNode *node = _realNode->parent();
+	AbstractFilesystemNode *node = _realNode->getParent();
 	if (node == 0) {
 		return *this;
 	} else {
@@ -100,7 +102,7 @@ FilesystemNode FilesystemNode::getChild(const Common::String &n) const {
 		return *this;
 
 	assert(_realNode->isDirectory());
-	AbstractFilesystemNode *node = _realNode->child(n);
+	AbstractFilesystemNode *node = _realNode->getChild(n);
 	return FilesystemNode(node);
 }
 
@@ -110,7 +112,7 @@ bool FilesystemNode::listDir(FSList &fslist, ListMode mode) const {
 
 	AbstractFSList tmp;
 	
-	if (!_realNode->listDir(tmp, mode))
+	if (!_realNode->getChildren(tmp, mode))
 		return false;
 	
 	fslist.clear();
@@ -129,20 +131,19 @@ bool FilesystemNode::isDirectory() const {
 
 Common::String FilesystemNode::displayName() const {
 	assert(_realNode);
-	return _realNode->displayName();
+	return _realNode->getDisplayName();
 }
 
 Common::String FilesystemNode::name() const {
 	assert(_realNode);
-	return _realNode->name();
+	return _realNode->getName();
 }
 
 Common::String FilesystemNode::path() const {
 	assert(_realNode);
-	return _realNode->path();
+	return _realNode->getPath();
 }
 
-
 bool FilesystemNode::operator< (const FilesystemNode& node) const
 {
 	if (isDirectory() && !node.isDirectory())

common/fs.h

@@ -30,7 +30,6 @@
 class FilesystemNode;
 class AbstractFilesystemNode;
 
-
 /**
  * List of multiple file system nodes. E.g. the contents of a given directory.
  * This is subclass instead of just a typedef so that we can use forward
@@ -38,9 +37,8 @@ class AbstractFilesystemNode;
  */
 class FSList : public Common::Array<FilesystemNode> {};
 
-
 /**
- * FilesystemNode provides an abstraction for file pathes, allowing for portable
+ * 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:, ...).
  *
@@ -64,8 +62,8 @@ class FSList : public Common::Array<FilesystemNode> {};
  */
 class FilesystemNode {
 private:
-	AbstractFilesystemNode *_realNode;
 	int *_refCount;
+	AbstractFilesystemNode *_realNode;
 
 	FilesystemNode(AbstractFilesystemNode *realNode);
 
@@ -110,43 +108,13 @@ public:
 	/**
 	 * Copy operator.
 	 */
-	FilesystemNode &operator  =(const FilesystemNode &node);
+	FilesystemNode &operator= (const FilesystemNode &node);
-
+	
 	/**
-	 * Checks if the FilesystemNode is valid for any usage
+	 * Compare the name of this node to the name of another. Directories
+	 * go before normal files.
 	 */
-	bool isValid() const;
+	bool operator< (const FilesystemNode& node) const;
-
-	/**
-	 * 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;
-
-	/**
-	 * Fetch a child node of this node, with the given name. Only valid for
-	 * directory nodes (an assertion is triggered otherwise). If no no child
-	 * node with the given name exists, an invalid node is returned.
-	 */
-	FilesystemNode getChild(const Common::String &name) const;
-
-	/**
-	 * Return a list of child nodes of this directory node. If called on a node
-	 * that does not represent a directory, false is returned.
-	 * @return true if succesful, false otherwise (e.g. when the directory does not exist).
-	 * @todo Rename this to listChildren or getChildren.
-	 */
-	virtual bool listDir(FSList &fslist, ListMode mode = kListDirectoriesOnly) const;
-
-	/**
-	 * Is this node pointing to a directory?
-	 * @todo Currently we assume that a valid node that is not a directory
-	 * automatically is a file (ignoring things like symlinks). That might
-	 * actually be OK... but we could still add an isFile method. Or even replace
-	 * isValid and isDirectory by a getType() method that can return values like
-	 * kDirNodeType, kFileNodeType, kInvalidNodeType.
-	 */
-	virtual bool isDirectory() const;
 
 	/**
 	 * Return a human readable string for this node, usable for display (e.g.
@@ -180,15 +148,51 @@ public:
 	virtual Common::String path() const;
 
 	/**
-	 * Compare the name of this node to the name of another. Directories
+	 * Fetch a child node of this node, with the given name. Only valid for
-	 * go before normal files.
+	 * directory nodes (an assertion is triggered otherwise).
+	 * If no child node with the given name exists, an invalid node is returned.
 	 */
-	bool operator< (const FilesystemNode& node) const;
+	FilesystemNode getChild(const Common::String &name) const;
+	
+	/**
+	 * Return a list of child nodes of this directory node. If called on a node
+	 * that does not represent a directory, false is returned.
+	 * 
+	 * @return true if succesful, false otherwise (e.g. when the directory does not exist).
+	 * @todo Rename this to listChildren or getChildren.
+	 */
+	virtual bool listDir(FSList &fslist, ListMode mode = kListDirectoriesOnly) const;	
+	
+	/**
+	 * 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;
+
+	/**
+	 * Indicates whether this path refers to a directory or not.
+	 * 
+	 * @todo Currently we assume that a valid node that is not a directory
+	 * automatically is a file (ignoring things like symlinks). That might
+	 * actually be OK... but we could still add an isFile method. Or even replace
+	 * isValid and isDirectory by a getType() method that can return values like
+	 * kDirNodeType, kFileNodeType, kInvalidNodeType.
+	 */
+	virtual bool isDirectory() const;
+	
+	/**
+	 * Indicates whether this path is valid or not for usage.
+	 */
+	bool isValid() const;
 
 protected:
+	/**
+	 * Decreases the reference count to the FilesystemNode, and if necessary,
+	 * deletes the corresponding underlying references.
+	 */
 	void decRefCount();
 };
 
 //} // End of namespace Common
 
-#endif
+#endif //COMMON_FS_H