qquickfolderlistmodel.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qquickfolderlistmodel_p.h"
#include "fileinfothread_p.h"
#include "fileproperty_p.h"
#include <QtCore/qloggingcategory.h>
#include <qqmlcontext.h>
#include <qqmlfile.h>
 
QT_BEGIN_NAMESPACE
 
Q_LOGGING_CATEGORY(lcFolderListModel, "qt.labs.folderlistmodel")
 
class QQuickFolderListModelPrivate
{
    Q_DECLARE_PUBLIC(QQuickFolderListModel)
 
public:
    QQuickFolderListModelPrivate(QQuickFolderListModel *q) : q_ptr(q) { }
 
    QQuickFolderListModel *q_ptr;
    QUrl currentDir;
    QUrl rootDir;
    FileInfoThread fileInfoThread;
    QList<FileProperty> data;
    QHash<int, QByteArray> roleNames;
    QQuickFolderListModel::SortField sortField = QQuickFolderListModel::Name;
    QStringList nameFilters = { QLatin1String("*") };
    QQuickFolderListModel::Status status = QQuickFolderListModel::Null;
    bool sortReversed = false;
    bool showFiles = true;
    bool showDirs = true;
    bool showDirsFirst = false;
    bool showDotAndDotDot = false;
    bool showOnlyReadable = false;
    bool showHidden = false;
    bool caseSensitive = true;
    bool sortCaseSensitive = true;
 
    ~QQuickFolderListModelPrivate() {}
    void init();
    void updateSorting();
 
    // private slots
    void _q_directoryChanged(const QString &directory, const QList<FileProperty> &list);
    void _q_directoryUpdated(const QString &directory, const QList<FileProperty> &list, int fromIndex, int toIndex);
    void _q_sortFinished(const QList<FileProperty> &list);
    void _q_statusChanged(QQuickFolderListModel::Status s);
 
    static QString resolvePath(const QUrl &path);
};
 
 
void QQuickFolderListModelPrivate::init()
{
    Q_Q(QQuickFolderListModel);
    qRegisterMetaType<QList<FileProperty> >("QList<FileProperty>");
    qRegisterMetaType<QQuickFolderListModel::Status>("QQuickFolderListModel::Status");
    q->connect(&fileInfoThread, SIGNAL(directoryChanged(QString,QList<FileProperty>)),
               q, SLOT(_q_directoryChanged(QString,QList<FileProperty>)));
    q->connect(&fileInfoThread, SIGNAL(directoryUpdated(QString,QList<FileProperty>,int,int)),
               q, SLOT(_q_directoryUpdated(QString,QList<FileProperty>,int,int)));
    q->connect(&fileInfoThread, SIGNAL(sortFinished(QList<FileProperty>)),
               q, SLOT(_q_sortFinished(QList<FileProperty>)));
    q->connect(&fileInfoThread, SIGNAL(statusChanged(QQuickFolderListModel::Status)),
               q, SLOT(_q_statusChanged(QQuickFolderListModel::Status)));
    q->connect(q, SIGNAL(rowCountChanged()), q, SIGNAL(countChanged()));
}
 
 
void QQuickFolderListModelPrivate::updateSorting()
{
    Q_Q(QQuickFolderListModel);
 
    QDir::SortFlags flags;
 
    switch (sortField) {
        case QQuickFolderListModel::Unsorted:
            flags |= QDir::Unsorted;
            break;
        case QQuickFolderListModel::Name:
            flags |= QDir::Name;
            break;
        case QQuickFolderListModel::Time:
            flags |= QDir::Time;
            break;
        case QQuickFolderListModel::Size:
            flags |= QDir::Size;
            break;
        case QQuickFolderListModel::Type:
            flags |= QDir::Type;
            break;
    }
 
    emit q->layoutAboutToBeChanged();
 
    if (sortReversed)
        flags |= QDir::Reversed;
    if (!sortCaseSensitive)
        flags |= QDir::IgnoreCase;
 
    fileInfoThread.setSortFlags(flags);
}
 
