docs: 添加涉密文件自检工具实施计划
This commit is contained in:
@@ -0,0 +1,717 @@
|
||||
/****************************************************************************
|
||||
**
|
||||
** 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 QtQml 2.14 as Qml
|
||||
import QtQuick 2.2
|
||||
import QtQuick.Controls 1.2
|
||||
import QtQuick.Controls.Private 1.0
|
||||
|
||||
/*!
|
||||
\qmltype ComboBox
|
||||
\inqmlmodule QtQuick.Controls
|
||||
\since 5.1
|
||||
\ingroup controls
|
||||
\brief Provides a drop-down list functionality.
|
||||
|
||||
\image combobox.png
|
||||
|
||||
Add items to the ComboBox by assigning it a ListModel, or a list of strings
|
||||
to the \l model property.
|
||||
|
||||
\qml
|
||||
ComboBox {
|
||||
width: 200
|
||||
model: [ "Banana", "Apple", "Coconut" ]
|
||||
}
|
||||
\endqml
|
||||
|
||||
In this example we are demonstrating how to use a ListModel with a combo box.
|
||||
|
||||
\qml
|
||||
ComboBox {
|
||||
currentIndex: 2
|
||||
model: ListModel {
|
||||
id: cbItems
|
||||
ListElement { text: "Banana"; color: "Yellow" }
|
||||
ListElement { text: "Apple"; color: "Green" }
|
||||
ListElement { text: "Coconut"; color: "Brown" }
|
||||
}
|
||||
width: 200
|
||||
onCurrentIndexChanged: console.debug(cbItems.get(currentIndex).text + ", " + cbItems.get(currentIndex).color)
|
||||
}
|
||||
\endqml
|
||||
|
||||
You can make a combo box editable by setting the \l editable property. An editable combo box will
|
||||
autocomplete its text based on what is available in the model.
|
||||
|
||||
In the next example we demonstrate how you can append content to an editable combo box by
|
||||
reacting to the \l accepted signal. Note that you have to explicitly prevent duplicates.
|
||||
|
||||
\qml
|
||||
ComboBox {
|
||||
editable: true
|
||||
model: ListModel {
|
||||
id: model
|
||||
ListElement { text: "Banana"; color: "Yellow" }
|
||||
ListElement { text: "Apple"; color: "Green" }
|
||||
ListElement { text: "Coconut"; color: "Brown" }
|
||||
}
|
||||
onAccepted: {
|
||||
if (find(currentText) === -1) {
|
||||
model.append({text: editText})
|
||||
currentIndex = find(editText)
|
||||
}
|
||||
}
|
||||
}
|
||||
\endqml
|
||||
|
||||
|
||||
You can create a custom appearance for a ComboBox by
|
||||
assigning a \l {ComboBoxStyle}.
|
||||
*/
|
||||
|
||||
Control {
|
||||
id: comboBox
|
||||
|
||||
/*! \qmlproperty model ComboBox::model
|
||||
The model to populate the ComboBox from.
|
||||
|
||||
Changing the model after initialization will reset \l currentIndex to \c 0.
|
||||
*/
|
||||
property alias model: popupItems.model
|
||||
|
||||
/*! The model role used for populating the ComboBox. */
|
||||
property string textRole: ""
|
||||
|
||||
/*! \qmlproperty int ComboBox::currentIndex
|
||||
The index of the currently selected item in the ComboBox.
|
||||
|
||||
Setting currentIndex to \c -1 will reset the selection and clear the text
|
||||
label. If \l editable is \c true, you may also need to manually clear \l editText.
|
||||
|
||||
\sa model
|
||||
*/
|
||||
property alias currentIndex: popup.__selectedIndex
|
||||
|
||||
/*! \qmlproperty string ComboBox::currentText
|
||||
The text of the currently selected item in the ComboBox.
|
||||
|
||||
\note Since \c currentText depends on \c currentIndex, there's no way to ensure \c currentText
|
||||
will be up to date whenever a \c onCurrentIndexChanged handler is called.
|
||||
*/
|
||||
readonly property alias currentText: popup.currentText
|
||||
|
||||
/*! This property holds whether the combo box can be edited by the user.
|
||||
The default value is \c false.
|
||||
\since QtQuick.Controls 1.1
|
||||
*/
|
||||
property bool editable: false
|
||||
|
||||
/*! \qmlproperty string ComboBox::editText
|
||||
\since QtQuick.Controls 1.1
|
||||
This property specifies text being manipulated by the user for an editable combo box.
|
||||
*/
|
||||
property alias editText: input.text
|
||||
|
||||
/*! \qmlproperty enumeration ComboBox::inputMethodHints
|
||||
\since QtQuick.Controls 1.5
|
||||
Provides hints to the input method about the expected content of the combo box and how it
|
||||
should operate.
|
||||
|
||||
The value is a bit-wise combination of flags or \c Qt.ImhNone if no hints are set.
|
||||
|
||||
Flags that alter behavior are:
|
||||
|
||||
\list
|
||||
\li Qt.ImhHiddenText - Characters should be hidden, as is typically used when entering passwords.
|
||||
\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 - Upper case letters are preferred (but not required).
|
||||
\li Qt.ImhPreferLowercase - Lower case letters are preferred (but not required).
|
||||
\li Qt.ImhNoPredictiveText - Do not use predictive text (i.e. 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.
|
||||
\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 upper case letter input is allowed.
|
||||
\li Qt.ImhLowercaseOnly - Only lower case 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: input.inputMethodHints
|
||||
|
||||
/*! This property specifies whether the combobox should gain active focus when pressed.
|
||||
The default value is \c false. */
|
||||
property bool activeFocusOnPress: false
|
||||
|
||||
/*! \qmlproperty bool ComboBox::pressed
|
||||
|
||||
This property holds whether the button is being pressed. */
|
||||
readonly property bool pressed: mouseArea.effectivePressed || popup.__popupVisible
|
||||
|
||||
/*! \qmlproperty bool ComboBox::hovered
|
||||
|
||||
This property indicates whether the control is being hovered.
|
||||
*/
|
||||
readonly property bool hovered: mouseArea.containsMouse || input.containsMouse
|
||||
|
||||
/*! \qmlproperty int ComboBox::count
|
||||
\since QtQuick.Controls 1.1
|
||||
This property holds the number of items in the combo box.
|
||||
*/
|
||||
readonly property alias count: popupItems.count
|
||||
|
||||
/*! \qmlmethod string ComboBox::textAt(int index)
|
||||
Returns the text for a given \a index.
|
||||
If an invalid index is provided, \c null is returned
|
||||
\since QtQuick.Controls 1.1
|
||||
*/
|
||||
function textAt (index) {
|
||||
if (index >= count || index < 0)
|
||||
return null;
|
||||
return popupItems.objectAt(index).text;
|
||||
}
|
||||
|
||||
/*! \qmlmethod int ComboBox::find(string text)
|
||||
Finds and returns the index of a given \a text
|
||||
If no match is found, \c -1 is returned. The search is case sensitive.
|
||||
\since QtQuick.Controls 1.1
|
||||
*/
|
||||
function find (text) {
|
||||
return input.find(text, Qt.MatchExactly)
|
||||
}
|
||||
|
||||
/*!
|
||||
\qmlproperty Validator ComboBox::validator
|
||||
\since QtQuick.Controls 1.1
|
||||
|
||||
Allows you to set a text validator for an editable ComboBox.
|
||||
When a validator is set,
|
||||
the text field 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 field:
|
||||
|
||||
\note This property is only applied when \l editable is \c true
|
||||
|
||||
\qml
|
||||
import QtQuick 2.2
|
||||
import QtQuick.Controls 1.2
|
||||
|
||||
ComboBox {
|
||||
editable: true
|
||||
model: 10
|
||||
validator: IntValidator {bottom: 0; top: 10;}
|
||||
focus: true
|
||||
}
|
||||
\endqml
|
||||
|
||||
\sa acceptableInput, accepted, editable
|
||||
*/
|
||||
property alias validator: input.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.
|
||||
|
||||
\note The menu is only in use when \l editable is \c true
|
||||
*/
|
||||
property Component menu: input.editMenu.defaultMenu
|
||||
|
||||
/*!
|
||||
\qmlproperty bool ComboBox::acceptableInput
|
||||
\since QtQuick.Controls 1.1
|
||||
|
||||
Returns \c true if the combo box contains acceptable
|
||||
text in the editable text field.
|
||||
|
||||
If a validator 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).
|
||||
|
||||
\sa validator, accepted
|
||||
|
||||
*/
|
||||
readonly property alias acceptableInput: input.acceptableInput
|
||||
|
||||
/*!
|
||||
\qmlproperty bool ComboBox::selectByMouse
|
||||
\since QtQuick.Controls 1.3
|
||||
|
||||
This property determines if the user can select the text in
|
||||
the editable text field with the mouse.
|
||||
|
||||
The default value is \c true.
|
||||
*/
|
||||
property bool selectByMouse: true
|
||||
|
||||
/*!
|
||||
\qmlproperty bool ComboBox::inputMethodComposing
|
||||
\since QtQuick.Controls 1.3
|
||||
|
||||
This property holds whether an editable ComboBox has partial text input from an input method.
|
||||
|
||||
While it is composing an input method may rely on mouse or key events from the ComboBox
|
||||
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: !!input.inputMethodComposing
|
||||
|
||||
/*!
|
||||
\qmlsignal ComboBox::accepted()
|
||||
\since QtQuick.Controls 1.1
|
||||
|
||||
This signal is emitted when the Return or Enter key is pressed on an
|
||||
\l editable combo box. If the confirmed string is not currently in the model,
|
||||
the currentIndex will be set to -1 and the \l currentText will be updated
|
||||
accordingly.
|
||||
|
||||
\note If there is a \l validator set on the combobox,
|
||||
the signal will only be emitted if the input is in an acceptable state.
|
||||
|
||||
The corresponding handler is \c onAccepted.
|
||||
*/
|
||||
signal accepted
|
||||
|
||||
/*!
|
||||
\qmlsignal ComboBox::activated(int index)
|
||||
\since QtQuick.Controls 1.1
|
||||
|
||||
This signal is similar to currentIndex changed, but will only
|
||||
be emitted if the combo box index was changed by the user, not
|
||||
when set programmatically.
|
||||
|
||||
\e index is the activated model index, or \c -1 if a new string is
|
||||
accepted.
|
||||
|
||||
The corresponding handler is \c onActivated.
|
||||
*/
|
||||
signal activated(int index)
|
||||
|
||||
/*!
|
||||
\qmlmethod void ComboBox::selectAll()
|
||||
\since QtQuick.Controls 1.1
|
||||
|
||||
Causes all \l editText to be selected.
|
||||
*/
|
||||
function selectAll() {
|
||||
input.selectAll()
|
||||
}
|
||||
|
||||
/*! \internal */
|
||||
function __selectPrevItem() {
|
||||
input.blockUpdate = true
|
||||
if (currentIndex > 0) {
|
||||
currentIndex--;
|
||||
input.text = popup.currentText;
|
||||
activated(currentIndex);
|
||||
}
|
||||
input.blockUpdate = false;
|
||||
}
|
||||
|
||||
/*! \internal */
|
||||
function __selectNextItem() {
|
||||
input.blockUpdate = true;
|
||||
if (currentIndex < popupItems.count - 1) {
|
||||
currentIndex++;
|
||||
input.text = popup.currentText;
|
||||
activated(currentIndex);
|
||||
}
|
||||
input.blockUpdate = false;
|
||||
}
|
||||
|
||||
/*! \internal */
|
||||
property var __popup: popup
|
||||
|
||||
style: Settings.styleComponent(Settings.style, "ComboBoxStyle.qml", comboBox)
|
||||
|
||||
activeFocusOnTab: true
|
||||
|
||||
Accessible.name: editable ? editText : currentText
|
||||
Accessible.role: Accessible.ComboBox
|
||||
Accessible.editable: editable
|
||||
|
||||
MouseArea {
|
||||
id: mouseArea
|
||||
property bool overridePressed: false
|
||||
readonly property bool effectivePressed: (pressed || overridePressed) && containsMouse
|
||||
anchors.fill: parent
|
||||
hoverEnabled: Settings.hoverEnabled
|
||||
onPressed: {
|
||||
if (comboBox.activeFocusOnPress)
|
||||
forceActiveFocus()
|
||||
if (!Settings.hasTouchScreen)
|
||||
popup.toggleShow()
|
||||
else
|
||||
overridePressed = true
|
||||
}
|
||||
onCanceled: overridePressed = false
|
||||
onClicked: {
|
||||
if (Settings.hasTouchScreen)
|
||||
popup.toggleShow()
|
||||
overridePressed = false
|
||||
}
|
||||
onWheel: {
|
||||
if (wheel.angleDelta.y > 0) {
|
||||
__selectPrevItem();
|
||||
} else if (wheel.angleDelta.y < 0){
|
||||
__selectNextItem();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Component.onCompleted: {
|
||||
if (currentIndex === -1)
|
||||
currentIndex = 0
|
||||
|
||||
popup.ready = true
|
||||
popup.resolveTextValue(textRole)
|
||||
}
|
||||
|
||||
Keys.onPressed: {
|
||||
// Perform one-character based lookup for non-editable combo box
|
||||
if (!editable && event.text.length > 0) {
|
||||
var index = input.find(event.text, Qt.MatchStartsWith);
|
||||
if (index >= 0 && index !== currentIndex) {
|
||||
currentIndex = index;
|
||||
activated(currentIndex);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TextInputWithHandles {
|
||||
id: input
|
||||
|
||||
visible: editable
|
||||
enabled: editable
|
||||
focus: true
|
||||
clip: contentWidth > width
|
||||
|
||||
control: comboBox
|
||||
cursorHandle: __style ? __style.__cursorHandle : undefined
|
||||
selectionHandle: __style ? __style.__selectionHandle : undefined
|
||||
|
||||
anchors.fill: parent
|
||||
anchors.leftMargin: __style ? __style.padding.left : 0
|
||||
anchors.topMargin: __style ? __style.padding.top : 0
|
||||
anchors.rightMargin: __style ? __panel.dropDownButtonWidth + __style.padding.right : 0
|
||||
anchors.bottomMargin: __style ? __style.padding.bottom: 0
|
||||
|
||||
verticalAlignment: Text.AlignVCenter
|
||||
|
||||
font: __panel && __panel.font !== undefined ? __panel.font : TextSingleton.font
|
||||
renderType: __style ? __style.renderType : Text.NativeRendering
|
||||
color: __panel ? __panel.textColor : "black"
|
||||
selectionColor: __panel ? __panel.selectionColor : "blue"
|
||||
selectedTextColor: __panel ? __panel.selectedTextColor : "white"
|
||||
onAccepted: {
|
||||
var idx = input.find(editText, Qt.MatchFixedString)
|
||||
if (idx > -1) {
|
||||
editTextMatches = true;
|
||||
currentIndex = idx;
|
||||
editText = textAt(idx);
|
||||
} else {
|
||||
editTextMatches = false;
|
||||
currentIndex = -1;
|
||||
popup.currentText = editText;
|
||||
}
|
||||
comboBox.accepted();
|
||||
}
|
||||
|
||||
property bool blockUpdate: false
|
||||
property string prevText
|
||||
property bool editTextMatches: true
|
||||
|
||||
function find (text, searchType) {
|
||||
for (var i = 0 ; i < popupItems.count ; ++i) {
|
||||
var currentString = popupItems.objectAt(i).text
|
||||
if (searchType === Qt.MatchExactly) {
|
||||
if (text === currentString)
|
||||
return i;
|
||||
} else if (searchType === Qt.CaseSensitive) {
|
||||
if (currentString.indexOf(text) === 0)
|
||||
return i;
|
||||
} else if (searchType === Qt.MatchFixedString) {
|
||||
if (currentString.toLowerCase().indexOf(text.toLowerCase()) === 0
|
||||
&& currentString.length === text.length)
|
||||
return i;
|
||||
} else if (currentString.toLowerCase().indexOf(text.toLowerCase()) === 0) {
|
||||
return i
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Finds first entry and shortest entry. Used by editable combo
|
||||
function tryComplete (inputText) {
|
||||
var candidate = "";
|
||||
var shortestString = "";
|
||||
for (var i = 0 ; i < popupItems.count ; ++i) {
|
||||
var currentString = popupItems.objectAt(i).text;
|
||||
|
||||
if (currentString.toLowerCase().indexOf(inputText.toLowerCase()) === 0) {
|
||||
if (candidate.length) { // Find smallest possible match
|
||||
var cmp = 0;
|
||||
|
||||
// We try to complete the shortest string that matches our search
|
||||
if (currentString.length < candidate.length)
|
||||
candidate = currentString
|
||||
|
||||
while (cmp < Math.min(currentString.length, shortestString.length)
|
||||
&& shortestString[cmp].toLowerCase() === currentString[cmp].toLowerCase())
|
||||
cmp++;
|
||||
shortestString = shortestString.substring(0, cmp);
|
||||
} else { // First match, select as current index and find other matches
|
||||
candidate = currentString;
|
||||
shortestString = currentString;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (candidate.length)
|
||||
return inputText + candidate.substring(inputText.length, candidate.length);
|
||||
return inputText;
|
||||
}
|
||||
|
||||
property bool allowComplete: false
|
||||
Keys.forwardTo: comboBox
|
||||
Keys.onPressed: allowComplete = (event.key !== Qt.Key_Backspace && event.key !== Qt.Key_Delete);
|
||||
|
||||
onTextChanged: {
|
||||
if (editable && !blockUpdate && allowComplete && text.length > 0) {
|
||||
var completed = input.tryComplete(text)
|
||||
if (completed.length > text.length) {
|
||||
var oldtext = input.text;
|
||||
input.text = completed;
|
||||
input.select(text.length, oldtext.length);
|
||||
}
|
||||
}
|
||||
prevText = text
|
||||
}
|
||||
}
|
||||
|
||||
Qml.Binding {
|
||||
target: input
|
||||
property: "text"
|
||||
value: popup.currentText
|
||||
when: input.editTextMatches
|
||||
restoreMode: Binding.RestoreBinding
|
||||
}
|
||||
|
||||
onTextRoleChanged: popup.resolveTextValue(textRole)
|
||||
|
||||
ExclusiveGroup { id: eg }
|
||||
|
||||
Menu {
|
||||
id: popup
|
||||
objectName: "popup"
|
||||
|
||||
style: isPopup ? __style.__popupStyle : __style.__dropDownStyle
|
||||
|
||||
property string currentText: selectedText
|
||||
onSelectedTextChanged: popup.currentText = selectedText
|
||||
|
||||
property string selectedText
|
||||
property int triggeredIndex: -1
|
||||
on__SelectedIndexChanged: {
|
||||
if (__selectedIndex === -1)
|
||||
popup.currentText = ""
|
||||
else
|
||||
updateSelectedText()
|
||||
if (triggeredIndex >= 0 && triggeredIndex == __selectedIndex) {
|
||||
activated(currentIndex)
|
||||
triggeredIndex = -1
|
||||
}
|
||||
}
|
||||
property string textRole: ""
|
||||
|
||||
property bool ready: false
|
||||
property bool isPopup: !editable && !!__panel && __panel.popup
|
||||
|
||||
property int y: isPopup ? (comboBox.__panel.height - comboBox.__panel.implicitHeight) / 2.0 : comboBox.__panel.height
|
||||
__minimumWidth: comboBox.width
|
||||
__visualItem: comboBox
|
||||
|
||||
property bool modelIsArray: false
|
||||
|
||||
Instantiator {
|
||||
id: popupItems
|
||||
active: false
|
||||
|
||||
property bool updatingModel: false
|
||||
onModelChanged: {
|
||||
popup.modelIsArray = !!model ? model.constructor === Array : false
|
||||
if (active) {
|
||||
if (updatingModel && popup.__selectedIndex === 0) {
|
||||
// We still want to update the currentText
|
||||
popup.updateSelectedText()
|
||||
} else {
|
||||
updatingModel = true
|
||||
popup.__selectedIndex = 0
|
||||
}
|
||||
}
|
||||
popup.resolveTextValue(comboBox.textRole)
|
||||
}
|
||||
|
||||
MenuItem {
|
||||
text: popup.textRole === '' ?
|
||||
modelData :
|
||||
((popup.modelIsArray ? modelData[popup.textRole] : model[popup.textRole]) || '')
|
||||
onTriggered: {
|
||||
popup.triggeredIndex = index
|
||||
comboBox.editText = text
|
||||
}
|
||||
onTextChanged: if (index === currentIndex) popup.updateSelectedText();
|
||||
checkable: true
|
||||
exclusiveGroup: eg
|
||||
}
|
||||
onObjectAdded: {
|
||||
popup.insertItem(index, object)
|
||||
if (!updatingModel && index === popup.__selectedIndex)
|
||||
popup.selectedText = object["text"]
|
||||
}
|
||||
onObjectRemoved: popup.removeItem(object)
|
||||
|
||||
}
|
||||
|
||||
function resolveTextValue(initialTextRole) {
|
||||
if (!ready || !model) {
|
||||
popupItems.active = false
|
||||
return;
|
||||
}
|
||||
|
||||
var get = model['get'];
|
||||
if (!get && popup.modelIsArray && !!model[0]) {
|
||||
if (model[0].constructor !== String && model[0].constructor !== Number)
|
||||
get = function(i) { return model[i]; }
|
||||
}
|
||||
|
||||
var modelMayHaveRoles = get !== undefined
|
||||
textRole = initialTextRole
|
||||
if (textRole === "" && modelMayHaveRoles && get(0)) {
|
||||
// No text role set, check whether model has a suitable role
|
||||
// If 'text' is found, or there's only one role, pick that.
|
||||
var listElement = get(0)
|
||||
var roleName = ""
|
||||
var roleCount = 0
|
||||
for (var role in listElement) {
|
||||
if (listElement[role].constructor === Function)
|
||||
continue;
|
||||
if (role === "text") {
|
||||
roleName = role
|
||||
break
|
||||
} else if (!roleName) {
|
||||
roleName = role
|
||||
}
|
||||
++roleCount
|
||||
}
|
||||
if (roleCount > 1 && roleName !== "text") {
|
||||
console.warn("No suitable 'textRole' found for ComboBox.")
|
||||
} else {
|
||||
textRole = roleName
|
||||
}
|
||||
}
|
||||
|
||||
if (!popupItems.active)
|
||||
popupItems.active = true
|
||||
else
|
||||
updateSelectedText()
|
||||
}
|
||||
|
||||
function toggleShow() {
|
||||
if (popup.__popupVisible) {
|
||||
popup.__dismissAndDestroy()
|
||||
} else {
|
||||
if (items[__selectedIndex])
|
||||
items[__selectedIndex].checked = true
|
||||
__currentIndex = comboBox.currentIndex
|
||||
if (Qt.application.layoutDirection === Qt.RightToLeft)
|
||||
__popup(Qt.rect(comboBox.width, y, 0, 0), isPopup ? __selectedIndex : 0)
|
||||
else
|
||||
__popup(Qt.rect(0, y, 0, 0), isPopup ? __selectedIndex : 0)
|
||||
}
|
||||
}
|
||||
|
||||
function updateSelectedText() {
|
||||
var selectedItem;
|
||||
if (__selectedIndex !== -1 && (selectedItem = items[__selectedIndex])) {
|
||||
input.editTextMatches = true
|
||||
selectedText = Qt.binding(function () { return selectedItem.text })
|
||||
if (currentText !== selectedText) // __selectedIndex went form -1 to 0
|
||||
selectedTextChanged()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The key bindings below will only be in use when popup is
|
||||
// not visible. Otherwise, native popup key handling will take place:
|
||||
Keys.onSpacePressed: {
|
||||
if (!editable)
|
||||
popup.toggleShow()
|
||||
else
|
||||
event.accepted = false
|
||||
}
|
||||
|
||||
Keys.onUpPressed: __selectPrevItem()
|
||||
Keys.onDownPressed: __selectNextItem()
|
||||
}
|
||||
Reference in New Issue
Block a user