QTfrontend/util/FileEngine.cpp
branchphysfslayer
changeset 7770 ff3442338882
parent 7768 13e2037ebc79
child 7931 5a27ed7f17b7
equal deleted inserted replaced
7768:13e2037ebc79 7770:ff3442338882
     1 /* borrowed from https://github.com/skhaz/qt-physfs-wrapper
     1 /* borrowed from https://github.com/skhaz/qt-physfs-wrapper
     2  * TODO: add copyright header, determine license
     2  * TODO: add copyright header, determine license
     3  */
     3  */
     4 
     4 
     5 #include "FileEngine.h"
     5 #include "FileEngine.h"
       
     6 
       
     7 
       
     8 const QString FileEngineHandler::scheme = "physfs:/";
     6 
     9 
     7 FileEngine::FileEngine(const QString& filename)
    10 FileEngine::FileEngine(const QString& filename)
     8 : _handler(NULL)
    11 : _handler(NULL)
     9 , _flags(0)
    12 , _flags(0)
    10 {
    13 {
    76     return PHYSFS_seek(_handler, pos) != 0;
    79     return PHYSFS_seek(_handler, pos) != 0;
    77 }
    80 }
    78 
    81 
    79 bool FileEngine::isSequential() const
    82 bool FileEngine::isSequential() const
    80 {
    83 {
    81     return true;
    84     return false;
    82 }
    85 }
    83 
    86 
    84 bool FileEngine::remove()
    87 bool FileEngine::remove()
    85 {
    88 {
    86     return PHYSFS_delete(_filename.toUtf8().constData()) != 0;
    89     return PHYSFS_delete(_filename.toUtf8().constData()) != 0;
   106 bool FileEngine::isRelativePath() const
   109 bool FileEngine::isRelativePath() const
   107 {
   110 {
   108     return true;
   111     return true;
   109 }
   112 }
   110 
   113 
       
   114 QAbstractFileEngineIterator * FileEngine::beginEntryList(QDir::Filters filters, const QStringList &filterNames)
       
   115 {
       
   116     return new FileEngineIterator(filters, filterNames, entryList(filters, filterNames));
       
   117 }
       
   118 
   111 QStringList FileEngine::entryList(QDir::Filters filters, const QStringList &filterNames) const
   119 QStringList FileEngine::entryList(QDir::Filters filters, const QStringList &filterNames) const
   112 {
   120 {
   113     Q_UNUSED(filters);
   121     Q_UNUSED(filters);
   114 
   122 
   115     QString file;
   123     QString file;
   116     QStringList result;
   124     QStringList result;
   117     char **files = PHYSFS_enumerateFiles("");
   125     char **files = PHYSFS_enumerateFiles(_filename.toUtf8().constData());
   118 
   126 
   119     for (char **i = files; *i != NULL; i++) {
   127     for (char **i = files; *i != NULL; i++) {
   120         file = QString::fromAscii(*i);
   128         file = QString::fromUtf8(*i);
   121         if (QDir::match(filterNames, file)) {
   129 
       
   130         if (filterNames.isEmpty() || QDir::match(filterNames, file)) {
   122             result << file;
   131             result << file;
   123         }
   132         }
   124     }
   133     }
   125 
   134 
   126     PHYSFS_freeList(files);
   135     PHYSFS_freeList(files);
       
   136 
   127     return result;
   137     return result;
   128 }
   138 }
   129 
   139 
   130 QAbstractFileEngine::FileFlags FileEngine::fileFlags(FileFlags type) const
   140 QAbstractFileEngine::FileFlags FileEngine::fileFlags(FileFlags type) const
   131 {
   141 {
   151     };
   161     };
   152 }
   162 }
   153 
   163 
   154 void FileEngine::setFileName(const QString &file)
   164 void FileEngine::setFileName(const QString &file)
   155 {
   165 {
   156     _filename = file;
   166     if(file.startsWith(FileEngineHandler::scheme))
       
   167         _filename = file.mid(FileEngineHandler::scheme.size());
       
   168     else
       
   169         _filename = file;
   157     PHYSFS_Stat stat;
   170     PHYSFS_Stat stat;
   158     if (PHYSFS_stat(_filename.toUtf8().constData(), &stat) != 0) {
   171     if (PHYSFS_stat(_filename.toUtf8().constData(), &stat) != 0) {
   159         _size = stat.filesize;
   172         _size = stat.filesize;
   160         _datetime = QDateTime::fromTime_t(stat.modtime);
   173         _datetime = QDateTime::fromTime_t(stat.modtime);
   161         _flags |= QAbstractFileEngine::ExistsFlag;
   174         _flags |= QAbstractFileEngine::ExistsFlag;
   185 qint64 FileEngine::read(char *data, qint64 maxlen)
   198 qint64 FileEngine::read(char *data, qint64 maxlen)
   186 {
   199 {
   187     return PHYSFS_readBytes(_handler, data, maxlen);
   200     return PHYSFS_readBytes(_handler, data, maxlen);
   188 }
   201 }
   189 
   202 
   190 qint64 FileEngine::readLine(char *data, qint64 maxlen)
       
   191 {
       
   192     Q_UNUSED(data);
       
   193     Q_UNUSED(maxlen);
       
   194     // TODO
       
   195     return 0;
       
   196 }
       
   197 
       
   198 qint64 FileEngine::write(const char *data, qint64 len)
   203 qint64 FileEngine::write(const char *data, qint64 len)
   199 {
   204 {
   200     return PHYSFS_writeBytes(_handler, data, len);
   205     return PHYSFS_writeBytes(_handler, data, len);
   201 }
   206 }
   202 
   207 
   218 bool FileEngine::supportsExtension(Extension extension) const
   223 bool FileEngine::supportsExtension(Extension extension) const
   219 {
   224 {
   220     return extension == QAbstractFileEngine::AtEndExtension;
   225     return extension == QAbstractFileEngine::AtEndExtension;
   221 }
   226 }
   222 
   227 
       
   228 
       
   229 
       
   230 FileEngineHandler::FileEngineHandler(char *argv0)
       
   231 {
       
   232     PHYSFS_init(argv0);
       
   233 }
       
   234 
       
   235 FileEngineHandler::~FileEngineHandler()
       
   236 {
       
   237     PHYSFS_deinit();
       
   238 }
       
   239 
   223 QAbstractFileEngine* FileEngineHandler::create(const QString &filename) const
   240 QAbstractFileEngine* FileEngineHandler::create(const QString &filename) const
   224 {
   241 {
   225     return new FileEngine(filename);
   242     if (filename.startsWith(scheme))
   226 }
   243         return new FileEngine(filename.mid(scheme.size()));
       
   244     else
       
   245         return NULL;
       
   246 }
       
   247 
       
   248 void FileEngineHandler::mount(const QString &path)
       
   249 {
       
   250     PHYSFS_mount(path.toUtf8().constData(), NULL, 1);
       
   251 }
       
   252 
       
   253 void FileEngineHandler::setWriteDir(const QString &path)
       
   254 {
       
   255     PHYSFS_setWriteDir(path.toUtf8().constData());
       
   256 }
       
   257 
       
   258 
       
   259 
       
   260 FileEngineIterator::FileEngineIterator(QDir::Filters filters, const QStringList &nameFilters, const QStringList &entries)
       
   261     : QAbstractFileEngineIterator(filters, nameFilters)
       
   262 {
       
   263     m_entries = entries;
       
   264 
       
   265     /* heck.. docs are unclear on this
       
   266      * QDirIterator puts iterator before first entry
       
   267      * but QAbstractFileEngineIterator example puts iterator on first entry
       
   268      * though QDirIterator approach seems to be the right one
       
   269      */
       
   270 
       
   271     m_index = -1;
       
   272 }
       
   273 
       
   274 bool FileEngineIterator::hasNext() const
       
   275 {
       
   276     return m_index < m_entries.size() - 1;
       
   277 }
       
   278 
       
   279 QString FileEngineIterator::next()
       
   280 {
       
   281    if (!hasNext())
       
   282        return QString();
       
   283 
       
   284    ++m_index;
       
   285    return currentFilePath();
       
   286 }
       
   287 
       
   288 QString FileEngineIterator::currentFileName() const
       
   289 {
       
   290     return m_entries.at(m_index);
       
   291 }