qdialog.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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 <QtWidgets/qtwidgetsglobal.h>
#if QT_CONFIG(colordialog)
#include "qcolordialog.h"
#endif
#if QT_CONFIG(fontdialog)
#include "qfontdialog.h"
#endif
#if QT_CONFIG(filedialog)
#include "qfiledialog.h"
#endif
 
#include "qevent.h"
#include "qapplication.h"
#include "qlayout.h"
#if QT_CONFIG(sizegrip)
#include "qsizegrip.h"
#endif
#if QT_CONFIG(whatsthis)
#include "qwhatsthis.h"
#endif
#if QT_CONFIG(menu)
#include "qmenu.h"
#endif
#include "qcursor.h"
#if QT_CONFIG(messagebox)
#include "qmessagebox.h"
#endif
#if QT_CONFIG(errormessage)
#include "qerrormessage.h"
#endif
#include <qpa/qplatformtheme.h>
#include "private/qdialog_p.h"
#include "private/qguiapplication_p.h"
#if QT_CONFIG(accessibility)
#include "qaccessible.h"
#endif
 
QT_BEGIN_NAMESPACE
 
static inline int themeDialogType(const QDialog *dialog)
{
#if QT_CONFIG(filedialog)
    if (qobject_cast<const QFileDialog *>(dialog))
        return QPlatformTheme::FileDialog;
#endif
#if QT_CONFIG(colordialog)
    if (qobject_cast<const QColorDialog *>(dialog))
        return QPlatformTheme::ColorDialog;
#endif
#if QT_CONFIG(fontdialog)
    if (qobject_cast<const QFontDialog *>(dialog))
        return QPlatformTheme::FontDialog;
#endif
#if QT_CONFIG(messagebox)
    if (qobject_cast<const QMessageBox *>(dialog))
        return QPlatformTheme::MessageDialog;
#endif
#if QT_CONFIG(errormessage)
    if (qobject_cast<const QErrorMessage *>(dialog))
        return QPlatformTheme::MessageDialog;
#endif
#if !QT_CONFIG(filedialog) && !QT_CONFIG(colordialog) && !QT_CONFIG(fontdialog) && \
    !QT_CONFIG(messagebox) && !QT_CONFIG(errormessage)
    Q_UNUSED(dialog);
#endif
    return -1;
}
 
QDialogPrivate::~QDialogPrivate()
{
    delete m_platformHelper;
}
 
QPlatformDialogHelper *QDialogPrivate::platformHelper() const
{
    // Delayed creation of the platform, ensuring that
    // that qobject_cast<> on the dialog works in the plugin.
    if (!m_platformHelperCreated && canBeNativeDialog()) {
        m_platformHelperCreated = true;
        QDialogPrivate *ncThis = const_cast<QDialogPrivate *>(this);
        QDialog *dialog = ncThis->q_func();
        const int type = themeDialogType(dialog);
        if (type >= 0) {
            m_platformHelper = QGuiApplicationPrivate::platformTheme()
                    ->createPlatformDialogHelper(static_cast<QPlatformTheme::DialogType>(type));
            if (m_platformHelper) {
                QObject::connect(m_platformHelper, SIGNAL(accept()), dialog, SLOT(accept()));
                QObject::connect(m_platformHelper, SIGNAL(reject()), dialog, SLOT(reject()));
                ncThis->initHelper(m_platformHelper);
            }
        }
    }
    return m_platformHelper;
}
 
bool QDialogPrivate::canBeNativeDialog() const
{
    if (QCoreApplication::testAttribute(Qt::AA_DontUseNativeDialogs))
        return false;
 
    QDialogPrivate *ncThis = const_cast<QDialogPrivate *>(this);
    QDialog *dialog = ncThis->q_func();
    const int type = themeDialogType(dialog);
    if (type >= 0)
        return QGuiApplicationPrivate::platformTheme()
                ->usePlatformNativeDialog(static_cast<QPlatformTheme::DialogType>(type));
    return false;
}
 
