transmission/qt/FileTreeModel.cc

/*
 * This file Copyright (C) 2009-2015 Mnemosyne LLC
 *
 * It may be used under the GNU GPL versions 2 or 3
 * or any future license endorsed by Mnemosyne LLC.
 *
 */

#include <cassert>

#include <libtransmission/transmission.h> // priorities

#include "FileTreeItem.h"
#include "FileTreeModel.h"

namespace
{

class PathIteratorBase
{
protected:
    PathIteratorBase(const QString& path, int slashIndex) :
        myPath(path),
        mySlashIndex(slashIndex),
        myToken()
    {
        myToken.reserve(path.size() / 2);
    }

protected:
    const QString& myPath;
    int mySlashIndex;
    QString myToken;

    static const QChar SlashChar;
};

const QChar PathIteratorBase::SlashChar = QLatin1Char('/');

class ForwardPathIterator : public PathIteratorBase
{
public:
    ForwardPathIterator(const QString& path) :
        PathIteratorBase(path, path.size() - 1)
    {
    }

    bool hasNext() const
    {
        return mySlashIndex > 0;
    }

    const QString& next()
    {
        int newSlashIndex = myPath.lastIndexOf(SlashChar, mySlashIndex);
        myToken.truncate(0);
        myToken += myPath.midRef(newSlashIndex + 1, mySlashIndex - newSlashIndex);
        mySlashIndex = newSlashIndex - 1;
        return myToken;
    }
};

class BackwardPathIterator : public PathIteratorBase
{
public:
    BackwardPathIterator(const QString& path) :
        PathIteratorBase(path, 0)
    {
    }

    bool hasNext() const
    {
        return mySlashIndex < myPath.size();
    }

    const QString& next()
    {
        int newSlashIndex = myPath.indexOf(SlashChar, mySlashIndex);

        if (newSlashIndex == -1)
        {
            newSlashIndex = myPath.size();
        }

        myToken.truncate(0);
        myToken += myPath.midRef(mySlashIndex, newSlashIndex - mySlashIndex);
        mySlashIndex = newSlashIndex + 1;
        return myToken;
    }
};

} // namespace

FileTreeModel::FileTreeModel(QObject* parent, bool isEditable) :
    QAbstractItemModel(parent),
    myIsEditable(isEditable),
    myRootItem(new FileTreeItem),
    myIndexCache()
{
}

FileTreeModel::~FileTreeModel()
{
    clear();

    delete myRootItem;
}

void FileTreeModel::setEditable(bool editable)
{
    myIsEditable = editable;
}

FileTreeItem* FileTreeModel::itemFromIndex(const QModelIndex& index) const
{
    if (!index.isValid())
    {
        return nullptr;
    }

    assert(index.model() == this);
    return static_cast<FileTreeItem*>(index.internalPointer());
}

QModelIndexList FileTreeModel::getOrphanIndices(const QModelIndexList& indices) const
{
    QModelIndexList orphanIndices = indices;

    qSort(orphanIndices);

    for (QMutableListIterator<QModelIndex> it(orphanIndices); it.hasNext();)
    {
        QModelIndex walk = it.next();

        for (;;)
        {
            walk = parent(walk, walk.column());

            if (!walk.isValid())
            {
                break;
            }

            if (qBinaryFind(orphanIndices, walk) != orphanIndices.end())
            {
                it.remove();
                break;
            }
        }
    }

    return orphanIndices;
}

QVariant FileTreeModel::data(const QModelIndex& index, int role) const
{
    QVariant value;

    if (index.isValid())
    {
        value = itemFromIndex(index)->data(index.column(), role);
    }

    return value;
}

Qt::ItemFlags FileTreeModel::flags(const QModelIndex& index) const
{
    int i(Qt::ItemIsSelectable | Qt::ItemIsEnabled);

    if (myIsEditable && (index.column() == COL_NAME))
    {
        i |= Qt::ItemIsEditable;
    }

    if (index.column() == COL_WANTED)
    {
        i |= Qt::ItemIsUserCheckable | Qt::ItemIsTristate;
    }

    return Qt::ItemFlags(i);
}

bool FileTreeModel::setData(const QModelIndex& index, const QVariant& newname, int role)
{
    if (role == Qt::EditRole)
    {
        FileTreeItem* item = itemFromIndex(index);

        emit pathEdited(item->path(), newname.toString());
    }

    return false; // don't update the view until the session confirms the change
}

QVariant FileTreeModel::headerData(int column, Qt::Orientation orientation, int role) const
{
    QVariant data;

    if (orientation == Qt::Horizontal && role == Qt::DisplayRole)
    {
        switch (column)
        {
        case COL_NAME:
            data.setValue(tr("File"));
            break;

        case COL_SIZE:
            data.setValue(tr("Size"));
            break;

        case COL_PROGRESS:
            data.setValue(tr("Progress"));
            break;

        case COL_WANTED:
            data.setValue(tr("Download"));
            break;

        case COL_PRIORITY:
            data.setValue(tr("Priority"));
            break;

        default:
            break;
        }
    }

    return data;
}

