qquickabstractdialog.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 "qquickabstractdialog_p.h"
 
#include <QtCore/qloggingcategory.h>
#include <QtGui/private/qguiapplication_p.h>
#include <QtQuick/qquickitem.h>
#include <QtQuick/qquickwindow.h>
#include <QtQuickDialogs2QuickImpl/private/qquickdialogimplfactory_p.h>
 
QT_BEGIN_NAMESPACE
 
Q_LOGGING_CATEGORY(lcDialogs, "qt.quick.dialogs")
 
 
 
Q_DECLARE_LOGGING_CATEGORY(lcDialogs)
 
QQuickAbstractDialog::QQuickAbstractDialog(QQuickDialogType type, QObject *parent)
    : QObject(parent),
      m_type(type)
{
}
 
QQuickAbstractDialog::~QQuickAbstractDialog()
{
    destroy();
}
 
QPlatformDialogHelper *QQuickAbstractDialog::handle() const
{
    return m_handle.get();
}
 
QQmlListProperty<QObject> QQuickAbstractDialog::data()
{
    return QQmlListProperty<QObject>(this, &m_data);
}
 
QWindow *QQuickAbstractDialog::parentWindow() const
{
    return m_parentWindow;
}
 
void QQuickAbstractDialog::setParentWindow(QWindow *window)
{
    qCDebug(lcDialogs) << "set parent window to" << window;
    m_parentWindowExplicitlySet = bool(window);
 
    if (m_parentWindow == window)
        return;
 
    m_parentWindow = window;
    emit parentWindowChanged();
}
 
void QQuickAbstractDialog::resetParentWindow()
{
    m_parentWindowExplicitlySet = false;
 
    if (!m_parentWindow)
        return;
 
    m_parentWindow = nullptr;
    emit parentWindowChanged();
}
 
QString QQuickAbstractDialog::title() const
{
    return m_title;
}
 
void QQuickAbstractDialog::setTitle(const QString &title)
{
    if (m_title == title)
        return;
 
    m_title = title;
    emit titleChanged();
}
 
Qt::WindowFlags QQuickAbstractDialog::flags() const
{
    return m_flags;
}
 
void QQuickAbstractDialog::setFlags(Qt::WindowFlags flags)
{
    if (m_flags == flags)
        return;
 
    m_flags = flags;
    emit flagsChanged();
}
 
Qt::WindowModality QQuickAbstractDialog::modality() const
{
    return m_modality;
}
 
void QQuickAbstractDialog::setModality(Qt::WindowModality modality)
{
    if (m_modality == modality)
        return;
 
    m_modality = modality;
    emit modalityChanged();
}
 
bool QQuickAbstractDialog::isVisible() const
{
    return m_handle && m_visible;
}
 
void QQuickAbstractDialog::setVisible(bool visible)
{
    qCDebug(lcDialogs) << "setVisible called with" << visible;
 
    if (visible) {
        // Don't try to open before component completion, as we won't have a window yet,
        // and open() sets m_visible to false if it fails.
        if (!m_complete)
            m_visibleRequested = true;
        else
            open();
    } else {
        close();
    }
}
 
int QQuickAbstractDialog::result() const
{
    return m_result;
}
 
void QQuickAbstractDialog::setResult(int result)
{
    if (m_result == result)
        return;
 
    m_result = result;
    emit resultChanged();
}
 
void QQuickAbstractDialog::open()
{
    qCDebug(lcDialogs) << "open called";
    if (m_visible || !create())
        return;
 
    onShow(m_handle.get());
 
    m_visible = m_handle->show(m_flags, m_modality, windowForOpen());
    if (m_visible) {
        m_result = Rejected; // in case an accepted dialog gets re-opened, then closed
        emit visibleChanged();
    }
}
 
void QQuickAbstractDialog::close()
{
    if (!m_handle || !m_visible)
        return;
 
    onHide(m_handle.get());
    m_handle->hide();
    m_visible = false;
    if (!m_parentWindowExplicitlySet)
        m_parentWindow = nullptr;
    emit visibleChanged();
 
    if (dialogCode() == Accepted)
        emit accepted();
    else if (dialogCode() == Rejected)
        emit rejected();
}
 
void QQuickAbstractDialog::accept()
{
    done(Accepted);
}
 
void QQuickAbstractDialog::reject()
{
    done(Rejected);
}
 
void QQuickAbstractDialog::done(int result)
{
    setResult(result);
    close();
}
 