void QDialogPrivate::close(int resultCode)
{
    Q_Q(QDialog);
 
    q->setResult(resultCode);
 
    if (!data.is_closing) {
        // Until Qt 6.3 we didn't close dialogs, so they didn't receive a QCloseEvent.
        // It is likely that subclasses implement closeEvent and handle them as rejection
        // (like QMessageBox and QProgressDialog do), so eat those events.
        struct CloseEventEater : QObject
        {
            using QObject::QObject;
        protected:
            bool eventFilter(QObject *o, QEvent *e) override
            {
                if (e->type() == QEvent::Close)
                    return true;
                return QObject::eventFilter(o, e);
            }
        } closeEventEater;
        q->installEventFilter(&closeEventEater);
        QWidgetPrivate::close();
    } else {
        // If the close was initiated outside of QDialog we will end up
        // here via QDialog::closeEvent calling reject(), in which case
        // we need to hide the dialog to ensure QDialog::closeEvent does
        // not ignore the close event. FIXME: Why is QDialog doing this?
        q->hide();
    }
 
    resetModalitySetByOpen();
}
 
QWindow *QDialogPrivate::transientParentWindow() const
{
    Q_Q(const QDialog);
    if (const QWidget *parent = q->nativeParentWidget())
        return parent->windowHandle();
    else if (q->windowHandle())
        return q->windowHandle()->transientParent();
    return nullptr;
}
 
bool QDialogPrivate::setNativeDialogVisible(bool visible)
{
    if (QPlatformDialogHelper *helper = platformHelper()) {
        if (visible) {
            Q_Q(QDialog);
            helperPrepareShow(helper);
            nativeDialogInUse = helper->show(q->windowFlags(), q->windowModality(), transientParentWindow());
        } else if (nativeDialogInUse) {
            helper->hide();
        }
    }
    return nativeDialogInUse;
}
 
QVariant QDialogPrivate::styleHint(QPlatformDialogHelper::StyleHint hint) const
{
    if (const QPlatformDialogHelper *helper = platformHelper())
        return helper->styleHint(hint);
    return QPlatformDialogHelper::defaultStyleHint(hint);
}
 
QDialog::QDialog(QWidget *parent, Qt::WindowFlags f)
    : QWidget(*new QDialogPrivate, parent,
              f | ((f & Qt::WindowType_Mask) == 0 ? Qt::Dialog : Qt::WindowType(0)))
{
}
 
QDialog::QDialog(QDialogPrivate &dd, QWidget *parent, Qt::WindowFlags f)
    : QWidget(dd, parent, f | ((f & Qt::WindowType_Mask) == 0 ? Qt::Dialog : Qt::WindowType(0)))
{
}
 
QDialog::~QDialog()
{
    QT_TRY {
        // Need to hide() here, as our (to-be) overridden hide()
        // will not be called in ~QWidget.
        hide();
    } QT_CATCH(...) {
        // we're in the destructor - just swallow the exception
    }
}
 
#if QT_CONFIG(pushbutton)
void QDialogPrivate::setDefault(QPushButton *pushButton)
{
    Q_Q(QDialog);
    bool hasMain = false;
    QList<QPushButton*> list = q->findChildren<QPushButton*>();
    for (int i=0; i<list.size(); ++i) {
        QPushButton *pb = list.at(i);
        if (pb->window() == q) {
            if (pb == mainDef)
                hasMain = true;
            if (pb != pushButton)
                pb->setDefault(false);
        }
    }
    if (!pushButton && hasMain)
        mainDef->setDefault(true);
    if (!hasMain)
        mainDef = pushButton;
}
 
void QDialogPrivate::setMainDefault(QPushButton *pushButton)
{
    mainDef = nullptr;
    setDefault(pushButton);
}
 
void QDialogPrivate::hideDefault()
{
    Q_Q(QDialog);
    QList<QPushButton*> list = q->findChildren<QPushButton*>();
    for (int i=0; i<list.size(); ++i) {
        list.at(i)->setDefault(false);
    }
}
#endif
 
