qquicktooltip.cpp

Go to the documentation of this file.

// Copyright (C) 2017 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 "qquicktooltip_p.h"
#include "qquickpopup_p_p.h"
#include "qquickpopupitem_p_p.h"
#include "qquickcontrol_p_p.h"
 
#include <QtCore/qbasictimer.h>
#include <QtQml/qqmlinfo.h>
#include <QtQml/qqmlengine.h>
#include <QtQml/qqmlcontext.h>
#include <QtQml/qqmlcomponent.h>
#include <QtQuick/qquickwindow.h>
 
QT_BEGIN_NAMESPACE
 
 
class QQuickToolTipPrivate : public QQuickPopupPrivate
{
    Q_DECLARE_PUBLIC(QQuickToolTip)
 
public:
    void startDelay();
    void stopDelay();
 
    void startTimeout();
    void stopTimeout();
 
    void opened() override;
 
    QPalette defaultPalette() const override { return QQuickTheme::palette(QQuickTheme::ToolTip); }
 
    int delay = 0;
    int timeout = -1;
    QString text;
    QBasicTimer delayTimer;
    QBasicTimer timeoutTimer;
};
 
void QQuickToolTipPrivate::startDelay()
{
    Q_Q(QQuickToolTip);
    if (delay > 0)
        delayTimer.start(delay, q);
}
 
void QQuickToolTipPrivate::stopDelay()
{
    delayTimer.stop();
}
 
void QQuickToolTipPrivate::startTimeout()
{
    Q_Q(QQuickToolTip);
    if (timeout > 0)
        timeoutTimer.start(timeout, q);
}
 
void QQuickToolTipPrivate::stopTimeout()
{
    timeoutTimer.stop();
}
 
void QQuickToolTipPrivate::opened()
{
    QQuickPopupPrivate::opened();
    startTimeout();
}
 
QQuickToolTip::QQuickToolTip(QQuickItem *parent)
    : QQuickPopup(*(new QQuickToolTipPrivate), parent)
{
    Q_D(QQuickToolTip);
    d->allowVerticalFlip = true;
    d->allowHorizontalFlip = true;
    d->popupItem->setHoverEnabled(false); // QTBUG-63644
}
 
QString QQuickToolTip::text() const
{
    Q_D(const QQuickToolTip);
    return d->text;
}
 
void QQuickToolTip::setText(const QString &text)
{
    Q_D(QQuickToolTip);
    if (d->text == text)
        return;
 
    d->text = text;
    maybeSetAccessibleName(text);
    emit textChanged();
}
 
int QQuickToolTip::delay() const
{
    Q_D(const QQuickToolTip);
    return d->delay;
}
 
void QQuickToolTip::setDelay(int delay)
{
    Q_D(QQuickToolTip);
    if (d->delay == delay)
        return;
 
    d->delay = delay;
    emit delayChanged();
}
 
int QQuickToolTip::timeout() const
{
    Q_D(const QQuickToolTip);
    return d->timeout;
}
 
void QQuickToolTip::setTimeout(int timeout)
{
    Q_D(QQuickToolTip);
    if (d->timeout == timeout)
        return;
 
    d->timeout = timeout;
 
    if (timeout <= 0)
        d->stopTimeout();
    else if (isOpened())
        d->startTimeout();
 
    emit timeoutChanged();
}
 
void QQuickToolTip::setVisible(bool visible)
{
    Q_D(QQuickToolTip);
    if (visible) {
        if (!d->visible) {
            // We are being made visible, and we weren't before.
            if (d->delay > 0) {
                d->startDelay();
                return;
            }
        }
    } else {
        d->stopDelay();
    }
    QQuickPopup::setVisible(visible);
}
 
QQuickToolTipAttached *QQuickToolTip::qmlAttachedProperties(QObject *object)
{
    QQuickItem *item = qobject_cast<QQuickItem *>(object);
    if (!item)
        qmlWarning(object) << "ToolTip must be attached to an Item";
 
    return new QQuickToolTipAttached(object);
}
 
void QQuickToolTip::show(const QString &text, int ms)
{
    if (ms >= 0)
        setTimeout(ms);
    setText(text);
    open();
}
 
void QQuickToolTip::hide()
{
    close();
}
 
QFont QQuickToolTip::defaultFont() const
{
    return QQuickTheme::font(QQuickTheme::ToolTip);
}
 
void QQuickToolTip::itemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &data)
{
    Q_D(QQuickToolTip);
    QQuickPopup::itemChange(change, data);
    if (change == QQuickItem::ItemVisibleHasChanged) {
        if (!data.boolValue)
            d->stopTimeout();
 
        QQuickToolTipAttached *attached = qobject_cast<QQuickToolTipAttached *>(qmlAttachedPropertiesObject<QQuickToolTip>(d->parentItem, false));
        if (attached)
            emit attached->visibleChanged();
    }
}
 
