| /**************************************************************************** | |
| ** | |
| ** Copyright (C) 2016 The Qt Company Ltd. | |
| ** Contact: https://www.qt.io/licensing/ | |
| ** | |
| ** This file is part of the Qt Quick Dialogs module of the Qt Toolkit. | |
| ** | |
| ** $QT_BEGIN_LICENSE:LGPL$ | |
| ** Commercial License Usage | |
| ** Licensees holding valid commercial Qt licenses may use this file in | |
| ** accordance with the commercial license agreement provided with the | |
| ** Software or, alternatively, in accordance with the terms contained in | |
| ** a written agreement between you and The Qt Company. For licensing terms | |
| ** and conditions see https://www.qt.io/terms-conditions. For further | |
| ** information use the contact form at https://www.qt.io/contact-us. | |
| ** | |
| ** GNU Lesser General Public License Usage | |
| ** Alternatively, this file may be used under the terms of the GNU Lesser | |
| ** General Public License version 3 as published by the Free Software | |
| ** Foundation and appearing in the file LICENSE.LGPL3 included in the | |
| ** packaging of this file. Please review the following information to | |
| ** ensure the GNU Lesser General Public License version 3 requirements | |
| ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. | |
| ** | |
| ** GNU General Public License Usage | |
| ** Alternatively, this file may be used under the terms of the GNU | |
| ** General Public License version 2.0 or (at your option) the GNU General | |
| ** Public license version 3 or any later version approved by the KDE Free | |
| ** Qt Foundation. The licenses are as published by the Free Software | |
| ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 | |
| ** included in the packaging of this file. Please review the following | |
| ** information to ensure the GNU General Public License requirements will | |
| ** be met: https://www.gnu.org/licenses/gpl-2.0.html and | |
| ** https://www.gnu.org/licenses/gpl-3.0.html. | |
| ** | |
| ** $QT_END_LICENSE$ | |
| ** | |
| ****************************************************************************/ | |
| #include "qquickdialog_p.h" | |
| #include <QQuickItem> | |
| #include <QQmlEngine> | |
| #include <QStandardPaths> | |
| #include <private/qguiapplication_p.h> | |
| QT_BEGIN_NAMESPACE | |
| /*! | |
| \qmltype Dialog | |
| \instantiates QQuickDialog1 | |
| \inqmlmodule QtQuick.Dialogs | |
| \ingroup qtquickdialogs | |
| \brief A generic QtQuick dialog wrapper with standard buttons. | |
| \since 5.3 | |
| The purpose of Dialog is to wrap arbitrary content into a \e {dialog window} | |
| including a row of platform-tailored buttons. | |
| \note On Android, it is recommended to use \l {QQuickDialog}{Qt Quick Controls 2 Dialog}. | |
| The \l contentItem is the default property (the only allowed child | |
| element), and items declared inside the Dialog will actually be children of | |
| another Item inside the \c contentItem. The row of \l standardButtons will | |
| also be inside \c contentItem below the declared content, and Dialog will | |
| attempt to size itself to fit the content and the buttons. | |
| Alternatively it is possible to bind \l contentItem to a custom Item, in | |
| which case there will be no buttons, no margins, and the custom content | |
| will fill the whole dialog. This is much like creating a \l Window, | |
| except that on platforms which do not support showing multiple windows, | |
| the window borders will be simulated and it will be shown in same scene. | |
| \note do not attempt to bind the width or height of the dialog to the width | |
| or height of its content, because Dialog already tries to size itself | |
| to the content. If your goal is to change or eliminate the margins, you | |
| must override \l contentItem. If your goal is simply to show a window | |
| (whether modal or not), and your platform supports it, it is simpler to use | |
| \l Window instead. | |
| */ | |
| /*! | |
| \qmlsignal Dialog::accepted() | |
| This signal is emitted when the user has pressed any button which has the | |
| \l {QMessageBox::}{AcceptRole}: \gui OK, \gui Open, \gui Save, | |
| \gui {Save All}, \gui Retry or \gui Ignore. | |
| The corresponding handler is \c onAccepted. | |
| */ | |
| /*! | |
| \qmlsignal Dialog::rejected() | |
| This signal is emitted when the user has dismissed the dialog, by closing | |
| the dialog window, by pressing a \gui Cancel, \gui Close or \gui Abort | |
| button on the dialog, or by pressing the back button or the escape key. | |
| The corresponding handler is \c onRejected. | |
| */ | |
| /*! | |
| \qmlsignal Dialog::discard() | |
| This signal is emitted when the user has pressed the \gui Discard button. | |
| The corresponding handler is \c onDiscard. | |
| */ | |
| /*! | |
| \qmlsignal Dialog::help() | |
| This signal is emitted when the user has pressed the \gui Help button. | |
| Depending on platform, the dialog may not be automatically dismissed | |
| because the help that your application provides may need to be relevant to | |
| the text shown in this dialog in order to assist the user in making a | |
| decision. However on other platforms it's not possible to show a dialog and | |
| a help window at the same time. If you want to be sure that the dialog will | |
| close, you can set \l visible to \c false in your handler. | |
| The corresponding handler is \c onHelp. | |
| */ | |
| /*! | |
| \qmlsignal Dialog::yes() | |
| This signal is emitted when the user has pressed any button which has | |
| the \l {QMessageBox::YesRole} {YesRole}: \gui Yes or \gui {Yes to All}. | |
| The corresponding handler is \c onYes. | |
| */ | |
| /*! | |
| \qmlsignal Dialog::no() | |
| This signal is emitted when the user has pressed any button which has | |
| the \l {QMessageBox::NoRole} {NoRole}: \gui No or \gui {No to All}. | |
| The corresponding handler is \c onNo. | |
| */ | |
| /*! | |
| \qmlsignal Dialog::apply() | |
| This signal is emitted when the user has pressed the \gui Apply button. | |
| The corresponding handler is \c onApply. | |
| */ | |
| /*! | |
| \qmlsignal Dialog::reset() | |
| This signal is emitted when the user has pressed any button which has | |
| the \l {QMessageBox::ResetRole} {ResetRole}: \gui Reset or \gui {Restore Defaults}. | |
| The corresponding handler is \c onReset. | |
| */ | |
| /*! | |
| \qmlsignal Dialog::actionChosen(var action) | |
| This signal is emitted when the user has pressed any button or a key | |
| associated with some role (such as the Enter or Escape keys). The \a | |
| action parameter carries information about the event: | |
| \list | |
| \li StandardButton button - The role of the button which was pressed. If a | |
| key was pressed instead, this will be \c StandardButton.Ok if accepted | |
| and \c StandardButton.Cancel if rejected. | |
| \li Qt.Key key - The key which was pressed, or \c 0 if none | |
| \li bool accepted - Set this to \c false to stop the event from triggering | |
| its predefined action | |
| \endlist | |
| By handling this signal and setting the \c action.accepted field to \c | |
| false, it's possible to implement some validation on the dialog contents | |
| before accepting it, for example. | |
| The corresponding handler is \c onActionChosen. | |
| \since QtQuick.Controls 1.8 | |
| */ | |
| /*! | |
| \qmlproperty bool Dialog::visible | |
| This property holds whether the dialog is visible. By default this is | |
| \c false. | |
| \sa modality | |
| */ | |
| /*! \qmlproperty StandardButton Dialog::clickedButton | |
| This property holds the button pressed by the user. Its value is | |
| one of the flags set for the standardButtons property. | |
| */ | |
| /*! | |
| \qmlproperty Qt::WindowModality Dialog::modality | |
| Whether the dialog should be shown modal with respect to the window | |
| containing the dialog's parent Item, modal with respect to the whole | |
| application, or non-modal. | |
| By default it is \c Qt.WindowModal. | |
| Modality does not mean that there are any blocking calls to wait for the | |
| dialog to be accepted or rejected: only that the user will be prevented | |
| from interacting with the parent window or the application windows | |
| until the dialog is dismissed. | |
| */ | |
| /*! | |
| \qmlmethod void Dialog::open() | |
| Shows the dialog to the user. It is equivalent to setting \l visible to | |
| \c true. | |
| */ | |
| /*! | |
| \qmlmethod void Dialog::close() | |
| Closes the dialog. | |
| */ | |
| /*! | |
| \qmlproperty string Dialog::title | |
| The title of the dialog window. | |
| */ | |
| /*! | |
| \class QQuickDialog1 | |
| \inmodule QtQuick.Dialogs | |
| \internal | |
| The QQuickDialog1 class represents a container for arbitrary | |
| dialog contents. | |
| \since 5.3 | |
| */ | |
| /*! | |
| Constructs a dialog wrapper with parent window \a parent. | |
| */ | |
| QQuickDialog1::QQuickDialog1(QObject *parent) | |
| : QQuickAbstractDialog(parent) | |
| , m_enabledButtons(Ok) | |
| , m_clickedButton(NoButton) | |
| { | |
| } | |
| /*! | |
| Destroys the dialog wrapper. | |
| */ | |
| QQuickDialog1::~QQuickDialog1() | |
| { | |
| } | |
| QJSValue QQuickDialog1::__standardButtonsLeftModel() | |
| { | |
| updateStandardButtons(); | |
| return m_standardButtonsLeftModel; | |
| } | |
| QJSValue QQuickDialog1::__standardButtonsRightModel() | |
| { | |
| updateStandardButtons(); | |
| return m_standardButtonsRightModel; | |
| } | |
| void QQuickDialog1::setVisible(bool v) | |
| { | |
| if (v) | |
| m_clickedButton = NoButton; | |
| QQuickAbstractDialog::setVisible(v); | |
| } | |
| void QQuickDialog1::updateStandardButtons() | |
| { | |
| if (m_standardButtonsRightModel.isUndefined()) { | |
| QJSEngine *engine = qmlEngine(this); | |
| // Managed objects so no need to destroy any existing ones | |
| m_standardButtonsLeftModel = engine->newArray(); | |
| m_standardButtonsRightModel = engine->newArray(); | |
| int i = 0; | |
| QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme(); | |
| QPlatformDialogHelper::ButtonLayout layoutPolicy = | |
| static_cast<QPlatformDialogHelper::ButtonLayout>(theme->themeHint(QPlatformTheme::DialogButtonBoxLayout).toInt()); | |
| const int *buttonLayout = QPlatformDialogHelper::buttonLayout(Qt::Horizontal, layoutPolicy); | |
| QJSValue *model = &m_standardButtonsLeftModel; | |
| for (int r = 0; buttonLayout[r] != QPlatformDialogHelper::EOL; ++r) { | |
| quint32 role = (buttonLayout[r] & ~QPlatformDialogHelper::Reverse); | |
| // Keep implementation in sync with that in QDialogButtonBoxPrivate::layoutButtons() | |
| // to the extent that QtQuick supports the same features | |
| switch (role) { | |
| case QPlatformDialogHelper::Stretch: | |
| model = &m_standardButtonsRightModel; | |
| i = 0; | |
| break; | |
| // TODO maybe: case QPlatformDialogHelper::AlternateRole: | |
| default: { | |
| for (int e = QPlatformDialogHelper::LowestBit; e <= QPlatformDialogHelper::HighestBit; ++e) { | |
| quint32 standardButton = 1 << e; | |
| quint32 standardButtonRole = QPlatformDialogHelper::buttonRole( | |
| static_cast<QPlatformDialogHelper::StandardButton>(standardButton)); | |
| if ((m_enabledButtons & standardButton) && standardButtonRole == role) { | |
| QJSValue o = engine->newObject(); | |
| o.setProperty("text", theme->standardButtonText(standardButton)); | |
| o.setProperty("standardButton", standardButton); | |
| o.setProperty("role", role); | |
| model->setProperty(i++, o); | |
| } | |
| } | |
| } break; | |
| } | |
| } | |
| } | |
| } | |
| void QQuickDialog1::setTitle(const QString &arg) | |
| { | |
| if (m_title != arg) { | |
| m_title = arg; | |
| if (m_dialogWindow) | |
| m_dialogWindow->setTitle(m_title); | |
| emit titleChanged(); | |
| } | |
| } | |
| void QQuickDialog1::setStandardButtons(StandardButtons buttons) | |
| { | |
| m_enabledButtons = buttons; | |
| m_standardButtonsLeftModel = QJSValue(); | |
| m_standardButtonsRightModel = QJSValue(); | |
| emit standardButtonsChanged(); | |
| } | |
| /*! | |
| \qmlproperty QObject Dialog::contentItem | |
| The QML object which implements the dialog contents. Should be an \l Item. | |
| For example the following dialog will show custom content and no buttons: | |
| \qml | |
| import QtQuick 2.3 | |
| import QtQuick.Controls 1.2 | |
| import QtQuick.Dialogs 1.2 | |
| Dialog { | |
| visible: true | |
| title: "Blue sky dialog" | |
| contentItem: Rectangle { | |
| color: "lightskyblue" | |
| implicitWidth: 400 | |
| implicitHeight: 100 | |
| Text { | |
| text: "Hello blue sky!" | |
| color: "navy" | |
| anchors.centerIn: parent | |
| } | |
| } | |
| } | |
| \endqml | |
| */ | |
| void QQuickDialog1::click(QPlatformDialogHelper::StandardButton button, QPlatformDialogHelper::ButtonRole role) | |
| { | |
| m_clickedButton = static_cast<StandardButton>(button); | |
| emit buttonClicked(); | |
| switch (role) { | |
| case QPlatformDialogHelper::AcceptRole: | |
| emit accepted(); | |
| setVisible(false); | |
| break; | |
| case QPlatformDialogHelper::RejectRole: | |
| emit rejected(); | |
| setVisible(false); | |
| break; | |
| case QPlatformDialogHelper::DestructiveRole: | |
| emit discard(); | |
| setVisible(false); | |
| break; | |
| case QPlatformDialogHelper::HelpRole: | |
| emit help(); | |
| break; | |
| case QPlatformDialogHelper::YesRole: | |
| emit yes(); | |
| setVisible(false); | |
| break; | |
| case QPlatformDialogHelper::NoRole: | |
| emit no(); | |
| setVisible(false); | |
| break; | |
| case QPlatformDialogHelper::ApplyRole: | |
| emit apply(); | |
| break; | |
| case QPlatformDialogHelper::ResetRole: | |
| emit reset(); | |
| break; | |
| default: | |
| qWarning("unhandled Dialog button %d with role %d", (int)button, (int)role); | |
| } | |
| } | |
| void QQuickDialog1::click(QQuickAbstractDialog::StandardButton button) | |
| { | |
| click(static_cast<QPlatformDialogHelper::StandardButton>(button), | |
| static_cast<QPlatformDialogHelper::ButtonRole>( | |
| QPlatformDialogHelper::buttonRole(static_cast<QPlatformDialogHelper::StandardButton>(button)))); | |
| } | |
| void QQuickDialog1::accept() { | |
| // enter key is treated like OK | |
| if (m_clickedButton == NoButton) | |
| m_clickedButton = Ok; | |
| QQuickAbstractDialog::accept(); | |
| } | |
| void QQuickDialog1::reject() { | |
| // escape key is treated like cancel | |
| if (m_clickedButton == NoButton) | |
| m_clickedButton = Cancel; | |
| QQuickAbstractDialog::reject(); | |
| } | |
| /*! | |
| \qmlproperty StandardButtons Dialog::standardButtons | |
| Dialog has a row of buttons along the bottom, each of which has a | |
| \l {QMessageBox::ButtonRole} {ButtonRole} that determines which signal | |
| will be emitted when the button is pressed. You can also find out which | |
| specific button was pressed after the fact via the \l clickedButton | |
| property. You can control which buttons are available by setting | |
| standardButtons to a bitwise-or combination of the following flags: | |
| \value StandardButton.Ok | |
| An \gui OK button defined with the | |
| \l {QMessageBox::}{AcceptRole}. | |
| \value StandardButton.Open | |
| An \gui Open button defined with the | |
| \l {QMessageBox::}{AcceptRole}. | |
| \value StandardButton.Save | |
| A \gui Save button defined with the | |
| \l {QMessageBox::}{AcceptRole}. | |
| \value StandardButton.Cancel | |
| A \gui Cancel button defined with the | |
| \l {QMessageBox::}{RejectRole}. | |
| \value StandardButton.Close | |
| A \gui Close button defined with the | |
| \l {QMessageBox::}{RejectRole}. | |
| \value StandardButton.Discard | |
| A \gui Discard or \gui {Don't Save} button, | |
| depending on the platform, defined with the | |
| \l {QMessageBox::}{DestructiveRole}. | |
| \value StandardButton.Apply | |
| An \gui Apply button defined with the | |
| \l {QMessageBox::}{ApplyRole}. | |
| \value StandardButton.Reset | |
| A \gui Reset button defined with the | |
| \l {QMessageBox::}{ResetRole}. | |
| \value StandardButton.RestoreDefaults | |
| A \gui {Restore Defaults} button defined with the | |
| \l {QMessageBox::}{ResetRole}. | |
| \value StandardButton.Help | |
| A \gui Help button defined with the | |
| \l {QMessageBox::}{HelpRole}. | |
| \value StandardButton.SaveAll | |
| A \gui {Save All} button defined with the | |
| \l {QMessageBox::}{AcceptRole}. | |
| \value StandardButton.Yes | |
| A \gui Yes button defined with the | |
| \l {QMessageBox::}{YesRole}. | |
| \value StandardButton.YesToAll | |
| A \gui {Yes to All} button defined with the | |
| \l {QMessageBox::}{YesRole}. | |
| \value StandardButton.No | |
| A \gui No button defined with the | |
| \l {QMessageBox::}{NoRole}. | |
| \value StandardButton.NoToAll | |
| A \gui {No to All} button defined with the | |
| \l {QMessageBox::}{NoRole}. | |
| \value StandardButton.Abort | |
| An \gui Abort button defined with the | |
| \l {QMessageBox::}{RejectRole}. | |
| \value StandardButton.Retry | |
| A \gui Retry button defined with the | |
| \l {QMessageBox::}{AcceptRole}. | |
| \value StandardButton.Ignore | |
| An \gui Ignore button defined with the | |
| \l {QMessageBox::}{AcceptRole}. | |
| For example the following dialog will show a calendar with the ability to | |
| save or cancel a date: | |
| \qml | |
| import QtQuick 2.3 | |
| import QtQuick.Controls 1.2 | |
| import QtQuick.Dialogs 1.2 | |
| Dialog { | |
| id: dateDialog | |
| visible: true | |
| title: "Choose a date" | |
| standardButtons: StandardButton.Save | StandardButton.Cancel | |
| onAccepted: console.log("Saving the date " + | |
| calendar.selectedDate.toLocaleDateString()) | |
| Calendar { | |
| id: calendar | |
| onDoubleClicked: dateDialog.click(StandardButton.Save) | |
| } | |
| } | |
| \endqml | |
| The default is \c StandardButton.Ok. | |
| The enum values are the same as in \l QMessageBox::StandardButtons. | |
| */ | |
| QT_END_NAMESPACE |