void QDialogPrivate::resetModalitySetByOpen()
{
    Q_Q(QDialog);
    if (resetModalityTo != -1 && !q->testAttribute(Qt::WA_SetWindowModality)) {
        // open() changed the window modality and the user didn't touch it afterwards; restore it
        q->setWindowModality(Qt::WindowModality(resetModalityTo));
        q->setAttribute(Qt::WA_SetWindowModality, wasModalitySet);
#ifdef Q_OS_MAC
        Q_ASSERT(resetModalityTo != Qt::WindowModal);
        q->setParent(q->parentWidget(), Qt::Dialog);
#endif
    }
    resetModalityTo = -1;
}
 
int QDialog::result() const
{
    Q_D(const QDialog);
    return d->rescode;
}
 
void QDialog::setResult(int r)
{
    Q_D(QDialog);
    d->rescode = r;
}
 
void QDialog::open()
{
    Q_D(QDialog);
 
    Qt::WindowModality modality = windowModality();
    if (modality != Qt::WindowModal) {
        d->resetModalityTo = modality;
        d->wasModalitySet = testAttribute(Qt::WA_SetWindowModality);
        setWindowModality(Qt::WindowModal);
        setAttribute(Qt::WA_SetWindowModality, false);
#ifdef Q_OS_MAC
        setParent(parentWidget(), Qt::Sheet);
#endif
    }
 
    setResult(0);
    show();
}
 
int QDialog::exec()
{
    Q_D(QDialog);
 
    if (Q_UNLIKELY(d->eventLoop)) {
        qWarning("QDialog::exec: Recursive call detected");
        return -1;
    }
 
    bool deleteOnClose = testAttribute(Qt::WA_DeleteOnClose);
    setAttribute(Qt::WA_DeleteOnClose, false);
 
    d->resetModalitySetByOpen();
 
    bool wasShowModal = testAttribute(Qt::WA_ShowModal);
    setAttribute(Qt::WA_ShowModal, true);
    setResult(0);
 
    show();
 
    QPointer<QDialog> guard = this;
    if (d->nativeDialogInUse) {
        d->platformHelper()->exec();
    } else {
        QEventLoop eventLoop;
        d->eventLoop = &eventLoop;
        (void) eventLoop.exec(QEventLoop::DialogExec);
    }
    if (guard.isNull())
        return QDialog::Rejected;
    d->eventLoop = nullptr;
 
    setAttribute(Qt::WA_ShowModal, wasShowModal);
 
    int res = result();
    if (d->nativeDialogInUse)
        d->helperDone(static_cast<QDialog::DialogCode>(res), d->platformHelper());
    if (deleteOnClose)
        delete this;
    return res;
}
 
void QDialog::done(int r)
{
    QPointer<QDialog> guard(this);
 
    Q_D(QDialog);
    d->close(r);
 
    if (!guard)
        return;
 
    int dialogCode = d->dialogCode();
    if (dialogCode == QDialog::Accepted)
        emit accepted();
    else if (dialogCode == QDialog::Rejected)
        emit rejected();
 
    if (guard)
        emit finished(r);
}
 
void QDialog::accept()
{
    done(Accepted);
}
 
void QDialog::reject()
{
    done(Rejected);
}
 
bool QDialog::eventFilter(QObject *o, QEvent *e)
{
    return QWidget::eventFilter(o, e);
}
 
/*****************************************************************************
  Event handlers
 *****************************************************************************/
 
#ifndef QT_NO_CONTEXTMENU
void QDialog::contextMenuEvent(QContextMenuEvent *e)
{
#if !QT_CONFIG(whatsthis) || !QT_CONFIG(menu)
    Q_UNUSED(e);
#else
    QWidget *w = childAt(e->pos());
    if (!w) {
        w = rect().contains(e->pos()) ? this : nullptr;
        if (!w)
            return;
    }
    while (w && w->whatsThis().size() == 0 && !w->testAttribute(Qt::WA_CustomWhatsThis))
        w = w->isWindow() ? nullptr : w->parentWidget();
    if (w) {
        QPointer<QMenu> p = new QMenu(this);
        QAction *wt = p.data()->addAction(tr("What's This?"));
        if (p.data()->exec(e->globalPos()) == wt) {
            QHelpEvent e(QEvent::WhatsThis, w->rect().center(),
                         w->mapToGlobal(w->rect().center()));
            QCoreApplication::sendEvent(w, &e);
        }
        delete p.data();
    }
#endif
}
#endif // QT_NO_CONTEXTMENU
 
