1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qinputdialog.h"

    43 

    44 #ifndef QT_NO_INPUTDIALOG

    45 

    46 #include "qapplication.h"

    47 #include "qcombobox.h"

    48 #include "qdialogbuttonbox.h"

    49 #include "qlabel.h"

    50 #include "qlayout.h"

    51 #include "qlineedit.h"

    52 #include "qlistwidget.h"

    53 #include "qpushbutton.h"

    54 #include "qspinbox.h"

    55 #include "qstackedlayout.h"

    56 #include "qvalidator.h"

    57 #include "qevent.h"

    58 #include "qdialog_p.h"

    59 

    60 QT_USE_NAMESPACE

    61 

    62 static const char *signalForMember(const char *member)

    63 {

    64     static const int NumCandidates = 4;

    65     static const char * const candidateSignals[NumCandidates] = {

    66         SIGNAL(textValueSelected(QString)),

    67         SIGNAL(intValueSelected(int)),

    68         SIGNAL(doubleValueSelected(double)),

    69         SIGNAL(accepted())

    70     };

    71 

    72     QByteArray normalizedMember(QMetaObject::normalizedSignature(member));

    73 

    74     int i = 0;

    75     while (i < NumCandidates - 1) { // sic

    76         if (QMetaObject::checkConnectArgs(candidateSignals[i], normalizedMember))

    77             break;

    78         ++i;

    79     }

    80     return candidateSignals[i];

    81 }

    82 

    83 QT_BEGIN_NAMESPACE

    84 

    85 /*

    86     These internal classes add extra validation to QSpinBox and QDoubleSpinBox by emitting

    87     textChanged(bool) after events that may potentially change the visible text. Return or

    88     Enter key presses are not propagated if the visible text is invalid. Instead, the visible

    89     text is modified to the last valid value.

    90 */

    91 class QInputDialogSpinBox : public QSpinBox

    92 {

    93     Q_OBJECT

    94 

    95 public:

    96     QInputDialogSpinBox(QWidget *parent)

    97         : QSpinBox(parent) {

    98         connect(lineEdit(), SIGNAL(textChanged(const QString&)), this, SLOT(notifyTextChanged()));

    99         connect(this, SIGNAL(editingFinished()), this, SLOT(notifyTextChanged()));

   100     }

   101 

   102 signals:

   103     void textChanged(bool);

   104 

   105 private slots:

   106     void notifyTextChanged() { emit textChanged(hasAcceptableInput()); }

   107 

   108 private:

   109     void keyPressEvent(QKeyEvent *event) {

   110         if ((event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) && !hasAcceptableInput()) {

   111 #ifndef QT_NO_PROPERTIES

   112             setProperty("value", property("value"));

   113 #endif

   114         } else {

   115             QSpinBox::keyPressEvent(event);

   116         }

   117         notifyTextChanged();

   118     }

   119 

   120     void mousePressEvent(QMouseEvent *event) {

   121         QSpinBox::mousePressEvent(event);

   122         notifyTextChanged();

   123     }

   124 };

   125 

   126 class QInputDialogDoubleSpinBox : public QDoubleSpinBox

   127 {

   128     Q_OBJECT

   129 

   130 public:

   131     QInputDialogDoubleSpinBox(QWidget *parent = 0)

   132         : QDoubleSpinBox(parent) {

   133         connect(lineEdit(), SIGNAL(textChanged(const QString&)), this, SLOT(notifyTextChanged()));

   134         connect(this, SIGNAL(editingFinished()), this, SLOT(notifyTextChanged()));

   135     }

   136 

   137 signals:

   138     void textChanged(bool);

   139 

   140 private slots:

   141     void notifyTextChanged() { emit textChanged(hasAcceptableInput()); }

   142 

   143 private:

   144     void keyPressEvent(QKeyEvent *event) {

   145         if ((event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) && !hasAcceptableInput()) {

   146 #ifndef QT_NO_PROPERTIES

   147             setProperty("value", property("value"));

   148 #endif

   149         } else {

   150             QDoubleSpinBox::keyPressEvent(event);

   151         }

   152         notifyTextChanged();

   153     }

   154 

   155     void mousePressEvent(QMouseEvent *event) {

   156         QDoubleSpinBox::mousePressEvent(event);

   157         notifyTextChanged();

   158     }

   159 };

   160 

   161 QT_BEGIN_INCLUDE_NAMESPACE

   162 #include "qinputdialog.moc"

   163 QT_END_INCLUDE_NAMESPACE

   164 

   165 class QInputDialogPrivate : public QDialogPrivate

   166 {

   167     Q_DECLARE_PUBLIC(QInputDialog)

   168 

   169 public:

   170     QInputDialogPrivate();

   171 

   172     void ensureLayout();

   173     void ensureLineEdit();

   174     void ensureComboBox();

   175     void ensureListView();

   176     void ensureIntSpinBox();

   177     void ensureDoubleSpinBox();

   178     void ensureEnabledConnection(QAbstractSpinBox *spinBox);

   179     void setInputWidget(QWidget *widget);

   180     void chooseRightTextInputWidget();

   181     void setComboBoxText(const QString &text);

   182     void setListViewText(const QString &text);

   183     QString listViewText() const;

   184     void ensureLayout() const { const_cast<QInputDialogPrivate *>(this)->ensureLayout(); }

   185     bool useComboBoxOrListView() const { return comboBox && comboBox->count() > 0; }

   186     void _q_textChanged(const QString &text);

   187     void _q_currentRowChanged(const QModelIndex &newIndex, const QModelIndex &oldIndex);

   188 

   189     mutable QLabel *label;

   190     mutable QDialogButtonBox *buttonBox;

   191     mutable QLineEdit *lineEdit;

   192     mutable QSpinBox *intSpinBox;

   193     mutable QDoubleSpinBox *doubleSpinBox;

   194     mutable QComboBox *comboBox;

   195     mutable QListView *listView;

   196     mutable QWidget *inputWidget;

   197     mutable QVBoxLayout *mainLayout;

   198     QInputDialog::InputDialogOptions opts;

   199     QString textValue;

   200     QPointer<QObject> receiverToDisconnectOnClose;

   201     QByteArray memberToDisconnectOnClose;

   202 };

   203 

   204 QInputDialogPrivate::QInputDialogPrivate()

   205     : label(0), buttonBox(0), lineEdit(0), intSpinBox(0), doubleSpinBox(0), comboBox(0), listView(0),

   206       inputWidget(0), mainLayout(0)

   207 {

   208 }

   209 

   210 void QInputDialogPrivate::ensureLayout()

   211 {

   212     Q_Q(QInputDialog);

   213 

   214     if (mainLayout)

   215         return;

   216 

   217     if (!inputWidget) {

   218         ensureLineEdit();

   219         inputWidget = lineEdit;

   220     }

   221 

   222     if (!label)

   223         label = new QLabel(QInputDialog::tr("Enter a value:"), q);

   224 #ifndef QT_NO_SHORTCUT

   225     label->setBuddy(inputWidget);

   226 #endif

   227     label->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);

   228 

   229     buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, q);

   230     QObject::connect(buttonBox, SIGNAL(accepted()), q, SLOT(accept()));

   231     QObject::connect(buttonBox, SIGNAL(rejected()), q, SLOT(reject()));

   232 

   233     mainLayout = new QVBoxLayout(q);

   234     mainLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);

   235     mainLayout->addWidget(label);

   236     mainLayout->addWidget(inputWidget);

   237     mainLayout->addWidget(buttonBox);

   238     ensureEnabledConnection(qobject_cast<QAbstractSpinBox *>(inputWidget));

   239     inputWidget->show();

   240 }

   241 

   242 void QInputDialogPrivate::ensureLineEdit()

   243 {

   244     Q_Q(QInputDialog);

   245     if (!lineEdit) {

   246         lineEdit = new QLineEdit(q);

   247         lineEdit->hide();

   248         QObject::connect(lineEdit, SIGNAL(textChanged(const QString&)),

   249                          q, SLOT(_q_textChanged(const QString&)));

   250     }

   251 }

   252 

   253 void QInputDialogPrivate::ensureComboBox()

   254 {

   255     Q_Q(QInputDialog);

   256     if (!comboBox) {

   257         comboBox = new QComboBox(q);

   258         comboBox->hide();

   259         QObject::connect(comboBox, SIGNAL(editTextChanged(const QString&)),

   260                          q, SLOT(_q_textChanged(const QString&)));

   261         QObject::connect(comboBox, SIGNAL(currentIndexChanged(const QString&)),

   262                          q, SLOT(_q_textChanged(const QString&)));

   263     }

   264 }

   265 

   266 void QInputDialogPrivate::ensureListView()

   267 {

   268     Q_Q(QInputDialog);

   269     if (!listView) {

   270         ensureComboBox();

   271 

   272         listView = new QListView(q);

   273         listView->hide();

   274         listView->setEditTriggers(QAbstractItemView::NoEditTriggers);

   275         listView->setSelectionMode(QAbstractItemView::SingleSelection);

   276         listView->setModel(comboBox->model());

   277         listView->setCurrentIndex(QModelIndex()); // ###

   278         QObject::connect(listView->selectionModel(),

   279                          SIGNAL(currentRowChanged(const QModelIndex&, const QModelIndex&)),

   280                          q, SLOT(_q_currentRowChanged(const QModelIndex&, const QModelIndex&)));

   281     }

   282 }

   283 

   284 void QInputDialogPrivate::ensureIntSpinBox()

   285 {

   286     Q_Q(QInputDialog);

   287     if (!intSpinBox) {

   288         intSpinBox = new QInputDialogSpinBox(q);

   289         intSpinBox->hide();

   290         QObject::connect(intSpinBox, SIGNAL(valueChanged(int)),

   291                          q, SIGNAL(intValueChanged(int)));

   292     }

   293 }

   294 

   295 void QInputDialogPrivate::ensureDoubleSpinBox()

   296 {

   297     Q_Q(QInputDialog);

   298     if (!doubleSpinBox) {

   299         doubleSpinBox = new QInputDialogDoubleSpinBox(q);

   300         doubleSpinBox->hide();

   301         QObject::connect(doubleSpinBox, SIGNAL(valueChanged(double)),

   302                          q, SIGNAL(doubleValueChanged(double)));

   303     }

   304 }

   305 

   306 void QInputDialogPrivate::ensureEnabledConnection(QAbstractSpinBox *spinBox)

   307 {

   308     if (spinBox) {

   309         QAbstractButton *okButton = buttonBox->button(QDialogButtonBox::Ok);

   310         QObject::connect(spinBox, SIGNAL(textChanged(bool)), okButton, SLOT(setEnabled(bool)), Qt::UniqueConnection);

   311     }

   312 }

   313 

   314 void QInputDialogPrivate::setInputWidget(QWidget *widget)

   315 {

   316     Q_ASSERT(widget);

   317     if (inputWidget == widget)

   318         return;

   319 

   320     if (mainLayout) {

   321         Q_ASSERT(inputWidget);

   322         mainLayout->removeWidget(inputWidget);

   323         inputWidget->hide();

   324         mainLayout->insertWidget(1, widget);

   325         widget->show();

   326 

   327         // disconnect old input widget

   328         QAbstractButton *okButton = buttonBox->button(QDialogButtonBox::Ok);

   329         if (QAbstractSpinBox *spinBox = qobject_cast<QAbstractSpinBox *>(inputWidget))

   330             QObject::disconnect(spinBox, SIGNAL(textChanged(bool)), okButton, SLOT(setEnabled(bool)));

   331 

   332         // connect new input widget and update enabled state of OK button

   333         QAbstractSpinBox *spinBox = qobject_cast<QAbstractSpinBox *>(widget);

   334         ensureEnabledConnection(spinBox);

   335         okButton->setEnabled(!spinBox || spinBox->hasAcceptableInput());

   336     }

   337 

   338     inputWidget = widget;

   339 

   340     // synchronize the text shown in the new text editor with the current

   341     // textValue

   342     if (widget == lineEdit) {

   343         lineEdit->setText(textValue);

   344     } else if (widget == comboBox) {

   345         setComboBoxText(textValue);

   346     } else if (widget == listView) {

   347         setListViewText(textValue);

   348         ensureLayout();

   349         buttonBox->button(QDialogButtonBox::Ok)->setEnabled(listView->selectionModel()->hasSelection());

   350     }

   351 }

   352 

   353 void QInputDialogPrivate::chooseRightTextInputWidget()

   354 {

   355     QWidget *widget;

   356 

   357     if (useComboBoxOrListView()) {

   358         if ((opts & QInputDialog::UseListViewForComboBoxItems) && !comboBox->isEditable()) {

   359             ensureListView();

   360             widget = listView;

   361         } else {

   362             widget = comboBox;

   363         }

   364     } else {

   365         ensureLineEdit();

   366         widget = lineEdit;

   367     }

   368 

   369     setInputWidget(widget);

   370 

   371     if (inputWidget == comboBox) {

   372         _q_textChanged(comboBox->currentText());

   373     } else if (inputWidget == listView) {

   374         _q_textChanged(listViewText());

   375     }

   376 }

   377 

   378 void QInputDialogPrivate::setComboBoxText(const QString &text)

   379 {

   380     int index = comboBox->findText(text);

   381     if (index != -1) {

   382         comboBox->setCurrentIndex(index);

   383     } else if (comboBox->isEditable()) {

   384         comboBox->setEditText(text);

   385     }

   386 }

   387 

   388 void QInputDialogPrivate::setListViewText(const QString &text)

   389 {

   390     int row = comboBox->findText(text);

   391     if (row != -1) {

   392         QModelIndex index(comboBox->model()->index(row, 0));

   393         listView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::Clear

   394                                                          | QItemSelectionModel::SelectCurrent);

   395     }

   396 }

   397 

   398 QString QInputDialogPrivate::listViewText() const

   399 {

   400     if (listView->selectionModel()->hasSelection()) {

   401         int row = listView->selectionModel()->selectedRows().value(0).row();

   402         return comboBox->itemText(row);

   403     } else {

   404         return QString();

   405     }

   406 }

   407 

   408 void QInputDialogPrivate::_q_textChanged(const QString &text)

   409 {

   410     Q_Q(QInputDialog);

   411     if (textValue != text) {

   412         textValue = text;

   413         emit q->textValueChanged(text);

   414     }

   415 }

   416 

   417 void QInputDialogPrivate::_q_currentRowChanged(const QModelIndex &newIndex,

   418                                                const QModelIndex & /* oldIndex */)

   419 {

   420     _q_textChanged(comboBox->model()->data(newIndex).toString());

   421     buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);

   422 }

   423 

   424 /*!

   425     \class QInputDialog

   426     \brief The QInputDialog class provides a simple convenience dialog to get a

   427     single value from the user.

   428     \ingroup standard-dialogs

   429 

   430 

   431     The input value can be a string, a number or an item from a list. A label

   432     must be set to tell the user what they should enter.

   433 

   434     Four static convenience functions are provided: getText(), getInt(),

   435     getDouble(), and getItem(). All the functions can be used in a similar way,

   436     for example:

   437 

   438     \snippet examples/dialogs/standarddialogs/dialog.cpp 3

   439 

   440     The \c ok variable is set to true if the user clicks \gui OK; otherwise it

   441     is set to false.

   442 

   443     \img inputdialogs.png Input Dialogs

   444 

   445     The \l{dialogs/standarddialogs}{Standard Dialogs} example shows how to use

   446     QInputDialog as well as other built-in Qt dialogs.

   447 

   448     \sa QMessageBox, {Standard Dialogs Example}

   449 */

   450 

   451 /*!

   452     \enum QInputDialog::InputMode

   453     \since 4.5

   454 

   455     This enum describes the different modes of input that can be selected for

   456     the dialog.

   457 

   458     \value TextInput   Used to input text strings.

   459     \value IntInput    Used to input integers.

   460     \value DoubleInput Used to input floating point numbers with double

   461                        precision accuracy.

   462 

   463     \sa inputMode

   464 */

   465 

   466 /*!

   467     \since 4.5

   468 

   469     Constructs a new input dialog with the given \a parent and window \a flags.

   470 */

   471 QInputDialog::QInputDialog(QWidget *parent, Qt::WindowFlags flags)

   472     : QDialog(*new QInputDialogPrivate, parent, flags)

   473 {

   474 }

   475 

   476 /*!

   477     \since 4.5

   478 

   479     Destroys the input dialog.

   480 */

   481 QInputDialog::~QInputDialog()

   482 {

   483 }

   484 

   485 /*!

   486     \since 4.5

   487 

   488     \property QInputDialog::inputMode

   489 

   490     \brief the mode used for input

   491 

   492     This property help determines which widget is used for entering input into

   493     the dialog.

   494 */

   495 void QInputDialog::setInputMode(InputMode mode)

   496 {

   497     Q_D(QInputDialog);

   498 

   499     QWidget *widget;

   500 

   501     /*

   502         Warning: Some functions in QInputDialog rely on implementation details

   503         of the code below. Look for the comments that accompany the calls to

   504         setInputMode() throughout this file before you change the code below.

   505     */

   506 

   507     switch (mode) {

   508     case IntInput:

   509         d->ensureIntSpinBox();

   510         widget = d->intSpinBox;

   511         break;

   512     case DoubleInput:

   513         d->ensureDoubleSpinBox();

   514         widget = d->doubleSpinBox;

   515         break;

   516     default:

   517         Q_ASSERT(mode == TextInput);

   518         d->chooseRightTextInputWidget();

   519         return;

   520     }

   521 

   522     d->setInputWidget(widget);

   523 }

   524 

   525 QInputDialog::InputMode QInputDialog::inputMode() const

   526 {

   527     Q_D(const QInputDialog);

   528 

   529     if (d->inputWidget) {

   530         if (d->inputWidget == d->intSpinBox) {

   531             return IntInput;

   532         } else if (d->inputWidget == d->doubleSpinBox) {

   533             return DoubleInput;

   534         }

   535     }

   536 

   537     return TextInput;

   538 }

   539 

   540 /*!

   541     \since 4.5

   542 

   543     \property QInputDialog::labelText

   544 

   545     \brief the text to for the label to describe what needs to be input

   546 */

   547 void QInputDialog::setLabelText(const QString &text)

   548 {

   549     Q_D(QInputDialog);

   550     if (!d->label) {

   551         d->label = new QLabel(text, this);

   552     } else {

   553         d->label->setText(text);

   554     }

   555 }

   556 

   557 QString QInputDialog::labelText() const

   558 {

   559     Q_D(const QInputDialog);

   560     d->ensureLayout();

   561     return d->label->text();

   562 }

   563 

   564 /*!

   565     \enum QInputDialog::InputDialogOption

   566 

   567     \since 4.5

   568 

   569     This enum specifies various options that affect the look and feel

   570     of an input dialog.

   571 

   572     \value NoButtons Don't display \gui{OK} and \gui{Cancel} buttons. (Useful for "live dialogs".)

   573     \value UseListViewForComboBoxItems Use a QListView rather than a non-editable QComboBox for

   574                                        displaying the items set with setComboBoxItems().

   575 

   576     \sa options, setOption(), testOption()

   577 */

   578 

   579 /*!

   580     Sets the given \a option to be enabled if \a on is true;

   581     otherwise, clears the given \a option.

   582 

   583     \sa options, testOption()

   584 */

   585 void QInputDialog::setOption(InputDialogOption option, bool on)

   586 {

   587     Q_D(QInputDialog);

   588     if (!(d->opts & option) != !on)

   589         setOptions(d->opts ^ option);

   590 }

   591 

   592 /*!

   593     Returns true if the given \a option is enabled; otherwise, returns

   594     false.

   595 

   596     \sa options, setOption()

   597 */

   598 bool QInputDialog::testOption(InputDialogOption option) const

   599 {

   600     Q_D(const QInputDialog);

   601     return (d->opts & option) != 0;

   602 }

   603 

   604 /*!

   605     \property QInputDialog::options

   606     \brief the various options that affect the look and feel of the dialog

   607     \since 4.5

   608 

   609     By default, all options are disabled.

   610 

   611     \sa setOption(), testOption()

   612 */

   613 void QInputDialog::setOptions(InputDialogOptions options)

   614 {

   615     Q_D(QInputDialog);

   616 

   617     InputDialogOptions changed = (options ^ d->opts);

   618     if (!changed)

   619         return;

   620 

   621     d->opts = options;

   622     d->ensureLayout();

   623 

   624     if (changed & NoButtons)

   625         d->buttonBox->setVisible(!(options & NoButtons));

   626     if ((changed & UseListViewForComboBoxItems) && inputMode() == TextInput)

   627         d->chooseRightTextInputWidget();

   628 }

   629 

   630 QInputDialog::InputDialogOptions QInputDialog::options() const

   631 {

   632     Q_D(const QInputDialog);

   633     return d->opts;

   634 }

   635 

   636 /*!

   637     \since 4.5

   638 

   639     \property QInputDialog::textValue

   640 

   641     \brief the text value for the input dialog

   642 

   643     This property is only relevant when the input dialog is used in

   644     TextInput mode.

   645 */

   646 void QInputDialog::setTextValue(const QString &text)

   647 {

   648     Q_D(QInputDialog);

   649 

   650     setInputMode(TextInput);

   651     if (d->inputWidget == d->lineEdit) {

   652         d->lineEdit->setText(text);

   653     } else if (d->inputWidget == d->comboBox) {

   654         d->setComboBoxText(text);

   655     } else {

   656         d->setListViewText(text);

   657     }

   658 }

   659 

   660 QString QInputDialog::textValue() const

   661 {

   662     Q_D(const QInputDialog);

   663     return d->textValue;

   664 }

   665 

   666 /*!

   667     \since 4.5

   668 

   669     \property QInputDialog::textEchoMode

   670 

   671     \brief the echo mode for the text value

   672 

   673     This property is only relevant when the input dialog is used in

   674     TextInput mode.

   675 */

   676 void QInputDialog::setTextEchoMode(QLineEdit::EchoMode mode)

   677 {

   678     Q_D(QInputDialog);

   679     d->ensureLineEdit();

   680     d->lineEdit->setEchoMode(mode);

   681 }

   682 

   683 QLineEdit::EchoMode QInputDialog::textEchoMode() const

   684 {

   685     Q_D(const QInputDialog);

   686     if (d->lineEdit) {

   687         return d->lineEdit->echoMode();

   688     } else {

   689         return QLineEdit::Normal;

   690     }

   691 }

   692 

   693 /*!

   694     \since 4.5

   695 

   696     \property QInputDialog::comboBoxEditable

   697 

   698     \brief whether or not the combo box is used in the input dialog is editable

   699 */

   700 void QInputDialog::setComboBoxEditable(bool editable)

   701 {

   702     Q_D(QInputDialog);

   703     d->ensureComboBox();

   704     d->comboBox->setEditable(editable);

   705     if (inputMode() == TextInput)

   706         d->chooseRightTextInputWidget();

   707 }

   708 

   709 bool QInputDialog::isComboBoxEditable() const

   710 {

   711     Q_D(const QInputDialog);

   712     if (d->comboBox) {

   713         return d->comboBox->isEditable();

   714     } else {

   715         return false;

   716     }

   717 }

   718 

   719 /*!

   720     \since 4.5

   721 

   722     \property QInputDialog::comboBoxItems

   723 

   724     \brief the items used in the combobox for the input dialog

   725 */

   726 void QInputDialog::setComboBoxItems(const QStringList &items)

   727 {

   728     Q_D(QInputDialog);

   729 

   730     d->ensureComboBox();

   731     d->comboBox->blockSignals(true);

   732     d->comboBox->clear();

   733     d->comboBox->addItems(items);

   734     d->comboBox->blockSignals(false);

   735 

   736     if (inputMode() == TextInput)

   737         d->chooseRightTextInputWidget();

   738 }

   739 

   740 QStringList QInputDialog::comboBoxItems() const

   741 {

   742     Q_D(const QInputDialog);

   743     QStringList result;

   744     if (d->comboBox) {

   745         const int count = d->comboBox->count();

   746         for (int i = 0; i < count; ++i)

   747             result.append(d->comboBox->itemText(i));

   748     }

   749     return result;

   750 }

   751 

   752 /*!

   753     \property QInputDialog::intValue

   754     \since 4.5

   755     \brief the current integer value accepted as input

   756 

   757     This property is only relevant when the input dialog is used in

   758     IntInput mode.

   759 */

   760 void QInputDialog::setIntValue(int value)

   761 {

   762     Q_D(QInputDialog);

   763     setInputMode(IntInput);

   764     d->intSpinBox->setValue(value);

   765 }

   766 

   767 int QInputDialog::intValue() const

   768 {

   769     Q_D(const QInputDialog);

   770     if (d->intSpinBox) {

   771         return d->intSpinBox->value();

   772     } else {

   773         return 0;

   774     }

   775 }

   776 

   777 /*!

   778     \property QInputDialog::intMinimum

   779     \since 4.5

   780     \brief the minimum integer value accepted as input

   781 

   782     This property is only relevant when the input dialog is used in

   783     IntInput mode.

   784 */

   785 void QInputDialog::setIntMinimum(int min)

   786 {

   787     Q_D(QInputDialog);

   788     d->ensureIntSpinBox();

   789     d->intSpinBox->setMinimum(min);

   790 }

   791 

   792 int QInputDialog::intMinimum() const

   793 {

   794     Q_D(const QInputDialog);

   795     if (d->intSpinBox) {

   796         return d->intSpinBox->minimum();

   797     } else {

   798         return 0;

   799     }

   800 }

   801 

   802 /*!

   803     \property QInputDialog::intMaximum

   804     \since 4.5

   805     \brief the maximum integer value accepted as input

   806 

   807     This property is only relevant when the input dialog is used in

   808     IntInput mode.

   809 */

   810 void QInputDialog::setIntMaximum(int max)

   811 {

   812     Q_D(QInputDialog);

   813     d->ensureIntSpinBox();

   814     d->intSpinBox->setMaximum(max);

   815 }

   816 

   817 int QInputDialog::intMaximum() const

   818 {

   819     Q_D(const QInputDialog);

   820     if (d->intSpinBox) {

   821         return d->intSpinBox->maximum();

   822     } else {

   823         return 99;

   824     }

   825 }

   826 

   827 /*!

   828     Sets the range of integer values accepted by the dialog when used in

   829     IntInput mode, with minimum and maximum values specified by \a min and

   830     \a max respectively.

   831 */

   832 void QInputDialog::setIntRange(int min, int max)

   833 {

   834     Q_D(QInputDialog);

   835     d->ensureIntSpinBox();

   836     d->intSpinBox->setRange(min, max);

   837 }

   838 

   839 /*!

   840     \property QInputDialog::intStep

   841     \since 4.5

   842     \brief the step by which the integer value is increased and decreased

   843 

   844     This property is only relevant when the input dialog is used in

   845     IntInput mode.

   846 */

   847 void QInputDialog::setIntStep(int step)

   848 {

   849     Q_D(QInputDialog);

   850     d->ensureIntSpinBox();

   851     d->intSpinBox->setSingleStep(step);

   852 }

   853 

   854 int QInputDialog::intStep() const

   855 {

   856     Q_D(const QInputDialog);

   857     if (d->intSpinBox) {

   858         return d->intSpinBox->singleStep();

   859     } else {

   860         return 1;

   861     }

   862 }

   863 

   864 /*!

   865     \property QInputDialog::doubleValue

   866     \since 4.5

   867     \brief the current double precision floating point value accepted as input

   868 

   869     This property is only relevant when the input dialog is used in

   870     DoubleInput mode.

   871 */

   872 void QInputDialog::setDoubleValue(double value)

   873 {

   874     Q_D(QInputDialog);

   875     setInputMode(DoubleInput);

   876     d->doubleSpinBox->setValue(value);

   877 }

   878 

   879 double QInputDialog::doubleValue() const

   880 {

   881     Q_D(const QInputDialog);

   882     if (d->doubleSpinBox) {

   883         return d->doubleSpinBox->value();

   884     } else {

   885         return 0.0;

   886     }

   887 }

   888 

   889 /*!

   890     \property QInputDialog::doubleMinimum

   891     \since 4.5

   892     \brief the minimum double precision floating point value accepted as input

   893 

   894     This property is only relevant when the input dialog is used in

   895     DoubleInput mode.

   896 */

   897 void QInputDialog::setDoubleMinimum(double min)

   898 {

   899     Q_D(QInputDialog);

   900     d->ensureDoubleSpinBox();

   901     d->doubleSpinBox->setMinimum(min);

   902 }

   903 

   904 double QInputDialog::doubleMinimum() const

   905 {

   906     Q_D(const QInputDialog);

   907     if (d->doubleSpinBox) {

   908         return d->doubleSpinBox->minimum();

   909     } else {

   910         return 0.0;

   911     }

   912 }

   913 

   914 /*!

   915     \property QInputDialog::doubleMaximum

   916     \since 4.5

   917     \brief the maximum double precision floating point value accepted as input

   918 

   919     This property is only relevant when the input dialog is used in

   920     DoubleInput mode.

   921 */

   922 void QInputDialog::setDoubleMaximum(double max)

   923 {

   924     Q_D(QInputDialog);

   925     d->ensureDoubleSpinBox();

   926     d->doubleSpinBox->setMaximum(max);

   927 }

   928 

   929 double QInputDialog::doubleMaximum() const

   930 {

   931     Q_D(const QInputDialog);

   932     if (d->doubleSpinBox) {

   933         return d->doubleSpinBox->maximum();

   934     } else {

   935         return 99.99;

   936     }

   937 }

   938 

   939 /*!

   940     Sets the range of double precision floating point values accepted by the

   941     dialog when used in DoubleInput mode, with minimum and maximum values

   942     specified by \a min and \a max respectively.

   943 */

   944 void QInputDialog::setDoubleRange(double min, double max)

   945 {

   946     Q_D(QInputDialog);

   947     d->ensureDoubleSpinBox();

   948     d->doubleSpinBox->setRange(min, max);

   949 }

   950 

   951 /*!

   952     \since 4.5

   953 

   954     \property QInputDialog::doubleDecimals

   955 

   956     \brief sets the percision of the double spinbox in decimals

   957 

   958     \sa QDoubleSpinBox::setDecimals()

   959 */

   960 void QInputDialog::setDoubleDecimals(int decimals)

   961 {

   962     Q_D(QInputDialog);

   963     d->ensureDoubleSpinBox();

   964     d->doubleSpinBox->setDecimals(decimals);

   965 }

   966 

   967 int QInputDialog::doubleDecimals() const

   968 {

   969     Q_D(const QInputDialog);

   970     if (d->doubleSpinBox) {

   971         return d->doubleSpinBox->decimals();

   972     } else {

   973         return 2;

   974     }

   975 }

   976 

   977 /*!

   978     \since 4.5

   979 

   980     \property QInputDialog::okButtonText

   981 

   982     \brief the text for the button used to accept the entry in the dialog

   983 */

   984 void QInputDialog::setOkButtonText(const QString &text)

   985 {

   986     Q_D(const QInputDialog);

   987     d->ensureLayout();

   988     d->buttonBox->button(QDialogButtonBox::Ok)->setText(text);

   989 }

   990 

   991 QString QInputDialog::okButtonText() const

   992 {

   993     Q_D(const QInputDialog);

   994     d->ensureLayout();

   995     return d->buttonBox->button(QDialogButtonBox::Ok)->text();

   996 }

   997 

   998 /*!

   999     \since 4.5

  1000 

  1001     \property QInputDialog::cancelButtonText

  1002     \brief the text for the button used to cancel the dialog

  1003 */

  1004 void QInputDialog::setCancelButtonText(const QString &text)

  1005 {

  1006     Q_D(const QInputDialog);

  1007     d->ensureLayout();

  1008     d->buttonBox->button(QDialogButtonBox::Cancel)->setText(text);

  1009 }

  1010 

  1011 QString QInputDialog::cancelButtonText() const

  1012 {

  1013     Q_D(const QInputDialog);

  1014     d->ensureLayout();

  1015     return d->buttonBox->button(QDialogButtonBox::Cancel)->text();

  1016 }

  1017 

  1018 /*!

  1019     \since 4.5

  1020     \overload

  1021 

  1022     This function connects one of its signals to the slot specified by \a receiver

  1023     and \a member. The specific signal depends on the arguments that are specified

  1024     in \a member. These are:

  1025 

  1026     \list

  1027       \o textValueSelected() if \a member has a QString for its first argument.

  1028       \o intValueSelected() if \a member has an int for its first argument.

  1029       \o doubleValueSelected() if \a member has a double for its first argument.

  1030       \o accepted() if \a member has NO arguments.

  1031     \endlist

  1032 

  1033     The signal will be disconnected from the slot when the dialog is closed.

  1034 */

  1035 void QInputDialog::open(QObject *receiver, const char *member)

  1036 {

  1037     Q_D(QInputDialog);

  1038     connect(this, signalForMember(member), receiver, member);

  1039     d->receiverToDisconnectOnClose = receiver;

  1040     d->memberToDisconnectOnClose = member;

  1041     QDialog::open();

  1042 }

  1043 

  1044 /*!

  1045     \reimp

  1046 */

  1047 QSize QInputDialog::minimumSizeHint() const

  1048 {

  1049     Q_D(const QInputDialog);

  1050     d->ensureLayout();

  1051     return QDialog::minimumSizeHint();

  1052 }

  1053 

  1054 /*!

  1055     \reimp

  1056 */

  1057 QSize QInputDialog::sizeHint() const

  1058 {

  1059     Q_D(const QInputDialog);

  1060     d->ensureLayout();

  1061     return QDialog::sizeHint();

  1062 }

  1063 

  1064 /*!

  1065     \reimp

  1066 */

  1067 void QInputDialog::setVisible(bool visible)

  1068 {

  1069     Q_D(const QInputDialog);

  1070     if (visible) {

  1071         d->ensureLayout();

  1072         d->inputWidget->setFocus();

  1073         if (d->inputWidget == d->lineEdit) {

  1074             d->lineEdit->selectAll();

  1075         } else if (d->inputWidget == d->intSpinBox) {

  1076             d->intSpinBox->selectAll();

  1077         } else if (d->inputWidget == d->doubleSpinBox) {

  1078             d->doubleSpinBox->selectAll();

  1079         }

  1080     }

  1081     QDialog::setVisible(visible);

  1082 }

  1083 

  1084 /*!

  1085   Closes the dialog and sets its result code to \a result. If this dialog

  1086   is shown with exec(), done() causes the local event loop to finish,

  1087   and exec() to return \a result.

  1088 

  1089   \sa QDialog::done()

  1090 */

  1091 void QInputDialog::done(int result)

  1092 {

  1093     Q_D(QInputDialog);

  1094     QDialog::done(result);

  1095     if (result) {

  1096         InputMode mode = inputMode();

  1097         switch (mode) {

  1098         case DoubleInput:

  1099             emit doubleValueSelected(doubleValue());

  1100             break;

  1101         case IntInput:

  1102             emit intValueSelected(intValue());

  1103             break;

  1104         default:

  1105             Q_ASSERT(mode == TextInput);

  1106             emit textValueSelected(textValue());

  1107         }

  1108     }

  1109     if (d->receiverToDisconnectOnClose) {

  1110         disconnect(this, signalForMember(d->memberToDisconnectOnClose),

  1111                    d->receiverToDisconnectOnClose, d->memberToDisconnectOnClose);

  1112         d->receiverToDisconnectOnClose = 0;

  1113     }

  1114     d->memberToDisconnectOnClose.clear();

  1115 }

  1116 

  1117 /*!

  1118     Static convenience function to get a string from the user.

  1119 

  1120     \a title is the text which is displayed in the title bar of the dialog.

  1121     \a label is the text which is shown to the user (it should say what should

  1122     be entered).

  1123     \a text is the default text which is placed in the line edit.

  1124     \a mode is the echo mode the line edit will use.

  1125 

  1126     If \a ok is nonnull \e *\a ok will be set to true if the user pressed

  1127     \gui OK and to false if the user pressed \gui Cancel. The dialog's parent

  1128     is \a parent. The dialog will be modal and uses the specified widget

  1129     \a flags.

  1130 

  1131     If the dialog is accepted, this function returns the text in the dialog's

  1132     line edit. If the dialog is rejected, a null QString is returned.

  1133 

  1134     Use this static function like this: