diff options
Diffstat (limited to 'src/quicktemplates2/qquickcombobox.cpp')
| -rw-r--r-- | src/quicktemplates2/qquickcombobox.cpp | 524 |
1 files changed, 512 insertions, 12 deletions
diff --git a/src/quicktemplates2/qquickcombobox.cpp b/src/quicktemplates2/qquickcombobox.cpp index 32a01b7b..d56c1a84 100644 --- a/src/quicktemplates2/qquickcombobox.cpp +++ b/src/quicktemplates2/qquickcombobox.cpp @@ -41,11 +41,15 @@ #include <QtCore/qregexp.h> #include <QtCore/qabstractitemmodel.h> +#include <QtGui/qinputmethod.h> +#include <QtGui/qguiapplication.h> #include <QtGui/qpa/qplatformtheme.h> #include <QtQml/qjsvalue.h> #include <QtQml/qqmlcontext.h> +#include <QtQml/private/qlazilyallocated_p.h> #include <QtQml/private/qqmldelegatemodel_p.h> #include <QtQuick/private/qquickevents_p_p.h> +#include <QtQuick/private/qquicktextinput_p.h> QT_BEGIN_NAMESPACE @@ -74,6 +78,30 @@ QT_BEGIN_NAMESPACE } \endcode + \section1 Editable ComboBox + + ComboBox can be made \l editable. An editable combo box auto-completes + its text based on what is available in the model. + + The following example demonstrates appending content to an editable + combo box by reacting to the \l accepted signal. + + \code + ComboBox { + editable: true + model: ListModel { + id: model + ListElement { text: "Banana" } + ListElement { text: "Apple" } + ListElement { text: "Coconut" } + } + onAccepted: { + if (find(editText) === -1) + model.append({text: editText}) + } + } + \endcode + \section1 ComboBox Model Roles ComboBox is able to visualize standard \l {qml-data-models}{data models} @@ -130,6 +158,19 @@ QT_BEGIN_NAMESPACE \sa highlightedIndex */ +/*! + \since QtQuick.Controls 2.2 + \qmlsignal void QtQuick.Controls::ComboBox::accepted() + + This signal is emitted when the \uicontrol Return or \uicontrol Enter key is pressed + on an \l editable combo box. If the confirmed string is not currently in the model, + the \l currentIndex will be set to \c -1 and the \c currentText will be updated + accordingly. + + \note If there is a \l validator set on the combo box, the signal will only be + emitted if the input is in an acceptable state. +*/ + namespace { enum Activation { NoActivate, Activate }; enum Highlighting { NoHighlight, Highlight }; @@ -170,20 +211,26 @@ class QQuickComboBoxPrivate : public QQuickControlPrivate Q_DECLARE_PUBLIC(QQuickComboBox) public: - QQuickComboBoxPrivate() : flat(false), pressed(false), ownModel(false), hasDisplayText(false), hasCurrentIndex(false), - highlightedIndex(-1), currentIndex(-1), delegateModel(nullptr), - delegate(nullptr), indicator(nullptr), popup(nullptr) { } + QQuickComboBoxPrivate(); bool isPopupVisible() const; void showPopup(); void hidePopup(bool accept); void togglePopup(bool accept); + void popupVisibleChanged(); void itemClicked(); void createdItem(int index, QObject *object); + void modelUpdated(); void countChanged(); + + void updateEditText(); void updateCurrentText(); + + void acceptInput(); + QString tryComplete(const QString &inputText); + void incrementCurrentIndex(); void decrementCurrentIndex(); void setCurrentIndex(int index, Activation activate); @@ -196,6 +243,8 @@ public: void createDelegateModel(); bool flat; + bool down; + bool hasDown; bool pressed; bool ownModel; bool hasDisplayText; @@ -211,8 +260,42 @@ public: QQmlComponent *delegate; QQuickItem *indicator; QQuickPopup *popup; + + struct ExtraData { + ExtraData() + : editable(false), + accepting(false), + allowComplete(false), + inputMethodHints(Qt::ImhNone), + validator(nullptr) { } + + bool editable; + bool accepting; + bool allowComplete; + Qt::InputMethodHints inputMethodHints; + QString editText; + QValidator *validator; + }; + QLazilyAllocated<ExtraData> extra; }; +QQuickComboBoxPrivate::QQuickComboBoxPrivate() + : flat(false), + down(false), + hasDown(false), + pressed(false), + ownModel(false), + hasDisplayText(false), + hasCurrentIndex(false), + highlightedIndex(-1), + currentIndex(-1), + delegateModel(nullptr), + delegate(nullptr), + indicator(nullptr), + popup(nullptr) +{ +} + bool QQuickComboBoxPrivate::isPopupVisible() const { return popup && popup->isVisible(); @@ -246,6 +329,19 @@ void QQuickComboBoxPrivate::togglePopup(bool accept) showPopup(); } +void QQuickComboBoxPrivate::popupVisibleChanged() +{ + Q_Q(QQuickComboBox); + if (isPopupVisible()) + QGuiApplication::inputMethod()->reset(); + + updateHighlightedIndex(); + if (!hasDown) { + q->setDown(pressed || isPopupVisible()); + hasDown = false; + } +} + void QQuickComboBoxPrivate::itemClicked() { Q_Q(QQuickComboBox); @@ -258,13 +354,26 @@ void QQuickComboBoxPrivate::itemClicked() void QQuickComboBoxPrivate::createdItem(int index, QObject *object) { + Q_Q(QQuickComboBox); + QQuickItem *item = qobject_cast<QQuickItem *>(object); + if (popup && item && !item->parentItem()) { + item->setParentItem(popup->contentItem()); + QQuickItemPrivate::get(item)->setCulled(true); + } + QQuickAbstractButton *button = qobject_cast<QQuickAbstractButton *>(object); if (button) { button->setFocusPolicy(Qt::NoFocus); connect(button, &QQuickAbstractButton::clicked, this, &QQuickComboBoxPrivate::itemClicked); } - if (index == currentIndex) + if (index == currentIndex && !q->isEditable()) + updateCurrentText(); +} + +void QQuickComboBoxPrivate::modelUpdated() +{ + if (!extra.isAllocated() || !extra->accepting) updateCurrentText(); } @@ -276,6 +385,26 @@ void QQuickComboBoxPrivate::countChanged() emit q->countChanged(); } +void QQuickComboBoxPrivate::updateEditText() +{ + Q_Q(QQuickComboBox); + QQuickTextInput *input = qobject_cast<QQuickTextInput *>(contentItem); + if (!input) + return; + + const QString text = input->text(); + + if (extra.isAllocated() && extra->allowComplete && !text.isEmpty()) { + const QString completed = tryComplete(text); + if (completed.length() > text.length()) { + input->setText(completed); + input->select(completed.length(), text.length()); + return; + } + } + q->setEditText(text); +} + void QQuickComboBoxPrivate::updateCurrentText() { Q_Q(QQuickComboBox); @@ -290,6 +419,45 @@ void QQuickComboBoxPrivate::updateCurrentText() displayText = text; emit q->displayTextChanged(); } + if (!extra.isAllocated() || !extra->accepting) + q->setEditText(currentText); +} + +void QQuickComboBoxPrivate::acceptInput() +{ + Q_Q(QQuickComboBox); + int idx = q->find(extra.value().editText, Qt::MatchFixedString); + if (idx > -1) + q->setCurrentIndex(idx); + + extra.value().accepting = true; + emit q->accepted(); + + if (idx == -1) + q->setCurrentIndex(q->find(extra.value().editText, Qt::MatchFixedString)); + extra.value().accepting = false; +} + +QString QQuickComboBoxPrivate::tryComplete(const QString &input) +{ + Q_Q(QQuickComboBox); + QString match; + + const int itemCount = q->count(); + for (int idx = 0; idx < itemCount; ++idx) { + const QString text = q->textAt(idx); + if (!text.startsWith(input, Qt::CaseInsensitive)) + continue; + + // either the first or the shortest match + if (match.isEmpty() || text.length() < match.length()) + match = text; + } + + if (match.isEmpty()) + return input; + + return input + match.mid(input.length()); } void QQuickComboBoxPrivate::setCurrentIndex(int index, Activation activate) @@ -311,6 +479,8 @@ void QQuickComboBoxPrivate::setCurrentIndex(int index, Activation activate) void QQuickComboBoxPrivate::incrementCurrentIndex() { Q_Q(QQuickComboBox); + if (extra.isAllocated()) + extra->allowComplete = false; if (isPopupVisible()) { if (highlightedIndex < q->count() - 1) setHighlightedIndex(highlightedIndex + 1, Highlight); @@ -318,10 +488,14 @@ void QQuickComboBoxPrivate::incrementCurrentIndex() if (currentIndex < q->count() - 1) setCurrentIndex(currentIndex + 1, Activate); } + if (extra.isAllocated()) + extra->allowComplete = true; } void QQuickComboBoxPrivate::decrementCurrentIndex() { + if (extra.isAllocated()) + extra->allowComplete = false; if (isPopupVisible()) { if (highlightedIndex > 0) setHighlightedIndex(highlightedIndex - 1, Highlight); @@ -329,6 +503,8 @@ void QQuickComboBoxPrivate::decrementCurrentIndex() if (currentIndex > 0) setCurrentIndex(currentIndex - 1, Activate); } + if (extra.isAllocated()) + extra->allowComplete = true; } void QQuickComboBoxPrivate::updateHighlightedIndex() @@ -415,7 +591,7 @@ void QQuickComboBoxPrivate::createDelegateModel() QQmlInstanceModel* oldModel = delegateModel; if (oldModel) { disconnect(delegateModel, &QQmlInstanceModel::countChanged, this, &QQuickComboBoxPrivate::countChanged); - disconnect(delegateModel, &QQmlInstanceModel::modelUpdated, this, &QQuickComboBoxPrivate::updateCurrentText); + disconnect(delegateModel, &QQmlInstanceModel::modelUpdated, this, &QQuickComboBoxPrivate::modelUpdated); disconnect(delegateModel, &QQmlInstanceModel::createdItem, this, &QQuickComboBoxPrivate::createdItem); } @@ -435,7 +611,7 @@ void QQuickComboBoxPrivate::createDelegateModel() if (delegateModel) { connect(delegateModel, &QQmlInstanceModel::countChanged, this, &QQuickComboBoxPrivate::countChanged); - connect(delegateModel, &QQmlInstanceModel::modelUpdated, this, &QQuickComboBoxPrivate::updateCurrentText); + connect(delegateModel, &QQmlInstanceModel::modelUpdated, this, &QQuickComboBoxPrivate::modelUpdated); connect(delegateModel, &QQmlInstanceModel::createdItem, this, &QQuickComboBoxPrivate::createdItem); } @@ -451,6 +627,7 @@ QQuickComboBox::QQuickComboBox(QQuickItem *parent) : setFocusPolicy(Qt::StrongFocus); setFlag(QQuickItem::ItemIsFocusScope); setAcceptedMouseButtons(Qt::LeftButton); + setInputMethodHints(Qt::ImhNoPredictiveText); } QQuickComboBox::~QQuickComboBox() @@ -533,6 +710,48 @@ QQmlInstanceModel *QQuickComboBox::delegateModel() const } /*! + \since QtQuick.Controls 2.2 + \qmlproperty bool QtQuick.Controls::ComboBox::editable + + This property holds whether the combo box is editable. + + The default value is \c false. + + \sa validator +*/ +bool QQuickComboBox::isEditable() const +{ + Q_D(const QQuickComboBox); + return d->extra.isAllocated() && d->extra->editable; +} + +void QQuickComboBox::setEditable(bool editable) +{ + Q_D(QQuickComboBox); + if (editable == isEditable()) + return; + + if (d->contentItem) { + if (editable) { + d->contentItem->installEventFilter(this); + if (QQuickTextInput *input = qobject_cast<QQuickTextInput *>(d->contentItem)) { + QObjectPrivate::connect(input, &QQuickTextInput::textChanged, d, &QQuickComboBoxPrivate::updateEditText); + QObjectPrivate::connect(input, &QQuickTextInput::accepted, d, &QQuickComboBoxPrivate::acceptInput); + } + } else { + d->contentItem->removeEventFilter(this); + if (QQuickTextInput *input = qobject_cast<QQuickTextInput *>(d->contentItem)) { + QObjectPrivate::disconnect(input, &QQuickTextInput::textChanged, d, &QQuickComboBoxPrivate::updateEditText); + QObjectPrivate::disconnect(input, &QQuickTextInput::accepted, d, &QQuickComboBoxPrivate::acceptInput); + } + } + } + + d->extra.value().editable = editable; + emit editableChanged(); +} + +/*! \since QtQuick.Controls 2.1 \qmlproperty bool QtQuick.Controls::ComboBox::flat @@ -563,9 +782,52 @@ void QQuickComboBox::setFlat(bool flat) } /*! + \since QtQuick.Controls 2.2 + \qmlproperty bool QtQuick.Controls::ComboBox::down + + This property holds whether the combo box button is visually down. + + Unless explicitly set, this property is \c true when either \c pressed + or \c popup.visible is \c true. To return to the default value, set this + property to \c undefined. + + \sa pressed, popup +*/ +bool QQuickComboBox::isDown() const +{ + Q_D(const QQuickComboBox); + return d->down; +} + +void QQuickComboBox::setDown(bool down) +{ + Q_D(QQuickComboBox); + d->hasDown = true; + + if (d->down == down) + return; + + d->down = down; + emit downChanged(); +} + +void QQuickComboBox::resetDown() +{ + Q_D(QQuickComboBox); + if (!d->hasDown) + return; + + setDown(d->pressed || d->isPopupVisible()); + d->hasDown = false; +} + +/*! \qmlproperty bool QtQuick.Controls::ComboBox::pressed - This property holds whether the combo box button is pressed. + This property holds whether the combo box button is physically pressed. + A button can be pressed by either touch or key events. + + \sa down */ bool QQuickComboBox::isPressed() const { @@ -581,6 +843,11 @@ void QQuickComboBox::setPressed(bool pressed) d->pressed = pressed; emit pressedChanged(); + + if (!d->hasDown) { + setDown(d->pressed || d->isPopupVisible()); + d->hasDown = false; + } } /*! @@ -683,6 +950,35 @@ void QQuickComboBox::resetDisplayText() } /*! + \since QtQuick.Controls 2.2 + \qmlproperty string QtQuick.Controls::ComboBox::editText + + This property holds the text in the text field of an editable combo box. + + \sa editable +*/ +QString QQuickComboBox::editText() const +{ + Q_D(const QQuickComboBox); + return d->extra.isAllocated() ? d->extra->editText : QString(); +} + +void QQuickComboBox::setEditText(const QString &text) +{ + Q_D(QQuickComboBox); + if (text == editText()) + return; + + d->extra.value().editText = text; + emit editTextChanged(); +} + +void QQuickComboBox::resetEditText() +{ + setEditText(QString()); +} + +/*! \qmlproperty string QtQuick.Controls::ComboBox::textRole This property holds the model role used for populating the combo box. @@ -807,18 +1103,127 @@ void QQuickComboBox::setPopup(QQuickPopup *popup) return; if (d->popup) - QObjectPrivate::disconnect(d->popup, &QQuickPopup::visibleChanged, d, &QQuickComboBoxPrivate::updateHighlightedIndex); + QObjectPrivate::disconnect(d->popup, &QQuickPopup::visibleChanged, d, &QQuickComboBoxPrivate::popupVisibleChanged); d->deleteDelegate(d->popup); if (popup) { QQuickPopupPrivate::get(popup)->allowVerticalFlip = true; popup->setClosePolicy(QQuickPopup::CloseOnEscape | QQuickPopup::CloseOnPressOutsideParent); - QObjectPrivate::connect(popup, &QQuickPopup::visibleChanged, d, &QQuickComboBoxPrivate::updateHighlightedIndex); + QObjectPrivate::connect(popup, &QQuickPopup::visibleChanged, d, &QQuickComboBoxPrivate::popupVisibleChanged); } d->popup = popup; emit popupChanged(); } /*! + \since QtQuick.Controls 2.2 + \qmlproperty Validator QtQuick.Controls::ComboBox::validator + + This property holds an input text validator for an editable combo box. + + When a validator is set, the text field will only accept input which + leaves the text property in an intermediate state. The \l accepted signal + will only be emitted if the text is in an acceptable state when the + \uicontrol Return or \uicontrol Enter key is pressed. + + The currently supported validators are \l[QtQuick]{IntValidator}, + \l[QtQuick]{DoubleValidator}, and \l[QtQuick]{RegExpValidator}. An + example of using validators is shown below, which allows input of + integers between \c 0 and \c 10 into the text field: + + \code + ComboBox { + model: 10 + editable: true + validator: IntValidator { + top: 9 + bottom: 0 + } + } + \endcode + + \sa acceptableInput, accepted, editable +*/ +QValidator *QQuickComboBox::validator() const +{ + Q_D(const QQuickComboBox); + return d->extra.isAllocated() ? d->extra->validator : nullptr; +} + +void QQuickComboBox::setValidator(QValidator *validator) +{ + Q_D(QQuickComboBox); + if (validator == QQuickComboBox::validator()) + return; + + d->extra.value().validator = validator; + if (validator) + validator->setLocale(d->locale); + emit validatorChanged(); +} + +/*! + \since QtQuick.Controls 2.2 + \qmlproperty flags QtQuick.Controls::ComboBox::inputMethodHints + + Provides hints to the input method about the expected content of the combo box and how it + should operate. + + The default value is \c Qt.ImhNoPredictiveText. + + \include inputmethodhints.qdocinc +*/ +Qt::InputMethodHints QQuickComboBox::inputMethodHints() const +{ + Q_D(const QQuickComboBox); + return d->extra.isAllocated() ? d->extra->inputMethodHints : Qt::ImhNoPredictiveText; +} + +void QQuickComboBox::setInputMethodHints(Qt::InputMethodHints hints) +{ + Q_D(QQuickComboBox); + if (hints == inputMethodHints()) + return; + + d->extra.value().inputMethodHints = hints; + emit inputMethodHintsChanged(); +} + +/*! + \since QtQuick.Controls 2.2 + \qmlproperty bool QtQuick.Controls::ComboBox::inputMethodComposing + \readonly + + This property holds whether an editable combo box has partial text input from an input method. + + While it is composing, an input method may rely on mouse or key events from the combo box to + edit or commit the partial text. This property can be used to determine when to disable event + handlers that may interfere with the correct operation of an input method. +*/ +bool QQuickComboBox::isInputMethodComposing() const +{ + Q_D(const QQuickComboBox); + return d->contentItem && d->contentItem->property("inputMethodComposing").toBool(); +} + +/*! + \since QtQuick.Controls 2.2 + \qmlproperty bool QtQuick.Controls::ComboBox::acceptableInput + \readonly + + This property holds whether the combo box contains acceptable text in the editable text field. + + If a validator has been set, the value is \c true only if the current text is acceptable + to the validator as a final string (not as an intermediate string). + + \sa validator, accepted +*/ +bool QQuickComboBox::hasAcceptableInput() const +{ + Q_D(const QQuickComboBox); + return d->contentItem && d->contentItem->property("acceptableInput").toBool(); +} + +/*! \qmlmethod string QtQuick.Controls::ComboBox::textAt(int index) Returns the text for the specified \a index, or an empty string @@ -895,6 +1300,59 @@ void QQuickComboBox::decrementCurrentIndex() d->decrementCurrentIndex(); } +/*! + \since QtQuick.Controls 2.2 + \qmlmethod void QtQuick.Controls::ComboBox::selectAll() + + Selects all the text in the editable text field of the combo box. + + \sa editText +*/ +void QQuickComboBox::selectAll() +{ + Q_D(QQuickComboBox); + QQuickTextInput *input = qobject_cast<QQuickTextInput *>(d->contentItem); + if (!input) + return; + input->selectAll(); +} + +bool QQuickComboBox::eventFilter(QObject *object, QEvent *event) +{ + Q_D(QQuickComboBox); + switch (event->type()) { + case QEvent::MouseButtonRelease: + if (d->isPopupVisible()) + d->hidePopup(false); + break; + case QEvent::KeyPress: { + const int key = static_cast<QKeyEvent *>(event)->key(); + if (d->extra.isAllocated()) + d->extra->allowComplete = key != Qt::Key_Backspace && key != Qt::Key_Delete; + break; + } + case QEvent::FocusOut: + d->hidePopup(false); + setPressed(false); + break; + case QEvent::InputMethod: + if (d->extra.isAllocated()) + d->extra->allowComplete = !static_cast<QInputMethodEvent*>(event)->commitString().isEmpty(); + break; + default: + break; + } + return QQuickControl::eventFilter(object, event); +} + +void QQuickComboBox::focusInEvent(QFocusEvent *event) +{ + Q_D(QQuickComboBox); + QQuickControl::focusInEvent(event); + if (d->contentItem && isEditable()) + d->contentItem->forceActiveFocus(event->reason()); +} + void QQuickComboBox::focusOutEvent(QFocusEvent *event) { Q_D(QQuickComboBox); @@ -903,6 +1361,16 @@ void QQuickComboBox::focusOutEvent(QFocusEvent *event) setPressed(false); } +void QQuickComboBox::inputMethodEvent(QInputMethodEvent *event) +{ + Q_D(QQuickComboBox); + QQuickControl::inputMethodEvent(event); + if (!isEditable() && !event->commitString().isEmpty()) + d->keySearch(event->commitString()); + else + event->ignore(); +} + void QQuickComboBox::keyPressEvent(QKeyEvent *event) { Q_D(QQuickComboBox); @@ -948,7 +1416,7 @@ void QQuickComboBox::keyPressEvent(QKeyEvent *event) event->accept(); break; default: - if (!event->text().isEmpty()) + if (!isEditable() && !event->text().isEmpty()) d->keySearch(event->text()); else event->ignore(); @@ -965,13 +1433,15 @@ void QQuickComboBox::keyReleaseEvent(QKeyEvent *event) switch (event->key()) { case Qt::Key_Space: - d->togglePopup(true); + if (!isEditable()) + d->togglePopup(true); setPressed(false); event->accept(); break; case Qt::Key_Enter: case Qt::Key_Return: - d->hidePopup(d->isPopupVisible()); + if (!isEditable() || d->isPopupVisible()) + d->hidePopup(d->isPopupVisible()); setPressed(false); event->accept(); break; @@ -1044,6 +1514,36 @@ void QQuickComboBox::componentComplete() } } +void QQuickComboBox::contentItemChange(QQuickItem *newItem, QQuickItem *oldItem) +{ + Q_D(QQuickComboBox); + if (oldItem) { + oldItem->removeEventFilter(this); + if (QQuickTextInput *oldInput = qobject_cast<QQuickTextInput *>(oldItem)) { + QObjectPrivate::disconnect(oldInput, &QQuickTextInput::accepted, d, &QQuickComboBoxPrivate::acceptInput); + QObjectPrivate::disconnect(oldInput, &QQuickTextInput::textChanged, d, &QQuickComboBoxPrivate::updateEditText); + disconnect(oldInput, &QQuickTextInput::inputMethodComposingChanged, this, &QQuickComboBox::inputMethodComposingChanged); + disconnect(oldInput, &QQuickTextInput::acceptableInputChanged, this, &QQuickComboBox::acceptableInputChanged); + } + } + if (newItem && isEditable()) { + newItem->installEventFilter(this); + if (QQuickTextInput *newInput = qobject_cast<QQuickTextInput *>(newItem)) { + QObjectPrivate::connect(newInput, &QQuickTextInput::accepted, d, &QQuickComboBoxPrivate::acceptInput); + QObjectPrivate::connect(newInput, &QQuickTextInput::textChanged, d, &QQuickComboBoxPrivate::updateEditText); + connect(newInput, &QQuickTextInput::inputMethodComposingChanged, this, &QQuickComboBox::inputMethodComposingChanged); + connect(newInput, &QQuickTextInput::acceptableInputChanged, this, &QQuickComboBox::acceptableInputChanged); + } + } +} + +void QQuickComboBox::localeChange(const QLocale &newLocale, const QLocale &oldLocale) +{ + QQuickControl::localeChange(newLocale, oldLocale); + if (QValidator *v = validator()) + v->setLocale(newLocale); +} + QFont QQuickComboBox::defaultFont() const { return QQuickControlPrivate::themeFont(QPlatformTheme::ComboMenuItemFont); |