btmenuview.cpp

Go to the documentation of this file.

/*********
*
* In the name of the Father, and of the Son, and of the Holy Spirit.
*
* This file is part of BibleTime's source code, https://bibletime.info/
*
* Copyright 1999-2025 by the BibleTime developers.
* The BibleTime source code is licensed under the GNU General Public License
* version 2.0.
*
**********/
 
#include "btmenuview.h"
 
#include <QAbstractItemModel>
#include <QAction>
#include <QActionGroup>
#include <QCoreApplication>
#include <QEvent>
#include <QIcon>
#include <QModelIndex>
#include <QPersistentModelIndex>
#include <QVariant>
#include <Qt>
#include "../util/btassert.h"
#include "../util/btconnect.h"
 
 
namespace {
 
char const persistentIndexPropertyName[] = "BtMenuView persistent index";
constexpr auto const rebuildEventType = QEvent::User;
 
} // anonymous namespace
namespace  {…}
 
BtMenuView::BtMenuView(QWidget * parent)
    : BtMenuView(QString(), parent)
{}
BtMenuView::BtMenuView(QWidget * parent) {…}
 
BtMenuView::BtMenuView(QString const & title, QWidget * parent)
    : QMenu(title, parent)
    , m_model(nullptr)
    , m_actions(nullptr)
{}
BtMenuView::BtMenuView(QString const & title, QWidget * parent) {…}
 
BtMenuView::~BtMenuView() {
    delete m_actions;
}
BtMenuView::~BtMenuView() {…}
 
void BtMenuView::setModel(QAbstractItemModel *model) {
    if (m_model)
        m_model->disconnect(this);
    m_model = model;
    rebuildMenu();
    if (model) {
        /* Instead of connecting each signal to rebuildMenu() directly, we
           instead queue events to this BtMenuView instance. The multiple
           "rebuild" events can be merged by the event handler to avoid
           consecutive rebuild events from causing needless rebuilds. */
        auto const triggerRebuild =
                [this] {
                    QCoreApplication::postEvent(this,
                                                new QEvent(rebuildEventType),
                                                Qt::HighEventPriority);
                };
        BT_CONNECT(model, &QAbstractItemModel::dataChanged, triggerRebuild);
        BT_CONNECT(model, &QAbstractItemModel::layoutChanged, triggerRebuild);
        BT_CONNECT(model, &QAbstractItemModel::modelReset, triggerRebuild);
        BT_CONNECT(model, &QAbstractItemModel::rowsInserted, triggerRebuild);
        BT_CONNECT(model, &QAbstractItemModel::rowsMoved, triggerRebuild);
        BT_CONNECT(model, &QAbstractItemModel::rowsRemoved, triggerRebuild);
    }
}
void BtMenuView::setModel(QAbstractItemModel *model) {…}
 
bool BtMenuView::event(QEvent * const e) {
    if (e->type() == rebuildEventType) {
        e->accept();
        QCoreApplication::removePostedEvents(this, rebuildEventType);
        rebuildMenu();
        return true;
    }
    return QMenu::event(e);
}
bool BtMenuView::event(QEvent * const e) {…}
 
void BtMenuView::preBuildMenu(QActionGroup *) {
    // Intentionally empty. Reimplement in subclass if needed.
}
void BtMenuView::preBuildMenu(QActionGroup *) {…}
 
void BtMenuView::postBuildMenu(QActionGroup *) {
    // Intentionally empty. Reimplement in subclass if needed.
}
void BtMenuView::postBuildMenu(QActionGroup *) {…}
 
QAction *BtMenuView::newAction(QMenu *parentMenu, const QModelIndex &itemIndex) {
    QVariant displayData(m_model->data(itemIndex, Qt::DisplayRole));
    QVariant iconData(m_model->data(itemIndex, Qt::DecorationRole));
    QVariant toolTipData(m_model->data(itemIndex, Qt::ToolTipRole));
    QVariant statusTipData(m_model->data(itemIndex, Qt::StatusTipRole));
    QVariant whatsThisData(m_model->data(itemIndex, Qt::WhatsThisRole));
 
    QAction *childAction = new QAction(parentMenu);
 
    // Set text:
    if (displayData.canConvert<QString>()) {
        childAction->setText(displayData.toString());
    }
 
    // Set icon:
    if (iconData.canConvert<QIcon>()) {
        childAction->setIcon(iconData.value<QIcon>());
    }
 
    // Set tooltip:
    if (toolTipData.canConvert<QString>()) {
        childAction->setToolTip(toolTipData.toString());
    }
 
    // Set status tip:
    if (statusTipData.canConvert<QString>()) {
        childAction->setStatusTip(statusTipData.toString());
    }
 
    // Set whatsthis:
    if (whatsThisData.canConvert<QString>()) {
        childAction->setWhatsThis(whatsThisData.toString());
    }
 
    // Set checkable:
    if (m_model->flags(itemIndex).testFlag(Qt::ItemIsUserCheckable)) {
        childAction->setCheckable(true);
    }
 
    // Set checked:
    QVariant checkData(m_model->data(itemIndex, Qt::CheckStateRole));
    bool ok;
    Qt::CheckState const state =
            static_cast<Qt::CheckState>(checkData.toInt(&ok));
    if (ok)
        childAction->setChecked(state == Qt::Checked);
 
    return childAction;
}
QAction *BtMenuView::newAction(QMenu *parentMenu, const QModelIndex &itemIndex) {…}
 
