| /**************************************************************************** |
| ** |
| ** Copyright (C) 2016 The Qt Company Ltd. |
| ** Contact: https://www.qt.io/licensing/ |
| ** |
| ** This file is part of the Qt Quick Controls 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$ |
| ** |
| ****************************************************************************/ |
| |
| import QtQuick 2.6 |
| import QtQuick.Controls 1.2 |
| import QtQuick.Controls.Private 1.0 |
| |
| /*! |
| \qmltype TextField |
| \inqmlmodule QtQuick.Controls |
| \since 5.1 |
| \ingroup controls |
| \brief Displays a single line of editable plain text. |
| |
| \image textfield.png |
| |
| TextField is used to accept a line of text input. Input constraints can be |
| placed on a TextField item (for example, through a \l validator or \l |
| inputMask). Setting \l echoMode to an appropriate value enables |
| TextField to be used for a password input field. |
| |
| \qml |
| TextField { |
| placeholderText: qsTr("Enter name") |
| } |
| \endqml |
| |
| You can create a custom appearance for a TextField by |
| assigning a \l {TextFieldStyle}. |
| |
| \sa TextArea, TextInput |
| */ |
| |
| Control { |
| id: textfield |
| |
| /*! |
| \qmlproperty bool TextField::acceptableInput |
| |
| Returns \c true if the text field contains acceptable |
| text. |
| |
| If a validator or input mask was set, this property will return \c |
| true if the current text satisfies the validator or mask as |
| a final string (not as an intermediate string). |
| |
| The default value is \c true. |
| |
| \sa validator, inputMask, accepted |
| |
| */ |
| readonly property alias acceptableInput: textInput.acceptableInput // read only |
| |
| /*! |
| \qmlproperty bool TextField::activeFocusOnPress |
| |
| This property is set to \c true if the TextField should gain active |
| focus on a mouse press. |
| |
| The default value is \c true. |
| */ |
| property alias activeFocusOnPress: textInput.activeFocusOnPress |
| |
| /*! |
| \qmlproperty bool TextField::canPaste |
| |
| Returns \c true if the TextField is writable and the content of the |
| clipboard is suitable for pasting into the TextField. |
| */ |
| readonly property alias canPaste: textInput.canPaste |
| |
| /*! |
| \qmlproperty bool TextField::canRedo |
| |
| Returns \c true if the TextField is writable and there are \l |
| {undo}{undone} operations that can be redone. |
| */ |
| readonly property alias canRedo: textInput.canRedo |
| |
| /*! |
| \qmlproperty bool TextField::canUndo |
| |
| Returns \c true if the TextField is writable and there are previous |
| operations that can be undone. |
| */ |
| readonly property alias canUndo: textInput.canUndo |
| |
| /*! |
| \qmlproperty color TextField::textColor |
| |
| This property holds the text color. |
| */ |
| property alias textColor: textInput.color |
| |
| /*! |
| \qmlproperty int TextField::cursorPosition |
| |
| This property holds the position of the cursor in the TextField. |
| */ |
| property alias cursorPosition: textInput.cursorPosition |
| |
| /*! |
| \qmlproperty rect TextField::cursorRectangle |
| \since QtQuick.Controls 1.3 |
| |
| The rectangle where the text cursor is rendered within the text field. |
| */ |
| readonly property alias cursorRectangle: textInput.cursorRectangle |
| |
| /*! |
| \qmlproperty string TextField::displayText |
| |
| This property holds the text displayed in the TextField. |
| |
| If \l echoMode is set to TextInput::Normal, this holds the |
| same value as the TextField::text property. Otherwise, |
| this property holds the text visible to the user, while |
| the \l text property holds the actual entered text. |
| */ |
| readonly property alias displayText: textInput.displayText |
| |
| /*! |
| \qmlproperty enumeration TextField::echoMode |
| |
| Specifies how the text should be displayed in the |
| TextField. |
| |
| The possible modes are: |
| \list |
| \li TextInput.Normal - Displays the text as it is. (Default) |
| \li TextInput.Password - Displays asterisks instead of characters. |
| \li TextInput.NoEcho - Displays nothing. |
| \li TextInput.PasswordEchoOnEdit - Displays characters as they are |
| entered while editing, otherwise displays asterisks. |
| \endlist |
| */ |
| property alias echoMode: textInput.echoMode |
| Accessible.passwordEdit: echoMode == TextInput.Password || echoMode === TextInput.PasswordEchoOnEdit |
| |
| /*! |
| \qmlproperty font TextField::font |
| |
| Sets the font of the TextField. |
| */ |
| property alias font: textInput.font |
| |
| /*! |
| \qmlproperty enumeration TextField::horizontalAlignment |
| |
| Sets the alignment of the text within the TextField item's width. |
| |
| By default, the horizontal text alignment follows the natural alignment |
| of the text, for example text that is read from left to right will be |
| aligned to the left. |
| |
| The possible alignment values are: |
| \list |
| \li TextInput.AlignLeft |
| \li TextInput.AlignRight |
| \li TextInput.AlignHCenter |
| \endlist |
| |
| When using the attached property, LayoutMirroring::enabled, to mirror |
| application layouts, the horizontal alignment of text will also be |
| mirrored. However, the property \c horizontalAlignment will remain |
| unchanged. To query the effective horizontal alignment of TextField, use |
| the read-only property \c effectiveHorizontalAlignment. |
| */ |
| property alias horizontalAlignment: textInput.horizontalAlignment |
| |
| /*! |
| \qmlproperty enumeration TextField::effectiveHorizontalAlignment |
| |
| Gets the effective horizontal alignment of the text within the TextField |
| item's width. |
| |
| \l horizontalAlignment contains the default horizontal alignment. |
| |
| \sa horizontalAlignment |
| |
| */ |
| readonly property alias effectiveHorizontalAlignment: textInput.effectiveHorizontalAlignment |
| |
| /*! |
| \qmlproperty enumeration TextField::verticalAlignment |
| |
| Sets the alignment of the text within the TextField item's height. |
| |
| The possible alignment values are: |
| \list |
| \li TextInput.AlignTop |
| \li TextInput.AlignBottom |
| \li TextInput.AlignVCenter (default). |
| \endlist |
| */ |
| property alias verticalAlignment: textInput.verticalAlignment |
| |
| /*! |
| \qmlproperty string TextField::inputMask |
| |
| Sets an input mask on the TextField, restricting the allowable text |
| inputs. See QLineEdit::inputMask for further details, as the exact same |
| mask strings are used by TextField. |
| |
| \sa acceptableInput, validator |
| */ |
| property alias inputMask: textInput.inputMask |
| |
| /*! |
| \qmlproperty bool TextField::inputMethodComposing |
| \since QtQuick.Controls 1.3 |
| |
| This property holds whether the TextField has partial text input from an input method. |
| |
| While it is composing an input method may rely on mouse or key events from the TextField |
| to edit or commit the partial text. This property can be used to determine when to disable |
| events handlers that may interfere with the correct operation of an input method. |
| */ |
| readonly property bool inputMethodComposing: !!textInput.inputMethodComposing |
| |
| /*! |
| \qmlproperty enumeration TextField::inputMethodHints |
| |
| Provides hints to the input method about the expected content of the |
| text field and how it should operate. |
| |
| The value is a bit-wise combination of flags, or \c Qt.ImhNone if no |
| hints are set. |
| |
| The default value is \c Qt.ImhNone. |
| |
| Flags that alter behavior are: |
| |
| \list |
| \li Qt.ImhHiddenText - Characters should be hidden, as is typically used when entering passwords. |
| This is automatically set when setting echoMode to \c TextInput.Password. |
| \li Qt.ImhSensitiveData - Typed text should not be stored by the active input method |
| in any persistent storage like predictive user dictionary. |
| \li Qt.ImhNoAutoUppercase - The input method should not try to automatically switch to upper case |
| when a sentence ends. |
| \li Qt.ImhPreferNumbers - Numbers are preferred (but not required). |
| \li Qt.ImhPreferUppercase - Uppercase letters are preferred (but not required). |
| \li Qt.ImhPreferLowercase - Lowercase letters are preferred (but not required). |
| \li Qt.ImhNoPredictiveText - Do not use predictive text (for example, dictionary lookup) while typing. |
| |
| \li Qt.ImhDate - The text editor functions as a date field. |
| \li Qt.ImhTime - The text editor functions as a time field. |
| \li Qt.ImhMultiLine - The text editor doesn't close software input keyboard when Return or Enter key is pressed (since QtQuick.Controls 1.3). |
| \endlist |
| |
| Flags that restrict input (exclusive flags) are: |
| |
| \list |
| \li Qt.ImhDigitsOnly - Only digits are allowed. |
| \li Qt.ImhFormattedNumbersOnly - Only number input is allowed. This includes decimal point and minus sign. |
| \li Qt.ImhUppercaseOnly - Only uppercase letter input is allowed. |
| \li Qt.ImhLowercaseOnly - Only lowercase letter input is allowed. |
| \li Qt.ImhDialableCharactersOnly - Only characters suitable for phone dialing are allowed. |
| \li Qt.ImhEmailCharactersOnly - Only characters suitable for email addresses are allowed. |
| \li Qt.ImhUrlCharactersOnly - Only characters suitable for URLs are allowed. |
| \endlist |
| |
| Masks: |
| \list |
| \li Qt.ImhExclusiveInputMask - This mask yields nonzero if any of the exclusive flags are used. |
| \endlist |
| */ |
| property alias inputMethodHints: textInput.inputMethodHints |
| |
| /*! |
| \qmlproperty int TextField::length |
| |
| Returns the total number of characters in the TextField item. |
| |
| If the TextField has an input mask, the length will include mask |
| characters and may differ from the length of the string returned by the |
| \l text property. |
| |
| This property can be faster than querying the length of the \l text |
| property as it doesn't require any copying or conversion of the |
| TextField's internal string data. |
| */ |
| readonly property alias length: textInput.length |
| |
| /*! |
| \qmlproperty int TextField::maximumLength |
| |
| This property holds the maximum permitted length of the text in the |
| TextField. |
| |
| If the text is too long, it is truncated at the limit. |
| */ |
| property alias maximumLength: textInput.maximumLength |
| |
| /*! |
| \qmlproperty string TextField::placeholderText |
| |
| This property contains the text that is shown in the text field when the |
| text field is empty. |
| */ |
| property alias placeholderText: placeholderTextComponent.text |
| |
| /*! |
| \qmlproperty bool TextField::readOnly |
| |
| Sets whether user input can modify the contents of the TextField. Read- |
| only is different from a disabled text field in that the text field will |
| appear to be active and text can still be selected and copied. |
| |
| If readOnly is set to \c true, then user input will not affect the text. |
| Any bindings or attempts to set the text property will still |
| work, however. |
| */ |
| property alias readOnly: textInput.readOnly |
| Accessible.readOnly: readOnly |
| |
| /*! |
| \qmlproperty bool TextField::selectByMouse |
| \since QtQuick.Controls 1.3 |
| |
| This property determines if the user can select the text with the |
| mouse. |
| |
| The default value is \c true. |
| */ |
| property bool selectByMouse: true |
| |
| /*! |
| \qmlproperty string TextField::selectedText |
| |
| Provides the text currently selected in the text input. |
| |
| It is equivalent to the following snippet, but is faster and easier |
| to use. |
| |
| \code |
| myTextField.text.toString().substring(myTextField.selectionStart, myTextField.selectionEnd); |
| \endcode |
| */ |
| readonly property alias selectedText: textInput.selectedText |
| |
| /*! |
| \qmlproperty int TextField::selectionEnd |
| |
| The cursor position after the last character in the current selection. |
| |
| This property is read-only. To change the selection, use |
| select(start,end), selectAll(), or selectWord(). |
| |
| \sa selectionStart, cursorPosition, selectedText |
| */ |
| readonly property alias selectionEnd: textInput.selectionEnd |
| |
| /*! |
| \qmlproperty int TextField::selectionStart |
| |
| The cursor position before the first character in the current selection. |
| |
| This property is read-only. To change the selection, use select(start,end), |
| selectAll(), or selectWord(). |
| |
| \sa selectionEnd, cursorPosition, selectedText |
| */ |
| readonly property alias selectionStart: textInput.selectionStart |
| |
| /*! |
| \qmlproperty string TextField::text |
| |
| This property contains the text in the TextField. |
| */ |
| property alias text: textInput.text |
| |
| /*! |
| \qmlproperty Validator TextField::validator |
| |
| Allows you to set a validator on the TextField. When a validator is set, |
| the TextField will only accept input which leaves the text property in |
| an intermediate state. The accepted signal will only be sent |
| if the text is in an acceptable state when enter is pressed. |
| |
| 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 11 and 31 into the text input: |
| |
| \code |
| import QtQuick 2.2 |
| import QtQuick.Controls 1.2 |
| |
| TextField { |
| validator: IntValidator {bottom: 11; top: 31;} |
| focus: true |
| } |
| \endcode |
| |
| \sa acceptableInput, inputMask, accepted |
| */ |
| property alias validator: textInput.validator |
| |
| /*! |
| \since QtQuick.Controls 1.3 |
| |
| This property contains the edit \l Menu for working |
| with text selection. Set it to \c null if no menu |
| is wanted. |
| */ |
| property Component menu: textInput.editMenu.defaultMenu |
| |
| /*! |
| \qmlsignal TextField::accepted() |
| |
| This signal is emitted when the Return or Enter key is pressed. |
| Note that if there is a \l validator or \l inputMask set on the text |
| field, the signal will only be emitted if the input is in an acceptable |
| state. |
| |
| The corresponding handler is \c onAccepted. |
| */ |
| signal accepted() |
| |
| /*! |
| \qmlsignal TextField::editingFinished() |
| \since QtQuick.Controls 1.1 |
| |
| This signal is emitted when the Return or Enter key is pressed or |
| the text field loses focus. Note that if there is a validator or |
| inputMask set on the text field and enter/return is pressed, this |
| signal will only be emitted if the input follows |
| the inputMask and the validator returns an acceptable state. |
| |
| The corresponding handler is \c onEditingFinished. |
| */ |
| signal editingFinished() |
| |
| /*! |
| \qmlmethod void TextField::copy() |
| |
| Copies the currently selected text to the system clipboard. |
| */ |
| function copy() { |
| textInput.copy() |
| } |
| |
| /*! |
| \qmlmethod void TextField::cut() |
| |
| Moves the currently selected text to the system clipboard. |
| */ |
| function cut() { |
| textInput.cut() |
| } |
| |
| /*! |
| \qmlmethod void TextField::deselect() |
| |
| Removes active text selection. |
| */ |
| function deselect() { |
| textInput.deselect(); |
| } |
| |
| /*! |
| \qmlmethod string TextField::getText(int start, int end) |
| |
| Removes the section of text that is between the \a start and \a end |
| positions from the TextField. |
| */ |
| function getText(start, end) { |
| return textInput.getText(start, end); |
| } |
| |
| /*! |
| \qmlmethod void TextField::insert(int position, string text) |
| |
| Inserts \a text into the TextField at \a position. |
| */ |
| function insert(position, text) { |
| textInput.insert(position, text); |
| } |
| |
| /*! |
| \qmlmethod bool TextField::isRightToLeft(int start, int end) |
| |
| Returns \c true if the natural reading direction of the editor text |
| found between positions \a start and \a end is right to left. |
| */ |
| function isRightToLeft(start, end) { |
| return textInput.isRightToLeft(start, end); |
| } |
| |
| /*! |
| \qmlmethod void TextField::paste() |
| |
| Replaces the currently selected text by the contents of the system |
| clipboard. |
| */ |
| function paste() { |
| textInput.paste() |
| } |
| |
| /*! |
| \qmlmethod void TextField::redo() |
| |
| Performs the last operation if redo is \l {canRedo}{available}. |
| */ |
| function redo() { |
| textInput.redo(); |
| } |
| |
| /*! |
| \qmlmethod void TextField::remove(int start, int end) |
| \since QtQuick.Controls 1.4 |
| |
| Removes the section of text that is between the \a start and \a end positions. |
| */ |
| function remove(start, end) { |
| textInput.remove(start, end) |
| } |
| |
| /*! |
| \qmlmethod void TextField::select(int start, int end) |
| |
| Causes the text from \a start to \a end to be selected. |
| |
| If either start or end is out of range, the selection is not changed. |
| |
| After calling select, selectionStart will become the lesser |
| and selectionEnd will become the greater (regardless of the order passed |
| to this method). |
| |
| \sa selectionStart, selectionEnd |
| */ |
| function select(start, end) { |
| textInput.select(start, end) |
| } |
| |
| /*! |
| \qmlmethod void TextField::selectAll() |
| |
| Causes all text to be selected. |
| */ |
| function selectAll() { |
| textInput.selectAll() |
| } |
| |
| /*! |
| \qmlmethod void TextField::selectWord() |
| |
| Causes the word closest to the current cursor position to be selected. |
| */ |
| function selectWord() { |
| textInput.selectWord() |
| } |
| |
| /*! |
| \qmlmethod void TextField::undo() |
| |
| Reverts the last operation if undo is \l {canUndo}{available}. undo() |
| deselects any current selection and updates the selection start to the |
| current cursor position. |
| */ |
| function undo() { |
| textInput.undo(); |
| } |
| |
| /*! \qmlproperty bool TextField::hovered |
| |
| This property holds whether the control is being hovered. |
| */ |
| readonly property alias hovered: textInput.containsMouse |
| |
| /*! \internal */ |
| property alias __contentHeight: textInput.contentHeight |
| |
| /*! \internal */ |
| property alias __contentWidth: textInput.contentWidth |
| |
| /*! \internal */ |
| property alias __baselineOffset: textInput.baselineOffset |
| |
| style: Settings.styleComponent(Settings.style, "TextFieldStyle.qml", textInput) |
| |
| activeFocusOnTab: true |
| |
| Accessible.name: text |
| Accessible.role: Accessible.EditableText |
| Accessible.description: placeholderText |
| |
| Text { |
| id: placeholderTextComponent |
| anchors.fill: textInput |
| font: textInput.font |
| horizontalAlignment: textInput.horizontalAlignment |
| verticalAlignment: textInput.verticalAlignment |
| opacity: !textInput.displayText && (!textInput.activeFocus || textInput.horizontalAlignment !== Qt.AlignHCenter) ? 1.0 : 0.0 |
| color: __panel ? __panel.placeholderTextColor : "darkgray" |
| clip: contentWidth > width; |
| elide: Text.ElideRight |
| renderType: __style ? __style.renderType : Text.NativeRendering |
| } |
| |
| TextInputWithHandles { |
| id: textInput |
| focus: true |
| passwordCharacter: __style && __style.passwordCharacter !== undefined ? __style.passwordCharacter |
| : Qt.styleHints.passwordMaskCharacter |
| selectionColor: __panel ? __panel.selectionColor : "darkred" |
| selectedTextColor: __panel ? __panel.selectedTextColor : "white" |
| |
| control: textfield |
| cursorHandle: __style ? __style.__cursorHandle : undefined |
| selectionHandle: __style ? __style.__selectionHandle : undefined |
| |
| font: __panel ? __panel.font : TextSingleton.font |
| anchors.leftMargin: __panel ? __panel.leftMargin : 0 |
| anchors.topMargin: __panel ? __panel.topMargin : 0 |
| anchors.rightMargin: __panel ? __panel.rightMargin : 0 |
| anchors.bottomMargin: __panel ? __panel.bottomMargin : 0 |
| |
| anchors.fill: parent |
| verticalAlignment: Text.AlignVCenter |
| |
| color: __panel ? __panel.textColor : "darkgray" |
| clip: contentWidth > width |
| |
| renderType: __style ? __style.renderType : Text.NativeRendering |
| |
| Keys.forwardTo: textfield |
| |
| EnterKey.type: control.EnterKey.type |
| |
| onAccepted: textfield.accepted() |
| |
| onEditingFinished: textfield.editingFinished() |
| } |
| } |