QModelIndex FileTreeModel::index(int row, int column, const QModelIndex& parent) const
{
    QModelIndex i;

    if (hasIndex(row, column, parent))
    {
        FileTreeItem* parentItem;

        if (!parent.isValid())
        {
            parentItem = myRootItem;
        }
        else
        {
            parentItem = itemFromIndex(parent);
        }

        FileTreeItem* childItem = parentItem->child(row);

        if (childItem)
        {
            i = createIndex(row, column, childItem);
        }
    }

    return i;
}

QModelIndex FileTreeModel::parent(const QModelIndex& child) const
{
    return parent(child, 0); // QAbstractItemModel::parent() wants col 0
}

QModelIndex FileTreeModel::parent(const QModelIndex& child, int column) const
{
    QModelIndex parent;

    if (child.isValid())
    {
        parent = indexOf(itemFromIndex(child)->parent(), column);
    }

    return parent;
}

int FileTreeModel::rowCount(const QModelIndex& parent) const
{
    FileTreeItem* parentItem;

    if (parent.isValid())
    {
        parentItem = itemFromIndex(parent);
    }
    else
    {
        parentItem = myRootItem;
    }

    return parentItem->childCount();
}

int FileTreeModel::columnCount(const QModelIndex& parent) const
{
    Q_UNUSED(parent);

    return NUM_COLUMNS;
}

QModelIndex FileTreeModel::indexOf(FileTreeItem* item, int column) const
{
    if (!item || item == myRootItem)
    {
        return QModelIndex();
    }

    return createIndex(item->row(), column, item);
}

void FileTreeModel::clearSubtree(const QModelIndex& top)
{
    size_t i = rowCount(top);

    while (i > 0)
    {
        clearSubtree(index(--i, 0, top));
    }

    FileTreeItem* const item = itemFromIndex(top);

    if (item == 0)
    {
        return;
    }

    if (item->fileIndex() != -1)
    {
        myIndexCache.remove(item->fileIndex());
    }

    delete item;
}

void FileTreeModel::clear()
{
    beginResetModel();
    clearSubtree(QModelIndex());
    endResetModel();

    assert(myIndexCache.isEmpty());
}

FileTreeItem* FileTreeModel::findItemForFileIndex(int fileIndex) const
{
    return myIndexCache.value(fileIndex, 0);
}

void FileTreeModel::addFile(int fileIndex, const QString& filename, bool wanted, int priority, uint64_t totalSize,
    uint64_t have, bool updateFields)
{
    FileTreeItem* item;

    item = findItemForFileIndex(fileIndex);

    if (item) // this file is already in the tree, we've added this
    {
        QModelIndex indexWithChangedParents;
        ForwardPathIterator filenameIt(filename);

        while (filenameIt.hasNext())
        {
            const QString& token = filenameIt.next();
            const std::pair<int, int> changed = item->update(token, wanted, priority, have, updateFields);

            if (changed.first >= 0)
            {
                emit dataChanged(indexOf(item, changed.first), indexOf(item, changed.second));

                if (!indexWithChangedParents.isValid() && changed.first <= COL_PRIORITY && changed.second >= COL_SIZE)
                {
                    indexWithChangedParents = indexOf(item, 0);
                }
            }

            item = item->parent();
        }

        assert(item == myRootItem);

        if (indexWithChangedParents.isValid())
        {
            emitParentsChanged(indexWithChangedParents, COL_SIZE, COL_PRIORITY);
        }
    }
    else // we haven't build the FileTreeItems for these tokens yet
    {
        bool added = false;

        item = myRootItem;
        BackwardPathIterator filenameIt(filename);

        while (filenameIt.hasNext())
        {
            const QString& token = filenameIt.next();
            FileTreeItem* child(item->child(token));

            if (!child)
            {
                added = true;
                QModelIndex parentIndex(indexOf(item, 0));
                const int n(item->childCount());

                beginInsertRows(parentIndex, n, n);

                if (!filenameIt.hasNext())
                {
                    child = new FileTreeItem(token, fileIndex, totalSize);
                }
                else
                {
                    child = new FileTreeItem(token);
                }

                item->appendChild(child);
                endInsertRows();
            }

            item = child;
        }

        if (item != myRootItem)
        {
            assert(item->fileIndex() == fileIndex);
            assert(item->totalSize() == totalSize);

            myIndexCache[fileIndex] = item;

            const std::pair<int, int> changed = item->update(item->name(), wanted, priority, have, added || updateFields);

            if (changed.first >= 0)
            {
                emit dataChanged(indexOf(item, changed.first), indexOf(item, changed.second));
            }
        }
    }
}