void QQuickFolderListModelPrivate::_q_directoryChanged(const QString &directory, const QList<FileProperty> &list)
{
    qCDebug(lcFolderListModel) << "_q_directoryChanged called with directory" << directory;
    Q_Q(QQuickFolderListModel);
    Q_UNUSED(directory);
 
    data = list;
    q->endResetModel();
    qCDebug(lcFolderListModel) << "- endResetModel called";
    emit q->rowCountChanged();
    emit q->folderChanged();
}
 
 
void QQuickFolderListModelPrivate::_q_directoryUpdated(const QString &directory, const QList<FileProperty> &list, int fromIndex, int toIndex)
{
    Q_Q(QQuickFolderListModel);
    Q_UNUSED(directory);
 
    QModelIndex parent;
    if (data.size() == list.size()) {
        QModelIndex modelIndexFrom = q->createIndex(fromIndex, 0);
        QModelIndex modelIndexTo = q->createIndex(toIndex, 0);
        data = list;
        emit q->dataChanged(modelIndexFrom, modelIndexTo);
    } else {
        // File(s) inserted or removed. Since I do not know how many
        // or where, I need to update the whole list from the first item.
        // This is a little pessimistic, but optimizing it would require
        // more information in the signal from FileInfoThread.
        if (data.size() > 0) {
            q->beginRemoveRows(parent, 0, data.size() - 1);
            q->endRemoveRows();
        }
        data = list;
        if (list.size() > 0) {
            if (toIndex > list.size() - 1)
                toIndex = list.size() - 1;
            q->beginInsertRows(parent, 0, data.size() - 1);
            q->endInsertRows();
        }
        emit q->rowCountChanged();
    }
}
 
void QQuickFolderListModelPrivate::_q_sortFinished(const QList<FileProperty> &list)
{
    Q_Q(QQuickFolderListModel);
    qCDebug(lcFolderListModel) << "_q_sortFinished called with" << list.size() << "files";
 
    QModelIndex parent;
    if (data.size() > 0) {
        qCDebug(lcFolderListModel) << "- removing all existing rows...";
        q->beginRemoveRows(parent, 0, data.size()-1);
        data.clear();
        q->endRemoveRows();
        qCDebug(lcFolderListModel) << "- ...removed all existing rows";
    }
 
    qCDebug(lcFolderListModel) << "- inserting sorted rows...";
    q->beginInsertRows(parent, 0, list.size()-1);
    data = list;
    q->endInsertRows();
    qCDebug(lcFolderListModel) << "- ... inserted sorted rows";
}
 
void QQuickFolderListModelPrivate::_q_statusChanged(QQuickFolderListModel::Status s)
{
    Q_Q(QQuickFolderListModel);
 
    if (status != s) {
        status = s;
        emit q->statusChanged();
    }
}
 
QString QQuickFolderListModelPrivate::resolvePath(const QUrl &path)
{
    QString localPath = QQmlFile::urlToLocalFileOrQrc(path);
    QUrl localUrl = QUrl(localPath);
    QString fullPath = localUrl.path();
    if (localUrl.scheme().size())
      fullPath = localUrl.scheme() + QLatin1Char(':') + fullPath;
    return QDir::cleanPath(fullPath);
}
 
 
QQuickFolderListModel::QQuickFolderListModel(QObject *parent)
    : QAbstractListModel(parent), d_ptr(new QQuickFolderListModelPrivate(this))
{
    Q_D(QQuickFolderListModel);
    d->roleNames[FileNameRole] = "fileName";
    d->roleNames[FilePathRole] = "filePath";
    d->roleNames[FileBaseNameRole] = "fileBaseName";
    d->roleNames[FileSuffixRole] = "fileSuffix";
    d->roleNames[FileSizeRole] = "fileSize";
    d->roleNames[FileLastModifiedRole] = "fileModified";
    d->roleNames[FileLastReadRole] = "fileAccessed";
    d->roleNames[FileIsDirRole] = "fileIsDir";
    d->roleNames[FileUrlRole] = "fileUrl";
    d->roleNames[FileURLRole] = "fileURL";
    d->init();
}
 
QQuickFolderListModel::~QQuickFolderListModel()
{
}
 
QVariant QQuickFolderListModel::data(const QModelIndex &index, int role) const
{
    Q_D(const QQuickFolderListModel);
    QVariant rv;
 
    if (index.row() >= d->data.size())
        return rv;
 
    switch (role)
    {
        case FileNameRole:
            rv = d->data.at(index.row()).fileName();
            break;
        case FilePathRole:
            rv = d->data.at(index.row()).filePath();
            break;
        case FileBaseNameRole:
            rv = d->data.at(index.row()).baseName();
            break;
        case FileSuffixRole:
            rv = d->data.at(index.row()).suffix();
            break;
        case FileSizeRole:
            rv = d->data.at(index.row()).size();
            break;
        case FileLastModifiedRole:
            rv = d->data.at(index.row()).lastModified();
            break;
        case FileLastReadRole:
            rv = d->data.at(index.row()).lastRead();
            break;
        case FileIsDirRole:
            rv = d->data.at(index.row()).isDir();
            break;
        case FileUrlRole:
        case FileURLRole:
            rv = QUrl::fromLocalFile(d->data.at(index.row()).filePath());
            break;
        default:
            break;
    }
    return rv;
}
 
