/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qinputdialog.h"

#ifndef QT_NO_INPUTDIALOG

#include "qapplication.h"

#include "qcombobox.h"

#include "qdialogbuttonbox.h"

#include "qlabel.h"

#include "qlayout.h"

#include "qlineedit.h"

#include "qlistwidget.h"

#include "qpushbutton.h"

#include "qspinbox.h"

#include "qstackedlayout.h"

#include "qvalidator.h"

#include "qevent.h"

#include "qdialog_p.h"

QT_USE_NAMESPACE

static const char *signalForMember(const char *member)

{

    static const int NumCandidates = 4;

    static const char * const candidateSignals[NumCandidates] = {

        SIGNAL(textValueSelected(QString)),

        SIGNAL(intValueSelected(int)),

        SIGNAL(doubleValueSelected(double)),

        SIGNAL(accepted())

    };

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

    int i = 0;

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

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

            break;

        ++i;

    }

    return candidateSignals[i];

}

QT_BEGIN_NAMESPACE

/*

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

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

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

    text is modified to the last valid value.

*/

class QInputDialogSpinBox : public QSpinBox

{

    Q_OBJECT

public:

    QInputDialogSpinBox(QWidget *parent)

        : QSpinBox(parent) {

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

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

    }

signals:

    void textChanged(bool);

private slots:

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

private:

    void keyPressEvent(QKeyEvent *event) {

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

#ifndef QT_NO_PROPERTIES

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

#endif

        } else {

            QSpinBox::keyPressEvent(event);

        }

        notifyTextChanged();

    }

    void mousePressEvent(QMouseEvent *event) {

        QSpinBox::mousePressEvent(event);

        notifyTextChanged();

    }

};

class QInputDialogDoubleSpinBox : public QDoubleSpinBox

{

    Q_OBJECT

public:

    QInputDialogDoubleSpinBox(QWidget *parent = 0)

        : QDoubleSpinBox(parent) {

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

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

    }

signals:

    void textChanged(bool);

private slots:

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

private:

    void keyPressEvent(QKeyEvent *event) {

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

#ifndef QT_NO_PROPERTIES

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

#endif

        } else {

            QDoubleSpinBox::keyPressEvent(event);

        }

        notifyTextChanged();

    }

    void mousePressEvent(QMouseEvent *event) {

        QDoubleSpinBox::mousePressEvent(event);

        notifyTextChanged();

    }

};

QT_BEGIN_INCLUDE_NAMESPACE

#include "qinputdialog.moc"

QT_END_INCLUDE_NAMESPACE

class QInputDialogPrivate : public QDialogPrivate

{

    Q_DECLARE_PUBLIC(QInputDialog)

public:

    QInputDialogPrivate();

    void ensureLayout();

    void ensureLineEdit();

    void ensureComboBox();

    void ensureListView();

    void ensureIntSpinBox();

    void ensureDoubleSpinBox();

    void ensureEnabledConnection(QAbstractSpinBox *spinBox);

    void setInputWidget(QWidget *widget);

    void chooseRightTextInputWidget();

    void setComboBoxText(const QString &text);

    void setListViewText(const QString &text);

    QString listViewText() const;

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

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

    void _q_textChanged(const QString &text);

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

    mutable QLabel *label;

    mutable QDialogButtonBox *buttonBox;

    mutable QLineEdit *lineEdit;

    mutable QSpinBox *intSpinBox;

    mutable QDoubleSpinBox *doubleSpinBox;

    mutable QComboBox *comboBox;

    mutable QListView *listView;

    mutable QWidget *inputWidget;

    mutable QVBoxLayout *mainLayout;

    QInputDialog::InputDialogOptions opts;

    QString textValue;

    QPointer<QObject> receiverToDisconnectOnClose;

    QByteArray memberToDisconnectOnClose;

};

QInputDialogPrivate::QInputDialogPrivate()

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

      inputWidget(0), mainLayout(0)

{

}

void QInputDialogPrivate::ensureLayout()

{

    Q_Q(QInputDialog);

    if (mainLayout)

        return;

    if (!inputWidget) {

        ensureLineEdit();

        inputWidget = lineEdit;

    }

    if (!label)

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

#ifndef QT_NO_SHORTCUT

    label->setBuddy(inputWidget);

#endif

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

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

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

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

    mainLayout = new QVBoxLayout(q);

    mainLayout->setSizeConstraint(QLayout::SetMinAndMaxSize);

    mainLayout->addWidget(label);

    mainLayout->addWidget(inputWidget);

    mainLayout->addWidget(buttonBox);

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

    inputWidget->show();

}

void QInputDialogPrivate::ensureLineEdit()

{

    Q_Q(QInputDialog);

    if (!lineEdit) {

        lineEdit = new QLineEdit(q);

        lineEdit->hide();

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

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

    }

}

void QInputDialogPrivate::ensureComboBox()

{

    Q_Q(QInputDialog);

    if (!comboBox) {

        comboBox = new QComboBox(q);

        comboBox->hide();

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

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

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

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

    }

}

void QInputDialogPrivate::ensureListView()

