Merge lp:~carlos-mazieri/ubuntu-filemanager-app/model into lp:ubuntu-filemanager-app

[Carlos Jose Mazieri]

Fixes bug #1180956.

It contains the fix for bug #1180956.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:20
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~carlos-mazieri/ubuntu-filemanager-app/model/+merge/166863/+edit-commit-message

http://91.189.93.125:8080/job/ubuntu-filemanager-app-ci/5/
Executed test runs:
    SUCCESS: http://91.189.93.125:8080/job/ubuntu-filemanager-app-quantal-amd64-ci/2
    SUCCESS: http://91.189.93.125:8080/job/ubuntu-filemanager-app-raring-amd64-ci/5

Click here to trigger a rebuild:
http://91.189.93.125:8080/job/ubuntu-filemanager-app-ci/5/rebuild

review: Needs Fixing (continuous-integration)

[Arto Jalkanen (ajalkane)]

Hi,

you've committed to the wrong branch. This is for the QML application. The correct branch for plugin changes are in lp:ubuntu-filemanager-app/plugin

review: Disapprove

[lp:~carlos-mazieri/ubuntu-filemanager-app/model]

21. By Carlos Jose Mazieri on 2013-06-01

fixed refresh view signals when a pate operation is made and items already exist.
In this case as the existent item is removed both signals: "removed" and "added" items are sent.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:21
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~carlos-mazieri/ubuntu-filemanager-app/model/+merge/166863/+edit-commit-message

http://91.189.93.125:8080/job/ubuntu-filemanager-app-ci/6/
Executed test runs:
    SUCCESS: http://91.189.93.125:8080/job/ubuntu-filemanager-app-quantal-amd64-ci/3
    SUCCESS: http://91.189.93.125:8080/job/ubuntu-filemanager-app-raring-amd64-ci/6

Click here to trigger a rebuild:
http://91.189.93.125:8080/job/ubuntu-filemanager-app-ci/6/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

66. By Carlos Jose Mazieri on 2014-05-24

remade C++ UI

65. By Carlos Jose Mazieri on 2014-05-01

added moveToTrash, removeFromTrash, restoreFromTrash and emptyTrash facilities.
Test View remade to use selection.

64. By Carlos Jose Mazieri on 2014-04-15

Preparation for Move/Restore to/from Trash and Undo Actions:
 * Some information from Action data structure were moved into ActionEntry data structure.
 * Actions used to have "targetPath" saying all items (ActionEntry items) were copied/moved into a unique path.
   Now having ActionEntry more indenpendent allows to move/copy items to different paths inside an Action.
   This is required for Restore items from Trash.

63. By Carlos Jose Mazieri on 2014-03-23

Redesign:
    * Created Location class which represents a URL supported in the File Manager
      - DiskLocation represents any url/path like file:/// or normal /
      - TrashLocation represents any url/path like trash:///
      - There will be a SmbLocation for samba/cifs network sharing
    * Browsing items (IOReuest/IOWorkerThread) moved into the Location
    * External File system watcher handling was moved into DiskLocation class
    * Navigation into child folders and up to parent folder were delegated to the Location
    * Created LocationsFactory class which keeps the supported Locations, it provides a URL
      parser that sets the current Location.
Trash:
    * implemented browsing: missing carry orignal item properties
    * implemented a specific External File system watcher for trash
    * missing Move/Restore to/from Trash (NOT YET IMPLEMENTED)

OBS:
     * due to current File Manager UI typing method both: "file:" and "trash:" are supported.

=== added directory 'folderlistmodel'
=== added file 'folderlistmodel/README'
--- folderlistmodel/README	1970-01-01 00:00:00 +0000
+++ folderlistmodel/README	2013-06-01 17:20:36 +0000
@@ -0,0 +1,6 @@
+Building and installing
+=======================
+
+qmake && make
+sudo make install
+
 
=== added file 'folderlistmodel/dirmodel.cpp'
--- folderlistmodel/dirmodel.cpp	1970-01-01 00:00:00 +0000
+++ folderlistmodel/dirmodel.cpp	2013-06-01 17:20:36 +0000
@@ -0,0 +1,1005 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#include <errno.h>
+#include <string.h>
+#include "dirmodel.h"
+#include "ioworkerthread.h"
+#include "filesystemaction.h"
+
+#include <QDirIterator>
+#include <QDir>
+#include <QDebug>
+#include <QDateTime>
+#include <QFileIconProvider>
+#include <QUrl>
+#include <QDesktopServices>
+
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL) || QT_VERSION >= 0x050000
+# include <QMimeType>
+# include <QMimeDatabase>
+#endif
+
+#define IS_VALID_ROW(row)             (row >=0 && row < mDirectoryContents.count())
+#define WARN_ROW_OUT_OF_RANGE(row)    qWarning() << Q_FUNC_INFO << "row" << row << "Out of bounds access"
+
+
+Q_GLOBAL_STATIC(IOWorkerThread, ioWorkerThread)
+
+namespace {
+    QHash<QByteArray, int> roleMapping;
+}
+
+
+
+
+static bool fileCompareExists(const QFileInfo &a, const QFileInfo &b)
+{
+    if (a.isDir() && !b.isDir())
+        return true;
+
+    if (b.isDir() && !a.isDir())
+        return false;
+
+    bool ret = QString::localeAwareCompare(a.absoluteFilePath(), b.absoluteFilePath()) < 0;
+#if DEBUG_MESSAGES
+    qDebug() <<  Q_FUNC_INFO << ret << a.absoluteFilePath() << b.absoluteFilePath();
+#endif
+    return ret;
+}
+
+static bool fileCompareAscending(const QFileInfo &a, const QFileInfo &b)
+{
+    if (a.isDir() && !b.isDir())
+        return true;
+
+    if (b.isDir() && !a.isDir())
+        return false;
+
+    return QString::localeAwareCompare(a.fileName(), b.fileName()) < 0;
+}
+
+
+static bool fileCompareDescending(const QFileInfo &a, const QFileInfo &b)
+{
+    if (a.isDir() && !b.isDir())
+        return true;
+
+    if (b.isDir() && !a.isDir())
+        return false;
+
+    return QString::localeAwareCompare(a.fileName(), b.fileName()) > 0;
+}
+
+static bool dateCompareDescending(const QFileInfo &a, const QFileInfo &b)
+{
+    if (a.isDir() && !b.isDir())
+        return true;
+
+    if (b.isDir() && !a.isDir())
+        return false;
+
+    return a.lastModified() > b.lastModified();
+}
+
+static bool dateCompareAscending(const QFileInfo &a, const QFileInfo &b)
+{
+    if (a.isDir() && !b.isDir())
+        return true;
+
+    if (b.isDir() && !a.isDir())
+        return false;
+
+    return a.lastModified() < b.lastModified();
+}
+
+/*!
+ *  Sort was originally done in \ref onItemsAdded() and that code is now in \ref addItem(),
+ *  the reason to keep doing sort and do not let QDir does it is that when adding new items
+ *  by \ref mkdir() or \paste() it is not necessary to call refresh() to load the entire directory
+ *  to organize it items again. New items order/position are organized by \ref addItem()
+ *
+ */
+static CompareFunction availableCompareFunctions[2][2] =
+{
+    {fileCompareAscending, fileCompareDescending}
+   ,{dateCompareAscending, dateCompareDescending}
+};
+
+
+
+
+class DirListWorker : public IORequest
+{
+    Q_OBJECT
+public:
+    DirListWorker(const QString &pathName, QDir::Filter filter)
+        : mPathName(pathName)
+        , mFilter(filter)
+    { }
+
+    void run()
+    {
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << "Running on: " << QThread::currentThreadId();
+#endif
+
+        QDir tmpDir = QDir(mPathName, QString(), QDir::NoSort, mFilter);
+        QDirIterator it(tmpDir);
+        QVector<QFileInfo> directoryContents;
+
+        while (it.hasNext()) {
+            it.next();
+
+            directoryContents.append(it.fileInfo());
+            if (directoryContents.count() >= 50) {
+                emit itemsAdded(directoryContents);
+
+                // clear() would force a deallocation, micro-optimization
+                directoryContents.erase(directoryContents.begin(), directoryContents.end());
+            }
+        }
+
+        // last batch
+        emit itemsAdded(directoryContents);
+        emit workerFinished();
+    }
+
+signals:
+    void itemsAdded(const QVector<QFileInfo> &files);
+    void workerFinished();
+
+private:
+    QString       mPathName;
+    QDir::Filter  mFilter;
+};
+
+DirModel::DirModel(QObject *parent)
+    : QAbstractListModel(parent)
+    , mShowDirectories(true)
+    , mAwaitingResults(false)
+    , mShowHiddenFiles(false)
+    , mSortBy(SortByName)
+    , mSortOrder(SortAscending)
+    , mCompareFunction(0)
+    , m_fsAction(new FileSystemAction(this) )
+{
+    mNameFilters = QStringList() << "*";
+
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
+    // There's no setRoleNames in Qt5.
+    setRoleNames(buildRoleNames());
+#else
+    // In Qt5, the roleNames() is virtual and will work just fine.
+#endif
+
+    connect(m_fsAction, SIGNAL(progress(int,int,int)),
+            this,     SIGNAL(progress(int,int,int)));
+
+    connect(m_fsAction, SIGNAL(added(QFileInfo)),
+            this,     SLOT(onItemAdded(QFileInfo)));
+
+    connect(m_fsAction, SIGNAL(added(QString)),
+            this,     SLOT(onItemAdded(QString)));
+
+    connect(m_fsAction, SIGNAL(removed(QFileInfo)),
+            this,     SLOT(onItemRemoved(QFileInfo)));
+
+    connect(m_fsAction, SIGNAL(removed(QString)),
+            this,     SLOT(onItemRemoved(QString)));
+
+    connect(m_fsAction, SIGNAL(error(QString,QString)),
+            this,     SIGNAL(error(QString,QString)));
+
+    connect(this,     SIGNAL(pathChanged(QString)),
+            m_fsAction, SLOT(pathChanged(QString)));
+
+    connect(m_fsAction, SIGNAL(clipboardChanged()),
+            this,       SIGNAL(clipboardChanged()));
+
+    setCompareAndReorder();
+}
+
+DirModel::~DirModel()
+{
+}
+
+#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
+// roleNames has changed between Qt4 and Qt5. In Qt5 it is a virtual
+ // function and setRoleNames should not be used.
+QHash<int, QByteArray> DirModel::roleNames() const
+{
+    static QHash<int, QByteArray> roles;
+    if (roles.isEmpty()) {
+        roles = buildRoleNames();
+    }
+
+    return roles;
+}
+#endif
+
+QHash<int, QByteArray> DirModel::buildRoleNames() const
+{
+    QHash<int, QByteArray> roles;
+        roles.insert(FileNameRole, QByteArray("fileName"));
+        roles.insert(CreationDateRole, QByteArray("creationDate"));
+        roles.insert(ModifiedDateRole, QByteArray("modifiedDate"));
+        roles.insert(FileSizeRole, QByteArray("fileSize"));
+        roles.insert(IconSourceRole, QByteArray("iconSource"));
+        roles.insert(FilePathRole, QByteArray("filePath"));
+        roles.insert(IsDirRole, QByteArray("isDir"));
+        roles.insert(IsFileRole, QByteArray("isFile"));
+        roles.insert(IsReadableRole, QByteArray("isReadable"));
+        roles.insert(IsWritableRole, QByteArray("isWritable"));
+        roles.insert(IsExecutableRole, QByteArray("isExecutable"));
+
+    // populate reverse mapping
+    if (roleMapping.isEmpty()) {
+        QHash<int, QByteArray>::ConstIterator it = roles.constBegin();
+        for (;it != roles.constEnd(); ++it)
+            roleMapping.insert(it.value(), it.key());
+
+        // make sure we cover all roles
+        //    Q_ASSERT(roles.count() == IsFileRole - FileNameRole);
+    }
+
+    return roles;
+}
+
+QVariant DirModel::data(int row, const QByteArray &stringRole) const
+{
+    QHash<QByteArray, int>::ConstIterator it = roleMapping.constFind(stringRole);
+
+    if (it == roleMapping.constEnd())
+        return QVariant();
+
+    return data(index(row, 0), *it);
+}
+
+QVariant DirModel::data(const QModelIndex &index, int role) const
+{
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL)
+    if (!index.isValid() || (role != Qt::DisplayRole && role != Qt::DecorationRole) )
+    {
+        return QVariant();
+    }
+    if (role == Qt::DecorationRole)
+    {
+        if (index.column() == 0)
+        {
+            QMimeDatabase database;
+            QIcon icon;
+            QMimeType mime = database.mimeTypeForFile(mDirectoryContents.at(index.row()));
+            if (mime.isValid()) {               
+                icon = QIcon::fromTheme(mime.iconName());                
+            }
+            if (icon.isNull()) {
+                icon = QFileIconProvider().icon(mDirectoryContents.at(index.row()));             
+            }           
+            return icon;
+        }
+        return QVariant();
+    }
+    role = FileNameRole + index.column();
+#else
+    if (role < FileNameRole || role > IsExecutableRole) {
+        qWarning() << Q_FUNC_INFO << "Got an out of range role: " << role;
+        return QVariant();
+    }
+
+    if (index.row() < 0 || index.row() >= mDirectoryContents.count()) {
+        qWarning() << "Attempted to access out of range row: " << index.row();
+        return QVariant();
+    }
+
+    if (index.column() != 0)
+        return QVariant();
+#endif
+
+    const QFileInfo &fi = mDirectoryContents.at(index.row());
+
+    switch (role) {
+        case FileNameRole:
+            return fi.fileName();
+        case CreationDateRole:
+            return fi.created();
+        case ModifiedDateRole:
+            return fi.lastModified();
+        case FileSizeRole: {
+             if (fi.isDir())
+             {
+                return dirItems(fi);
+             }
+             return fileSize(fi.size());
+        }
+        case IconSourceRole: {
+            const QString &fileName = fi.fileName();
+
+            if (fi.isDir())
+                return QLatin1String("image://theme/icon-m-common-directory");
+
+            if (fileName.endsWith(QLatin1String(".jpg"), Qt::CaseInsensitive) ||
+                fileName.endsWith(QLatin1String(".png"), Qt::CaseInsensitive)) {
+                return QLatin1String("image://nemoThumbnail/") + fi.filePath();
+            }
+
+            return "image://theme/icon-m-content-document";
+        }
+        case FilePathRole:
+            return fi.filePath();
+        case IsDirRole:
+            return fi.isDir();
+        case IsFileRole:
+            return !fi.isDir();
+        case IsReadableRole:
+            return fi.isReadable();
+        case IsWritableRole:
+            return fi.isWritable();
+        case IsExecutableRole:
+            return fi.isExecutable();
+        default:
+#if !defined(REGRESSION_TEST_FOLDERLISTMODEL)
+            // this should not happen, ever
+            Q_ASSERT(false);
+            qWarning() << Q_FUNC_INFO << "Got an unknown role: " << role;
+#endif
+            return QVariant();
+    }
+}
+
+void DirModel::setPath(const QString &pathName)
+{
+    if (pathName.isEmpty())
+        return;
+
+    if (mAwaitingResults) {
+        // TODO: handle the case where pathName != our current path, cancel old
+        // request, start a new one
+        qDebug() << Q_FUNC_INFO << "Ignoring path change request, request already running";
+        return;
+    }
+
+    mAwaitingResults = true;
+    emit awaitingResultsChanged();
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "Changing to " << pathName << " on " << QThread::currentThreadId();
+#endif
+    beginResetModel();
+    mDirectoryContents.clear();
+    endResetModel();
+
+    QDir::Filter dirFilter = currentDirFilter();
+    // TODO: we need to set a spinner active before we start getting results from DirListWorker
+    DirListWorker *dlw = new DirListWorker(pathName, dirFilter);
+    connect(dlw, SIGNAL(itemsAdded(QVector<QFileInfo>)), SLOT(onItemsAdded(QVector<QFileInfo>)));
+    connect(dlw, SIGNAL(workerFinished()), SLOT(onResultsFetched()));
+    ioWorkerThread()->addRequest(dlw);
+
+    mCurrentDir = pathName;
+    emit pathChanged(pathName);
+}
+
+
+void DirModel::onResultsFetched() {
+    if (mAwaitingResults) {
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << "No longer awaiting results";
+#endif
+        mAwaitingResults = false;
+        emit awaitingResultsChanged();
+    }
+}
+
+void DirModel::onItemsAdded(const QVector<QFileInfo> &newFiles)
+{
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "Got new files: " << newFiles.count();
+#endif
+
+    foreach (const QFileInfo &fi, newFiles) {
+
+        bool doAdd = true;
+        foreach (const QString &nameFilter, mNameFilters) {
+            // TODO: using QRegExp for wildcard matching is slow
+            QRegExp re(nameFilter, Qt::CaseInsensitive, QRegExp::Wildcard);
+            if (!re.exactMatch(fi.fileName())) {
+                doAdd = false;
+                break;
+            }
+        }
+
+        if (!doAdd)
+            continue;
+
+        addItem(fi);
+    }
+}
+
+void DirModel::rm(const QStringList &paths)
+{
+   m_fsAction->remove(paths);
+}
+
+bool DirModel::rename(int row, const QString &newName)
+{
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "Renaming " << row << " to " << newName;
+#endif
+
+    if (!IS_VALID_ROW(row)) {
+        WARN_ROW_OUT_OF_RANGE(row);
+        return false;
+    }
+
+    const QFileInfo &fi = mDirectoryContents.at(row);
+    QString newFullFilename(fi.absolutePath() + QDir::separator() + newName);
+
+    //QFile::rename() works for File and Dir
+    QFile f(fi.absoluteFilePath());
+    bool retval = f.rename(newFullFilename);
+    if (!retval)
+    {
+        qDebug() << Q_FUNC_INFO << "Rename returned error code: " << f.error() << f.errorString();
+        emit(QObject::tr("Rename error"), f.errorString());
+    }
+    else
+    {
+        mDirectoryContents[row] = QFileInfo(newFullFilename);
+        QModelIndex idx = createIndex(row,0);
+        emit dataChanged(idx, idx);
+    }
+    return retval;
+}
+
+void DirModel::mkdir(const QString &newDir)
+{
+    QDir dir(mCurrentDir);
+    bool retval = dir.mkdir(newDir);
+    if (!retval) {
+        const char *errorStr = strerror(errno);
+        qDebug() << Q_FUNC_INFO << "Error creating new directory: " << errno << " (" << errorStr << ")";
+        emit error(QObject::tr("Error creating new folder"), errorStr);
+    } else {
+        onItemAdded(dir.filePath(newDir));
+    }
+}
+
+bool DirModel::showDirectories() const
+{
+    return mShowDirectories;
+}
+
+void DirModel::setShowDirectories(bool showDirectories)
+{
+    mShowDirectories = showDirectories;
+    refresh();
+    emit showDirectoriesChanged();
+}
+
+QStringList DirModel::nameFilters() const
+{
+    return mNameFilters;
+}
+
+void DirModel::setNameFilters(const QStringList &nameFilters)
+{
+    mNameFilters = nameFilters;
+    refresh();
+    emit nameFiltersChanged();
+}
+
+bool DirModel::awaitingResults() const
+{
+    return mAwaitingResults;
+}
+
+
+QString DirModel::parentPath() const
+{
+    QDir dir(mCurrentDir);
+    if (dir.isRoot()) {
+        qDebug() << Q_FUNC_INFO << "already at root";
+        return mCurrentDir;
+    }
+
+    bool success = dir.cdUp();
+    if (!success) {
+        qWarning() << Q_FUNC_INFO << "Failed to to go to parent of " << mCurrentDir;
+        return mCurrentDir;
+    }
+    qDebug() << Q_FUNC_INFO << "returning" << dir.absolutePath();
+    return dir.absolutePath();
+}
+
+QString DirModel::homePath() const
+{
+    return QDir::homePath();
+}
+
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL)
+ QVariant  DirModel::headerData(int section, Qt::Orientation orientation, int role) const
+ {
+   if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
+   {
+       QVariant ret;
+       QHash<int, QByteArray> roles = this->roleNames();
+       section += FileNameRole;
+       if (roles.contains(section))
+       {
+           QString header=  QString(roles.value(section));
+           ret = header;
+       }
+       return ret;
+   }
+   return QAbstractItemModel::headerData(section, orientation, role);
+ }
+#endif
+
+
+void DirModel::goHome()
+{
+    setPath(QDir::homePath());
+}
+
+
+bool DirModel::cdUp()
+{
+    int ret = false;
+    if (!mCurrentDir.isEmpty()) // we are in any dir
+    {
+        QDir current(mCurrentDir);
+        if (current.cdUp())
+        {
+            setPath(current.absolutePath());
+            ret = true;
+        }
+    }
+    return ret;
+}
+
+
+void DirModel::removeIndex(int row)
+{
+    if (IS_VALID_ROW(row))
+    {
+        const QFileInfo &fi = mDirectoryContents.at(row);
+        QStringList list(fi.absoluteFilePath());
+        this->rm(list);
+    }
+    else
+    {
+        WARN_ROW_OUT_OF_RANGE(row);
+    }
+}
+
+void DirModel::removePaths(const QStringList& items)
+{
+     this->rm(items);
+}
+
+void DirModel::copyIndex(int row)
+{
+    if (IS_VALID_ROW(row))
+    {
+        const QFileInfo &fi = mDirectoryContents.at(row);
+        QStringList list(fi.absoluteFilePath());
+        this->copyPaths(list);
+    }
+    else
+    {
+        WARN_ROW_OUT_OF_RANGE(row);
+    }
+}
+
+void DirModel::copyPaths(const QStringList &items)
+{
+   m_fsAction->copy(items);
+}
+
+
+void DirModel::cutIndex(int row)
+{
+    if (IS_VALID_ROW(row))
+    {
+        const QFileInfo &fi = mDirectoryContents.at(row);
+        QStringList list(fi.absoluteFilePath());
+        m_fsAction->cut(list);
+    }
+    else
+    {
+        WARN_ROW_OUT_OF_RANGE(row);
+    }
+}
+
+
+void DirModel::cutPaths(const QStringList &items)
+{
+     m_fsAction->cut(items);
+}
+
+
+void DirModel::paste()
+{
+   m_fsAction->paste();
+}
+
+
+bool  DirModel::cdIntoIndex(int row)
+{
+    bool ret = false;
+    if (IS_VALID_ROW(row))
+    {
+        ret = cdInto(mDirectoryContents.at(row));
+    }
+    else
+    {
+        WARN_ROW_OUT_OF_RANGE(row);
+    }
+    return ret;
+}
+
+
+bool  DirModel::cdIntoPath(const QString &filename)
+{
+    QFileInfo fi(filename);
+    if (fi.isRelative())
+    {
+        fi.setFile(mCurrentDir, filename);
+    }
+    return cdInto(fi);
+}
+
+
+bool  DirModel::cdInto(const QFileInfo &fi)
+{
+    bool ret = false;
+    if (fi.exists() && fi.isDir() && fi.isReadable())
+    {
+        QDir childDir(mCurrentDir);
+        if ( childDir.cd(fi.fileName()) )
+        {
+            setPath(childDir.absolutePath());
+            ret = true;
+        }
+    }
+    return ret;
+}
+
+/*!
+ * \brief DirModel::onItemRemoved()
+ * \param pathname full pathname of removed file
+ */
+void DirModel::onItemRemoved(const QString &pathname)
+{
+    QFileInfo info(pathname);
+    onItemRemoved(info);
+}
+
+
+void DirModel::onItemRemoved(const QFileInfo &fi)
+{  
+    int row = rowOfItem(fi);   
+    if (row >= 0)
+    {
+        beginRemoveRows(QModelIndex(), row, row);
+        mDirectoryContents.remove(row,1);
+        endRemoveRows();
+    }
+}
+
+/*!
+ * \brief DirModel::onItemAdded()
+ * \param pathname full pathname of the added file
+ */
+void DirModel::onItemAdded(const QString &pathname)
+{
+    QFileInfo info(pathname);
+    onItemAdded(info);
+}
+
+
+void DirModel::onItemAdded(const QFileInfo &fi)
+{
+    int newRow = addItem(fi);
+    emit insertedRow(newRow);
+}
+
+/*!
+ * \brief DirModel::addItem() adds an item into the model
+ *        This code was moved from onItemsAdded(const QVector<QFileInfo> &newFiles),
+ *           the reason is:  this code now is used for \ref mkdir() and for \ref paste() operations
+ *           that inserts new items
+ * \param fi
+ * \return  the index where it was inserted, it can be used in the view
+ * \sa insertedRow()
+ */
+int DirModel::addItem(const QFileInfo &fi)
+{
+    QVector<QFileInfo>::Iterator it = qLowerBound(mDirectoryContents.begin(),
+                                                  mDirectoryContents.end(),
+                                                  fi,
+                                                  mCompareFunction);
+    int idx =  mDirectoryContents.count();
+
+    if (it == mDirectoryContents.end()) {
+        beginInsertRows(QModelIndex(), mDirectoryContents.count(), mDirectoryContents.count());
+        mDirectoryContents.append(fi);
+        endInsertRows();
+    } else {
+        idx = it - mDirectoryContents.begin();
+        beginInsertRows(QModelIndex(), idx, idx);
+        mDirectoryContents.insert(it, fi);
+        endInsertRows();
+    }   
+    return idx;
+}
+
+
+
+void DirModel::cancelAction()
+{
+    m_fsAction->cancel();
+}
+
+
+QString DirModel::fileSize(qint64 size) const
+{
+    struct UnitSizes
+    {
+        qint64      bytes;
+        const char *name;
+    };
+
+    static UnitSizes m_unitBytes[5] =
+    {
+        { 1,           "Bytes" }
+       ,{1024,         "KB"}
+        // got it from http://wiki.answers.com/Q/How_many_bytes_are_in_a_megabyte
+       ,{1000 * 1000,  "MB"}
+       ,{1000 *  m_unitBytes[2].bytes,   "GB"}
+       ,{1000 *  m_unitBytes[3].bytes, "TB"}
+    };
+
+    QString ret;
+    int unit = sizeof(m_unitBytes)/sizeof(m_unitBytes[0]);
+    while( unit-- > 1 && size < m_unitBytes[unit].bytes );
+    if (unit > 0 )
+    {
+        ret.sprintf("%0.1f %s", (float)size/m_unitBytes[unit].bytes,
+                    m_unitBytes[unit].name);
+    }
+    else
+    {
+        ret.sprintf("%ld %s", (long int)size, m_unitBytes[0].name);
+    }
+    return ret;
+}
+
+
+
+bool DirModel::getShowHiddenFiles() const
+{
+    return mShowHiddenFiles;
+}
+
+
+void DirModel::setShowHiddenFiles(bool show)
+{
+    if (show != mShowHiddenFiles)
+    {
+        mShowHiddenFiles = show;
+        refresh();
+        emit showHiddenFilesChanged();
+    }
+}
+
+
+void DirModel::toggleShowDirectories()
+{
+    setShowDirectories(!mShowDirectories);
+}
+
+
+void DirModel::toggleShowHiddenFiles()
+{
+    setShowHiddenFiles(!mShowHiddenFiles);
+}
+
+
+DirModel::SortBy
+DirModel::getSortBy()  const
+{
+    return mSortBy;
+}
+
+
+void DirModel::setSortBy(SortBy field)
+{
+    if (field != mSortBy)
+    {
+        mSortBy = field;
+        setCompareAndReorder();
+        emit sortByChanged();
+    }
+}
+
+
+DirModel::SortOrder
+DirModel::getSortOrder() const
+{
+    return mSortOrder;
+}
+
+void DirModel::setSortOrder(SortOrder order)
+{
+    if ( order != mSortOrder )
+    {
+        mSortOrder = order;
+        setCompareAndReorder();
+        emit sortOrderChanged();
+    }
+}
+
+
+void DirModel::toggleSortOrder()
+{
+    SortOrder  order = static_cast<SortOrder> (mSortOrder ^ 1);
+    setSortOrder(order);
+}
+
+
+void DirModel::toggleSortBy()
+{
+    SortBy by = static_cast<SortBy> (mSortBy ^ 1);
+    setSortBy(by);
+}
+
+/*!
+ * \brief DirModel::setCompareAndReorder() called when  SortOrder or SortBy change
+ *
+ *  It does not reload items from disk, just reorganize items from \a mDirectoryContents array
+ */
+void DirModel::setCompareAndReorder()
+{
+    mCompareFunction = availableCompareFunctions[mSortBy][mSortOrder];
+    if (mDirectoryContents.count() > 0 && !mAwaitingResults )
+    {
+        QVector<QFileInfo> tmpDirectoryContents = mDirectoryContents;
+        beginResetModel();
+        mDirectoryContents.clear();
+        endResetModel();
+        for(int counter=0; counter < tmpDirectoryContents.count(); counter++)
+        {
+            addItem(tmpDirectoryContents.at(counter));
+        }
+    }
+}
+
+
+int DirModel::getClipboardUrlsCounter() const
+{
+    return m_fsAction->clipboardLocalUrlsConunter();
+}
+
+
+int DirModel::rowOfItem(const QFileInfo& fi)
+{
+    QVector<QFileInfo>::Iterator it = qBinaryFind(mDirectoryContents.begin(),
+                                                  mDirectoryContents.end(),
+                                                  fi,
+                                                  fileCompareExists);
+    int row;
+    if (it == mDirectoryContents.end())
+    {       
+        row = -1;
+    }
+    else
+    {
+        row = it - mDirectoryContents.begin();
+    }
+    return row;
+}
+
+
+QDir::Filter DirModel::currentDirFilter() const
+{
+    int filter = QDir::AllEntries | QDir::NoDotAndDotDot ;
+    if (!mShowDirectories)
+    {
+        filter &= ~QDir::AllDirs;
+        filter &= ~QDir::Dirs;
+    }
+    if (mShowHiddenFiles)
+    {
+        filter |= QDir::Hidden;
+    }
+    QDir::Filter dirFilter = static_cast<QDir::Filter>(filter);
+    return dirFilter;
+}
+
+QString DirModel::dirItems(const QFileInfo& fi) const
+{
+    int counter = 0;
+    QDir d(fi.absoluteFilePath(), QString(), QDir::NoSort, currentDirFilter());
+    counter = d.count();
+    if (counter < 0)
+    {
+        counter = 0;
+    }
+    QString ret (QString::number(counter) + QLatin1Char(' '));
+    ret += QObject::tr("items");
+    return ret;
+}
+
+
+bool DirModel::openIndex(int row)
+{
+    bool ret = false;
+    if (IS_VALID_ROW(row))
+    {
+        ret = openItem(mDirectoryContents.at(row));
+    }
+    else
+    {
+        WARN_ROW_OUT_OF_RANGE(row);
+    }
+    return ret;
+}
+
+bool DirModel::openPath(const QString &filename)
+{
+    QFileInfo fi(filename);
+    if (fi.isRelative())
+    {
+        fi.setFile(mCurrentDir, filename);
+    }
+    return openItem(fi);
+}
+
+bool DirModel::openItem(const QFileInfo &fi)
+{
+    bool ret = false;
+    if (fi.exists())
+    {
+        if (fi.isDir())
+        {
+            ret = cdInto(fi);
+        }
+        else
+        {
+            ret = QDesktopServices::openUrl(QUrl::fromLocalFile(fi.absoluteFilePath()));
+        }
+    }
+    return ret;
+}
+
+// for dirlistworker
+#include "dirmodel.moc"
 
=== added file 'folderlistmodel/dirmodel.h'
--- folderlistmodel/dirmodel.h	1970-01-01 00:00:00 +0000
+++ folderlistmodel/dirmodel.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,328 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#ifndef DIRMODEL_H
+#define DIRMODEL_H
+
+#include <QAbstractListModel>
+#include <QFileInfo>
+#include <QVector>
+#include <QStringList>
+#include <QDir>
+
+#include "iorequest.h"
+
+class FileSystemAction;
+typedef bool  (*CompareFunction)(const QFileInfo &a, const QFileInfo &b);
+
+class DirModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+    enum Roles {
+        FileNameRole = Qt::UserRole,
+        CreationDateRole,
+        ModifiedDateRole,
+        FileSizeRole,
+        IconSourceRole,
+        FilePathRole,
+        IsDirRole,
+        IsFileRole,
+        IsReadableRole,
+        IsWritableRole,
+        IsExecutableRole
+    };
+
+public:
+    explicit DirModel(QObject *parent = 0);
+    ~DirModel();
+
+    int rowCount(const QModelIndex &index = QModelIndex()) const
+    {
+        if (index.parent() != QModelIndex())
+            return 0;
+        return mDirectoryContents.count();
+    }
+
+    // TODO: this won't be safe if the model can change under the holder of the row
+    Q_INVOKABLE QVariant data(int row, const QByteArray &stringRole) const;
+
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
+
+    Q_INVOKABLE void refresh()
+    {
+        // just some syntactical sugar really
+        setPath(path());
+    }
+
+    Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged)
+    inline QString path() const { return mCurrentDir; }
+    void setPath(const QString &pathName);
+
+    Q_PROPERTY(bool awaitingResults READ awaitingResults NOTIFY awaitingResultsChanged)
+    bool awaitingResults() const;
+
+    Q_INVOKABLE void rm(const QStringList &paths);
+
+    Q_INVOKABLE bool rename(int row, const QString &newName);
+
+    Q_INVOKABLE void mkdir(const QString &newdir);
+
+    Q_PROPERTY(bool showDirectories READ showDirectories WRITE setShowDirectories NOTIFY showDirectoriesChanged)
+    bool showDirectories() const;
+
+    Q_PROPERTY(QStringList nameFilters READ nameFilters WRITE setNameFilters NOTIFY nameFiltersChanged)
+    QStringList nameFilters() const;
+    void setNameFilters(const QStringList &nameFilters);
+
+public slots:
+    void onItemsAdded(const QVector<QFileInfo> &newFiles);
+    void onResultsFetched();
+
+signals:
+    void awaitingResultsChanged();
+    void nameFiltersChanged();
+    void showDirectoriesChanged();
+    void pathChanged(const QString& newPath);
+    void error(const QString &errorTitle, const QString &errorMessage);
+
+private:
+    QHash<int, QByteArray> buildRoleNames() const;
+#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
+    // In Qt5, the roleNames() is virtual and will work just fine. On qt4 setRoleNames must be used with buildRoleNames.
+    QHash<int, QByteArray> roleNames() const;
+#endif
+
+    QStringList mNameFilters;
+    bool mShowDirectories;
+    bool mAwaitingResults;
+    QString mCurrentDir;
+    QVector<QFileInfo> mDirectoryContents;
+
+public:
+    //[0] new stuff Ubuntu File Manager
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL)
+    //make this work with tables
+    virtual int columnCount(const QModelIndex &) const
+    {
+        return IsExecutableRole - FileNameRole + 1;
+    }
+    virtual QVariant  headerData(int section, Qt::Orientation orientation, int role) const;
+#endif
+
+    Q_PROPERTY(QString parentPath READ parentPath NOTIFY pathChanged)
+    QString parentPath() const;
+
+    Q_PROPERTY(bool showHiddenFiles READ getShowHiddenFiles WRITE setShowHiddenFiles NOTIFY showHiddenFilesChanged)
+    bool getShowHiddenFiles() const;
+
+    Q_ENUMS(SortBy)
+    enum SortBy
+    {
+        SortByName,
+        SortByDate
+    };
+    Q_PROPERTY(SortBy sortBy READ getSortBy WRITE setSortBy NOTIFY sortByChanged)
+    SortBy getSortBy() const;
+
+    Q_ENUMS(SortOrder)
+    enum SortOrder
+    {
+        SortAscending   = Qt::AscendingOrder,
+        SortDescending = Qt::DescendingOrder
+    };
+    Q_PROPERTY(SortOrder sortOrder READ getSortOrder WRITE setSortOrder NOTIFY sortOrderChanged)
+    SortOrder getSortOrder() const;
+
+    Q_PROPERTY(int clipboardUrlsCounter READ getClipboardUrlsCounter NOTIFY clipboardChanged)
+    int getClipboardUrlsCounter() const;
+
+    Q_INVOKABLE QString homePath() const;
+
+    /*!
+     *    \brief Tries to make the directory pointed by row as the current to be browsed
+     *    \return true if row points to a directory and the directory is readble, false otherwise
+     */
+    Q_INVOKABLE  bool cdIntoIndex(int row);
+
+    Q_INVOKABLE  bool cdIntoPath(const QString& filename);
+    /*!
+     * \brief copyIndex() puts the item pointed by \a row (dir or file) into the clipboard
+     * \param row points to the item file or directory
+     */
+    Q_INVOKABLE void  copyIndex(int row);
+
+    /*!
+     *  \brief copyPaths(const QStringList& urls) several items (dirs or files) into the clipboard
+     *  \param items  fullpathnames or names only
+     */
+    Q_INVOKABLE void  copyPaths(const QStringList& items);
+
+    /*!
+     * \brief cutIndex() puts the item into the clipboard as \ref copy(),
+     *        mark the item to be removed after \ref paste()
+     * \param row points to the item file or directory
+     */
+    Q_INVOKABLE void  cutIndex(int row);
+
+    /*!
+     *  \brief cut() puts several items (dirs or files) into the clipboard as \ref copy(),
+     *         mark the item to be removed after \ref paste()
+     *   \param items  fullpathnames or names only
+     */
+    Q_INVOKABLE void  cutPaths(const QStringList& items);
+
+    /*!
+     * \brief removeIndex();  remove a item file or directory
+     *
+     * I gets the item indicated by \row and calls \ref rm()
+     *
+     * \param row points to the item to b e removed
+     * \return true if it was possible to remove the item
+     */
+    Q_INVOKABLE void removeIndex(int row);
+
+    /*!
+     *  Just calls \ref rm()
+     */
+    Q_INVOKABLE void removePaths(const QStringList& items);
+
+    /*!
+     *  Tries to open a file using a suitable application, if the index points to a directory
+     *  it goes into it using \ref cdIntoIndex() or \ref cdIntoPath()
+     *
+     *  \note Qt uses Qt QDesktopServices::openUrl()
+     */
+
+    Q_INVOKABLE bool  openIndex(int row);
+    /*!
+     *  Same as \ref openIndex() but using a file name instead of index
+     *
+     *  \sa \ref cdIntoPath()
+     */
+    Q_INVOKABLE bool  openPath(const QString& filename);
+
+public slots:
+    /*!
+     * \brief goHome() goes to user home dir
+     *  Go to user home dir, we may have a tab for places or something like that
+     */
+    void  goHome();
+
+    /*!
+     * \brief cdUp() sets the parent directory as current directory
+     *
+     *  It can work as a back function if there is no user input path
+     * \return true if it was possible to change to parent dir, otherwise false
+     */
+    bool  cdUp();
+
+    /*!
+     * \brief paste() copy item(s) from \ref copy() and \ref paste() into the current directory
+     *
+     *  If the operation was \ref cut(), then remove the original item
+     */
+    void paste();
+
+    /*!
+     * \brief cancelAction() any copy/cut/remove can be cancelled
+     */
+    void cancelAction();    
+
+    void setShowDirectories(bool showDirectories);
+    void setShowHiddenFiles(bool show);
+    void setSortBy(SortBy field);
+    void setSortOrder(SortOrder order);
+
+    void toggleShowDirectories();
+    void toggleShowHiddenFiles();
+    void toggleSortOrder();
+    void toggleSortBy();
+
+signals:
+    /*!
+     * \brief insertedItem()
+     *
+     *  It happens when a new file is inserted in an existent view,
+     *  for example from  \ref mkdir() or \ref paste()
+     *
+     *  It can be used to make the new row visible to the user doing a scroll to
+     */
+    void  insertedRow(int row);
+    /*!
+     * \brief progress()
+     *  Sends status about recursive and multi-items remove/move/copy
+     *
+     * \param curItem     current item being handled
+     * \param totalItems  total of items including recursive directories content
+     * \param percent     a percent done
+     */
+    void     progress(int curItem, int totalItems, int percent);
+
+    void     showHiddenFilesChanged();
+    void     sortByChanged();
+    void     sortOrderChanged();
+
+    void     clipboardChanged();
+
+private slots:
+    void onItemRemoved(const QString&);
+    void onItemRemoved(const QFileInfo&);
+    void onItemAdded(const QString&);
+    void onItemAdded(const QFileInfo&);
+
+private:
+    int           addItem(const QFileInfo& fi);
+    void          setCompareAndReorder();
+    int           rowOfItem(const QFileInfo& fi);
+    QDir::Filter  currentDirFilter()  const;
+    QString       dirItems(const QFileInfo& fi) const;
+    bool          cdInto(const QFileInfo& fi);
+    bool          openItem(const QFileInfo& fi);
+
+private:
+    bool               mShowHiddenFiles;
+    SortBy             mSortBy;
+    SortOrder          mSortOrder;
+    CompareFunction    mCompareFunction;
+
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL) //used in Unit/Regression tests
+public:
+#else
+private:
+#endif
+    FileSystemAction  *  m_fsAction;  //!< it does file system recursive remove/copy/move
+    QString fileSize(qint64 size)  const;
+//[0]
+};
+
+
+#endif // DIRMODEL_H
 
