1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
|
/****************************************************************************
**
** Copyright (C) 2021 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt Virtual Keyboard module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:COMM$
**
** 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.
**
** $QT_END_LICENSE$
**
**
**
**
**
**
**
**
**
****************************************************************************/
#include <QtVirtualKeyboard/qvirtualkeyboardselectionlistmodel.h>
#include <QtVirtualKeyboard/qvirtualkeyboardabstractinputmethod.h>
#include <QtVirtualKeyboard/private/settings_p.h>
#include <QtCore/private/qabstractitemmodel_p.h>
#include <QtCore/qpointer.h>
QT_BEGIN_NAMESPACE
using namespace QtVirtualKeyboard;
class QVirtualKeyboardSelectionListModelPrivate : public QAbstractItemModelPrivate
{
public:
QVirtualKeyboardSelectionListModelPrivate() :
QAbstractItemModelPrivate(),
dataSource(nullptr),
type(QVirtualKeyboardSelectionListModel::Type::WordCandidateList),
rowCount(0),
wclAutoCommitWord(false)
{
}
QHash<int, QByteArray> roles;
QPointer<QVirtualKeyboardAbstractInputMethod> dataSource;
QVirtualKeyboardSelectionListModel::Type type;
int rowCount;
bool wclAutoCommitWord;
};
/*!
\qmltype SelectionListModel
\instantiates QVirtualKeyboardSelectionListModel
\inqmlmodule QtQuick.VirtualKeyboard
\ingroup qtvirtualkeyboard-qml
\brief Provides a data model for the selection lists.
The SelectionListModel is a data model for word candidates
provided by the input method.
An instance of a SelectionListModel cannot be created directly.
Instead, the InputEngine manages the instances and provides
access to the model by InputEngine::wordCandidateListModel
property.
The model exposes the following data roles for the list delegate:
\list
\li \c display Display text for item.
\li \c wordCompletionLength Word completion length for item.
\li \c dictionaryType Dictionary type of the word, see QVirtualKeyboardSelectionListModel::DictionaryType.
\li \c canRemoveSuggestion A boolean indicating if the word can be removed from the dictionary.
\endlist
The activeItemChanged signal indicates which item is currently
highlighted by the input method. The view should respond to this
signal by highlighting the corresponding item in the list.
The user selection is handled by the selectItem() method. The view
should be invoke this method when the user selects an item from the
list.
*/
/*!
\class QVirtualKeyboardSelectionListModel
\inmodule QtVirtualKeyboard
\brief List model for selection lists.
This class acts as a bridge between the UI and the
input method that provides the data for selection
lists.
*/
/*!
\enum QVirtualKeyboardSelectionListModel::Type
This enum specifies the type of selection list.
\value WordCandidateList
Shows list of word candidates.
*/
/*!
\enum QVirtualKeyboardSelectionListModel::Role
This enum specifies a role of the data requested.
\value Display
The data to be rendered in form of text.
\value DisplayRole
\c obsolete Use Role::Display.
\value WordCompletionLength
An integer specifying the length of the word
the completion part expressed as the
number of characters counted from the
end of the string.
\value WordCompletionLengthRole
\c obsolete Use Role::WordCompletionLength.
\value Dictionary
An integer specifying \ l {QVirtualKeyboardSelectionListModel::DictionaryType}{dictionary type}.
\value CanRemoveSuggestion
A boolean value indicating if the word candidate
can be removed from the dictionary.
*/
/*!
\enum QVirtualKeyboardSelectionListModel::DictionaryType
This enum specifies the dictionary type of a word.
\value Default
The word candidate is from the default dictionary.
\value User
The word candidate is from the user dictionary.
*/
QVirtualKeyboardSelectionListModel::QVirtualKeyboardSelectionListModel(QObject *parent) :
QAbstractListModel(*new QVirtualKeyboardSelectionListModelPrivate(), parent)
{
Q_D(QVirtualKeyboardSelectionListModel);
d->roles =
{{static_cast<int>(Role::Display), "display"},
{static_cast<int>(Role::WordCompletionLength), "wordCompletionLength"},
{static_cast<int>(Role::Dictionary), "dictionary"},
{static_cast<int>(Role::CanRemoveSuggestion), "canRemoveSuggestion"}};
}
/*!
\internal
*/
QVirtualKeyboardSelectionListModel::~QVirtualKeyboardSelectionListModel()
{
}
/*!
\internal
*/
void QVirtualKeyboardSelectionListModel::setDataSource(QVirtualKeyboardAbstractInputMethod *dataSource, Type type)
{
Q_D(QVirtualKeyboardSelectionListModel);
if (d->dataSource) {
disconnect(this, SLOT(selectionListChanged(Type)));
disconnect(this, SLOT(selectionListActiveItemChanged(Type, int)));
}
d->type = type;
if (d->dataSource) {
d->dataSource = nullptr;
selectionListChanged(type);
selectionListActiveItemChanged(type, -1);
}
d->dataSource = dataSource;
if (d->dataSource) {
QObject::connect(d->dataSource.data(), &QVirtualKeyboardAbstractInputMethod::selectionListChanged, this, &QVirtualKeyboardSelectionListModel::selectionListChanged);
QObject::connect(d->dataSource.data(), &QVirtualKeyboardAbstractInputMethod::selectionListActiveItemChanged, this, &QVirtualKeyboardSelectionListModel::selectionListActiveItemChanged);
}
}
/*!
\internal
*/
QVirtualKeyboardAbstractInputMethod *QVirtualKeyboardSelectionListModel::dataSource() const
{
Q_D(const QVirtualKeyboardSelectionListModel);
return d->dataSource;
}
/*!
\internal
*/
int QVirtualKeyboardSelectionListModel::rowCount(const QModelIndex &parent) const
{
Q_D(const QVirtualKeyboardSelectionListModel);
Q_UNUSED(parent)
return d->rowCount;
}
/*!
\internal
*/
QVariant QVirtualKeyboardSelectionListModel::data(const QModelIndex &index, int role) const
{
Q_D(const QVirtualKeyboardSelectionListModel);
return d->dataSource ? d->dataSource->selectionListData(d->type, index.row(), static_cast<Role>(role)) : QVariant();
}
/*!
\internal
*/
QHash<int,QByteArray> QVirtualKeyboardSelectionListModel::roleNames() const
{
Q_D(const QVirtualKeyboardSelectionListModel);
return d->roles;
}
/*!
\property QVirtualKeyboardSelectionListModel::count
\internal
*/
/*
\internal
*/
int QVirtualKeyboardSelectionListModel::count() const
{
Q_D(const QVirtualKeyboardSelectionListModel);
return d->rowCount;
}
/*! \qmlmethod void SelectionListModel::selectItem(int index)
This method should be called when the user selects an item at position
\a index from the list.
The selection is forwarded to the input method for further processing.
*/
/*!
This method should be called when the user selects an item at position
\a index from the list.
The selection is forwarded to the input method for further processing.
*/
void QVirtualKeyboardSelectionListModel::selectItem(int index)
{
Q_D(QVirtualKeyboardSelectionListModel);
if (index >= 0 && index < d->rowCount && d->dataSource) {
emit itemSelected(index);
d->dataSource->selectionListItemSelected(d->type, index);
}
}
/*!
\qmlmethod void SelectionListModel::removeItem(int index)
This method should be called when the user removes an item at position
\a index from the list.
The removal is forwarded to the input method for further processing.
*/
/*!
This method should be called when the user removes an item at position
\a index from the list.
The removal is forwarded to the input method for further processing.
*/
void QVirtualKeyboardSelectionListModel::removeItem(int index)
{
Q_D(QVirtualKeyboardSelectionListModel);
if (index >= 0 && index < d->rowCount && d->dataSource) {
d->dataSource->selectionListRemoveItem(d->type, index);
}
}
/*!
* \internal
*/
QVariant QVirtualKeyboardSelectionListModel::dataAt(int index, QVirtualKeyboardSelectionListModel::Role role) const
{
return data(this->index(index, 0), static_cast<int>(role));
}
/*!
\internal
*/
void QVirtualKeyboardSelectionListModel::selectionListChanged(QVirtualKeyboardSelectionListModel::Type type)
{
Q_D(QVirtualKeyboardSelectionListModel);
if (static_cast<Type>(type) == d->type) {
int oldCount = d->rowCount;
int newCount = d->dataSource ? d->dataSource->selectionListItemCount(d->type) : 0;
if (newCount) {
int changedCount = qMin(oldCount, newCount);
if (changedCount)
emit dataChanged(index(0), index(changedCount - 1));
if (oldCount > newCount) {
beginRemoveRows(QModelIndex(), newCount, oldCount - 1);
d->rowCount = newCount;
endRemoveRows();
} else if (oldCount < newCount) {
beginInsertRows(QModelIndex(), oldCount, newCount - 1);
d->rowCount = newCount;
endInsertRows();
}
} else {
beginResetModel();
d->rowCount = 0;
endResetModel();
}
if (static_cast<QVirtualKeyboardSelectionListModel::Type>(type) == QVirtualKeyboardSelectionListModel::Type::WordCandidateList)
d->wclAutoCommitWord = ((oldCount > 1 || (oldCount == 1 && d->wclAutoCommitWord)) && newCount == 1 &&
Settings::instance()->wclAutoCommitWord() &&
dataAt(0).toString().length() > 1);
if (d->rowCount != oldCount)
emit countChanged();
}
}
/*!
\internal
*/
void QVirtualKeyboardSelectionListModel::selectionListActiveItemChanged(QVirtualKeyboardSelectionListModel::Type type, int index)
{
Q_D(QVirtualKeyboardSelectionListModel);
if (static_cast<Type>(type) == d->type && index < d->rowCount) {
emit activeItemChanged(index);
if (index == 0 && d->wclAutoCommitWord)
selectItem(0);
}
}
/*!
\qmlsignal void SelectionListModel::activeItemChanged(int index)
This signal is emitted when the active item in the list changes. The
UI should react to this signal by highlighting the item at \a index in
the list.
*/
/*!
\fn void QVirtualKeyboardSelectionListModel::activeItemChanged(int index)
This signal is emitted when the active item in the list changes. The
UI should react to this signal by highlighting the item at \a index in
the list.
*/
/*!
\qmlsignal void SelectionListModel::itemSelected(int index)
This signal is emitted when an item at \a index is selected by the user.
*/
/*!
\fn void QVirtualKeyboardSelectionListModel::itemSelected(int index)
This signal is emitted when an item at \a index is selected by the user.
*/
QT_END_NAMESPACE
|