void QQuickAbstractDialog::classBegin()
{
}
 
void QQuickAbstractDialog::componentComplete()
{
    qCDebug(lcDialogs) << "componentComplete";
    m_complete = true;
 
    if (!m_visibleRequested)
        return;
 
    m_visibleRequested = false;
 
    if (windowForOpen()) {
        open();
        return;
    }
 
    // Since visible were set to true by the user, we want the dialog to be open by default.
    // There is no guarantee that the dialog will work when it exists in a object tree that lacks a window,
    // and since qml components are sometimes instantiated before they're given a window
    // (which is the case when using QQuickView), we want to delay the call to open(), until the window is provided.
    if (const auto parentItem = findParentItem())
        connect(parentItem, &QQuickItem::windowChanged, this, &QQuickAbstractDialog::deferredOpen, Qt::SingleShotConnection);
}
 
static const char *qmlTypeName(const QObject *object)
{
    return object->metaObject()->className() + qstrlen("QQuickPlatform");
}
 
QPlatformTheme::DialogType toPlatformDialogType(QQuickDialogType quickDialogType)
{
    return quickDialogType == QQuickDialogType::FolderDialog
        ? QPlatformTheme::FileDialog : static_cast<QPlatformTheme::DialogType>(quickDialogType);
}
 
bool QQuickAbstractDialog::create()
{
    qCDebug(lcDialogs) << qmlTypeName(this) << "attempting to create dialog backend of type"
        << int(m_type) << "with parent window" << m_parentWindow;
    if (m_handle)
        return m_handle.get();
 
    qCDebug(lcDialogs) << "- attempting to create a native dialog";
    if (useNativeDialog()) {
        m_handle.reset(QGuiApplicationPrivate::platformTheme()->createPlatformDialogHelper(
            toPlatformDialogType(m_type)));
    }
 
    if (!m_handle) {
        qCDebug(lcDialogs) << "- attempting to create a quick dialog";
        m_handle = QQuickDialogImplFactory::createPlatformDialogHelper(m_type, this);
    }
 
    qCDebug(lcDialogs) << qmlTypeName(this) << "created ->" << m_handle.get();
    if (m_handle) {
        onCreate(m_handle.get());
        connect(m_handle.get(), &QPlatformDialogHelper::accept, this, &QQuickAbstractDialog::accept);
        connect(m_handle.get(), &QPlatformDialogHelper::reject, this, &QQuickAbstractDialog::reject);
    }
    return m_handle.get();
}
 
void QQuickAbstractDialog::destroy()
{
    m_handle.reset();
}
 
bool QQuickAbstractDialog::useNativeDialog() const
{
    if (QCoreApplication::testAttribute(Qt::AA_DontUseNativeDialogs)) {
        qCDebug(lcDialogs) << "  - Qt::AA_DontUseNativeDialogs was set; not using native dialog";
        return false;
    }
 
    if (!QGuiApplicationPrivate::platformTheme()->usePlatformNativeDialog(toPlatformDialogType(m_type))) {
        qCDebug(lcDialogs) << "  - the platform theme told us a native dialog isn't available; not using native dialog";
        return false;
    }
 
    return true;
}
 
void QQuickAbstractDialog::onCreate(QPlatformDialogHelper *dialog)
{
    Q_UNUSED(dialog);
}
 
void QQuickAbstractDialog::onShow(QPlatformDialogHelper *dialog)
{
    Q_UNUSED(dialog);
    m_firstShow = false;
}
 
void QQuickAbstractDialog::onHide(QPlatformDialogHelper *dialog)
{
    Q_UNUSED(dialog);
}
 
int QQuickAbstractDialog::dialogCode() const { return m_result; }
 
QQuickItem *QQuickAbstractDialog::findParentItem() const
{
    QObject *obj = parent();
    while (obj) {
        QQuickItem *item = qobject_cast<QQuickItem *>(obj);
        if (item)
            return item;
        obj = obj->parent();
    }
    return nullptr;
}
 
QWindow *QQuickAbstractDialog::windowForOpen() const
{
    if (m_parentWindowExplicitlySet)
        return m_parentWindow;
    else if (auto parentItem = findParentItem())
        return parentItem->window();
    return m_parentWindow;
}
 
void QQuickAbstractDialog::deferredOpen(QWindow *window)
{
    m_parentWindow = window;
    open();
}
 
QT_END_NAMESPACE
 
#include "moc_qquickabstractdialog_p.cpp"