qquicktreeviewdelegate.cpp

Go to the documentation of this file.

// Copyright (C) 2021 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 "qquicktreeviewdelegate_p.h"
 
#include <QtQuickTemplates2/private/qquickitemdelegate_p_p.h>
#include <QtQuick/private/qquicktaphandler_p.h>
#include <QtQuick/private/qquicktreeview_p_p.h>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::Literals::StringLiterals;
 
class QQuickTreeViewDelegatePrivate : public QQuickItemDelegatePrivate
{
public:
    Q_DECLARE_PUBLIC(QQuickTreeViewDelegate)
 
    void updateIndicatorVisibility();
    void updateIndicatorPointerHandlers();
    void toggleExpanded();
    QPalette defaultPalette() const override;
 
public:
    QPointer<QQuickTreeView> m_treeView;
    QPointer<QQuickTapHandler> m_tapHandlerOnIndicator;
    qreal m_indentation = 18;
    qreal m_leftMargin = 0;
    qreal m_rightMargin = 0;
    bool m_isTreeNode = false;
    bool m_expanded = false;
    bool m_current = false;
    bool m_selected = false;
    bool m_editing = false;
    bool m_hasChildren = false;
    bool m_pressOnTopOfIndicator = false;
    int m_depth = 0;
};
 
void QQuickTreeViewDelegatePrivate::toggleExpanded()
{
    Q_Q(QQuickTreeViewDelegate);
 
    auto view = q->treeView();
    if (!view)
        return;
    if (!view->pointerNavigationEnabled())
        return;
 
    const int row = qmlContext(q)->contextProperty(u"row"_s).toInt();
    view->toggleExpanded(row);
}
 
void QQuickTreeViewDelegatePrivate::updateIndicatorPointerHandlers()
{
    Q_Q(QQuickTreeViewDelegate);
 
    // Remove the tap handler that was installed
    // on the previous indicator
    delete m_tapHandlerOnIndicator.data();
 
    auto indicator = q->indicator();
    if (!indicator)
        return;
 
    m_tapHandlerOnIndicator = new QQuickTapHandler(indicator);
    m_tapHandlerOnIndicator->setAcceptedModifiers(Qt::NoModifier);
    // Work-around to block taps from passing through to TreeView.
    m_tapHandlerOnIndicator->setGesturePolicy(QQuickTapHandler::ReleaseWithinBounds);
    connect(m_tapHandlerOnIndicator, &QQuickTapHandler::tapped, this, &QQuickTreeViewDelegatePrivate::toggleExpanded);
}
 
void QQuickTreeViewDelegatePrivate::updateIndicatorVisibility()
{
    Q_Q(QQuickTreeViewDelegate);
 
    if (auto indicator = q_func()->indicator()) {
        const bool insideDelegateBounds = indicator->x() + indicator->width() < q->width();
        indicator->setVisible(m_isTreeNode && m_hasChildren && insideDelegateBounds);
    }
}
 
QQuickTreeViewDelegate::QQuickTreeViewDelegate(QQuickItem *parent)
    : QQuickItemDelegate(*(new QQuickTreeViewDelegatePrivate), parent)
{
    Q_D(QQuickTreeViewDelegate);
 
    auto tapHandler = new QQuickTapHandler(this);
    tapHandler->setAcceptedModifiers(Qt::NoModifier);
    QObjectPrivate::connect(this, &QQuickAbstractButton::indicatorChanged, d, &QQuickTreeViewDelegatePrivate::updateIndicatorPointerHandlers);
 
    // Since we override mousePressEvent to avoid QQuickAbstractButton from blocking
    // pointer handlers, we inform the button about its pressed state from the tap
    // handler instead. This will ensure that we emit button signals like
    // pressed, clicked, and doubleClicked.
    connect(tapHandler, &QQuickTapHandler::pressedChanged, [this, d, tapHandler] {
        auto view = treeView();
        if (view && !view->pointerNavigationEnabled())
            return;
 
        const QQuickHandlerPoint p = tapHandler->point();
        if (tapHandler->isPressed())
            d->handlePress(p.position(), 0);
        else if (tapHandler->tapCount() > 0)
            d->handleRelease(p.position(), 0);
        else
            d->handleUngrab();
 
        if (tapHandler->tapCount() > 1 && !tapHandler->isPressed())
            emit doubleClicked();
    });
}
 
void QQuickTreeViewDelegate::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
{
    Q_D(QQuickTreeViewDelegate);
 
    QQuickItemDelegate::geometryChange(newGeometry, oldGeometry);
    d->updateIndicatorVisibility();
}
 
void QQuickTreeViewDelegate::mousePressEvent(QMouseEvent *event)
{
    Q_D(QQuickTreeViewDelegate);
 
    const auto view = d->m_treeView;
    if (view && view->pointerNavigationEnabled()) {
        // Ignore mouse events so that we don't block our own pointer handlers, or
        // pointer handlers in e.g TreeView, TableView, or SelectionRectangle. Instead
        // we call out to the needed mouse handling functions in QAbstractButton directly
        // from our pointer handlers, to ensure that continue to work as a button.
        event->ignore();
        return;
    }
 
    QQuickItemDelegate::mousePressEvent(event);
}
 