{

    Q_Q(QInputDialog);

    if (!listView) {

        ensureComboBox();

        listView = new QListView(q);

        listView->hide();

        listView->setEditTriggers(QAbstractItemView::NoEditTriggers);

        listView->setSelectionMode(QAbstractItemView::SingleSelection);

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

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

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

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

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

    }

}

void QInputDialogPrivate::ensureIntSpinBox()

{

    Q_Q(QInputDialog);

    if (!intSpinBox) {

        intSpinBox = new QInputDialogSpinBox(q);

        intSpinBox->hide();

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

                         q, SIGNAL(intValueChanged(int)));

    }

}

void QInputDialogPrivate::ensureDoubleSpinBox()

{

    Q_Q(QInputDialog);

    if (!doubleSpinBox) {

        doubleSpinBox = new QInputDialogDoubleSpinBox(q);

        doubleSpinBox->hide();

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

                         q, SIGNAL(doubleValueChanged(double)));

    }

}

void QInputDialogPrivate::ensureEnabledConnection(QAbstractSpinBox *spinBox)

{

    if (spinBox) {

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

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

    }

}

void QInputDialogPrivate::setInputWidget(QWidget *widget)

{

    Q_ASSERT(widget);

    if (inputWidget == widget)

        return;

    if (mainLayout) {

        Q_ASSERT(inputWidget);

        mainLayout->removeWidget(inputWidget);

        inputWidget->hide();

        mainLayout->insertWidget(1, widget);

        widget->show();

        // disconnect old input widget

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

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

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

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

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

        ensureEnabledConnection(spinBox);

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

    }

    inputWidget = widget;

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

    // textValue

    if (widget == lineEdit) {

        lineEdit->setText(textValue);

    } else if (widget == comboBox) {

        setComboBoxText(textValue);

    } else if (widget == listView) {

        setListViewText(textValue);

        ensureLayout();

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

    }

}

void QInputDialogPrivate::chooseRightTextInputWidget()

{

    QWidget *widget;

    if (useComboBoxOrListView()) {

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

            ensureListView();

            widget = listView;

        } else {

            widget = comboBox;

        }

    } else {

        ensureLineEdit();

        widget = lineEdit;

    }

    setInputWidget(widget);

    if (inputWidget == comboBox) {

        _q_textChanged(comboBox->currentText());

    } else if (inputWidget == listView) {

        _q_textChanged(listViewText());

    }

}

void QInputDialogPrivate::setComboBoxText(const QString &text)

{

    int index = comboBox->findText(text);

    if (index != -1) {

        comboBox->setCurrentIndex(index);

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

        comboBox->setEditText(text);

    }

}

void QInputDialogPrivate::setListViewText(const QString &text)

{

    int row = comboBox->findText(text);

    if (row != -1) {

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

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

                                                         | QItemSelectionModel::SelectCurrent);

    }

}

QString QInputDialogPrivate::listViewText() const

{

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

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

        return comboBox->itemText(row);

    } else {

        return QString();

    }

}

void QInputDialogPrivate::_q_textChanged(const QString &text)

{

    Q_Q(QInputDialog);

    if (textValue != text) {

        textValue = text;

        emit q->textValueChanged(text);

    }

}

void QInputDialogPrivate::_q_currentRowChanged(const QModelIndex &newIndex,

                                               const QModelIndex & /* oldIndex */)

{

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

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

}

/*!

    \class QInputDialog

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

    single value from the user.

    \ingroup standard-dialogs

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

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

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

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

    for example:

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

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

    is set to false.

    \img inputdialogs.png Input Dialogs

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

    QInputDialog as well as other built-in Qt dialogs.

    \sa QMessageBox, {Standard Dialogs Example}

*/

/*!

    \enum QInputDialog::InputMode

    \since 4.5

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

    the dialog.

    \value TextInput   Used to input text strings.

    \value IntInput    Used to input integers.

    \value DoubleInput Used to input floating point numbers with double

                       precision accuracy.

    \sa inputMode

*/

/*!

    \since 4.5

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

*/

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

    : QDialog(*new QInputDialogPrivate, parent, flags)

{

}

/*!

    \since 4.5

    Destroys the input dialog.

*/

QInputDialog::~QInputDialog()

{

}

/*!

    \since 4.5

    \property QInputDialog::inputMode

    \brief the mode used for input

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

    the dialog.

*/

void QInputDialog::setInputMode(InputMode mode)

{

    Q_D(QInputDialog);

    QWidget *widget;

    /*

        Warning: Some functions in QInputDialog rely on implementation details

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

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

    */

    switch (mode) {

    case IntInput:

        d->ensureIntSpinBox();

        widget = d->intSpinBox;

        break;

    case DoubleInput:

        d->ensureDoubleSpinBox();

        widget = d->doubleSpinBox;

        break;

    default:

        Q_ASSERT(mode == TextInput);

        d->chooseRightTextInputWidget();

        return;

    }

    d->setInputWidget(widget);

}

QInputDialog::InputMode QInputDialog::inputMode() const

{

    Q_D(const QInputDialog);