void QQuickToolTip::timerEvent(QTimerEvent *event)
{
    Q_D(QQuickToolTip);
    if (event->timerId() == d->timeoutTimer.timerId()) {
        d->stopTimeout();
        QQuickPopup::setVisible(false);
        return;
    }
    if (event->timerId() == d->delayTimer.timerId()) {
        d->stopDelay();
        QQuickPopup::setVisible(true);
        return;
    }
    QQuickPopup::timerEvent(event);
}
 
#if QT_CONFIG(accessibility)
QAccessible::Role QQuickToolTip::accessibleRole() const
{
    return QAccessible::ToolTip;
}
 
void QQuickToolTip::accessibilityActiveChanged(bool active)
{
    Q_D(QQuickToolTip);
    QQuickPopup::accessibilityActiveChanged(active);
 
    if (active)
        maybeSetAccessibleName(d->text);
}
#endif
 
class QQuickToolTipAttachedPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QQuickToolTipAttached)
 
public:
    QQuickToolTip *instance(bool create) const;
 
    int delay = 0;
    int timeout = -1;
    QString text;
};
 
QQuickToolTip *QQuickToolTipAttachedPrivate::instance(bool create) const
{
    QQmlEngine *engine = qmlEngine(parent);
    if (!engine)
        return nullptr;
 
    static const char *name = "_q_QQuickToolTip";
 
    QQuickToolTip *tip = engine->property(name).value<QQuickToolTip *>();
    if (!tip && create) {
        // TODO: a cleaner way to create the instance? QQml(Meta)Type?
        QQmlComponent component(engine);
        component.setData("import QtQuick.Controls; ToolTip { }", QUrl());
 
        QObject *object = component.create();
        if (object)
            object->setParent(engine);
 
        tip = qobject_cast<QQuickToolTip *>(object);
        if (!tip)
            delete object;
        else
            engine->setProperty(name, QVariant::fromValue(object));
    }
    return tip;
}
 
QQuickToolTipAttached::QQuickToolTipAttached(QObject *parent)
    : QObject(*(new QQuickToolTipAttachedPrivate), parent)
{
}
 
QString QQuickToolTipAttached::text() const
{
    Q_D(const QQuickToolTipAttached);
    return d->text;
}
 
void QQuickToolTipAttached::setText(const QString &text)
{
    Q_D(QQuickToolTipAttached);
    if (d->text == text)
        return;
 
    d->text = text;
    emit textChanged();
 
    if (isVisible())
        d->instance(true)->setText(text);
}
 
int QQuickToolTipAttached::delay() const
{
    Q_D(const QQuickToolTipAttached);
    return d->delay;
}
 
void QQuickToolTipAttached::setDelay(int delay)
{
    Q_D(QQuickToolTipAttached);
    if (d->delay == delay)
        return;
 
    d->delay = delay;
    emit delayChanged();
 
    if (isVisible())
        d->instance(true)->setDelay(delay);
}
 
int QQuickToolTipAttached::timeout() const
{
    Q_D(const QQuickToolTipAttached);
    return d->timeout;
}
 
void QQuickToolTipAttached::setTimeout(int timeout)
{
    Q_D(QQuickToolTipAttached);
    if (d->timeout == timeout)
        return;
 
    d->timeout = timeout;
    emit timeoutChanged();
 
    if (isVisible())
        d->instance(true)->setTimeout(timeout);
}
 
bool QQuickToolTipAttached::isVisible() const
{
    Q_D(const QQuickToolTipAttached);
    QQuickToolTip *tip = d->instance(false);
    if (!tip)
        return false;
 
    return tip->isVisible() && tip->parentItem() == parent();
}
 
void QQuickToolTipAttached::setVisible(bool visible)
{
    Q_D(QQuickToolTipAttached);
    if (visible)
        show(d->text);
    else
        hide();
}
 
QQuickToolTip *QQuickToolTipAttached::toolTip() const
{
    Q_D(const QQuickToolTipAttached);
    return d->instance(true);
}
 
void QQuickToolTipAttached::show(const QString &text, int ms)
{
    Q_D(QQuickToolTipAttached);
    QQuickToolTip *tip = d->instance(true);
    if (!tip)
        return;
 
    tip->resetWidth();
    tip->resetHeight();
    tip->setParentItem(qobject_cast<QQuickItem *>(parent()));
    tip->setDelay(d->delay);
    tip->setTimeout(ms >= 0 ? ms : d->timeout);
    tip->show(text);
}
 
void QQuickToolTipAttached::hide()
{
    Q_D(QQuickToolTipAttached);
    QQuickToolTip *tip = d->instance(false);
    if (!tip)
        return;
    // check the parent item to prevent unexpectedly closing tooltip by new created invisible tooltip
    if (parent() == tip->parentItem())
        tip->close();
}
 
QT_END_NAMESPACE
 
#include "moc_qquicktooltip_p.cpp"