flattofoldersproxymodel.cpp

Go to the documentation of this file.

/**********************************************************************
 * LeechCraft - modular cross-platform feature rich internet client.
 * Copyright (C) 2006-2014  Georg Rudoy
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 **********************************************************************/
 
#include "flattofoldersproxymodel.h"
#include <algorithm>
#include <QMimeData>
#include "modelsanitizer.h"
 
namespace LC::Util
{
    struct FlatTreeItem
    {
        enum class Type : std::uint8_t
        {
            Root,
            Folder,
            Item
        };
 
        const Type Type_ = Type::Root;
        FlatTreeItem * const Parent_ = nullptr;
 
        QList<FlatTreeItem_ptr> C_;
        QPersistentModelIndex Index_;
        QString Key_;
 
        FlatTreeItem () = default;
 
        FlatTreeItem (Type type, FlatTreeItem& parent, QString key)
        : Type_ { type }
        , Parent_ { &parent }
        , Key_ { std::move (key) }
        {
        }
 
        int Row () const
        {
            if (!Parent_)
                return 0;
 
            const auto& siblings = Parent_->C_;
            const auto pos = std::ranges::find_if (siblings, [this] (const auto& sibling) { return sibling.get () == this; });
            return pos - siblings.begin ();
        }
 
        FlatTreeItem_ptr AddFolder (const QString& key)
        {
            return C_.emplaceBack (std::make_shared<FlatTreeItem> (Type::Folder, *this, key));
        }
 
        FlatTreeItem_ptr AddLeaf (const QPersistentModelIndex& index)
        {
            const auto& leaf = C_.emplaceBack (std::make_shared<FlatTreeItem> (Type::Item, *this, Key_));
            leaf->Index_ = index;
            return leaf;
        }
    };
 
    namespace
    {
        FlatTreeItem* ToFlat (const QModelIndex& idx)
        {
            return static_cast<FlatTreeItem*> (idx.internalPointer ());
        }
    }
 
    FlatToFoldersProxyModel::FlatToFoldersProxyModel (Config config, QObject *parent)
    : QAbstractItemModel { parent }
    , Config_ { std::move (config) }
    , Root_ { std::make_shared<FlatTreeItem> () }
    {
        InstallModelSanitizer (*this);
    }
 
    int FlatToFoldersProxyModel::columnCount (const QModelIndex&) const
    {
        return SourceModel_ ?
            SourceModel_->columnCount ({}) :
            0;
    }
 
    QVariant FlatToFoldersProxyModel::data (const QModelIndex& index, int role) const
    {
        if (!index.isValid ())
            return {};
 
        const auto fti = ToFlat (index);
 
        if (fti->Type_ == FlatTreeItem::Type::Item)
        {
            const auto& source = fti->Index_;
            return source.sibling (source.row (), index.column ()).data (role);
        }
 
        if (fti->Type_ == FlatTreeItem::Type::Folder && index.column () == 0 && role == Qt::DisplayRole)
            return fti->Key_.isEmpty () ? Config_.UnkeyedLabel_ : fti->Key_;
 
        return {};
    }
 
    QVariant FlatToFoldersProxyModel::headerData (int section, Qt::Orientation orient, int role) const
    {
        if (!SourceModel_)
            return {};
 
        return SourceModel_->headerData (section, orient, role);
    }
 
    Qt::ItemFlags FlatToFoldersProxyModel::flags (const QModelIndex& index) const
    {
        if (!index.isValid ())
            return Qt::ItemIsDropEnabled;
 
        if (const auto fti = ToFlat (index);
            fti->Type_ == FlatTreeItem::Type::Item)
        {
            const auto& source = fti->Index_;
            return source.sibling (source.row (), index.column ()).flags ();
        }
 
        return Qt::ItemIsSelectable |
                Qt::ItemIsEnabled |
                Qt::ItemIsDragEnabled |
                Qt::ItemIsDropEnabled;
    }
 
    bool FlatToFoldersProxyModel::setData (const QModelIndex& index, const QVariant& value, int role)
    {
        if (!index.isValid ())
            return false;
 
        const auto fti = ToFlat (index);
        if (fti->Type_ != FlatTreeItem::Type::Item)
            return false;
 
        const auto& source = fti->Index_;
        return SourceModel_->setData (source.sibling (source.row (), index.column ()), value, role);
    }
 
    QModelIndex FlatToFoldersProxyModel::index (int row, int column, const QModelIndex& parent) const
    {
        if (!hasIndex (row, column, parent))
            return {};
 
        return createIndex (row, column, ToFlatOrRoot (parent).C_.at (row).get ());
    }
 
    QModelIndex FlatToFoldersProxyModel::parent (const QModelIndex& index) const
    {
        const auto parent = ToFlatOrRoot (index).Parent_;
        if (!parent || parent->Type_ == FlatTreeItem::Type::Root)
            return {};
 
        return IndexOf (*parent);
    }
 
    int FlatToFoldersProxyModel::rowCount (const QModelIndex& index) const
    {
        if (index.column () > 0)
            return 0;
 
        return ToFlatOrRoot (index).C_.size ();
    }
 