=== added file 'folderlistmodel/filesystemaction.cpp'
--- folderlistmodel/filesystemaction.cpp	1970-01-01 00:00:00 +0000
+++ folderlistmodel/filesystemaction.cpp	2013-06-01 17:20:36 +0000
@@ -0,0 +1,1389 @@
+/**************************************************************************
+ *
+ * Copyright 2013 Canonical Ltd.
+ * Copyright 2013 Carlos J Mazieri <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ *
+ * File: filesystemaction.cpp
+ * Date: 3/13/2013
+ */
+
+#include "filesystemaction.h"
+#include <sys/statvfs.h>
+#include <errno.h>
+
+#include <QDirIterator>
+#include <QDebug>
+#include <QTimer>
+#include <QMimeData>
+#include <QClipboard>
+#include <QApplication>
+#include <QUrl>
+#include <QFileInfo>
+#include <QDir>
+#include <QThread>
+#include <QTemporaryFile>
+
+#define  STEP_FILES               5  // number of the files to work on a step, when this number is reached a signal is emitted
+
+#define SHOULD_EMIT_PROGRESS_SIGNAL(action)       (1)
+
+#define   COMMON_SIZE_ITEM       120
+
+RemoveNotifier   FileSystemAction::m_removeNotifier;
+
+static  QLatin1String GNOME_COPIED_MIME_TYPE  ("x-special/gnome-copied-files");
+static  QLatin1String KDE_CUT_MIME_TYPE       ("application/x-kde-cutselection");
+
+
+
+class DirModelMimeData : public QMimeData
+{
+public:
+    enum ClipBoardDataOwner
+    {
+        Nobody,    // might have failed
+        Application,
+        MySelf
+    };
+
+    explicit DirModelMimeData();
+    ~DirModelMimeData();
+    virtual QStringList     formats() const    { return m_formats; }
+    virtual bool            hasFormat ( const QString & mimeType ) const;
+public:
+    ClipBoardDataOwner      setIntoClipboard(const QStringList& files,
+                                             const QString &path,
+                                             ClipboardOperation operation);
+    const QMimeData *clipboardMimeData();
+    QStringList             localUrls(ClipboardOperation& operation);
+private:
+    static QList<QUrl>      gnomeUrls(const QMimeData *mime, ClipboardOperation& operation);
+    ClipboardOperation      clipBoardOperation();
+    bool                    fillClipboard(const QStringList& files, const QString &path, ClipboardOperation operation);
+private:
+    QStringList              m_formats;
+    const QMimeData *        m_appMime;
+    QByteArray               gnomeData;
+    QList<QUrl>              urls;
+    static DirModelMimeData* m_globalMimeData; //!< some mobile devices do not use X, they may not have clipboard
+    static   int             instances;
+};
+
+
+int DirModelMimeData::instances = 0;
+DirModelMimeData*  DirModelMimeData::m_globalMimeData = 0;
+
+void FileSystemAction::CopyFile::clear()
+{
+    bytesWritten = 0;
+    if (source)   delete source;
+    if (target)   delete target;
+    source = 0;
+    target = 0;
+}
+
+bool DirModelMimeData::hasFormat ( const QString & mimeType ) const
+{
+   bool ret = false;
+   if (  mimeType == KDE_CUT_MIME_TYPE  )
+   {
+      ret = true;
+   }
+   else
+   {
+      ret = m_formats.contains(mimeType);
+   }
+   return ret;
+}
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::DirModelMimeData
+ */
+DirModelMimeData::DirModelMimeData() :
+    QMimeData()
+  , m_appMime(0)
+{
+    m_formats.append("text/uri-list");
+    m_formats.append(GNOME_COPIED_MIME_TYPE);
+    m_formats.append("text/plain");
+    m_formats.append("COMPOUND_TEXT");
+    m_formats.append("TARGETS");
+    m_formats.append("MULTIPLE");
+    m_formats.append("TIMESTAMP");
+    m_formats.append("SAVE_TARGETS");
+
+    ++instances;
+#if DEBUG_MESSAGES
+     qDebug() << Q_FUNC_INFO << this << "instances" << instances;
+#endif
+}
+
+
+
+
+DirModelMimeData::~DirModelMimeData()
+{
+    --instances;
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << this  << "instances" << instances
+             << "m_globalMimeData" << m_globalMimeData;
+#endif
+    if (instances == 1 && m_globalMimeData)
+    {
+        DirModelMimeData * tmp = m_globalMimeData;
+        m_globalMimeData = 0;
+        delete tmp;
+    }
+}
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::gnomeUrls
+ * \param mime
+ * \param operation
+ * \return
+ */
+QList<QUrl>
+DirModelMimeData::gnomeUrls(const QMimeData * mime,
+                            ClipboardOperation& operation)
+{
+    QList<QUrl>  urls;
+    if (mime->hasFormat(GNOME_COPIED_MIME_TYPE))
+    {
+       QByteArray  bytes = mime->data(GNOME_COPIED_MIME_TYPE);
+       QList<QString>  d = QString(bytes).split(QLatin1String("\r\n"),
+                                                QString::SkipEmptyParts);
+       for (int counter= 0; counter < d.count(); counter++)
+       {
+           if (counter==0)
+           {
+               QStringList couple = d.at(0).split(QLatin1Char('\n'));
+               urls.append(couple[1]);
+               if (couple[0] == QLatin1String("cut"))  {
+                   operation = ClipboardCut;
+               }
+               else  {
+                   operation = ClipboardCopy;
+               }
+           }
+           else {
+               urls.append(d.at(counter));
+           }
+       }
+    }
+    return urls;
+}
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::clipBoardOperation()
+ * \param mime
+ * \return
+ */
+ClipboardOperation DirModelMimeData::clipBoardOperation()
+{
+    ClipboardOperation op = ClipboardCopy;
+    m_appMime = clipboardMimeData();
+    if (m_appMime)
+    {
+       //first check for GNOME clipboard format, op comes with Copy/Cut
+        if (gnomeUrls(m_appMime, op).count() == 0)
+        { // there is no gnome format, tries KDE format
+            QStringList formats = m_appMime->formats();
+            int f = formats.count();
+            while(f--)
+            {
+                const QString &mi = formats.at(f);
+                if(mi.startsWith(QLatin1String("application/x-kde")) )
+                {
+                    if (mi.contains(QLatin1String("cut")))
+                    {
+                        op = ClipboardCut;
+                        break;
+                    }
+                }
+            }
+        }
+    }    
+    return op;
+}
+
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::setIntoClipboard
+ *
+ *  Try to put data in the global cliboard
+ *
+ *  \note:
+ *       On mobile devices clipboard might not work, in this case a local Clipboard is simulated
+ *
+ * \param files
+ * \param path
+ * \param isCut
+ * \return who is owner of clipboard data
+ */
+DirModelMimeData::ClipBoardDataOwner
+DirModelMimeData::setIntoClipboard(const QStringList &files, const QString& path, ClipboardOperation operation)
+{
+  DirModelMimeData::ClipBoardDataOwner  ret = Nobody;
+  QClipboard *clipboard = QApplication::clipboard();
+  if (clipboard)
+  {      
+        ret = Application;
+        DirModelMimeData *mime = m_globalMimeData ? m_globalMimeData
+                                                  : new DirModelMimeData();
+        if (mime->fillClipboard(files, path, operation))
+        {
+           clipboard->setMimeData(mime);
+           const QMimeData *data = clipboard->mimeData();
+           //it looks like some mobile devices does not have X
+           //in this case we simulate our own clipboard
+           if (!data && !m_globalMimeData)
+           {
+               m_globalMimeData = mime;
+           }        
+#if DEBUG_MESSAGES
+           qDebug() << Q_FUNC_INFO << "mime" << mime << "clipboard->mimeData()" << data
+                    << "m_ownClipboardMimeData" << m_globalMimeData;
+#endif
+        }
+        else
+        if (m_globalMimeData != mime)
+        {
+            delete mime;
+        }
+        //check if it is necessary to send notification about Clipboard changed
+        if (m_globalMimeData)
+        {
+           ret = MySelf;
+        }
+  }
+  return ret;
+}
+
+
+bool DirModelMimeData::fillClipboard(const QStringList& files, const QString &path, ClipboardOperation operation)
+{
+    bool ret = false;
+    int index = m_formats.indexOf(KDE_CUT_MIME_TYPE);
+    if (index != -1 && operation != ClipboardCut)
+    {
+        m_formats.removeAt(index);
+    }
+    else
+    if (operation == ClipboardCut)
+    {
+        m_formats.append(KDE_CUT_MIME_TYPE);
+    }
+
+    urls.clear();
+    QFileInfo fi;
+    gnomeData.clear();
+    gnomeData += operation == ClipboardCut ?
+                                    QLatin1String("cut\n") :
+                                    QLatin1String("copy\n");
+    for(int counter = 0; counter < files.count(); counter++)
+    {
+        const QString& item = files.at(counter);
+        fi.setFile(item);
+        if (!fi.isAbsolute())
+        {
+            fi.setFile(path + QDir::separator() + item);
+        }
+        if (fi.exists())
+        {
+            QUrl item = QUrl::fromLocalFile(fi.absoluteFilePath());
+            urls.append(item);
+            gnomeData += item.toEncoded() + QLatin1String("\r\n");
+        }
+        else
+        {
+         // emit error( QObject::tr("Item does not exist"), item);
+           urls.clear();
+           break;
+        }
+    }
+    if (urls.count() > 0)
+    {
+        setData(GNOME_COPIED_MIME_TYPE, gnomeData);
+        setUrls(urls);
+        ret = true;
+    }
+    return ret;
+}
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::clipboardMimeData
+ * \return
+ */
+const QMimeData *DirModelMimeData::clipboardMimeData()
+{
+    const QMimeData *ret = 0;
+    QClipboard *clipboard = QApplication::clipboard();
+    if (m_globalMimeData)
+    {
+        ret = m_globalMimeData;
+    }
+    else
+    if (clipboard)
+    {
+        ret = clipboard->mimeData();
+    }
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "clipboard" << clipboard
+                << "m_ownClipboardMimeData" << m_globalMimeData
+                << "clipboard->mimeData()" << ret;
+#endif
+    return ret;
+}
+
+//===============================================================================================
+/*!
+ * \brief DirModelMimeData::localUrls
+ * \return
+ */
+QStringList
+DirModelMimeData::localUrls(ClipboardOperation& operation)
+{
+     m_appMime = clipboardMimeData();
+     QStringList paths;
+     //it may have external urls
+     if (m_appMime)
+     {
+         QList<QUrl> urls;
+         if (m_appMime->hasUrls())
+         {
+             urls =  m_appMime->urls();
+             operation = clipBoardOperation();
+         }
+         else
+         {
+             urls = gnomeUrls(m_appMime, operation);
+         }
+         for (int counter=0; counter < urls.count(); counter++)
+         {
+             if (urls.at(counter).toString().startsWith(QLatin1String("file://")))
+             {
+                 paths.append(urls.at(counter).toLocalFile());
+             }
+         }
+     }
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << paths;
+#endif
+     return paths;
+}
+
+/*!
+ * \brief RemoveNotifier::RemoveNotifier
+ * \param parent
+ */
+RemoveNotifier::RemoveNotifier(QObject *parent) :
+    QObject(parent)
+{
+}
+
+//===============================================================================================
+/*!
+ * \brief RemoveNotifier::notifyRemoved
+ * \param fi
+ */
+void RemoveNotifier::notifyRemoved(const QFileInfo &fi)
+{
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "emit removed(QFileInfo)" << fi.absoluteFilePath();
+#endif
+    emit removed(fi);
+}
+
+//===============================================================================================
+/*!
+ * \brief RemoveNotifier::notifyRemoved
+ * \param item
+ */
+void RemoveNotifier::notifyRemoved(const QString &item)
+{
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "emit removed(QString)" << item;
+#endif
+    emit removed(item);
+}
+
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::FileSystemAction
+ * \param parent
+ */
+FileSystemAction::FileSystemAction(QObject *parent) :
+    QObject(parent)
+  , m_curAction(0)
+  , m_cancelCurrentAction(false)
+  , m_busy(false)
+  , m_mimeData ( new DirModelMimeData() )
+  , m_clipboardModifiedByOther(false)
+{
+  //as m_removeNotifier is static it will send signals to all instances of
+  //the model
+    connect(&m_removeNotifier, SIGNAL(removed(QFileInfo)),
+            this,              SIGNAL(removed(QFileInfo)));
+
+    connect(&m_removeNotifier, SIGNAL(removed(QString)),
+            this,              SIGNAL(removed(QString)));
+
+    QClipboard *clipboard = QApplication::clipboard();
+
+    connect(clipboard, SIGNAL(dataChanged()), this,    SIGNAL(clipboardChanged()));
+    connect(clipboard, SIGNAL(dataChanged()), this,    SLOT(clipboardHasChanged()));
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::~FileSystemAction
+ */
+FileSystemAction::~FileSystemAction()
+{   
+   delete m_mimeData;
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::remove
+ * \param paths
+ */
+void FileSystemAction::remove(const QStringList &paths)
+{
+    createAndProcessAction(ActionRemove, paths, NoClipboard);
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::createAction
+ * \param type
+ * \param origBase
+ * \return
+ */
+FileSystemAction::Action* FileSystemAction::createAction(ActionType type, int  origBase)
+{
+    Action * action = new Action();
+    action->type         = type;
+    action->baseOrigSize = origBase;
+    action->targetPath   = m_path;
+    action->totalItems   = 0;
+    action->currItem     = 0;
+    action->currEntry    = 0;
+    action->totalBytes   = 0;
+    action->bytesWritten = 0;
+    action->done         = false;
+
+    return action;
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::addEntry
+ * \param action
+ * \param pathname
+ */
+void  FileSystemAction::addEntry(Action* action, const QString& pathname)
+{
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << pathname;
+#endif
+    QFileInfo info(pathname);
+    if (!info.isAbsolute())
+    {
+        info.setFile(action->targetPath, pathname);
+    }
+    if (!info.exists())
+    {
+        emit error(QObject::tr("File or Directory does not exist"),
+                   pathname + QObject::tr(" does not exist")
+                  );
+        return;
+    }
+    ActionEntry * entry = new ActionEntry();
+    QFileInfo   item;
+    //ActionMove will perform a rename, so no Directory expanding is necessary
+    if (action->type != ActionMove && info.isDir() && !info.isSymLink())
+    {
+        QDirIterator it(info.absoluteFilePath(),
+                        QDir::AllEntries | QDir::System |
+                              QDir::NoDotAndDotDot | QDir::Hidden,
+                        QDirIterator::Subdirectories);
+        while (it.hasNext() &&  !it.next().isEmpty())
+        {
+            item = it.fileInfo();
+            entry->reversedOrder.prepend(it.fileInfo());
+            if (item.isFile() && !item.isDir() && !item.isSymLink())
+            {
+                action->totalBytes += item.size();
+            }
+            else
+            {
+                action->totalBytes += COMMON_SIZE_ITEM;
+            }
+        }
+    }
+    //this is the item being handled
+    entry->reversedOrder.append(info);
+
+    // verify if the destination item already exists
+    if (action->type == ActionCopy || action->type == ActionMove ||
+            action->type == ActionHardMoveCopy)
+    {
+        QFileInfo destination(targetFom(info.absoluteFilePath()));
+        entry->alreadyExists = destination.exists();
+    }
+
+    action->totalItems += entry->reversedOrder.count();
+    if (info.isFile() && !info.isDir() && !info.isSymLink())
+    {
+        action->totalBytes += info.size();
+    }
+    else
+    {
+        action->totalBytes += COMMON_SIZE_ITEM;
+    }
+    action->entries.append(entry);
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::processAction
+ */
+void FileSystemAction::processAction()
+{
+    if (m_curAction)
+    {
+        //it will be ActionHardMoveRemove only when switched from ActionHardMoveCopy
+        //in this case the move is done in two steps COPY and REMOVE
+        if (m_curAction->type != ActionHardMoveCopy)
+        {
+            delete m_curAction;
+            m_curAction = 0;
+        }
+    }
+    if (!m_curAction && m_queuedActions.count())
+    {
+        m_curAction = m_queuedActions.at(0);
+        m_queuedActions.remove(0,1);
+    }
+    if (m_curAction)
+    {
+        m_busy = true;
+        m_cancelCurrentAction = false;
+        m_errorMsg.clear();
+        m_errorTitle.clear();
+        scheduleSlot(SLOT(processActionEntry()));
+        if (SHOULD_EMIT_PROGRESS_SIGNAL(m_curAction))
+        {
+            emit progress(0,m_curAction->totalItems, 0);
+        }
+    }
+    else
+    {
+         m_busy = false;
+    }
+}
+
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::processActionEntry
+ */
+void FileSystemAction::processActionEntry()
+{
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO;
+#endif
+
+    ActionEntry * curEntry = static_cast<ActionEntry*>
+            ( m_curAction->entries.at(m_curAction->currEntry) );
+
+#if defined(SIMULATE_LONG_ACTION)
+    {
+        unsigned int delay = SIMULATE_LONG_ACTION;
+        if (delay == 1)
+        {
+            delay = 100;           //each (10 * STEP_FILES) files will waits a second
+            QThread::currentThread()->wait(delay);
+        }
+    }
+#endif
+    if (!m_cancelCurrentAction)
+    {
+        switch(m_curAction->type)
+        {
+           case ActionRemove:
+           case ActionHardMoveRemove:
+                removeEntry(curEntry);
+                endActionEntry();
+                break;
+           case ActionCopy:
+           case ActionHardMoveCopy:
+                processCopyEntry();          // specially: this is a slot
+                break;
+          case ActionMove:
+                moveEntry(curEntry);
+                endActionEntry();
+                break;
+        }
+    }
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::endActionEntry
+ */
+void FileSystemAction::endActionEntry()
+{
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO;
+#endif
+    ActionEntry * curEntry = static_cast<ActionEntry*>
+            ( m_curAction->entries.at(m_curAction->currEntry) );
+
+    // first of all check for any error or a cancel issued by the user
+    if (m_cancelCurrentAction)
+    {
+        if (!m_errorTitle.isEmpty())
+        {
+            emit error(m_errorTitle, m_errorMsg);
+        }
+        //it may have other actions to do
+        scheduleSlot(SLOT(processAction()));
+        return;
+    }
+    // check if the current entry has finished
+    // if so Views need to receive the notification about that
+    if (curEntry->currItem == curEntry->reversedOrder.count())
+    {
+        const QFileInfo & mainItem = curEntry->reversedOrder.at(curEntry->currItem -1);
+        if (m_curAction->type == ActionRemove || m_curAction->type == ActionMove ||
+                m_curAction->type == ActionHardMoveRemove)
+        {
+            m_removeNotifier.notifyRemoved(mainItem); // notify all instances
+        }
+        if (m_curAction->type == ActionCopy || m_curAction->type == ActionMove ||
+                m_curAction->type == ActionHardMoveCopy)
+        {
+            QString addedItem = targetFom(mainItem.absoluteFilePath());
+            if (curEntry->alreadyExists)
+            {
+                m_removeNotifier.notifyRemoved(addedItem);
+            }
+            emit added(addedItem);
+        }
+        m_curAction->currEntry++;
+        //check if is doing a hard move and the copy part has finished
+        //if so switch the action to remove
+        if (m_curAction->type == ActionHardMoveCopy &&
+                m_curAction->currEntry == m_curAction->entries.count() )
+        {
+            m_curAction->type      = ActionHardMoveRemove;
+            m_curAction->currEntry = 0;
+            int entryCounter = m_curAction->entries.count();
+            ActionEntry * entry;
+            while (entryCounter--)
+            {
+                entry = m_curAction->entries.at(entryCounter);
+                entry->currItem = 0;
+                entry->currStep = 0;
+            }
+        }
+    }
+    if (curEntry->currStep == STEP_FILES)
+    {
+        curEntry->currStep = 0;
+    }
+
+    int percent = notifyProgress();
+    //Check if the current action has finished or cancelled
+    if (m_cancelCurrentAction ||
+        m_curAction->currEntry == m_curAction->entries.count())
+    {
+        if (!m_cancelCurrentAction)
+        {
+            endCurrentAction();
+            if (percent < 100)
+            {
+                notifyProgress(100);
+            }
+        }
+        //it may have other actions to do
+        scheduleSlot(SLOT(processAction()));
+    }
+    else
+    {
+        //keep working on current Action maybe more entries
+        scheduleSlot(SLOT(processActionEntry()));
+    }
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::cancel
+ */
+void FileSystemAction::cancel()
+{
+    m_cancelCurrentAction = true;
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::removeEntry
+ * \param entry
+ */
+void FileSystemAction::removeEntry(ActionEntry *entry)
+{
+    QDir dir;
+    //do one step at least
+    for(; !m_cancelCurrentAction                          &&
+          entry->currStep       < STEP_FILES              &&
+          m_curAction->currItem < m_curAction->totalItems &&
+          entry->currItem       < entry->reversedOrder.count()
+        ; entry->currStep++,    m_curAction->currItem++, entry->currItem++
+        )
+
+    {
+        const QFileInfo &fi = entry->reversedOrder.at(entry->currItem);
+        if (fi.isDir() && !fi.isSymLink())
+        {
+            m_cancelCurrentAction = !dir.rmdir(fi.absoluteFilePath());
+        }
+        else
+        {
+            m_cancelCurrentAction = !QFile::remove(fi.absoluteFilePath());
+        }
+#if DEBUG_REMOVE
+        qDebug() << "remove ret=" << !m_cancelCurrentAction << fi.absoluteFilePath();
+#endif
+        if (m_cancelCurrentAction)
+        {
+            m_errorTitle = QObject::tr("Could not remove the item ") +
+                                       fi.absoluteFilePath();
+            m_errorMsg   = ::strerror(errno);
+        }
+    }
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::copyEntry
+ * \param entry
+ */
+void  FileSystemAction::processCopyEntry()
+{
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO;
+#endif
+
+     ActionEntry * entry = static_cast<ActionEntry*>
+            ( m_curAction->entries.at(m_curAction->currEntry) );
+
+    /*
+     * This flag will be true when processCopySingleFile() has put any slot in the execution queue
+     * it will work to stop the loop.
+     * Later processCopyEntry() will be called again to continue working
+     */
+    bool scheduleAnySlot = false;
+
+    for(; !m_cancelCurrentAction  && !scheduleAnySlot     &&
+          entry->currStep       < STEP_FILES              &&
+          m_curAction->currItem < m_curAction->totalItems &&
+          entry->currItem       < entry->reversedOrder.count()
+        ; entry->currStep++,    entry->currItem++
+        )
+
+    {
+        const QFileInfo &fi = entry->reversedOrder.at(entry->currItem);
+        QString orig    = fi.absoluteFilePath();
+        QString target = targetFom(orig);
+        QString path(target);
+        // do this here to allow progress send right item number, copySingleFile will emit progress()
+        m_curAction->currItem++;
+
+        if (fi.isFile() || fi.isSymLink())
+        {
+            QFileInfo  t(target);
+            path = t.path();
+        }
+        QDir d(path);
+        if (!d.exists() && !d.mkpath(path))
+        {
+            m_cancelCurrentAction = true;
+            m_errorTitle = QObject::tr("Could not create the directory");
+            m_errorMsg   = path;
+        }
+        else
+        if (fi.isSymLink())
+        {
+            m_cancelCurrentAction = ! copySymLink(target,fi);
+            if (m_cancelCurrentAction)
+            {
+                m_errorTitle = QObject::tr("Could not create link to");
+                m_errorMsg   = target;
+            }
+            m_curAction->bytesWritten += COMMON_SIZE_ITEM;
+        }
+        else
+        if (fi.isDir())
+        {
+            m_cancelCurrentAction = !
+                 QFile(target).setPermissions(fi.permissions());
+            if (m_cancelCurrentAction)
+            {
+                m_errorTitle = QObject::tr("Could not set permissions to dir");
+                m_errorMsg   = target;
+            }
+            m_curAction->bytesWritten += COMMON_SIZE_ITEM;
+        }
+        else
+        if (fi.isFile())
+        {
+            m_curAction->copyFile.clear();
+            m_curAction->copyFile.source = new QFile(orig);
+            if (!m_curAction->copyFile.source->open(QFile::ReadOnly))
+            {
+                m_cancelCurrentAction = true;
+                m_errorTitle = QObject::tr("Could not open file");
+                m_errorMsg   = orig;
+            }
+             m_curAction->copyFile.target = new QTemporaryFile();
+            if (! m_curAction->copyFile.target->open())
+            {
+                m_cancelCurrentAction = true;
+                m_errorTitle = QObject::tr("Could not create temporary file");
+                m_errorMsg   =  m_curAction->copyFile.target->fileName();
+            }
+            m_curAction->copyFile.targetName = target;
+            scheduleAnySlot =  processCopySingleFile();
+        }
+    }//for
+
+    //no copy going on
+    if (!scheduleAnySlot)
+    {
+        endActionEntry();
+    }
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::moveEntry
+ * \param entry
+ */
+void FileSystemAction::moveEntry(ActionEntry *entry)
+{
+    QFile file;
+
+    for(; !m_cancelCurrentAction                          &&
+          entry->currStep       < STEP_FILES              &&
+          m_curAction->currItem < m_curAction->totalItems &&
+          entry->currItem       < entry->reversedOrder.count()
+        ; entry->currStep++,    m_curAction->currItem++, entry->currItem++
+        )
+
+    {
+        const QFileInfo &fi = entry->reversedOrder.at(entry->currItem);
+        file.setFileName(fi.absoluteFilePath());
+        QString target = targetFom(fi.absoluteFilePath());
+        if (!file.rename(target))
+        {
+            m_cancelCurrentAction = true;
+            m_errorTitle = QObject::tr("Could not move the directory/file ") + target;
+            m_errorMsg   = ::strerror(errno);
+        }
+    }//for
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::pathChanged
+ * \param path
+ */
+void FileSystemAction::pathChanged(const QString &path)
+{
+    m_path = path;
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::copy
+ * \param pathnames
+ */
+void FileSystemAction::copy(const QStringList &pathnames)
+{
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << pathnames;
+#endif
+    DirModelMimeData::ClipBoardDataOwner owner =
+               m_mimeData->setIntoClipboard(pathnames, m_path, ClipboardCopy);
+    if (owner == DirModelMimeData::MySelf )
+    {
+        emit clipboardChanged();
+    }
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::cut
+ * \param pathnames
+ */
+void FileSystemAction::cut(const QStringList &pathnames)
+{
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << pathnames;
+#endif
+     DirModelMimeData::ClipBoardDataOwner owner =
+         m_mimeData->setIntoClipboard(pathnames, m_path, ClipboardCut);
+     if (owner == DirModelMimeData::MySelf )
+     {
+         emit clipboardChanged();
+     }
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::paste
+ */
+void FileSystemAction::paste()
+{
+    ClipboardOperation  operation;
+    QStringList paths     = m_mimeData->localUrls(operation);
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << paths;
+#endif
+    if (paths.count())
+    {
+       if (QFileInfo(m_path).absoluteFilePath() == QFileInfo(paths.at(0)).absolutePath())
+       {
+           emit error(tr("Cannot paste"),
+                      tr("origin and destination folder are the same"));
+           return;
+       }
+       ActionType actionType  = ActionCopy; // start with Copy and check for Cut
+       if (operation == ClipboardCut)
+       {
+            //so far it always returns true since on Linux it is possible to rename
+            // between different file systems
+            if ( moveUsingSameFileSystem(paths.at(0)) ) {
+                actionType = ActionMove;
+            } else {
+                actionType = ActionHardMoveCopy; // first step
+            }
+       }
+       createAndProcessAction(actionType, paths, operation);
+    }
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::createAndProcessAction
+ * \param actionType
+ * \param paths
+ * \param operation
+ */
+void  FileSystemAction::createAndProcessAction(ActionType actionType, const QStringList& paths, ClipboardOperation operation)
+{
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO << paths;
+#endif
+    Action       *myAction       = 0;
+    int           origPathLen    = 0;
+    myAction                     = createAction(actionType, origPathLen);
+    myAction->operation          = operation;
+    myAction->origPath           = QFileInfo(paths.at(0)).absolutePath();
+    myAction->baseOrigSize       = myAction->origPath.length();
+    Action * saveAction          = m_curAction;
+    m_curAction                  = myAction;
+    for (int counter=0; counter < paths.count(); counter++)
+    {
+        //targetFom() uses m_curAction and is called inside addEntry()
+        addEntry(myAction, paths.at(counter));
+    }
+    m_curAction    = saveAction;
+    if (actionType == ActionHardMoveCopy)
+    {
+        myAction->totalItems *= 2; //duplicate this
+        myAction->totalBytes *= 2;
+    }
+    if (operation == ClipboardCut)
+    {
+        //this must still be false when cut finishes to change the clipboard to the target
+        m_clipboardModifiedByOther = false;
+    }
+    m_queuedActions.append(myAction);
+    if (!m_busy)
+    {
+        processAction();
+    }
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::targetFom() makes a destination full pathname from \a origItem
+ * \param origItem full pathname from a item intended to be copied or moved into current path
+ * \return full pathname of target
+ */
+QString FileSystemAction::targetFom(const QString& origItem)
+{
+    QString target(m_curAction->targetPath + origItem.mid(m_curAction->baseOrigSize));
+    return target;
+}
+
+//===============================================================================================
+/*!
+ * \brief FileSystemAction::moveUsingSameFileSystem() Checks if the item being moved to
+ *   current m_path belongs to the same File System
+ *
+ * \param itemToMovePathname  first item being moved from a paste operation
+ *
+ * \return true if the item being moved to the current m_path belongs to the same file system as m_path
+ */
+bool FileSystemAction::moveUsingSameFileSystem(const QString& itemToMovePathname)
+{
+#if 0 //disabled since on Linux it looks like renaming between different file systems works
+    unsigned long targetFsId = 0xffff;
+    unsigned long originFsId = 0xfffe;
+    struct statvfs  vfs;
+
+    if ( ::statvfs(m_path.toLatin1().constData(), &vfs) == 0 )
+    {
+        targetFsId = vfs.f_fsid;
+    }
+    if ( ::statvfs(itemToMovePathname.toLatin1().constData(), &vfs) == 0)
+    {
+        originFsId = vfs.f_fsid;
+    }
+    return targetFsId == originFsId;
+#else
+    Q_UNUSED(itemToMovePathname);
+    return true;
+#endif
+}
+
+//=======================================================
+/*!
+ * \brief FileSystemAction::clipboardLocalUrlsConunter
+ * \return
+ */
+int FileSystemAction::clipboardLocalUrlsConunter()
+{
+    ClipboardOperation operation;
+    return m_mimeData->localUrls(operation).count();
+}
+
+//================================================================================
+/*!
+ * \brief FileSystemAction::endCurrentAction() finishes an Action
+ *
+ *  If a Paste was made from a Cut operation, items pasted become avaialable in the clipboard
+ *   as from Copy source operation, so items can be now Pasted again, but with no source removal
+ *
+ * It checks for \a m_clipboardModifiedByOther that idenftifies if the clipboard was modified during the
+ * operation maybe by another application.
+ */
+void FileSystemAction::endCurrentAction()
+{
+    if ( m_curAction->origPath != m_curAction->targetPath &&
+         m_curAction->operation == ClipboardCut           &&
+         !m_clipboardModifiedByOther )
+    {
+         QStringList items;
+         const ActionEntry *entry;
+         int   last;
+         for(int e = 0; e < m_curAction->entries.count(); e++)
+         {
+             entry   = m_curAction->entries.at(e);
+             last    = entry->reversedOrder.count() -1;
+             QString item(targetFom(entry->reversedOrder.at(last).absoluteFilePath()));
+             items.append(item);
+         }
+         if (items.count())
+         {
+             QString targetPath = m_curAction->targetPath;
+             //it is not necessary to handle own clipboard here
+             m_mimeData->setIntoClipboard(items, targetPath, ClipboardCopy);
+         }
+    }
+}
+
+//================================================================================
+/*!
+ * \brief FileSystemAction::copySingleFile() do a single file copy
+ *
+ * Several write operations are required to copy big files, each operation writes (STEP_FILES * 4k) bytes.
+ * After a write operation if more operations are required to copy the whole file,
+ * a progress() signal is emitted and a new write operation is scheduled to happen in the next loop interaction.
+ *
+ * \return  true if scheduled to another slot either processCopyEntry() or itself; false if not.
+ */
+bool FileSystemAction::processCopySingleFile()
+{
+#if DEBUG_MESSAGES
+        qDebug() << Q_FUNC_INFO;
+#endif
+    char block[4096];
+    int  step = 0;
+    bool copySingleFileDone = false;
+    bool scheduleAnySlot    = true;
+    int  startBytes         = m_curAction->copyFile.bytesWritten;
+
+    while( m_curAction->copyFile.source           &&
+           !m_curAction->copyFile.source->atEnd() &&
+           !m_cancelCurrentAction                 &&
+           m_curAction->copyFile.bytesWritten < m_curAction->copyFile.source->size() &&
+           step++ < STEP_FILES
+         )
+    {
+        qint64 in = m_curAction->copyFile.source->read(block, sizeof(block));
+        if (in > 0)
+        {
+            if(in != m_curAction->copyFile.target->write(block, in))
+            {
+                  m_curAction->copyFile.source->close();
+                  m_curAction->copyFile.target->close();
+                  m_cancelCurrentAction = true;
+                  m_errorTitle = QObject::tr("Write error in ")
+                                  + m_curAction->copyFile.targetName,
+                  m_errorMsg   = ::strerror(errno);
+                  break;
+            }
+            m_curAction->bytesWritten          += in;
+            m_curAction->copyFile.bytesWritten += in;
+        }
+        else
+        if (in < 0)
+        {
+           m_cancelCurrentAction = true;
+           m_errorTitle = QObject::tr("Read error in ")
+                           + m_curAction->copyFile.source->fileName();
+           m_errorMsg   = ::strerror(errno);
+           break;
+        }
+    }// end write loop
+
+    // write loop finished, the copy might be finished
+    if (!m_cancelCurrentAction
+        && m_curAction->copyFile.source
+        && m_curAction->copyFile.bytesWritten == m_curAction->copyFile.source->size()
+        && m_curAction->copyFile.source->isOpen()
+       )
+    {
+        m_curAction->copyFile.source->close();
+        m_curAction->copyFile.target->close();
+        m_curAction->copyFile.target->setAutoRemove(false);
+        m_cancelCurrentAction = !m_curAction->copyFile.target->setPermissions(
+                                     m_curAction->copyFile.source->permissions());
+        if (m_cancelCurrentAction)
+        {
+            m_errorTitle = QObject::tr("Set permissions error in ")
+                            + m_curAction->copyFile.targetName,
+            m_errorMsg   = ::strerror(errno);
+        }
+        else
+        {
+            QFile testExistTarget(m_curAction->copyFile.targetName);
+            if (testExistTarget.exists())
+            {
+                if ((m_cancelCurrentAction = ! testExistTarget.remove()))
+                {
+                    m_errorTitle = QObject::tr("Could not remove original file ")
+                                    + m_curAction->copyFile.targetName,
+                    m_errorMsg   = ::strerror(errno);
+                }
+            }
+            if (!m_cancelCurrentAction)
+            {
+                m_cancelCurrentAction = ! m_curAction->copyFile.target->
+                        rename(m_curAction->copyFile.targetName);
+                if (m_cancelCurrentAction)
+                {
+                    m_errorTitle = QObject::tr("Rename error: renaming to ")
+                            + m_curAction->copyFile.targetName,
+                            m_errorMsg   = ::strerror(errno);
+                }
+                else
+                {
+                    copySingleFileDone = true;
+                }
+            }
+        }
+    }
+
+    if (m_cancelCurrentAction)
+    {
+        if (m_curAction->copyFile.target)
+        {
+            m_curAction->copyFile.target->setAutoRemove(true);
+        }
+        m_curAction->copyFile.clear();
+        endActionEntry();
+    }
+    else
+    {
+        notifyProgress();
+        if (copySingleFileDone)
+        {
+            m_curAction->copyFile.clear();
+            //whem the whole copy could be done just in one call
+            //do not schedule to call copyEntry()
+            if (startBytes > 0)
+            {
+                //the whole took more than one call to copySingleFile()
+                scheduleSlot(SLOT(processCopyEntry()));
+            }
+            else
+            {   //return normally to entry loop
+                scheduleAnySlot = false;
+            }
+        }
+        else
+        {
+            scheduleSlot(SLOT(processCopySingleFile()));
+        }
+    }
+
+    return scheduleAnySlot;
+}
+
+
+//================================================================================
+/*!
+ * \brief FileSystemAction::percentWorkDone() Compute the percent of work done
+ *
+ * Copy operations are based on bytes written while remove/move operations are based on items number
+ *
+ * \return the percent of work done
+ */
+int FileSystemAction::percentWorkDone()
+{
+    int percent = 0;
+    if (m_curAction->type != ActionCopy && m_curAction->type != ActionHardMoveCopy)
+    {
+         percent = (m_curAction->currItem * 100) / m_curAction->totalItems;
+    }
+    else
+    {
+         percent = (m_curAction->bytesWritten * 100) / m_curAction->totalBytes ;
+    }
+    if (percent > 100)
+    {
+        percent = 100;
+    }
+    return percent;
+}
+
+
+//================================================================================
+/*!
+ * \brief FileSystemAction::notifyProgress() Notify the progress signal
+ *
+ * \return the percent of work done
+ */
+int FileSystemAction::notifyProgress(int forcePercent)
+{
+    int percent = forcePercent > 0 ? forcePercent :  percentWorkDone();
+    if (percent == 0)
+    {
+        percent = 1;
+    }
+    if (SHOULD_EMIT_PROGRESS_SIGNAL(m_curAction) && !m_curAction->done)
+    {
+        if (m_curAction->type == ActionHardMoveCopy ||
+            m_curAction->type ==ActionHardMoveRemove)
+        {
+            emit progress(m_curAction->currItem/2,  m_curAction->totalItems/2, percent);
+        }
+        else
+        {
+            emit progress(m_curAction->currItem,  m_curAction->totalItems, percent);
+        }
+        if (percent == 100 && m_curAction->currItem == m_curAction->totalItems)
+        {
+            m_curAction->done = true;
+        }
+    }
+    return  percent;
+}
+
+//================================================================================
+/*!
+ * \brief FileSystemAction::copySymLink() creates the \a target as a link according to \a orig
+ * \param target full pathname of the file to be created
+ * \param orig   original file, it carries the link that \a target will point to
+ * \return true if it could create, else if not
+ */
+bool FileSystemAction::copySymLink(const QString &target, const QFileInfo &orig)
+{
+    QString link(orig.symLinkTarget());
+    QFileInfo linkFile(link);
+    if (linkFile.isAbsolute() && linkFile.absolutePath() == orig.absolutePath())
+    {
+        link = linkFile.fileName();
+    }
+#if QT_VERSION <= 0x040704
+    QString current = QDir::currentPath();
+    QDir::setCurrent(linkFile.absolutePath());
+    bool ret = QFile::link(link, target);
+    QDir::setCurrent(current);
+#else
+    bool ret = QFile::link(link, target);
+#endif
+#if DEBUG_MESSAGES
+    qDebug() << "FileSystemAction::copySymLink" << ret << target << link;
+#endif
+    return ret;
+}
+
+//================================================================================
+void FileSystemAction::scheduleSlot(const char *slot)
+{
+#if DEBUG_MESSAGES
+    qDebug() << "FileSystemAction::scheduleSlot()" << slot;
+#endif
+    QTimer::singleShot(0, this, slot);
+}
+
+//================================================================================
+/*!
+ * \brief FileSystemAction::clipboardHasChanged() used to identify if the clipboard changed during a Cut operation
+ *
+ *  \sa \ref endCurrentAction()
+ */
+void FileSystemAction::clipboardHasChanged()
+{
+    m_clipboardModifiedByOther = true;
+}
 
=== added file 'folderlistmodel/filesystemaction.h'
--- folderlistmodel/filesystemaction.h	1970-01-01 00:00:00 +0000
+++ folderlistmodel/filesystemaction.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,212 @@
+/**************************************************************************
+ *
+ * Copyright 2013 Canonical Ltd.
+ * Copyright 2013 Carlos J Mazieri <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ *
+ * File: filesystemaction.h
+ * Date: 3/13/2013
+ */
+
+#ifndef FILESYSTEMACTION_H
+#define FILESYSTEMACTION_H
+
+
+#include <QObject>
+#include <QFileInfo>
+#include <QVector>
+
+class DirModelMimeData;
+class RemoveNotifier;
+class QFile;
+class QTemporaryFile;
+
+enum ClipboardOperation
+{
+    NoClipboard, ClipboardCopy, ClipboardCut
+};
+
+/*!
+ * \brief The FileSystemAction class
+ *
+ *
+ */
+class FileSystemAction : public QObject
+{
+    Q_OBJECT
+public:  
+    explicit FileSystemAction(QObject *parent = 0);
+    ~FileSystemAction();
+public slots:
+    void     cancel();
+    void     remove(const QStringList & filePaths);
+    int      clipboardLocalUrlsConunter();
+
+signals:
+    void     error(const QString& errorTitle, const QString &errorMessage);
+    void     removed(const QString& item);   //must be sent to all Model instances
+    void     removed(const QFileInfo&);
+    void     added(const QString& );
+    void     added(const QFileInfo& );
+    void     progress(int curItem, int totalItems, int percent);
+    void     clipboardChanged();
+
+public slots:
+    void     pathChanged(const QString& path);
+    void     paste();
+    void     cut(const QStringList& );
+    void     copy(const QStringList&);
+
+private slots:
+    void     processAction();
+    void     processActionEntry();   
+    void     processCopyEntry();
+    bool     processCopySingleFile();
+    void     clipboardHasChanged();
+
+#if defined(REGRESSION_TEST_FOLDERLISTMODEL) //used in Unit/Regression tests
+ public:
+#else
+ private:
+#endif
+   enum ActionType
+   {
+       ActionRemove,
+       ActionCopy,
+       ActionMove,
+       ActionHardMoveCopy,
+       ActionHardMoveRemove
+   };
+   void     createAndProcessAction(ActionType actionType, const QStringList& paths,
+                                   ClipboardOperation operation=NoClipboard);
+
+private:
+
+   struct CopyFile
+   {
+     public:
+       CopyFile() : bytesWritten(0), source(0), target(0) {}
+       ~CopyFile() { clear(); }
+       void clear();
+
+       qint64            bytesWritten;           // set 0 when reach  bytesToNotify, notify progress
+       QFile          *  source;
+       QTemporaryFile *  target;
+       QString           targetName;
+   };
+
+   /*!
+       An ActionEntry represents a high level item as a File or a Directory which an Action is required
+
+       For directories \a reversedOrder keeps all children
+    */
+   struct ActionEntry
+   {
+     public:
+       ActionEntry(): currStep(0),currItem(0),alreadyExists(false), newName(0) {}
+       ~ActionEntry()
+       {
+           reversedOrder.clear();
+           if (newName) { delete newName; }
+       }
+       QList<QFileInfo>   reversedOrder;   //!< last item must be the item from the list
+       int                currStep;
+       int                currItem;
+       bool               alreadyExists;
+       QString *          newName; //TODO:  allow to rename an existent file when it already exists
+   };
+
+   struct Action
+   {
+    public:
+       ~Action()           {qDeleteAll(entries); entries.clear(); copyFile.clear();}
+       ActionType          type;
+       QList<ActionEntry*> entries;
+       int                 totalItems;
+       int                 currItem;
+       int                 baseOrigSize;
+       QString             origPath;
+       QString             targetPath;
+       quint64             totalBytes;
+       quint64             bytesWritten;
+       int                 currEntry;
+       ClipboardOperation  operation;
+       CopyFile            copyFile;
+       bool                done;
+   };
+
+   QVector<Action*>        m_queuedActions;  //!< work always at item 0, after finishing taking item 0 out
+   Action            *     m_curAction;
+   bool                    m_cancelCurrentAction;
+   bool                    m_busy;
+   static RemoveNotifier   m_removeNotifier;
+   QString                 m_path;
+   DirModelMimeData  *     m_mimeData;
+   QString                 m_errorTitle;
+   QString                 m_errorMsg;
+   bool                    m_clipboardModifiedByOther;
+
+private:  
+   Action * createAction(ActionType, int origBase = 0);
+   void     addEntry(Action* action, const QString &pathname);
+   void     removeEntry(ActionEntry *);   
+   void     moveEntry(ActionEntry *entry);
+   bool     moveUsingSameFileSystem(const QString& itemToMovePathname);
+   QString  targetFom(const QString& origItem);
+   void     endCurrentAction();
+   int      percentWorkDone();
+   int      notifyProgress(int forcePercent = 0);
+   void     endActionEntry();
+   bool     copySymLink(const QString& target, const QFileInfo& orig);
+   void     scheduleSlot(const char *slot);
+};
+    
+
+/*!
+ * \brief The RemoveNotifier is a utility class for \ref FileSystemAction to send
+ *         notifications about removed files/dir
+ *
+ *  This class must have a unique instance to notify all instances of \ref FileSystemAction and \ref DirModel
+ */
+class RemoveNotifier : public QObject
+{
+    Q_OBJECT
+
+    friend class FileSystemAction;
+private:
+    explicit RemoveNotifier(QObject *parent = 0);
+    void notifyRemoved(const QString& item);
+    void notifyRemoved(const QFileInfo& fi);
+
+signals:
+    void     removed(const QString& item);
+    void     removed(const QFileInfo&);
+};
+
+#endif // FILESYSTEMACTION_H
 
=== added file 'folderlistmodel/folderlistmodel.pri'
--- folderlistmodel/folderlistmodel.pri	1970-01-01 00:00:00 +0000
+++ folderlistmodel/folderlistmodel.pri	2013-06-01 17:20:36 +0000
@@ -0,0 +1,26 @@
+SOURCES += $$PWD/dirmodel.cpp \
+           $$PWD/iorequest.cpp \
+           $$PWD/iorequestworker.cpp \
+           $$PWD/ioworkerthread.cpp \
+           $$PWD/filesystemaction.cpp \
+
+
+
+
+HEADERS += $$PWD/dirmodel.h \
+           $$PWD/iorequest.h \
+           $$PWD/iorequestworker.h \
+           $$PWD/ioworkerthread.h \
+           $$PWD/filesystemaction.h \
+
+
+
+INCLUDEPATH  += $$PWD 
+
+greaterThan(QT_MAJOR_VERSION, 4) {
+   QT += qml
+}
+else {
+    QT += declarative    
+}
+
 
=== added file 'folderlistmodel/folderlistmodel.pro'
--- folderlistmodel/folderlistmodel.pro	1970-01-01 00:00:00 +0000
+++ folderlistmodel/folderlistmodel.pro	2013-06-01 17:20:36 +0000
@@ -0,0 +1,39 @@
+TARGET = nemofolderlistmodel
+
+PLUGIN_IMPORT_PATH = org/nemomobile/folderlistmodel
+PLUGIN_URI         = org.nemomobile.folderlistmodel
+
+# plugin.h and plugin.cpp use URI from PLUGIN_URI instead of hard coded
+DEFINES += PLUGIN_URI=$$PLUGIN_URI
+
+#core:  sources + headers, separated here to use in regression test project
+include (folderlistmodel.pri)
+
+# Input
+SOURCES += plugin.cpp
+HEADERS += plugin.h
+
+## QApplication::clipboard() needs gui
+QT += gui
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
+exists(../plugin.pri) {
+   include(../plugin.pri)
+}
+else {
+    TEMPLATE = lib
+    CONFIG += qt plugin hide_symbols
+    greaterThan(QT_MAJOR_VERSION, 4) {
+       QT += qml
+    }
+    else {
+       QT += declarative
+    }
+    target.path = $$[QT_INSTALL_QML]/$$PLUGIN_IMPORT_PATH
+    INSTALLS += target
+    qmldir.files += $$PWD/qmldir
+    qmldir.path +=  $$[QT_INSTALL_QML]/$$$$PLUGIN_IMPORT_PATH
+    INSTALLS += qmldir
+}
+
+
 
=== added file 'folderlistmodel/iorequest.cpp'
--- folderlistmodel/iorequest.cpp	1970-01-01 00:00:00 +0000
+++ folderlistmodel/iorequest.cpp	2013-06-01 17:20:36 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#include "iorequest.h"
+
+IORequest::IORequest() : QObject()
+{
+}
 
=== added file 'folderlistmodel/iorequest.h'
--- folderlistmodel/iorequest.h	1970-01-01 00:00:00 +0000
+++ folderlistmodel/iorequest.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#ifndef IOREQUEST_H
+#define IOREQUEST_H
+
+#include <QObject>
+
+class IORequest : public QObject
+{
+    Q_OBJECT
+public:
+    explicit IORequest();
+    
+public:
+    virtual void run() = 0;
+    
+private:
+    // hide this because IORequest should *NOT* be parented directly
+    using QObject::setParent;
+};
+
+#endif // IOREQUEST_H
 
=== added file 'folderlistmodel/iorequestworker.cpp'
--- folderlistmodel/iorequestworker.cpp	1970-01-01 00:00:00 +0000
+++ folderlistmodel/iorequestworker.cpp	2013-06-01 17:20:36 +0000
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#include "iorequestworker.h"
+#include "iorequest.h"
+
+#include <QMutexLocker>
+#include <QDebug>
+
+/*!
+  Lives on an IOWorkerThread.
+
+  Responsible for running IORequest jobs on the thread instance, and
+  disposing of their resources once they are done.
+ */
+IORequestWorker::IORequestWorker()
+    : QThread()
+    , mTimeToQuit(false)
+{
+}
+
+void IORequestWorker::addRequest(IORequest *request)
+{
+    request->moveToThread(this);
+
+    // TODO: queue requests so we run the most important one first
+    QMutexLocker lock(&mMutex);
+    mRequests.append(request);
+
+    // wake run()
+    mWaitCondition.wakeOne();
+}
+
+void IORequestWorker::run()
+{
+    forever {
+        QMutexLocker lock(&mMutex);
+
+        if (mTimeToQuit)
+            return;
+
+        if (mRequests.empty())
+            mWaitCondition.wait(&mMutex);
+
+        while (!mRequests.isEmpty()) {
+            IORequest *request = mRequests.takeFirst();
+
+            lock.unlock();
+
+            request->run();
+            request->deleteLater();
+
+            lock.relock();
+        }
+    }
+}
+
+void IORequestWorker::exit()
+{
+#if DEBUG_MESSAGES
+    qDebug() << Q_FUNC_INFO << "Quitting";
+#endif
+    QMutexLocker lock(&mMutex);
+    mTimeToQuit = true;
+    mWaitCondition.wakeOne();
+}
 
=== added file 'folderlistmodel/iorequestworker.h'
--- folderlistmodel/iorequestworker.h	1970-01-01 00:00:00 +0000
+++ folderlistmodel/iorequestworker.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#ifndef IOREQUESTWORKER_H
+#define IOREQUESTWORKER_H
+
+#include <QObject>
+#include <QThread>
+#include <QMutex>
+#include <QWaitCondition>
+
+#include "iorequest.h"
+
+class IORequestWorker : public QThread
+{
+    Q_OBJECT
+public:
+    explicit IORequestWorker();
+
+    void addRequest(IORequest *request);
+
+    void run();
+
+    void exit();
+
+private:
+    QMutex mMutex;
+    QWaitCondition mWaitCondition;
+    QList<IORequest *> mRequests;
+    bool mTimeToQuit;
+};
+
+#endif // IOREQUESTWORKER_H
 
=== added file 'folderlistmodel/ioworkerthread.cpp'
--- folderlistmodel/ioworkerthread.cpp	1970-01-01 00:00:00 +0000
+++ folderlistmodel/ioworkerthread.cpp	2013-06-01 17:20:36 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#include "ioworkerthread.h"
+
+
+/*!
+  Hosts a thread, lives on the main thread.
+
+  Responsible for relaying interaction between the main thread and an IOWorkerThread.
+ */
+IOWorkerThread::IOWorkerThread(QObject *parent) :
+    QObject(parent)
+{
+    mWorker.start(QThread::IdlePriority);
+}
+
+/*!
+  Destroys an IOWorkerThread instance.
+ */
+IOWorkerThread::~IOWorkerThread()
+{
+    mWorker.exit();
+    mWorker.wait();
+}
+
+/*!
+  Attempts an asynchronous attempt to start a \a request.
+
+  If the request may be run, it is queued, and true is returned, otherwise, false.
+ */
+bool IOWorkerThread::addRequest(IORequest *request)
+{
+    mWorker.addRequest(request);
+    return true;
+}
 
=== added file 'folderlistmodel/ioworkerthread.h'
--- folderlistmodel/ioworkerthread.h	1970-01-01 00:00:00 +0000
+++ folderlistmodel/ioworkerthread.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#ifndef IOWORKERTHREAD_H
+#define IOWORKERTHREAD_H
+
+#include <QObject>
+#include <QThread>
+
+#include "iorequestworker.h"
+
+class IOWorkerThread : public QObject
+{
+    Q_OBJECT
+public:
+    explicit IOWorkerThread(QObject *parent = 0);
+    virtual ~IOWorkerThread();
+    bool addRequest(IORequest *request);
+
+private:
+    IORequestWorker mWorker;
+};
+
+#endif // IOWORKERTHREAD_H
 
=== added file 'folderlistmodel/plugin.cpp'
--- folderlistmodel/plugin.cpp	1970-01-01 00:00:00 +0000
+++ folderlistmodel/plugin.cpp	2013-06-01 17:20:36 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#include <QVector>
+#include <QFileInfo>
+
+#include "plugin.h"
+
+NemoFolderListModelPlugin::NemoFolderListModelPlugin() { }
+
+NemoFolderListModelPlugin::~NemoFolderListModelPlugin() { }
+
+void NemoFolderListModelPlugin::initializeEngine(QmlEngine *engine, const char *uri)
+{
+    Q_UNUSED(engine)
+    Q_ASSERT(uri == QLatin1String(QUOTES(PLUGIN_URI)));
+}
+
+void NemoFolderListModelPlugin::registerTypes(const char *uri)
+{
+    Q_ASSERT(uri == QLatin1String(QUOTES(PLUGIN_URI)));
+    qRegisterMetaType<QVector<QFileInfo> >();
+    qmlRegisterType<DirModel>(uri, 1, 0, "FolderListModel");
+}
+
 
=== added file 'folderlistmodel/plugin.h'
--- folderlistmodel/plugin.h	1970-01-01 00:00:00 +0000
+++ folderlistmodel/plugin.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#ifndef NEMO_QML_PLUGINS_FOLDERLISTMODEL
+#define NEMO_QML_PLUGINS_FOLDERLISTMODEL
+
+#include <QtGlobal>
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
+#include <QtDeclarative>
+#include <QDeclarativeEngine>
+#include <QDeclarativeExtensionPlugin>
+#include <QVector>
+#include <QFileInfo>
+
+#define PLUGIN_CLASS_EXPORT
+#define PLUGIN_CLASS_EXTERNAL_EXPORT Q_EXPORT_PLUGIN2(nemofolderlistmodel, NemoFolderListModelPlugin);
+#define PLUGIN_CLASS_EXTEND
+typedef QDeclarativeExtensionPlugin QmlPluginParent;
+typedef QDeclarativeEngine QmlEngine;
+Q_DECLARE_METATYPE(QVector<QFileInfo>)
+
+#else
+#include <QQmlComponent>
+#include <QQmlEngine>
+#include <QQmlContext>
+#include <QQmlExtensionPlugin>
+
+#define PLUGIN_CLASS_EXPORT Q_DECL_EXPORT
+#define PLUGIN_CLASS_EXTERNAL_EXPORT
+#define PLUGIN_CLASS_EXTEND \
+    Q_OBJECT \
+    Q_PLUGIN_METADATA(IID "org.nemomobile.folderlistmodel")
+typedef QQmlExtensionPlugin QmlPluginParent;
+typedef QQmlEngine QmlEngine;
+#endif
+
+#include "dirmodel.h"
+
+#define QUOTES(x)  #x
+
+
+class PLUGIN_CLASS_EXPORT NemoFolderListModelPlugin  : public QmlPluginParent
+{
+    PLUGIN_CLASS_EXTEND
+
+public:
+    NemoFolderListModelPlugin();
+    virtual ~NemoFolderListModelPlugin();
+
+    void initializeEngine(QmlEngine *engine, const char *uri);
+    void registerTypes(const char *uri);
+};
+
+PLUGIN_CLASS_EXTERNAL_EXPORT
+
+#endif // NEMO_QML_PLUGINS_FOLDERLISTMODEL
 
=== added file 'folderlistmodel/qmldir'
--- folderlistmodel/qmldir	1970-01-01 00:00:00 +0000
+++ folderlistmodel/qmldir	2013-06-01 17:20:36 +0000
@@ -0,0 +1,1 @@
+plugin nemofolderlistmodel
 
=== added directory 'nemo-folderlistmodel'
=== added file 'nemo-folderlistmodel/dirmodel.cpp'
--- nemo-folderlistmodel/dirmodel.cpp	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/dirmodel.cpp	2013-06-01 17:20:36 +0000
@@ -0,0 +1,385 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#include <QDirIterator>
+#include <QDir>
+#include <QDebug>
+#include <QDateTime>
+#include <QUrl>
+
+#include <errno.h>
+#include <string.h>
+
+#include "dirmodel.h"
+#include "ioworkerthread.h"
+
+Q_GLOBAL_STATIC(IOWorkerThread, ioWorkerThread);
+
+class DirListWorker : public IORequest
+{
+    Q_OBJECT
+public:
+    DirListWorker(const QString &pathName)
+        : mPathName(pathName)
+    { }
+
+    void run()
+    {
+        qDebug() << Q_FUNC_INFO << "Running on: " << QThread::currentThreadId();
+
+        QDir tmpDir = QDir(mPathName);
+        QDirIterator it(tmpDir);
+        QVector<QFileInfo> directoryContents;
+
+        while (it.hasNext()) {
+            it.next();
+
+            // skip hidden files
+            if (it.fileName()[0] == QLatin1Char('.'))
+                continue;
+
+            directoryContents.append(it.fileInfo());
+            if (directoryContents.count() >= 50) {
+                emit itemsAdded(directoryContents);
+
+                // clear() would force a deallocation, micro-optimisation
+                directoryContents.erase(directoryContents.begin(), directoryContents.end());
+            }
+        }
+
+        // last batch
+        emit itemsAdded(directoryContents);
+
+        //std::sort(directoryContents.begin(), directoryContents.end(), DirModel::fileCompare);
+    }
+
+signals:
+    void itemsAdded(const QVector<QFileInfo> &files);
+
+private:
+    QString mPathName;
+};
+
+DirModel::DirModel(QObject *parent)
+    : QAbstractListModel(parent)
+    , mAwaitingResults(false)
+    , mShowDirectories(true)
+{
+    mNameFilters = QStringList() << "*";
+
+    QHash<int, QByteArray> roles = roleNames();
+    roles.insert(FileNameRole, QByteArray("fileName"));
+    roles.insert(CreationDateRole, QByteArray("creationDate"));
+    roles.insert(ModifiedDateRole, QByteArray("modifiedDate"));
+    roles.insert(FileSizeRole, QByteArray("fileSize"));
+    roles.insert(IconSourceRole, QByteArray("iconSource"));
+    roles.insert(FilePathRole, QByteArray("filePath"));
+    roles.insert(IsDirRole, QByteArray("isDir"));
+    roles.insert(IsFileRole, QByteArray("isFile"));
+    roles.insert(IsReadableRole, QByteArray("isReadable"));
+    roles.insert(IsWritableRole, QByteArray("isWritable"));
+    roles.insert(IsExecutableRole, QByteArray("isExecutable"));
+    setRoleNames(roles);
+
+    // populate reverse mapping
+    QHash<int, QByteArray>::ConstIterator it = roles.constBegin();
+    for (;it != roles.constEnd(); ++it)
+        mRoleMapping.insert(it.value(), it.key());
+
+    // make sure we cover all roles
+//    Q_ASSERT(roles.count() == IsFileRole - FileNameRole);
+}
+
+QVariant DirModel::data(int row, const QByteArray &stringRole) const
+{
+    QHash<QByteArray, int>::ConstIterator it = mRoleMapping.constFind(stringRole);
+
+    if (it == mRoleMapping.constEnd())
+        return QVariant();
+
+    return data(index(row, 0), *it);
+}
+
+QVariant DirModel::data(const QModelIndex &index, int role) const
+{
+    if (role < FileNameRole || role > IsExecutableRole) {
+        qWarning() << Q_FUNC_INFO << "Got an out of range role: " << role;
+        return QVariant();
+    }
+
+    if (index.row() < 0 || index.row() >= mDirectoryContents.count()) {
+        qWarning() << "Attempted to access out of range row: " << index.row();
+        return QVariant();
+    }
+
+    if (index.column() != 0)
+        return QVariant();
+
+    const QFileInfo &fi = mDirectoryContents.at(index.row());
+
+    switch (role) {
+        case FileNameRole:
+            return fi.fileName();
+        case CreationDateRole:
+            return fi.created();
+        case ModifiedDateRole:
+            return fi.lastModified();
+        case FileSizeRole: {
+            qint64 kb = fi.size() / 1024;
+            if (kb < 1)
+                return QString::number(fi.size()) + " bytes";
+            else if (kb < 1024)
+                return QString::number(kb) + " kb";
+
+            kb /= 1024;
+            return QString::number(kb) + "mb";
+        }
+        case IconSourceRole: {
+            const QString &fileName = fi.fileName();
+
+            if (fi.isDir())
+                return "image://theme/icon-m-common-directory";
+
+            if (fileName.endsWith(".jpg", Qt::CaseInsensitive) ||
+                fileName.endsWith(".png", Qt::CaseInsensitive)) {
+                return "image://nemoThumbnail/" + fi.filePath();
+            }
+
+            return "image://theme/icon-m-content-document";
+        }
+        case FilePathRole:
+            return fi.filePath();
+        case IsDirRole:
+            return fi.isDir();
+        case IsFileRole:
+            return !fi.isDir();
+        case IsReadableRole:
+            return fi.isReadable();
+        case IsWritableRole:
+            return fi.isWritable();
+        case IsExecutableRole:
+            return fi.isExecutable();
+        default:
+            // this should not happen, ever
+            Q_ASSERT(false);
+            qWarning() << Q_FUNC_INFO << "Got an unknown role: " << role;
+            return QVariant();
+    }
+}
+
+void DirModel::setPath(const QString &pathName)
+{
+    if (pathName.isEmpty())
+        return;
+
+    if (mAwaitingResults) {
+        // TODO: handle the case where pathName != our current path, cancel old
+        // request, start a new one
+        qDebug() << Q_FUNC_INFO << "Ignoring path change request, request already running";
+        return;
+    }
+
+    mAwaitingResults = true;
+    emit awaitingResultsChanged();
+    qDebug() << Q_FUNC_INFO << "Changing to " << pathName << " on " << QThread::currentThreadId();
+
+    beginResetModel();
+    mDirectoryContents.clear();
+    endResetModel();
+
+    // TODO: we need to set a spinner active before we start getting results from DirListWorker
+    DirListWorker *dlw = new DirListWorker(pathName);
+    connect(dlw, SIGNAL(itemsAdded(QVector<QFileInfo>)), SLOT(onItemsAdded(QVector<QFileInfo>)));
+    ioWorkerThread()->addRequest(dlw);
+
+    mCurrentDir = pathName;
+    emit pathChanged();
+}
+
+static bool fileCompare(const QFileInfo &a, const QFileInfo &b)
+{
+    if (a.isDir() && !b.isDir())
+        return true;
+
+    if (b.isDir() && !a.isDir())
+        return false;
+
+    return QString::localeAwareCompare(a.fileName(), b.fileName()) < 0;
+}
+
+void DirModel::onItemsAdded(const QVector<QFileInfo> &newFiles)
+{
+    qDebug() << Q_FUNC_INFO << "Got new files: " << newFiles.count();
+
+    if (mAwaitingResults) {
+        qDebug() << Q_FUNC_INFO << "No longer awaiting results";
+        mAwaitingResults = false;
+        emit awaitingResultsChanged();
+    }
+
+    foreach (const QFileInfo &fi, newFiles) {
+        if (!mShowDirectories && fi.isDir())
+            continue;
+
+        bool doAdd = true;
+        foreach (const QString &nameFilter, mNameFilters) {
+            // TODO: using QRegExp for wildcard matching is slow
+            QRegExp re(nameFilter, Qt::CaseInsensitive, QRegExp::Wildcard);
+            if (!re.exactMatch(fi.fileName())) {
+                doAdd = false;
+                break;
+            }
+        }
+
+        if (!doAdd)
+            continue;
+
+        QVector<QFileInfo>::Iterator it = qLowerBound(mDirectoryContents.begin(),
+                                                      mDirectoryContents.end(),
+                                                      fi,
+                                                      fileCompare);
+
+        if (it == mDirectoryContents.end()) {
+            beginInsertRows(QModelIndex(), mDirectoryContents.count(), mDirectoryContents.count());
+            mDirectoryContents.append(fi);
+            endInsertRows();
+        } else {
+            int idx = it - mDirectoryContents.begin();
+            beginInsertRows(QModelIndex(), idx, idx);
+            mDirectoryContents.insert(it, fi);
+            endInsertRows();
+        }
+    }
+}
+
+void DirModel::rm(const QStringList &paths)
+{
+    // TODO: handle directory deletions?
+    bool error = false;
+
+    foreach (const QString &path, paths) {
+        error |= QFile::remove(path);
+
+        if (error) {
+            qWarning() << Q_FUNC_INFO << "Failed to remove " << path;
+            error = false;
+        }
+    }
+
+    // TODO: just remove removed items; don't reload the entire model
+    refresh();
+}
+
+bool DirModel::rename(int row, const QString &newName)
+{
+    qDebug() << Q_FUNC_INFO << "Renaming " << row << " to " << newName;
+    Q_ASSERT(row >= 0 && row < mDirectoryContents.count());
+    if (row < 0 || row >= mDirectoryContents.count()) {
+        qWarning() << Q_FUNC_INFO << "Out of bounds access";
+        return false;
+    }
+
+    const QFileInfo &fi = mDirectoryContents.at(row);
+
+    if (!fi.isDir()) {
+        QFile f(fi.absoluteFilePath());
+        bool retval = f.rename(fi.absolutePath() + QDir::separator() + newName);
+
+        if (!retval)
+            qDebug() << Q_FUNC_INFO << "Rename returned error code: " << f.error() << f.errorString();
+        else
+            refresh();
+        // TODO: just change the affected item... ^^
+
+        return retval;
+    } else {
+        QDir d(fi.absoluteFilePath());
+        bool retval = d.rename(fi.absoluteFilePath(), fi.absolutePath() + QDir::separator() + newName);
+
+        // QDir has no way to detect what went wrong. woohoo!
+
+        // TODO: just change the affected item...
+        refresh();
+
+        return retval;
+    }
+
+    // unreachable (we hope)
+    Q_ASSERT(false);
+    return false;
+}
+
+void DirModel::mkdir(const QString &newDir)
+{
+    qDebug() << Q_FUNC_INFO << "Creating new folder " << newDir << " to " << mCurrentDir;
+
+    QDir dir(mCurrentDir);
+    bool retval = dir.mkdir(newDir);
+    if (!retval) {
+        const char *errorStr = strerror(errno);
+        qDebug() << Q_FUNC_INFO << "Error creating new directory: " << errno << " (" << errorStr << ")";
+        emit error("Error creating new folder", errorStr);
+    } else {
+        refresh();
+    }
+}
+
+bool DirModel::showDirectories() const
+{
+    return mShowDirectories;
+}
+
+void DirModel::setShowDirectories(bool showDirectories)
+{
+    mShowDirectories = showDirectories;
+    refresh();
+    emit showDirectoriesChanged();
+}
+
+QStringList DirModel::nameFilters() const
+{
+    return mNameFilters;
+}
+
+void DirModel::setNameFilters(const QStringList &nameFilters)
+{
+    mNameFilters = nameFilters;
+    refresh();
+    emit nameFiltersChanged();
+}
+
+bool DirModel::awaitingResults() const
+{
+    return mAwaitingResults;
+}
+
+// for dirlistworker
+#include "dirmodel.moc"
 
=== added file 'nemo-folderlistmodel/dirmodel.h'
--- nemo-folderlistmodel/dirmodel.h	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/dirmodel.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#ifndef DIRMODEL_H
+#define DIRMODEL_H
+
+#include <QAbstractListModel>
+#include <QFileInfo>
+#include <QVector>
+#include <QStringList>
+
+#include "iorequest.h"
+
+class DirModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+    enum Roles {
+        FileNameRole = Qt::UserRole,
+        CreationDateRole,
+        ModifiedDateRole,
+        FileSizeRole,
+        IconSourceRole,
+        FilePathRole,
+        IsDirRole,
+        IsFileRole,
+        IsReadableRole,
+        IsWritableRole,
+        IsExecutableRole
+    };
+
+public:
+    DirModel(QObject *parent = 0);
+
+    int rowCount(const QModelIndex &index) const
+    {
+        if (index.parent() != QModelIndex())
+            return 0;
+
+        return mDirectoryContents.count();
+    }
+
+    // TODO: this won't be safe if the model can change under the holder of the row
+    Q_INVOKABLE QVariant data(int row, const QByteArray &stringRole) const;
+
+    QVariant data(const QModelIndex &index, int role) const;
+
+    Q_INVOKABLE void refresh()
+    {
+        // just some syntactical sugar really
+        setPath(path());
+    }
+
+    Q_PROPERTY(QString path READ path WRITE setPath NOTIFY pathChanged);
+    inline QString path() const { return mCurrentDir; }
+
+    Q_PROPERTY(bool awaitingResults READ awaitingResults NOTIFY awaitingResultsChanged);
+    bool awaitingResults() const;
+
+    void setPath(const QString &pathName);
+
+    Q_INVOKABLE void rm(const QStringList &paths);
+
+    Q_INVOKABLE bool rename(int row, const QString &newName);
+
+    Q_INVOKABLE void mkdir(const QString &newdir);
+
+    Q_PROPERTY(bool showDirectories READ showDirectories WRITE setShowDirectories NOTIFY showDirectoriesChanged)
+    bool showDirectories() const;
+    void setShowDirectories(bool showDirectories);
+
+    Q_PROPERTY(QStringList nameFilters READ nameFilters WRITE setNameFilters NOTIFY nameFiltersChanged)
+    QStringList nameFilters() const;
+    void setNameFilters(const QStringList &nameFilters);
+
+public slots:
+    void onItemsAdded(const QVector<QFileInfo> &newFiles);
+
+signals:
+    void awaitingResultsChanged();
+    void nameFiltersChanged();
+    void showDirectoriesChanged();
+    void pathChanged();
+    void error(const QString &errorTitle, const QString &errorMessage);
+
+private:
+    QStringList mNameFilters;
+    bool mShowDirectories;
+    bool mAwaitingResults;
+    QString mCurrentDir;
+    QVector<QFileInfo> mDirectoryContents;
+    QHash<QByteArray, int> mRoleMapping;
+};
+
+
+#endif // DIRMODEL_H
 
=== added file 'nemo-folderlistmodel/folderlistmodel.pro'
--- nemo-folderlistmodel/folderlistmodel.pro	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/folderlistmodel.pro	2013-06-01 17:20:36 +0000
@@ -0,0 +1,16 @@
+TARGET = nemofolderlistmodel
+PLUGIN_IMPORT_PATH = org/nemomobile/folderlistmodel
+
+SOURCES += plugin.cpp \
+           dirmodel.cpp \
+           iorequest.cpp \
+           iorequestworker.cpp \
+           ioworkerthread.cpp
+
+HEADERS += plugin.h \
+           dirmodel.h \
+           iorequest.h \
+           iorequestworker.h \
+           ioworkerthread.h
+
+include(../plugin.pri)
 
=== added file 'nemo-folderlistmodel/iorequest.cpp'
--- nemo-folderlistmodel/iorequest.cpp	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/iorequest.cpp	2013-06-01 17:20:36 +0000
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#include "iorequest.h"
+
+IORequest::IORequest() : QObject()
+{
+}
 
=== added file 'nemo-folderlistmodel/iorequest.h'
--- nemo-folderlistmodel/iorequest.h	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/iorequest.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#ifndef IOREQUEST_H
+#define IOREQUEST_H
+
+#include <QObject>
+
+class IORequest : public QObject
+{
+    Q_OBJECT
+public:
+    explicit IORequest();
+    
+public:
+    virtual void run() = 0;
+    
+private:
+    // hide this because IORequest should *NOT* be parented directly
+    using QObject::setParent;
+};
+
+#endif // IOREQUEST_H
 
=== added file 'nemo-folderlistmodel/iorequestworker.cpp'
--- nemo-folderlistmodel/iorequestworker.cpp	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/iorequestworker.cpp	2013-06-01 17:20:36 +0000
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#include <QMutexLocker>
+#include <QDebug>
+
+#include "iorequestworker.h"
+#include "iorequest.h"
+
+/*!
+  Lives on an IOWorkerThread.
+
+  Responsible for running IORequest jobs on the thread instance, and
+  disposing of their resources once they are done.
+ */
+IORequestWorker::IORequestWorker()
+    : QThread()
+    , mTimeToQuit(false)
+{
+}
+
+void IORequestWorker::addRequest(IORequest *request)
+{
+    request->moveToThread(this);
+
+    // TODO: queue requests so we run the most important one first
+    QMutexLocker lock(&mMutex);
+    mRequests.append(request);
+
+    // wake run()
+    mWaitCondition.wakeOne();
+}
+
+void IORequestWorker::run()
+{
+    forever {
+        QMutexLocker lock(&mMutex);
+
+        if (mTimeToQuit)
+            return;
+
+        if (mRequests.empty())
+            mWaitCondition.wait(&mMutex);
+
+        while (!mRequests.isEmpty()) {
+            IORequest *request = mRequests.takeFirst();
+
+            lock.unlock();
+
+            request->run();
+            request->deleteLater();
+
+            lock.relock();
+        }
+    }
+}
+
+void IORequestWorker::exit()
+{
+    qDebug() << Q_FUNC_INFO << "Quitting";
+    QMutexLocker lock(&mMutex);
+    mTimeToQuit = true;
+    mWaitCondition.wakeOne();
+}
 
=== added file 'nemo-folderlistmodel/iorequestworker.h'
--- nemo-folderlistmodel/iorequestworker.h	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/iorequestworker.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#ifndef IOREQUESTWORKER_H
+#define IOREQUESTWORKER_H
+
+#include <QObject>
+#include <QThread>
+#include <QMutex>
+#include <QWaitCondition>
+
+#include "iorequest.h"
+
+class IORequestWorker : public QThread
+{
+    Q_OBJECT
+public:
+    explicit IORequestWorker();
+
+    void addRequest(IORequest *request);
+
+    void run();
+
+    void exit();
+
+private:
+    QMutex mMutex;
+    QWaitCondition mWaitCondition;
+    QList<IORequest *> mRequests;
+    bool mTimeToQuit;
+};
+
+#endif // IOREQUESTWORKER_H
 
=== added file 'nemo-folderlistmodel/ioworkerthread.cpp'
--- nemo-folderlistmodel/ioworkerthread.cpp	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/ioworkerthread.cpp	2013-06-01 17:20:36 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#include "ioworkerthread.h"
+
+
+/*!
+  Hosts a thread, lives on the main thread.
+
+  Responsible for relaying interaction between the main thread and an IOWorkerThread.
+ */
+IOWorkerThread::IOWorkerThread(QObject *parent) :
+    QObject(parent)
+{
+    mWorker.start(QThread::IdlePriority);
+}
+
+/*!
+  Destroys an IOWorkerThread instance.
+ */
+IOWorkerThread::~IOWorkerThread()
+{
+    mWorker.exit();
+    mWorker.wait();
+}
+
+/*!
+  Attempts an asynchronous attempt to start a \a request.
+
+  If the request may be run, it is queued, and true is returned, otherwise, false.
+ */
+bool IOWorkerThread::addRequest(IORequest *request)
+{
+    mWorker.addRequest(request);
+    return true;
+}
 
=== added file 'nemo-folderlistmodel/ioworkerthread.h'
--- nemo-folderlistmodel/ioworkerthread.h	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/ioworkerthread.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#ifndef IOWORKERTHREAD_H
+#define IOWORKERTHREAD_H
+
+#include <QObject>
+#include <QThread>
+
+#include "iorequestworker.h"
+
+class IOWorkerThread : public QObject
+{
+    Q_OBJECT
+public:
+    explicit IOWorkerThread(QObject *parent = 0);
+    virtual ~IOWorkerThread();
+    bool addRequest(IORequest *request);
+
+private:
+    IORequestWorker mWorker;
+};
+
+#endif // IOWORKERTHREAD_H
 
=== added file 'nemo-folderlistmodel/plugin.cpp'
--- nemo-folderlistmodel/plugin.cpp	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/plugin.cpp	2013-06-01 17:20:36 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#include <QVector>
+#include <QFileInfo>
+
+#include "plugin.h"
+
+NemoFolderListModelPlugin::NemoFolderListModelPlugin() { }
+
+NemoFolderListModelPlugin::~NemoFolderListModelPlugin() { }
+
+void NemoFolderListModelPlugin::initializeEngine(QmlEngine *engine, const char *uri)
+{
+    Q_UNUSED(engine)
+    Q_ASSERT(uri == QLatin1String("org.nemomobile.folderlistmodel"));
+}
+
+void NemoFolderListModelPlugin::registerTypes(const char *uri)
+{
+    Q_ASSERT(uri == QLatin1String("org.nemomobile.folderlistmodel"));
+    qRegisterMetaType<QVector<QFileInfo> >();
+    qmlRegisterType<DirModel>(uri, 1, 0, "FolderListModel");
+}
+
 
=== added file 'nemo-folderlistmodel/plugin.h'
--- nemo-folderlistmodel/plugin.h	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/plugin.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2012 Robin Burchell <[e-mail]>
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * "Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *   * Neither the name of Nemo Mobile nor the names of its contributors
+ *     may be used to endorse or promote products derived from this
+ *     software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
+ */
+
+#ifndef NEMO_QML_PLUGINS_FOLDERLISTMODEL
+#define NEMO_QML_PLUGINS_FOLDERLISTMODEL
+
+#include <QtGlobal>
+
+#if QT_VERSION < QT_VERSION_CHECK(5, 0, 0)
+#include <QtDeclarative>
+#include <QDeclarativeEngine>
+#include <QDeclarativeExtensionPlugin>
+#include <QVector>
+#include <QFileInfo>
+
+#define PLUGIN_CLASS_EXPORT
+#define PLUGIN_CLASS_EXTERNAL_EXPORT Q_EXPORT_PLUGIN2(nemofolderlistmodel, NemoFolderListModelPlugin);
+#define PLUGIN_CLASS_EXTEND
+typedef QDeclarativeExtensionPlugin QmlPluginParent;
+typedef QDeclarativeEngine QmlEngine;
+Q_DECLARE_METATYPE(QVector<QFileInfo>)
+
+#else
+#include <QQmlComponent>
+#include <QQmlEngine>
+#include <QQmlContext>
+#include <QQmlExtensionPlugin>
+
+#define PLUGIN_CLASS_EXPORT Q_DECL_EXPORT
+#define PLUGIN_CLASS_EXTERNAL_EXPORT
+#define PLUGIN_CLASS_EXTEND \
+    Q_OBJECT \
+    Q_PLUGIN_METADATA(IID "org.nemomobile.folderlistmodel")
+typedef QQmlExtensionPlugin QmlPluginParent;
+typedef QQmlEngine QmlEngine;
+#endif
+
+#include "dirmodel.h"
+
+class PLUGIN_CLASS_EXPORT NemoFolderListModelPlugin  : public QmlPluginParent
+{
+    PLUGIN_CLASS_EXTEND
+
+public:
+    NemoFolderListModelPlugin();
+    virtual ~NemoFolderListModelPlugin();
+
+    void initializeEngine(QmlEngine *engine, const char *uri);
+    void registerTypes(const char *uri);
+};
+
+PLUGIN_CLASS_EXTERNAL_EXPORT
+
+#endif // NEMO_QML_PLUGINS_FOLDERLISTMODEL
 
=== added file 'nemo-folderlistmodel/qmldir'
--- nemo-folderlistmodel/qmldir	1970-01-01 00:00:00 +0000
+++ nemo-folderlistmodel/qmldir	2013-06-01 17:20:36 +0000
@@ -0,0 +1,1 @@
+plugin nemofolderlistmodel
 
=== added directory 'test_folderlistmodel'
=== added directory 'test_folderlistmodel/regression'
=== added file 'test_folderlistmodel/regression/media_asx.h'
--- test_folderlistmodel/regression/media_asx.h	1970-01-01 00:00:00 +0000
+++ test_folderlistmodel/regression/media_asx.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,21 @@
+const unsigned char media_asx[] = {
+  0x3c, 0x61, 0x73, 0x78, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
+  0x3d, 0x22, 0x33, 0x2e, 0x30, 0x22, 0x3e, 0x0d, 0x0a, 0x3c, 0x65, 0x6e,
+  0x74, 0x72, 0x79, 0x3e, 0x0d, 0x0a, 0x3c, 0x72, 0x65, 0x66, 0x20, 0x68,
+  0x72, 0x65, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f,
+  0x72, 0x65, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x61, 0x62, 0x61, 0x63, 0x61,
+  0x73, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x67, 0x61, 0x74, 0x65, 0x77,
+  0x61, 0x79, 0x2f, 0x67, 0x65, 0x74, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x2e,
+  0x61, 0x73, 0x70, 0x3f, 0x73, 0x63, 0x3d, 0x77, 0x74, 0x72, 0x78, 0x2d,
+  0x66, 0x6d, 0x22, 0x20, 0x2f, 0x3e, 0x0d, 0x0a, 0x3c, 0x2f, 0x65, 0x6e,
+  0x74, 0x72, 0x79, 0x3e, 0x0d, 0x0a, 0x3c, 0x65, 0x6e, 0x74, 0x72, 0x79,
+  0x3e, 0x0d, 0x0a, 0x3c, 0x72, 0x65, 0x66, 0x20, 0x68, 0x72, 0x65, 0x66,
+  0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6d, 0x65, 0x64,
+  0x69, 0x61, 0x2e, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x61, 0x64, 0x73,
+  0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x64,
+  0x61, 0x74, 0x61, 0x2f, 0x72, 0x65, 0x67, 0x65, 0x6e, 0x74, 0x2f, 0x61,
+  0x73, 0x78, 0x2f, 0x57, 0x54, 0x52, 0x58, 0x2e, 0x61, 0x73, 0x78, 0x22,
+  0x20, 0x2f, 0x3e, 0x0d, 0x0a, 0x3c, 0x2f, 0x65, 0x6e, 0x74, 0x72, 0x79,
+  0x3e, 0x0d, 0x0a, 0x3c, 0x2f, 0x61, 0x73, 0x78, 0x3e, 0x0d, 0x0a
+};
+qint64  media_asx_len = 215;
 
=== added file 'test_folderlistmodel/regression/media_xspf.h'
--- test_folderlistmodel/regression/media_xspf.h	1970-01-01 00:00:00 +0000
+++ test_folderlistmodel/regression/media_xspf.h	2013-06-01 17:20:36 +0000
@@ -0,0 +1,135 @@
+const unsigned char media_xspf[] = {
+  0x3c, 0x3f, 0x78, 0x6d, 0x6c, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
+  0x6e, 0x3d, 0x22, 0x31, 0x2e, 0x30, 0x22, 0x20, 0x65, 0x6e, 0x63, 0x6f,
+  0x64, 0x69, 0x6e, 0x67, 0x3d, 0x22, 0x55, 0x54, 0x46, 0x2d, 0x38, 0x22,
+  0x3f, 0x3e, 0x0a, 0x3c, 0x70, 0x6c, 0x61, 0x79, 0x6c, 0x69, 0x73, 0x74,
+  0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x31, 0x22,
+  0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70,
+  0x3a, 0x2f, 0x2f, 0x78, 0x73, 0x70, 0x66, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
+  0x6e, 0x73, 0x2f, 0x30, 0x2f, 0x22, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73,
+  0x3a, 0x76, 0x6c, 0x63, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
+  0x2f, 0x77, 0x77, 0x77, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x6c, 0x61,
+  0x6e, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x76, 0x6c, 0x63, 0x2f, 0x70, 0x6c,
+  0x61, 0x79, 0x6c, 0x69, 0x73, 0x74, 0x2f, 0x6e, 0x73, 0x2f, 0x30, 0x2f,
+  0x22, 0x3e, 0x0a, 0x09, 0x3c, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x4c,
+  0x69, 0x73, 0x74, 0x61, 0x20, 0x64, 0x65, 0x20, 0x72, 0x65, 0x70, 0x72,
+  0x6f, 0x64, 0x75, 0xc3, 0xa7, 0xc3, 0xa3, 0x6f, 0x3c, 0x2f, 0x74, 0x69,
+  0x74, 0x6c, 0x65, 0x3e, 0x0a, 0x09, 0x3c, 0x74, 0x72, 0x61, 0x63, 0x6b,
+  0x4c, 0x69, 0x73, 0x74, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x74,
+  0x72, 0x61, 0x63, 0x6b, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x3c, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x4c, 0x69, 0x61, 0x6e, 0xc3,
+  0xa7, 0x61, 0x2f, 0x45, 0x41, 0x45, 0x20, 0x70, 0x61, 0x72, 0x61, 0x20,
+  0x61, 0x20, 0x53, 0x6f, 0x63, 0x69, 0x65, 0x64, 0x61, 0x64, 0x65, 0x3c,
+  0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x3c, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3e,
+  0x66, 0x69, 0x6c, 0x65, 0x3a, 0x2f, 0x2f, 0x2f, 0x6d, 0x6e, 0x74, 0x2f,
+  0x62, 0x61, 0x63, 0x6b, 0x75, 0x70, 0x2f, 0x61, 0x75, 0x6c, 0x61, 0x73,
+  0x2f, 0x45, 0x41, 0x45, 0x2f, 0x31, 0x31, 0x35, 0x25, 0x32, 0x30, 0x50,
+  0x72, 0x6f, 0x70, 0x61, 0x67, 0x61, 0x63, 0x61, 0x6f, 0x5f, 0x64, 0x6f,
+  0x5f, 0x45, 0x73, 0x70, 0x69, 0x72, 0x69, 0x74, 0x69, 0x73, 0x6d, 0x6f,
+  0x2f, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x73, 0x2f, 0x4f, 0x25, 0x32, 0x30,
+  0x71, 0x75, 0x65, 0x25, 0x32, 0x30, 0x65, 0x25, 0x32, 0x30, 0x61, 0x25,
+  0x32, 0x30, 0x45, 0x41, 0x45, 0x25, 0x32, 0x30, 0x31, 0x2e, 0x6d, 0x70,
+  0x34, 0x3c, 0x2f, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3e,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x3c, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20,
+  0x61, 0x70, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3d,
+  0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e,
+  0x76, 0x69, 0x64, 0x65, 0x6f, 0x6c, 0x61, 0x6e, 0x2e, 0x6f, 0x72, 0x67,
+  0x2f, 0x76, 0x6c, 0x63, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x6c, 0x69, 0x73,
+  0x74, 0x2f, 0x30, 0x22, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x3c, 0x76, 0x6c, 0x63, 0x3a, 0x69, 0x64, 0x3e, 0x30, 0x3c,
+  0x2f, 0x76, 0x6c, 0x63, 0x3a, 0x69, 0x64, 0x3e, 0x0a, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x76,
+  0x6c, 0x63, 0x3a, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x73, 0x74,
+  0x61, 0x72, 0x74, 0x2d, 0x74, 0x69, 0x6d, 0x65, 0x3d, 0x34, 0x35, 0x3c,
+  0x2f, 0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x3c, 0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+  0x6e, 0x3e, 0x73, 0x74, 0x6f, 0x70, 0x2d, 0x74, 0x69, 0x6d, 0x65, 0x3d,
+  0x36, 0x39, 0x3c, 0x2f, 0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70, 0x74, 0x69,
+  0x6f, 0x6e, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70,
+  0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x66, 0x75, 0x6c, 0x6c, 0x73, 0x63, 0x72,
+  0x65, 0x65, 0x6e, 0x3c, 0x2f, 0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70, 0x74,
+  0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x76, 0x6c, 0x63, 0x3a, 0x6f,
+  0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65,
+  0x3d, 0x35, 0x30, 0x30, 0x3c, 0x2f, 0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70,
+  0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x2f, 0x65, 0x78, 0x74, 0x65,
+  0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c,
+  0x2f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x74,
+  0x72, 0x61, 0x63, 0x6b, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x3c, 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0x48, 0x69, 0x73, 0x74, 0x6f,
+  0x72, 0x69, 0x61, 0x20, 0x64, 0x6f, 0x20, 0x45, 0x73, 0x70, 0x69, 0x72,
+  0x69, 0x74, 0x69, 0x73, 0x6d, 0x6f, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c,
+  0x65, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x6c, 0x6f,
+  0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x66, 0x69, 0x6c, 0x65, 0x3a,
+  0x2f, 0x2f, 0x2f, 0x6d, 0x6e, 0x74, 0x2f, 0x62, 0x61, 0x63, 0x6b, 0x75,
+  0x70, 0x2f, 0x61, 0x75, 0x6c, 0x61, 0x73, 0x2f, 0x45, 0x41, 0x45, 0x2f,
+  0x31, 0x31, 0x35, 0x25, 0x32, 0x30, 0x50, 0x72, 0x6f, 0x70, 0x61, 0x67,
+  0x61, 0x63, 0x61, 0x6f, 0x5f, 0x64, 0x6f, 0x5f, 0x45, 0x73, 0x70, 0x69,
+  0x72, 0x69, 0x74, 0x69, 0x73, 0x6d, 0x6f, 0x2f, 0x76, 0x69, 0x64, 0x65,
+  0x6f, 0x73, 0x2f, 0x4f, 0x25, 0x32, 0x30, 0x71, 0x75, 0x65, 0x25, 0x32,
+  0x30, 0x65, 0x25, 0x32, 0x30, 0x61, 0x25, 0x32, 0x30, 0x45, 0x41, 0x45,
+  0x25, 0x32, 0x30, 0x31, 0x2e, 0x6d, 0x70, 0x34, 0x3c, 0x2f, 0x6c, 0x6f,
+  0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c,
+  0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x70,
+  0x70, 0x6c, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x68,
+  0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x76, 0x69,
+  0x64, 0x65, 0x6f, 0x6c, 0x61, 0x6e, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x76,
+  0x6c, 0x63, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x6c, 0x69, 0x73, 0x74, 0x2f,
+  0x30, 0x22, 0x3e, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x3c, 0x76, 0x6c, 0x63,
+  0x3a, 0x69, 0x64, 0x3e, 0x31, 0x3c, 0x2f, 0x76, 0x6c, 0x63, 0x3a, 0x69,
+  0x64, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x3c, 0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70, 0x74,
+  0x69, 0x6f, 0x6e, 0x3e, 0x73, 0x74, 0x61, 0x72, 0x74, 0x2d, 0x74, 0x69,
+  0x6d, 0x65, 0x3d, 0x31, 0x39, 0x37, 0x3c, 0x2f, 0x76, 0x6c, 0x63, 0x3a,
+  0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3c, 0x76, 0x6c,
+  0x63, 0x3a, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x73, 0x74, 0x6f,
+  0x70, 0x2d, 0x74, 0x69, 0x6d, 0x65, 0x3d, 0x32, 0x36, 0x37, 0x3c, 0x2f,
+  0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x3c, 0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+  0x3e, 0x66, 0x75, 0x6c, 0x6c, 0x73, 0x63, 0x72, 0x65, 0x65, 0x6e, 0x3c,
+  0x2f, 0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e,
+  0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+  0x20, 0x20, 0x3c, 0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70, 0x74, 0x69, 0x6f,
+  0x6e, 0x3e, 0x76, 0x6f, 0x6c, 0x75, 0x6d, 0x65, 0x3d, 0x35, 0x30, 0x30,
+  0x3c, 0x2f, 0x76, 0x6c, 0x63, 0x3a, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
+  0x3e, 0x0a, 0x09, 0x09, 0x09, 0x3c, 0x2f, 0x65, 0x78, 0x74, 0x65, 0x6e,
+  0x73, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x09, 0x09, 0x3c, 0x2f, 0x74, 0x72,
+  0x61, 0x63, 0x6b, 0x3e, 0x0a, 0x09, 0x3c, 0x2f, 0x74, 0x72, 0x61, 0x63,
+  0x6b, 0x4c, 0x69, 0x73, 0x74, 0x3e, 0x0a, 0x09, 0x3c, 0x65, 0x78, 0x74,
+  0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x61, 0x70, 0x70, 0x6c, 0x69,
+  0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70,
+  0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f,
+  0x6c, 0x61, 0x6e, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x76, 0x6c, 0x63, 0x2f,
+  0x70, 0x6c, 0x61, 0x79, 0x6c, 0x69, 0x73, 0x74, 0x2f, 0x30, 0x22, 0x3e,
+  0x0a, 0x09, 0x09, 0x09, 0x3c, 0x76, 0x6c, 0x63, 0x3a, 0x69, 0x74, 0x65,
+  0x6d, 0x20, 0x74, 0x69, 0x64, 0x3d, 0x22, 0x30, 0x22, 0x20, 0x2f, 0x3e,
+  0x0a, 0x09, 0x3c, 0x2f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f,
+  0x6e, 0x3e, 0x0a, 0x3c, 0x2f, 0x70, 0x6c, 0x61, 0x79, 0x6c, 0x69, 0x73,
+  0x74, 0x3e, 0x0a
+};
+qint64 media_xspf_len = 1575;
 
=== added directory 'test_folderlistmodel/regression/mimetypes'
=== added file 'test_folderlistmodel/regression/mimetypes/LICENSE.LGPL'
--- test_folderlistmodel/regression/mimetypes/LICENSE.LGPL	1970-01-01 00:00:00 +0000
+++ test_folderlistmodel/regression/mimetypes/LICENSE.LGPL	2013-06-01 17:20:36 +0000
@@ -0,0 +1,504 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
 
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
 
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
 
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1