void QDialog::keyPressEvent(QKeyEvent *e)
{
#ifndef QT_NO_SHORTCUT
    //   Calls reject() if Escape is pressed. Simulates a button
    //   click for the default button if Enter is pressed. Move focus
    //   for the arrow keys. Ignore the rest.
    if (e->matches(QKeySequence::Cancel)) {
        reject();
    } else
#endif
    if (!e->modifiers() || (e->modifiers() & Qt::KeypadModifier && e->key() == Qt::Key_Enter)) {
        switch (e->key()) {
#if QT_CONFIG(pushbutton)
        case Qt::Key_Enter:
        case Qt::Key_Return: {
            QList<QPushButton*> list = findChildren<QPushButton*>();
            for (int i=0; i<list.size(); ++i) {
                QPushButton *pb = list.at(i);
                if (pb->isDefault() && pb->isVisible()) {
                    if (pb->isEnabled())
                        pb->click();
                    return;
                }
            }
        }
        break;
#endif
        default:
            e->ignore();
            return;
        }
    } else {
        e->ignore();
    }
}
 
void QDialog::closeEvent(QCloseEvent *e)
{
#if QT_CONFIG(whatsthis)
    if (isModal() && QWhatsThis::inWhatsThisMode())
        QWhatsThis::leaveWhatsThisMode();
#endif
    if (isVisible()) {
        QPointer<QObject> that = this;
        reject();
        if (that && isVisible())
            e->ignore();
    } else {
        e->accept();
    }
}
 
/*****************************************************************************
  Geometry management.
 *****************************************************************************/
 
void QDialog::setVisible(bool visible)
{
    Q_D(QDialog);
 
    if (testAttribute(Qt::WA_WState_ExplicitShowHide) && testAttribute(Qt::WA_WState_Hidden) != visible)
        return;
 
    d->setVisible(visible);
}
 
void QDialogPrivate::setVisible(bool visible)
{
    Q_Q(QDialog);
    if (!q->testAttribute(Qt::WA_DontShowOnScreen) && canBeNativeDialog() && setNativeDialogVisible(visible))
        return;
 
    // We should not block windows by the invisible modal dialog
    // if a platform-specific dialog is implemented as an in-process
    // Qt window, because in this case it will also be blocked.
    const bool dontBlockWindows = q->testAttribute(Qt::WA_DontShowOnScreen)
            && styleHint(QPlatformDialogHelper::DialogIsQtWindow).toBool();
    Qt::WindowModality oldModality;
    bool wasModalitySet;
 
    if (dontBlockWindows) {
        oldModality = q->windowModality();
        wasModalitySet = q->testAttribute(Qt::WA_SetWindowModality);
        q->setWindowModality(Qt::NonModal);
    }
 
    if (visible) {
        q->QWidget::setVisible(visible);
 
        // Window activation might be prevented. We can't test isActiveWindow here,
        // as the window will be activated asynchronously by the window manager.
        if (!q->testAttribute(Qt::WA_ShowWithoutActivating)) {
            QWidget *fw = q->window()->focusWidget();
            if (!fw)
                fw = q;
 
            /*
            The following block is to handle a special case, and does not
            really follow proper logic in concern of autoDefault and TAB
            order. However, it's here to ease usage for the users. If a
            dialog has a default QPushButton, and first widget in the TAB
            order also is a QPushButton, then we give focus to the main
            default QPushButton. This simplifies code for the developers,
            and actually catches most cases... If not, then they simply
            have to use [widget*]->setFocus() themselves...
            */
#if QT_CONFIG(pushbutton)
            if (mainDef && fw->focusPolicy() == Qt::NoFocus) {
                QWidget *first = fw;
                while ((first = first->nextInFocusChain()) != fw && first->focusPolicy() == Qt::NoFocus)
                    ;
                if (first != mainDef && qobject_cast<QPushButton*>(first))
                    mainDef->setFocus();
            }
            if (!mainDef && q->isWindow()) {
                QWidget *w = fw;
                while ((w = w->nextInFocusChain()) != fw) {
                    QPushButton *pb = qobject_cast<QPushButton *>(w);
                    if (pb && pb->autoDefault() && pb->focusPolicy() != Qt::NoFocus) {
                        pb->setDefault(true);
                        break;
                    }
                }
            }
#endif
            if (fw && !fw->hasFocus()) {
                QFocusEvent e(QEvent::FocusIn, Qt::TabFocusReason);
                QCoreApplication::sendEvent(fw, &e);
            }
        }
 
#if QT_CONFIG(accessibility)
        QAccessibleEvent event(q, QAccessible::DialogStart);
        QAccessible::updateAccessibility(&event);
#endif
 
    } else {
 
#if QT_CONFIG(accessibility)
        if (q->isVisible()) {
            QAccessibleEvent event(q, QAccessible::DialogEnd);
            QAccessible::updateAccessibility(&event);
        }
#endif
 
        // Reimplemented to exit a modal event loop when the dialog is hidden.
        q->QWidget::setVisible(visible);
        if (eventLoop)
            eventLoop->exit();
    }
 
    if (dontBlockWindows) {
        q->setWindowModality(oldModality);
        q->setAttribute(Qt::WA_SetWindowModality, wasModalitySet);
    }
 
#if QT_CONFIG(pushbutton)
    const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme();
    if (mainDef && q->isActiveWindow()
        && theme->themeHint(QPlatformTheme::DialogSnapToDefaultButton).toBool())
        QCursor::setPos(mainDef->mapToGlobal(mainDef->rect().center()));
#endif
}
 