    Qt::DropActions FlatToFoldersProxyModel::supportedDropActions() const
    {
        return SourceModel_ ?
                SourceModel_->supportedDropActions () :
                QAbstractItemModel::supportedDropActions ();
    }
 
    QStringList FlatToFoldersProxyModel::mimeTypes() const
    {
        return SourceModel_ ?
                SourceModel_->mimeTypes () :
                QAbstractItemModel::mimeTypes ();
    }
 
    QMimeData* FlatToFoldersProxyModel::mimeData (const QModelIndexList& indexes) const
    {
        if (!SourceModel_)
            return QAbstractItemModel::mimeData (indexes);
 
        QModelIndexList sourceIdxs;
        for (const auto& index : indexes)
        {
            auto item = static_cast<FlatTreeItem*> (index.internalPointer ());
            switch (item->Type_)
            {
            case FlatTreeItem::Type::Item:
                sourceIdxs << MapToSource (index);
                break;
            case FlatTreeItem::Type::Folder:
                for (const auto& subItem : item->C_)
                    sourceIdxs << subItem->Index_;
                break;
            default:
                break;
            }
        }
 
        return SourceModel_->mimeData (sourceIdxs);
    }
 
    bool FlatToFoldersProxyModel::dropMimeData (const QMimeData* data, Qt::DropAction action, int, int, const QModelIndex& parent)
    {
        if (!SourceModel_)
            return false;
 
        QMimeData modified;
        for (const auto& format : data->formats ())
            modified.setData (format, data->data (format));
 
        if (parent.isValid ())
            modified.setData (Config_.DropFormat_, ToFlat (parent)->Key_.toUtf8 ());
 
        return SourceModel_->dropMimeData (&modified, action, -1, -1, QModelIndex ());
    }
 
    void FlatToFoldersProxyModel::SetSourceModel (QAbstractItemModel *model)
    {
        if (SourceModel_)
            disconnect (SourceModel_,
                    nullptr,
                    this,
                    nullptr);
 
        SourceModel_ = model;
 
        if (model)
        {
            // We don't support changing columns (yet) so don't connect
            // to columns* signals.
            // Source layout changes aren't forwarded either: the class contract
            // requires rows to move as units, which leaves nothing to show here.
            connect (model,
                    &QAbstractItemModel::headerDataChanged,
                    this,
                    &QAbstractItemModel::headerDataChanged);
            connect (model,
                    &QAbstractItemModel::dataChanged,
                    this,
                    &FlatToFoldersProxyModel::HandleDataChanged);
            connect (model,
                    &QAbstractItemModel::modelReset,
                    this,
                    &FlatToFoldersProxyModel::HandleModelReset);
            connect (model,
                    &QAbstractItemModel::rowsInserted,
                    this,
                    &FlatToFoldersProxyModel::HandleRowsInserted);
            connect (model,
                    &QAbstractItemModel::rowsAboutToBeRemoved,
                    this,
                    &FlatToFoldersProxyModel::HandleRowsAboutToBeRemoved);
        }
 
        HandleModelReset ();
    }
 
    QAbstractItemModel* FlatToFoldersProxyModel::GetSourceModel () const
    {
        return SourceModel_;
    }
 
    QModelIndex FlatToFoldersProxyModel::MapToSource (const QModelIndex& proxy) const
    {
        if (!GetSourceModel ())
            return {};
 
        if (!proxy.isValid ())
            return {};
 
        const auto item = ToFlat (proxy);
 
        if (item->Type_ != FlatTreeItem::Type::Item)
            return {};
 
        return item->Index_;
    }
 
    QList<QModelIndex> FlatToFoldersProxyModel::MapFromSource (const QModelIndex& source) const
    {
        QList<QModelIndex> result;
        for (const auto& leaf : Items_.values (QPersistentModelIndex { source }))
            result << IndexOf (*leaf);
        return result;
    }
 
    bool FlatToFoldersProxyModel::IsFolder (const QModelIndex& index) const
    {
        const auto item = ToFlat (index);
        return item && item->Type_ == FlatTreeItem::Type::Folder;
    }
 
    QList<QModelIndex> FlatToFoldersProxyModel::GetChildren (const QModelIndex& index) const
    {
        if (!IsFolder (index))
            return {};
 
        const auto& children = ToFlat (index)->C_;
        QList<QModelIndex> result;
        result.reserve (children.size ());
        for (const auto& child : children)
            result << child->Index_;
        return result;
    }
 
    QList<QVariant> FlatToFoldersProxyModel::GetChildrenData (const QModelIndex& index, int role) const
    {
        const auto& children = GetChildren (index);
 
        QList<QVariant> result;
        result.reserve (children.size ());
        for (const auto& child : children)
            result.push_back (child.data (role));
        return result;
    }
 
    QStringList FlatToFoldersProxyModel::KeysOf (const QModelIndex& index) const
    {
        auto keys = Config_.KeysOf_ (index);
        keys.removeDuplicates ();
        if (keys.isEmpty ())
            keys << QString {};
        return keys;
    }
 
