1 | /**************************************************************************** |
2 | ** |
3 | ** Copyright (C) 2016 The Qt Company Ltd. |
4 | ** Contact: https://www.qt.io/licensing/ |
5 | ** |
6 | ** This file is part of the test suite of the Qt Toolkit. |
7 | ** |
8 | ** $QT_BEGIN_LICENSE:GPL-EXCEPT$ |
9 | ** Commercial License Usage |
10 | ** Licensees holding valid commercial Qt licenses may use this file in |
11 | ** accordance with the commercial license agreement provided with the |
12 | ** Software or, alternatively, in accordance with the terms contained in |
13 | ** a written agreement between you and The Qt Company. For licensing terms |
14 | ** and conditions see https://www.qt.io/terms-conditions. For further |
15 | ** information use the contact form at https://www.qt.io/contact-us. |
16 | ** |
17 | ** GNU General Public License Usage |
18 | ** Alternatively, this file may be used under the terms of the GNU |
19 | ** General Public License version 3 as published by the Free Software |
20 | ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT |
21 | ** included in the packaging of this file. Please review the following |
22 | ** information to ensure the GNU General Public License requirements will |
23 | ** be met: https://www.gnu.org/licenses/gpl-3.0.html. |
24 | ** |
25 | ** $QT_END_LICENSE$ |
26 | ** |
27 | ****************************************************************************/ |
28 | #include <qtest.h> |
29 | #include <QtTest/QSignalSpy> |
30 | #include "../../shared/testhttpserver.h" |
31 | #include <math.h> |
32 | #include <QFile> |
33 | #include <QTextDocument> |
34 | #include <QtQml/qqmlengine.h> |
35 | #include <QtQml/qqmlcontext.h> |
36 | #include <QtQml/qqmlexpression.h> |
37 | #include <QtQml/qqmlcomponent.h> |
38 | #include <QtGui/qguiapplication.h> |
39 | #include <private/qquickrectangle_p.h> |
40 | #include <private/qquicktextedit_p.h> |
41 | #include <private/qquicktextedit_p_p.h> |
42 | #include <private/qquicktext_p.h> |
43 | #include <private/qquicktextdocument_p.h> |
44 | #include <QFontMetrics> |
45 | #include <QtQuick/QQuickView> |
46 | #include <QDir> |
47 | #include <QInputMethod> |
48 | #include <QClipboard> |
49 | #include <QMimeData> |
50 | #include <private/qquicktextcontrol_p.h> |
51 | #include "../../shared/util.h" |
52 | #include "../shared/viewtestutil.h" |
53 | #include "../../shared/platformquirks.h" |
54 | #include "../../shared/platforminputcontext.h" |
55 | #include <private/qinputmethod_p.h> |
56 | #include <QtGui/qstylehints.h> |
57 | #include <qmath.h> |
58 | |
59 | #ifdef Q_OS_MAC |
60 | #include <Carbon/Carbon.h> |
61 | #endif |
62 | |
63 | Q_DECLARE_METATYPE(QQuickTextEdit::SelectionMode) |
64 | Q_DECLARE_METATYPE(Qt::Key) |
65 | DEFINE_BOOL_CONFIG_OPTION(qmlDisableDistanceField, QML_DISABLE_DISTANCEFIELD) |
66 | |
67 | static bool isPlatformWayland() |
68 | { |
69 | return !QGuiApplication::platformName().compare(other: QLatin1String("wayland" ), cs: Qt::CaseInsensitive); |
70 | } |
71 | |
72 | QString createExpectedFileIfNotFound(const QString& filebasename, const QImage& actual) |
73 | { |
74 | // XXX This will be replaced by some clever persistent platform image store. |
75 | QString persistent_dir = QQmlDataTest::instance()->dataDirectory(); |
76 | QString arch = "unknown-architecture" ; // QTest needs to help with this. |
77 | |
78 | QString expectfile = persistent_dir + QDir::separator() + filebasename + QLatin1Char('-') + arch + ".png" ; |
79 | |
80 | if (!QFile::exists(fileName: expectfile)) { |
81 | actual.save(fileName: expectfile); |
82 | qWarning() << "created" << expectfile; |
83 | } |
84 | |
85 | return expectfile; |
86 | } |
87 | |
88 | typedef QPair<int, QChar> Key; |
89 | |
90 | class tst_qquicktextedit : public QQmlDataTest |
91 | |
92 | { |
93 | Q_OBJECT |
94 | public: |
95 | tst_qquicktextedit(); |
96 | |
97 | private slots: |
98 | void cleanup(); |
99 | void text(); |
100 | void width(); |
101 | void wrap(); |
102 | void textFormat(); |
103 | void lineCount_data(); |
104 | void lineCount(); |
105 | |
106 | // ### these tests may be trivial |
107 | void hAlign(); |
108 | void hAlign_RightToLeft(); |
109 | void hAlignVisual(); |
110 | void vAlign(); |
111 | void font(); |
112 | void color(); |
113 | void textMargin(); |
114 | void persistentSelection(); |
115 | void selectionOnFocusOut(); |
116 | void focusOnPress(); |
117 | void selection(); |
118 | void overwriteMode(); |
119 | void isRightToLeft_data(); |
120 | void isRightToLeft(); |
121 | void keySelection(); |
122 | void moveCursorSelection_data(); |
123 | void moveCursorSelection(); |
124 | void moveCursorSelectionSequence_data(); |
125 | void moveCursorSelectionSequence(); |
126 | void mouseSelection_data(); |
127 | void mouseSelection(); |
128 | void mouseSelectionMode_data(); |
129 | void mouseSelectionMode(); |
130 | void dragMouseSelection(); |
131 | void mouseSelectionMode_accessors(); |
132 | void selectByMouse(); |
133 | void selectByKeyboard(); |
134 | #if QT_CONFIG(shortcut) |
135 | void keyboardSelection_data(); |
136 | void keyboardSelection(); |
137 | #endif |
138 | void renderType(); |
139 | void inputMethodHints(); |
140 | |
141 | void positionAt_data(); |
142 | void positionAt(); |
143 | |
144 | void linkHover(); |
145 | void linkInteraction(); |
146 | |
147 | void cursorDelegate_data(); |
148 | void cursorDelegate(); |
149 | void remoteCursorDelegate(); |
150 | void cursorVisible(); |
151 | void delegateLoading_data(); |
152 | void delegateLoading(); |
153 | void cursorDelegateHeight(); |
154 | void navigation(); |
155 | void readOnly(); |
156 | #if QT_CONFIG(clipboard) |
157 | void copyAndPaste(); |
158 | void canPaste(); |
159 | void canPasteEmpty(); |
160 | void middleClickPaste(); |
161 | #endif |
162 | void textInput(); |
163 | void inputMethodUpdate(); |
164 | void openInputPanel(); |
165 | void geometrySignals(); |
166 | #if QT_CONFIG(clipboard) |
167 | void pastingRichText_QTBUG_14003(); |
168 | #endif |
169 | void implicitSize_data(); |
170 | void implicitSize(); |
171 | void implicitSize_QTBUG_63153(); |
172 | void contentSize(); |
173 | void boundingRect(); |
174 | void clipRect(); |
175 | void implicitSizeBinding_data(); |
176 | void implicitSizeBinding(); |
177 | |
178 | void signal_editingfinished(); |
179 | |
180 | void preeditCursorRectangle(); |
181 | void inputMethodComposing(); |
182 | void cursorRectangleSize_data(); |
183 | void cursorRectangleSize(); |
184 | |
185 | void getText_data(); |
186 | void getText(); |
187 | void getFormattedText_data(); |
188 | void getFormattedText(); |
189 | void append_data(); |
190 | void append(); |
191 | void insert_data(); |
192 | void insert(); |
193 | void remove_data(); |
194 | void remove(); |
195 | #if QT_CONFIG(shortcut) |
196 | void keySequence_data(); |
197 | void keySequence(); |
198 | #endif |
199 | |
200 | void undo_data(); |
201 | void undo(); |
202 | void redo_data(); |
203 | void redo(); |
204 | #if QT_CONFIG(shortcut) |
205 | void undo_keypressevents_data(); |
206 | void undo_keypressevents(); |
207 | #endif |
208 | void clear(); |
209 | |
210 | void baseUrl(); |
211 | void embeddedImages(); |
212 | void embeddedImages_data(); |
213 | |
214 | void emptytags_QTBUG_22058(); |
215 | void cursorRectangle_QTBUG_38947(); |
216 | void textCached_QTBUG_41583(); |
217 | void doubleSelect_QTBUG_38704(); |
218 | |
219 | void padding(); |
220 | void paddingAndWrap(); |
221 | void QTBUG_51115_readOnlyResetsSelection(); |
222 | void keys_shortcutoverride(); |
223 | |
224 | void transparentSelectionColor(); |
225 | private: |
226 | void simulateKeys(QWindow *window, const QList<Key> &keys); |
227 | #if QT_CONFIG(shortcut) |
228 | void simulateKeys(QWindow *window, const QKeySequence &sequence); |
229 | #endif |
230 | |
231 | void simulateKey(QWindow *, int key, Qt::KeyboardModifiers modifiers = {}); |
232 | |
233 | QStringList standard; |
234 | QStringList richText; |
235 | |
236 | QStringList hAlignmentStrings; |
237 | QStringList vAlignmentStrings; |
238 | |
239 | QList<Qt::Alignment> vAlignments; |
240 | QList<Qt::Alignment> hAlignments; |
241 | |
242 | QStringList colorStrings; |
243 | |
244 | QQmlEngine engine; |
245 | }; |
246 | |
247 | typedef QList<int> IntList; |
248 | Q_DECLARE_METATYPE(IntList) |
249 | |
250 | typedef QList<Key> KeyList; |
251 | Q_DECLARE_METATYPE(KeyList) |
252 | |
253 | Q_DECLARE_METATYPE(QQuickTextEdit::HAlignment) |
254 | Q_DECLARE_METATYPE(QQuickTextEdit::VAlignment) |
255 | Q_DECLARE_METATYPE(QQuickTextEdit::TextFormat) |
256 | |
257 | void tst_qquicktextedit::simulateKeys(QWindow *window, const QList<Key> &keys) |
258 | { |
259 | for (int i = 0; i < keys.count(); ++i) { |
260 | const int key = keys.at(i).first; |
261 | const int modifiers = key & Qt::KeyboardModifierMask; |
262 | const QString text = !keys.at(i).second.isNull() ? QString(keys.at(i).second) : QString(); |
263 | |
264 | QKeyEvent press(QEvent::KeyPress, Qt::Key(key), Qt::KeyboardModifiers(modifiers), text); |
265 | QKeyEvent release(QEvent::KeyRelease, Qt::Key(key), Qt::KeyboardModifiers(modifiers), text); |
266 | |
267 | QGuiApplication::sendEvent(receiver: window, event: &press); |
268 | QGuiApplication::sendEvent(receiver: window, event: &release); |
269 | } |
270 | } |
271 | |
272 | #if QT_CONFIG(shortcut) |
273 | |
274 | void tst_qquicktextedit::simulateKeys(QWindow *window, const QKeySequence &sequence) |
275 | { |
276 | for (int i = 0; i < sequence.count(); ++i) { |
277 | const int key = sequence[i]; |
278 | const int modifiers = key & Qt::KeyboardModifierMask; |
279 | |
280 | QTest::keyClick(window, key: Qt::Key(key & ~modifiers), modifier: Qt::KeyboardModifiers(modifiers)); |
281 | } |
282 | } |
283 | |
284 | QList<Key> &operator <<(QList<Key> &keys, const QKeySequence &sequence) |
285 | { |
286 | for (int i = 0; i < sequence.count(); ++i) |
287 | keys << Key(sequence[i], QChar()); |
288 | return keys; |
289 | } |
290 | |
291 | #endif // QT_CONFIG(shortcut) |
292 | |
293 | template <int N> QList<Key> &operator <<(QList<Key> &keys, const char (&characters)[N]) |
294 | { |
295 | for (int i = 0; i < N - 1; ++i) { |
296 | int key = QTest::asciiToKey(ascii: characters[i]); |
297 | QChar character = QLatin1Char(characters[i]); |
298 | keys << Key(key, character); |
299 | } |
300 | return keys; |
301 | } |
302 | |
303 | QList<Key> &operator <<(QList<Key> &keys, Qt::Key key) |
304 | { |
305 | keys << Key(key, QChar()); |
306 | return keys; |
307 | } |
308 | |
309 | tst_qquicktextedit::tst_qquicktextedit() |
310 | { |
311 | qRegisterMetaType<QQuickTextEdit::TextFormat>(); |
312 | qRegisterMetaType<QQuickTextEdit::SelectionMode>(); |
313 | |
314 | standard << "the quick brown fox jumped over the lazy dog" |
315 | << "the quick brown fox\n jumped over the lazy dog" |
316 | << "Hello, world!" |
317 | << "!dlrow ,olleH" ; |
318 | |
319 | richText << "<i>the <b>quick</b> brown <a href=\\\"http://www.google.com\\\">fox</a> jumped over the <b>lazy</b> dog</i>" |
320 | << "<i>the <b>quick</b> brown <a href=\\\"http://www.google.com\\\">fox</a><br>jumped over the <b>lazy</b> dog</i>" ; |
321 | |
322 | hAlignmentStrings << "AlignLeft" |
323 | << "AlignRight" |
324 | << "AlignHCenter" ; |
325 | |
326 | vAlignmentStrings << "AlignTop" |
327 | << "AlignBottom" |
328 | << "AlignVCenter" ; |
329 | |
330 | hAlignments << Qt::AlignLeft |
331 | << Qt::AlignRight |
332 | << Qt::AlignHCenter; |
333 | |
334 | vAlignments << Qt::AlignTop |
335 | << Qt::AlignBottom |
336 | << Qt::AlignVCenter; |
337 | |
338 | colorStrings << "aliceblue" |
339 | << "antiquewhite" |
340 | << "aqua" |
341 | << "darkkhaki" |
342 | << "darkolivegreen" |
343 | << "dimgray" |
344 | << "palevioletred" |
345 | << "lightsteelblue" |
346 | << "#000000" |
347 | << "#AAAAAA" |
348 | << "#FFFFFF" |
349 | << "#2AC05F" ; |
350 | // |
351 | // need a different test to do alpha channel test |
352 | // << "#AA0011DD" |
353 | // << "#00F16B11"; |
354 | // |
355 | } |
356 | |
357 | void tst_qquicktextedit::cleanup() |
358 | { |
359 | // ensure not even skipped tests with custom input context leave it dangling |
360 | QInputMethodPrivate *inputMethodPrivate = QInputMethodPrivate::get(qApp->inputMethod()); |
361 | inputMethodPrivate->testContext = nullptr; |
362 | } |
363 | |
364 | void tst_qquicktextedit::text() |
365 | { |
366 | { |
367 | QQmlComponent texteditComponent(&engine); |
368 | texteditComponent.setData("import QtQuick 2.0\nTextEdit { text: \"\" }" , baseUrl: QUrl()); |
369 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
370 | |
371 | QVERIFY(textEditObject != nullptr); |
372 | QCOMPARE(textEditObject->text(), QString("" )); |
373 | QCOMPARE(textEditObject->length(), 0); |
374 | } |
375 | |
376 | for (int i = 0; i < standard.size(); i++) |
377 | { |
378 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + standard.at(i) + "\" }" ; |
379 | QQmlComponent texteditComponent(&engine); |
380 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
381 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
382 | |
383 | QVERIFY(textEditObject != nullptr); |
384 | QCOMPARE(textEditObject->text(), standard.at(i)); |
385 | QCOMPARE(textEditObject->length(), standard.at(i).length()); |
386 | } |
387 | |
388 | for (int i = 0; i < richText.size(); i++) |
389 | { |
390 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + richText.at(i) + "\" }" ; |
391 | QQmlComponent texteditComponent(&engine); |
392 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
393 | |
394 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
395 | |
396 | QVERIFY(textEditObject != nullptr); |
397 | |
398 | QString expected = richText.at(i); |
399 | expected.replace(rx: QRegExp("\\\\(.)" ),after: "\\1" ); |
400 | QCOMPARE(textEditObject->text(), expected); |
401 | QCOMPARE(textEditObject->length(), expected.length()); |
402 | } |
403 | |
404 | for (int i = 0; i < standard.size(); i++) |
405 | { |
406 | QString componentStr = "import QtQuick 2.0\nTextEdit { textFormat: TextEdit.RichText; text: \"" + standard.at(i) + "\" }" ; |
407 | QQmlComponent texteditComponent(&engine); |
408 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
409 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
410 | |
411 | QVERIFY(textEditObject != nullptr); |
412 | |
413 | QString actual = textEditObject->text(); |
414 | QString expected = standard.at(i); |
415 | actual.remove(rx: QRegExp(".*<body[^>]*>" )); |
416 | actual.remove(rx: QRegExp("(<[^>]*>)+" )); |
417 | expected.remove(s: "\n" ); |
418 | QCOMPARE(actual.simplified(), expected); |
419 | QCOMPARE(textEditObject->length(), expected.length()); |
420 | } |
421 | |
422 | for (int i = 0; i < richText.size(); i++) |
423 | { |
424 | QString componentStr = "import QtQuick 2.0\nTextEdit { textFormat: TextEdit.RichText; text: \"" + richText.at(i) + "\" }" ; |
425 | QQmlComponent texteditComponent(&engine); |
426 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
427 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
428 | |
429 | QVERIFY(textEditObject != nullptr); |
430 | QString actual = textEditObject->text(); |
431 | QString expected = richText.at(i); |
432 | actual.replace(rx: QRegExp(".*<body[^>]*>" ),after: "" ); |
433 | actual.replace(rx: QRegExp("(<[^>]*>)+" ),after: "<>" ); |
434 | expected.replace(rx: QRegExp("(<[^>]*>)+" ),after: "<>" ); |
435 | QCOMPARE(actual.simplified(),expected.simplified()); |
436 | |
437 | expected.replace(before: "<>" , after: " " ); |
438 | QCOMPARE(textEditObject->length(), expected.simplified().length()); |
439 | } |
440 | |
441 | for (int i = 0; i < standard.size(); i++) |
442 | { |
443 | QString componentStr = "import QtQuick 2.0\nTextEdit { textFormat: TextEdit.AutoText; text: \"" + standard.at(i) + "\" }" ; |
444 | QQmlComponent texteditComponent(&engine); |
445 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
446 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
447 | |
448 | QVERIFY(textEditObject != nullptr); |
449 | QCOMPARE(textEditObject->text(), standard.at(i)); |
450 | QCOMPARE(textEditObject->length(), standard.at(i).length()); |
451 | } |
452 | |
453 | for (int i = 0; i < richText.size(); i++) |
454 | { |
455 | QString componentStr = "import QtQuick 2.0\nTextEdit { textFormat: TextEdit.AutoText; text: \"" + richText.at(i) + "\" }" ; |
456 | QQmlComponent texteditComponent(&engine); |
457 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
458 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
459 | |
460 | QVERIFY(textEditObject != nullptr); |
461 | QString actual = textEditObject->text(); |
462 | QString expected = richText.at(i); |
463 | actual.replace(rx: QRegExp(".*<body[^>]*>" ),after: "" ); |
464 | actual.replace(rx: QRegExp("(<[^>]*>)+" ),after: "<>" ); |
465 | expected.replace(rx: QRegExp("(<[^>]*>)+" ),after: "<>" ); |
466 | QCOMPARE(actual.simplified(),expected.simplified()); |
467 | |
468 | expected.replace(before: "<>" , after: " " ); |
469 | QCOMPARE(textEditObject->length(), expected.simplified().length()); |
470 | } |
471 | } |
472 | |
473 | void tst_qquicktextedit::width() |
474 | { |
475 | // uses Font metrics to find the width for standard and document to find the width for rich |
476 | { |
477 | QQmlComponent texteditComponent(&engine); |
478 | texteditComponent.setData("import QtQuick 2.0\nTextEdit { text: \"\" }" , baseUrl: QUrl()); |
479 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
480 | |
481 | QVERIFY(textEditObject != nullptr); |
482 | QCOMPARE(textEditObject->width(), 0.0); |
483 | } |
484 | |
485 | bool requiresUnhintedMetrics = !qmlDisableDistanceField(); |
486 | |
487 | for (int i = 0; i < standard.size(); i++) |
488 | { |
489 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + standard.at(i) + "\" }" ; |
490 | QQmlComponent texteditComponent(&engine); |
491 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
492 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
493 | |
494 | QString s = standard.at(i); |
495 | s.replace(before: QLatin1Char('\n'), after: QChar::LineSeparator); |
496 | |
497 | QTextLayout layout(s); |
498 | layout.setFont(textEditObject->font()); |
499 | layout.setFlags(Qt::TextExpandTabs | Qt::TextShowMnemonic); |
500 | if (requiresUnhintedMetrics) { |
501 | QTextOption option; |
502 | option.setUseDesignMetrics(true); |
503 | layout.setTextOption(option); |
504 | } |
505 | |
506 | layout.beginLayout(); |
507 | forever { |
508 | QTextLine line = layout.createLine(); |
509 | if (!line.isValid()) |
510 | break; |
511 | } |
512 | |
513 | layout.endLayout(); |
514 | |
515 | qreal metricWidth = layout.boundingRect().width(); |
516 | |
517 | QVERIFY(textEditObject != nullptr); |
518 | QCOMPARE(textEditObject->width(), metricWidth); |
519 | } |
520 | |
521 | for (int i = 0; i < richText.size(); i++) |
522 | { |
523 | QTextDocument document; |
524 | document.setHtml(richText.at(i)); |
525 | document.setDocumentMargin(0); |
526 | if (requiresUnhintedMetrics) |
527 | document.setUseDesignMetrics(true); |
528 | |
529 | qreal documentWidth = document.idealWidth(); |
530 | |
531 | QString componentStr = "import QtQuick 2.0\nTextEdit { textFormat: TextEdit.RichText; text: \"" + richText.at(i) + "\" }" ; |
532 | QQmlComponent texteditComponent(&engine); |
533 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
534 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
535 | |
536 | QVERIFY(textEditObject != nullptr); |
537 | QCOMPARE(textEditObject->width(), documentWidth); |
538 | } |
539 | } |
540 | |
541 | void tst_qquicktextedit::wrap() |
542 | { |
543 | // for specified width and wrap set true |
544 | { |
545 | QQmlComponent texteditComponent(&engine); |
546 | texteditComponent.setData("import QtQuick 2.0\nTextEdit { text: \"\"; wrapMode: TextEdit.WordWrap; width: 300 }" , baseUrl: QUrl()); |
547 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
548 | |
549 | QVERIFY(textEditObject != nullptr); |
550 | QCOMPARE(textEditObject->width(), 300.); |
551 | } |
552 | |
553 | for (int i = 0; i < standard.size(); i++) |
554 | { |
555 | QString componentStr = "import QtQuick 2.0\nTextEdit { wrapMode: TextEdit.WordWrap; width: 300; text: \"" + standard.at(i) + "\" }" ; |
556 | QQmlComponent texteditComponent(&engine); |
557 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
558 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
559 | |
560 | QVERIFY(textEditObject != nullptr); |
561 | QCOMPARE(textEditObject->width(), 300.); |
562 | } |
563 | |
564 | for (int i = 0; i < richText.size(); i++) |
565 | { |
566 | QString componentStr = "import QtQuick 2.0\nTextEdit { wrapMode: TextEdit.WordWrap; width: 300; text: \"" + richText.at(i) + "\" }" ; |
567 | QQmlComponent texteditComponent(&engine); |
568 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
569 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
570 | |
571 | QVERIFY(textEditObject != nullptr); |
572 | QCOMPARE(textEditObject->width(), 300.); |
573 | } |
574 | { |
575 | QQmlComponent component(&engine); |
576 | component.setData("import QtQuick 2.0\n TextEdit {}" , baseUrl: QUrl()); |
577 | QScopedPointer<QObject> object(component.create()); |
578 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: object.data()); |
579 | QVERIFY(edit); |
580 | |
581 | QSignalSpy spy(edit, SIGNAL(wrapModeChanged())); |
582 | |
583 | QCOMPARE(edit->wrapMode(), QQuickTextEdit::NoWrap); |
584 | |
585 | edit->setWrapMode(QQuickTextEdit::Wrap); |
586 | QCOMPARE(edit->wrapMode(), QQuickTextEdit::Wrap); |
587 | QCOMPARE(spy.count(), 1); |
588 | |
589 | edit->setWrapMode(QQuickTextEdit::Wrap); |
590 | QCOMPARE(spy.count(), 1); |
591 | |
592 | edit->setWrapMode(QQuickTextEdit::NoWrap); |
593 | QCOMPARE(edit->wrapMode(), QQuickTextEdit::NoWrap); |
594 | QCOMPARE(spy.count(), 2); |
595 | } |
596 | |
597 | } |
598 | |
599 | void tst_qquicktextedit::textFormat() |
600 | { |
601 | { |
602 | QQmlComponent textComponent(&engine); |
603 | textComponent.setData("import QtQuick 2.0\nTextEdit { text: \"Hello\"; textFormat: Text.RichText }" , baseUrl: QUrl::fromLocalFile(localfile: "" )); |
604 | QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit*>(object: textComponent.create()); |
605 | |
606 | QVERIFY(textObject != nullptr); |
607 | QCOMPARE(textObject->textFormat(), QQuickTextEdit::RichText); |
608 | } |
609 | { |
610 | QQmlComponent textComponent(&engine); |
611 | textComponent.setData("import QtQuick 2.0\nTextEdit { text: \"<b>Hello</b>\"; textFormat: Text.PlainText }" , baseUrl: QUrl::fromLocalFile(localfile: "" )); |
612 | QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit*>(object: textComponent.create()); |
613 | |
614 | QVERIFY(textObject != nullptr); |
615 | QCOMPARE(textObject->textFormat(), QQuickTextEdit::PlainText); |
616 | } |
617 | { |
618 | QQmlComponent component(&engine); |
619 | component.setData("import QtQuick 2.0\n TextEdit {}" , baseUrl: QUrl()); |
620 | QScopedPointer<QObject> object(component.create()); |
621 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: object.data()); |
622 | QVERIFY(edit); |
623 | |
624 | QSignalSpy spy(edit, &QQuickTextEdit::textFormatChanged); |
625 | |
626 | QCOMPARE(edit->textFormat(), QQuickTextEdit::PlainText); |
627 | |
628 | edit->setTextFormat(QQuickTextEdit::RichText); |
629 | QCOMPARE(edit->textFormat(), QQuickTextEdit::RichText); |
630 | QCOMPARE(spy.count(), 1); |
631 | |
632 | edit->setTextFormat(QQuickTextEdit::RichText); |
633 | QCOMPARE(spy.count(), 1); |
634 | |
635 | edit->setTextFormat(QQuickTextEdit::PlainText); |
636 | QCOMPARE(edit->textFormat(), QQuickTextEdit::PlainText); |
637 | QCOMPARE(spy.count(), 2); |
638 | } |
639 | } |
640 | |
641 | static int calcLineCount(QTextDocument* doc) |
642 | { |
643 | int subLines = 0; |
644 | for (QTextBlock it = doc->begin(); it != doc->end(); it = it.next()) { |
645 | QTextLayout *layout = it.layout(); |
646 | if (!layout) |
647 | continue; |
648 | subLines += layout->lineCount()-1; |
649 | } |
650 | return doc->lineCount() + subLines; |
651 | } |
652 | |
653 | void tst_qquicktextedit::lineCount_data() |
654 | { |
655 | QTest::addColumn<QStringList>(name: "texts" ); |
656 | QTest::newRow(dataTag: "plaintext" ) << standard; |
657 | QTest::newRow(dataTag: "richtext" ) << richText; |
658 | } |
659 | |
660 | void tst_qquicktextedit::lineCount() |
661 | { |
662 | QFETCH(QStringList, texts); |
663 | |
664 | foreach (const QString& text, texts) { |
665 | QQmlComponent component(&engine); |
666 | component.setData("import QtQuick 2.0\nTextEdit { }" , baseUrl: QUrl()); |
667 | |
668 | QQuickTextEdit *textedit = qobject_cast<QQuickTextEdit*>(object: component.create()); |
669 | QVERIFY(textedit); |
670 | |
671 | QTextDocument *doc = QQuickTextEditPrivate::get(item: textedit)->document; |
672 | QVERIFY(doc); |
673 | |
674 | textedit->setText(text); |
675 | |
676 | textedit->setWidth(100.0); |
677 | QCOMPARE(textedit->lineCount(), calcLineCount(doc)); |
678 | |
679 | textedit->setWrapMode(QQuickTextEdit::Wrap); |
680 | QCOMPARE(textedit->lineCount(), calcLineCount(doc)); |
681 | |
682 | textedit->setWidth(50.0); |
683 | QCOMPARE(textedit->lineCount(), calcLineCount(doc)); |
684 | |
685 | textedit->setWrapMode(QQuickTextEdit::NoWrap); |
686 | QCOMPARE(textedit->lineCount(), calcLineCount(doc)); |
687 | } |
688 | } |
689 | |
690 | //the alignment tests may be trivial o.oa |
691 | void tst_qquicktextedit::hAlign() |
692 | { |
693 | //test one align each, and then test if two align fails. |
694 | |
695 | for (int i = 0; i < standard.size(); i++) |
696 | { |
697 | for (int j=0; j < hAlignmentStrings.size(); j++) |
698 | { |
699 | QString componentStr = "import QtQuick 2.0\nTextEdit { horizontalAlignment: \"" + hAlignmentStrings.at(i: j) + "\"; text: \"" + standard.at(i) + "\" }" ; |
700 | QQmlComponent texteditComponent(&engine); |
701 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
702 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
703 | |
704 | QVERIFY(textEditObject != nullptr); |
705 | QCOMPARE((int)textEditObject->hAlign(), (int)hAlignments.at(j)); |
706 | } |
707 | } |
708 | |
709 | for (int i = 0; i < richText.size(); i++) |
710 | { |
711 | for (int j=0; j < hAlignmentStrings.size(); j++) |
712 | { |
713 | QString componentStr = "import QtQuick 2.0\nTextEdit { horizontalAlignment: \"" + hAlignmentStrings.at(i: j) + "\"; text: \"" + richText.at(i) + "\" }" ; |
714 | QQmlComponent texteditComponent(&engine); |
715 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
716 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
717 | |
718 | QVERIFY(textEditObject != nullptr); |
719 | QCOMPARE((int)textEditObject->hAlign(), (int)hAlignments.at(j)); |
720 | } |
721 | } |
722 | |
723 | } |
724 | |
725 | void tst_qquicktextedit::hAlign_RightToLeft() |
726 | { |
727 | PlatformInputContext platformInputContext; |
728 | QInputMethodPrivate *inputMethodPrivate = QInputMethodPrivate::get(qApp->inputMethod()); |
729 | inputMethodPrivate->testContext = &platformInputContext; |
730 | |
731 | QQuickView window(testFileUrl(fileName: "horizontalAlignment_RightToLeft.qml" )); |
732 | QQuickTextEdit *textEdit = window.rootObject()->findChild<QQuickTextEdit*>(aName: "text" ); |
733 | QVERIFY(textEdit != nullptr); |
734 | window.showNormal(); |
735 | |
736 | const QString rtlText = textEdit->text(); |
737 | |
738 | // implicit alignment should follow the reading direction of text |
739 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
740 | QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2); |
741 | |
742 | // explicitly left aligned |
743 | textEdit->setHAlign(QQuickTextEdit::AlignLeft); |
744 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft); |
745 | QVERIFY(textEdit->positionToRectangle(0).x() < window.width()/2); |
746 | |
747 | // explicitly right aligned |
748 | textEdit->setHAlign(QQuickTextEdit::AlignRight); |
749 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
750 | QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2); |
751 | |
752 | QString textString = textEdit->text(); |
753 | textEdit->setText(QString("<i>" ) + textString + QString("</i>" )); |
754 | textEdit->resetHAlign(); |
755 | |
756 | // implicitly aligned rich text should follow the reading direction of RTL text |
757 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
758 | QCOMPARE(textEdit->effectiveHAlign(), textEdit->hAlign()); |
759 | QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2); |
760 | |
761 | // explicitly left aligned rich text |
762 | textEdit->setHAlign(QQuickTextEdit::AlignLeft); |
763 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft); |
764 | QCOMPARE(textEdit->effectiveHAlign(), textEdit->hAlign()); |
765 | QVERIFY(textEdit->positionToRectangle(0).x() < window.width()/2); |
766 | |
767 | // explicitly right aligned rich text |
768 | textEdit->setHAlign(QQuickTextEdit::AlignRight); |
769 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
770 | QCOMPARE(textEdit->effectiveHAlign(), textEdit->hAlign()); |
771 | QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2); |
772 | |
773 | textEdit->setText(textString); |
774 | |
775 | // explicitly center aligned |
776 | textEdit->setHAlign(QQuickTextEdit::AlignHCenter); |
777 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignHCenter); |
778 | QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2); |
779 | |
780 | // reseted alignment should go back to following the text reading direction |
781 | textEdit->resetHAlign(); |
782 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
783 | QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2); |
784 | |
785 | // mirror the text item |
786 | QQuickItemPrivate::get(item: textEdit)->setLayoutMirror(true); |
787 | |
788 | // mirrored implicit alignment should continue to follow the reading direction of the text |
789 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
790 | QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignRight); |
791 | QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2); |
792 | |
793 | // mirrored explicitly right aligned behaves as left aligned |
794 | textEdit->setHAlign(QQuickTextEdit::AlignRight); |
795 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
796 | QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignLeft); |
797 | QVERIFY(textEdit->positionToRectangle(0).x() < window.width()/2); |
798 | |
799 | // mirrored explicitly left aligned behaves as right aligned |
800 | textEdit->setHAlign(QQuickTextEdit::AlignLeft); |
801 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft); |
802 | QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignRight); |
803 | QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2); |
804 | |
805 | // disable mirroring |
806 | QQuickItemPrivate::get(item: textEdit)->setLayoutMirror(false); |
807 | textEdit->resetHAlign(); |
808 | |
809 | // English text should be implicitly left aligned |
810 | textEdit->setText("Hello world!" ); |
811 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft); |
812 | QVERIFY(textEdit->positionToRectangle(0).x() < window.width()/2); |
813 | |
814 | window.requestActivate(); |
815 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
816 | QVERIFY(textEdit->hasActiveFocus()); |
817 | |
818 | textEdit->setText(QString()); |
819 | { QInputMethodEvent ev(rtlText, QList<QInputMethodEvent::Attribute>()); QGuiApplication::sendEvent(receiver: textEdit, event: &ev); } |
820 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
821 | { QInputMethodEvent ev("Hello world!" , QList<QInputMethodEvent::Attribute>()); QGuiApplication::sendEvent(receiver: textEdit, event: &ev); } |
822 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft); |
823 | |
824 | // Clear pre-edit text. TextEdit should maybe do this itself on setText, but that may be |
825 | // redundant as an actual input method may take care of it. |
826 | { QInputMethodEvent ev; QGuiApplication::sendEvent(receiver: textEdit, event: &ev); } |
827 | |
828 | // empty text with implicit alignment follows the system locale-based |
829 | // keyboard input direction from qApp->inputMethod()->inputDirection |
830 | textEdit->setText("" ); |
831 | platformInputContext.setInputDirection(Qt::LeftToRight); |
832 | QCOMPARE(qApp->inputMethod()->inputDirection(), Qt::LeftToRight); |
833 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignLeft); |
834 | QVERIFY(textEdit->positionToRectangle(0).x() < window.width()/2); |
835 | |
836 | QSignalSpy cursorRectangleSpy(textEdit, SIGNAL(cursorRectangleChanged())); |
837 | |
838 | platformInputContext.setInputDirection(Qt::RightToLeft); |
839 | QCOMPARE(cursorRectangleSpy.count(), 1); |
840 | QCOMPARE(qApp->inputMethod()->inputDirection(), Qt::RightToLeft); |
841 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
842 | QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2); |
843 | |
844 | // neutral text follows also input method direction |
845 | textEdit->resetHAlign(); |
846 | textEdit->setText(" ()((=<>" ); |
847 | platformInputContext.setInputDirection(Qt::LeftToRight); |
848 | QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignLeft); |
849 | QVERIFY(textEdit->cursorRectangle().left() < window.width()/2); |
850 | platformInputContext.setInputDirection(Qt::RightToLeft); |
851 | QCOMPARE(textEdit->effectiveHAlign(), QQuickTextEdit::AlignRight); |
852 | QVERIFY(textEdit->cursorRectangle().left() > window.width()/2); |
853 | |
854 | // set input direction while having content |
855 | platformInputContext.setInputDirection(Qt::LeftToRight); |
856 | textEdit->setText("a" ); |
857 | textEdit->setCursorPosition(1); |
858 | platformInputContext.setInputDirection(Qt::RightToLeft); |
859 | QTest::keyClick(window: &window, key: Qt::Key_Backspace); |
860 | QVERIFY(textEdit->text().isEmpty()); |
861 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
862 | QVERIFY(textEdit->cursorRectangle().left() > window.width()/2); |
863 | |
864 | // input direction changed while not having focus |
865 | platformInputContext.setInputDirection(Qt::LeftToRight); |
866 | textEdit->setFocus(false); |
867 | platformInputContext.setInputDirection(Qt::RightToLeft); |
868 | textEdit->setFocus(true); |
869 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
870 | QVERIFY(textEdit->cursorRectangle().left() > window.width()/2); |
871 | |
872 | textEdit->setHAlign(QQuickTextEdit::AlignRight); |
873 | QCOMPARE(textEdit->hAlign(), QQuickTextEdit::AlignRight); |
874 | QVERIFY(textEdit->positionToRectangle(0).x() > window.width()/2); |
875 | |
876 | // make sure editor doesn't rely on input for updating size |
877 | QQuickTextEdit *emptyEdit = window.rootObject()->findChild<QQuickTextEdit*>(aName: "emptyTextEdit" ); |
878 | QVERIFY(emptyEdit != nullptr); |
879 | platformInputContext.setInputDirection(Qt::RightToLeft); |
880 | emptyEdit->setFocus(true); |
881 | QCOMPARE(emptyEdit->hAlign(), QQuickTextEdit::AlignRight); |
882 | QVERIFY(emptyEdit->cursorRectangle().left() > window.width()/2); |
883 | } |
884 | |
885 | |
886 | static int numberOfNonWhitePixels(int fromX, int toX, const QImage &image) |
887 | { |
888 | int pixels = 0; |
889 | for (int x = fromX; x < toX; ++x) { |
890 | for (int y = 0; y < image.height(); ++y) { |
891 | if (image.pixel(x, y) != qRgb(r: 255, g: 255, b: 255)) |
892 | pixels++; |
893 | } |
894 | } |
895 | return pixels; |
896 | } |
897 | |
898 | static inline QByteArray msgNotGreaterThan(int n1, int n2) |
899 | { |
900 | return QByteArray::number(n1) + QByteArrayLiteral(" is not greater than " ) + QByteArray::number(n2); |
901 | } |
902 | |
903 | static inline QByteArray msgNotLessThan(int n1, int n2) |
904 | { |
905 | return QByteArray::number(n1) + QByteArrayLiteral(" is not less than " ) + QByteArray::number(n2); |
906 | } |
907 | |
908 | void tst_qquicktextedit::hAlignVisual() |
909 | { |
910 | QQuickView view(testFileUrl(fileName: "hAlignVisual.qml" )); |
911 | view.setFlags(view.flags() | Qt::WindowStaysOnTopHint); // Prevent being obscured by other windows. |
912 | view.showNormal(); |
913 | QVERIFY(QTest::qWaitForWindowExposed(&view)); |
914 | |
915 | QQuickText *text = view.rootObject()->findChild<QQuickText*>(aName: "textItem" ); |
916 | QVERIFY(text != nullptr); |
917 | |
918 | // Try to check whether alignment works by checking the number of black |
919 | // pixels in the thirds of the grabbed image. |
920 | const int windowWidth = 200; |
921 | const int textWidth = qCeil(v: text->implicitWidth()); |
922 | QVERIFY2(textWidth < windowWidth, "System font too large." ); |
923 | const int sectionWidth = textWidth / 3; |
924 | const int centeredSection1 = (windowWidth - textWidth) / 2; |
925 | const int centeredSection2 = centeredSection1 + sectionWidth; |
926 | const int centeredSection3 = centeredSection2 + sectionWidth; |
927 | const int centeredSection3End = centeredSection3 + sectionWidth; |
928 | |
929 | { |
930 | if ((QGuiApplication::platformName() == QLatin1String("offscreen" )) |
931 | || (QGuiApplication::platformName() == QLatin1String("minimal" ))) |
932 | QEXPECT_FAIL("" , "Failure due to grabWindow not functional on offscreen/minimal platforms" , Abort); |
933 | |
934 | // Left Align |
935 | QImage image = view.grabWindow(); |
936 | const int left = numberOfNonWhitePixels(fromX: centeredSection1, toX: centeredSection2, image); |
937 | const int mid = numberOfNonWhitePixels(fromX: centeredSection2, toX: centeredSection3, image); |
938 | const int right = numberOfNonWhitePixels(fromX: centeredSection3, toX: centeredSection3End, image); |
939 | QVERIFY2(left > mid, msgNotGreaterThan(left, mid).constData()); |
940 | QVERIFY2(mid > right, msgNotGreaterThan(mid, right).constData()); |
941 | } |
942 | { |
943 | // HCenter Align |
944 | text->setHAlign(QQuickText::AlignHCenter); |
945 | QImage image = view.grabWindow(); |
946 | const int left = numberOfNonWhitePixels(fromX: centeredSection1, toX: centeredSection2, image); |
947 | const int mid = numberOfNonWhitePixels(fromX: centeredSection2, toX: centeredSection3, image); |
948 | const int right = numberOfNonWhitePixels(fromX: centeredSection3, toX: centeredSection3End, image); |
949 | QVERIFY2(left < mid, msgNotLessThan(left, mid).constData()); |
950 | QVERIFY2(mid > right, msgNotGreaterThan(mid, right).constData()); |
951 | } |
952 | { |
953 | // Right Align |
954 | text->setHAlign(QQuickText::AlignRight); |
955 | QImage image = view.grabWindow(); |
956 | const int left = numberOfNonWhitePixels(fromX: centeredSection1, toX: centeredSection2, image); |
957 | const int mid = numberOfNonWhitePixels(fromX: centeredSection2, toX: centeredSection3, image); |
958 | const int right = numberOfNonWhitePixels(fromX: centeredSection3, toX: centeredSection3End, image); |
959 | QVERIFY2(left < mid, msgNotLessThan(left, mid).constData()); |
960 | QVERIFY2(mid < right, msgNotLessThan(mid, right).constData()); |
961 | } |
962 | |
963 | text->setWidth(200); |
964 | |
965 | { |
966 | // Left Align |
967 | QImage image = view.grabWindow(); |
968 | int x = qCeil(v: text->implicitWidth()); |
969 | int left = numberOfNonWhitePixels(fromX: 0, toX: x, image); |
970 | int right = numberOfNonWhitePixels(fromX: x, toX: image.width() - x, image); |
971 | QVERIFY2(left > 0, msgNotGreaterThan(left, 0).constData()); |
972 | QCOMPARE(right, 0); |
973 | } |
974 | { |
975 | // HCenter Align |
976 | text->setHAlign(QQuickText::AlignHCenter); |
977 | QImage image = view.grabWindow(); |
978 | int x1 = qFloor(v: image.width() - text->implicitWidth()) / 2; |
979 | int x2 = image.width() - x1; |
980 | int left = numberOfNonWhitePixels(fromX: 0, toX: x1, image); |
981 | int mid = numberOfNonWhitePixels(fromX: x1, toX: x2 - x1, image); |
982 | int right = numberOfNonWhitePixels(fromX: x2, toX: image.width() - x2, image); |
983 | QCOMPARE(left, 0); |
984 | QVERIFY2(mid > 0, msgNotGreaterThan(left, 0).constData()); |
985 | QCOMPARE(right, 0); |
986 | } |
987 | { |
988 | // Right Align |
989 | text->setHAlign(QQuickText::AlignRight); |
990 | QImage image = view.grabWindow(); |
991 | int x = image.width() - qCeil(v: text->implicitWidth()); |
992 | int left = numberOfNonWhitePixels(fromX: 0, toX: x, image); |
993 | int right = numberOfNonWhitePixels(fromX: x, toX: image.width() - x, image); |
994 | QCOMPARE(left, 0); |
995 | QVERIFY2(right > 0, msgNotGreaterThan(left, 0).constData()); |
996 | } |
997 | } |
998 | |
999 | void tst_qquicktextedit::vAlign() |
1000 | { |
1001 | //test one align each, and then test if two align fails. |
1002 | |
1003 | for (int i = 0; i < standard.size(); i++) |
1004 | { |
1005 | for (int j=0; j < vAlignmentStrings.size(); j++) |
1006 | { |
1007 | QString componentStr = "import QtQuick 2.0\nTextEdit { verticalAlignment: \"" + vAlignmentStrings.at(i: j) + "\"; text: \"" + standard.at(i) + "\" }" ; |
1008 | QQmlComponent texteditComponent(&engine); |
1009 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1010 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1011 | |
1012 | QVERIFY(textEditObject != nullptr); |
1013 | QCOMPARE((int)textEditObject->vAlign(), (int)vAlignments.at(j)); |
1014 | } |
1015 | } |
1016 | |
1017 | for (int i = 0; i < richText.size(); i++) |
1018 | { |
1019 | for (int j=0; j < vAlignmentStrings.size(); j++) |
1020 | { |
1021 | QString componentStr = "import QtQuick 2.0\nTextEdit { verticalAlignment: \"" + vAlignmentStrings.at(i: j) + "\"; text: \"" + richText.at(i) + "\" }" ; |
1022 | QQmlComponent texteditComponent(&engine); |
1023 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1024 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1025 | |
1026 | QVERIFY(textEditObject != nullptr); |
1027 | QCOMPARE((int)textEditObject->vAlign(), (int)vAlignments.at(j)); |
1028 | } |
1029 | } |
1030 | |
1031 | QQmlComponent texteditComponent(&engine); |
1032 | texteditComponent.setData( |
1033 | "import QtQuick 2.0\n" |
1034 | "TextEdit { width: 100; height: 100; text: \"Hello World\" }" , baseUrl: QUrl()); |
1035 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1036 | |
1037 | QVERIFY(textEditObject != nullptr); |
1038 | |
1039 | QCOMPARE(textEditObject->vAlign(), QQuickTextEdit::AlignTop); |
1040 | QVERIFY(textEditObject->cursorRectangle().bottom() < 50); |
1041 | QVERIFY(textEditObject->positionToRectangle(0).bottom() < 50); |
1042 | |
1043 | // bottom aligned |
1044 | textEditObject->setVAlign(QQuickTextEdit::AlignBottom); |
1045 | QCOMPARE(textEditObject->vAlign(), QQuickTextEdit::AlignBottom); |
1046 | QVERIFY(textEditObject->cursorRectangle().top() > 50); |
1047 | QVERIFY(textEditObject->positionToRectangle(0).top() > 50); |
1048 | |
1049 | // explicitly center aligned |
1050 | textEditObject->setVAlign(QQuickTextEdit::AlignVCenter); |
1051 | QCOMPARE(textEditObject->vAlign(), QQuickTextEdit::AlignVCenter); |
1052 | QVERIFY(textEditObject->cursorRectangle().top() < 50); |
1053 | QVERIFY(textEditObject->cursorRectangle().bottom() > 50); |
1054 | QVERIFY(textEditObject->positionToRectangle(0).top() < 50); |
1055 | QVERIFY(textEditObject->positionToRectangle(0).bottom() > 50); |
1056 | |
1057 | // Test vertical alignment after resizing the height. |
1058 | textEditObject->setHeight(textEditObject->height() - 20); |
1059 | QVERIFY(textEditObject->cursorRectangle().top() < 40); |
1060 | QVERIFY(textEditObject->cursorRectangle().bottom() > 40); |
1061 | QVERIFY(textEditObject->positionToRectangle(0).top() < 40); |
1062 | QVERIFY(textEditObject->positionToRectangle(0).bottom() > 40); |
1063 | |
1064 | textEditObject->setHeight(textEditObject->height() + 40); |
1065 | QVERIFY(textEditObject->cursorRectangle().top() < 60); |
1066 | QVERIFY(textEditObject->cursorRectangle().bottom() > 60); |
1067 | QVERIFY(textEditObject->positionToRectangle(0).top() < 60); |
1068 | QVERIFY(textEditObject->positionToRectangle(0).bottom() > 60); |
1069 | } |
1070 | |
1071 | void tst_qquicktextedit::font() |
1072 | { |
1073 | //test size, then bold, then italic, then family |
1074 | { |
1075 | QString componentStr = "import QtQuick 2.0\nTextEdit { font.pointSize: 40; text: \"Hello World\" }" ; |
1076 | QQmlComponent texteditComponent(&engine); |
1077 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1078 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1079 | |
1080 | QVERIFY(textEditObject != nullptr); |
1081 | QCOMPARE(textEditObject->font().pointSize(), 40); |
1082 | QCOMPARE(textEditObject->font().bold(), false); |
1083 | QCOMPARE(textEditObject->font().italic(), false); |
1084 | } |
1085 | |
1086 | { |
1087 | QString componentStr = "import QtQuick 2.0\nTextEdit { font.bold: true; text: \"Hello World\" }" ; |
1088 | QQmlComponent texteditComponent(&engine); |
1089 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1090 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1091 | |
1092 | QVERIFY(textEditObject != nullptr); |
1093 | QCOMPARE(textEditObject->font().bold(), true); |
1094 | QCOMPARE(textEditObject->font().italic(), false); |
1095 | } |
1096 | |
1097 | { |
1098 | QString componentStr = "import QtQuick 2.0\nTextEdit { font.italic: true; text: \"Hello World\" }" ; |
1099 | QQmlComponent texteditComponent(&engine); |
1100 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1101 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1102 | |
1103 | QVERIFY(textEditObject != nullptr); |
1104 | QCOMPARE(textEditObject->font().italic(), true); |
1105 | QCOMPARE(textEditObject->font().bold(), false); |
1106 | } |
1107 | |
1108 | { |
1109 | QString componentStr = "import QtQuick 2.0\nTextEdit { font.family: \"Helvetica\"; text: \"Hello World\" }" ; |
1110 | QQmlComponent texteditComponent(&engine); |
1111 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1112 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1113 | |
1114 | QVERIFY(textEditObject != nullptr); |
1115 | QCOMPARE(textEditObject->font().family(), QString("Helvetica" )); |
1116 | QCOMPARE(textEditObject->font().bold(), false); |
1117 | QCOMPARE(textEditObject->font().italic(), false); |
1118 | } |
1119 | |
1120 | { |
1121 | QString componentStr = "import QtQuick 2.0\nTextEdit { font.family: \"\"; text: \"Hello World\" }" ; |
1122 | QQmlComponent texteditComponent(&engine); |
1123 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1124 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1125 | |
1126 | QVERIFY(textEditObject != nullptr); |
1127 | QCOMPARE(textEditObject->font().family(), QString("" )); |
1128 | } |
1129 | } |
1130 | |
1131 | void tst_qquicktextedit::color() |
1132 | { |
1133 | //test initial color |
1134 | { |
1135 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"Hello World\" }" ; |
1136 | QQmlComponent texteditComponent(&engine); |
1137 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1138 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1139 | |
1140 | QVERIFY(textEditObject); |
1141 | QCOMPARE(textEditObject->color(), QColor("black" )); |
1142 | QCOMPARE(textEditObject->selectionColor(), QColor::fromRgba(0xFF000080)); |
1143 | QCOMPARE(textEditObject->selectedTextColor(), QColor("white" )); |
1144 | |
1145 | QSignalSpy colorSpy(textEditObject, SIGNAL(colorChanged(QColor))); |
1146 | QSignalSpy selectionColorSpy(textEditObject, SIGNAL(selectionColorChanged(QColor))); |
1147 | QSignalSpy selectedTextColorSpy(textEditObject, SIGNAL(selectedTextColorChanged(QColor))); |
1148 | |
1149 | textEditObject->setColor(QColor("white" )); |
1150 | QCOMPARE(textEditObject->color(), QColor("white" )); |
1151 | QCOMPARE(colorSpy.count(), 1); |
1152 | |
1153 | textEditObject->setSelectionColor(QColor("black" )); |
1154 | QCOMPARE(textEditObject->selectionColor(), QColor("black" )); |
1155 | QCOMPARE(selectionColorSpy.count(), 1); |
1156 | |
1157 | textEditObject->setSelectedTextColor(QColor("blue" )); |
1158 | QCOMPARE(textEditObject->selectedTextColor(), QColor("blue" )); |
1159 | QCOMPARE(selectedTextColorSpy.count(), 1); |
1160 | |
1161 | textEditObject->setColor(QColor("white" )); |
1162 | QCOMPARE(colorSpy.count(), 1); |
1163 | |
1164 | textEditObject->setSelectionColor(QColor("black" )); |
1165 | QCOMPARE(selectionColorSpy.count(), 1); |
1166 | |
1167 | textEditObject->setSelectedTextColor(QColor("blue" )); |
1168 | QCOMPARE(selectedTextColorSpy.count(), 1); |
1169 | |
1170 | textEditObject->setColor(QColor("black" )); |
1171 | QCOMPARE(textEditObject->color(), QColor("black" )); |
1172 | QCOMPARE(colorSpy.count(), 2); |
1173 | |
1174 | textEditObject->setSelectionColor(QColor("blue" )); |
1175 | QCOMPARE(textEditObject->selectionColor(), QColor("blue" )); |
1176 | QCOMPARE(selectionColorSpy.count(), 2); |
1177 | |
1178 | textEditObject->setSelectedTextColor(QColor("white" )); |
1179 | QCOMPARE(textEditObject->selectedTextColor(), QColor("white" )); |
1180 | QCOMPARE(selectedTextColorSpy.count(), 2); |
1181 | } |
1182 | |
1183 | //test normal |
1184 | for (int i = 0; i < colorStrings.size(); i++) |
1185 | { |
1186 | QString componentStr = "import QtQuick 2.0\nTextEdit { color: \"" + colorStrings.at(i) + "\"; text: \"Hello World\" }" ; |
1187 | QQmlComponent texteditComponent(&engine); |
1188 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1189 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1190 | //qDebug() << "textEditObject: " << textEditObject->color() << "vs. " << QColor(colorStrings.at(i)); |
1191 | QVERIFY(textEditObject != nullptr); |
1192 | QCOMPARE(textEditObject->color(), QColor(colorStrings.at(i))); |
1193 | } |
1194 | |
1195 | //test selection |
1196 | for (int i = 0; i < colorStrings.size(); i++) |
1197 | { |
1198 | QString componentStr = "import QtQuick 2.0\nTextEdit { selectionColor: \"" + colorStrings.at(i) + "\"; text: \"Hello World\" }" ; |
1199 | QQmlComponent texteditComponent(&engine); |
1200 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1201 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1202 | QVERIFY(textEditObject != nullptr); |
1203 | QCOMPARE(textEditObject->selectionColor(), QColor(colorStrings.at(i))); |
1204 | } |
1205 | |
1206 | //test selected text |
1207 | for (int i = 0; i < colorStrings.size(); i++) |
1208 | { |
1209 | QString componentStr = "import QtQuick 2.0\nTextEdit { selectedTextColor: \"" + colorStrings.at(i) + "\"; text: \"Hello World\" }" ; |
1210 | QQmlComponent texteditComponent(&engine); |
1211 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1212 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1213 | QVERIFY(textEditObject != nullptr); |
1214 | QCOMPARE(textEditObject->selectedTextColor(), QColor(colorStrings.at(i))); |
1215 | } |
1216 | |
1217 | { |
1218 | QString colorStr = "#AA001234" ; |
1219 | QColor testColor("#001234" ); |
1220 | testColor.setAlpha(170); |
1221 | |
1222 | QString componentStr = "import QtQuick 2.0\nTextEdit { color: \"" + colorStr + "\"; text: \"Hello World\" }" ; |
1223 | QQmlComponent texteditComponent(&engine); |
1224 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1225 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1226 | |
1227 | QVERIFY(textEditObject != nullptr); |
1228 | QCOMPARE(textEditObject->color(), testColor); |
1229 | } |
1230 | } |
1231 | |
1232 | void tst_qquicktextedit::textMargin() |
1233 | { |
1234 | for (qreal i=0; i<=10; i+=0.3) { |
1235 | QString componentStr = "import QtQuick 2.0\nTextEdit { textMargin: " + QString::number(i) + "; text: \"Hello World\" }" ; |
1236 | QQmlComponent texteditComponent(&engine); |
1237 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1238 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1239 | QVERIFY(textEditObject != nullptr); |
1240 | QCOMPARE(textEditObject->textMargin(), i); |
1241 | } |
1242 | } |
1243 | |
1244 | void tst_qquicktextedit::persistentSelection() |
1245 | { |
1246 | QQuickView window(testFileUrl(fileName: "persistentSelection.qml" )); |
1247 | window.show(); |
1248 | window.requestActivate(); |
1249 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
1250 | |
1251 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: window.rootObject()); |
1252 | QVERIFY(edit); |
1253 | QVERIFY(edit->hasActiveFocus()); |
1254 | |
1255 | QSignalSpy spy(edit, SIGNAL(persistentSelectionChanged(bool))); |
1256 | |
1257 | QCOMPARE(edit->persistentSelection(), false); |
1258 | |
1259 | edit->setPersistentSelection(false); |
1260 | QCOMPARE(edit->persistentSelection(), false); |
1261 | QCOMPARE(spy.count(), 0); |
1262 | |
1263 | edit->select(start: 1, end: 4); |
1264 | QCOMPARE(edit->property("selected" ).toString(), QLatin1String("ell" )); |
1265 | |
1266 | edit->setFocus(false); |
1267 | QCOMPARE(edit->property("selected" ).toString(), QString()); |
1268 | |
1269 | edit->setFocus(true); |
1270 | QCOMPARE(edit->property("selected" ).toString(), QString()); |
1271 | |
1272 | edit->setPersistentSelection(true); |
1273 | QCOMPARE(edit->persistentSelection(), true); |
1274 | QCOMPARE(spy.count(), 1); |
1275 | |
1276 | edit->select(start: 1, end: 4); |
1277 | QCOMPARE(edit->property("selected" ).toString(), QLatin1String("ell" )); |
1278 | |
1279 | edit->setFocus(false); |
1280 | QCOMPARE(edit->property("selected" ).toString(), QLatin1String("ell" )); |
1281 | |
1282 | edit->setFocus(true); |
1283 | QCOMPARE(edit->property("selected" ).toString(), QLatin1String("ell" )); |
1284 | |
1285 | // QTBUG-50587 (persistentSelection with readOnly) |
1286 | edit->setReadOnly(true); |
1287 | |
1288 | edit->setPersistentSelection(false); |
1289 | QCOMPARE(edit->persistentSelection(), false); |
1290 | QCOMPARE(spy.count(), 2); |
1291 | |
1292 | edit->select(start: 1, end: 4); |
1293 | QCOMPARE(edit->property("selected" ).toString(), QLatin1String("ell" )); |
1294 | |
1295 | edit->setFocus(false); |
1296 | QCOMPARE(edit->property("selected" ).toString(), QString()); |
1297 | |
1298 | edit->setFocus(true); |
1299 | QCOMPARE(edit->property("selected" ).toString(), QString()); |
1300 | |
1301 | edit->setPersistentSelection(true); |
1302 | QCOMPARE(edit->persistentSelection(), true); |
1303 | QCOMPARE(spy.count(), 3); |
1304 | |
1305 | edit->select(start: 1, end: 4); |
1306 | QCOMPARE(edit->property("selected" ).toString(), QLatin1String("ell" )); |
1307 | |
1308 | edit->setFocus(false); |
1309 | QCOMPARE(edit->property("selected" ).toString(), QLatin1String("ell" )); |
1310 | |
1311 | edit->setFocus(true); |
1312 | QCOMPARE(edit->property("selected" ).toString(), QLatin1String("ell" )); |
1313 | } |
1314 | |
1315 | void tst_qquicktextedit::selectionOnFocusOut() |
1316 | { |
1317 | QQuickView window(testFileUrl(fileName: "focusOutSelection.qml" )); |
1318 | window.show(); |
1319 | window.requestActivate(); |
1320 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
1321 | |
1322 | QPoint p1(25, 35); |
1323 | QPoint p2(25, 85); |
1324 | |
1325 | QQuickTextEdit *edit1 = window.rootObject()->findChild<QQuickTextEdit*>(aName: "text1" ); |
1326 | QQuickTextEdit *edit2 = window.rootObject()->findChild<QQuickTextEdit*>(aName: "text2" ); |
1327 | |
1328 | QTest::mouseClick(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: p1); |
1329 | QVERIFY(edit1->hasActiveFocus()); |
1330 | QVERIFY(!edit2->hasActiveFocus()); |
1331 | |
1332 | edit1->selectAll(); |
1333 | QCOMPARE(edit1->selectedText(), QLatin1String("text 1" )); |
1334 | |
1335 | QTest::mouseClick(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: p2); |
1336 | |
1337 | QCOMPARE(edit1->selectedText(), QLatin1String("" )); |
1338 | QVERIFY(!edit1->hasActiveFocus()); |
1339 | QVERIFY(edit2->hasActiveFocus()); |
1340 | |
1341 | edit2->selectAll(); |
1342 | QCOMPARE(edit2->selectedText(), QLatin1String("text 2" )); |
1343 | |
1344 | |
1345 | edit2->setFocus(focus: false, reason: Qt::ActiveWindowFocusReason); |
1346 | QVERIFY(!edit2->hasActiveFocus()); |
1347 | QCOMPARE(edit2->selectedText(), QLatin1String("text 2" )); |
1348 | |
1349 | edit2->setFocus(true); |
1350 | QVERIFY(edit2->hasActiveFocus()); |
1351 | |
1352 | edit2->setFocus(focus: false, reason: Qt::PopupFocusReason); |
1353 | QVERIFY(edit2->hasActiveFocus()); |
1354 | QCOMPARE(edit2->selectedText(), QLatin1String("text 2" )); |
1355 | } |
1356 | |
1357 | void tst_qquicktextedit::focusOnPress() |
1358 | { |
1359 | QString componentStr = |
1360 | "import QtQuick 2.0\n" |
1361 | "TextEdit {\n" |
1362 | "property bool selectOnFocus: false\n" |
1363 | "width: 100; height: 50\n" |
1364 | "activeFocusOnPress: true\n" |
1365 | "text: \"Hello World\"\n" |
1366 | "onFocusChanged: { if (focus && selectOnFocus) selectAll() }" |
1367 | " }" ; |
1368 | QQmlComponent texteditComponent(&engine); |
1369 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1370 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1371 | QVERIFY(textEditObject != nullptr); |
1372 | QCOMPARE(textEditObject->focusOnPress(), true); |
1373 | QCOMPARE(textEditObject->hasFocus(), false); |
1374 | |
1375 | QSignalSpy focusSpy(textEditObject, SIGNAL(focusChanged(bool))); |
1376 | QSignalSpy activeFocusSpy(textEditObject, SIGNAL(focusChanged(bool))); |
1377 | QSignalSpy activeFocusOnPressSpy(textEditObject, SIGNAL(activeFocusOnPressChanged(bool))); |
1378 | |
1379 | textEditObject->setFocusOnPress(true); |
1380 | QCOMPARE(textEditObject->focusOnPress(), true); |
1381 | QCOMPARE(activeFocusOnPressSpy.count(), 0); |
1382 | |
1383 | QQuickWindow window; |
1384 | window.resize(w: 100, h: 50); |
1385 | textEditObject->setParentItem(window.contentItem()); |
1386 | window.showNormal(); |
1387 | window.requestActivate(); |
1388 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
1389 | |
1390 | QCOMPARE(textEditObject->hasFocus(), false); |
1391 | QCOMPARE(textEditObject->hasActiveFocus(), false); |
1392 | |
1393 | QPoint centerPoint(window.width()/2, window.height()/2); |
1394 | Qt::KeyboardModifiers noModifiers; |
1395 | QTest::mousePress(window: &window, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
1396 | QGuiApplication::processEvents(); |
1397 | QCOMPARE(textEditObject->hasFocus(), true); |
1398 | QCOMPARE(textEditObject->hasActiveFocus(), true); |
1399 | QCOMPARE(focusSpy.count(), 1); |
1400 | QCOMPARE(activeFocusSpy.count(), 1); |
1401 | QCOMPARE(textEditObject->selectedText(), QString()); |
1402 | QTest::mouseRelease(window: &window, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
1403 | |
1404 | textEditObject->setFocusOnPress(false); |
1405 | QCOMPARE(textEditObject->focusOnPress(), false); |
1406 | QCOMPARE(activeFocusOnPressSpy.count(), 1); |
1407 | |
1408 | textEditObject->setFocus(false); |
1409 | QCOMPARE(textEditObject->hasFocus(), false); |
1410 | QCOMPARE(textEditObject->hasActiveFocus(), false); |
1411 | QCOMPARE(focusSpy.count(), 2); |
1412 | QCOMPARE(activeFocusSpy.count(), 2); |
1413 | |
1414 | // Wait for double click timeout to expire before clicking again. |
1415 | QTest::qWait(ms: 400); |
1416 | QTest::mousePress(window: &window, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
1417 | QGuiApplication::processEvents(); |
1418 | QCOMPARE(textEditObject->hasFocus(), false); |
1419 | QCOMPARE(textEditObject->hasActiveFocus(), false); |
1420 | QCOMPARE(focusSpy.count(), 2); |
1421 | QCOMPARE(activeFocusSpy.count(), 2); |
1422 | QTest::mouseRelease(window: &window, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
1423 | |
1424 | textEditObject->setFocusOnPress(true); |
1425 | QCOMPARE(textEditObject->focusOnPress(), true); |
1426 | QCOMPARE(activeFocusOnPressSpy.count(), 2); |
1427 | |
1428 | // Test a selection made in the on(Active)FocusChanged handler isn't overwritten. |
1429 | textEditObject->setProperty(name: "selectOnFocus" , value: true); |
1430 | |
1431 | QTest::qWait(ms: 400); |
1432 | QTest::mousePress(window: &window, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
1433 | QGuiApplication::processEvents(); |
1434 | QCOMPARE(textEditObject->hasFocus(), true); |
1435 | QCOMPARE(textEditObject->hasActiveFocus(), true); |
1436 | QCOMPARE(focusSpy.count(), 3); |
1437 | QCOMPARE(activeFocusSpy.count(), 3); |
1438 | QCOMPARE(textEditObject->selectedText(), textEditObject->text()); |
1439 | QTest::mouseRelease(window: &window, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
1440 | } |
1441 | |
1442 | void tst_qquicktextedit::selection() |
1443 | { |
1444 | QString testStr = standard[0];//TODO: What should happen for multiline/rich text? |
1445 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + testStr +"\"; }" ; |
1446 | QQmlComponent texteditComponent(&engine); |
1447 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1448 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
1449 | QVERIFY(textEditObject != nullptr); |
1450 | |
1451 | |
1452 | //Test selection follows cursor |
1453 | for (int i=0; i<= testStr.size(); i++) { |
1454 | textEditObject->setCursorPosition(i); |
1455 | QCOMPARE(textEditObject->cursorPosition(), i); |
1456 | QCOMPARE(textEditObject->selectionStart(), i); |
1457 | QCOMPARE(textEditObject->selectionEnd(), i); |
1458 | QVERIFY(textEditObject->selectedText().isNull()); |
1459 | } |
1460 | |
1461 | textEditObject->setCursorPosition(0); |
1462 | QCOMPARE(textEditObject->cursorPosition(), 0); |
1463 | QCOMPARE(textEditObject->selectionStart(), 0); |
1464 | QCOMPARE(textEditObject->selectionEnd(), 0); |
1465 | QVERIFY(textEditObject->selectedText().isNull()); |
1466 | |
1467 | // Verify invalid positions are ignored. |
1468 | textEditObject->setCursorPosition(-1); |
1469 | QCOMPARE(textEditObject->cursorPosition(), 0); |
1470 | QCOMPARE(textEditObject->selectionStart(), 0); |
1471 | QCOMPARE(textEditObject->selectionEnd(), 0); |
1472 | QVERIFY(textEditObject->selectedText().isNull()); |
1473 | |
1474 | textEditObject->setCursorPosition(textEditObject->text().count()+1); |
1475 | QCOMPARE(textEditObject->cursorPosition(), 0); |
1476 | QCOMPARE(textEditObject->selectionStart(), 0); |
1477 | QCOMPARE(textEditObject->selectionEnd(), 0); |
1478 | QVERIFY(textEditObject->selectedText().isNull()); |
1479 | |
1480 | //Test selection |
1481 | for (int i=0; i<= testStr.size(); i++) { |
1482 | textEditObject->select(start: 0,end: i); |
1483 | QCOMPARE(testStr.mid(0,i), textEditObject->selectedText()); |
1484 | } |
1485 | for (int i=0; i<= testStr.size(); i++) { |
1486 | textEditObject->select(start: i,end: testStr.size()); |
1487 | QCOMPARE(testStr.mid(i,testStr.size()-i), textEditObject->selectedText()); |
1488 | } |
1489 | |
1490 | textEditObject->setCursorPosition(0); |
1491 | QCOMPARE(textEditObject->cursorPosition(), 0); |
1492 | QCOMPARE(textEditObject->selectionStart(), 0); |
1493 | QCOMPARE(textEditObject->selectionEnd(), 0); |
1494 | QVERIFY(textEditObject->selectedText().isNull()); |
1495 | |
1496 | //Test Error Ignoring behaviour |
1497 | textEditObject->setCursorPosition(0); |
1498 | QVERIFY(textEditObject->selectedText().isNull()); |
1499 | textEditObject->select(start: -10,end: 0); |
1500 | QVERIFY(textEditObject->selectedText().isNull()); |
1501 | textEditObject->select(start: 100,end: 101); |
1502 | QVERIFY(textEditObject->selectedText().isNull()); |
1503 | textEditObject->select(start: 0,end: -10); |
1504 | QVERIFY(textEditObject->selectedText().isNull()); |
1505 | textEditObject->select(start: 0,end: 100); |
1506 | QVERIFY(textEditObject->selectedText().isNull()); |
1507 | textEditObject->select(start: 0,end: 10); |
1508 | QCOMPARE(textEditObject->selectedText().size(), 10); |
1509 | textEditObject->select(start: -10,end: 0); |
1510 | QCOMPARE(textEditObject->selectedText().size(), 10); |
1511 | textEditObject->select(start: 100,end: 101); |
1512 | QCOMPARE(textEditObject->selectedText().size(), 10); |
1513 | textEditObject->select(start: 0,end: -10); |
1514 | QCOMPARE(textEditObject->selectedText().size(), 10); |
1515 | textEditObject->select(start: 0,end: 100); |
1516 | QCOMPARE(textEditObject->selectedText().size(), 10); |
1517 | |
1518 | textEditObject->deselect(); |
1519 | QVERIFY(textEditObject->selectedText().isNull()); |
1520 | textEditObject->select(start: 0,end: 10); |
1521 | QCOMPARE(textEditObject->selectedText().size(), 10); |
1522 | textEditObject->deselect(); |
1523 | QVERIFY(textEditObject->selectedText().isNull()); |
1524 | } |
1525 | |
1526 | void tst_qquicktextedit::overwriteMode() |
1527 | { |
1528 | QString componentStr = "import QtQuick 2.0\nTextEdit { focus: true; }" ; |
1529 | QQmlComponent textEditComponent(&engine); |
1530 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1531 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
1532 | QVERIFY(textEdit != nullptr); |
1533 | |
1534 | QSignalSpy spy(textEdit, SIGNAL(overwriteModeChanged(bool))); |
1535 | |
1536 | QQuickWindow window; |
1537 | textEdit->setParentItem(window.contentItem()); |
1538 | window.show(); |
1539 | window.requestActivate(); |
1540 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
1541 | |
1542 | QVERIFY(textEdit->hasActiveFocus()); |
1543 | |
1544 | textEdit->setOverwriteMode(true); |
1545 | QCOMPARE(spy.count(), 1); |
1546 | QCOMPARE(true, textEdit->overwriteMode()); |
1547 | textEdit->setOverwriteMode(false); |
1548 | QCOMPARE(spy.count(), 2); |
1549 | QCOMPARE(false, textEdit->overwriteMode()); |
1550 | |
1551 | QVERIFY(!textEdit->overwriteMode()); |
1552 | QString insertString = "Some first text" ; |
1553 | for (int j = 0; j < insertString.length(); j++) |
1554 | QTest::keyClick(window: &window, key: insertString.at(i: j).toLatin1()); |
1555 | |
1556 | QCOMPARE(textEdit->text(), QString("Some first text" )); |
1557 | |
1558 | textEdit->setOverwriteMode(true); |
1559 | QCOMPARE(spy.count(), 3); |
1560 | textEdit->setCursorPosition(5); |
1561 | |
1562 | insertString = "shiny" ; |
1563 | for (int j = 0; j < insertString.length(); j++) |
1564 | QTest::keyClick(window: &window, key: insertString.at(i: j).toLatin1()); |
1565 | QCOMPARE(textEdit->text(), QString("Some shiny text" )); |
1566 | |
1567 | textEdit->setCursorPosition(textEdit->text().length()); |
1568 | QTest::keyClick(window: &window, key: Qt::Key_Enter); |
1569 | |
1570 | textEdit->setOverwriteMode(false); |
1571 | QCOMPARE(spy.count(), 4); |
1572 | |
1573 | insertString = "Second paragraph" ; |
1574 | |
1575 | for (int j = 0; j < insertString.length(); j++) |
1576 | QTest::keyClick(window: &window, key: insertString.at(i: j).toLatin1()); |
1577 | QCOMPARE(textEdit->lineCount(), 2); |
1578 | |
1579 | textEdit->setCursorPosition(15); |
1580 | |
1581 | QCOMPARE(textEdit->cursorPosition(), 15); |
1582 | |
1583 | textEdit->setOverwriteMode(true); |
1584 | QCOMPARE(spy.count(), 5); |
1585 | |
1586 | insertString = " blah" ; |
1587 | for (int j = 0; j < insertString.length(); j++) |
1588 | QTest::keyClick(window: &window, key: insertString.at(i: j).toLatin1()); |
1589 | QCOMPARE(textEdit->lineCount(), 2); |
1590 | |
1591 | QCOMPARE(textEdit->text(), QString("Some shiny text blah\nSecond paragraph" )); |
1592 | } |
1593 | |
1594 | void tst_qquicktextedit::isRightToLeft_data() |
1595 | { |
1596 | QTest::addColumn<QString>(name: "text" ); |
1597 | QTest::addColumn<bool>(name: "emptyString" ); |
1598 | QTest::addColumn<bool>(name: "firstCharacter" ); |
1599 | QTest::addColumn<bool>(name: "lastCharacter" ); |
1600 | QTest::addColumn<bool>(name: "middleCharacter" ); |
1601 | QTest::addColumn<bool>(name: "startString" ); |
1602 | QTest::addColumn<bool>(name: "midString" ); |
1603 | QTest::addColumn<bool>(name: "endString" ); |
1604 | |
1605 | const quint16 arabic_str[] = { 0x0638, 0x0643, 0x00646, 0x0647, 0x0633, 0x0638, 0x0643, 0x00646, 0x0647, 0x0633, 0x0647}; |
1606 | QTest::newRow(dataTag: "Empty" ) << "" << false << false << false << false << false << false << false; |
1607 | QTest::newRow(dataTag: "Neutral" ) << "23244242" << false << false << false << false << false << false << false; |
1608 | QTest::newRow(dataTag: "LTR" ) << "Hello world" << false << false << false << false << false << false << false; |
1609 | QTest::newRow(dataTag: "RTL" ) << QString::fromUtf16(arabic_str, size: 11) << false << true << true << true << true << true << true; |
1610 | QTest::newRow(dataTag: "Bidi RTL + LTR + RTL" ) << QString::fromUtf16(arabic_str, size: 11) + QString("Hello world" ) + QString::fromUtf16(arabic_str, size: 11) << false << true << true << false << true << true << true; |
1611 | QTest::newRow(dataTag: "Bidi LTR + RTL + LTR" ) << QString("Hello world" ) + QString::fromUtf16(arabic_str, size: 11) + QString("Hello world" ) << false << false << false << true << false << false << false; |
1612 | } |
1613 | |
1614 | void tst_qquicktextedit::isRightToLeft() |
1615 | { |
1616 | QFETCH(QString, text); |
1617 | QFETCH(bool, emptyString); |
1618 | QFETCH(bool, firstCharacter); |
1619 | QFETCH(bool, lastCharacter); |
1620 | QFETCH(bool, middleCharacter); |
1621 | QFETCH(bool, startString); |
1622 | QFETCH(bool, midString); |
1623 | QFETCH(bool, endString); |
1624 | |
1625 | QQuickTextEdit textEdit; |
1626 | textEdit.setText(text); |
1627 | |
1628 | // first test that the right string is delivered to the QString::isRightToLeft() |
1629 | QCOMPARE(textEdit.isRightToLeft(0,0), text.mid(0,0).isRightToLeft()); |
1630 | QCOMPARE(textEdit.isRightToLeft(0,1), text.mid(0,1).isRightToLeft()); |
1631 | QCOMPARE(textEdit.isRightToLeft(text.count()-2, text.count()-1), text.mid(text.count()-2, text.count()-1).isRightToLeft()); |
1632 | QCOMPARE(textEdit.isRightToLeft(text.count()/2, text.count()/2 + 1), text.mid(text.count()/2, text.count()/2 + 1).isRightToLeft()); |
1633 | QCOMPARE(textEdit.isRightToLeft(0,text.count()/4), text.mid(0,text.count()/4).isRightToLeft()); |
1634 | QCOMPARE(textEdit.isRightToLeft(text.count()/4,3*text.count()/4), text.mid(text.count()/4,3*text.count()/4).isRightToLeft()); |
1635 | if (text.isEmpty()) |
1636 | QTest::ignoreMessage(type: QtWarningMsg, message: "<Unknown File>: QML TextEdit: isRightToLeft(start, end) called with the end property being smaller than the start." ); |
1637 | QCOMPARE(textEdit.isRightToLeft(3*text.count()/4,text.count()-1), text.mid(3*text.count()/4,text.count()-1).isRightToLeft()); |
1638 | |
1639 | // then test that the feature actually works |
1640 | QCOMPARE(textEdit.isRightToLeft(0,0), emptyString); |
1641 | QCOMPARE(textEdit.isRightToLeft(0,1), firstCharacter); |
1642 | QCOMPARE(textEdit.isRightToLeft(text.count()-2, text.count()-1), lastCharacter); |
1643 | QCOMPARE(textEdit.isRightToLeft(text.count()/2, text.count()/2 + 1), middleCharacter); |
1644 | QCOMPARE(textEdit.isRightToLeft(0,text.count()/4), startString); |
1645 | QCOMPARE(textEdit.isRightToLeft(text.count()/4,3*text.count()/4), midString); |
1646 | if (text.isEmpty()) |
1647 | QTest::ignoreMessage(type: QtWarningMsg, message: "<Unknown File>: QML TextEdit: isRightToLeft(start, end) called with the end property being smaller than the start." ); |
1648 | QCOMPARE(textEdit.isRightToLeft(3*text.count()/4,text.count()-1), endString); |
1649 | } |
1650 | |
1651 | void tst_qquicktextedit::keySelection() |
1652 | { |
1653 | QQuickView window(testFileUrl(fileName: "navigation.qml" )); |
1654 | window.show(); |
1655 | window.requestActivate(); |
1656 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
1657 | |
1658 | QVERIFY(window.rootObject() != nullptr); |
1659 | |
1660 | QQuickTextEdit *input = qobject_cast<QQuickTextEdit *>(object: qvariant_cast<QObject *>(v: window.rootObject()->property(name: "myInput" ))); |
1661 | |
1662 | QVERIFY(input != nullptr); |
1663 | QVERIFY(input->hasActiveFocus()); |
1664 | |
1665 | QSignalSpy spy(input, SIGNAL(selectedTextChanged())); |
1666 | |
1667 | simulateKey(&window, key: Qt::Key_Right, modifiers: Qt::ShiftModifier); |
1668 | QVERIFY(input->hasActiveFocus()); |
1669 | QCOMPARE(input->selectedText(), QString("a" )); |
1670 | QCOMPARE(spy.count(), 1); |
1671 | simulateKey(&window, key: Qt::Key_Right); |
1672 | QVERIFY(input->hasActiveFocus()); |
1673 | QCOMPARE(input->selectedText(), QString()); |
1674 | QCOMPARE(spy.count(), 2); |
1675 | simulateKey(&window, key: Qt::Key_Right); |
1676 | QVERIFY(!input->hasActiveFocus()); |
1677 | QCOMPARE(input->selectedText(), QString()); |
1678 | QCOMPARE(spy.count(), 2); |
1679 | |
1680 | simulateKey(&window, key: Qt::Key_Left); |
1681 | QVERIFY(input->hasActiveFocus()); |
1682 | QCOMPARE(spy.count(), 2); |
1683 | simulateKey(&window, key: Qt::Key_Left, modifiers: Qt::ShiftModifier); |
1684 | QVERIFY(input->hasActiveFocus()); |
1685 | QCOMPARE(input->selectedText(), QString("a" )); |
1686 | QCOMPARE(spy.count(), 3); |
1687 | simulateKey(&window, key: Qt::Key_Left); |
1688 | QVERIFY(input->hasActiveFocus()); |
1689 | QCOMPARE(input->selectedText(), QString()); |
1690 | QCOMPARE(spy.count(), 4); |
1691 | simulateKey(&window, key: Qt::Key_Left); |
1692 | QVERIFY(!input->hasActiveFocus()); |
1693 | QCOMPARE(input->selectedText(), QString()); |
1694 | QCOMPARE(spy.count(), 4); |
1695 | } |
1696 | |
1697 | void tst_qquicktextedit::moveCursorSelection_data() |
1698 | { |
1699 | QTest::addColumn<QString>(name: "testStr" ); |
1700 | QTest::addColumn<int>(name: "cursorPosition" ); |
1701 | QTest::addColumn<int>(name: "movePosition" ); |
1702 | QTest::addColumn<QQuickTextEdit::SelectionMode>(name: "mode" ); |
1703 | QTest::addColumn<int>(name: "selectionStart" ); |
1704 | QTest::addColumn<int>(name: "selectionEnd" ); |
1705 | QTest::addColumn<bool>(name: "reversible" ); |
1706 | |
1707 | QTest::newRow(dataTag: "(t)he|characters" ) |
1708 | << standard[0] << 0 << 1 << QQuickTextEdit::SelectCharacters << 0 << 1 << true; |
1709 | QTest::newRow(dataTag: "do(g)|characters" ) |
1710 | << standard[0] << 43 << 44 << QQuickTextEdit::SelectCharacters << 43 << 44 << true; |
1711 | QTest::newRow(dataTag: "jum(p)ed|characters" ) |
1712 | << standard[0] << 23 << 24 << QQuickTextEdit::SelectCharacters << 23 << 24 << true; |
1713 | QTest::newRow(dataTag: "jumped( )over|characters" ) |
1714 | << standard[0] << 26 << 27 << QQuickTextEdit::SelectCharacters << 26 << 27 << true; |
1715 | QTest::newRow(dataTag: "(the )|characters" ) |
1716 | << standard[0] << 0 << 4 << QQuickTextEdit::SelectCharacters << 0 << 4 << true; |
1717 | QTest::newRow(dataTag: "( dog)|characters" ) |
1718 | << standard[0] << 40 << 44 << QQuickTextEdit::SelectCharacters << 40 << 44 << true; |
1719 | QTest::newRow(dataTag: "( jumped )|characters" ) |
1720 | << standard[0] << 19 << 27 << QQuickTextEdit::SelectCharacters << 19 << 27 << true; |
1721 | QTest::newRow(dataTag: "th(e qu)ick|characters" ) |
1722 | << standard[0] << 2 << 6 << QQuickTextEdit::SelectCharacters << 2 << 6 << true; |
1723 | QTest::newRow(dataTag: "la(zy d)og|characters" ) |
1724 | << standard[0] << 38 << 42 << QQuickTextEdit::SelectCharacters << 38 << 42 << true; |
1725 | QTest::newRow(dataTag: "jum(ped ov)er|characters" ) |
1726 | << standard[0] << 23 << 29 << QQuickTextEdit::SelectCharacters << 23 << 29 << true; |
1727 | QTest::newRow(dataTag: "()the|characters" ) |
1728 | << standard[0] << 0 << 0 << QQuickTextEdit::SelectCharacters << 0 << 0 << true; |
1729 | QTest::newRow(dataTag: "dog()|characters" ) |
1730 | << standard[0] << 44 << 44 << QQuickTextEdit::SelectCharacters << 44 << 44 << true; |
1731 | QTest::newRow(dataTag: "jum()ped|characters" ) |
1732 | << standard[0] << 23 << 23 << QQuickTextEdit::SelectCharacters << 23 << 23 << true; |
1733 | |
1734 | QTest::newRow(dataTag: "<(t)he>|words" ) |
1735 | << standard[0] << 0 << 1 << QQuickTextEdit::SelectWords << 0 << 3 << true; |
1736 | QTest::newRow(dataTag: "<do(g)>|words" ) |
1737 | << standard[0] << 43 << 44 << QQuickTextEdit::SelectWords << 41 << 44 << true; |
1738 | QTest::newRow(dataTag: "<jum(p)ed>|words" ) |
1739 | << standard[0] << 23 << 24 << QQuickTextEdit::SelectWords << 20 << 26 << true; |
1740 | QTest::newRow(dataTag: "<jumped( )>over|words" ) |
1741 | << standard[0] << 26 << 27 << QQuickTextEdit::SelectWords << 20 << 27 << false; |
1742 | QTest::newRow(dataTag: "jumped<( )over>|words,reversed" ) |
1743 | << standard[0] << 27 << 26 << QQuickTextEdit::SelectWords << 26 << 31 << false; |
1744 | QTest::newRow(dataTag: "<(the )>quick|words" ) |
1745 | << standard[0] << 0 << 4 << QQuickTextEdit::SelectWords << 0 << 4 << false; |
1746 | QTest::newRow(dataTag: "<(the )quick>|words,reversed" ) |
1747 | << standard[0] << 4 << 0 << QQuickTextEdit::SelectWords << 0 << 9 << false; |
1748 | QTest::newRow(dataTag: "<lazy( dog)>|words" ) |
1749 | << standard[0] << 40 << 44 << QQuickTextEdit::SelectWords << 36 << 44 << false; |
1750 | QTest::newRow(dataTag: "lazy<( dog)>|words,reversed" ) |
1751 | << standard[0] << 44 << 40 << QQuickTextEdit::SelectWords << 40 << 44 << false; |
1752 | QTest::newRow(dataTag: "<fox( jumped )>over|words" ) |
1753 | << standard[0] << 19 << 27 << QQuickTextEdit::SelectWords << 16 << 27 << false; |
1754 | QTest::newRow(dataTag: "fox<( jumped )over>|words,reversed" ) |
1755 | << standard[0] << 27 << 19 << QQuickTextEdit::SelectWords << 19 << 31 << false; |
1756 | QTest::newRow(dataTag: "<th(e qu)ick>|words" ) |
1757 | << standard[0] << 2 << 6 << QQuickTextEdit::SelectWords << 0 << 9 << true; |
1758 | QTest::newRow(dataTag: "<la(zy d)og|words>" ) |
1759 | << standard[0] << 38 << 42 << QQuickTextEdit::SelectWords << 36 << 44 << true; |
1760 | QTest::newRow(dataTag: "<jum(ped ov)er>|words" ) |
1761 | << standard[0] << 23 << 29 << QQuickTextEdit::SelectWords << 20 << 31 << true; |
1762 | QTest::newRow(dataTag: "<()>the|words" ) |
1763 | << standard[0] << 0 << 0 << QQuickTextEdit::SelectWords << 0 << 0 << true; |
1764 | QTest::newRow(dataTag: "dog<()>|words" ) |
1765 | << standard[0] << 44 << 44 << QQuickTextEdit::SelectWords << 44 << 44 << true; |
1766 | QTest::newRow(dataTag: "jum<()>ped|words" ) |
1767 | << standard[0] << 23 << 23 << QQuickTextEdit::SelectWords << 23 << 23 << true; |
1768 | |
1769 | QTest::newRow(dataTag: "Hello<(,)> |words" ) |
1770 | << standard[2] << 5 << 6 << QQuickTextEdit::SelectWords << 5 << 6 << true; |
1771 | QTest::newRow(dataTag: "Hello<(, )>world|words" ) |
1772 | << standard[2] << 5 << 7 << QQuickTextEdit::SelectWords << 5 << 7 << false; |
1773 | QTest::newRow(dataTag: "Hello<(, )world>|words,reversed" ) |
1774 | << standard[2] << 7 << 5 << QQuickTextEdit::SelectWords << 5 << 12 << false; |
1775 | QTest::newRow(dataTag: "<Hel(lo, )>world|words" ) |
1776 | << standard[2] << 3 << 7 << QQuickTextEdit::SelectWords << 0 << 7 << false; |
1777 | QTest::newRow(dataTag: "<Hel(lo, )world>|words,reversed" ) |
1778 | << standard[2] << 7 << 3 << QQuickTextEdit::SelectWords << 0 << 12 << false; |
1779 | QTest::newRow(dataTag: "<Hel(lo)>,|words" ) |
1780 | << standard[2] << 3 << 5 << QQuickTextEdit::SelectWords << 0 << 5 << true; |
1781 | QTest::newRow(dataTag: "Hello<()>,|words" ) |
1782 | << standard[2] << 5 << 5 << QQuickTextEdit::SelectWords << 5 << 5 << true; |
1783 | QTest::newRow(dataTag: "Hello,<()>|words" ) |
1784 | << standard[2] << 6 << 6 << QQuickTextEdit::SelectWords << 6 << 6 << true; |
1785 | QTest::newRow(dataTag: "Hello<,( )>world|words" ) |
1786 | << standard[2] << 6 << 7 << QQuickTextEdit::SelectWords << 5 << 7 << false; |
1787 | QTest::newRow(dataTag: "Hello,<( )world>|words,reversed" ) |
1788 | << standard[2] << 7 << 6 << QQuickTextEdit::SelectWords << 6 << 12 << false; |
1789 | QTest::newRow(dataTag: "Hello<,( world)>|words" ) |
1790 | << standard[2] << 6 << 12 << QQuickTextEdit::SelectWords << 5 << 12 << false; |
1791 | QTest::newRow(dataTag: "Hello,<( world)>|words,reversed" ) |
1792 | << standard[2] << 12 << 6 << QQuickTextEdit::SelectWords << 6 << 12 << false; |
1793 | QTest::newRow(dataTag: "Hello<,( world!)>|words" ) |
1794 | << standard[2] << 6 << 13 << QQuickTextEdit::SelectWords << 5 << 13 << false; |
1795 | QTest::newRow(dataTag: "Hello,<( world!)>|words,reversed" ) |
1796 | << standard[2] << 13 << 6 << QQuickTextEdit::SelectWords << 6 << 13 << false; |
1797 | QTest::newRow(dataTag: "Hello<(, world!)>|words" ) |
1798 | << standard[2] << 5 << 13 << QQuickTextEdit::SelectWords << 5 << 13 << true; |
1799 | QTest::newRow(dataTag: "world<(!)>|words" ) |
1800 | << standard[2] << 12 << 13 << QQuickTextEdit::SelectWords << 12 << 13 << true; |
1801 | QTest::newRow(dataTag: "world!<()>)|words" ) |
1802 | << standard[2] << 13 << 13 << QQuickTextEdit::SelectWords << 13 << 13 << true; |
1803 | QTest::newRow(dataTag: "world<()>!)|words" ) |
1804 | << standard[2] << 12 << 12 << QQuickTextEdit::SelectWords << 12 << 12 << true; |
1805 | |
1806 | QTest::newRow(dataTag: "<(,)>olleH |words" ) |
1807 | << standard[3] << 7 << 8 << QQuickTextEdit::SelectWords << 7 << 8 << true; |
1808 | QTest::newRow(dataTag: "<dlrow( ,)>olleH|words" ) |
1809 | << standard[3] << 6 << 8 << QQuickTextEdit::SelectWords << 1 << 8 << false; |
1810 | QTest::newRow(dataTag: "dlrow<( ,)>olleH|words,reversed" ) |
1811 | << standard[3] << 8 << 6 << QQuickTextEdit::SelectWords << 6 << 8 << false; |
1812 | QTest::newRow(dataTag: "<dlrow( ,ol)leH>|words" ) |
1813 | << standard[3] << 6 << 10 << QQuickTextEdit::SelectWords << 1 << 13 << false; |
1814 | QTest::newRow(dataTag: "dlrow<( ,ol)leH>|words,reversed" ) |
1815 | << standard[3] << 10 << 6 << QQuickTextEdit::SelectWords << 6 << 13 << false; |
1816 | QTest::newRow(dataTag: ",<(ol)leH>,|words" ) |
1817 | << standard[3] << 8 << 10 << QQuickTextEdit::SelectWords << 8 << 13 << true; |
1818 | QTest::newRow(dataTag: ",<()>olleH|words" ) |
1819 | << standard[3] << 8 << 8 << QQuickTextEdit::SelectWords << 8 << 8 << true; |
1820 | QTest::newRow(dataTag: "<()>,olleH|words" ) |
1821 | << standard[3] << 7 << 7 << QQuickTextEdit::SelectWords << 7 << 7 << true; |
1822 | QTest::newRow(dataTag: "<dlrow( )>,olleH|words" ) |
1823 | << standard[3] << 6 << 7 << QQuickTextEdit::SelectWords << 1 << 7 << false; |
1824 | QTest::newRow(dataTag: "dlrow<( ),>olleH|words,reversed" ) |
1825 | << standard[3] << 7 << 6 << QQuickTextEdit::SelectWords << 6 << 8 << false; |
1826 | QTest::newRow(dataTag: "<(dlrow )>,olleH|words" ) |
1827 | << standard[3] << 1 << 7 << QQuickTextEdit::SelectWords << 1 << 7 << false; |
1828 | QTest::newRow(dataTag: "<(dlrow ),>olleH|words,reversed" ) |
1829 | << standard[3] << 7 << 1 << QQuickTextEdit::SelectWords << 1 << 8 << false; |
1830 | QTest::newRow(dataTag: "<(!dlrow )>,olleH|words" ) |
1831 | << standard[3] << 0 << 7 << QQuickTextEdit::SelectWords << 0 << 7 << false; |
1832 | QTest::newRow(dataTag: "<(!dlrow ),>olleH|words,reversed" ) |
1833 | << standard[3] << 7 << 0 << QQuickTextEdit::SelectWords << 0 << 8 << false; |
1834 | QTest::newRow(dataTag: "(!dlrow ,)olleH|words" ) |
1835 | << standard[3] << 0 << 8 << QQuickTextEdit::SelectWords << 0 << 8 << true; |
1836 | QTest::newRow(dataTag: "<(!)>dlrow|words" ) |
1837 | << standard[3] << 0 << 1 << QQuickTextEdit::SelectWords << 0 << 1 << true; |
1838 | QTest::newRow(dataTag: "<()>!dlrow|words" ) |
1839 | << standard[3] << 0 << 0 << QQuickTextEdit::SelectWords << 0 << 0 << true; |
1840 | QTest::newRow(dataTag: "!<()>dlrow|words" ) |
1841 | << standard[3] << 1 << 1 << QQuickTextEdit::SelectWords << 1 << 1 << true; |
1842 | } |
1843 | |
1844 | void tst_qquicktextedit::moveCursorSelection() |
1845 | { |
1846 | QFETCH(QString, testStr); |
1847 | QFETCH(int, cursorPosition); |
1848 | QFETCH(int, movePosition); |
1849 | QFETCH(QQuickTextEdit::SelectionMode, mode); |
1850 | QFETCH(int, selectionStart); |
1851 | QFETCH(int, selectionEnd); |
1852 | QFETCH(bool, reversible); |
1853 | |
1854 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + testStr +"\"; }" ; |
1855 | QQmlComponent textinputComponent(&engine); |
1856 | textinputComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
1857 | QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit*>(object: textinputComponent.create()); |
1858 | QVERIFY(texteditObject != nullptr); |
1859 | |
1860 | texteditObject->setCursorPosition(cursorPosition); |
1861 | texteditObject->moveCursorSelection(pos: movePosition, mode); |
1862 | |
1863 | QCOMPARE(texteditObject->selectedText(), testStr.mid(selectionStart, selectionEnd - selectionStart)); |
1864 | QCOMPARE(texteditObject->selectionStart(), selectionStart); |
1865 | QCOMPARE(texteditObject->selectionEnd(), selectionEnd); |
1866 | |
1867 | if (reversible) { |
1868 | texteditObject->setCursorPosition(movePosition); |
1869 | texteditObject->moveCursorSelection(pos: cursorPosition, mode); |
1870 | |
1871 | QCOMPARE(texteditObject->selectedText(), testStr.mid(selectionStart, selectionEnd - selectionStart)); |
1872 | QCOMPARE(texteditObject->selectionStart(), selectionStart); |
1873 | QCOMPARE(texteditObject->selectionEnd(), selectionEnd); |
1874 | } |
1875 | } |
1876 | |
1877 | void tst_qquicktextedit::moveCursorSelectionSequence_data() |
1878 | { |
1879 | QTest::addColumn<QString>(name: "testStr" ); |
1880 | QTest::addColumn<int>(name: "cursorPosition" ); |
1881 | QTest::addColumn<int>(name: "movePosition1" ); |
1882 | QTest::addColumn<int>(name: "movePosition2" ); |
1883 | QTest::addColumn<int>(name: "selection1Start" ); |
1884 | QTest::addColumn<int>(name: "selection1End" ); |
1885 | QTest::addColumn<int>(name: "selection2Start" ); |
1886 | QTest::addColumn<int>(name: "selection2End" ); |
1887 | |
1888 | QTest::newRow(dataTag: "the {<quick( bro)wn> f^ox} jumped|ltr" ) |
1889 | << standard[0] |
1890 | << 9 << 13 << 17 |
1891 | << 4 << 15 |
1892 | << 4 << 19; |
1893 | QTest::newRow(dataTag: "the quick<( {bro)wn> f^ox} jumped|rtl" ) |
1894 | << standard[0] |
1895 | << 13 << 9 << 17 |
1896 | << 9 << 15 |
1897 | << 10 << 19; |
1898 | QTest::newRow(dataTag: "the {<quick( bro)wn> ^}fox jumped|ltr" ) |
1899 | << standard[0] |
1900 | << 9 << 13 << 16 |
1901 | << 4 << 15 |
1902 | << 4 << 16; |
1903 | QTest::newRow(dataTag: "the quick<( {bro)wn> ^}fox jumped|rtl" ) |
1904 | << standard[0] |
1905 | << 13 << 9 << 16 |
1906 | << 9 << 15 |
1907 | << 10 << 16; |
1908 | QTest::newRow(dataTag: "the {<quick( bro)wn^>} fox jumped|ltr" ) |
1909 | << standard[0] |
1910 | << 9 << 13 << 15 |
1911 | << 4 << 15 |
1912 | << 4 << 15; |
1913 | QTest::newRow(dataTag: "the quick<( {bro)wn^>} f^ox jumped|rtl" ) |
1914 | << standard[0] |
1915 | << 13 << 9 << 15 |
1916 | << 9 << 15 |
1917 | << 10 << 15; |
1918 | QTest::newRow(dataTag: "the {<quick() ^}bro)wn> fox|ltr" ) |
1919 | << standard[0] |
1920 | << 9 << 13 << 10 |
1921 | << 4 << 15 |
1922 | << 4 << 10; |
1923 | QTest::newRow(dataTag: "the quick<(^ {^bro)wn>} fox|rtl" ) |
1924 | << standard[0] |
1925 | << 13 << 9 << 10 |
1926 | << 9 << 15 |
1927 | << 10 << 15; |
1928 | QTest::newRow(dataTag: "the {<quick^}( bro)wn> fox|ltr" ) |
1929 | << standard[0] |
1930 | << 9 << 13 << 9 |
1931 | << 4 << 15 |
1932 | << 4 << 9; |
1933 | QTest::newRow(dataTag: "the quick{<(^ bro)wn>} fox|rtl" ) |
1934 | << standard[0] |
1935 | << 13 << 9 << 9 |
1936 | << 9 << 15 |
1937 | << 9 << 15; |
1938 | QTest::newRow(dataTag: "the {<qui^ck}( bro)wn> fox|ltr" ) |
1939 | << standard[0] |
1940 | << 9 << 13 << 7 |
1941 | << 4 << 15 |
1942 | << 4 << 9; |
1943 | QTest::newRow(dataTag: "the {<qui^ck}( bro)wn> fox|rtl" ) |
1944 | << standard[0] |
1945 | << 13 << 9 << 7 |
1946 | << 9 << 15 |
1947 | << 4 << 15; |
1948 | QTest::newRow(dataTag: "the {<^quick}( bro)wn> fox|ltr" ) |
1949 | << standard[0] |
1950 | << 9 << 13 << 4 |
1951 | << 4 << 15 |
1952 | << 4 << 9; |
1953 | QTest::newRow(dataTag: "the {<^quick}( bro)wn> fox|rtl" ) |
1954 | << standard[0] |
1955 | << 13 << 9 << 4 |
1956 | << 9 << 15 |
1957 | << 4 << 15; |
1958 | QTest::newRow(dataTag: "the{^ <quick}( bro)wn> fox|ltr" ) |
1959 | << standard[0] |
1960 | << 9 << 13 << 3 |
1961 | << 4 << 15 |
1962 | << 3 << 9; |
1963 | QTest::newRow(dataTag: "the{^ <quick}( bro)wn> fox|rtl" ) |
1964 | << standard[0] |
1965 | << 13 << 9 << 3 |
1966 | << 9 << 15 |
1967 | << 3 << 15; |
1968 | QTest::newRow(dataTag: "{t^he <quick}( bro)wn> fox|ltr" ) |
1969 | << standard[0] |
1970 | << 9 << 13 << 1 |
1971 | << 4 << 15 |
1972 | << 0 << 9; |
1973 | QTest::newRow(dataTag: "{t^he <quick}( bro)wn> fox|rtl" ) |
1974 | << standard[0] |
1975 | << 13 << 9 << 1 |
1976 | << 9 << 15 |
1977 | << 0 << 15; |
1978 | |
1979 | QTest::newRow(dataTag: "{<He(ll)o>, w^orld}!|ltr" ) |
1980 | << standard[2] |
1981 | << 2 << 4 << 8 |
1982 | << 0 << 5 |
1983 | << 0 << 12; |
1984 | QTest::newRow(dataTag: "{<He(ll)o>, w^orld}!|rtl" ) |
1985 | << standard[2] |
1986 | << 4 << 2 << 8 |
1987 | << 0 << 5 |
1988 | << 0 << 12; |
1989 | |
1990 | QTest::newRow(dataTag: "!{dlro^w ,<o(ll)eH>}|ltr" ) |
1991 | << standard[3] |
1992 | << 9 << 11 << 5 |
1993 | << 8 << 13 |
1994 | << 1 << 13; |
1995 | QTest::newRow(dataTag: "!{dlro^w ,<o(ll)eH>}|rtl" ) |
1996 | << standard[3] |
1997 | << 11 << 9 << 5 |
1998 | << 8 << 13 |
1999 | << 1 << 13; |
2000 | } |
2001 | |
2002 | void tst_qquicktextedit::moveCursorSelectionSequence() |
2003 | { |
2004 | QFETCH(QString, testStr); |
2005 | QFETCH(int, cursorPosition); |
2006 | QFETCH(int, movePosition1); |
2007 | QFETCH(int, movePosition2); |
2008 | QFETCH(int, selection1Start); |
2009 | QFETCH(int, selection1End); |
2010 | QFETCH(int, selection2Start); |
2011 | QFETCH(int, selection2End); |
2012 | |
2013 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + testStr +"\"; }" ; |
2014 | QQmlComponent texteditComponent(&engine); |
2015 | texteditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
2016 | QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit*>(object: texteditComponent.create()); |
2017 | QVERIFY(texteditObject != nullptr); |
2018 | |
2019 | texteditObject->setCursorPosition(cursorPosition); |
2020 | |
2021 | texteditObject->moveCursorSelection(pos: movePosition1, mode: QQuickTextEdit::SelectWords); |
2022 | QCOMPARE(texteditObject->selectedText(), testStr.mid(selection1Start, selection1End - selection1Start)); |
2023 | QCOMPARE(texteditObject->selectionStart(), selection1Start); |
2024 | QCOMPARE(texteditObject->selectionEnd(), selection1End); |
2025 | |
2026 | texteditObject->moveCursorSelection(pos: movePosition2, mode: QQuickTextEdit::SelectWords); |
2027 | QCOMPARE(texteditObject->selectedText(), testStr.mid(selection2Start, selection2End - selection2Start)); |
2028 | QCOMPARE(texteditObject->selectionStart(), selection2Start); |
2029 | QCOMPARE(texteditObject->selectionEnd(), selection2End); |
2030 | } |
2031 | |
2032 | |
2033 | void tst_qquicktextedit::mouseSelection_data() |
2034 | { |
2035 | QTest::addColumn<QString>(name: "qmlfile" ); |
2036 | QTest::addColumn<int>(name: "from" ); |
2037 | QTest::addColumn<int>(name: "to" ); |
2038 | QTest::addColumn<QString>(name: "selectedText" ); |
2039 | QTest::addColumn<bool>(name: "focus" ); |
2040 | QTest::addColumn<bool>(name: "focusOnPress" ); |
2041 | QTest::addColumn<int>(name: "clicks" ); |
2042 | |
2043 | // import installed |
2044 | QTest::newRow(dataTag: "on" ) << testFile(fileName: "mouseselection_true.qml" ) << 4 << 9 << "45678" << true << true << 1; |
2045 | QTest::newRow(dataTag: "off" ) << testFile(fileName: "mouseselection_false.qml" ) << 4 << 9 << QString() << true << true << 1; |
2046 | QTest::newRow(dataTag: "default" ) << testFile(fileName: "mouseselection_default.qml" ) << 4 << 9 << QString() << true << true << 1; |
2047 | QTest::newRow(dataTag: "off word selection" ) << testFile(fileName: "mouseselection_false_words.qml" ) << 4 << 9 << QString() << true << true << 1; |
2048 | QTest::newRow(dataTag: "on word selection (4,9)" ) << testFile(fileName: "mouseselection_true_words.qml" ) << 4 << 9 << "0123456789" << true << true << 1; |
2049 | |
2050 | QTest::newRow(dataTag: "on unfocused" ) << testFile(fileName: "mouseselection_true.qml" ) << 4 << 9 << "45678" << false << false << 1; |
2051 | QTest::newRow(dataTag: "on word selection (4,9) unfocused" ) << testFile(fileName: "mouseselection_true_words.qml" ) << 4 << 9 << "0123456789" << false << false << 1; |
2052 | |
2053 | QTest::newRow(dataTag: "on focus on press" ) << testFile(fileName: "mouseselection_true.qml" ) << 4 << 9 << "45678" << false << true << 1; |
2054 | QTest::newRow(dataTag: "on word selection (4,9) focus on press" ) << testFile(fileName: "mouseselection_true_words.qml" ) << 4 << 9 << "0123456789" << false << true << 1; |
2055 | |
2056 | QTest::newRow(dataTag: "on word selection (2,13)" ) << testFile(fileName: "mouseselection_true_words.qml" ) << 2 << 13 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 1; |
2057 | QTest::newRow(dataTag: "on word selection (2,30)" ) << testFile(fileName: "mouseselection_true_words.qml" ) << 2 << 30 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 1; |
2058 | QTest::newRow(dataTag: "on word selection (9,13)" ) << testFile(fileName: "mouseselection_true_words.qml" ) << 9 << 13 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 1; |
2059 | QTest::newRow(dataTag: "on word selection (9,30)" ) << testFile(fileName: "mouseselection_true_words.qml" ) << 9 << 30 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 1; |
2060 | QTest::newRow(dataTag: "on word selection (13,2)" ) << testFile(fileName: "mouseselection_true_words.qml" ) << 13 << 2 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 1; |
2061 | QTest::newRow(dataTag: "on word selection (20,2)" ) << testFile(fileName: "mouseselection_true_words.qml" ) << 20 << 2 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 1; |
2062 | QTest::newRow(dataTag: "on word selection (12,9)" ) << testFile(fileName: "mouseselection_true_words.qml" ) << 12 << 9 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 1; |
2063 | QTest::newRow(dataTag: "on word selection (30,9)" ) << testFile(fileName: "mouseselection_true_words.qml" ) << 30 << 9 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 1; |
2064 | |
2065 | QTest::newRow(dataTag: "on double click (4,9)" ) << testFile(fileName: "mouseselection_true.qml" ) << 4 << 9 << "0123456789" << true << true << 2; |
2066 | QTest::newRow(dataTag: "on double click (2,13)" ) << testFile(fileName: "mouseselection_true.qml" ) << 2 << 13 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 2; |
2067 | QTest::newRow(dataTag: "on double click (2,30)" ) << testFile(fileName: "mouseselection_true.qml" ) << 2 << 30 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 2; |
2068 | QTest::newRow(dataTag: "on double click (9,13)" ) << testFile(fileName: "mouseselection_true.qml" ) << 9 << 13 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 2; |
2069 | QTest::newRow(dataTag: "on double click (9,30)" ) << testFile(fileName: "mouseselection_true.qml" ) << 9 << 30 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 2; |
2070 | QTest::newRow(dataTag: "on double click (13,2)" ) << testFile(fileName: "mouseselection_true.qml" ) << 13 << 2 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 2; |
2071 | QTest::newRow(dataTag: "on double click (20,2)" ) << testFile(fileName: "mouseselection_true.qml" ) << 20 << 2 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 2; |
2072 | QTest::newRow(dataTag: "on double click (12,9)" ) << testFile(fileName: "mouseselection_true.qml" ) << 12 << 9 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 2; |
2073 | QTest::newRow(dataTag: "on double click (30,9)" ) << testFile(fileName: "mouseselection_true.qml" ) << 30 << 9 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ" << true << true << 2; |
2074 | |
2075 | QTest::newRow(dataTag: "on triple click (4,9)" ) << testFile(fileName: "mouseselection_true.qml" ) << 4 << 9 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n" << true << true << 3; |
2076 | QTest::newRow(dataTag: "on triple click (2,13)" ) << testFile(fileName: "mouseselection_true.qml" ) << 2 << 13 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n" << true << true << 3; |
2077 | QTest::newRow(dataTag: "on triple click (2,30)" ) << testFile(fileName: "mouseselection_true.qml" ) << 2 << 30 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n" << true << true << 3; |
2078 | QTest::newRow(dataTag: "on triple click (9,13)" ) << testFile(fileName: "mouseselection_true.qml" ) << 9 << 13 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n" << true << true << 3; |
2079 | QTest::newRow(dataTag: "on triple click (9,30)" ) << testFile(fileName: "mouseselection_true.qml" ) << 9 << 30 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n" << true << true << 3; |
2080 | QTest::newRow(dataTag: "on triple click (13,2)" ) << testFile(fileName: "mouseselection_true.qml" ) << 13 << 2 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n" << true << true << 3; |
2081 | QTest::newRow(dataTag: "on triple click (20,2)" ) << testFile(fileName: "mouseselection_true.qml" ) << 20 << 2 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n" << true << true << 3; |
2082 | QTest::newRow(dataTag: "on triple click (12,9)" ) << testFile(fileName: "mouseselection_true.qml" ) << 12 << 9 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n" << true << true << 3; |
2083 | QTest::newRow(dataTag: "on triple click (30,9)" ) << testFile(fileName: "mouseselection_true.qml" ) << 30 << 9 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n" << true << true << 3; |
2084 | |
2085 | QTest::newRow(dataTag: "on triple click (2,40)" ) << testFile(fileName: "mouseselection_true.qml" ) << 2 << 40 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n9876543210\n" << true << true << 3; |
2086 | QTest::newRow(dataTag: "on triple click (2,50)" ) << testFile(fileName: "mouseselection_true.qml" ) << 2 << 50 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n9876543210\n\nZXYWVUTSRQPON MLKJIHGFEDCBA" << true << true << 3; |
2087 | QTest::newRow(dataTag: "on triple click (25,40)" ) << testFile(fileName: "mouseselection_true.qml" ) << 25 << 40 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n9876543210\n" << true << true << 3; |
2088 | QTest::newRow(dataTag: "on triple click (25,50)" ) << testFile(fileName: "mouseselection_true.qml" ) << 25 << 50 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n9876543210\n\nZXYWVUTSRQPON MLKJIHGFEDCBA" << true << true << 3; |
2089 | QTest::newRow(dataTag: "on triple click (40,25)" ) << testFile(fileName: "mouseselection_true.qml" ) << 40 << 25 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n9876543210\n" << true << true << 3; |
2090 | QTest::newRow(dataTag: "on triple click (40,50)" ) << testFile(fileName: "mouseselection_true.qml" ) << 40 << 50 << "9876543210\n\nZXYWVUTSRQPON MLKJIHGFEDCBA" << true << true << 3; |
2091 | QTest::newRow(dataTag: "on triple click (50,25)" ) << testFile(fileName: "mouseselection_true.qml" ) << 50 << 25 << "0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ\n9876543210\n\nZXYWVUTSRQPON MLKJIHGFEDCBA" << true << true << 3; |
2092 | QTest::newRow(dataTag: "on triple click (50,40)" ) << testFile(fileName: "mouseselection_true.qml" ) << 50 << 40 << "9876543210\n\nZXYWVUTSRQPON MLKJIHGFEDCBA" << true << true << 3; |
2093 | |
2094 | QTest::newRow(dataTag: "on tr align" ) << testFile(fileName: "mouseselection_align_tr.qml" ) << 4 << 9 << "45678" << true << true << 1; |
2095 | QTest::newRow(dataTag: "on center align" ) << testFile(fileName: "mouseselection_align_center.qml" ) << 4 << 9 << "45678" << true << true << 1; |
2096 | QTest::newRow(dataTag: "on bl align" ) << testFile(fileName: "mouseselection_align_bl.qml" ) << 4 << 9 << "45678" << true << true << 1; |
2097 | } |
2098 | |
2099 | void tst_qquicktextedit::mouseSelection() |
2100 | { |
2101 | QFETCH(QString, qmlfile); |
2102 | QFETCH(int, from); |
2103 | QFETCH(int, to); |
2104 | QFETCH(QString, selectedText); |
2105 | QFETCH(bool, focus); |
2106 | QFETCH(bool, focusOnPress); |
2107 | QFETCH(int, clicks); |
2108 | |
2109 | QQuickView window(QUrl::fromLocalFile(localfile: qmlfile)); |
2110 | |
2111 | window.show(); |
2112 | window.requestActivate(); |
2113 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
2114 | |
2115 | QVERIFY(window.rootObject() != nullptr); |
2116 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(object: window.rootObject()); |
2117 | QVERIFY(textEditObject != nullptr); |
2118 | |
2119 | textEditObject->setFocus(focus); |
2120 | textEditObject->setFocusOnPress(focusOnPress); |
2121 | |
2122 | // Avoid that the last click from the previous test data and the first click in the |
2123 | // current test data happens so close in time that they are interpreted as a double click. |
2124 | static const int moreThanDoubleClickInterval = QGuiApplication::styleHints()->mouseDoubleClickInterval() + 1; |
2125 | |
2126 | // press-and-drag-and-release from x1 to x2 |
2127 | QPoint p1 = textEditObject->positionToRectangle(from).center().toPoint(); |
2128 | QPoint p2 = textEditObject->positionToRectangle(to).center().toPoint(); |
2129 | if (clicks == 2) |
2130 | QTest::mouseClick(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: p1, delay: moreThanDoubleClickInterval); |
2131 | else if (clicks == 3) |
2132 | QTest::mouseDClick(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: p1, delay: moreThanDoubleClickInterval); |
2133 | // cancel the 500ms delta QTestLib adds in order to properly synthesize a triple click within the required interval |
2134 | QTest::lastMouseTimestamp -= QTest::mouseDoubleClickInterval; |
2135 | QTest::mousePress(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: p1); |
2136 | QTest::mouseMove(window: &window, pos: p2); |
2137 | QTest::mouseRelease(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: p2); |
2138 | QTRY_COMPARE(textEditObject->selectedText(), selectedText); |
2139 | |
2140 | // Clicking and shift to clicking between the same points should select the same text. |
2141 | textEditObject->setCursorPosition(0); |
2142 | if (clicks > 1) { |
2143 | QTest::mouseDClick(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: p1); |
2144 | // cancel the 500ms delta QTestLib adds in order to properly synthesize a triple click within the required interval |
2145 | QTest::lastMouseTimestamp -= QTest::mouseDoubleClickInterval; |
2146 | } |
2147 | if (clicks != 2) |
2148 | QTest::mouseClick(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: p1); |
2149 | QTest::mouseClick(window: &window, button: Qt::LeftButton, stateKey: Qt::ShiftModifier, pos: p2); |
2150 | QTRY_COMPARE(textEditObject->selectedText(), selectedText); |
2151 | } |
2152 | |
2153 | void tst_qquicktextedit::dragMouseSelection() |
2154 | { |
2155 | QString qmlfile = testFile(fileName: "mouseselection_true.qml" ); |
2156 | |
2157 | QQuickView window(QUrl::fromLocalFile(localfile: qmlfile)); |
2158 | |
2159 | window.show(); |
2160 | window.requestActivate(); |
2161 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
2162 | |
2163 | QVERIFY(window.rootObject() != nullptr); |
2164 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(object: window.rootObject()); |
2165 | QVERIFY(textEditObject != nullptr); |
2166 | |
2167 | // press-and-drag-and-release from x1 to x2 |
2168 | int x1 = 10; |
2169 | int x2 = 70; |
2170 | int y = QFontMetrics(textEditObject->font()).height() / 2; |
2171 | QTest::mousePress(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: QPoint(x1,y)); |
2172 | QTest::mouseMove(window: &window, pos: QPoint(x2, y)); |
2173 | QTest::mouseRelease(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: QPoint(x2,y)); |
2174 | QTest::qWait(ms: 300); |
2175 | QString str1; |
2176 | QTRY_VERIFY((str1 = textEditObject->selectedText()).length() > 3); |
2177 | |
2178 | // press and drag the current selection. |
2179 | x1 = 40; |
2180 | x2 = 100; |
2181 | QTest::mousePress(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: QPoint(x1,y)); |
2182 | QTest::mouseMove(window: &window, pos: QPoint(x2, y)); |
2183 | QTest::mouseRelease(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: QPoint(x2,y)); |
2184 | QTest::qWait(ms: 300); |
2185 | QString str2; |
2186 | QTRY_VERIFY((str2 = textEditObject->selectedText()).length() > 3); |
2187 | |
2188 | QVERIFY(str1 != str2); // Verify the second press and drag is a new selection and not the first moved. |
2189 | |
2190 | } |
2191 | |
2192 | void tst_qquicktextedit::mouseSelectionMode_data() |
2193 | { |
2194 | QTest::addColumn<QString>(name: "qmlfile" ); |
2195 | QTest::addColumn<bool>(name: "selectWords" ); |
2196 | |
2197 | // import installed |
2198 | QTest::newRow(dataTag: "SelectWords" ) << testFile(fileName: "mouseselectionmode_words.qml" ) << true; |
2199 | QTest::newRow(dataTag: "SelectCharacters" ) << testFile(fileName: "mouseselectionmode_characters.qml" ) << false; |
2200 | QTest::newRow(dataTag: "default" ) << testFile(fileName: "mouseselectionmode_default.qml" ) << false; |
2201 | } |
2202 | |
2203 | void tst_qquicktextedit::mouseSelectionMode() |
2204 | { |
2205 | QFETCH(QString, qmlfile); |
2206 | QFETCH(bool, selectWords); |
2207 | |
2208 | QString text = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" ; |
2209 | |
2210 | QQuickView window(QUrl::fromLocalFile(localfile: qmlfile)); |
2211 | |
2212 | window.show(); |
2213 | window.requestActivate(); |
2214 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
2215 | |
2216 | QVERIFY(window.rootObject() != nullptr); |
2217 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(object: window.rootObject()); |
2218 | QVERIFY(textEditObject != nullptr); |
2219 | |
2220 | // press-and-drag-and-release from x1 to x2 |
2221 | int x1 = 10; |
2222 | int x2 = 70; |
2223 | int y = textEditObject->height()/2; |
2224 | QTest::mousePress(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: QPoint(x1,y)); |
2225 | QTest::mouseMove(window: &window, pos: QPoint(x2, y)); |
2226 | QTest::mouseRelease(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: QPoint(x2,y)); |
2227 | QString str = textEditObject->selectedText(); |
2228 | if (selectWords) { |
2229 | QTRY_COMPARE(textEditObject->selectedText(), text); |
2230 | } else { |
2231 | QTRY_VERIFY(textEditObject->selectedText().length() > 3); |
2232 | QVERIFY(str != text); |
2233 | } |
2234 | } |
2235 | |
2236 | void tst_qquicktextedit::mouseSelectionMode_accessors() |
2237 | { |
2238 | QQmlComponent component(&engine); |
2239 | component.setData("import QtQuick 2.0\n TextEdit {}" , baseUrl: QUrl()); |
2240 | QScopedPointer<QObject> object(component.create()); |
2241 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: object.data()); |
2242 | QVERIFY(edit); |
2243 | |
2244 | QSignalSpy spy(edit, &QQuickTextEdit::mouseSelectionModeChanged); |
2245 | |
2246 | QCOMPARE(edit->mouseSelectionMode(), QQuickTextEdit::SelectCharacters); |
2247 | |
2248 | edit->setMouseSelectionMode(QQuickTextEdit::SelectWords); |
2249 | QCOMPARE(edit->mouseSelectionMode(), QQuickTextEdit::SelectWords); |
2250 | QCOMPARE(spy.count(), 1); |
2251 | |
2252 | edit->setMouseSelectionMode(QQuickTextEdit::SelectWords); |
2253 | QCOMPARE(spy.count(), 1); |
2254 | |
2255 | edit->setMouseSelectionMode(QQuickTextEdit::SelectCharacters); |
2256 | QCOMPARE(edit->mouseSelectionMode(), QQuickTextEdit::SelectCharacters); |
2257 | QCOMPARE(spy.count(), 2); |
2258 | } |
2259 | |
2260 | void tst_qquicktextedit::selectByMouse() |
2261 | { |
2262 | QQmlComponent component(&engine); |
2263 | component.setData("import QtQuick 2.0\n TextEdit {}" , baseUrl: QUrl()); |
2264 | QScopedPointer<QObject> object(component.create()); |
2265 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: object.data()); |
2266 | QVERIFY(edit); |
2267 | |
2268 | QSignalSpy spy(edit, SIGNAL(selectByMouseChanged(bool))); |
2269 | |
2270 | QCOMPARE(edit->selectByMouse(), false); |
2271 | |
2272 | edit->setSelectByMouse(true); |
2273 | QCOMPARE(edit->selectByMouse(), true); |
2274 | QCOMPARE(spy.count(), 1); |
2275 | QCOMPARE(spy.at(0).at(0).toBool(), true); |
2276 | |
2277 | edit->setSelectByMouse(true); |
2278 | QCOMPARE(spy.count(), 1); |
2279 | |
2280 | edit->setSelectByMouse(false); |
2281 | QCOMPARE(edit->selectByMouse(), false); |
2282 | QCOMPARE(spy.count(), 2); |
2283 | QCOMPARE(spy.at(1).at(0).toBool(), false); |
2284 | } |
2285 | |
2286 | void tst_qquicktextedit::selectByKeyboard() |
2287 | { |
2288 | QQmlComponent oldComponent(&engine); |
2289 | oldComponent.setData("import QtQuick 2.0\n TextEdit { selectByKeyboard: true }" , baseUrl: QUrl()); |
2290 | QVERIFY(!oldComponent.create()); |
2291 | |
2292 | QQmlComponent component(&engine); |
2293 | component.setData("import QtQuick 2.1\n TextEdit { }" , baseUrl: QUrl()); |
2294 | QScopedPointer<QObject> object(component.create()); |
2295 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: object.data()); |
2296 | QVERIFY(edit); |
2297 | |
2298 | QSignalSpy spy(edit, SIGNAL(selectByKeyboardChanged(bool))); |
2299 | |
2300 | QCOMPARE(edit->isReadOnly(), false); |
2301 | QCOMPARE(edit->selectByKeyboard(), true); |
2302 | |
2303 | edit->setReadOnly(true); |
2304 | QCOMPARE(edit->selectByKeyboard(), false); |
2305 | QCOMPARE(spy.count(), 1); |
2306 | QCOMPARE(spy.at(0).at(0).toBool(), false); |
2307 | |
2308 | edit->setSelectByKeyboard(true); |
2309 | QCOMPARE(edit->selectByKeyboard(), true); |
2310 | QCOMPARE(spy.count(), 2); |
2311 | QCOMPARE(spy.at(1).at(0).toBool(), true); |
2312 | |
2313 | edit->setReadOnly(false); |
2314 | QCOMPARE(edit->selectByKeyboard(), true); |
2315 | QCOMPARE(spy.count(), 2); |
2316 | |
2317 | edit->setSelectByKeyboard(false); |
2318 | QCOMPARE(edit->selectByKeyboard(), false); |
2319 | QCOMPARE(spy.count(), 3); |
2320 | QCOMPARE(spy.at(2).at(0).toBool(), false); |
2321 | } |
2322 | |
2323 | #if QT_CONFIG(shortcut) |
2324 | |
2325 | Q_DECLARE_METATYPE(QKeySequence::StandardKey) |
2326 | |
2327 | void tst_qquicktextedit::keyboardSelection_data() |
2328 | { |
2329 | QTest::addColumn<QString>(name: "text" ); |
2330 | QTest::addColumn<bool>(name: "readOnly" ); |
2331 | QTest::addColumn<bool>(name: "selectByKeyboard" ); |
2332 | QTest::addColumn<int>(name: "cursorPosition" ); |
2333 | QTest::addColumn<QKeySequence::StandardKey>(name: "standardKey" ); |
2334 | QTest::addColumn<QString>(name: "selectedText" ); |
2335 | |
2336 | QTest::newRow(dataTag: "editable - select first char" ) |
2337 | << QStringLiteral("editable - select first char" ) << false << true << 0 << QKeySequence::SelectNextChar << QStringLiteral("e" ); |
2338 | QTest::newRow(dataTag: "editable - select first word" ) |
2339 | << QStringLiteral("editable - select first char" ) << false << true << 0 << QKeySequence::SelectNextWord << QStringLiteral("editable " ); |
2340 | |
2341 | QTest::newRow(dataTag: "editable - cannot select first char" ) |
2342 | << QStringLiteral("editable - cannot select first char" ) << false << false << 0 << QKeySequence::SelectNextChar << QStringLiteral("" ); |
2343 | QTest::newRow(dataTag: "editable - cannot select first word" ) |
2344 | << QStringLiteral("editable - cannot select first word" ) << false << false << 0 << QKeySequence::SelectNextWord << QStringLiteral("" ); |
2345 | |
2346 | QTest::newRow(dataTag: "editable - select last char" ) |
2347 | << QStringLiteral("editable - select last char" ) << false << true << 27 << QKeySequence::SelectPreviousChar << QStringLiteral("r" ); |
2348 | QTest::newRow(dataTag: "editable - select last word" ) |
2349 | << QStringLiteral("editable - select last word" ) << false << true << 27 << QKeySequence::SelectPreviousWord << QStringLiteral("word" ); |
2350 | |
2351 | QTest::newRow(dataTag: "editable - cannot select last char" ) |
2352 | << QStringLiteral("editable - cannot select last char" ) << false << false << 35 << QKeySequence::SelectPreviousChar << QStringLiteral("" ); |
2353 | QTest::newRow(dataTag: "editable - cannot select last word" ) |
2354 | << QStringLiteral("editable - cannot select last word" ) << false << false << 35 << QKeySequence::SelectPreviousWord << QStringLiteral("" ); |
2355 | |
2356 | QTest::newRow(dataTag: "read-only - cannot select first char" ) |
2357 | << QStringLiteral("read-only - cannot select first char" ) << true << false << 0 << QKeySequence::SelectNextChar << QStringLiteral("" ); |
2358 | QTest::newRow(dataTag: "read-only - cannot select first word" ) |
2359 | << QStringLiteral("read-only - cannot select first word" ) << true << false << 0 << QKeySequence::SelectNextWord << QStringLiteral("" ); |
2360 | |
2361 | QTest::newRow(dataTag: "read-only - cannot select last char" ) |
2362 | << QStringLiteral("read-only - cannot select last char" ) << true << false << 35 << QKeySequence::SelectPreviousChar << QStringLiteral("" ); |
2363 | QTest::newRow(dataTag: "read-only - cannot select last word" ) |
2364 | << QStringLiteral("read-only - cannot select last word" ) << true << false << 35 << QKeySequence::SelectPreviousWord << QStringLiteral("" ); |
2365 | |
2366 | QTest::newRow(dataTag: "read-only - select first char" ) |
2367 | << QStringLiteral("read-only - select first char" ) << true << true << 0 << QKeySequence::SelectNextChar << QStringLiteral("r" ); |
2368 | QTest::newRow(dataTag: "read-only - select first word" ) |
2369 | << QStringLiteral("read-only - select first word" ) << true << true << 0 << QKeySequence::SelectNextWord << QStringLiteral("read" ); |
2370 | |
2371 | QTest::newRow(dataTag: "read-only - select last char" ) |
2372 | << QStringLiteral("read-only - select last char" ) << true << true << 28 << QKeySequence::SelectPreviousChar << QStringLiteral("r" ); |
2373 | QTest::newRow(dataTag: "read-only - select last word" ) |
2374 | << QStringLiteral("read-only - select last word" ) << true << true << 28 << QKeySequence::SelectPreviousWord << QStringLiteral("word" ); |
2375 | } |
2376 | |
2377 | void tst_qquicktextedit::keyboardSelection() |
2378 | { |
2379 | QFETCH(QString, text); |
2380 | QFETCH(bool, readOnly); |
2381 | QFETCH(bool, selectByKeyboard); |
2382 | QFETCH(int, cursorPosition); |
2383 | QFETCH(QKeySequence::StandardKey, standardKey); |
2384 | QFETCH(QString, selectedText); |
2385 | |
2386 | QQmlComponent component(&engine); |
2387 | component.setData("import QtQuick 2.1\n TextEdit { focus: true }" , baseUrl: QUrl()); |
2388 | QScopedPointer<QObject> object(component.create()); |
2389 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: object.data()); |
2390 | QVERIFY(edit); |
2391 | |
2392 | edit->setText(text); |
2393 | edit->setSelectByKeyboard(selectByKeyboard); |
2394 | edit->setReadOnly(readOnly); |
2395 | edit->setCursorPosition(cursorPosition); |
2396 | |
2397 | QQuickWindow window; |
2398 | edit->setParentItem(window.contentItem()); |
2399 | window.show(); |
2400 | window.requestActivate(); |
2401 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
2402 | QVERIFY(edit->hasActiveFocus()); |
2403 | |
2404 | simulateKeys(window: &window, sequence: standardKey); |
2405 | |
2406 | QCOMPARE(edit->selectedText(), selectedText); |
2407 | } |
2408 | |
2409 | #endif // QT_CONFIG(shortcut) |
2410 | |
2411 | void tst_qquicktextedit::renderType() |
2412 | { |
2413 | QQmlComponent component(&engine); |
2414 | component.setData("import QtQuick 2.0\n TextEdit {}" , baseUrl: QUrl()); |
2415 | QScopedPointer<QObject> object(component.create()); |
2416 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: object.data()); |
2417 | QVERIFY(edit); |
2418 | |
2419 | QSignalSpy spy(edit, SIGNAL(renderTypeChanged())); |
2420 | |
2421 | QCOMPARE(edit->renderType(), QQuickTextEdit::QtRendering); |
2422 | |
2423 | edit->setRenderType(QQuickTextEdit::NativeRendering); |
2424 | QCOMPARE(edit->renderType(), QQuickTextEdit::NativeRendering); |
2425 | QCOMPARE(spy.count(), 1); |
2426 | |
2427 | edit->setRenderType(QQuickTextEdit::NativeRendering); |
2428 | QCOMPARE(spy.count(), 1); |
2429 | |
2430 | edit->setRenderType(QQuickTextEdit::QtRendering); |
2431 | QCOMPARE(edit->renderType(), QQuickTextEdit::QtRendering); |
2432 | QCOMPARE(spy.count(), 2); |
2433 | } |
2434 | |
2435 | void tst_qquicktextedit::inputMethodHints() |
2436 | { |
2437 | QQuickView window(testFileUrl(fileName: "inputmethodhints.qml" )); |
2438 | window.show(); |
2439 | window.requestActivate(); |
2440 | |
2441 | QVERIFY(window.rootObject() != nullptr); |
2442 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(object: window.rootObject()); |
2443 | QVERIFY(textEditObject != nullptr); |
2444 | QVERIFY(textEditObject->inputMethodHints() & Qt::ImhNoPredictiveText); |
2445 | QSignalSpy inputMethodHintSpy(textEditObject, SIGNAL(inputMethodHintsChanged())); |
2446 | textEditObject->setInputMethodHints(Qt::ImhUppercaseOnly); |
2447 | QVERIFY(textEditObject->inputMethodHints() & Qt::ImhUppercaseOnly); |
2448 | QCOMPARE(inputMethodHintSpy.count(), 1); |
2449 | textEditObject->setInputMethodHints(Qt::ImhUppercaseOnly); |
2450 | QCOMPARE(inputMethodHintSpy.count(), 1); |
2451 | |
2452 | QQuickTextEdit plainTextEdit; |
2453 | QCOMPARE(plainTextEdit.inputMethodHints(), Qt::ImhNone); |
2454 | } |
2455 | |
2456 | void tst_qquicktextedit::positionAt_data() |
2457 | { |
2458 | QTest::addColumn<QQuickTextEdit::HAlignment>(name: "horizontalAlignment" ); |
2459 | QTest::addColumn<QQuickTextEdit::VAlignment>(name: "verticalAlignment" ); |
2460 | |
2461 | QTest::newRow(dataTag: "top-left" ) << QQuickTextEdit::AlignLeft << QQuickTextEdit::AlignTop; |
2462 | QTest::newRow(dataTag: "bottom-left" ) << QQuickTextEdit::AlignLeft << QQuickTextEdit::AlignBottom; |
2463 | QTest::newRow(dataTag: "center-left" ) << QQuickTextEdit::AlignLeft << QQuickTextEdit::AlignVCenter; |
2464 | |
2465 | QTest::newRow(dataTag: "top-right" ) << QQuickTextEdit::AlignRight << QQuickTextEdit::AlignTop; |
2466 | QTest::newRow(dataTag: "top-center" ) << QQuickTextEdit::AlignHCenter << QQuickTextEdit::AlignTop; |
2467 | |
2468 | QTest::newRow(dataTag: "center" ) << QQuickTextEdit::AlignHCenter << QQuickTextEdit::AlignVCenter; |
2469 | } |
2470 | |
2471 | void tst_qquicktextedit::positionAt() |
2472 | { |
2473 | QFETCH(QQuickTextEdit::HAlignment, horizontalAlignment); |
2474 | QFETCH(QQuickTextEdit::VAlignment, verticalAlignment); |
2475 | |
2476 | QQuickView window(testFileUrl(fileName: "positionAt.qml" )); |
2477 | QVERIFY(window.rootObject() != nullptr); |
2478 | window.show(); |
2479 | window.requestActivate(); |
2480 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
2481 | |
2482 | QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit *>(object: window.rootObject()); |
2483 | QVERIFY(texteditObject != nullptr); |
2484 | texteditObject->setHAlign(horizontalAlignment); |
2485 | texteditObject->setVAlign(verticalAlignment); |
2486 | |
2487 | QTextLayout layout(texteditObject->text().replace(before: QLatin1Char('\n'), after: QChar::LineSeparator)); |
2488 | layout.setFont(texteditObject->font()); |
2489 | |
2490 | if (!qmlDisableDistanceField()) { |
2491 | QTextOption option; |
2492 | option.setUseDesignMetrics(true); |
2493 | layout.setTextOption(option); |
2494 | } |
2495 | |
2496 | layout.beginLayout(); |
2497 | QTextLine line = layout.createLine(); |
2498 | line.setLineWidth(texteditObject->width()); |
2499 | QTextLine secondLine = layout.createLine(); |
2500 | secondLine.setLineWidth(texteditObject->width()); |
2501 | layout.endLayout(); |
2502 | |
2503 | qreal y0 = 0; |
2504 | qreal y1 = 0; |
2505 | |
2506 | switch (verticalAlignment) { |
2507 | case QQuickTextEdit::AlignTop: |
2508 | y0 = line.height() / 2; |
2509 | y1 = line.height() * 3 / 2; |
2510 | break; |
2511 | case QQuickTextEdit::AlignVCenter: |
2512 | y0 = (texteditObject->height() - line.height()) / 2; |
2513 | y1 = (texteditObject->height() + line.height()) / 2; |
2514 | break; |
2515 | case QQuickTextEdit::AlignBottom: |
2516 | y0 = texteditObject->height() - line.height() * 3 / 2; |
2517 | y1 = texteditObject->height() - line.height() / 2; |
2518 | break; |
2519 | } |
2520 | |
2521 | qreal xoff = 0; |
2522 | switch (horizontalAlignment) { |
2523 | case QQuickTextEdit::AlignLeft: |
2524 | break; |
2525 | case QQuickTextEdit::AlignHCenter: |
2526 | xoff = (texteditObject->width() - secondLine.naturalTextWidth()) / 2; |
2527 | break; |
2528 | case QQuickTextEdit::AlignRight: |
2529 | xoff = texteditObject->width() - secondLine.naturalTextWidth(); |
2530 | break; |
2531 | default: |
2532 | break; |
2533 | } |
2534 | int pos = texteditObject->positionAt(x: texteditObject->width()/2, y: y0); |
2535 | |
2536 | int widthBegin = floor(x: xoff + line.cursorToX(cursorPos: pos - 1)); |
2537 | int widthEnd = ceil(x: xoff + line.cursorToX(cursorPos: pos + 1)); |
2538 | |
2539 | QVERIFY(widthBegin <= texteditObject->width() / 2); |
2540 | QVERIFY(widthEnd >= texteditObject->width() / 2); |
2541 | |
2542 | const qreal x0 = texteditObject->positionToRectangle(pos).x(); |
2543 | const qreal x1 = texteditObject->positionToRectangle(pos + 1).x(); |
2544 | |
2545 | QString preeditText = texteditObject->text().mid(position: 0, n: pos); |
2546 | texteditObject->setText(texteditObject->text().mid(position: pos)); |
2547 | texteditObject->setCursorPosition(0); |
2548 | |
2549 | QInputMethodEvent inputEvent(preeditText, QList<QInputMethodEvent::Attribute>()); |
2550 | QGuiApplication::sendEvent(receiver: texteditObject, event: &inputEvent); |
2551 | |
2552 | // Check all points within the preedit text return the same position. |
2553 | QCOMPARE(texteditObject->positionAt(0, y0), 0); |
2554 | QCOMPARE(texteditObject->positionAt(x0 / 2, y0), 0); |
2555 | QCOMPARE(texteditObject->positionAt(x0, y0), 0); |
2556 | |
2557 | // Verify positioning returns to normal after the preedit text. |
2558 | QCOMPARE(texteditObject->positionAt(x1, y0), 1); |
2559 | QCOMPARE(texteditObject->positionToRectangle(1).x(), x1); |
2560 | |
2561 | QVERIFY(texteditObject->positionAt(x0 / 2, y1) > 0); |
2562 | } |
2563 | |
2564 | #if QT_CONFIG(cursor) |
2565 | void tst_qquicktextedit::linkHover() |
2566 | { |
2567 | if (isPlatformWayland()) |
2568 | QSKIP("Wayland: QCursor::setPos() doesn't work." ); |
2569 | |
2570 | QQuickView window(testFileUrl(fileName: "linkInteraction.qml" )); |
2571 | window.setFlag(Qt::FramelessWindowHint); |
2572 | QVERIFY(window.rootObject() != nullptr); |
2573 | QQuickViewTestUtil::centerOnScreen(window: &window); |
2574 | QQuickViewTestUtil::moveMouseAway(window: &window); |
2575 | window.show(); |
2576 | window.requestActivate(); |
2577 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
2578 | QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit *>(object: window.rootObject()); |
2579 | QVERIFY(texteditObject != nullptr); |
2580 | |
2581 | QSignalSpy hover(texteditObject, SIGNAL(linkHovered(QString))); |
2582 | |
2583 | const QString link("http://example.com/" ); |
2584 | const QPoint linkPos = window.mapToGlobal(pos: texteditObject->positionToRectangle(7).center().toPoint()); |
2585 | const QPoint textPos = window.mapToGlobal(pos: texteditObject->positionToRectangle(2).center().toPoint()); |
2586 | |
2587 | QCursor::setPos(linkPos); |
2588 | QTRY_COMPARE(hover.count(), 1); |
2589 | QCOMPARE(window.cursor().shape(), Qt::PointingHandCursor); |
2590 | QCOMPARE(hover.last()[0].toString(), link); |
2591 | |
2592 | QCursor::setPos(textPos); |
2593 | QTRY_COMPARE(hover.count(), 2); |
2594 | QCOMPARE(window.cursor().shape(), Qt::IBeamCursor); |
2595 | QCOMPARE(hover.last()[0].toString(), QString()); |
2596 | |
2597 | texteditObject->setCursor(Qt::OpenHandCursor); |
2598 | |
2599 | QCursor::setPos(linkPos); |
2600 | QTRY_COMPARE(hover.count(), 3); |
2601 | QCOMPARE(window.cursor().shape(), Qt::PointingHandCursor); |
2602 | QCOMPARE(hover.last()[0].toString(), link); |
2603 | |
2604 | QCursor::setPos(textPos); |
2605 | QTRY_COMPARE(hover.count(), 4); |
2606 | QCOMPARE(window.cursor().shape(), Qt::OpenHandCursor); |
2607 | QCOMPARE(hover.last()[0].toString(), QString()); |
2608 | } |
2609 | #endif |
2610 | |
2611 | void tst_qquicktextedit::linkInteraction() |
2612 | { |
2613 | QQuickView window(testFileUrl(fileName: "linkInteraction.qml" )); |
2614 | QVERIFY(window.rootObject() != nullptr); |
2615 | QQuickViewTestUtil::centerOnScreen(window: &window); |
2616 | QQuickViewTestUtil::moveMouseAway(window: &window); |
2617 | window.show(); |
2618 | window.requestActivate(); |
2619 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
2620 | |
2621 | QQuickTextEdit *texteditObject = qobject_cast<QQuickTextEdit *>(object: window.rootObject()); |
2622 | QVERIFY(texteditObject != nullptr); |
2623 | |
2624 | QSignalSpy spy(texteditObject, SIGNAL(linkActivated(QString))); |
2625 | QSignalSpy hover(texteditObject, SIGNAL(linkHovered(QString))); |
2626 | |
2627 | const QString link("http://example.com/" ); |
2628 | |
2629 | const QPointF linkPos = texteditObject->positionToRectangle(7).center(); |
2630 | const QPointF textPos = texteditObject->positionToRectangle(2).center(); |
2631 | |
2632 | QTest::mouseClick(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: linkPos.toPoint()); |
2633 | QTRY_COMPARE(spy.count(), 1); |
2634 | QTRY_COMPARE(hover.count(), 1); |
2635 | QCOMPARE(spy.last()[0].toString(), link); |
2636 | QCOMPARE(hover.last()[0].toString(), link); |
2637 | QCOMPARE(texteditObject->hoveredLink(), link); |
2638 | QCOMPARE(texteditObject->linkAt(linkPos.x(), linkPos.y()), link); |
2639 | |
2640 | QTest::mouseClick(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: textPos.toPoint()); |
2641 | QTRY_COMPARE(spy.count(), 1); |
2642 | QTRY_COMPARE(hover.count(), 2); |
2643 | QCOMPARE(hover.last()[0].toString(), QString()); |
2644 | QCOMPARE(texteditObject->hoveredLink(), QString()); |
2645 | QCOMPARE(texteditObject->linkAt(textPos.x(), textPos.y()), QString()); |
2646 | |
2647 | texteditObject->setReadOnly(true); |
2648 | |
2649 | QTest::mouseClick(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: linkPos.toPoint()); |
2650 | QTRY_COMPARE(spy.count(), 2); |
2651 | QTRY_COMPARE(hover.count(), 3); |
2652 | QCOMPARE(spy.last()[0].toString(), link); |
2653 | QCOMPARE(hover.last()[0].toString(), link); |
2654 | QCOMPARE(texteditObject->hoveredLink(), link); |
2655 | QCOMPARE(texteditObject->linkAt(linkPos.x(), linkPos.y()), link); |
2656 | |
2657 | QTest::mouseClick(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: textPos.toPoint()); |
2658 | QTRY_COMPARE(spy.count(), 2); |
2659 | QTRY_COMPARE(hover.count(), 4); |
2660 | QCOMPARE(hover.last()[0].toString(), QString()); |
2661 | QCOMPARE(texteditObject->hoveredLink(), QString()); |
2662 | QCOMPARE(texteditObject->linkAt(textPos.x(), textPos.y()), QString()); |
2663 | } |
2664 | |
2665 | void tst_qquicktextedit::cursorDelegate_data() |
2666 | { |
2667 | QTest::addColumn<QUrl>(name: "source" ); |
2668 | QTest::newRow(dataTag: "out of line" ) << testFileUrl(fileName: "cursorTest.qml" ); |
2669 | QTest::newRow(dataTag: "in line" ) << testFileUrl(fileName: "cursorTestInline.qml" ); |
2670 | QTest::newRow(dataTag: "external" ) << testFileUrl(fileName: "cursorTestExternal.qml" ); |
2671 | } |
2672 | |
2673 | void tst_qquicktextedit::cursorDelegate() |
2674 | { |
2675 | QFETCH(QUrl, source); |
2676 | QQuickView view(source); |
2677 | view.show(); |
2678 | view.requestActivate(); |
2679 | QVERIFY(QTest::qWaitForWindowActive(&view)); |
2680 | QQuickTextEdit *textEditObject = view.rootObject()->findChild<QQuickTextEdit*>(aName: "textEditObject" ); |
2681 | QVERIFY(textEditObject != nullptr); |
2682 | // Delegate creation is deferred until focus in or cursor visibility is forced. |
2683 | QVERIFY(!textEditObject->findChild<QQuickItem*>("cursorInstance" )); |
2684 | QVERIFY(!textEditObject->isCursorVisible()); |
2685 | //Test Delegate gets created |
2686 | textEditObject->setFocus(true); |
2687 | QVERIFY(textEditObject->isCursorVisible()); |
2688 | QQuickItem* delegateObject = textEditObject->findChild<QQuickItem*>(aName: "cursorInstance" ); |
2689 | QVERIFY(delegateObject); |
2690 | QCOMPARE(delegateObject->property("localProperty" ).toString(), QString("Hello" )); |
2691 | //Test Delegate gets moved |
2692 | for (int i=0; i<= textEditObject->text().length(); i++) { |
2693 | textEditObject->setCursorPosition(i); |
2694 | QCOMPARE(textEditObject->cursorRectangle().x(), delegateObject->x()); |
2695 | QCOMPARE(textEditObject->cursorRectangle().y(), delegateObject->y()); |
2696 | } |
2697 | |
2698 | // Test delegate gets moved on mouse press. |
2699 | textEditObject->setSelectByMouse(true); |
2700 | textEditObject->setCursorPosition(0); |
2701 | const QPoint point1 = textEditObject->positionToRectangle(5).center().toPoint(); |
2702 | QTest::qWait(ms: 400); //ensure this isn't treated as a double-click |
2703 | QTest::mouseClick(window: &view, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: point1); |
2704 | QTest::qWait(ms: 50); |
2705 | QTRY_VERIFY(textEditObject->cursorPosition() != 0); |
2706 | QCOMPARE(textEditObject->cursorRectangle().x(), delegateObject->x()); |
2707 | QCOMPARE(textEditObject->cursorRectangle().y(), delegateObject->y()); |
2708 | |
2709 | // Test delegate gets moved on mouse drag |
2710 | textEditObject->setCursorPosition(0); |
2711 | const QPoint point2 = textEditObject->positionToRectangle(10).center().toPoint(); |
2712 | QTest::qWait(ms: 400); //ensure this isn't treated as a double-click |
2713 | QTest::mousePress(window: &view, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: point1); |
2714 | QMouseEvent mv(QEvent::MouseMove, point2, Qt::LeftButton, Qt::LeftButton,Qt::NoModifier); |
2715 | QGuiApplication::sendEvent(receiver: &view, event: &mv); |
2716 | QTest::mouseRelease(window: &view, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: point2); |
2717 | QTest::qWait(ms: 50); |
2718 | QTRY_COMPARE(textEditObject->cursorRectangle().x(), delegateObject->x()); |
2719 | QCOMPARE(textEditObject->cursorRectangle().y(), delegateObject->y()); |
2720 | |
2721 | textEditObject->setReadOnly(true); |
2722 | textEditObject->setCursorPosition(0); |
2723 | QTest::qWait(ms: 400); //ensure this isn't treated as a double-click |
2724 | QTest::mouseClick(window: &view, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: textEditObject->positionToRectangle(5).center().toPoint()); |
2725 | QTest::qWait(ms: 50); |
2726 | QTRY_VERIFY(textEditObject->cursorPosition() != 0); |
2727 | QCOMPARE(textEditObject->cursorRectangle().x(), delegateObject->x()); |
2728 | QCOMPARE(textEditObject->cursorRectangle().y(), delegateObject->y()); |
2729 | |
2730 | textEditObject->setCursorPosition(0); |
2731 | QTest::qWait(ms: 400); //ensure this isn't treated as a double-click |
2732 | QTest::mouseClick(window: &view, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: textEditObject->positionToRectangle(5).center().toPoint()); |
2733 | QTest::qWait(ms: 50); |
2734 | QTRY_VERIFY(textEditObject->cursorPosition() != 0); |
2735 | QCOMPARE(textEditObject->cursorRectangle().x(), delegateObject->x()); |
2736 | QCOMPARE(textEditObject->cursorRectangle().y(), delegateObject->y()); |
2737 | |
2738 | textEditObject->setCursorPosition(0); |
2739 | QCOMPARE(textEditObject->cursorRectangle().x(), delegateObject->x()); |
2740 | QCOMPARE(textEditObject->cursorRectangle().y(), delegateObject->y()); |
2741 | |
2742 | textEditObject->setReadOnly(false); |
2743 | |
2744 | // Delegate moved when text is entered |
2745 | textEditObject->setText(QString()); |
2746 | for (int i = 0; i < 20; ++i) { |
2747 | QTest::keyClick(window: &view, key: Qt::Key_A); |
2748 | QCOMPARE(textEditObject->cursorRectangle().x(), delegateObject->x()); |
2749 | QCOMPARE(textEditObject->cursorRectangle().y(), delegateObject->y()); |
2750 | } |
2751 | |
2752 | // Delegate moved when text is entered by im. |
2753 | textEditObject->setText(QString()); |
2754 | for (int i = 0; i < 20; ++i) { |
2755 | QInputMethodEvent event; |
2756 | event.setCommitString(commitString: "a" ); |
2757 | QGuiApplication::sendEvent(receiver: textEditObject, event: &event); |
2758 | QCOMPARE(textEditObject->cursorRectangle().x(), delegateObject->x()); |
2759 | QCOMPARE(textEditObject->cursorRectangle().y(), delegateObject->y()); |
2760 | } |
2761 | // Delegate moved when text is removed by im. |
2762 | for (int i = 19; i > 1; --i) { |
2763 | QInputMethodEvent event; |
2764 | event.setCommitString(commitString: QString(), replaceFrom: -1, replaceLength: 1); |
2765 | QGuiApplication::sendEvent(receiver: textEditObject, event: &event); |
2766 | QCOMPARE(textEditObject->cursorRectangle().x(), delegateObject->x()); |
2767 | QCOMPARE(textEditObject->cursorRectangle().y(), delegateObject->y()); |
2768 | } |
2769 | { // Delegate moved the text is changed in place by im. |
2770 | QInputMethodEvent event; |
2771 | event.setCommitString(commitString: "i" , replaceFrom: -1, replaceLength: 1); |
2772 | QGuiApplication::sendEvent(receiver: textEditObject, event: &event); |
2773 | QCOMPARE(textEditObject->cursorRectangle().x(), delegateObject->x()); |
2774 | QCOMPARE(textEditObject->cursorRectangle().y(), delegateObject->y()); |
2775 | } |
2776 | |
2777 | //Test Delegate gets deleted |
2778 | textEditObject->setCursorDelegate(nullptr); |
2779 | QVERIFY(!textEditObject->findChild<QQuickItem*>("cursorInstance" )); |
2780 | } |
2781 | |
2782 | void tst_qquicktextedit::remoteCursorDelegate() |
2783 | { |
2784 | ThreadedTestHTTPServer server(dataDirectory(), TestHTTPServer::Delay); |
2785 | |
2786 | QQuickView view; |
2787 | |
2788 | QQmlComponent component(view.engine(), server.url(documentPath: "/RemoteCursor.qml" )); |
2789 | |
2790 | view.rootContext()->setContextProperty("contextDelegate" , &component); |
2791 | view.setSource(testFileUrl(fileName: "cursorTestRemote.qml" )); |
2792 | view.showNormal(); |
2793 | view.requestActivate(); |
2794 | QVERIFY(QTest::qWaitForWindowActive(&view)); |
2795 | QQuickTextEdit *textEditObject = view.rootObject()->findChild<QQuickTextEdit*>(aName: "textEditObject" ); |
2796 | QVERIFY(textEditObject != nullptr); |
2797 | |
2798 | // Delegate is created on demand, and so won't be available immediately. Focus in or |
2799 | // setCursorVisible(true) will trigger creation. |
2800 | QTRY_VERIFY(!textEditObject->findChild<QQuickItem*>("cursorInstance" )); |
2801 | QVERIFY(!textEditObject->isCursorVisible()); |
2802 | |
2803 | textEditObject->setFocus(true); |
2804 | QVERIFY(textEditObject->isCursorVisible()); |
2805 | |
2806 | // Wait for component to load. |
2807 | QTRY_COMPARE(component.status(), QQmlComponent::Ready); |
2808 | QVERIFY(textEditObject->findChild<QQuickItem*>("cursorInstance" )); |
2809 | } |
2810 | |
2811 | void tst_qquicktextedit::cursorVisible() |
2812 | { |
2813 | QQuickTextEdit edit; |
2814 | edit.componentComplete(); |
2815 | QSignalSpy spy(&edit, SIGNAL(cursorVisibleChanged(bool))); |
2816 | |
2817 | QQuickView view(testFileUrl(fileName: "cursorVisible.qml" )); |
2818 | view.show(); |
2819 | view.requestActivate(); |
2820 | QVERIFY(QTest::qWaitForWindowActive(&view)); |
2821 | QCOMPARE(&view, qGuiApp->focusWindow()); |
2822 | |
2823 | QCOMPARE(edit.isCursorVisible(), false); |
2824 | |
2825 | edit.setCursorVisible(true); |
2826 | QCOMPARE(edit.isCursorVisible(), true); |
2827 | QCOMPARE(spy.count(), 1); |
2828 | |
2829 | edit.setCursorVisible(false); |
2830 | QCOMPARE(edit.isCursorVisible(), false); |
2831 | QCOMPARE(spy.count(), 2); |
2832 | |
2833 | edit.setFocus(true); |
2834 | QCOMPARE(edit.isCursorVisible(), false); |
2835 | QCOMPARE(spy.count(), 2); |
2836 | |
2837 | edit.setParentItem(view.rootObject()); |
2838 | QCOMPARE(edit.isCursorVisible(), true); |
2839 | QCOMPARE(spy.count(), 3); |
2840 | |
2841 | edit.setFocus(false); |
2842 | QCOMPARE(edit.isCursorVisible(), false); |
2843 | QCOMPARE(spy.count(), 4); |
2844 | |
2845 | edit.setFocus(true); |
2846 | QCOMPARE(edit.isCursorVisible(), true); |
2847 | QCOMPARE(spy.count(), 5); |
2848 | |
2849 | QWindow alternateView; |
2850 | alternateView.show(); |
2851 | alternateView.requestActivate(); |
2852 | QVERIFY(QTest::qWaitForWindowActive(&alternateView)); |
2853 | |
2854 | QCOMPARE(edit.isCursorVisible(), false); |
2855 | QCOMPARE(spy.count(), 6); |
2856 | |
2857 | view.requestActivate(); |
2858 | QVERIFY(QTest::qWaitForWindowActive(&view)); |
2859 | QCOMPARE(edit.isCursorVisible(), true); |
2860 | QCOMPARE(spy.count(), 7); |
2861 | |
2862 | { // Cursor attribute with 0 length hides cursor. |
2863 | QInputMethodEvent ev(QString(), QList<QInputMethodEvent::Attribute>() |
2864 | << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, 0, 0, QVariant())); |
2865 | QCoreApplication::sendEvent(receiver: &edit, event: &ev); |
2866 | } |
2867 | QCOMPARE(edit.isCursorVisible(), false); |
2868 | QCOMPARE(spy.count(), 8); |
2869 | |
2870 | { // Cursor attribute with non zero length shows cursor. |
2871 | QInputMethodEvent ev(QString(), QList<QInputMethodEvent::Attribute>() |
2872 | << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, 0, 1, QVariant())); |
2873 | QCoreApplication::sendEvent(receiver: &edit, event: &ev); |
2874 | } |
2875 | QCOMPARE(edit.isCursorVisible(), true); |
2876 | QCOMPARE(spy.count(), 9); |
2877 | |
2878 | |
2879 | { // If the cursor is hidden by the input method and the text is changed it should be visible again. |
2880 | QInputMethodEvent ev(QString(), QList<QInputMethodEvent::Attribute>() |
2881 | << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, 0, 0, QVariant())); |
2882 | QCoreApplication::sendEvent(receiver: &edit, event: &ev); |
2883 | } |
2884 | QCOMPARE(edit.isCursorVisible(), false); |
2885 | QCOMPARE(spy.count(), 10); |
2886 | |
2887 | edit.setText("something" ); |
2888 | QCOMPARE(edit.isCursorVisible(), true); |
2889 | QCOMPARE(spy.count(), 11); |
2890 | |
2891 | { // If the cursor is hidden by the input method and the cursor position is changed it should be visible again. |
2892 | QInputMethodEvent ev(QString(), QList<QInputMethodEvent::Attribute>() |
2893 | << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, 0, 0, QVariant())); |
2894 | QCoreApplication::sendEvent(receiver: &edit, event: &ev); |
2895 | } |
2896 | QCOMPARE(edit.isCursorVisible(), false); |
2897 | QCOMPARE(spy.count(), 12); |
2898 | |
2899 | edit.setCursorPosition(5); |
2900 | QCOMPARE(edit.isCursorVisible(), true); |
2901 | QCOMPARE(spy.count(), 13); |
2902 | } |
2903 | |
2904 | void tst_qquicktextedit::delegateLoading_data() |
2905 | { |
2906 | QTest::addColumn<QString>(name: "qmlfile" ); |
2907 | QTest::addColumn<QString>(name: "error" ); |
2908 | |
2909 | // import installed |
2910 | QTest::newRow(dataTag: "pass" ) << "cursorHttpTestPass.qml" << "" ; |
2911 | QTest::newRow(dataTag: "fail1" ) << "cursorHttpTestFail1.qml" << "{{ServerBaseUrl}}/FailItem.qml: Remote host closed the connection" ; |
2912 | QTest::newRow(dataTag: "fail2" ) << "cursorHttpTestFail2.qml" << "{{ServerBaseUrl}}/ErrItem.qml:4:5: Fungus is not a type" ; |
2913 | } |
2914 | |
2915 | void tst_qquicktextedit::delegateLoading() |
2916 | { |
2917 | QFETCH(QString, qmlfile); |
2918 | QFETCH(QString, error); |
2919 | |
2920 | QHash<QString, TestHTTPServer::Mode> dirs; |
2921 | dirs[testFile(fileName: "httpfail" )] = TestHTTPServer::Disconnect; |
2922 | dirs[testFile(fileName: "httpslow" )] = TestHTTPServer::Delay; |
2923 | dirs[testFile(fileName: "http" )] = TestHTTPServer::Normal; |
2924 | ThreadedTestHTTPServer server(dirs); |
2925 | |
2926 | error.replace(QStringLiteral("{{ServerBaseUrl}}" ), after: server.baseUrl().toString()); |
2927 | |
2928 | if (!error.isEmpty()) |
2929 | QTest::ignoreMessage(type: QtWarningMsg, message: error.toUtf8()); |
2930 | QQuickView view(server.url(documentPath: qmlfile)); |
2931 | view.show(); |
2932 | view.requestActivate(); |
2933 | |
2934 | if (!error.isEmpty()) { |
2935 | QTRY_VERIFY(view.status()==QQuickView::Error); |
2936 | QTRY_VERIFY(!view.rootObject()); // there is fail item inside this test |
2937 | } else { |
2938 | QTRY_VERIFY(view.rootObject());//Wait for loading to finish. |
2939 | QQuickTextEdit *textEditObject = view.rootObject()->findChild<QQuickTextEdit*>(aName: "textEditObject" ); |
2940 | // view.rootObject()->dumpObjectTree(); |
2941 | QVERIFY(textEditObject != nullptr); |
2942 | textEditObject->setFocus(true); |
2943 | QQuickItem *delegate; |
2944 | delegate = view.rootObject()->findChild<QQuickItem*>(aName: "delegateOkay" ); |
2945 | QVERIFY(delegate); |
2946 | delegate = view.rootObject()->findChild<QQuickItem*>(aName: "delegateSlow" ); |
2947 | QVERIFY(delegate); |
2948 | |
2949 | delete delegate; |
2950 | } |
2951 | |
2952 | |
2953 | //A test should be added here with a component which is ready but component.create() returns null |
2954 | //Not sure how to accomplish this with QQuickTextEdits cursor delegate |
2955 | //###This was only needed for code coverage, and could be a case of overzealous defensive programming |
2956 | //delegate = view.rootObject()->findChild<QQuickItem*>("delegateErrorB"); |
2957 | //QVERIFY(!delegate); |
2958 | } |
2959 | |
2960 | void tst_qquicktextedit::cursorDelegateHeight() |
2961 | { |
2962 | QQuickView view(testFileUrl(fileName: "cursorHeight.qml" )); |
2963 | view.show(); |
2964 | view.requestActivate(); |
2965 | QVERIFY(QTest::qWaitForWindowActive(&view)); |
2966 | QQuickTextEdit *textEditObject = view.rootObject()->findChild<QQuickTextEdit*>(aName: "textEditObject" ); |
2967 | QVERIFY(textEditObject); |
2968 | // Delegate creation is deferred until focus in or cursor visibility is forced. |
2969 | QVERIFY(!textEditObject->findChild<QQuickItem*>("cursorInstance" )); |
2970 | QVERIFY(!textEditObject->isCursorVisible()); |
2971 | |
2972 | // Test that the delegate gets created. |
2973 | textEditObject->setFocus(true); |
2974 | QVERIFY(textEditObject->isCursorVisible()); |
2975 | QQuickItem* delegateObject = textEditObject->findChild<QQuickItem*>(aName: "cursorInstance" ); |
2976 | QVERIFY(delegateObject); |
2977 | |
2978 | const int largerHeight = textEditObject->cursorRectangle().height(); |
2979 | |
2980 | textEditObject->setCursorPosition(0); |
2981 | QCOMPARE(delegateObject->x(), textEditObject->cursorRectangle().x()); |
2982 | QCOMPARE(delegateObject->y(), textEditObject->cursorRectangle().y()); |
2983 | QCOMPARE(delegateObject->height(), textEditObject->cursorRectangle().height()); |
2984 | |
2985 | // Move the cursor to the next line, which has a smaller font. |
2986 | textEditObject->setCursorPosition(5); |
2987 | QCOMPARE(delegateObject->x(), textEditObject->cursorRectangle().x()); |
2988 | QCOMPARE(delegateObject->y(), textEditObject->cursorRectangle().y()); |
2989 | QVERIFY(textEditObject->cursorRectangle().height() < largerHeight); |
2990 | QCOMPARE(delegateObject->height(), textEditObject->cursorRectangle().height()); |
2991 | |
2992 | // Test that the delegate gets deleted |
2993 | textEditObject->setCursorDelegate(nullptr); |
2994 | QVERIFY(!textEditObject->findChild<QQuickItem*>("cursorInstance" )); |
2995 | } |
2996 | |
2997 | /* |
2998 | TextEdit element should only handle left/right keys until the cursor reaches |
2999 | the extent of the text, then they should ignore the keys. |
3000 | */ |
3001 | void tst_qquicktextedit::navigation() |
3002 | { |
3003 | QQuickView window(testFileUrl(fileName: "navigation.qml" )); |
3004 | window.show(); |
3005 | window.requestActivate(); |
3006 | |
3007 | QVERIFY(window.rootObject() != nullptr); |
3008 | |
3009 | QQuickTextEdit *input = qobject_cast<QQuickTextEdit *>(object: qvariant_cast<QObject *>(v: window.rootObject()->property(name: "myInput" ))); |
3010 | |
3011 | QVERIFY(input != nullptr); |
3012 | QTRY_VERIFY(input->hasActiveFocus()); |
3013 | simulateKey(&window, key: Qt::Key_Left); |
3014 | QVERIFY(!input->hasActiveFocus()); |
3015 | simulateKey(&window, key: Qt::Key_Right); |
3016 | QVERIFY(input->hasActiveFocus()); |
3017 | simulateKey(&window, key: Qt::Key_Right); |
3018 | QVERIFY(input->hasActiveFocus()); |
3019 | simulateKey(&window, key: Qt::Key_Right); |
3020 | QVERIFY(!input->hasActiveFocus()); |
3021 | simulateKey(&window, key: Qt::Key_Left); |
3022 | QVERIFY(input->hasActiveFocus()); |
3023 | |
3024 | // Test left and right navigation works if the TextEdit is empty (QTBUG-25447). |
3025 | input->setText(QString()); |
3026 | QCOMPARE(input->cursorPosition(), 0); |
3027 | simulateKey(&window, key: Qt::Key_Right); |
3028 | QCOMPARE(input->hasActiveFocus(), false); |
3029 | simulateKey(&window, key: Qt::Key_Left); |
3030 | QCOMPARE(input->hasActiveFocus(), true); |
3031 | simulateKey(&window, key: Qt::Key_Left); |
3032 | QCOMPARE(input->hasActiveFocus(), false); |
3033 | } |
3034 | |
3035 | #if QT_CONFIG(clipboard) |
3036 | void tst_qquicktextedit::copyAndPaste() |
3037 | { |
3038 | if (!PlatformQuirks::isClipboardAvailable()) |
3039 | QSKIP("This machine doesn't support the clipboard" ); |
3040 | |
3041 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"Hello world!\" }" ; |
3042 | QQmlComponent textEditComponent(&engine); |
3043 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
3044 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
3045 | QVERIFY(textEdit != nullptr); |
3046 | |
3047 | // copy and paste |
3048 | QCOMPARE(textEdit->text().length(), 12); |
3049 | textEdit->select(start: 0, end: textEdit->text().length());; |
3050 | textEdit->copy(); |
3051 | QCOMPARE(textEdit->selectedText(), QString("Hello world!" )); |
3052 | QCOMPARE(textEdit->selectedText().length(), 12); |
3053 | textEdit->setCursorPosition(0); |
3054 | QVERIFY(textEdit->canPaste()); |
3055 | textEdit->paste(); |
3056 | QCOMPARE(textEdit->text(), QString("Hello world!Hello world!" )); |
3057 | QCOMPARE(textEdit->text().length(), 24); |
3058 | |
3059 | // canPaste |
3060 | QVERIFY(textEdit->canPaste()); |
3061 | textEdit->setReadOnly(true); |
3062 | QVERIFY(!textEdit->canPaste()); |
3063 | textEdit->paste(); |
3064 | QCOMPARE(textEdit->text(), QString("Hello world!Hello world!" )); |
3065 | QCOMPARE(textEdit->text().length(), 24); |
3066 | textEdit->setReadOnly(false); |
3067 | QVERIFY(textEdit->canPaste()); |
3068 | |
3069 | // QTBUG-12339 |
3070 | // test that document and internal text attribute are in sync |
3071 | QQuickItemPrivate* pri = QQuickItemPrivate::get(item: textEdit); |
3072 | QQuickTextEditPrivate *editPrivate = static_cast<QQuickTextEditPrivate*>(pri); |
3073 | QCOMPARE(textEdit->text(), editPrivate->text); |
3074 | |
3075 | // cut: no selection |
3076 | textEdit->cut(); |
3077 | QCOMPARE(textEdit->text(), QString("Hello world!Hello world!" )); |
3078 | |
3079 | // select word |
3080 | textEdit->setCursorPosition(0); |
3081 | textEdit->selectWord(); |
3082 | QCOMPARE(textEdit->selectedText(), QString("Hello" )); |
3083 | |
3084 | // cut: read only. |
3085 | textEdit->setReadOnly(true); |
3086 | textEdit->cut(); |
3087 | QCOMPARE(textEdit->text(), QString("Hello world!Hello world!" )); |
3088 | textEdit->setReadOnly(false); |
3089 | |
3090 | // select all and cut |
3091 | textEdit->selectAll(); |
3092 | textEdit->cut(); |
3093 | QCOMPARE(textEdit->text().length(), 0); |
3094 | textEdit->paste(); |
3095 | QCOMPARE(textEdit->text(), QString("Hello world!Hello world!" )); |
3096 | QCOMPARE(textEdit->text().length(), 24); |
3097 | |
3098 | // Copy first word. |
3099 | textEdit->setCursorPosition(0); |
3100 | textEdit->selectWord(); |
3101 | textEdit->copy(); |
3102 | // copy: no selection, previous copy retained; |
3103 | textEdit->setCursorPosition(0); |
3104 | QCOMPARE(textEdit->selectedText(), QString()); |
3105 | textEdit->copy(); |
3106 | textEdit->setText(QString()); |
3107 | textEdit->paste(); |
3108 | QCOMPARE(textEdit->text(), QString("Hello" )); |
3109 | } |
3110 | #endif |
3111 | |
3112 | #if QT_CONFIG(clipboard) |
3113 | void tst_qquicktextedit::canPaste() |
3114 | { |
3115 | QGuiApplication::clipboard()->setText("Some text" ); |
3116 | |
3117 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"Hello world!\" }" ; |
3118 | QQmlComponent textEditComponent(&engine); |
3119 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
3120 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
3121 | QVERIFY(textEdit != nullptr); |
3122 | |
3123 | // check initial value - QTBUG-17765 |
3124 | QTextDocument document; |
3125 | QQuickTextControl tc(&document); |
3126 | QCOMPARE(textEdit->canPaste(), tc.canPaste()); |
3127 | } |
3128 | #endif |
3129 | |
3130 | #if QT_CONFIG(clipboard) |
3131 | void tst_qquicktextedit::canPasteEmpty() |
3132 | { |
3133 | QGuiApplication::clipboard()->clear(); |
3134 | |
3135 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"Hello world!\" }" ; |
3136 | QQmlComponent textEditComponent(&engine); |
3137 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
3138 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
3139 | QVERIFY(textEdit != nullptr); |
3140 | |
3141 | // check initial value - QTBUG-17765 |
3142 | QTextDocument document; |
3143 | QQuickTextControl tc(&document); |
3144 | QCOMPARE(textEdit->canPaste(), tc.canPaste()); |
3145 | } |
3146 | #endif |
3147 | |
3148 | #if QT_CONFIG(clipboard) |
3149 | void tst_qquicktextedit::middleClickPaste() |
3150 | { |
3151 | if (!PlatformQuirks::isClipboardAvailable()) |
3152 | QSKIP("This machine doesn't support the clipboard" ); |
3153 | |
3154 | QQuickView window(testFileUrl(fileName: "mouseselection_true.qml" )); |
3155 | |
3156 | window.show(); |
3157 | window.requestActivate(); |
3158 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
3159 | |
3160 | QVERIFY(window.rootObject() != nullptr); |
3161 | QQuickTextEdit *textEditObject = qobject_cast<QQuickTextEdit *>(object: window.rootObject()); |
3162 | QVERIFY(textEditObject != nullptr); |
3163 | |
3164 | textEditObject->setFocus(true); |
3165 | |
3166 | QString originalText = textEditObject->text(); |
3167 | QString selectedText = "234567" ; |
3168 | |
3169 | // press-and-drag-and-release from x1 to x2 |
3170 | const QPoint p1 = textEditObject->positionToRectangle(2).center().toPoint(); |
3171 | const QPoint p2 = textEditObject->positionToRectangle(8).center().toPoint(); |
3172 | const QPoint p3 = textEditObject->positionToRectangle(1).center().toPoint(); |
3173 | QTest::mousePress(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: p1); |
3174 | QTest::mouseMove(window: &window, pos: p2); |
3175 | QTest::mouseRelease(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: p2); |
3176 | QTRY_COMPARE(textEditObject->selectedText(), selectedText); |
3177 | |
3178 | // Middle click pastes the selected text, assuming the platform supports it. |
3179 | QTest::mouseClick(window: &window, button: Qt::MiddleButton, stateKey: Qt::NoModifier, pos: p3); |
3180 | |
3181 | if (QGuiApplication::clipboard()->supportsSelection()) |
3182 | QCOMPARE(textEditObject->text().mid(1, selectedText.length()), selectedText); |
3183 | else |
3184 | QCOMPARE(textEditObject->text(), originalText); |
3185 | } |
3186 | #endif |
3187 | |
3188 | void tst_qquicktextedit::readOnly() |
3189 | { |
3190 | QQuickView window(testFileUrl(fileName: "readOnly.qml" )); |
3191 | window.show(); |
3192 | window.requestActivate(); |
3193 | |
3194 | QVERIFY(window.rootObject() != nullptr); |
3195 | |
3196 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: qvariant_cast<QObject *>(v: window.rootObject()->property(name: "myInput" ))); |
3197 | |
3198 | QVERIFY(edit != nullptr); |
3199 | QTRY_VERIFY(edit->hasActiveFocus()); |
3200 | QVERIFY(edit->isReadOnly()); |
3201 | QString initial = edit->text(); |
3202 | for (int k=Qt::Key_0; k<=Qt::Key_Z; k++) |
3203 | simulateKey(&window, key: k); |
3204 | simulateKey(&window, key: Qt::Key_Return); |
3205 | simulateKey(&window, key: Qt::Key_Space); |
3206 | simulateKey(&window, key: Qt::Key_Escape); |
3207 | QCOMPARE(edit->text(), initial); |
3208 | |
3209 | edit->setCursorPosition(3); |
3210 | edit->setReadOnly(false); |
3211 | QCOMPARE(edit->isReadOnly(), false); |
3212 | QCOMPARE(edit->cursorPosition(), edit->text().length()); |
3213 | } |
3214 | |
3215 | void tst_qquicktextedit::simulateKey(QWindow *view, int key, Qt::KeyboardModifiers modifiers) |
3216 | { |
3217 | QKeyEvent press(QKeyEvent::KeyPress, key, modifiers); |
3218 | QKeyEvent release(QKeyEvent::KeyRelease, key, modifiers); |
3219 | |
3220 | QGuiApplication::sendEvent(receiver: view, event: &press); |
3221 | QGuiApplication::sendEvent(receiver: view, event: &release); |
3222 | } |
3223 | |
3224 | void tst_qquicktextedit::textInput() |
3225 | { |
3226 | QQuickView view(testFileUrl(fileName: "inputMethodEvent.qml" )); |
3227 | view.show(); |
3228 | view.requestActivate(); |
3229 | QVERIFY(QTest::qWaitForWindowActive(&view)); |
3230 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: view.rootObject()); |
3231 | QVERIFY(edit); |
3232 | QVERIFY(edit->hasActiveFocus()); |
3233 | |
3234 | // test that input method event is committed and change signal is emitted |
3235 | QSignalSpy spy(edit, SIGNAL(textChanged())); |
3236 | QInputMethodEvent event; |
3237 | event.setCommitString( commitString: "Hello world!" , replaceFrom: 0, replaceLength: 0); |
3238 | QGuiApplication::sendEvent(receiver: edit, event: &event); |
3239 | QCOMPARE(edit->text(), QString("Hello world!" )); |
3240 | QCOMPARE(spy.count(), 1); |
3241 | |
3242 | // QTBUG-12339 |
3243 | // test that document and internal text attribute are in sync |
3244 | QQuickTextEditPrivate *editPrivate = static_cast<QQuickTextEditPrivate*>(QQuickItemPrivate::get(item: edit)); |
3245 | QCOMPARE(editPrivate->text, QString("Hello world!" )); |
3246 | |
3247 | QInputMethodQueryEvent queryEvent(Qt::ImEnabled); |
3248 | QGuiApplication::sendEvent(receiver: edit, event: &queryEvent); |
3249 | QCOMPARE(queryEvent.value(Qt::ImEnabled).toBool(), true); |
3250 | |
3251 | edit->setReadOnly(true); |
3252 | QGuiApplication::sendEvent(receiver: edit, event: &queryEvent); |
3253 | QCOMPARE(queryEvent.value(Qt::ImEnabled).toBool(), false); |
3254 | |
3255 | edit->setReadOnly(false); |
3256 | |
3257 | QInputMethodEvent preeditEvent("PREEDIT" , QList<QInputMethodEvent::Attribute>()); |
3258 | QGuiApplication::sendEvent(receiver: edit, event: &preeditEvent); |
3259 | QCOMPARE(edit->text(), QString("Hello world!" )); |
3260 | QCOMPARE(edit->preeditText(), QString("PREEDIT" )); |
3261 | |
3262 | QInputMethodEvent preeditEvent2("PREEDIT2" , QList<QInputMethodEvent::Attribute>()); |
3263 | QGuiApplication::sendEvent(receiver: edit, event: &preeditEvent2); |
3264 | QCOMPARE(edit->text(), QString("Hello world!" )); |
3265 | QCOMPARE(edit->preeditText(), QString("PREEDIT2" )); |
3266 | |
3267 | QInputMethodEvent preeditEvent3("" , QList<QInputMethodEvent::Attribute>()); |
3268 | QGuiApplication::sendEvent(receiver: edit, event: &preeditEvent3); |
3269 | QCOMPARE(edit->text(), QString("Hello world!" )); |
3270 | QCOMPARE(edit->preeditText(), QString("" )); |
3271 | } |
3272 | |
3273 | void tst_qquicktextedit::inputMethodUpdate() |
3274 | { |
3275 | PlatformInputContext platformInputContext; |
3276 | QInputMethodPrivate *inputMethodPrivate = QInputMethodPrivate::get(qApp->inputMethod()); |
3277 | inputMethodPrivate->testContext = &platformInputContext; |
3278 | |
3279 | QQuickView view(testFileUrl(fileName: "inputMethodEvent.qml" )); |
3280 | view.show(); |
3281 | view.requestActivate(); |
3282 | QVERIFY(QTest::qWaitForWindowActive(&view)); |
3283 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: view.rootObject()); |
3284 | QVERIFY(edit); |
3285 | QVERIFY(edit->hasActiveFocus()); |
3286 | |
3287 | // text change even without cursor position change needs to trigger update |
3288 | edit->setText("test" ); |
3289 | platformInputContext.clear(); |
3290 | edit->setText("xxxx" ); |
3291 | QVERIFY(platformInputContext.m_updateCallCount > 0); |
3292 | |
3293 | // input method event replacing text |
3294 | platformInputContext.clear(); |
3295 | { |
3296 | QInputMethodEvent inputMethodEvent; |
3297 | inputMethodEvent.setCommitString(commitString: "y" , replaceFrom: -1, replaceLength: 1); |
3298 | QGuiApplication::sendEvent(receiver: edit, event: &inputMethodEvent); |
3299 | } |
3300 | QVERIFY(platformInputContext.m_updateCallCount > 0); |
3301 | |
3302 | // input method changing selection |
3303 | platformInputContext.clear(); |
3304 | { |
3305 | QList<QInputMethodEvent::Attribute> attributes; |
3306 | attributes << QInputMethodEvent::Attribute(QInputMethodEvent::Selection, 0, 2, QVariant()); |
3307 | QInputMethodEvent inputMethodEvent("" , attributes); |
3308 | QGuiApplication::sendEvent(receiver: edit, event: &inputMethodEvent); |
3309 | } |
3310 | QVERIFY(edit->selectionStart() != edit->selectionEnd()); |
3311 | QVERIFY(platformInputContext.m_updateCallCount > 0); |
3312 | |
3313 | // programmatical selections trigger update |
3314 | platformInputContext.clear(); |
3315 | edit->selectAll(); |
3316 | QVERIFY(platformInputContext.m_updateCallCount > 0); |
3317 | |
3318 | // font changes |
3319 | platformInputContext.clear(); |
3320 | QFont font = edit->font(); |
3321 | font.setBold(!font.bold()); |
3322 | edit->setFont(font); |
3323 | QVERIFY(platformInputContext.m_updateCallCount > 0); |
3324 | |
3325 | // normal input |
3326 | platformInputContext.clear(); |
3327 | { |
3328 | QInputMethodEvent inputMethodEvent; |
3329 | inputMethodEvent.setCommitString(commitString: "y" ); |
3330 | QGuiApplication::sendEvent(receiver: edit, event: &inputMethodEvent); |
3331 | } |
3332 | QVERIFY(platformInputContext.m_updateCallCount > 0); |
3333 | |
3334 | // changing cursor position |
3335 | platformInputContext.clear(); |
3336 | edit->setCursorPosition(0); |
3337 | QVERIFY(platformInputContext.m_updateCallCount > 0); |
3338 | |
3339 | // continuing with selection |
3340 | platformInputContext.clear(); |
3341 | edit->moveCursorSelection(pos: 1); |
3342 | QVERIFY(platformInputContext.m_updateCallCount > 0); |
3343 | |
3344 | // read only disabled input method |
3345 | platformInputContext.clear(); |
3346 | edit->setReadOnly(true); |
3347 | QVERIFY(platformInputContext.m_updateCallCount > 0); |
3348 | edit->setReadOnly(false); |
3349 | |
3350 | // no updates while no focus |
3351 | edit->setFocus(false); |
3352 | platformInputContext.clear(); |
3353 | edit->setText("Foo" ); |
3354 | QCOMPARE(platformInputContext.m_updateCallCount, 0); |
3355 | edit->setCursorPosition(1); |
3356 | QCOMPARE(platformInputContext.m_updateCallCount, 0); |
3357 | edit->selectAll(); |
3358 | QCOMPARE(platformInputContext.m_updateCallCount, 0); |
3359 | edit->setReadOnly(true); |
3360 | QCOMPARE(platformInputContext.m_updateCallCount, 0); |
3361 | } |
3362 | |
3363 | void tst_qquicktextedit::openInputPanel() |
3364 | { |
3365 | PlatformInputContext platformInputContext; |
3366 | QInputMethodPrivate *inputMethodPrivate = QInputMethodPrivate::get(qApp->inputMethod()); |
3367 | inputMethodPrivate->testContext = &platformInputContext; |
3368 | |
3369 | QQuickView view(testFileUrl(fileName: "openInputPanel.qml" )); |
3370 | view.showNormal(); |
3371 | view.requestActivate(); |
3372 | QVERIFY(QTest::qWaitForWindowActive(&view)); |
3373 | |
3374 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: view.rootObject()); |
3375 | QVERIFY(edit); |
3376 | |
3377 | // check default values |
3378 | QVERIFY(edit->focusOnPress()); |
3379 | QVERIFY(!edit->hasActiveFocus()); |
3380 | QVERIFY(qApp->focusObject() != edit); |
3381 | |
3382 | QCOMPARE(qApp->inputMethod()->isVisible(), false); |
3383 | |
3384 | // input panel should open on focus |
3385 | QPoint centerPoint(view.width()/2, view.height()/2); |
3386 | Qt::KeyboardModifiers noModifiers = Qt::NoModifier; |
3387 | QTest::mousePress(window: &view, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
3388 | QGuiApplication::processEvents(); |
3389 | QVERIFY(edit->hasActiveFocus()); |
3390 | QCOMPARE(qApp->focusObject(), edit); |
3391 | QCOMPARE(qApp->inputMethod()->isVisible(), true); |
3392 | QTest::mouseRelease(window: &view, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
3393 | |
3394 | // input panel should be re-opened when pressing already focused TextEdit |
3395 | qApp->inputMethod()->hide(); |
3396 | QCOMPARE(qApp->inputMethod()->isVisible(), false); |
3397 | QVERIFY(edit->hasActiveFocus()); |
3398 | QTest::mousePress(window: &view, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
3399 | QGuiApplication::processEvents(); |
3400 | QCOMPARE(qApp->inputMethod()->isVisible(), true); |
3401 | QTest::mouseRelease(window: &view, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
3402 | |
3403 | // input panel should stay visible if focus is lost to another text editor |
3404 | QSignalSpy inputPanelVisibilitySpy(qApp->inputMethod(), SIGNAL(visibleChanged())); |
3405 | QQuickTextEdit anotherEdit; |
3406 | anotherEdit.setParentItem(view.rootObject()); |
3407 | anotherEdit.setFocus(true); |
3408 | QCOMPARE(qApp->inputMethod()->isVisible(), true); |
3409 | QCOMPARE(qApp->focusObject(), qobject_cast<QObject*>(&anotherEdit)); |
3410 | QCOMPARE(inputPanelVisibilitySpy.count(), 0); |
3411 | |
3412 | anotherEdit.setFocus(false); |
3413 | QVERIFY(qApp->focusObject() != &anotherEdit); |
3414 | QCOMPARE(view.activeFocusItem(), view.contentItem()); |
3415 | anotherEdit.setFocus(true); |
3416 | |
3417 | qApp->inputMethod()->hide(); |
3418 | |
3419 | // input panel should not be opened if TextEdit is read only |
3420 | edit->setReadOnly(true); |
3421 | edit->setFocus(true); |
3422 | QCOMPARE(qApp->inputMethod()->isVisible(), false); |
3423 | QTest::mousePress(window: &view, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
3424 | QTest::mouseRelease(window: &view, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
3425 | QGuiApplication::processEvents(); |
3426 | QCOMPARE(qApp->inputMethod()->isVisible(), false); |
3427 | |
3428 | // input panel should not be opened if focusOnPress is set to false |
3429 | edit->setFocusOnPress(false); |
3430 | edit->setFocus(false); |
3431 | edit->setFocus(true); |
3432 | QCOMPARE(qApp->inputMethod()->isVisible(), false); |
3433 | QTest::mousePress(window: &view, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
3434 | QTest::mouseRelease(window: &view, button: Qt::LeftButton, stateKey: noModifiers, pos: centerPoint); |
3435 | QCOMPARE(qApp->inputMethod()->isVisible(), false); |
3436 | |
3437 | inputMethodPrivate->testContext = nullptr; |
3438 | } |
3439 | |
3440 | void tst_qquicktextedit::geometrySignals() |
3441 | { |
3442 | QQmlComponent component(&engine, testFileUrl(fileName: "geometrySignals.qml" )); |
3443 | QObject *o = component.create(); |
3444 | QVERIFY(o); |
3445 | QCOMPARE(o->property("bindingWidth" ).toInt(), 400); |
3446 | QCOMPARE(o->property("bindingHeight" ).toInt(), 500); |
3447 | delete o; |
3448 | } |
3449 | |
3450 | #if QT_CONFIG(clipboard) |
3451 | void tst_qquicktextedit::pastingRichText_QTBUG_14003() |
3452 | { |
3453 | QString componentStr = "import QtQuick 2.0\nTextEdit { textFormat: TextEdit.PlainText }" ; |
3454 | QQmlComponent component(&engine); |
3455 | component.setData(componentStr.toLatin1(), baseUrl: QUrl::fromLocalFile(localfile: "" )); |
3456 | QQuickTextEdit *obj = qobject_cast<QQuickTextEdit*>(object: component.create()); |
3457 | |
3458 | QTRY_VERIFY(obj != nullptr); |
3459 | QTRY_COMPARE(obj->textFormat(), QQuickTextEdit::PlainText); |
3460 | |
3461 | QMimeData *mData = new QMimeData; |
3462 | mData->setHtml("<font color=\"red\">Hello</font>" ); |
3463 | QGuiApplication::clipboard()->setMimeData(data: mData); |
3464 | |
3465 | obj->paste(); |
3466 | QTRY_COMPARE(obj->text(), QString()); |
3467 | QTRY_COMPARE(obj->textFormat(), QQuickTextEdit::PlainText); |
3468 | } |
3469 | #endif |
3470 | |
3471 | void tst_qquicktextedit::implicitSize_data() |
3472 | { |
3473 | QTest::addColumn<QString>(name: "text" ); |
3474 | QTest::addColumn<QString>(name: "wrap" ); |
3475 | QTest::addColumn<QString>(name: "format" ); |
3476 | QTest::newRow(dataTag: "plain" ) << "The quick red fox jumped over the lazy brown dog" << "TextEdit.NoWrap" << "TextEdit.PlainText" ; |
3477 | QTest::newRow(dataTag: "richtext" ) << "<b>The quick red fox jumped over the lazy brown dog</b>" << "TextEdit.NoWrap" << "TextEdit.RichText" ; |
3478 | QTest::newRow(dataTag: "plain_wrap" ) << "The quick red fox jumped over the lazy brown dog" << "TextEdit.Wrap" << "TextEdit.PlainText" ; |
3479 | QTest::newRow(dataTag: "richtext_wrap" ) << "<b>The quick red fox jumped over the lazy brown dog</b>" << "TextEdit.Wrap" << "TextEdit.RichText" ; |
3480 | } |
3481 | |
3482 | void tst_qquicktextedit::implicitSize() |
3483 | { |
3484 | QFETCH(QString, text); |
3485 | QFETCH(QString, wrap); |
3486 | QFETCH(QString, format); |
3487 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + text + "\"; width: 50; wrapMode: " + wrap + "; textFormat: " + format + " }" ; |
3488 | QQmlComponent textComponent(&engine); |
3489 | textComponent.setData(componentStr.toLatin1(), baseUrl: QUrl::fromLocalFile(localfile: "" )); |
3490 | QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit*>(object: textComponent.create()); |
3491 | |
3492 | QVERIFY(textObject->width() < textObject->implicitWidth()); |
3493 | QCOMPARE(textObject->height(), textObject->implicitHeight()); |
3494 | |
3495 | textObject->resetWidth(); |
3496 | QCOMPARE(textObject->width(), textObject->implicitWidth()); |
3497 | QCOMPARE(textObject->height(), textObject->implicitHeight()); |
3498 | } |
3499 | |
3500 | void tst_qquicktextedit::implicitSize_QTBUG_63153() |
3501 | { |
3502 | QString componentStr = "import QtQuick 2.0\nTextEdit { }" ; |
3503 | QQmlComponent textComponent(&engine); |
3504 | textComponent.setData(componentStr.toLatin1(), baseUrl: QUrl::fromLocalFile(localfile: "" )); |
3505 | QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit*>(object: textComponent.create()); |
3506 | textObject->setText("short" ); |
3507 | qreal shortImplicitWidth = textObject->implicitWidth(); |
3508 | textObject->setText("in contrast to short this is long" ); |
3509 | QVERIFY2(shortImplicitWidth < textObject->implicitWidth(), qPrintable(QString("%1 < %2" ).arg(textObject->implicitWidth()).arg(shortImplicitWidth))); |
3510 | } |
3511 | |
3512 | void tst_qquicktextedit::contentSize() |
3513 | { |
3514 | QString componentStr = "import QtQuick 2.0\nTextEdit { width: 75; height: 16; font.pixelSize: 10 }" ; |
3515 | QQmlComponent textComponent(&engine); |
3516 | textComponent.setData(componentStr.toLatin1(), baseUrl: QUrl::fromLocalFile(localfile: "" )); |
3517 | QScopedPointer<QObject> object(textComponent.create()); |
3518 | QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit *>(object: object.data()); |
3519 | |
3520 | QSignalSpy spy(textObject, SIGNAL(contentSizeChanged())); |
3521 | |
3522 | textObject->setText("The quick red fox jumped over the lazy brown dog" ); |
3523 | |
3524 | QVERIFY(textObject->contentWidth() > textObject->width()); |
3525 | QVERIFY(textObject->contentHeight() < textObject->height()); |
3526 | QCOMPARE(spy.count(), 1); |
3527 | |
3528 | textObject->setWrapMode(QQuickTextEdit::WordWrap); |
3529 | QVERIFY(textObject->contentWidth() <= textObject->width()); |
3530 | QVERIFY(textObject->contentHeight() > textObject->height()); |
3531 | QCOMPARE(spy.count(), 2); |
3532 | |
3533 | textObject->setText("The quickredfoxjumpedoverthe lazy brown dog" ); |
3534 | |
3535 | QVERIFY(textObject->contentWidth() > textObject->width()); |
3536 | QVERIFY(textObject->contentHeight() > textObject->height()); |
3537 | QCOMPARE(spy.count(), 3); |
3538 | } |
3539 | |
3540 | void tst_qquicktextedit::implicitSizeBinding_data() |
3541 | { |
3542 | implicitSize_data(); |
3543 | } |
3544 | |
3545 | void tst_qquicktextedit::implicitSizeBinding() |
3546 | { |
3547 | QFETCH(QString, text); |
3548 | QFETCH(QString, wrap); |
3549 | QFETCH(QString, format); |
3550 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + text + "\"; width: implicitWidth; height: implicitHeight; wrapMode: " + wrap + "; textFormat: " + format + " }" ; |
3551 | QQmlComponent textComponent(&engine); |
3552 | textComponent.setData(componentStr.toLatin1(), baseUrl: QUrl::fromLocalFile(localfile: "" )); |
3553 | QScopedPointer<QObject> object(textComponent.create()); |
3554 | QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit *>(object: object.data()); |
3555 | |
3556 | QCOMPARE(textObject->width(), textObject->implicitWidth()); |
3557 | QCOMPARE(textObject->height(), textObject->implicitHeight()); |
3558 | |
3559 | textObject->resetWidth(); |
3560 | QCOMPARE(textObject->width(), textObject->implicitWidth()); |
3561 | QCOMPARE(textObject->height(), textObject->implicitHeight()); |
3562 | |
3563 | textObject->resetHeight(); |
3564 | QCOMPARE(textObject->width(), textObject->implicitWidth()); |
3565 | QCOMPARE(textObject->height(), textObject->implicitHeight()); |
3566 | } |
3567 | |
3568 | void tst_qquicktextedit::signal_editingfinished() |
3569 | { |
3570 | QQuickView *window = new QQuickView(nullptr); |
3571 | window->setBaseSize(QSize(800,600)); |
3572 | |
3573 | window->setSource(testFileUrl(fileName: "signal_editingfinished.qml" )); |
3574 | window->show(); |
3575 | window->requestActivate(); |
3576 | QVERIFY(QTest::qWaitForWindowActive(window)); |
3577 | QCOMPARE(QGuiApplication::focusWindow(), window); |
3578 | |
3579 | QVERIFY(window->rootObject() != nullptr); |
3580 | |
3581 | QQuickTextEdit *input1 = qobject_cast<QQuickTextEdit *>(object: qvariant_cast<QObject *>(v: window->rootObject()->property(name: "input1" ))); |
3582 | QVERIFY(input1); |
3583 | QQuickTextEdit *input2 = qobject_cast<QQuickTextEdit *>(object: qvariant_cast<QObject *>(v: window->rootObject()->property(name: "input2" ))); |
3584 | QVERIFY(input2); |
3585 | |
3586 | QSignalSpy editingFinished1Spy(input1, SIGNAL(editingFinished())); |
3587 | |
3588 | input1->setFocus(true); |
3589 | QTRY_VERIFY(input1->hasActiveFocus()); |
3590 | QTRY_VERIFY(!input2->hasActiveFocus()); |
3591 | |
3592 | QKeyEvent key(QEvent::KeyPress, Qt::Key_Tab, Qt::ShiftModifier, "" , false, 1); |
3593 | QGuiApplication::sendEvent(receiver: window, event: &key); |
3594 | QVERIFY(key.isAccepted()); |
3595 | QTRY_COMPARE(editingFinished1Spy.count(), 1); |
3596 | |
3597 | QTRY_VERIFY(!input1->hasActiveFocus()); |
3598 | QTRY_VERIFY(input2->hasActiveFocus()); |
3599 | |
3600 | QSignalSpy editingFinished2Spy(input2, SIGNAL(editingFinished())); |
3601 | |
3602 | input2->setFocus(true); |
3603 | QTRY_VERIFY(!input1->hasActiveFocus()); |
3604 | QTRY_VERIFY(input2->hasActiveFocus()); |
3605 | |
3606 | key = QKeyEvent(QEvent::KeyPress, Qt::Key_Tab, Qt::ShiftModifier, "" , false, 1); |
3607 | QGuiApplication::sendEvent(receiver: window, event: &key); |
3608 | QVERIFY(key.isAccepted()); |
3609 | QTRY_COMPARE(editingFinished2Spy.count(), 1); |
3610 | |
3611 | QTRY_VERIFY(input1->hasActiveFocus()); |
3612 | QTRY_VERIFY(!input2->hasActiveFocus()); |
3613 | } |
3614 | |
3615 | void tst_qquicktextedit::clipRect() |
3616 | { |
3617 | QQmlComponent component(&engine); |
3618 | component.setData("import QtQuick 2.0\n TextEdit {}" , baseUrl: QUrl()); |
3619 | QScopedPointer<QObject> object(component.create()); |
3620 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: object.data()); |
3621 | QVERIFY(edit); |
3622 | |
3623 | QCOMPARE(edit->clipRect().x(), qreal(0)); |
3624 | QCOMPARE(edit->clipRect().y(), qreal(0)); |
3625 | |
3626 | QCOMPARE(edit->clipRect().width(), edit->width() + edit->cursorRectangle().width()); |
3627 | QCOMPARE(edit->clipRect().height(), edit->height()); |
3628 | |
3629 | edit->setText("Hello World" ); |
3630 | QCOMPARE(edit->clipRect().x(), qreal(0)); |
3631 | QCOMPARE(edit->clipRect().y(), qreal(0)); |
3632 | // XXX: TextEdit allows an extra 3 pixels boundary for the cursor beyond it's width for non |
3633 | // empty text. TextInput doesn't. |
3634 | QCOMPARE(edit->clipRect().width(), edit->width() + edit->cursorRectangle().width() + 3); |
3635 | QCOMPARE(edit->clipRect().height(), edit->height()); |
3636 | |
3637 | // clip rect shouldn't exceed the size of the item, expect for the cursor width; |
3638 | edit->setWidth(edit->width() / 2); |
3639 | QCOMPARE(edit->clipRect().x(), qreal(0)); |
3640 | QCOMPARE(edit->clipRect().y(), qreal(0)); |
3641 | QCOMPARE(edit->clipRect().width(), edit->width() + edit->cursorRectangle().width() + 3); |
3642 | QCOMPARE(edit->clipRect().height(), edit->height()); |
3643 | |
3644 | edit->setHeight(edit->height() * 2); |
3645 | QCOMPARE(edit->clipRect().x(), qreal(0)); |
3646 | QCOMPARE(edit->clipRect().y(), qreal(0)); |
3647 | QCOMPARE(edit->clipRect().width(), edit->width() + edit->cursorRectangle().width() + 3); |
3648 | QCOMPARE(edit->clipRect().height(), edit->height()); |
3649 | |
3650 | QQmlComponent cursorComponent(&engine); |
3651 | cursorComponent.setData("import QtQuick 2.0\nRectangle { height: 20; width: 8 }" , baseUrl: QUrl()); |
3652 | |
3653 | edit->setCursorDelegate(&cursorComponent); |
3654 | edit->setCursorVisible(true); |
3655 | |
3656 | // If a cursor delegate is used it's size should determine the excess width. |
3657 | QCOMPARE(edit->clipRect().x(), qreal(0)); |
3658 | QCOMPARE(edit->clipRect().y(), qreal(0)); |
3659 | QCOMPARE(edit->clipRect().width(), edit->width() + 8 + 3); |
3660 | QCOMPARE(edit->clipRect().height(), edit->height()); |
3661 | |
3662 | // Alignment and wrapping don't affect the clip rect. |
3663 | edit->setHAlign(QQuickTextEdit::AlignRight); |
3664 | QCOMPARE(edit->clipRect().x(), qreal(0)); |
3665 | QCOMPARE(edit->clipRect().y(), qreal(0)); |
3666 | QCOMPARE(edit->clipRect().width(), edit->width() + 8 + 3); |
3667 | QCOMPARE(edit->clipRect().height(), edit->height()); |
3668 | |
3669 | edit->setWrapMode(QQuickTextEdit::Wrap); |
3670 | QCOMPARE(edit->clipRect().x(), qreal(0)); |
3671 | QCOMPARE(edit->clipRect().y(), qreal(0)); |
3672 | QCOMPARE(edit->clipRect().width(), edit->width() + 8 + 3); |
3673 | QCOMPARE(edit->clipRect().height(), edit->height()); |
3674 | |
3675 | edit->setVAlign(QQuickTextEdit::AlignBottom); |
3676 | QCOMPARE(edit->clipRect().x(), qreal(0)); |
3677 | QCOMPARE(edit->clipRect().y(), qreal(0)); |
3678 | QCOMPARE(edit->clipRect().width(), edit->width() + 8 + 3); |
3679 | QCOMPARE(edit->clipRect().height(), edit->height()); |
3680 | } |
3681 | |
3682 | void tst_qquicktextedit::boundingRect() |
3683 | { |
3684 | QQmlComponent component(&engine); |
3685 | component.setData("import QtQuick 2.0\n TextEdit {}" , baseUrl: QUrl()); |
3686 | QScopedPointer<QObject> object(component.create()); |
3687 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: object.data()); |
3688 | QVERIFY(edit); |
3689 | |
3690 | QTextLayout layout; |
3691 | layout.setFont(edit->font()); |
3692 | |
3693 | if (!qmlDisableDistanceField()) { |
3694 | QTextOption option; |
3695 | option.setUseDesignMetrics(true); |
3696 | layout.setTextOption(option); |
3697 | } |
3698 | layout.beginLayout(); |
3699 | QTextLine line = layout.createLine(); |
3700 | layout.endLayout(); |
3701 | |
3702 | QCOMPARE(edit->boundingRect().x(), qreal(0)); |
3703 | QCOMPARE(edit->boundingRect().y(), qreal(0)); |
3704 | QCOMPARE(edit->boundingRect().width(), edit->cursorRectangle().width()); |
3705 | QCOMPARE(edit->boundingRect().height(), line.height()); |
3706 | |
3707 | edit->setText("Hello World" ); |
3708 | |
3709 | layout.setText(edit->text()); |
3710 | layout.beginLayout(); |
3711 | line = layout.createLine(); |
3712 | layout.endLayout(); |
3713 | |
3714 | QCOMPARE(edit->boundingRect().x(), qreal(0)); |
3715 | QCOMPARE(edit->boundingRect().y(), qreal(0)); |
3716 | QCOMPARE(edit->boundingRect().width(), line.naturalTextWidth() + edit->cursorRectangle().width() + 3); |
3717 | QCOMPARE(edit->boundingRect().height(), line.height()); |
3718 | |
3719 | // the size of the bounding rect shouldn't be bounded by the size of item. |
3720 | edit->setWidth(edit->width() / 2); |
3721 | QCOMPARE(edit->boundingRect().x(), qreal(0)); |
3722 | QCOMPARE(edit->boundingRect().y(), qreal(0)); |
3723 | QCOMPARE(edit->boundingRect().width(), line.naturalTextWidth() + edit->cursorRectangle().width() + 3); |
3724 | QCOMPARE(edit->boundingRect().height(), line.height()); |
3725 | |
3726 | edit->setHeight(edit->height() * 2); |
3727 | QCOMPARE(edit->boundingRect().x(), qreal(0)); |
3728 | QCOMPARE(edit->boundingRect().y(), qreal(0)); |
3729 | QCOMPARE(edit->boundingRect().width(), line.naturalTextWidth() + edit->cursorRectangle().width() + 3); |
3730 | QCOMPARE(edit->boundingRect().height(), line.height()); |
3731 | |
3732 | QQmlComponent cursorComponent(&engine); |
3733 | cursorComponent.setData("import QtQuick 2.0\nRectangle { height: 20; width: 8 }" , baseUrl: QUrl()); |
3734 | |
3735 | edit->setCursorDelegate(&cursorComponent); |
3736 | edit->setCursorVisible(true); |
3737 | |
3738 | // Don't include the size of a cursor delegate as it has its own bounding rect. |
3739 | QCOMPARE(edit->boundingRect().x(), qreal(0)); |
3740 | QCOMPARE(edit->boundingRect().y(), qreal(0)); |
3741 | QCOMPARE(edit->boundingRect().width(), line.naturalTextWidth()); |
3742 | QCOMPARE(edit->boundingRect().height(), line.height()); |
3743 | |
3744 | edit->setHAlign(QQuickTextEdit::AlignRight); |
3745 | QCOMPARE(edit->boundingRect().x(), edit->width() - line.naturalTextWidth()); |
3746 | QCOMPARE(edit->boundingRect().y(), qreal(0)); |
3747 | QCOMPARE(edit->boundingRect().width(), line.naturalTextWidth()); |
3748 | QCOMPARE(edit->boundingRect().height(), line.height()); |
3749 | |
3750 | edit->setWrapMode(QQuickTextEdit::Wrap); |
3751 | QCOMPARE(edit->boundingRect().right(), edit->width()); |
3752 | QCOMPARE(edit->boundingRect().y(), qreal(0)); |
3753 | QVERIFY(edit->boundingRect().width() < line.naturalTextWidth()); |
3754 | QVERIFY(edit->boundingRect().height() > line.height()); |
3755 | |
3756 | edit->setVAlign(QQuickTextEdit::AlignBottom); |
3757 | QCOMPARE(edit->boundingRect().right(), edit->width()); |
3758 | QCOMPARE(edit->boundingRect().bottom(), edit->height()); |
3759 | QVERIFY(edit->boundingRect().width() < line.naturalTextWidth()); |
3760 | QVERIFY(edit->boundingRect().height() > line.height()); |
3761 | } |
3762 | |
3763 | void tst_qquicktextedit::preeditCursorRectangle() |
3764 | { |
3765 | QString preeditText = "super" ; |
3766 | |
3767 | QQuickView view(testFileUrl(fileName: "inputMethodEvent.qml" )); |
3768 | view.show(); |
3769 | view.requestActivate(); |
3770 | QVERIFY(QTest::qWaitForWindowActive(&view)); |
3771 | |
3772 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: view.rootObject()); |
3773 | QVERIFY(edit); |
3774 | |
3775 | QQuickItem *cursor = edit->findChild<QQuickItem *>(aName: "cursor" ); |
3776 | QVERIFY(cursor); |
3777 | |
3778 | QSignalSpy editSpy(edit, SIGNAL(cursorRectangleChanged())); |
3779 | QSignalSpy panelSpy(qGuiApp->inputMethod(), SIGNAL(cursorRectangleChanged())); |
3780 | |
3781 | QRectF currentRect; |
3782 | |
3783 | QCOMPARE(QGuiApplication::focusObject(), static_cast<QObject *>(edit)); |
3784 | QInputMethodQueryEvent query(Qt::ImCursorRectangle); |
3785 | QCoreApplication::sendEvent(receiver: edit, event: &query); |
3786 | QRectF previousRect = query.value(query: Qt::ImCursorRectangle).toRectF(); |
3787 | |
3788 | // Verify that the micro focus rect is positioned the same for position 0 as |
3789 | // it would be if there was no preedit text. |
3790 | QInputMethodEvent imEvent(preeditText, QList<QInputMethodEvent::Attribute>() |
3791 | << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, 0, preeditText.length(), QVariant())); |
3792 | QCoreApplication::sendEvent(receiver: edit, event: &imEvent); |
3793 | QCoreApplication::sendEvent(receiver: edit, event: &query); |
3794 | currentRect = query.value(query: Qt::ImCursorRectangle).toRectF(); |
3795 | QCOMPARE(edit->cursorRectangle(), currentRect); |
3796 | QCOMPARE(cursor->position(), currentRect.topLeft()); |
3797 | QCOMPARE(currentRect, previousRect); |
3798 | |
3799 | // Verify that the micro focus rect moves to the left as the cursor position |
3800 | // is incremented. |
3801 | editSpy.clear(); |
3802 | panelSpy.clear(); |
3803 | for (int i = 1; i <= 5; ++i) { |
3804 | QInputMethodEvent imEvent(preeditText, QList<QInputMethodEvent::Attribute>() |
3805 | << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, i, preeditText.length(), QVariant())); |
3806 | QCoreApplication::sendEvent(receiver: edit, event: &imEvent); |
3807 | QCoreApplication::sendEvent(receiver: edit, event: &query); |
3808 | currentRect = query.value(query: Qt::ImCursorRectangle).toRectF(); |
3809 | QCOMPARE(edit->cursorRectangle(), currentRect); |
3810 | QCOMPARE(cursor->position(), currentRect.topLeft()); |
3811 | QVERIFY(previousRect.left() < currentRect.left()); |
3812 | QCOMPARE(editSpy.count(), 1); editSpy.clear(); |
3813 | QCOMPARE(panelSpy.count(), 1); panelSpy.clear(); |
3814 | previousRect = currentRect; |
3815 | } |
3816 | |
3817 | // Verify that if the cursor rectangle is updated if the pre-edit text changes |
3818 | // but the (non-zero) cursor position is the same. |
3819 | editSpy.clear(); |
3820 | panelSpy.clear(); |
3821 | { QInputMethodEvent imEvent("wwwww" , QList<QInputMethodEvent::Attribute>() |
3822 | << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, 5, 1, QVariant())); |
3823 | QCoreApplication::sendEvent(receiver: edit, event: &imEvent); } |
3824 | QCoreApplication::sendEvent(receiver: edit, event: &query); |
3825 | currentRect = query.value(query: Qt::ImCursorRectangle).toRectF(); |
3826 | QCOMPARE(edit->cursorRectangle(), currentRect); |
3827 | QCOMPARE(cursor->position(), currentRect.topLeft()); |
3828 | QCOMPARE(editSpy.count(), 1); |
3829 | QCOMPARE(panelSpy.count(), 1); |
3830 | |
3831 | // Verify that if there is no preedit cursor then the micro focus rect is the |
3832 | // same as it would be if it were positioned at the end of the preedit text. |
3833 | editSpy.clear(); |
3834 | panelSpy.clear(); |
3835 | { QInputMethodEvent imEvent(preeditText, QList<QInputMethodEvent::Attribute>()); |
3836 | QCoreApplication::sendEvent(receiver: edit, event: &imEvent); } |
3837 | QCoreApplication::sendEvent(receiver: edit, event: &query); |
3838 | currentRect = query.value(query: Qt::ImCursorRectangle).toRectF(); |
3839 | QCOMPARE(edit->cursorRectangle(), currentRect); |
3840 | QCOMPARE(cursor->position(), currentRect.topLeft()); |
3841 | QCOMPARE(currentRect, previousRect); |
3842 | QCOMPARE(editSpy.count(), 1); |
3843 | QCOMPARE(panelSpy.count(), 1); |
3844 | } |
3845 | |
3846 | void tst_qquicktextedit::inputMethodComposing() |
3847 | { |
3848 | QString text = "supercalifragisiticexpialidocious!" ; |
3849 | |
3850 | QQuickView view(testFileUrl(fileName: "inputContext.qml" )); |
3851 | view.show(); |
3852 | view.requestActivate(); |
3853 | QVERIFY(QTest::qWaitForWindowActive(&view)); |
3854 | |
3855 | QQuickTextEdit *edit = qobject_cast<QQuickTextEdit *>(object: view.rootObject()); |
3856 | QVERIFY(edit); |
3857 | QCOMPARE(QGuiApplication::focusObject(), static_cast<QObject *>(edit)); |
3858 | |
3859 | QSignalSpy spy(edit, SIGNAL(inputMethodComposingChanged())); |
3860 | edit->setCursorPosition(12); |
3861 | |
3862 | QCOMPARE(edit->isInputMethodComposing(), false); |
3863 | |
3864 | { |
3865 | QInputMethodEvent event(text.mid(position: 3), QList<QInputMethodEvent::Attribute>()); |
3866 | QGuiApplication::sendEvent(receiver: edit, event: &event); |
3867 | } |
3868 | |
3869 | QCOMPARE(edit->isInputMethodComposing(), true); |
3870 | QCOMPARE(spy.count(), 1); |
3871 | |
3872 | { |
3873 | QInputMethodEvent event(text.mid(position: 12), QList<QInputMethodEvent::Attribute>()); |
3874 | QGuiApplication::sendEvent(receiver: edit, event: &event); |
3875 | } |
3876 | QCOMPARE(spy.count(), 1); |
3877 | |
3878 | { |
3879 | QInputMethodEvent event; |
3880 | QGuiApplication::sendEvent(receiver: edit, event: &event); |
3881 | } |
3882 | QCOMPARE(edit->isInputMethodComposing(), false); |
3883 | QCOMPARE(spy.count(), 2); |
3884 | |
3885 | // Changing the text while not composing doesn't alter the composing state. |
3886 | edit->setText(text.mid(position: 0, n: 16)); |
3887 | QCOMPARE(edit->isInputMethodComposing(), false); |
3888 | QCOMPARE(spy.count(), 2); |
3889 | |
3890 | { |
3891 | QInputMethodEvent event(text.mid(position: 16), QList<QInputMethodEvent::Attribute>()); |
3892 | QGuiApplication::sendEvent(receiver: edit, event: &event); |
3893 | } |
3894 | QCOMPARE(edit->isInputMethodComposing(), true); |
3895 | QCOMPARE(spy.count(), 3); |
3896 | |
3897 | // Changing the text while composing cancels composition. |
3898 | edit->setText(text.mid(position: 0, n: 12)); |
3899 | QCOMPARE(edit->isInputMethodComposing(), false); |
3900 | QCOMPARE(spy.count(), 4); |
3901 | |
3902 | { // Preedit cursor positioned outside (empty) preedit; composing. |
3903 | QInputMethodEvent event(QString(), QList<QInputMethodEvent::Attribute>() |
3904 | << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, -2, 1, QVariant())); |
3905 | QGuiApplication::sendEvent(receiver: edit, event: &event); |
3906 | } |
3907 | QCOMPARE(edit->isInputMethodComposing(), true); |
3908 | QCOMPARE(spy.count(), 5); |
3909 | |
3910 | { // Cursor hidden; composing |
3911 | QInputMethodEvent event(QString(), QList<QInputMethodEvent::Attribute>() |
3912 | << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, 0, 0, QVariant())); |
3913 | QGuiApplication::sendEvent(receiver: edit, event: &event); |
3914 | } |
3915 | QCOMPARE(edit->isInputMethodComposing(), true); |
3916 | QCOMPARE(spy.count(), 5); |
3917 | |
3918 | { // Default cursor attributes; composing. |
3919 | QInputMethodEvent event(QString(), QList<QInputMethodEvent::Attribute>() |
3920 | << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, 0, 1, QVariant())); |
3921 | QGuiApplication::sendEvent(receiver: edit, event: &event); |
3922 | } |
3923 | QCOMPARE(edit->isInputMethodComposing(), true); |
3924 | QCOMPARE(spy.count(), 5); |
3925 | |
3926 | { // Selections are persisted: not composing |
3927 | QInputMethodEvent event(QString(), QList<QInputMethodEvent::Attribute>() |
3928 | << QInputMethodEvent::Attribute(QInputMethodEvent::Selection, 2, 4, QVariant())); |
3929 | QGuiApplication::sendEvent(receiver: edit, event: &event); |
3930 | } |
3931 | QCOMPARE(edit->isInputMethodComposing(), false); |
3932 | QCOMPARE(spy.count(), 6); |
3933 | |
3934 | edit->setCursorPosition(0); |
3935 | |
3936 | { // Formatting applied; composing. |
3937 | QTextCharFormat format; |
3938 | format.setUnderlineStyle(QTextCharFormat::SingleUnderline); |
3939 | QInputMethodEvent event(QString(), QList<QInputMethodEvent::Attribute>() |
3940 | << QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, 2, 4, format)); |
3941 | QGuiApplication::sendEvent(receiver: edit, event: &event); |
3942 | } |
3943 | QCOMPARE(edit->isInputMethodComposing(), true); |
3944 | QCOMPARE(spy.count(), 7); |
3945 | |
3946 | { |
3947 | QInputMethodEvent event; |
3948 | QGuiApplication::sendEvent(receiver: edit, event: &event); |
3949 | } |
3950 | QCOMPARE(edit->isInputMethodComposing(), false); |
3951 | QCOMPARE(spy.count(), 8); |
3952 | } |
3953 | |
3954 | void tst_qquicktextedit::cursorRectangleSize_data() |
3955 | { |
3956 | QTest::addColumn<bool>(name: "useCursorDelegate" ); |
3957 | |
3958 | QTest::newRow(dataTag: "default cursor" ) << false; |
3959 | QTest::newRow(dataTag: "custom cursor delegate" ) << true; |
3960 | } |
3961 | |
3962 | void tst_qquicktextedit::cursorRectangleSize() |
3963 | { |
3964 | QFETCH(bool, useCursorDelegate); |
3965 | |
3966 | QQuickView *window = new QQuickView(testFileUrl(fileName: "positionAt.qml" )); |
3967 | QVERIFY(window->rootObject() != nullptr); |
3968 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit *>(object: window->rootObject()); |
3969 | |
3970 | QQmlComponent cursorDelegate(window->engine()); |
3971 | if (useCursorDelegate) { |
3972 | cursorDelegate.setData("import QtQuick 2.0\nRectangle { width:10; height:10; }" , baseUrl: QUrl()); |
3973 | textEdit->setCursorDelegate(&cursorDelegate); |
3974 | } |
3975 | |
3976 | // make sure cursor rectangle is not at (0,0) |
3977 | textEdit->setX(10); |
3978 | textEdit->setY(10); |
3979 | textEdit->setCursorPosition(3); |
3980 | QVERIFY(textEdit != nullptr); |
3981 | textEdit->setFocus(true); |
3982 | window->show(); |
3983 | window->requestActivate(); |
3984 | QVERIFY(QTest::qWaitForWindowActive(window)); |
3985 | |
3986 | QInputMethodQueryEvent event(Qt::ImCursorRectangle); |
3987 | qApp->sendEvent(receiver: textEdit, event: &event); |
3988 | QRectF cursorRectFromQuery = event.value(query: Qt::ImCursorRectangle).toRectF(); |
3989 | |
3990 | QRectF cursorRectFromItem = textEdit->cursorRectangle(); |
3991 | QRectF cursorRectFromPositionToRectangle = textEdit->positionToRectangle(textEdit->cursorPosition()); |
3992 | |
3993 | QVERIFY(cursorRectFromItem.isValid()); |
3994 | QVERIFY(cursorRectFromQuery.isValid()); |
3995 | QVERIFY(cursorRectFromPositionToRectangle.isValid()); |
3996 | |
3997 | // item and input query cursor rectangles match |
3998 | QCOMPARE(cursorRectFromItem, cursorRectFromQuery); |
3999 | |
4000 | // item cursor rectangle and positionToRectangle calculations match |
4001 | QCOMPARE(cursorRectFromItem, cursorRectFromPositionToRectangle); |
4002 | |
4003 | // item-window transform and input item transform match |
4004 | QCOMPARE(QQuickItemPrivate::get(textEdit)->itemToWindowTransform(), qApp->inputMethod()->inputItemTransform()); |
4005 | |
4006 | // input panel cursorRectangle property and tranformed item cursor rectangle match |
4007 | QRectF sceneCursorRect = QQuickItemPrivate::get(item: textEdit)->itemToWindowTransform().mapRect(cursorRectFromItem); |
4008 | QCOMPARE(sceneCursorRect, qApp->inputMethod()->cursorRectangle()); |
4009 | |
4010 | delete window; |
4011 | } |
4012 | |
4013 | void tst_qquicktextedit::getText_data() |
4014 | { |
4015 | QTest::addColumn<QString>(name: "text" ); |
4016 | QTest::addColumn<int>(name: "start" ); |
4017 | QTest::addColumn<int>(name: "end" ); |
4018 | QTest::addColumn<QString>(name: "expectedText" ); |
4019 | |
4020 | const QString richBoldText = QStringLiteral("This is some <b>bold</b> text" ); |
4021 | const QString plainBoldText = QStringLiteral("This is some bold text" ); |
4022 | const QString richBoldTextLB = QStringLiteral("This is some<br/><b>bold</b> text" ); |
4023 | const QString plainBoldTextLB = QString(QStringLiteral("This is some\nbold text" )).replace(before: QLatin1Char('\n'), after: QChar(QChar::LineSeparator)); |
4024 | |
4025 | QTest::newRow(dataTag: "all plain text" ) |
4026 | << standard.at(i: 0) |
4027 | << 0 << standard.at(i: 0).length() |
4028 | << standard.at(i: 0); |
4029 | |
4030 | QTest::newRow(dataTag: "plain text sub string" ) |
4031 | << standard.at(i: 0) |
4032 | << 0 << 12 |
4033 | << standard.at(i: 0).mid(position: 0, n: 12); |
4034 | |
4035 | QTest::newRow(dataTag: "plain text sub string reversed" ) |
4036 | << standard.at(i: 0) |
4037 | << 12 << 0 |
4038 | << standard.at(i: 0).mid(position: 0, n: 12); |
4039 | |
4040 | QTest::newRow(dataTag: "plain text cropped beginning" ) |
4041 | << standard.at(i: 0) |
4042 | << -3 << 4 |
4043 | << standard.at(i: 0).mid(position: 0, n: 4); |
4044 | |
4045 | QTest::newRow(dataTag: "plain text cropped end" ) |
4046 | << standard.at(i: 0) |
4047 | << 23 << standard.at(i: 0).length() + 8 |
4048 | << standard.at(i: 0).mid(position: 23); |
4049 | |
4050 | QTest::newRow(dataTag: "plain text cropped beginning and end" ) |
4051 | << standard.at(i: 0) |
4052 | << -9 << standard.at(i: 0).length() + 4 |
4053 | << standard.at(i: 0); |
4054 | |
4055 | QTest::newRow(dataTag: "all rich text" ) |
4056 | << richBoldText |
4057 | << 0 << plainBoldText.length() |
4058 | << plainBoldText; |
4059 | |
4060 | QTest::newRow(dataTag: "rich text sub string" ) |
4061 | << richBoldText |
4062 | << 14 << 21 |
4063 | << plainBoldText.mid(position: 14, n: 7); |
4064 | |
4065 | // Line break. |
4066 | QTest::newRow(dataTag: "all plain text (line break)" ) |
4067 | << standard.at(i: 1) |
4068 | << 0 << standard.at(i: 1).length() |
4069 | << standard.at(i: 1); |
4070 | |
4071 | QTest::newRow(dataTag: "plain text sub string (line break)" ) |
4072 | << standard.at(i: 1) |
4073 | << 0 << 12 |
4074 | << standard.at(i: 1).mid(position: 0, n: 12); |
4075 | |
4076 | QTest::newRow(dataTag: "plain text sub string reversed (line break)" ) |
4077 | << standard.at(i: 1) |
4078 | << 12 << 0 |
4079 | << standard.at(i: 1).mid(position: 0, n: 12); |
4080 | |
4081 | QTest::newRow(dataTag: "plain text cropped beginning (line break)" ) |
4082 | << standard.at(i: 1) |
4083 | << -3 << 4 |
4084 | << standard.at(i: 1).mid(position: 0, n: 4); |
4085 | |
4086 | QTest::newRow(dataTag: "plain text cropped end (line break)" ) |
4087 | << standard.at(i: 1) |
4088 | << 23 << standard.at(i: 1).length() + 8 |
4089 | << standard.at(i: 1).mid(position: 23); |
4090 | |
4091 | QTest::newRow(dataTag: "plain text cropped beginning and end (line break)" ) |
4092 | << standard.at(i: 1) |
4093 | << -9 << standard.at(i: 1).length() + 4 |
4094 | << standard.at(i: 1); |
4095 | |
4096 | QTest::newRow(dataTag: "all rich text (line break)" ) |
4097 | << richBoldTextLB |
4098 | << 0 << plainBoldTextLB.length() |
4099 | << plainBoldTextLB; |
4100 | |
4101 | QTest::newRow(dataTag: "rich text sub string (line break)" ) |
4102 | << richBoldTextLB |
4103 | << 14 << 21 |
4104 | << plainBoldTextLB.mid(position: 14, n: 7); |
4105 | } |
4106 | |
4107 | void tst_qquicktextedit::getText() |
4108 | { |
4109 | QFETCH(QString, text); |
4110 | QFETCH(int, start); |
4111 | QFETCH(int, end); |
4112 | QFETCH(QString, expectedText); |
4113 | |
4114 | QString componentStr = "import QtQuick 2.0\nTextEdit { textFormat: TextEdit.AutoText; text: \"" + text + "\" }" ; |
4115 | QQmlComponent textEditComponent(&engine); |
4116 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
4117 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
4118 | QVERIFY(textEdit != nullptr); |
4119 | |
4120 | QCOMPARE(textEdit->getText(start, end), expectedText); |
4121 | } |
4122 | |
4123 | void tst_qquicktextedit::getFormattedText_data() |
4124 | { |
4125 | QTest::addColumn<QString>(name: "text" ); |
4126 | QTest::addColumn<QQuickTextEdit::TextFormat>(name: "textFormat" ); |
4127 | QTest::addColumn<int>(name: "start" ); |
4128 | QTest::addColumn<int>(name: "end" ); |
4129 | QTest::addColumn<QString>(name: "expectedText" ); |
4130 | |
4131 | const QString richBoldText = QStringLiteral("This is some <b>bold</b> text" ); |
4132 | const QString plainBoldText = QStringLiteral("This is some bold text" ); |
4133 | |
4134 | QTest::newRow(dataTag: "all plain text" ) |
4135 | << standard.at(i: 0) |
4136 | << QQuickTextEdit::PlainText |
4137 | << 0 << standard.at(i: 0).length() |
4138 | << standard.at(i: 0); |
4139 | |
4140 | QTest::newRow(dataTag: "plain text sub string" ) |
4141 | << standard.at(i: 0) |
4142 | << QQuickTextEdit::PlainText |
4143 | << 0 << 12 |
4144 | << standard.at(i: 0).mid(position: 0, n: 12); |
4145 | |
4146 | QTest::newRow(dataTag: "plain text sub string reversed" ) |
4147 | << standard.at(i: 0) |
4148 | << QQuickTextEdit::PlainText |
4149 | << 12 << 0 |
4150 | << standard.at(i: 0).mid(position: 0, n: 12); |
4151 | |
4152 | QTest::newRow(dataTag: "plain text cropped beginning" ) |
4153 | << standard.at(i: 0) |
4154 | << QQuickTextEdit::PlainText |
4155 | << -3 << 4 |
4156 | << standard.at(i: 0).mid(position: 0, n: 4); |
4157 | |
4158 | QTest::newRow(dataTag: "plain text cropped end" ) |
4159 | << standard.at(i: 0) |
4160 | << QQuickTextEdit::PlainText |
4161 | << 23 << standard.at(i: 0).length() + 8 |
4162 | << standard.at(i: 0).mid(position: 23); |
4163 | |
4164 | QTest::newRow(dataTag: "plain text cropped beginning and end" ) |
4165 | << standard.at(i: 0) |
4166 | << QQuickTextEdit::PlainText |
4167 | << -9 << standard.at(i: 0).length() + 4 |
4168 | << standard.at(i: 0); |
4169 | |
4170 | QTest::newRow(dataTag: "all rich (Auto) text" ) |
4171 | << richBoldText |
4172 | << QQuickTextEdit::AutoText |
4173 | << 0 << plainBoldText.length() |
4174 | << QString("This is some \\<.*\\>bold\\</.*\\> text" ); |
4175 | |
4176 | QTest::newRow(dataTag: "all rich (Rich) text" ) |
4177 | << richBoldText |
4178 | << QQuickTextEdit::RichText |
4179 | << 0 << plainBoldText.length() |
4180 | << QString("This is some \\<.*\\>bold\\</.*\\> text" ); |
4181 | |
4182 | QTest::newRow(dataTag: "all rich (Plain) text" ) |
4183 | << richBoldText |
4184 | << QQuickTextEdit::PlainText |
4185 | << 0 << richBoldText.length() |
4186 | << richBoldText; |
4187 | |
4188 | QTest::newRow(dataTag: "rich (Auto) text sub string" ) |
4189 | << richBoldText |
4190 | << QQuickTextEdit::AutoText |
4191 | << 14 << 21 |
4192 | << QString("\\<.*\\>old\\</.*\\> tex" ); |
4193 | |
4194 | QTest::newRow(dataTag: "rich (Rich) text sub string" ) |
4195 | << richBoldText |
4196 | << QQuickTextEdit::RichText |
4197 | << 14 << 21 |
4198 | << QString("\\<.*\\>old\\</.*\\> tex" ); |
4199 | |
4200 | QTest::newRow(dataTag: "rich (Plain) text sub string" ) |
4201 | << richBoldText |
4202 | << QQuickTextEdit::PlainText |
4203 | << 17 << 27 |
4204 | << richBoldText.mid(position: 17, n: 10); |
4205 | } |
4206 | |
4207 | void tst_qquicktextedit::getFormattedText() |
4208 | { |
4209 | QFETCH(QString, text); |
4210 | QFETCH(QQuickTextEdit::TextFormat, textFormat); |
4211 | QFETCH(int, start); |
4212 | QFETCH(int, end); |
4213 | QFETCH(QString, expectedText); |
4214 | |
4215 | QString componentStr = "import QtQuick 2.0\nTextEdit {}" ; |
4216 | QQmlComponent textEditComponent(&engine); |
4217 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
4218 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
4219 | QVERIFY(textEdit != nullptr); |
4220 | |
4221 | textEdit->setTextFormat(textFormat); |
4222 | textEdit->setText(text); |
4223 | |
4224 | if (textFormat == QQuickTextEdit::RichText |
4225 | || (textFormat == QQuickTextEdit::AutoText && Qt::mightBeRichText(text))) { |
4226 | QVERIFY(textEdit->getFormattedText(start, end).contains(QRegExp(expectedText))); |
4227 | } else { |
4228 | QCOMPARE(textEdit->getFormattedText(start, end), expectedText); |
4229 | } |
4230 | } |
4231 | |
4232 | void tst_qquicktextedit::append_data() |
4233 | { |
4234 | QTest::addColumn<QString>(name: "text" ); |
4235 | QTest::addColumn<QQuickTextEdit::TextFormat>(name: "textFormat" ); |
4236 | QTest::addColumn<int>(name: "selectionStart" ); |
4237 | QTest::addColumn<int>(name: "selectionEnd" ); |
4238 | QTest::addColumn<QString>(name: "appendText" ); |
4239 | QTest::addColumn<QString>(name: "expectedText" ); |
4240 | QTest::addColumn<int>(name: "expectedSelectionStart" ); |
4241 | QTest::addColumn<int>(name: "expectedSelectionEnd" ); |
4242 | QTest::addColumn<int>(name: "expectedCursorPosition" ); |
4243 | QTest::addColumn<bool>(name: "selectionChanged" ); |
4244 | QTest::addColumn<bool>(name: "cursorPositionChanged" ); |
4245 | |
4246 | QTest::newRow(dataTag: "cursor kept intact (beginning)" ) |
4247 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4248 | << 0 << 0 |
4249 | << QString("Hello" ) |
4250 | << standard.at(i: 0) + QString("\nHello" ) |
4251 | << 0 << 0 << 0 |
4252 | << false << false; |
4253 | |
4254 | QTest::newRow(dataTag: "cursor kept intact (middle)" ) |
4255 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4256 | << 18 << 18 |
4257 | << QString("Hello" ) |
4258 | << standard.at(i: 0) + QString("\nHello" ) |
4259 | << 18 << 18 << 18 |
4260 | << false << false; |
4261 | |
4262 | QTest::newRow(dataTag: "cursor follows (end)" ) |
4263 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4264 | << standard.at(i: 0).length() << standard.at(i: 0).length() |
4265 | << QString("Hello" ) |
4266 | << standard.at(i: 0) + QString("\nHello" ) |
4267 | << standard.at(i: 0).length() + 6 << standard.at(i: 0).length() + 6 << standard.at(i: 0).length() + 6 |
4268 | << false << true; |
4269 | |
4270 | QTest::newRow(dataTag: "selection kept intact (beginning)" ) |
4271 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4272 | << 0 << 18 |
4273 | << QString("Hello" ) |
4274 | << standard.at(i: 0) + QString("\nHello" ) |
4275 | << 0 << 18 << 18 |
4276 | << false << false; |
4277 | |
4278 | QTest::newRow(dataTag: "selection kept intact (middle)" ) |
4279 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4280 | << 14 << 18 |
4281 | << QString("Hello" ) |
4282 | << standard.at(i: 0) + QString("\nHello" ) |
4283 | << 14 << 18 << 18 |
4284 | << false << false; |
4285 | |
4286 | QTest::newRow(dataTag: "selection kept intact, cursor follows (end)" ) |
4287 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4288 | << 18 << standard.at(i: 0).length() |
4289 | << QString("Hello" ) |
4290 | << standard.at(i: 0) + QString("\nHello" ) |
4291 | << 18 << standard.at(i: 0).length() + 6 << standard.at(i: 0).length() + 6 |
4292 | << true << true; |
4293 | |
4294 | QTest::newRow(dataTag: "reversed selection kept intact" ) |
4295 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4296 | << 18 << 14 |
4297 | << QString("Hello" ) |
4298 | << standard.at(i: 0) + QString("\nHello" ) |
4299 | << 14 << 18 << 14 |
4300 | << false << false; |
4301 | |
4302 | QTest::newRow(dataTag: "rich text into plain text" ) |
4303 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4304 | << 0 << 0 |
4305 | << QString("<b>Hello</b>" ) |
4306 | << standard.at(i: 0) + QString("\n<b>Hello</b>" ) |
4307 | << 0 << 0 << 0 |
4308 | << false << false; |
4309 | |
4310 | QTest::newRow(dataTag: "rich text into rich text" ) |
4311 | << standard.at(i: 0) << QQuickTextEdit::RichText |
4312 | << 0 << 0 |
4313 | << QString("<b>Hello</b>" ) |
4314 | << standard.at(i: 0) + QChar(QChar::ParagraphSeparator) + QString("Hello" ) |
4315 | << 0 << 0 << 0 |
4316 | << false << false; |
4317 | |
4318 | QTest::newRow(dataTag: "rich text into auto text" ) |
4319 | << standard.at(i: 0) << QQuickTextEdit::AutoText |
4320 | << 0 << 0 |
4321 | << QString("<b>Hello</b>" ) |
4322 | << standard.at(i: 0) + QString("\nHello" ) |
4323 | << 0 << 0 << 0 |
4324 | << false << false; |
4325 | } |
4326 | |
4327 | void tst_qquicktextedit::append() |
4328 | { |
4329 | QFETCH(QString, text); |
4330 | QFETCH(QQuickTextEdit::TextFormat, textFormat); |
4331 | QFETCH(int, selectionStart); |
4332 | QFETCH(int, selectionEnd); |
4333 | QFETCH(QString, appendText); |
4334 | QFETCH(QString, expectedText); |
4335 | QFETCH(int, expectedSelectionStart); |
4336 | QFETCH(int, expectedSelectionEnd); |
4337 | QFETCH(int, expectedCursorPosition); |
4338 | QFETCH(bool, selectionChanged); |
4339 | QFETCH(bool, cursorPositionChanged); |
4340 | |
4341 | QString componentStr = "import QtQuick 2.2\nTextEdit { text: \"" + text + "\" }" ; |
4342 | QQmlComponent textEditComponent(&engine); |
4343 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
4344 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
4345 | QVERIFY(textEdit != nullptr); |
4346 | |
4347 | textEdit->setTextFormat(textFormat); |
4348 | textEdit->select(start: selectionStart, end: selectionEnd); |
4349 | |
4350 | QSignalSpy selectionSpy(textEdit, SIGNAL(selectedTextChanged())); |
4351 | QSignalSpy selectionStartSpy(textEdit, SIGNAL(selectionStartChanged())); |
4352 | QSignalSpy selectionEndSpy(textEdit, SIGNAL(selectionEndChanged())); |
4353 | QSignalSpy textSpy(textEdit, SIGNAL(textChanged())); |
4354 | QSignalSpy cursorPositionSpy(textEdit, SIGNAL(cursorPositionChanged())); |
4355 | |
4356 | textEdit->append(text: appendText); |
4357 | |
4358 | if (textFormat == QQuickTextEdit::RichText || (textFormat == QQuickTextEdit::AutoText && ( |
4359 | Qt::mightBeRichText(text) || Qt::mightBeRichText(appendText)))) { |
4360 | QCOMPARE(textEdit->getText(0, expectedText.length()), expectedText); |
4361 | } else { |
4362 | QCOMPARE(textEdit->text(), expectedText); |
4363 | |
4364 | } |
4365 | QCOMPARE(textEdit->length(), expectedText.length()); |
4366 | |
4367 | QCOMPARE(textEdit->selectionStart(), expectedSelectionStart); |
4368 | QCOMPARE(textEdit->selectionEnd(), expectedSelectionEnd); |
4369 | QCOMPARE(textEdit->cursorPosition(), expectedCursorPosition); |
4370 | |
4371 | if (selectionStart > selectionEnd) |
4372 | qSwap(value1&: selectionStart, value2&: selectionEnd); |
4373 | |
4374 | QCOMPARE(selectionSpy.count() > 0, selectionChanged); |
4375 | QCOMPARE(selectionStartSpy.count() > 0, selectionStart != expectedSelectionStart); |
4376 | QCOMPARE(selectionEndSpy.count() > 0, selectionEnd != expectedSelectionEnd); |
4377 | QCOMPARE(textSpy.count() > 0, text != expectedText); |
4378 | QCOMPARE(cursorPositionSpy.count() > 0, cursorPositionChanged); |
4379 | } |
4380 | |
4381 | void tst_qquicktextedit::insert_data() |
4382 | { |
4383 | QTest::addColumn<QString>(name: "text" ); |
4384 | QTest::addColumn<QQuickTextEdit::TextFormat>(name: "textFormat" ); |
4385 | QTest::addColumn<int>(name: "selectionStart" ); |
4386 | QTest::addColumn<int>(name: "selectionEnd" ); |
4387 | QTest::addColumn<int>(name: "insertPosition" ); |
4388 | QTest::addColumn<QString>(name: "insertText" ); |
4389 | QTest::addColumn<QString>(name: "expectedText" ); |
4390 | QTest::addColumn<int>(name: "expectedSelectionStart" ); |
4391 | QTest::addColumn<int>(name: "expectedSelectionEnd" ); |
4392 | QTest::addColumn<int>(name: "expectedCursorPosition" ); |
4393 | QTest::addColumn<bool>(name: "selectionChanged" ); |
4394 | QTest::addColumn<bool>(name: "cursorPositionChanged" ); |
4395 | |
4396 | QTest::newRow(dataTag: "at cursor position (beginning)" ) |
4397 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4398 | << 0 << 0 << 0 |
4399 | << QString("Hello" ) |
4400 | << QString("Hello" ) + standard.at(i: 0) |
4401 | << 5 << 5 << 5 |
4402 | << false << true; |
4403 | |
4404 | QTest::newRow(dataTag: "at cursor position (end)" ) |
4405 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4406 | << standard.at(i: 0).length() << standard.at(i: 0).length() << standard.at(i: 0).length() |
4407 | << QString("Hello" ) |
4408 | << standard.at(i: 0) + QString("Hello" ) |
4409 | << standard.at(i: 0).length() + 5 << standard.at(i: 0).length() + 5 << standard.at(i: 0).length() + 5 |
4410 | << false << true; |
4411 | |
4412 | QTest::newRow(dataTag: "at cursor position (middle)" ) |
4413 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4414 | << 18 << 18 << 18 |
4415 | << QString("Hello" ) |
4416 | << standard.at(i: 0).mid(position: 0, n: 18) + QString("Hello" ) + standard.at(i: 0).mid(position: 18) |
4417 | << 23 << 23 << 23 |
4418 | << false << true; |
4419 | |
4420 | QTest::newRow(dataTag: "after cursor position (beginning)" ) |
4421 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4422 | << 0 << 0 << 18 |
4423 | << QString("Hello" ) |
4424 | << standard.at(i: 0).mid(position: 0, n: 18) + QString("Hello" ) + standard.at(i: 0).mid(position: 18) |
4425 | << 0 << 0 << 0 |
4426 | << false << false; |
4427 | |
4428 | QTest::newRow(dataTag: "before cursor position (end)" ) |
4429 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4430 | << standard.at(i: 0).length() << standard.at(i: 0).length() << 18 |
4431 | << QString("Hello" ) |
4432 | << standard.at(i: 0).mid(position: 0, n: 18) + QString("Hello" ) + standard.at(i: 0).mid(position: 18) |
4433 | << standard.at(i: 0).length() + 5 << standard.at(i: 0).length() + 5 << standard.at(i: 0).length() + 5 |
4434 | << false << true; |
4435 | |
4436 | QTest::newRow(dataTag: "before cursor position (middle)" ) |
4437 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4438 | << 18 << 18 << 0 |
4439 | << QString("Hello" ) |
4440 | << QString("Hello" ) + standard.at(i: 0) |
4441 | << 23 << 23 << 23 |
4442 | << false << true; |
4443 | |
4444 | QTest::newRow(dataTag: "after cursor position (middle)" ) |
4445 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4446 | << 18 << 18 << standard.at(i: 0).length() |
4447 | << QString("Hello" ) |
4448 | << standard.at(i: 0) + QString("Hello" ) |
4449 | << 18 << 18 << 18 |
4450 | << false << false; |
4451 | |
4452 | QTest::newRow(dataTag: "before selection" ) |
4453 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4454 | << 14 << 19 << 0 |
4455 | << QString("Hello" ) |
4456 | << QString("Hello" ) + standard.at(i: 0) |
4457 | << 19 << 24 << 24 |
4458 | << true << true; |
4459 | |
4460 | QTest::newRow(dataTag: "before reversed selection" ) |
4461 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4462 | << 19 << 14 << 0 |
4463 | << QString("Hello" ) |
4464 | << QString("Hello" ) + standard.at(i: 0) |
4465 | << 19 << 24 << 19 |
4466 | << true << true; |
4467 | |
4468 | QTest::newRow(dataTag: "after selection" ) |
4469 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4470 | << 14 << 19 << standard.at(i: 0).length() |
4471 | << QString("Hello" ) |
4472 | << standard.at(i: 0) + QString("Hello" ) |
4473 | << 14 << 19 << 19 |
4474 | << false << false; |
4475 | |
4476 | QTest::newRow(dataTag: "after reversed selection" ) |
4477 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4478 | << 19 << 14 << standard.at(i: 0).length() |
4479 | << QString("Hello" ) |
4480 | << standard.at(i: 0) + QString("Hello" ) |
4481 | << 14 << 19 << 14 |
4482 | << false << false; |
4483 | |
4484 | QTest::newRow(dataTag: "into selection" ) |
4485 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4486 | << 14 << 19 << 18 |
4487 | << QString("Hello" ) |
4488 | << standard.at(i: 0).mid(position: 0, n: 18) + QString("Hello" ) + standard.at(i: 0).mid(position: 18) |
4489 | << 14 << 24 << 24 |
4490 | << true << true; |
4491 | |
4492 | QTest::newRow(dataTag: "into reversed selection" ) |
4493 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4494 | << 19 << 14 << 18 |
4495 | << QString("Hello" ) |
4496 | << standard.at(i: 0).mid(position: 0, n: 18) + QString("Hello" ) + standard.at(i: 0).mid(position: 18) |
4497 | << 14 << 24 << 14 |
4498 | << true << false; |
4499 | |
4500 | QTest::newRow(dataTag: "rich text into plain text" ) |
4501 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4502 | << 0 << 0 << 0 |
4503 | << QString("<b>Hello</b>" ) |
4504 | << QString("<b>Hello</b>" ) + standard.at(i: 0) |
4505 | << 12 << 12 << 12 |
4506 | << false << true; |
4507 | |
4508 | QTest::newRow(dataTag: "rich text into rich text" ) |
4509 | << standard.at(i: 0) << QQuickTextEdit::RichText |
4510 | << 0 << 0 << 0 |
4511 | << QString("<b>Hello</b>" ) |
4512 | << QString("Hello" ) + standard.at(i: 0) |
4513 | << 5 << 5 << 5 |
4514 | << false << true; |
4515 | |
4516 | QTest::newRow(dataTag: "rich text into auto text" ) |
4517 | << standard.at(i: 0) << QQuickTextEdit::AutoText |
4518 | << 0 << 0 << 0 |
4519 | << QString("<b>Hello</b>" ) |
4520 | << QString("Hello" ) + standard.at(i: 0) |
4521 | << 5 << 5 << 5 |
4522 | << false << true; |
4523 | |
4524 | QTest::newRow(dataTag: "before start" ) |
4525 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4526 | << 0 << 0 << -3 |
4527 | << QString("Hello" ) |
4528 | << standard.at(i: 0) |
4529 | << 0 << 0 << 0 |
4530 | << false << false; |
4531 | |
4532 | QTest::newRow(dataTag: "past end" ) |
4533 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4534 | << 0 << 0 << standard.at(i: 0).length() + 3 |
4535 | << QString("Hello" ) |
4536 | << standard.at(i: 0) |
4537 | << 0 << 0 << 0 |
4538 | << false << false; |
4539 | } |
4540 | |
4541 | void tst_qquicktextedit::insert() |
4542 | { |
4543 | QFETCH(QString, text); |
4544 | QFETCH(QQuickTextEdit::TextFormat, textFormat); |
4545 | QFETCH(int, selectionStart); |
4546 | QFETCH(int, selectionEnd); |
4547 | QFETCH(int, insertPosition); |
4548 | QFETCH(QString, insertText); |
4549 | QFETCH(QString, expectedText); |
4550 | QFETCH(int, expectedSelectionStart); |
4551 | QFETCH(int, expectedSelectionEnd); |
4552 | QFETCH(int, expectedCursorPosition); |
4553 | QFETCH(bool, selectionChanged); |
4554 | QFETCH(bool, cursorPositionChanged); |
4555 | |
4556 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + text + "\" }" ; |
4557 | QQmlComponent textEditComponent(&engine); |
4558 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
4559 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
4560 | QVERIFY(textEdit != nullptr); |
4561 | |
4562 | textEdit->setTextFormat(textFormat); |
4563 | textEdit->select(start: selectionStart, end: selectionEnd); |
4564 | |
4565 | QSignalSpy selectionSpy(textEdit, SIGNAL(selectedTextChanged())); |
4566 | QSignalSpy selectionStartSpy(textEdit, SIGNAL(selectionStartChanged())); |
4567 | QSignalSpy selectionEndSpy(textEdit, SIGNAL(selectionEndChanged())); |
4568 | QSignalSpy textSpy(textEdit, SIGNAL(textChanged())); |
4569 | QSignalSpy cursorPositionSpy(textEdit, SIGNAL(cursorPositionChanged())); |
4570 | |
4571 | textEdit->insert(position: insertPosition, text: insertText); |
4572 | |
4573 | if (textFormat == QQuickTextEdit::RichText || (textFormat == QQuickTextEdit::AutoText && ( |
4574 | Qt::mightBeRichText(text) || Qt::mightBeRichText(insertText)))) { |
4575 | QCOMPARE(textEdit->getText(0, expectedText.length()), expectedText); |
4576 | } else { |
4577 | QCOMPARE(textEdit->text(), expectedText); |
4578 | |
4579 | } |
4580 | QCOMPARE(textEdit->length(), expectedText.length()); |
4581 | |
4582 | QCOMPARE(textEdit->selectionStart(), expectedSelectionStart); |
4583 | QCOMPARE(textEdit->selectionEnd(), expectedSelectionEnd); |
4584 | QCOMPARE(textEdit->cursorPosition(), expectedCursorPosition); |
4585 | |
4586 | if (selectionStart > selectionEnd) |
4587 | qSwap(value1&: selectionStart, value2&: selectionEnd); |
4588 | |
4589 | QCOMPARE(selectionSpy.count() > 0, selectionChanged); |
4590 | QCOMPARE(selectionStartSpy.count() > 0, selectionStart != expectedSelectionStart); |
4591 | QCOMPARE(selectionEndSpy.count() > 0, selectionEnd != expectedSelectionEnd); |
4592 | QCOMPARE(textSpy.count() > 0, text != expectedText); |
4593 | QCOMPARE(cursorPositionSpy.count() > 0, cursorPositionChanged); |
4594 | } |
4595 | |
4596 | void tst_qquicktextedit::remove_data() |
4597 | { |
4598 | QTest::addColumn<QString>(name: "text" ); |
4599 | QTest::addColumn<QQuickTextEdit::TextFormat>(name: "textFormat" ); |
4600 | QTest::addColumn<int>(name: "selectionStart" ); |
4601 | QTest::addColumn<int>(name: "selectionEnd" ); |
4602 | QTest::addColumn<int>(name: "removeStart" ); |
4603 | QTest::addColumn<int>(name: "removeEnd" ); |
4604 | QTest::addColumn<QString>(name: "expectedText" ); |
4605 | QTest::addColumn<int>(name: "expectedSelectionStart" ); |
4606 | QTest::addColumn<int>(name: "expectedSelectionEnd" ); |
4607 | QTest::addColumn<int>(name: "expectedCursorPosition" ); |
4608 | QTest::addColumn<bool>(name: "selectionChanged" ); |
4609 | QTest::addColumn<bool>(name: "cursorPositionChanged" ); |
4610 | |
4611 | const QString richBoldText = QStringLiteral("This is some <b>bold</b> text" ); |
4612 | const QString plainBoldText = QStringLiteral("This is some bold text" ); |
4613 | |
4614 | QTest::newRow(dataTag: "from cursor position (beginning)" ) |
4615 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4616 | << 0 << 0 |
4617 | << 0 << 5 |
4618 | << standard.at(i: 0).mid(position: 5) |
4619 | << 0 << 0 << 0 |
4620 | << false << false; |
4621 | |
4622 | QTest::newRow(dataTag: "to cursor position (beginning)" ) |
4623 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4624 | << 0 << 0 |
4625 | << 5 << 0 |
4626 | << standard.at(i: 0).mid(position: 5) |
4627 | << 0 << 0 << 0 |
4628 | << false << false; |
4629 | |
4630 | QTest::newRow(dataTag: "to cursor position (end)" ) |
4631 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4632 | << standard.at(i: 0).length() << standard.at(i: 0).length() |
4633 | << standard.at(i: 0).length() << standard.at(i: 0).length() - 5 |
4634 | << standard.at(i: 0).mid(position: 0, n: standard.at(i: 0).length() - 5) |
4635 | << standard.at(i: 0).length() - 5 << standard.at(i: 0).length() - 5 << standard.at(i: 0).length() - 5 |
4636 | << false << true; |
4637 | |
4638 | QTest::newRow(dataTag: "to cursor position (end)" ) |
4639 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4640 | << standard.at(i: 0).length() << standard.at(i: 0).length() |
4641 | << standard.at(i: 0).length() - 5 << standard.at(i: 0).length() |
4642 | << standard.at(i: 0).mid(position: 0, n: standard.at(i: 0).length() - 5) |
4643 | << standard.at(i: 0).length() - 5 << standard.at(i: 0).length() - 5 << standard.at(i: 0).length() - 5 |
4644 | << false << true; |
4645 | |
4646 | QTest::newRow(dataTag: "from cursor position (middle)" ) |
4647 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4648 | << 18 << 18 |
4649 | << 18 << 23 |
4650 | << standard.at(i: 0).mid(position: 0, n: 18) + standard.at(i: 0).mid(position: 23) |
4651 | << 18 << 18 << 18 |
4652 | << false << false; |
4653 | |
4654 | QTest::newRow(dataTag: "to cursor position (middle)" ) |
4655 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4656 | << 23 << 23 |
4657 | << 18 << 23 |
4658 | << standard.at(i: 0).mid(position: 0, n: 18) + standard.at(i: 0).mid(position: 23) |
4659 | << 18 << 18 << 18 |
4660 | << false << true; |
4661 | |
4662 | QTest::newRow(dataTag: "after cursor position (beginning)" ) |
4663 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4664 | << 0 << 0 |
4665 | << 18 << 23 |
4666 | << standard.at(i: 0).mid(position: 0, n: 18) + standard.at(i: 0).mid(position: 23) |
4667 | << 0 << 0 << 0 |
4668 | << false << false; |
4669 | |
4670 | QTest::newRow(dataTag: "before cursor position (end)" ) |
4671 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4672 | << standard.at(i: 0).length() << standard.at(i: 0).length() |
4673 | << 18 << 23 |
4674 | << standard.at(i: 0).mid(position: 0, n: 18) + standard.at(i: 0).mid(position: 23) |
4675 | << standard.at(i: 0).length() - 5 << standard.at(i: 0).length() - 5 << standard.at(i: 0).length() - 5 |
4676 | << false << true; |
4677 | |
4678 | QTest::newRow(dataTag: "before cursor position (middle)" ) |
4679 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4680 | << 23 << 23 |
4681 | << 0 << 5 |
4682 | << standard.at(i: 0).mid(position: 5) |
4683 | << 18 << 18 << 18 |
4684 | << false << true; |
4685 | |
4686 | QTest::newRow(dataTag: "after cursor position (middle)" ) |
4687 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4688 | << 18 << 18 |
4689 | << 18 << 23 |
4690 | << standard.at(i: 0).mid(position: 0, n: 18) + standard.at(i: 0).mid(position: 23) |
4691 | << 18 << 18 << 18 |
4692 | << false << false; |
4693 | |
4694 | QTest::newRow(dataTag: "before selection" ) |
4695 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4696 | << 14 << 19 |
4697 | << 0 << 5 |
4698 | << standard.at(i: 0).mid(position: 5) |
4699 | << 9 << 14 << 14 |
4700 | << true << true; |
4701 | |
4702 | QTest::newRow(dataTag: "before reversed selection" ) |
4703 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4704 | << 19 << 14 |
4705 | << 0 << 5 |
4706 | << standard.at(i: 0).mid(position: 5) |
4707 | << 9 << 14 << 9 |
4708 | << true << true; |
4709 | |
4710 | QTest::newRow(dataTag: "after selection" ) |
4711 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4712 | << 14 << 19 |
4713 | << standard.at(i: 0).length() - 5 << standard.at(i: 0).length() |
4714 | << standard.at(i: 0).mid(position: 0, n: standard.at(i: 0).length() - 5) |
4715 | << 14 << 19 << 19 |
4716 | << false << false; |
4717 | |
4718 | QTest::newRow(dataTag: "after reversed selection" ) |
4719 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4720 | << 19 << 14 |
4721 | << standard.at(i: 0).length() - 5 << standard.at(i: 0).length() |
4722 | << standard.at(i: 0).mid(position: 0, n: standard.at(i: 0).length() - 5) |
4723 | << 14 << 19 << 14 |
4724 | << false << false; |
4725 | |
4726 | QTest::newRow(dataTag: "from selection" ) |
4727 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4728 | << 14 << 24 |
4729 | << 18 << 23 |
4730 | << standard.at(i: 0).mid(position: 0, n: 18) + standard.at(i: 0).mid(position: 23) |
4731 | << 14 << 19 << 19 |
4732 | << true << true; |
4733 | |
4734 | QTest::newRow(dataTag: "from reversed selection" ) |
4735 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4736 | << 24 << 14 |
4737 | << 18 << 23 |
4738 | << standard.at(i: 0).mid(position: 0, n: 18) + standard.at(i: 0).mid(position: 23) |
4739 | << 14 << 19 << 14 |
4740 | << true << false; |
4741 | |
4742 | QTest::newRow(dataTag: "plain text cropped beginning" ) |
4743 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4744 | << 0 << 0 |
4745 | << -3 << 4 |
4746 | << standard.at(i: 0).mid(position: 4) |
4747 | << 0 << 0 << 0 |
4748 | << false << false; |
4749 | |
4750 | QTest::newRow(dataTag: "plain text cropped end" ) |
4751 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4752 | << 0 << 0 |
4753 | << 23 << standard.at(i: 0).length() + 8 |
4754 | << standard.at(i: 0).mid(position: 0, n: 23) |
4755 | << 0 << 0 << 0 |
4756 | << false << false; |
4757 | |
4758 | QTest::newRow(dataTag: "plain text cropped beginning and end" ) |
4759 | << standard.at(i: 0) << QQuickTextEdit::PlainText |
4760 | << 0 << 0 |
4761 | << -9 << standard.at(i: 0).length() + 4 |
4762 | << QString() |
4763 | << 0 << 0 << 0 |
4764 | << false << false; |
4765 | |
4766 | QTest::newRow(dataTag: "all rich text" ) |
4767 | << richBoldText << QQuickTextEdit::RichText |
4768 | << 0 << 0 |
4769 | << 0 << plainBoldText.length() |
4770 | << QString() |
4771 | << 0 << 0 << 0 |
4772 | << false << false; |
4773 | |
4774 | QTest::newRow(dataTag: "rick text sub string" ) |
4775 | << richBoldText << QQuickTextEdit::RichText |
4776 | << 0 << 0 |
4777 | << 14 << 21 |
4778 | << plainBoldText.mid(position: 0, n: 14) + plainBoldText.mid(position: 21) |
4779 | << 0 << 0 << 0 |
4780 | << false << false; |
4781 | } |
4782 | |
4783 | void tst_qquicktextedit::remove() |
4784 | { |
4785 | QFETCH(QString, text); |
4786 | QFETCH(QQuickTextEdit::TextFormat, textFormat); |
4787 | QFETCH(int, selectionStart); |
4788 | QFETCH(int, selectionEnd); |
4789 | QFETCH(int, removeStart); |
4790 | QFETCH(int, removeEnd); |
4791 | QFETCH(QString, expectedText); |
4792 | QFETCH(int, expectedSelectionStart); |
4793 | QFETCH(int, expectedSelectionEnd); |
4794 | QFETCH(int, expectedCursorPosition); |
4795 | QFETCH(bool, selectionChanged); |
4796 | QFETCH(bool, cursorPositionChanged); |
4797 | |
4798 | QString componentStr = "import QtQuick 2.0\nTextEdit { text: \"" + text + "\" }" ; |
4799 | QQmlComponent textEditComponent(&engine); |
4800 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
4801 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
4802 | QVERIFY(textEdit != nullptr); |
4803 | |
4804 | textEdit->setTextFormat(textFormat); |
4805 | textEdit->select(start: selectionStart, end: selectionEnd); |
4806 | |
4807 | QSignalSpy selectionSpy(textEdit, SIGNAL(selectedTextChanged())); |
4808 | QSignalSpy selectionStartSpy(textEdit, SIGNAL(selectionStartChanged())); |
4809 | QSignalSpy selectionEndSpy(textEdit, SIGNAL(selectionEndChanged())); |
4810 | QSignalSpy textSpy(textEdit, SIGNAL(textChanged())); |
4811 | QSignalSpy cursorPositionSpy(textEdit, SIGNAL(cursorPositionChanged())); |
4812 | |
4813 | textEdit->remove(start: removeStart, end: removeEnd); |
4814 | |
4815 | if (textFormat == QQuickTextEdit::RichText |
4816 | || (textFormat == QQuickTextEdit::AutoText && Qt::mightBeRichText(text))) { |
4817 | QCOMPARE(textEdit->getText(0, expectedText.length()), expectedText); |
4818 | } else { |
4819 | QCOMPARE(textEdit->text(), expectedText); |
4820 | } |
4821 | QCOMPARE(textEdit->length(), expectedText.length()); |
4822 | |
4823 | if (selectionStart > selectionEnd) // |
4824 | qSwap(value1&: selectionStart, value2&: selectionEnd); |
4825 | |
4826 | QCOMPARE(textEdit->selectionStart(), expectedSelectionStart); |
4827 | QCOMPARE(textEdit->selectionEnd(), expectedSelectionEnd); |
4828 | QCOMPARE(textEdit->cursorPosition(), expectedCursorPosition); |
4829 | |
4830 | QCOMPARE(selectionSpy.count() > 0, selectionChanged); |
4831 | QCOMPARE(selectionStartSpy.count() > 0, selectionStart != expectedSelectionStart); |
4832 | QCOMPARE(selectionEndSpy.count() > 0, selectionEnd != expectedSelectionEnd); |
4833 | QCOMPARE(textSpy.count() > 0, text != expectedText); |
4834 | |
4835 | |
4836 | if (cursorPositionChanged) // |
4837 | QVERIFY(cursorPositionSpy.count() > 0); |
4838 | } |
4839 | |
4840 | #if QT_CONFIG(shortcut) |
4841 | |
4842 | void tst_qquicktextedit::keySequence_data() |
4843 | { |
4844 | QTest::addColumn<QString>(name: "text" ); |
4845 | QTest::addColumn<QKeySequence>(name: "sequence" ); |
4846 | QTest::addColumn<int>(name: "selectionStart" ); |
4847 | QTest::addColumn<int>(name: "selectionEnd" ); |
4848 | QTest::addColumn<int>(name: "cursorPosition" ); |
4849 | QTest::addColumn<QString>(name: "expectedText" ); |
4850 | QTest::addColumn<QString>(name: "selectedText" ); |
4851 | QTest::addColumn<Qt::Key>(name: "layoutDirection" ); |
4852 | |
4853 | // standard[0] == "the [4]quick [10]brown [16]fox [20]jumped [27]over [32]the [36]lazy [41]dog" |
4854 | |
4855 | QTest::newRow(dataTag: "select all" ) |
4856 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectAll) << 0 << 0 |
4857 | << 44 << standard.at(i: 0) << standard.at(i: 0) |
4858 | << Qt::Key_Direction_L; |
4859 | QTest::newRow(dataTag: "select start of line" ) |
4860 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectStartOfLine) << 5 << 5 |
4861 | << 0 << standard.at(i: 0) << standard.at(i: 0).mid(position: 0, n: 5) |
4862 | << Qt::Key_Direction_L; |
4863 | QTest::newRow(dataTag: "select start of block" ) |
4864 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectStartOfBlock) << 5 << 5 |
4865 | << 0 << standard.at(i: 0) << standard.at(i: 0).mid(position: 0, n: 5) |
4866 | << Qt::Key_Direction_L; |
4867 | QTest::newRow(dataTag: "select end of line" ) |
4868 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectEndOfLine) << 5 << 5 |
4869 | << 44 << standard.at(i: 0) << standard.at(i: 0).mid(position: 5) |
4870 | << Qt::Key_Direction_L; |
4871 | QTest::newRow(dataTag: "select end of document" ) |
4872 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectEndOfDocument) << 3 << 3 |
4873 | << 44 << standard.at(i: 0) << standard.at(i: 0).mid(position: 3) |
4874 | << Qt::Key_Direction_L; |
4875 | QTest::newRow(dataTag: "select end of block" ) |
4876 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectEndOfBlock) << 18 << 18 |
4877 | << 44 << standard.at(i: 0) << standard.at(i: 0).mid(position: 18) |
4878 | << Qt::Key_Direction_L; |
4879 | QTest::newRow(dataTag: "delete end of line" ) |
4880 | << standard.at(i: 0) << QKeySequence(QKeySequence::DeleteEndOfLine) << 24 << 24 |
4881 | << 24 << standard.at(i: 0).mid(position: 0, n: 24) << QString() |
4882 | << Qt::Key_Direction_L; |
4883 | QTest::newRow(dataTag: "move to start of line" ) |
4884 | << standard.at(i: 0) << QKeySequence(QKeySequence::MoveToStartOfLine) << 31 << 31 |
4885 | << 0 << standard.at(i: 0) << QString() |
4886 | << Qt::Key_Direction_L; |
4887 | QTest::newRow(dataTag: "move to start of block" ) |
4888 | << standard.at(i: 0) << QKeySequence(QKeySequence::MoveToStartOfBlock) << 25 << 25 |
4889 | << 0 << standard.at(i: 0) << QString() |
4890 | << Qt::Key_Direction_L; |
4891 | QTest::newRow(dataTag: "move to next char" ) |
4892 | << standard.at(i: 0) << QKeySequence(QKeySequence::MoveToNextChar) << 12 << 12 |
4893 | << 13 << standard.at(i: 0) << QString() |
4894 | << Qt::Key_Direction_L; |
4895 | QTest::newRow(dataTag: "move to previous char (ltr)" ) |
4896 | << standard.at(i: 0) << QKeySequence(QKeySequence::MoveToPreviousChar) << 3 << 3 |
4897 | << 2 << standard.at(i: 0) << QString() |
4898 | << Qt::Key_Direction_L; |
4899 | QTest::newRow(dataTag: "move to previous char (rtl)" ) |
4900 | << standard.at(i: 0) << QKeySequence(QKeySequence::MoveToPreviousChar) << 3 << 3 |
4901 | << 4 << standard.at(i: 0) << QString() |
4902 | << Qt::Key_Direction_R; |
4903 | QTest::newRow(dataTag: "move to previous char with selection" ) |
4904 | << standard.at(i: 0) << QKeySequence(QKeySequence::MoveToPreviousChar) << 3 << 7 |
4905 | << 3 << standard.at(i: 0) << QString() |
4906 | << Qt::Key_Direction_L; |
4907 | QTest::newRow(dataTag: "select next char (ltr)" ) |
4908 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectNextChar) << 23 << 23 |
4909 | << 24 << standard.at(i: 0) << standard.at(i: 0).mid(position: 23, n: 1) |
4910 | << Qt::Key_Direction_L; |
4911 | QTest::newRow(dataTag: "select next char (rtl)" ) |
4912 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectNextChar) << 23 << 23 |
4913 | << 22 << standard.at(i: 0) << standard.at(i: 0).mid(position: 22, n: 1) |
4914 | << Qt::Key_Direction_R; |
4915 | QTest::newRow(dataTag: "select previous char (ltr)" ) |
4916 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectPreviousChar) << 19 << 19 |
4917 | << 18 << standard.at(i: 0) << standard.at(i: 0).mid(position: 18, n: 1) |
4918 | << Qt::Key_Direction_L; |
4919 | QTest::newRow(dataTag: "select previous char (rtl)" ) |
4920 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectPreviousChar) << 19 << 19 |
4921 | << 20 << standard.at(i: 0) << standard.at(i: 0).mid(position: 19, n: 1) |
4922 | << Qt::Key_Direction_R; |
4923 | QTest::newRow(dataTag: "move to next word (ltr)" ) |
4924 | << standard.at(i: 0) << QKeySequence(QKeySequence::MoveToNextWord) << 7 << 7 |
4925 | << 10 << standard.at(i: 0) << QString() |
4926 | << Qt::Key_Direction_L; |
4927 | QTest::newRow(dataTag: "move to next word (rtl)" ) |
4928 | << standard.at(i: 0) << QKeySequence(QKeySequence::MoveToNextWord) << 7 << 7 |
4929 | << 4 << standard.at(i: 0) << QString() |
4930 | << Qt::Key_Direction_R; |
4931 | QTest::newRow(dataTag: "move to previous word (ltr)" ) |
4932 | << standard.at(i: 0) << QKeySequence(QKeySequence::MoveToPreviousWord) << 7 << 7 |
4933 | << 4 << standard.at(i: 0) << QString() |
4934 | << Qt::Key_Direction_L; |
4935 | QTest::newRow(dataTag: "move to previous word (rlt)" ) |
4936 | << standard.at(i: 0) << QKeySequence(QKeySequence::MoveToPreviousWord) << 7 << 7 |
4937 | << 10 << standard.at(i: 0) << QString() |
4938 | << Qt::Key_Direction_R; |
4939 | QTest::newRow(dataTag: "select next word" ) |
4940 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectNextWord) << 11 << 11 |
4941 | << 16 << standard.at(i: 0) << standard.at(i: 0).mid(position: 11, n: 5) |
4942 | << Qt::Key_Direction_L; |
4943 | QTest::newRow(dataTag: "select previous word" ) |
4944 | << standard.at(i: 0) << QKeySequence(QKeySequence::SelectPreviousWord) << 11 << 11 |
4945 | << 10 << standard.at(i: 0) << standard.at(i: 0).mid(position: 10, n: 1) |
4946 | << Qt::Key_Direction_L; |
4947 | QTest::newRow(dataTag: "delete (selection)" ) |
4948 | << standard.at(i: 0) << QKeySequence(QKeySequence::Delete) << 12 << 15 |
4949 | << 12 << (standard.at(i: 0).mid(position: 0, n: 12) + standard.at(i: 0).mid(position: 15)) << QString() |
4950 | << Qt::Key_Direction_L; |
4951 | QTest::newRow(dataTag: "delete (no selection)" ) |
4952 | << standard.at(i: 0) << QKeySequence(QKeySequence::Delete) << 15 << 15 |
4953 | << 15 << (standard.at(i: 0).mid(position: 0, n: 15) + standard.at(i: 0).mid(position: 16)) << QString() |
4954 | << Qt::Key_Direction_L; |
4955 | QTest::newRow(dataTag: "delete end of word" ) |
4956 | << standard.at(i: 0) << QKeySequence(QKeySequence::DeleteEndOfWord) << 24 << 24 |
4957 | << 24 << (standard.at(i: 0).mid(position: 0, n: 24) + standard.at(i: 0).mid(position: 27)) << QString() |
4958 | << Qt::Key_Direction_L; |
4959 | QTest::newRow(dataTag: "delete start of word" ) |
4960 | << standard.at(i: 0) << QKeySequence(QKeySequence::DeleteStartOfWord) << 7 << 7 |
4961 | << 4 << (standard.at(i: 0).mid(position: 0, n: 4) + standard.at(i: 0).mid(position: 7)) << QString() |
4962 | << Qt::Key_Direction_L; |
4963 | } |
4964 | |
4965 | void tst_qquicktextedit::keySequence() |
4966 | { |
4967 | QFETCH(QString, text); |
4968 | QFETCH(QKeySequence, sequence); |
4969 | QFETCH(int, selectionStart); |
4970 | QFETCH(int, selectionEnd); |
4971 | QFETCH(int, cursorPosition); |
4972 | QFETCH(QString, expectedText); |
4973 | QFETCH(QString, selectedText); |
4974 | QFETCH(Qt::Key, layoutDirection); |
4975 | |
4976 | if (sequence.isEmpty()) { |
4977 | QSKIP("Key sequence is undefined" ); |
4978 | } |
4979 | |
4980 | QString componentStr = "import QtQuick 2.0\nTextEdit { focus: true; text: \"" + text + "\" }" ; |
4981 | QQmlComponent textEditComponent(&engine); |
4982 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
4983 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
4984 | QVERIFY(textEdit != nullptr); |
4985 | |
4986 | QQuickWindow window; |
4987 | textEdit->setParentItem(window.contentItem()); |
4988 | window.show(); |
4989 | window.requestActivate(); |
4990 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
4991 | |
4992 | QVERIFY(textEdit->hasActiveFocus()); |
4993 | |
4994 | simulateKey(view: &window, key: layoutDirection); |
4995 | |
4996 | textEdit->select(start: selectionStart, end: selectionEnd); |
4997 | |
4998 | simulateKeys(window: &window, sequence); |
4999 | |
5000 | QCOMPARE(textEdit->cursorPosition(), cursorPosition); |
5001 | QCOMPARE(textEdit->text(), expectedText); |
5002 | QCOMPARE(textEdit->selectedText(), selectedText); |
5003 | } |
5004 | |
5005 | #endif // QT_CONFIG(shortcut) |
5006 | |
5007 | #define NORMAL 0 |
5008 | #define REPLACE_UNTIL_END 1 |
5009 | |
5010 | void tst_qquicktextedit::undo_data() |
5011 | { |
5012 | QTest::addColumn<QStringList>(name: "insertString" ); |
5013 | QTest::addColumn<IntList>(name: "insertIndex" ); |
5014 | QTest::addColumn<IntList>(name: "insertMode" ); |
5015 | QTest::addColumn<QStringList>(name: "expectedString" ); |
5016 | QTest::addColumn<bool>(name: "use_keys" ); |
5017 | |
5018 | for (int i=0; i<2; i++) { |
5019 | QString keys_str = "keyboard" ; |
5020 | bool use_keys = true; |
5021 | if (i==0) { |
5022 | keys_str = "insert" ; |
5023 | use_keys = false; |
5024 | } |
5025 | |
5026 | { |
5027 | IntList insertIndex; |
5028 | IntList insertMode; |
5029 | QStringList insertString; |
5030 | QStringList expectedString; |
5031 | |
5032 | insertIndex << -1; |
5033 | insertMode << NORMAL; |
5034 | insertString << "1" ; |
5035 | |
5036 | insertIndex << -1; |
5037 | insertMode << NORMAL; |
5038 | insertString << "5" ; |
5039 | |
5040 | insertIndex << 1; |
5041 | insertMode << NORMAL; |
5042 | insertString << "3" ; |
5043 | |
5044 | insertIndex << 1; |
5045 | insertMode << NORMAL; |
5046 | insertString << "2" ; |
5047 | |
5048 | insertIndex << 3; |
5049 | insertMode << NORMAL; |
5050 | insertString << "4" ; |
5051 | |
5052 | expectedString << "12345" ; |
5053 | expectedString << "1235" ; |
5054 | expectedString << "135" ; |
5055 | expectedString << "15" ; |
5056 | expectedString << "" ; |
5057 | |
5058 | QTest::newRow(dataTag: QString(keys_str + "_numbers" ).toLatin1()) << |
5059 | insertString << |
5060 | insertIndex << |
5061 | insertMode << |
5062 | expectedString << |
5063 | bool(use_keys); |
5064 | } |
5065 | { |
5066 | IntList insertIndex; |
5067 | IntList insertMode; |
5068 | QStringList insertString; |
5069 | QStringList expectedString; |
5070 | |
5071 | insertIndex << -1; |
5072 | insertMode << NORMAL; |
5073 | insertString << "World" ; // World |
5074 | |
5075 | insertIndex << 0; |
5076 | insertMode << NORMAL; |
5077 | insertString << "Hello" ; // HelloWorld |
5078 | |
5079 | insertIndex << 0; |
5080 | insertMode << NORMAL; |
5081 | insertString << "Well" ; // WellHelloWorld |
5082 | |
5083 | insertIndex << 9; |
5084 | insertMode << NORMAL; |
5085 | insertString << "There" ; // WellHelloThereWorld; |
5086 | |
5087 | expectedString << "WellHelloThereWorld" ; |
5088 | expectedString << "WellHelloWorld" ; |
5089 | expectedString << "HelloWorld" ; |
5090 | expectedString << "World" ; |
5091 | expectedString << "" ; |
5092 | |
5093 | QTest::newRow(dataTag: QString(keys_str + "_helloworld" ).toLatin1()) << |
5094 | insertString << |
5095 | insertIndex << |
5096 | insertMode << |
5097 | expectedString << |
5098 | bool(use_keys); |
5099 | } |
5100 | { |
5101 | IntList insertIndex; |
5102 | IntList insertMode; |
5103 | QStringList insertString; |
5104 | QStringList expectedString; |
5105 | |
5106 | insertIndex << -1; |
5107 | insertMode << NORMAL; |
5108 | insertString << "Ensuring" ; |
5109 | |
5110 | insertIndex << -1; |
5111 | insertMode << NORMAL; |
5112 | insertString << " instan" ; |
5113 | |
5114 | insertIndex << 9; |
5115 | insertMode << NORMAL; |
5116 | insertString << "an " ; |
5117 | |
5118 | insertIndex << 10; |
5119 | insertMode << REPLACE_UNTIL_END; |
5120 | insertString << " unique instance." ; |
5121 | |
5122 | expectedString << "Ensuring a unique instance." ; |
5123 | expectedString << "Ensuring an instan" ; |
5124 | expectedString << "Ensuring instan" ; |
5125 | expectedString << "" ; |
5126 | |
5127 | QTest::newRow(dataTag: QString(keys_str + "_patterns" ).toLatin1()) << |
5128 | insertString << |
5129 | insertIndex << |
5130 | insertMode << |
5131 | expectedString << |
5132 | bool(use_keys); |
5133 | } |
5134 | } |
5135 | } |
5136 | |
5137 | void tst_qquicktextedit::undo() |
5138 | { |
5139 | QFETCH(QStringList, insertString); |
5140 | QFETCH(IntList, insertIndex); |
5141 | QFETCH(IntList, insertMode); |
5142 | QFETCH(QStringList, expectedString); |
5143 | |
5144 | QString componentStr = "import QtQuick 2.0\nTextEdit { focus: true }" ; |
5145 | QQmlComponent textEditComponent(&engine); |
5146 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
5147 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
5148 | QVERIFY(textEdit != nullptr); |
5149 | |
5150 | QQuickWindow window; |
5151 | textEdit->setParentItem(window.contentItem()); |
5152 | window.show(); |
5153 | window.requestActivate(); |
5154 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
5155 | |
5156 | QVERIFY(textEdit->hasActiveFocus()); |
5157 | QVERIFY(!textEdit->canUndo()); |
5158 | |
5159 | QSignalSpy spy(textEdit, SIGNAL(canUndoChanged())); |
5160 | |
5161 | int i; |
5162 | |
5163 | // STEP 1: First build up an undo history by inserting or typing some strings... |
5164 | for (i = 0; i < insertString.size(); ++i) { |
5165 | if (insertIndex[i] > -1) |
5166 | textEdit->setCursorPosition(insertIndex[i]); |
5167 | |
5168 | // experimental stuff |
5169 | if (insertMode[i] == REPLACE_UNTIL_END) { |
5170 | textEdit->select(start: insertIndex[i], end: insertIndex[i] + 8); |
5171 | |
5172 | // This is what I actually want... |
5173 | // QTest::keyClick(testWidget, Qt::Key_End, Qt::ShiftModifier); |
5174 | } |
5175 | |
5176 | for (int j = 0; j < insertString.at(i).length(); j++) |
5177 | QTest::keyClick(window: &window, key: insertString.at(i).at(i: j).toLatin1()); |
5178 | } |
5179 | |
5180 | QCOMPARE(spy.count(), 1); |
5181 | |
5182 | // STEP 2: Next call undo several times and see if we can restore to the previous state |
5183 | for (i = 0; i < expectedString.size() - 1; ++i) { |
5184 | QCOMPARE(textEdit->text(), expectedString[i]); |
5185 | QVERIFY(textEdit->canUndo()); |
5186 | textEdit->undo(); |
5187 | } |
5188 | |
5189 | // STEP 3: Verify that we have undone everything |
5190 | QVERIFY(textEdit->text().isEmpty()); |
5191 | QVERIFY(!textEdit->canUndo()); |
5192 | QCOMPARE(spy.count(), 2); |
5193 | } |
5194 | |
5195 | void tst_qquicktextedit::redo_data() |
5196 | { |
5197 | QTest::addColumn<QStringList>(name: "insertString" ); |
5198 | QTest::addColumn<IntList>(name: "insertIndex" ); |
5199 | QTest::addColumn<QStringList>(name: "expectedString" ); |
5200 | |
5201 | { |
5202 | IntList insertIndex; |
5203 | QStringList insertString; |
5204 | QStringList expectedString; |
5205 | |
5206 | insertIndex << -1; |
5207 | insertString << "World" ; // World |
5208 | insertIndex << 0; |
5209 | insertString << "Hello" ; // HelloWorld |
5210 | insertIndex << 0; |
5211 | insertString << "Well" ; // WellHelloWorld |
5212 | insertIndex << 9; |
5213 | insertString << "There" ; // WellHelloThereWorld; |
5214 | |
5215 | expectedString << "World" ; |
5216 | expectedString << "HelloWorld" ; |
5217 | expectedString << "WellHelloWorld" ; |
5218 | expectedString << "WellHelloThereWorld" ; |
5219 | |
5220 | QTest::newRow(dataTag: "Inserts and setting cursor" ) << insertString << insertIndex << expectedString; |
5221 | } |
5222 | } |
5223 | |
5224 | void tst_qquicktextedit::redo() |
5225 | { |
5226 | QFETCH(QStringList, insertString); |
5227 | QFETCH(IntList, insertIndex); |
5228 | QFETCH(QStringList, expectedString); |
5229 | |
5230 | QString componentStr = "import QtQuick 2.0\nTextEdit { focus: true }" ; |
5231 | QQmlComponent textEditComponent(&engine); |
5232 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
5233 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
5234 | QVERIFY(textEdit != nullptr); |
5235 | |
5236 | QQuickWindow window; |
5237 | textEdit->setParentItem(window.contentItem()); |
5238 | window.show(); |
5239 | window.requestActivate(); |
5240 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
5241 | QVERIFY(textEdit->hasActiveFocus()); |
5242 | |
5243 | QVERIFY(!textEdit->canUndo()); |
5244 | QVERIFY(!textEdit->canRedo()); |
5245 | |
5246 | QSignalSpy spy(textEdit, SIGNAL(canRedoChanged())); |
5247 | |
5248 | int i; |
5249 | // inserts the diff strings at diff positions |
5250 | for (i = 0; i < insertString.size(); ++i) { |
5251 | if (insertIndex[i] > -1) |
5252 | textEdit->setCursorPosition(insertIndex[i]); |
5253 | for (int j = 0; j < insertString.at(i).length(); j++) |
5254 | QTest::keyClick(window: &window, key: insertString.at(i).at(i: j).toLatin1()); |
5255 | QVERIFY(textEdit->canUndo()); |
5256 | QVERIFY(!textEdit->canRedo()); |
5257 | } |
5258 | |
5259 | QCOMPARE(spy.count(), 0); |
5260 | |
5261 | // undo everything |
5262 | while (!textEdit->text().isEmpty()) { |
5263 | QVERIFY(textEdit->canUndo()); |
5264 | textEdit->undo(); |
5265 | QVERIFY(textEdit->canRedo()); |
5266 | } |
5267 | |
5268 | QCOMPARE(spy.count(), 1); |
5269 | |
5270 | for (i = 0; i < expectedString.size(); ++i) { |
5271 | QVERIFY(textEdit->canRedo()); |
5272 | textEdit->redo(); |
5273 | QCOMPARE(textEdit->text() , expectedString[i]); |
5274 | QVERIFY(textEdit->canUndo()); |
5275 | } |
5276 | QVERIFY(!textEdit->canRedo()); |
5277 | QCOMPARE(spy.count(), 2); |
5278 | } |
5279 | |
5280 | #if QT_CONFIG(shortcut) |
5281 | |
5282 | void tst_qquicktextedit::undo_keypressevents_data() |
5283 | { |
5284 | QTest::addColumn<KeyList>(name: "keys" ); |
5285 | QTest::addColumn<QStringList>(name: "expectedString" ); |
5286 | |
5287 | { |
5288 | KeyList keys; |
5289 | QStringList expectedString; |
5290 | |
5291 | keys << "AFRAID" |
5292 | << Qt::Key_Home |
5293 | << "VERY" |
5294 | << Qt::Key_Left |
5295 | << Qt::Key_Left |
5296 | << Qt::Key_Left |
5297 | << Qt::Key_Left |
5298 | << "BE" |
5299 | << Qt::Key_End |
5300 | << "!" ; |
5301 | |
5302 | expectedString << "BEVERYAFRAID!" ; |
5303 | expectedString << "BEVERYAFRAID" ; |
5304 | expectedString << "VERYAFRAID" ; |
5305 | expectedString << "AFRAID" ; |
5306 | |
5307 | QTest::newRow(dataTag: "Inserts and moving cursor" ) << keys << expectedString; |
5308 | } { |
5309 | KeyList keys; |
5310 | QStringList expectedString; |
5311 | |
5312 | // inserting '1234' |
5313 | keys << "1234" << Qt::Key_Home |
5314 | // skipping '12' |
5315 | << Qt::Key_Right << Qt::Key_Right |
5316 | // selecting '34' |
5317 | << (Qt::Key_Right | Qt::ShiftModifier) << (Qt::Key_Right | Qt::ShiftModifier) |
5318 | // deleting '34' |
5319 | << Qt::Key_Delete; |
5320 | |
5321 | expectedString << "12" ; |
5322 | expectedString << "1234" ; |
5323 | |
5324 | QTest::newRow(dataTag: "Inserts,moving,selection and delete" ) << keys << expectedString; |
5325 | } { |
5326 | KeyList keys; |
5327 | QStringList expectedString; |
5328 | |
5329 | // inserting 'AB12' |
5330 | keys << "AB12" |
5331 | << Qt::Key_Home |
5332 | // selecting 'AB' |
5333 | << (Qt::Key_Right | Qt::ShiftModifier) << (Qt::Key_Right | Qt::ShiftModifier) |
5334 | << Qt::Key_Delete |
5335 | << QKeySequence::Undo |
5336 | // ### Text is selected in text input |
5337 | // << Qt::Key_Right |
5338 | << (Qt::Key_Right | Qt::ShiftModifier) << (Qt::Key_Right | Qt::ShiftModifier) |
5339 | << Qt::Key_Delete; |
5340 | |
5341 | expectedString << "AB" ; |
5342 | expectedString << "AB12" ; |
5343 | |
5344 | QTest::newRow(dataTag: "Inserts,moving,selection, delete and undo" ) << keys << expectedString; |
5345 | } { |
5346 | KeyList keys; |
5347 | QStringList expectedString; |
5348 | |
5349 | // inserting 'ABCD' |
5350 | keys << "abcd" |
5351 | //move left two |
5352 | << Qt::Key_Left << Qt::Key_Left |
5353 | // inserting '1234' |
5354 | << "1234" |
5355 | // selecting '1234' |
5356 | << (Qt::Key_Left | Qt::ShiftModifier) << (Qt::Key_Left | Qt::ShiftModifier) << (Qt::Key_Left | Qt::ShiftModifier) << (Qt::Key_Left | Qt::ShiftModifier) |
5357 | // overwriting '1234' with '5' |
5358 | << "5" |
5359 | // undoing deletion of 'AB' |
5360 | << QKeySequence::Undo |
5361 | // ### Text is selected in text input |
5362 | << (Qt::Key_Left | Qt::ShiftModifier) << (Qt::Key_Left | Qt::ShiftModifier) << (Qt::Key_Left | Qt::ShiftModifier) << (Qt::Key_Left | Qt::ShiftModifier) |
5363 | // overwriting '1234' with '6' |
5364 | << "6" ; |
5365 | |
5366 | expectedString << "ab6cd" ; |
5367 | // for versions previous to 3.2 we overwrite needed two undo operations |
5368 | expectedString << "ab1234cd" ; |
5369 | expectedString << "abcd" ; |
5370 | |
5371 | QTest::newRow(dataTag: "Inserts,moving,selection and undo, removing selection" ) << keys << expectedString; |
5372 | } { |
5373 | KeyList keys; |
5374 | QStringList expectedString; |
5375 | |
5376 | // inserting 'ABC' |
5377 | keys << "ABC" |
5378 | // removes 'C' |
5379 | << Qt::Key_Backspace; |
5380 | |
5381 | expectedString << "AB" ; |
5382 | expectedString << "ABC" ; |
5383 | |
5384 | QTest::newRow(dataTag: "Inserts,backspace" ) << keys << expectedString; |
5385 | } { |
5386 | KeyList keys; |
5387 | QStringList expectedString; |
5388 | |
5389 | keys << "ABC" |
5390 | // removes 'C' |
5391 | << Qt::Key_Backspace |
5392 | // inserting 'Z' |
5393 | << "Z" ; |
5394 | |
5395 | expectedString << "ABZ" ; |
5396 | expectedString << "AB" ; |
5397 | expectedString << "ABC" ; |
5398 | |
5399 | QTest::newRow(dataTag: "Inserts,backspace,inserts" ) << keys << expectedString; |
5400 | } { |
5401 | KeyList keys; |
5402 | QStringList expectedString; |
5403 | |
5404 | // inserting '123' |
5405 | keys << "123" << Qt::Key_Home |
5406 | // selecting '123' |
5407 | << (Qt::Key_End | Qt::ShiftModifier) |
5408 | // overwriting '123' with 'ABC' |
5409 | << "ABC" ; |
5410 | |
5411 | expectedString << "ABC" ; |
5412 | expectedString << "123" ; |
5413 | |
5414 | QTest::newRow(dataTag: "Inserts,moving,selection and overwriting" ) << keys << expectedString; |
5415 | } |
5416 | |
5417 | bool canCopyPaste = PlatformQuirks::isClipboardAvailable(); |
5418 | |
5419 | if (canCopyPaste) { |
5420 | KeyList keys; |
5421 | keys << "123" |
5422 | << QKeySequence(QKeySequence::SelectStartOfLine) |
5423 | << QKeySequence(QKeySequence::Cut) |
5424 | << "ABC" |
5425 | << QKeySequence(QKeySequence::Paste); |
5426 | QStringList expectedString = QStringList() |
5427 | << "ABC123" |
5428 | << "ABC" |
5429 | << "" |
5430 | << "123" ; |
5431 | QTest::newRow(dataTag: "Cut,paste" ) << keys << expectedString; |
5432 | } |
5433 | if (canCopyPaste) { |
5434 | KeyList keys; |
5435 | keys << "123" |
5436 | << QKeySequence(QKeySequence::SelectStartOfLine) |
5437 | << QKeySequence(QKeySequence::Copy) |
5438 | << "ABC" |
5439 | << QKeySequence(QKeySequence::Paste); |
5440 | QStringList expectedString = QStringList() |
5441 | << "ABC123" |
5442 | << "ABC" |
5443 | << "123" ; |
5444 | QTest::newRow(dataTag: "Copy,paste" ) << keys << expectedString; |
5445 | } |
5446 | } |
5447 | |
5448 | void tst_qquicktextedit::undo_keypressevents() |
5449 | { |
5450 | QFETCH(KeyList, keys); |
5451 | QFETCH(QStringList, expectedString); |
5452 | |
5453 | QString componentStr = "import QtQuick 2.0\nTextEdit { focus: true }" ; |
5454 | QQmlComponent textEditComponent(&engine); |
5455 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
5456 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
5457 | QVERIFY(textEdit != nullptr); |
5458 | |
5459 | QQuickWindow window; |
5460 | textEdit->setParentItem(window.contentItem()); |
5461 | window.show(); |
5462 | window.requestActivate(); |
5463 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
5464 | QVERIFY(textEdit->hasActiveFocus()); |
5465 | |
5466 | simulateKeys(window: &window, keys); |
5467 | |
5468 | for (int i = 0; i < expectedString.size(); ++i) { |
5469 | QCOMPARE(textEdit->text() , expectedString[i]); |
5470 | textEdit->undo(); |
5471 | } |
5472 | QVERIFY(textEdit->text().isEmpty()); |
5473 | } |
5474 | |
5475 | #endif // QT_CONFIG(shortcut) |
5476 | |
5477 | void tst_qquicktextedit::clear() |
5478 | { |
5479 | QString componentStr = "import QtQuick 2.0\nTextEdit { focus: true }" ; |
5480 | QQmlComponent textEditComponent(&engine); |
5481 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
5482 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
5483 | QVERIFY(textEdit != nullptr); |
5484 | |
5485 | QQuickWindow window; |
5486 | textEdit->setParentItem(window.contentItem()); |
5487 | window.show(); |
5488 | window.requestActivate(); |
5489 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
5490 | QVERIFY(textEdit->hasActiveFocus()); |
5491 | |
5492 | QSignalSpy spy(textEdit, SIGNAL(canUndoChanged())); |
5493 | |
5494 | textEdit->setText("I am Legend" ); |
5495 | QCOMPARE(textEdit->text(), QString("I am Legend" )); |
5496 | textEdit->clear(); |
5497 | QVERIFY(textEdit->text().isEmpty()); |
5498 | |
5499 | QCOMPARE(spy.count(), 1); |
5500 | |
5501 | // checks that clears can be undone |
5502 | textEdit->undo(); |
5503 | QVERIFY(!textEdit->canUndo()); |
5504 | QCOMPARE(spy.count(), 2); |
5505 | QCOMPARE(textEdit->text(), QString("I am Legend" )); |
5506 | |
5507 | textEdit->setCursorPosition(4); |
5508 | QInputMethodEvent preeditEvent("PREEDIT" , QList<QInputMethodEvent::Attribute>()); |
5509 | QGuiApplication::sendEvent(receiver: textEdit, event: &preeditEvent); |
5510 | QCOMPARE(textEdit->text(), QString("I am Legend" )); |
5511 | QCOMPARE(textEdit->preeditText(), QString("PREEDIT" )); |
5512 | |
5513 | textEdit->clear(); |
5514 | QVERIFY(textEdit->text().isEmpty()); |
5515 | |
5516 | QCOMPARE(spy.count(), 3); |
5517 | |
5518 | // checks that clears can be undone |
5519 | textEdit->undo(); |
5520 | QVERIFY(!textEdit->canUndo()); |
5521 | QCOMPARE(spy.count(), 4); |
5522 | QCOMPARE(textEdit->text(), QString("I am Legend" )); |
5523 | |
5524 | textEdit->setText(QString("<i>I am Legend</i>" )); |
5525 | QCOMPARE(textEdit->text(), QString("<i>I am Legend</i>" )); |
5526 | textEdit->clear(); |
5527 | QVERIFY(textEdit->text().isEmpty()); |
5528 | |
5529 | QCOMPARE(spy.count(), 5); |
5530 | |
5531 | // checks that clears can be undone |
5532 | textEdit->undo(); |
5533 | QCOMPARE(spy.count(), 6); |
5534 | QCOMPARE(textEdit->text(), QString("<i>I am Legend</i>" )); |
5535 | } |
5536 | |
5537 | void tst_qquicktextedit::baseUrl() |
5538 | { |
5539 | QUrl localUrl("file:///tests/text.qml" ); |
5540 | QUrl remoteUrl("http://www.qt-project.org/test.qml" ); |
5541 | |
5542 | QQmlComponent textComponent(&engine); |
5543 | textComponent.setData("import QtQuick 2.0\n TextEdit {}" , baseUrl: localUrl); |
5544 | QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit *>(object: textComponent.create()); |
5545 | |
5546 | QCOMPARE(textObject->baseUrl(), localUrl); |
5547 | |
5548 | QSignalSpy spy(textObject, SIGNAL(baseUrlChanged())); |
5549 | |
5550 | textObject->setBaseUrl(localUrl); |
5551 | QCOMPARE(textObject->baseUrl(), localUrl); |
5552 | QCOMPARE(spy.count(), 0); |
5553 | |
5554 | textObject->setBaseUrl(remoteUrl); |
5555 | QCOMPARE(textObject->baseUrl(), remoteUrl); |
5556 | QCOMPARE(spy.count(), 1); |
5557 | |
5558 | textObject->resetBaseUrl(); |
5559 | QCOMPARE(textObject->baseUrl(), localUrl); |
5560 | QCOMPARE(spy.count(), 2); |
5561 | } |
5562 | |
5563 | void tst_qquicktextedit::embeddedImages_data() |
5564 | { |
5565 | QTest::addColumn<QUrl>(name: "qmlfile" ); |
5566 | QTest::addColumn<QString>(name: "error" ); |
5567 | QTest::newRow(dataTag: "local" ) << testFileUrl(fileName: "embeddedImagesLocal.qml" ) << "" ; |
5568 | QTest::newRow(dataTag: "local-error" ) << testFileUrl(fileName: "embeddedImagesLocalError.qml" ) |
5569 | << testFileUrl(fileName: "embeddedImagesLocalError.qml" ).toString()+":3:1: QML TextEdit: Cannot open: " + testFileUrl(fileName: "http/notexists.png" ).toString(); |
5570 | QTest::newRow(dataTag: "local" ) << testFileUrl(fileName: "embeddedImagesLocalRelative.qml" ) << "" ; |
5571 | QTest::newRow(dataTag: "remote" ) << testFileUrl(fileName: "embeddedImagesRemote.qml" ) << "" ; |
5572 | QTest::newRow(dataTag: "remote-error" ) << testFileUrl(fileName: "embeddedImagesRemoteError.qml" ) |
5573 | << testFileUrl(fileName: "embeddedImagesRemoteError.qml" ).toString()+":3:1: QML TextEdit: Error transferring {{ServerBaseUrl}}/notexists.png - server replied: Not found" ; |
5574 | QTest::newRow(dataTag: "remote" ) << testFileUrl(fileName: "embeddedImagesRemoteRelative.qml" ) << "" ; |
5575 | } |
5576 | |
5577 | void tst_qquicktextedit::embeddedImages() |
5578 | { |
5579 | QFETCH(QUrl, qmlfile); |
5580 | QFETCH(QString, error); |
5581 | |
5582 | TestHTTPServer server; |
5583 | QVERIFY2(server.listen(), qPrintable(server.errorString())); |
5584 | server.serveDirectory(testFile(fileName: "http" )); |
5585 | |
5586 | error.replace(QStringLiteral("{{ServerBaseUrl}}" ), after: server.baseUrl().toString()); |
5587 | |
5588 | if (!error.isEmpty()) |
5589 | QTest::ignoreMessage(type: QtWarningMsg, message: error.toLatin1()); |
5590 | |
5591 | QQmlComponent textComponent(&engine, qmlfile); |
5592 | QQuickTextEdit *textObject = qobject_cast<QQuickTextEdit*>(object: textComponent.beginCreate(engine.rootContext())); |
5593 | QVERIFY(textObject != nullptr); |
5594 | |
5595 | const int baseUrlPropertyIndex = textObject->metaObject()->indexOfProperty(name: "serverBaseUrl" ); |
5596 | if (baseUrlPropertyIndex != -1) { |
5597 | QMetaProperty prop = textObject->metaObject()->property(index: baseUrlPropertyIndex); |
5598 | QVERIFY(prop.write(textObject, server.baseUrl().toString())); |
5599 | } |
5600 | |
5601 | textComponent.completeCreate(); |
5602 | |
5603 | QTRY_COMPARE(QQuickTextEditPrivate::get(textObject)->document->resourcesLoading(), 0); |
5604 | |
5605 | QPixmap pm(testFile(fileName: "http/exists.png" )); |
5606 | if (error.isEmpty()) { |
5607 | QCOMPARE(textObject->width(), double(pm.width())); |
5608 | QCOMPARE(textObject->height(), double(pm.height())); |
5609 | } else { |
5610 | QVERIFY(16 != pm.width()); // check test is effective |
5611 | QCOMPARE(textObject->width(), 16.0); // default size of QTextDocument broken image icon |
5612 | QCOMPARE(textObject->height(), 16.0); |
5613 | } |
5614 | |
5615 | delete textObject; |
5616 | } |
5617 | |
5618 | void tst_qquicktextedit::emptytags_QTBUG_22058() |
5619 | { |
5620 | QQuickView window(testFileUrl(fileName: "qtbug-22058.qml" )); |
5621 | QVERIFY(window.rootObject() != nullptr); |
5622 | |
5623 | window.show(); |
5624 | window.requestActivate(); |
5625 | QVERIFY(QTest::qWaitForWindowActive(&window)); |
5626 | QQuickTextEdit *input = qobject_cast<QQuickTextEdit *>(object: qvariant_cast<QObject *>(v: window.rootObject()->property(name: "inputField" ))); |
5627 | QVERIFY(input->hasActiveFocus()); |
5628 | |
5629 | QInputMethodEvent event("" , QList<QInputMethodEvent::Attribute>()); |
5630 | event.setCommitString(commitString: "<b>Bold<" ); |
5631 | QGuiApplication::sendEvent(receiver: input, event: &event); |
5632 | QCOMPARE(input->text(), QString("<b>Bold<" )); |
5633 | event.setCommitString(commitString: ">" ); |
5634 | QGuiApplication::sendEvent(receiver: input, event: &event); |
5635 | QCOMPARE(input->text(), QString("<b>Bold<>" )); |
5636 | } |
5637 | |
5638 | void tst_qquicktextedit::cursorRectangle_QTBUG_38947() |
5639 | { |
5640 | QQuickView window(testFileUrl(fileName: "qtbug-38947.qml" )); |
5641 | |
5642 | window.show(); |
5643 | window.requestActivate(); |
5644 | QVERIFY(QTest::qWaitForWindowExposed(&window)); |
5645 | QQuickTextEdit *edit = window.rootObject()->findChild<QQuickTextEdit *>(aName: "textedit" ); |
5646 | QVERIFY(edit); |
5647 | |
5648 | QPoint from = edit->positionToRectangle(0).center().toPoint(); |
5649 | QTest::mousePress(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: from); |
5650 | |
5651 | QSignalSpy spy(edit, SIGNAL(cursorRectangleChanged())); |
5652 | QVERIFY(spy.isValid()); |
5653 | |
5654 | for (int i = 1; i < edit->length() - 1; ++i) { |
5655 | QRectF rect = edit->positionToRectangle(i); |
5656 | QTest::mouseMove(window: &window, pos: rect.center().toPoint()); |
5657 | QCOMPARE(edit->cursorRectangle(), rect); |
5658 | QCOMPARE(spy.count(), i); |
5659 | } |
5660 | |
5661 | QPoint to = edit->positionToRectangle(edit->length() - 1).center().toPoint(); |
5662 | QTest::mouseRelease(window: &window, button: Qt::LeftButton, stateKey: Qt::NoModifier, pos: to); |
5663 | } |
5664 | |
5665 | void tst_qquicktextedit::textCached_QTBUG_41583() |
5666 | { |
5667 | QQmlComponent component(&engine); |
5668 | component.setData("import QtQuick 2.0\nTextEdit { property int margin: 10; text: \"TextEdit\"; textMargin: margin; property bool empty: !text; }" , baseUrl: QUrl()); |
5669 | QQuickTextEdit *textedit = qobject_cast<QQuickTextEdit*>(object: component.create()); |
5670 | QVERIFY(textedit); |
5671 | QCOMPARE(textedit->textMargin(), qreal(10.0)); |
5672 | QCOMPARE(textedit->text(), QString("TextEdit" )); |
5673 | QVERIFY(!textedit->property("empty" ).toBool()); |
5674 | } |
5675 | |
5676 | void tst_qquicktextedit::doubleSelect_QTBUG_38704() |
5677 | { |
5678 | QString componentStr = "import QtQuick 2.2\nTextEdit { text: \"TextEdit\" }" ; |
5679 | QQmlComponent textEditComponent(&engine); |
5680 | textEditComponent.setData(componentStr.toLatin1(), baseUrl: QUrl()); |
5681 | QQuickTextEdit *textEdit = qobject_cast<QQuickTextEdit*>(object: textEditComponent.create()); |
5682 | QVERIFY(textEdit != nullptr); |
5683 | |
5684 | QSignalSpy selectionSpy(textEdit, SIGNAL(selectedTextChanged())); |
5685 | |
5686 | textEdit->select(start: 0,end: 1); //Select some text initially |
5687 | QCOMPARE(selectionSpy.count(), 1); |
5688 | textEdit->select(start: 0,end: 1); //No change to selection start/end |
5689 | QCOMPARE(selectionSpy.count(), 1); |
5690 | textEdit->select(start: 0,end: 2); //Change selection end |
5691 | QCOMPARE(selectionSpy.count(), 2); |
5692 | textEdit->select(start: 1,end: 2); //Change selection start |
5693 | QCOMPARE(selectionSpy.count(), 3); |
5694 | } |
5695 | |
5696 | void tst_qquicktextedit::padding() |
5697 | { |
5698 | QScopedPointer<QQuickView> window(new QQuickView); |
5699 | window->setSource(testFileUrl(fileName: "padding.qml" )); |
5700 | QTRY_COMPARE(window->status(), QQuickView::Ready); |
5701 | window->show(); |
5702 | QVERIFY(QTest::qWaitForWindowExposed(window.data())); |
5703 | QQuickItem *root = window->rootObject(); |
5704 | QVERIFY(root); |
5705 | QQuickTextEdit *obj = qobject_cast<QQuickTextEdit*>(object: root); |
5706 | QVERIFY(obj != nullptr); |
5707 | |
5708 | qreal cw = obj->contentWidth(); |
5709 | qreal ch = obj->contentHeight(); |
5710 | |
5711 | QVERIFY(cw > 0); |
5712 | QVERIFY(ch > 0); |
5713 | |
5714 | QCOMPARE(obj->topPadding(), 20.0); |
5715 | QCOMPARE(obj->leftPadding(), 30.0); |
5716 | QCOMPARE(obj->rightPadding(), 40.0); |
5717 | QCOMPARE(obj->bottomPadding(), 50.0); |
5718 | |
5719 | QCOMPARE(obj->implicitWidth(), cw + obj->leftPadding() + obj->rightPadding()); |
5720 | QCOMPARE(obj->implicitHeight(), ch + obj->topPadding() + obj->bottomPadding()); |
5721 | |
5722 | obj->setTopPadding(2.25); |
5723 | QCOMPARE(obj->topPadding(), 2.25); |
5724 | QCOMPARE(obj->implicitHeight(), ch + obj->topPadding() + obj->bottomPadding()); |
5725 | |
5726 | obj->setLeftPadding(3.75); |
5727 | QCOMPARE(obj->leftPadding(), 3.75); |
5728 | QCOMPARE(obj->implicitWidth(), cw + obj->leftPadding() + obj->rightPadding()); |
5729 | |
5730 | obj->setRightPadding(4.4); |
5731 | QCOMPARE(obj->rightPadding(), 4.4); |
5732 | QCOMPARE(obj->implicitWidth(), cw + obj->leftPadding() + obj->rightPadding()); |
5733 | |
5734 | obj->setBottomPadding(1.11); |
5735 | QCOMPARE(obj->bottomPadding(), 1.11); |
5736 | QCOMPARE(obj->implicitHeight(), ch + obj->topPadding() + obj->bottomPadding()); |
5737 | |
5738 | obj->setText("Qt" ); |
5739 | QVERIFY(obj->contentWidth() < cw); |
5740 | QCOMPARE(obj->contentHeight(), ch); |
5741 | cw = obj->contentWidth(); |
5742 | |
5743 | QCOMPARE(obj->implicitWidth(), cw + obj->leftPadding() + obj->rightPadding()); |
5744 | QCOMPARE(obj->implicitHeight(), ch + obj->topPadding() + obj->bottomPadding()); |
5745 | |
5746 | obj->setFont(QFont("Courier" , 96)); |
5747 | QVERIFY(obj->contentWidth() > cw); |
5748 | QVERIFY(obj->contentHeight() > ch); |
5749 | cw = obj->contentWidth(); |
5750 | ch = obj->contentHeight(); |
5751 | |
5752 | QCOMPARE(obj->implicitWidth(), cw + obj->leftPadding() + obj->rightPadding()); |
5753 | QCOMPARE(obj->implicitHeight(), ch + obj->topPadding() + obj->bottomPadding()); |
5754 | |
5755 | obj->resetTopPadding(); |
5756 | QCOMPARE(obj->topPadding(), 10.0); |
5757 | obj->resetLeftPadding(); |
5758 | QCOMPARE(obj->leftPadding(), 10.0); |
5759 | obj->resetRightPadding(); |
5760 | QCOMPARE(obj->rightPadding(), 10.0); |
5761 | obj->resetBottomPadding(); |
5762 | QCOMPARE(obj->bottomPadding(), 10.0); |
5763 | |
5764 | obj->resetPadding(); |
5765 | QCOMPARE(obj->padding(), 0.0); |
5766 | QCOMPARE(obj->topPadding(), 0.0); |
5767 | QCOMPARE(obj->leftPadding(), 0.0); |
5768 | QCOMPARE(obj->rightPadding(), 0.0); |
5769 | QCOMPARE(obj->bottomPadding(), 0.0); |
5770 | |
5771 | delete root; |
5772 | } |
5773 | |
5774 | void tst_qquicktextedit::paddingAndWrap() |
5775 | { |
5776 | // Check that the document ends up with the correct width if |
5777 | // we set left and right padding after component completed. |
5778 | QScopedPointer<QQuickView> window(new QQuickView); |
5779 | window->setSource(testFileUrl(fileName: "wordwrap.qml" )); |
5780 | QTRY_COMPARE(window->status(), QQuickView::Ready); |
5781 | window->show(); |
5782 | QVERIFY(QTest::qWaitForWindowExposed(window.data())); |
5783 | QQuickItem *root = window->rootObject(); |
5784 | QVERIFY(root); |
5785 | QQuickTextEdit *obj = qobject_cast<QQuickTextEdit *>(object: root); |
5786 | QVERIFY(obj != nullptr); |
5787 | QTextDocument *doc = QQuickTextEditPrivate::get(item: obj)->document; |
5788 | |
5789 | QCOMPARE(doc->textWidth(), obj->width()); |
5790 | obj->setLeftPadding(10); |
5791 | obj->setRightPadding(10); |
5792 | QCOMPARE(doc->textWidth(), obj->width() - obj->leftPadding() - obj->rightPadding()); |
5793 | obj->setLeftPadding(0); |
5794 | obj->setRightPadding(0); |
5795 | QCOMPARE(doc->textWidth(), obj->width()); |
5796 | } |
5797 | |
5798 | void tst_qquicktextedit::QTBUG_51115_readOnlyResetsSelection() |
5799 | { |
5800 | QQuickView view; |
5801 | view.setSource(testFileUrl(fileName: "qtbug51115.qml" )); |
5802 | view.show(); |
5803 | QVERIFY(QTest::qWaitForWindowExposed(&view)); |
5804 | QQuickTextEdit *obj = qobject_cast<QQuickTextEdit*>(object: view.rootObject()); |
5805 | |
5806 | QCOMPARE(obj->selectedText(), QString()); |
5807 | } |
5808 | |
5809 | void tst_qquicktextedit::keys_shortcutoverride() |
5810 | { |
5811 | // Tests that QML TextEdit receives Keys.onShortcutOverride (QTBUG-68711) |
5812 | QQuickView view; |
5813 | view.setSource(testFileUrl(fileName: "keys_shortcutoverride.qml" )); |
5814 | view.show(); |
5815 | view.requestActivate(); |
5816 | QVERIFY(QTest::qWaitForWindowActive(&view)); |
5817 | QObject *root = view.rootObject(); |
5818 | QVERIFY(root); |
5819 | |
5820 | QQuickTextEdit *textEdit = root->findChild<QQuickTextEdit*>(); |
5821 | QVERIFY(textEdit); |
5822 | QQuickRectangle *rectangle = root->findChild<QQuickRectangle*>(aName: QLatin1String("rectangle" )); |
5823 | QVERIFY(rectangle); |
5824 | |
5825 | // Precondition: check if its not already changed |
5826 | QCOMPARE(root->property("who" ).value<QString>(), QLatin1String("nobody" )); |
5827 | |
5828 | // send Key_Escape to the Rectangle |
5829 | QVERIFY(rectangle->hasActiveFocus()); |
5830 | QTest::keyPress(window: &view, key: Qt::Key_Escape); |
5831 | QCOMPARE(root->property("who" ).value<QString>(), QLatin1String("Rectangle" )); |
5832 | |
5833 | // send Key_Escape to TextEdit |
5834 | textEdit->setFocus(true); |
5835 | QTest::keyPress(window: &view, key: Qt::Key_Escape); |
5836 | QCOMPARE(root->property("who" ).value<QString>(), QLatin1String("TextEdit" )); |
5837 | } |
5838 | |
5839 | void tst_qquicktextedit::transparentSelectionColor() |
5840 | { |
5841 | if ((QGuiApplication::platformName() == QLatin1String("offscreen" )) |
5842 | || (QGuiApplication::platformName() == QLatin1String("minimal" ))) |
5843 | QSKIP("Skipping due to grabToImage not functional on offscreen/minimal platforms" ); |
5844 | |
5845 | QQuickView view; |
5846 | view.setSource(testFileUrl(fileName: "transparentSelectionColor.qml" )); |
5847 | view.show(); |
5848 | QVERIFY(QTest::qWaitForWindowExposed(&view)); |
5849 | QObject *root = view.rootObject(); |
5850 | QVERIFY(root); |
5851 | |
5852 | QQuickTextEdit *textEdit = root->findChild<QQuickTextEdit *>(); |
5853 | QVERIFY(textEdit); |
5854 | textEdit->selectAll(); |
5855 | |
5856 | QImage img = view.grabWindow(); |
5857 | QCOMPARE(img.isNull(), false); |
5858 | |
5859 | QColor color = img.pixelColor(x: int(textEdit->width() / 2), y: int(textEdit->height()) / 2); |
5860 | QVERIFY(color.red() > 250); |
5861 | QVERIFY(color.blue() < 10); |
5862 | QVERIFY(color.green() < 10); |
5863 | } |
5864 | |
5865 | QTEST_MAIN(tst_qquicktextedit) |
5866 | |
5867 | #include "tst_qquicktextedit.moc" |
5868 | |