path: root/lib/bookmarks/bookmarksmodel.cpp

/*
 * This file is part of smolbote. It's copyrighted by the contributors recorded
 * in the version control history of the file, available from its original
 * location: https://neueland.iserlohn-fortress.net/smolbote.hg
 *
 * SPDX-License-Identifier: GPL-3.0
 */

#include "bookmarksmodel.h"

BookmarksModel::BookmarksModel(QStyle *style, QObject *parent)
    : QAbstractItemModel(parent)
{
    folderIcon.addPixmap(style->standardPixmap(QStyle::SP_DirOpenIcon), QIcon::Normal, QIcon::On);
    folderIcon.addPixmap(style->standardPixmap(QStyle::SP_DirClosedIcon), QIcon::Normal, QIcon::Off);
    bookmarkIcon.addPixmap(style->standardPixmap(QStyle::SP_FileIcon));

    // create a root item
    m_rootItem = new BookmarkItem(BookmarkItem::Root, nullptr);
    m_rootItem->title = tr("Title");
    m_rootItem->href = tr("href");
}

BookmarksModel::~BookmarksModel()
{
    delete m_rootItem;
}

bool BookmarksModel::isModified() const
{
    return modified;
}

bool BookmarksModel::read(Xbel *xbel)
{
    Q_CHECK_PTR(xbel);
    // if there are items in the bookmark list, we're adding to them, so the model becomes modified
    if(m_rootItem->childCount() != 0) {
        modified = true;
    }
    return xbel->read(m_rootItem);
}

bool BookmarksModel::write(Xbel *xbel)
{
    Q_CHECK_PTR(xbel);
    return xbel->write(m_rootItem);
}

QVariant BookmarksModel::headerData(int section, Qt::Orientation orientation, int role) const
{
    if(orientation == Qt::Horizontal && role == Qt::DisplayRole) {
        if(section == 0) {
            return m_rootItem->title;
        } else if(section == 1) {
            return m_rootItem->href;
        } else {
            return QVariant();
        }
    }

    return QVariant();
}

QModelIndex BookmarksModel::index(BookmarkItem *node, int column) const
{
    BookmarkItem *parentItem = node->parentItem();
    if(!parentItem) {
        return QModelIndex();
    }

    return createIndex(parentItem->childIndex(node), column, node);
}

QModelIndex BookmarksModel::index(int row, int column, const QModelIndex &parent) const
{
    // invalid item requested
    if(!hasIndex(row, column, parent)) {
        return QModelIndex();
    }

    // index exists
    BookmarkItem *parentItem;
    if(parent.isValid()) {
        parentItem = static_cast<BookmarkItem *>(parent.internalPointer());
    } else {
        parentItem = m_rootItem;
    }

    BookmarkItem *childItem = parentItem->child(row);
    if(childItem) {
        return createIndex(row, column, childItem);
    }
    return QModelIndex();
}

QModelIndex BookmarksModel::parent(const QModelIndex &index) const
{
    if(!index.isValid()) {
        return QModelIndex();
    }

    BookmarkItem *childItem = static_cast<BookmarkItem *>(index.internalPointer());
    BookmarkItem *parentItem = childItem->parentItem();

    if(parentItem == m_rootItem) {
        return QModelIndex();
    }

    return createIndex(parentItem->row(), 0, parentItem);
}

int BookmarksModel::rowCount(const QModelIndex &parent) const
{
    if(parent.column() > 0) {
        return 0;
    }

    BookmarkItem *parentItem;
    if(!parent.isValid()) {
        parentItem = m_rootItem;
    } else {
        parentItem = static_cast<BookmarkItem *>(parent.internalPointer());
    }

    return parentItem->childCount();
}

QModelIndex BookmarksModel::insertItem(BookmarkItem::BookmarkItemType type, const QModelIndex &parent)
{
    BookmarkItem *parentItem;
    if(!parent.isValid()) {
        parentItem = m_rootItem;
    } else {
        parentItem = static_cast<BookmarkItem *>(parent.internalPointer());
        if(parentItem->type() == BookmarkItem::Bookmark)
            parentItem = parentItem->parentItem();
    }

    beginInsertRows(index(parentItem), parentItem->row(), parentItem->row());
    auto *node = new BookmarkItem(type, parentItem);
    node->title = tr("title");
    node->href = tr("href");
    endInsertRows();

    return index(node);
}