    FlatTreeItem_ptr FlatToFoldersProxyModel::FindFolder (const QString& key) const
    {
        const auto& folders = Root_->C_;
        const auto pos = std::ranges::find (folders, key, &FlatTreeItem::Key_);
        return pos == folders.end () ? nullptr : *pos;
    }
 
    FlatTreeItem_ptr FlatToFoldersProxyModel::GetFolder (const QString& key)
    {
        if (const auto& folder = FindFolder (key))
            return folder;
 
        const auto row = Root_->C_.size ();
        beginInsertRows ({}, row, row);
        const auto& folder = Root_->AddFolder (key);
        endInsertRows ();
        return folder;
    }
 
    const FlatTreeItem& FlatToFoldersProxyModel::ToFlatOrRoot (const QModelIndex& idx) const
    {
        return idx.isValid () ? *ToFlat (idx) : *Root_;
    }
 
    QModelIndex FlatToFoldersProxyModel::IndexOf (const FlatTreeItem& item, int column) const
    {
        return createIndex (item.Row (), column, &item);
    }
 
    void FlatToFoldersProxyModel::AddForKey (const QString& key, const QPersistentModelIndex& pidx)
    {
        const auto& folder = GetFolder (key);
        const auto row = folder->C_.size ();
        beginInsertRows (IndexOf (*folder), row, row);
        Items_.insert (pidx, folder->AddLeaf (pidx));
        endInsertRows ();
    }
 
    void FlatToFoldersProxyModel::RemoveLeaf (const FlatTreeItem_ptr& leaf)
    {
        const auto folder = leaf->Parent_;
        const auto leafRow = leaf->Row ();
        beginRemoveRows (IndexOf (*folder), leafRow, leafRow);
        Items_.remove (leaf->Index_, leaf);
        folder->C_.removeAt (leafRow);
        endRemoveRows ();
 
        if (!folder->C_.isEmpty ())
            return;
 
        const auto folderRow = folder->Row ();
        beginRemoveRows ({}, folderRow, folderRow);
        Root_->C_.removeAt (folderRow);
        endRemoveRows ();
    }
 
    void FlatToFoldersProxyModel::UpdateLeaves (const QPersistentModelIndex& pidx, const QList<int>& roles)
    {
        auto keys = KeysOf (pidx);
        for (const auto& leaf : Items_.values (pidx))
            if (keys.removeOne (leaf->Key_))
                emit dataChanged (IndexOf (*leaf), IndexOf (*leaf, columnCount () - 1), roles);
            else
                RemoveLeaf (leaf);
 
        for (const auto& key : keys)
            AddForKey (key, pidx);
    }
 
    void FlatToFoldersProxyModel::RenameFolder (FlatTreeItem& folder, const QString& key)
    {
        folder.Key_ = key;
        for (const auto& leaf : folder.C_)
            leaf->Key_ = key;
 
        const auto& index = IndexOf (folder);
        emit dataChanged (index, index, { Qt::DisplayRole });
    }
 
    void FlatToFoldersProxyModel::ReplaceKey (const QString& old, const QStringList& newKeys)
    {
        const auto& folder = FindFolder (old);
        if (!folder)
            return;
 
        if (newKeys.size () == 1 && !FindFolder (newKeys.first ()))
        {
            RenameFolder (*folder, newKeys.first ());
            return;
        }
 
        for (const auto& leaf : auto { folder->C_ })
            UpdateLeaves (leaf->Index_, {});
    }
 
    void FlatToFoldersProxyModel::HandleDataChanged (const QModelIndex& topLeft, const QModelIndex& bottomRight, const QList<int>& roles)
    {
        for (int row = topLeft.row (); row <= bottomRight.row (); ++row)
            UpdateLeaves (topLeft.sibling (row, 0), roles);
    }
 
    void FlatToFoldersProxyModel::HandleModelReset ()
    {
        beginResetModel ();
        Items_.clear ();
        Root_->C_.clear ();
        if (SourceModel_)
            for (int i = 0, size = SourceModel_->rowCount (); i < size; ++i)
            {
                const QPersistentModelIndex pidx { SourceModel_->index (i, 0) };
                for (const auto& key : KeysOf (pidx))
                {
                    auto folder = FindFolder (key);
                    if (!folder)
                        folder = Root_->AddFolder (key);
                    Items_.insert (pidx, folder->AddLeaf (pidx));
                }
            }
        endResetModel ();
    }
 
    void FlatToFoldersProxyModel::HandleRowsInserted (const QModelIndex&, int start, int end)
    {
        for (int i = start; i <= end; ++i)
        {
            const QPersistentModelIndex pidx { SourceModel_->index (i, 0) };
            for (const auto& key : KeysOf (pidx))
                AddForKey (key, pidx);
        }
    }
 
    void FlatToFoldersProxyModel::HandleRowsAboutToBeRemoved (const QModelIndex&, int start, int end)
    {
        for (int i = start; i <= end; ++i)
            for (const auto& leaf : Items_.values (QPersistentModelIndex { SourceModel_->index (i, 0) }))
                RemoveLeaf (leaf);
    }
}