void QDialog::showEvent(QShowEvent *event)
{
    if (!event->spontaneous() && !testAttribute(Qt::WA_Moved)) {
        Qt::WindowStates  state = windowState();
        adjustPosition(parentWidget());
        setAttribute(Qt::WA_Moved, false); // not really an explicit position
        if (state != windowState())
            setWindowState(state);
    }
}
 
void QDialog::adjustPosition(QWidget* w)
{
    Q_D(QDialog);
 
    if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme())
        if (theme->themeHint(QPlatformTheme::WindowAutoPlacement).toBool())
            return;
    QPoint p(0, 0);
    int extraw = 0, extrah = 0;
    const QWindow *parentWindow = nullptr;
    if (w) {
        w = w->window();
    } else {
        parentWindow = d->transientParentWindow();
    }
    QRect desk;
    QScreen *scrn = nullptr;
    if (w)
        scrn = w->screen();
    else if (parentWindow)
        scrn = parentWindow->screen();
    else if (QGuiApplication::primaryScreen()->virtualSiblings().size() > 1)
        scrn = QGuiApplication::screenAt(QCursor::pos());
    else
        scrn = screen();
    if (scrn)
        desk = scrn->availableGeometry();
 
    QWidgetList list = QApplication::topLevelWidgets();
    for (int i = 0; (extraw == 0 || extrah == 0) && i < list.size(); ++i) {
        QWidget * current = list.at(i);
        if (current->isVisible()) {
            int framew = current->geometry().x() - current->x();
            int frameh = current->geometry().y() - current->y();
 
            extraw = qMax(extraw, framew);
            extrah = qMax(extrah, frameh);
        }
    }
 
    // sanity check for decoration frames. With embedding, we
    // might get extraordinary values
    if (extraw == 0 || extrah == 0 || extraw >= 10 || extrah >= 40) {
        extrah = 40;
        extraw = 10;
    }
 
 
    if (w) {
        // Use pos() if the widget is embedded into a native window
        QPoint pp;
        if (w->windowHandle() && qvariant_cast<WId>(w->windowHandle()->property("_q_embedded_native_parent_handle")))
            pp = w->pos();
        else
            pp = w->mapToGlobal(QPoint(0,0));
        p = QPoint(pp.x() + w->width()/2,
                    pp.y() + w->height()/ 2);
    } else if (parentWindow) {
        // QTBUG-63406: Widget-based dialog in QML, which has no Widget parent
        // but a transient parent window.
        QPoint pp = parentWindow->mapToGlobal(QPoint(0, 0));
        p = QPoint(pp.x() + parentWindow->width() / 2, pp.y() + parentWindow->height() / 2);
    } else {
        // p = middle of the desktop
        p = QPoint(desk.x() + desk.width()/2, desk.y() + desk.height()/2);
    }
 
    // p = origin of this
    p = QPoint(p.x()-width()/2 - extraw,
                p.y()-height()/2 - extrah);
 
 
    if (p.x() + extraw + width() > desk.x() + desk.width())
        p.setX(desk.x() + desk.width() - width() - extraw);
    if (p.x() < desk.x())
        p.setX(desk.x());
 
    if (p.y() + extrah + height() > desk.y() + desk.height())
        p.setY(desk.y() + desk.height() - height() - extrah);
    if (p.y() < desk.y())
        p.setY(desk.y());
 
    // QTBUG-52735: Manually set the correct target screen since scaling in a
    // subsequent call to QWindow::resize() may otherwise use the wrong factor
    // if the screen changed notification is still in an event queue.
    if (scrn) {
        if (QWindow *window = windowHandle())
            window->setScreen(scrn);
    }
 
    move(p);
}
 