int BookmarksModel::columnCount(const QModelIndex &parent) const
{
    if(parent.isValid()) {
        return static_cast<BookmarkItem *>(parent.internalPointer())->columnCount();
    } else {
        return m_rootItem->columnCount();
    }
}

Qt::ItemFlags BookmarksModel::flags(const QModelIndex &index) const
{
    if(!index.isValid())
        return Qt::NoItemFlags;

    Qt::ItemFlags flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
    auto *node = static_cast<BookmarkItem *>(index.internalPointer());
    switch(node->type()) {
    case BookmarkItem::Root:
        break;
    case BookmarkItem::Folder:
        flags |= Qt::ItemIsEditable;
        break;
    case BookmarkItem::Bookmark:
        flags |= Qt::ItemIsEnabled | Qt::ItemNeverHasChildren;
        break;
    }
    return flags;
}

QVariant BookmarksModel::data(const QModelIndex &index, int role) const
{
    // get data of invalid index?
    if(!index.isValid()) {
        return QVariant();
    }

    const BookmarkItem *item = static_cast<BookmarkItem *>(index.internalPointer());
    switch(role) {
    case Qt::DisplayRole:
    case Qt::EditRole:
        if(index.column() == 0) {
            return item->title;
        } else if(index.column() == 1) {
            return item->href;
        } else {
            return QVariant();
        }

    case Qt::DecorationRole:
        if(index.column() == 0) {
            if(item->type() == BookmarkItem::Folder) {
                return folderIcon;
            } else if(item->type() == BookmarkItem::Bookmark) {
                return bookmarkIcon;
            } else {
                return QVariant();
            }
        } else {
            return QVariant();
        }

    case OpenUrlRole:
        if(item->type() == BookmarkItem::Bookmark) {
            return item->href;
        } else {
            return QVariant();
        }

    default:
        return QVariant();
    }
}

bool BookmarksModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if(!index.isValid())
        return false;

    auto *node = static_cast<BookmarkItem *>(index.internalPointer());
    switch(node->type()) {
    case BookmarkItem::Root:
        return false;

    case BookmarkItem::Folder:
        if(index.column() == 0) {
            node->title = value.toString();
            modified = true;
            emit dataChanged(index, index);
            return true;
        }
        return false;

    case BookmarkItem::Bookmark:
        if(index.column() == 0) {
            node->title = value.toString();
            modified = true;
            emit dataChanged(index, index);
            return true;
        } else if(index.column() == 1) {
            node->href = value.toString();
            modified = true;
            emit dataChanged(index, index);
            return true;
        }
        return false;
    }
}

bool BookmarksModel::hasChildren(const QModelIndex &parent) const
{
    if(!parent.isValid()) {
        return true;
    }

    const BookmarkItem *parentItem = static_cast<BookmarkItem *>(parent.internalPointer());
    return (parentItem->type() == BookmarkItem::Folder);
}

QModelIndexList BookmarksModel::match(const QModelIndex &start, int role, const QVariant &value, int hits, Qt::MatchFlags flags) const
{
    QModelIndexList list;

    // search root
    BookmarkItem *searchRoot;
    if(!start.isValid()) {
        searchRoot = m_rootItem;
    } else {
        searchRoot = static_cast<BookmarkItem *>(start.internalPointer());
    }

    // iterate through searchRoot children
    for(int i = 0; i < searchRoot->childCount(); ++i) {
        BookmarkItem *item = searchRoot->child(i);
        if(item->type() == BookmarkItem::Bookmark) {
            if(item->href.contains(value.toString())) {
                list.append(index(item, 1));
            }
        } else if(item->type() == BookmarkItem::Folder) {
            list.append(match(index(item), role, value, hits, flags));
        }
    }

    return list;
}

void BookmarksModel::expandItems(QTreeView *view, BookmarkItem *root)
{
    if(root == nullptr)
        root = m_rootItem;

    // iterate through children
    for(int i = 0; i < root->childCount(); ++i) {
        BookmarkItem *childNode = root->child(i);

        // and if it's a folder
        if(childNode->type() == BookmarkItem::Folder) {
            QModelIndex idx = index(childNode);
            view->setExpanded(idx, !childNode->folded);

            // only folders have children, so go through them
            expandItems(view, childNode);
        }
    }
}