QHash<int, QByteArray> QQuickFolderListModel::roleNames() const
{
    Q_D(const QQuickFolderListModel);
    return d->roleNames;
}
 
int QQuickFolderListModel::rowCount(const QModelIndex &parent) const
{
    Q_D(const QQuickFolderListModel);
    Q_UNUSED(parent);
    return d->data.size();
}
 
QModelIndex QQuickFolderListModel::index(int row, int , const QModelIndex &) const
{
    return createIndex(row, 0);
}
 
QUrl QQuickFolderListModel::folder() const
{
    Q_D(const QQuickFolderListModel);
    return d->currentDir;
}
 
void QQuickFolderListModel::setFolder(const QUrl &folder)
{
    Q_D(QQuickFolderListModel);
 
    if (folder == d->currentDir)
        return;
 
    QString resolvedPath = QQuickFolderListModelPrivate::resolvePath(folder);
 
    qCDebug(lcFolderListModel) << "about to emit beginResetModel since our folder was set to" << folder;
    beginResetModel();
 
    //Remove the old path for the file system watcher
    if (!d->currentDir.isEmpty())
        d->fileInfoThread.removePath(d->currentDir.path());
 
    d->currentDir = folder;
 
    QFileInfo info(resolvedPath);
    if (!info.exists() || !info.isDir()) {
        d->data.clear();
        endResetModel();
        emit rowCountChanged();
        if (d->status != QQuickFolderListModel::Null) {
            d->status = QQuickFolderListModel::Null;
            emit statusChanged();
        }
        return;
    }
 
    d->fileInfoThread.setPath(resolvedPath);
}
 
 
QUrl QQuickFolderListModel::rootFolder() const
{
    Q_D(const QQuickFolderListModel);
    return d->rootDir;
}
 
void QQuickFolderListModel::setRootFolder(const QUrl &path)
{
    Q_D(QQuickFolderListModel);
 
    if (path.isEmpty())
        return;
 
    QString resolvedPath = QQuickFolderListModelPrivate::resolvePath(path);
 
    QFileInfo info(resolvedPath);
    if (!info.exists() || !info.isDir())
        return;
 
    d->fileInfoThread.setRootPath(resolvedPath);
    d->rootDir = path;
}
 
 
QUrl QQuickFolderListModel::parentFolder() const
{
    Q_D(const QQuickFolderListModel);
 
    QString localFile = d->currentDir.toLocalFile();
    if (!localFile.isEmpty()) {
        QDir dir(localFile);
        if (dir.isRoot() || !dir.cdUp())
            return QUrl();
        localFile = dir.path();
    } else {
        const QString path = d->currentDir.path();
        const int pos = path.lastIndexOf(QLatin1Char('/'));
        if (pos <= 0)
            return QUrl();
        localFile = path.left(pos);
    }
    return QUrl::fromLocalFile(localFile);
}
 
QStringList QQuickFolderListModel::nameFilters() const
{
    Q_D(const QQuickFolderListModel);
    return d->nameFilters;
}
 
void QQuickFolderListModel::setNameFilters(const QStringList &filters)
{
    Q_D(QQuickFolderListModel);
    if (d->nameFilters == filters)
        return;
    d->fileInfoThread.setNameFilters(filters);
    d->nameFilters = filters;
}
 
void QQuickFolderListModel::classBegin()
{
}
 
void QQuickFolderListModel::componentComplete()
{
    Q_D(QQuickFolderListModel);
    QString localPath = QQmlFile::urlToLocalFileOrQrc(d->currentDir);
    if (localPath.isEmpty() || !QDir(localPath).exists())
        setFolder(QUrl::fromLocalFile(QDir::currentPath()));
    d->fileInfoThread.start(QThread::LowPriority);
}
 
QQuickFolderListModel::SortField QQuickFolderListModel::sortField() const
{
    Q_D(const QQuickFolderListModel);
    return d->sortField;
}
 
void QQuickFolderListModel::setSortField(SortField field)
{
    Q_D(QQuickFolderListModel);
    if (field != d->sortField) {
        d->sortField = field;
        d->updateSorting();
    }
}
 
int QQuickFolderListModel::roleFromString(const QString &roleName) const
{
    Q_D(const QQuickFolderListModel);
    return d->roleNames.key(roleName.toLatin1(), -1);
}
 