QMenu *BtMenuView::newMenu(QMenu *parentMenu, const QModelIndex &itemIndex) {
    QVariant displayData(m_model->data(itemIndex, Qt::DisplayRole));
    QVariant iconData(m_model->data(itemIndex, Qt::DecorationRole));
    QVariant toolTipData(m_model->data(itemIndex, Qt::ToolTipRole));
    QVariant statusTipData(m_model->data(itemIndex, Qt::StatusTipRole));
    QVariant whatsThisData(m_model->data(itemIndex, Qt::WhatsThisRole));
 
    QMenu *childMenu = new QMenu(parentMenu);
 
    // Set text:
    if (displayData.canConvert<QString>()) {
        childMenu->setTitle(displayData.toString());
    }
 
    // Set icon:
    if (iconData.canConvert<QIcon>()) {
        childMenu->setIcon(iconData.value<QIcon>());
    }
 
    // Set tooltip:
    if (toolTipData.canConvert<QString>()) {
        childMenu->setToolTip(toolTipData.toString());
    }
 
    // Set status tip:
    if (statusTipData.canConvert<QString>()) {
        childMenu->setStatusTip(statusTipData.toString());
    }
 
    // Set whatsthis:
    if (whatsThisData.canConvert<QString>()) {
        childMenu->setWhatsThis(whatsThisData.toString());
    }
 
    return childMenu;
}
QMenu *BtMenuView::newMenu(QMenu *parentMenu, const QModelIndex &itemIndex) {…}
 
void BtMenuView::rebuildMenu() {
    removeMenus();
 
    delete m_actions;
    m_actions = m_model ? new QActionGroup(this) : nullptr;
 
    preBuildMenu(m_actions);
    if (m_model)
        buildMenu(this, QModelIndex());
    postBuildMenu(m_actions);
 
    if (m_actions)
        BT_CONNECT(m_actions, &QActionGroup::triggered,
                   [this](QAction * const action){
                        auto const indexProperty =
                                action->property(persistentIndexPropertyName);
                        if (!indexProperty.isValid())
                            return;
                        Q_EMIT triggered(
                                    indexProperty.toPersistentModelIndex());
                    });
}
void BtMenuView::rebuildMenu() {…}
 
void BtMenuView::buildMenu(QMenu *parentMenu, const QModelIndex &parentIndex) {
    BT_ASSERT(m_model);
    BT_ASSERT(m_actions);
 
    int children = m_model->rowCount(parentIndex);
    for (int i = 0; i < children; i++) {
        QModelIndex childIndex(m_model->index(i, 0, parentIndex));
 
        if (m_model->rowCount(childIndex) > 0) {
            QMenu *childMenu = newMenu(parentMenu, childIndex);
 
            if (childMenu != nullptr) {
                // Add the child menu and populate it:
                parentMenu->addMenu(childMenu);
                buildMenu(childMenu, childIndex);
            }
        } else {
            QAction *childAction = newAction(parentMenu, childIndex);
 
            if (childAction != nullptr) {
 
                // Add action to action group:
                childAction->setActionGroup(m_actions);
 
                // Add action to menu:
                parentMenu->addAction(childAction);
 
                // Pass persistent model index for handling of triggered():
                childAction->setProperty(persistentIndexPropertyName,
                                         QPersistentModelIndex(childIndex));
            }
        }
    }
}
void BtMenuView::buildMenu(QMenu *parentMenu, const QModelIndex &parentIndex) {…}
void BtMenuView::removeMenus() {
    // QMenu::clear() is documented only to delete direct child actions:
    clear();
 
    // Delete submenus also:
    for (auto * const childMenu
         : findChildren<QMenu *>(QString(), Qt::FindDirectChildrenOnly))
        childMenu->deleteLater();
}
void BtMenuView::removeMenus() {…}