QPalette QQuickTreeViewDelegatePrivate::defaultPalette() const
{
    return QQuickTheme::palette(QQuickTheme::ItemView);
}
 
QFont QQuickTreeViewDelegate::defaultFont() const
{
    return QQuickTheme::font(QQuickTheme::ItemView);
}
 
qreal QQuickTreeViewDelegate::indentation() const
{
    return d_func()->m_indentation;
}
 
void QQuickTreeViewDelegate::setIndentation(qreal indentation)
{
    Q_D(QQuickTreeViewDelegate);
    if (qFuzzyCompare(d->m_indentation, indentation))
        return;
 
    d->m_indentation = indentation;
    emit indentationChanged();
}
 
bool QQuickTreeViewDelegate::isTreeNode() const
{
    return d_func()->m_isTreeNode;
}
 
void QQuickTreeViewDelegate::setIsTreeNode(bool isTreeNode)
{
    Q_D(QQuickTreeViewDelegate);
    if (d->m_isTreeNode == isTreeNode)
        return;
 
    d->m_isTreeNode = isTreeNode;
    d->updateIndicatorVisibility();
    emit isTreeNodeChanged();
}
 
bool QQuickTreeViewDelegate::hasChildren() const
{
    return d_func()->m_hasChildren;
}
 
void QQuickTreeViewDelegate::setHasChildren(bool hasChildren)
{
    Q_D(QQuickTreeViewDelegate);
    if (d->m_hasChildren == hasChildren)
        return;
 
    d->m_hasChildren = hasChildren;
    d->updateIndicatorVisibility();
    emit hasChildrenChanged();
}
 
bool QQuickTreeViewDelegate::expanded() const
{
    return d_func()->m_expanded;
}
 
void QQuickTreeViewDelegate::setExpanded(bool expanded)
{
    Q_D(QQuickTreeViewDelegate);
    if (d->m_expanded == expanded)
        return;
 
    d->m_expanded = expanded;
    emit expandedChanged();
}
 
bool QQuickTreeViewDelegate::current() const
{
    return d_func()->m_current;
}
 
void QQuickTreeViewDelegate::setCurrent(bool current)
{
    Q_D(QQuickTreeViewDelegate);
    if (d->m_current == current)
        return;
 
    d->m_current = current;
    emit currentChanged();
}
 
bool QQuickTreeViewDelegate::selected() const
{
    return d_func()->m_selected;
}
 
void QQuickTreeViewDelegate::setSelected(bool selected)
{
    Q_D(QQuickTreeViewDelegate);
    if (d->m_selected == selected)
        return;
 
    d->m_selected = selected;
    emit selectedChanged();
}
 
bool QQuickTreeViewDelegate::editing() const
{
    return d_func()->m_editing;
}
 
void QQuickTreeViewDelegate::setEditing(bool editing)
{
    Q_D(QQuickTreeViewDelegate);
    if (d->m_editing == editing)
        return;
 
    d->m_editing = editing;
    emit editingChanged();
}
 
int QQuickTreeViewDelegate::depth() const
{
    return d_func()->m_depth;
}
 
void QQuickTreeViewDelegate::setDepth(int depth)
{
    Q_D(QQuickTreeViewDelegate);
    if (d->m_depth == depth)
        return;
 
    d->m_depth = depth;
    emit depthChanged();
}
 
QQuickTreeView *QQuickTreeViewDelegate::treeView() const
{
    return d_func()->m_treeView;
}
 
void QQuickTreeViewDelegate::setTreeView(QQuickTreeView *treeView)
{
    Q_D(QQuickTreeViewDelegate);
    if (d->m_treeView == treeView)
        return;
 
    d->m_treeView = treeView;
    emit treeviewChanged();
}
 
void QQuickTreeViewDelegate::componentComplete()
{
    Q_D(QQuickTreeViewDelegate);
    QQuickItemDelegate::componentComplete();
    d->updateIndicatorVisibility();
    d->updateIndicatorPointerHandlers();
}
 
qreal QQuickTreeViewDelegate::leftMargin() const
{
    return d_func()->m_leftMargin;
}
 
void QQuickTreeViewDelegate::setLeftMargin(qreal leftMargin)
{
    Q_D(QQuickTreeViewDelegate);
    if (qFuzzyCompare(d->m_leftMargin, leftMargin))
        return;
 
    d->m_leftMargin = leftMargin;
    emit leftMarginChanged();
}
 
qreal QQuickTreeViewDelegate::rightMargin() const
{
    return d_func()->m_rightMargin;
}
 
void QQuickTreeViewDelegate::setRightMargin(qreal rightMargin)
{
    Q_D(QQuickTreeViewDelegate);
    if (qFuzzyCompare(d->m_rightMargin, rightMargin))
        return;
 
    d->m_rightMargin = rightMargin;
    emit rightMarginChanged();
}
 
QT_END_NAMESPACE
 
#include "moc_qquicktreeviewdelegate_p.cpp"