bool QQuickFolderListModel::sortReversed() const
{
    Q_D(const QQuickFolderListModel);
    return d->sortReversed;
}
 
void QQuickFolderListModel::setSortReversed(bool rev)
{
    Q_D(QQuickFolderListModel);
 
    if (rev != d->sortReversed) {
        d->sortReversed = rev;
        d->updateSorting();
    }
}
 
bool QQuickFolderListModel::isFolder(int index) const
{
    if (index != -1) {
        QModelIndex idx = createIndex(index, 0);
        if (idx.isValid()) {
            QVariant var = data(idx, FileIsDirRole);
            if (var.isValid())
                return var.toBool();
        }
    }
    return false;
}
 
bool QQuickFolderListModel::showFiles() const
{
    Q_D(const QQuickFolderListModel);
    return d->showFiles;
}
 
void QQuickFolderListModel::setShowFiles(bool on)
{
    Q_D(QQuickFolderListModel);
 
    d->fileInfoThread.setShowFiles(on);
    d->showFiles = on;
}
 
bool QQuickFolderListModel::showDirs() const
{
    Q_D(const QQuickFolderListModel);
    return d->showDirs;
}
 
void  QQuickFolderListModel::setShowDirs(bool on)
{
    Q_D(QQuickFolderListModel);
 
    d->fileInfoThread.setShowDirs(on);
    d->showDirs = on;
}
 
bool QQuickFolderListModel::showDirsFirst() const
{
    Q_D(const QQuickFolderListModel);
    return d->showDirsFirst;
}
 
void  QQuickFolderListModel::setShowDirsFirst(bool on)
{
    Q_D(QQuickFolderListModel);
 
    d->fileInfoThread.setShowDirsFirst(on);
    d->showDirsFirst = on;
}
 
 
bool QQuickFolderListModel::showDotAndDotDot() const
{
    Q_D(const QQuickFolderListModel);
    return d->showDotAndDotDot;
}
 
void  QQuickFolderListModel::setShowDotAndDotDot(bool on)
{
    Q_D(QQuickFolderListModel);
 
    if (on != d->showDotAndDotDot) {
        d->fileInfoThread.setShowDotAndDotDot(on);
        d->showDotAndDotDot = on;
    }
}
 
 
bool QQuickFolderListModel::showHidden() const
{
    Q_D(const QQuickFolderListModel);
    return d->showHidden;
}
 
void QQuickFolderListModel::setShowHidden(bool on)
{
    Q_D(QQuickFolderListModel);
 
    if (on != d->showHidden) {
        d->fileInfoThread.setShowHidden(on);
        d->showHidden = on;
    }
}
 
bool QQuickFolderListModel::showOnlyReadable() const
{
    Q_D(const QQuickFolderListModel);
    return d->showOnlyReadable;
}
 
void QQuickFolderListModel::setShowOnlyReadable(bool on)
{
    Q_D(QQuickFolderListModel);
 
    if (on != d->showOnlyReadable) {
        d->fileInfoThread.setShowOnlyReadable(on);
        d->showOnlyReadable = on;
    }
}
 
bool QQuickFolderListModel::caseSensitive() const
{
    Q_D(const QQuickFolderListModel);
    return d->caseSensitive;
}
 
void QQuickFolderListModel::setCaseSensitive(bool on)
{
    Q_D(QQuickFolderListModel);
 
    if (on != d->caseSensitive) {
        d->fileInfoThread.setCaseSensitive(on);
        d->caseSensitive = on;
    }
}
 
QQuickFolderListModel::Status QQuickFolderListModel::status() const
{
    Q_D(const QQuickFolderListModel);
    return d->status;
}
 
bool QQuickFolderListModel::sortCaseSensitive() const
{
    Q_D(const QQuickFolderListModel);
    return d->sortCaseSensitive;
}
 
void QQuickFolderListModel::setSortCaseSensitive(bool on)
{
    Q_D(QQuickFolderListModel);
 
    if (on != d->sortCaseSensitive) {
        d->sortCaseSensitive = on;
        d->updateSorting();
    }
}
 
QVariant QQuickFolderListModel::get(int idx, const QString &property) const
{
    int role = roleFromString(property);
    if (role >= 0 && idx >= 0)
        return data(index(idx, 0), role);
    else
        return QVariant();
}
 
int QQuickFolderListModel::indexOf(const QUrl &file) const
{
    Q_D(const QQuickFolderListModel);
    FileProperty toFind(QFileInfo(file.toLocalFile()));
    return d->data.indexOf(toFind);
}
 
QT_END_NAMESPACE
 
#include "moc_qquickfolderlistmodel_p.cpp"