void FileTreeModel::emitParentsChanged(const QModelIndex& index, int firstColumn, int lastColumn,
    QSet<QModelIndex>* visitedParentIndices)
{
    assert(firstColumn <= lastColumn);

    QModelIndex walk = index;

    for (;;)
    {
        walk = parent(walk, firstColumn);

        if (!walk.isValid())
        {
            break;
        }

        if (visitedParentIndices != nullptr)
        {
            if (visitedParentIndices->contains(walk))
            {
                break;
            }

            visitedParentIndices->insert(walk);
        }

        emit dataChanged(walk, walk.sibling(walk.row(), lastColumn));
    }
}

void FileTreeModel::emitSubtreeChanged(const QModelIndex& index, int firstColumn, int lastColumn)
{
    assert(firstColumn <= lastColumn);

    const int childCount = rowCount(index);

    if (!childCount)
    {
        return;
    }

    // tell everyone that this item changed
    emit dataChanged(index.child(0, firstColumn), index.child(childCount - 1, lastColumn));

    // walk the subitems
    for (int i = 0; i < childCount; ++i)
    {
        emitSubtreeChanged(index.child(i, 0), firstColumn, lastColumn);
    }
}

void FileTreeModel::twiddleWanted(const QModelIndexList& indices)
{
    QMap<bool, QModelIndexList> wantedIndices;

    for (const QModelIndex& i : getOrphanIndices(indices))
    {
        const FileTreeItem* const item = itemFromIndex(i);
        wantedIndices[item->isSubtreeWanted() != Qt::Checked] << i;
    }

    for (int i = 0; i <= 1; ++i)
    {
        if (wantedIndices.contains(i))
        {
            setWanted(wantedIndices[i], i != 0);
        }
    }
}

void FileTreeModel::twiddlePriority(const QModelIndexList& indices)
{
    QMap<int, QModelIndexList> priorityIndices;

    for (const QModelIndex& i : getOrphanIndices(indices))
    {
        const FileTreeItem* const item = itemFromIndex(i);
        int priority = item->priority();

        // ... -> normal -> high -> low -> normal -> ...; mixed -> normal
        if (priority == FileTreeItem::NORMAL)
        {
            priority = TR_PRI_HIGH;
        }
        else if (priority == FileTreeItem::HIGH)
        {
            priority = TR_PRI_LOW;
        }
        else
        {
            priority = TR_PRI_NORMAL;
        }

        priorityIndices[priority] << i;
    }

    for (int i = TR_PRI_LOW; i <= TR_PRI_HIGH; ++i)
    {
        if (priorityIndices.contains(i))
        {
            setPriority(priorityIndices[i], i);
        }
    }
}

void FileTreeModel::setWanted(const QModelIndexList& indices, bool wanted)
{
    if (indices.isEmpty())
    {
        return;
    }

    const QModelIndexList orphanIndices = getOrphanIndices(indices);

    QSet<int> fileIds;

    for (const QModelIndex& i : orphanIndices)
    {
        FileTreeItem* const item = itemFromIndex(i);
        item->setSubtreeWanted(wanted, fileIds);

        emit dataChanged(i, i);
        emitSubtreeChanged(i, COL_WANTED, COL_WANTED);
    }

    // emit parent changes separately to avoid multiple updates for same items
    QSet<QModelIndex> parentIndices;

    for (const QModelIndex& i : orphanIndices)
    {
        emitParentsChanged(i, COL_SIZE, COL_WANTED, &parentIndices);
    }

    if (!fileIds.isEmpty())
    {
        emit wantedChanged(fileIds, wanted);
    }
}

void FileTreeModel::setPriority(const QModelIndexList& indices, int priority)
{
    if (indices.isEmpty())
    {
        return;
    }

    const QModelIndexList orphanIndices = getOrphanIndices(indices);

    QSet<int> fileIds;

    for (const QModelIndex& i : orphanIndices)
    {
        FileTreeItem* const item = itemFromIndex(i);
        item->setSubtreePriority(priority, fileIds);

        emit dataChanged(i, i);
        emitSubtreeChanged(i, COL_PRIORITY, COL_PRIORITY);
    }

    // emit parent changes separately to avoid multiple updates for same items
    QSet<QModelIndex> parentIndices;

    for (const QModelIndex& i : orphanIndices)
    {
        emitParentsChanged(i, COL_PRIORITY, COL_PRIORITY, &parentIndices);
    }

    if (!fileIds.isEmpty())
    {
        emit priorityChanged(fileIds, priority);
    }
}

bool FileTreeModel::openFile(const QModelIndex& index)
{
    if (!index.isValid())
    {
        return false;
    }

    FileTreeItem* const item = itemFromIndex(index);

    if (item->fileIndex() < 0 || !item->isComplete())
    {
        return false;
    }

    emit openRequested(item->path());
    return true;
}