QSize QDialog::sizeHint() const
{
    Q_D(const QDialog);
    if (d->extension) {
        if (d->orientation == Qt::Horizontal)
            return QSize(QWidget::sizeHint().width(),
                        qMax(QWidget::sizeHint().height(),d->extension->sizeHint().height()));
        else
            return QSize(qMax(QWidget::sizeHint().width(), d->extension->sizeHint().width()),
                        QWidget::sizeHint().height());
    }
    return QWidget::sizeHint();
}
 
 
QSize QDialog::minimumSizeHint() const
{
    Q_D(const QDialog);
    if (d->extension) {
        if (d->orientation == Qt::Horizontal)
            return QSize(QWidget::minimumSizeHint().width(),
                        qMax(QWidget::minimumSizeHint().height(), d->extension->minimumSizeHint().height()));
        else
            return QSize(qMax(QWidget::minimumSizeHint().width(), d->extension->minimumSizeHint().width()),
                        QWidget::minimumSizeHint().height());
    }
 
    return QWidget::minimumSizeHint();
}
 
void QDialog::setModal(bool modal)
{
    setAttribute(Qt::WA_ShowModal, modal);
}
 
 
bool QDialog::isSizeGripEnabled() const
{
#if QT_CONFIG(sizegrip)
    Q_D(const QDialog);
    return !!d->resizer;
#else
    return false;
#endif
}
 
 
void QDialog::setSizeGripEnabled(bool enabled)
{
#if !QT_CONFIG(sizegrip)
    Q_UNUSED(enabled);
#else
    Q_D(QDialog);
#if QT_CONFIG(sizegrip)
    d->sizeGripEnabled = enabled;
    if (enabled && d->doShowExtension)
        return;
#endif
    if (!enabled != !d->resizer) {
        if (enabled) {
            d->resizer = new QSizeGrip(this);
            // adjustSize() processes all events, which is suboptimal
            d->resizer->resize(d->resizer->sizeHint());
            if (isRightToLeft())
                d->resizer->move(rect().bottomLeft() -d->resizer->rect().bottomLeft());
            else
                d->resizer->move(rect().bottomRight() -d->resizer->rect().bottomRight());
            d->resizer->raise();
            d->resizer->show();
        } else {
            delete d->resizer;
            d->resizer = nullptr;
        }
    }
#endif // QT_CONFIG(sizegrip)
}
 
 
 
void QDialog::resizeEvent(QResizeEvent *)
{
#if QT_CONFIG(sizegrip)
    Q_D(QDialog);
    if (d->resizer) {
        if (isRightToLeft())
            d->resizer->move(rect().bottomLeft() -d->resizer->rect().bottomLeft());
        else
            d->resizer->move(rect().bottomRight() -d->resizer->rect().bottomRight());
        d->resizer->raise();
    }
#endif
}
 
QT_END_NAMESPACE
#include "moc_qdialog.cpp"