X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=tests%2Fauto%2Fquick%2Fqquicktextinput%2Ftst_qquicktextinput.cpp;h=249755b813d2e683186119b8acc17ea01ddba86a;hb=5c4108e2f0bcd8c116882eeb4aa96dc02cd22c06;hp=d2d8d5ad14dd90d157332a3bb631b79fbcf59bad;hpb=a1ea8f59e650c6be3e14274b36b1197245e96067;p=profile%2Fivi%2Fqtdeclarative.git

diff --git a/tests/auto/quick/qquicktextinput/tst_qquicktextinput.cpp b/tests/auto/quick/qquicktextinput/tst_qquicktextinput.cpp
index d2d8d5a..249755b 100644
--- a/tests/auto/quick/qquicktextinput/tst_qquicktextinput.cpp
+++ b/tests/auto/quick/qquicktextinput/tst_qquicktextinput.cpp
@@ -1,38 +1,38 @@
 /****************************************************************************
 **
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
+** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the test suite of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
 ** GNU Lesser General Public License Usage
-** This file may be used under the terms of the GNU Lesser General Public
-** License version 2.1 as published by the Free Software Foundation and
-** appearing in the file LICENSE.LGPL included in the packaging of this
-** file. Please review the following information to ensure the GNU Lesser
-** General Public License version 2.1 requirements will be met:
-** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain additional
-** rights. These rights are described in the Nokia Qt LGPL Exception
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU General
-** Public License version 3.0 as published by the Free Software Foundation
-** and appearing in the file LICENSE.GPL included in the packaging of this
-** file. Please review the following information to ensure the GNU General
-** Public License version 3.0 requirements will be met:
-** http://www.gnu.org/copyleft/gpl.html.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms and
-** conditions contained in a signed written agreement between you and Nokia.
-**
-**
-**
-**
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
 **
 **
 ** $QT_END_LICENSE$
@@ -41,6 +41,7 @@
 #include <qtest.h>
 #include <QtTest/QSignalSpy>
 #include "../../shared/util.h"
+#include "../../shared/testhttpserver.h"
 #include <private/qinputmethod_p.h>
 #include <QtQml/qqmlengine.h>
 #include <QtQml/qqmlexpression.h>
@@ -60,8 +61,12 @@
 #endif
 
 #include "qplatformdefs.h"
+#include "../../shared/platformquirks.h"
 #include "../../shared/platforminputcontext.h"
 
+#define SERVER_PORT 14460
+#define SERVER_ADDR "http://localhost:14460"
+
 Q_DECLARE_METATYPE(QQuickTextInput::SelectionMode)
 Q_DECLARE_METATYPE(QQuickTextInput::EchoMode)
 Q_DECLARE_METATYPE(Qt::Key)
@@ -122,10 +127,11 @@ private slots:
     void dragMouseSelection();
     void mouseSelectionMode_data();
     void mouseSelectionMode();
+    void mouseSelectionMode_accessors();
+    void selectByMouse();
+    void renderType();
     void tripleClickSelectsAll();
 
-    void horizontalAlignment_data();
-    void horizontalAlignment();
     void horizontalAlignment_RightToLeft();
     void verticalAlignment();
 
@@ -142,15 +148,19 @@ private slots:
     void passwordCharacter();
     void cursorDelegate_data();
     void cursorDelegate();
+    void remoteCursorDelegate();
     void cursorVisible();
     void cursorRectangle_data();
     void cursorRectangle();
     void navigation();
     void navigation_RTL();
+#ifndef QT_NO_CLIPBOARD
     void copyAndPaste();
     void copyAndPasteKeySequence();
     void canPasteEmpty();
     void canPaste();
+    void middleClickPaste();
+#endif
     void readOnly();
     void focusOnPress();
 
@@ -187,6 +197,8 @@ private slots:
     void undo_keypressevents_data();
     void undo_keypressevents();
 
+    void backspaceSurrogatePairs();
+
     void QTBUG_19956();
     void QTBUG_19956_data();
     void QTBUG_19956_regexp();
@@ -231,8 +243,8 @@ Q_DECLARE_METATYPE(KeyList)
 void tst_qquicktextinput::simulateKeys(QWindow *window, const QList<Key> &keys)
 {
     for (int i = 0; i < keys.count(); ++i) {
-        const int key = keys.at(i).first;
-        const int modifiers = key & Qt::KeyboardModifierMask;
+        const int key = keys.at(i).first & ~Qt::KeyboardModifierMask;
+        const int modifiers = keys.at(i).first & Qt::KeyboardModifierMask;
         const QString text = !keys.at(i).second.isNull() ? QString(keys.at(i).second) : QString();
 
         QKeyEvent press(QEvent::KeyPress, Qt::Key(key), Qt::KeyboardModifiers(modifiers), text);
@@ -461,6 +473,57 @@ void tst_qquicktextinput::font()
 
 void tst_qquicktextinput::color()
 {
+    //test initial color
+    {
+        QString componentStr = "import QtQuick 2.0\nTextInput { text: \"Hello World\" }";
+        QQmlComponent texteditComponent(&engine);
+        texteditComponent.setData(componentStr.toLatin1(), QUrl());
+        QScopedPointer<QObject> object(texteditComponent.create());
+        QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput*>(object.data());
+
+        QVERIFY(textInputObject);
+        QCOMPARE(textInputObject->color(), QColor("black"));
+        QCOMPARE(textInputObject->selectionColor(), QColor::fromRgba(0xFF000080));
+        QCOMPARE(textInputObject->selectedTextColor(), QColor("white"));
+
+        QSignalSpy colorSpy(textInputObject, SIGNAL(colorChanged()));
+        QSignalSpy selectionColorSpy(textInputObject, SIGNAL(selectionColorChanged()));
+        QSignalSpy selectedTextColorSpy(textInputObject, SIGNAL(selectedTextColorChanged()));
+
+        textInputObject->setColor(QColor("white"));
+        QCOMPARE(textInputObject->color(), QColor("white"));
+        QCOMPARE(colorSpy.count(), 1);
+
+        textInputObject->setSelectionColor(QColor("black"));
+        QCOMPARE(textInputObject->selectionColor(), QColor("black"));
+        QCOMPARE(selectionColorSpy.count(), 1);
+
+        textInputObject->setSelectedTextColor(QColor("blue"));
+        QCOMPARE(textInputObject->selectedTextColor(), QColor("blue"));
+        QCOMPARE(selectedTextColorSpy.count(), 1);
+
+        textInputObject->setColor(QColor("white"));
+        QCOMPARE(colorSpy.count(), 1);
+
+        textInputObject->setSelectionColor(QColor("black"));
+        QCOMPARE(selectionColorSpy.count(), 1);
+
+        textInputObject->setSelectedTextColor(QColor("blue"));
+        QCOMPARE(selectedTextColorSpy.count(), 1);
+
+        textInputObject->setColor(QColor("black"));
+        QCOMPARE(textInputObject->color(), QColor("black"));
+        QCOMPARE(colorSpy.count(), 2);
+
+        textInputObject->setSelectionColor(QColor("blue"));
+        QCOMPARE(textInputObject->selectionColor(), QColor("blue"));
+        QCOMPARE(selectionColorSpy.count(), 2);
+
+        textInputObject->setSelectedTextColor(QColor("white"));
+        QCOMPARE(textInputObject->selectedTextColor(), QColor("white"));
+        QCOMPARE(selectedTextColorSpy.count(), 2);
+    }
+
     //test color
     for (int i = 0; i < colorStrings.size(); i++)
     {
@@ -550,6 +613,29 @@ void tst_qquicktextinput::wrap()
 
         delete textObject;
     }
+
+    {
+        QQmlComponent component(&engine);
+        component.setData("import QtQuick 2.0\n TextInput {}", QUrl());
+        QScopedPointer<QObject> object(component.create());
+        QQuickTextInput *input = qobject_cast<QQuickTextInput *>(object.data());
+        QVERIFY(input);
+
+        QSignalSpy spy(input, SIGNAL(wrapModeChanged()));
+
+        QCOMPARE(input->wrapMode(), QQuickTextInput::NoWrap);
+
+        input->setWrapMode(QQuickTextInput::Wrap);
+        QCOMPARE(input->wrapMode(), QQuickTextInput::Wrap);
+        QCOMPARE(spy.count(), 1);
+
+        input->setWrapMode(QQuickTextInput::Wrap);
+        QCOMPARE(spy.count(), 1);
+
+        input->setWrapMode(QQuickTextInput::NoWrap);
+        QCOMPARE(input->wrapMode(), QQuickTextInput::NoWrap);
+        QCOMPARE(spy.count(), 2);
+    }
 }
 
 void tst_qquicktextinput::selection()
@@ -653,14 +739,12 @@ void tst_qquicktextinput::selection()
 
 void tst_qquicktextinput::persistentSelection()
 {
-    QQuickView canvas(testFileUrl("persistentSelection.qml"));
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
-    canvas.requestActivateWindow();
-
-    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+    QQuickView window(testFileUrl("persistentSelection.qml"));
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
+
+    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(window.rootObject());
     QVERIFY(input);
     QVERIFY(input->hasActiveFocus());
 
@@ -827,10 +911,12 @@ void tst_qquicktextinput::moveCursorSelection_data()
     QTest::newRow("jum<()>ped|words")
             << standard[0] << 23 << 23 << QQuickTextInput::SelectWords << 23 << 23 << true;
 
-    QTest::newRow("Hello<(,)> |words")
-            << standard[2] << 5 << 6 << QQuickTextInput::SelectWords << 5 << 6 << true;
-    QTest::newRow("Hello<(, )>world|words,ltr")
-            << standard[2] << 5 << 7 << QQuickTextInput::SelectWords << 5 << 7 << false;
+    QTest::newRow("<Hello(,)> |words,ltr")
+            << standard[2] << 5 << 6 << QQuickTextInput::SelectWords << 0 << 6 << false;
+    QTest::newRow("Hello<(,)> |words,rtl")
+            << standard[2] << 6 << 5 << QQuickTextInput::SelectWords << 5 << 6 << false;
+    QTest::newRow("<Hello(, )>world|words,ltr")
+            << standard[2] << 5 << 7 << QQuickTextInput::SelectWords << 0 << 7 << false;
     QTest::newRow("Hello<(, )world>|words,rtl")
             << standard[2] << 7 << 5 << QQuickTextInput::SelectWords << 5 << 12 << false;
     QTest::newRow("<Hel(lo, )>world|words,ltr")
@@ -843,35 +929,35 @@ void tst_qquicktextinput::moveCursorSelection_data()
             << standard[2] << 5 << 5 << QQuickTextInput::SelectWords << 5 << 5 << true;
     QTest::newRow("Hello,<()>|words")
             << standard[2] << 6 << 6 << QQuickTextInput::SelectWords << 6 << 6 << true;
-    QTest::newRow("Hello<,( )>world|words,ltr")
-            << standard[2] << 6 << 7 << QQuickTextInput::SelectWords << 5 << 7 << false;
+    QTest::newRow("Hello,<( )>world|words,ltr")
+            << standard[2] << 6 << 7 << QQuickTextInput::SelectWords << 6 << 7 << false;
     QTest::newRow("Hello,<( )world>|words,rtl")
             << standard[2] << 7 << 6 << QQuickTextInput::SelectWords << 6 << 12 << false;
-    QTest::newRow("Hello<,( world)>|words,ltr")
-            << standard[2] << 6 << 12 << QQuickTextInput::SelectWords << 5 << 12 << false;
-    QTest::newRow("Hello,<( world)>|words,rtl")
-            << standard[2] << 12 << 6 << QQuickTextInput::SelectWords << 6 << 12 << false;
-    QTest::newRow("Hello<,( world!)>|words,ltr")
-            << standard[2] << 6 << 13 << QQuickTextInput::SelectWords << 5 << 13 << false;
-    QTest::newRow("Hello,<( world!)>|words,rtl")
-            << standard[2] << 13 << 6 << QQuickTextInput::SelectWords << 6 << 13 << false;
-    QTest::newRow("Hello<(, world!)>|words")
-            << standard[2] << 5 << 13 << QQuickTextInput::SelectWords << 5 << 13 << true;
-    // Fails due to an issue with QTextBoundaryFinder and punctuation at the end of strings.
-    // QTBUG-11365
-    // QTest::newRow("world<(!)>|words")
-    //         << standard[2] << 12 << 13 << QQuickTextInput::SelectWords << 12 << 13 << true;
+    QTest::newRow("Hello,<( world)>|words")
+            << standard[2] << 6 << 12 << QQuickTextInput::SelectWords << 6 << 12 << true;
+    QTest::newRow("Hello,<( world!)>|words")
+            << standard[2] << 6 << 13 << QQuickTextInput::SelectWords << 6 << 13 << true;
+    QTest::newRow("<Hello(, world!)>|words,ltr")
+            << standard[2] << 5 << 13 << QQuickTextInput::SelectWords << 0 << 13 << false;
+    QTest::newRow("Hello<(, world!)>|words,rtl")
+            << standard[2] << 13 << 5 << QQuickTextInput::SelectWords << 5 << 13 << false;
+    QTest::newRow("<world(!)>|words,ltr")
+            << standard[2] << 12 << 13 << QQuickTextInput::SelectWords << 7 << 13 << false;
+    QTest::newRow("world<(!)>|words,rtl")
+            << standard[2] << 13 << 12 << QQuickTextInput::SelectWords << 12 << 13 << false;
     QTest::newRow("world!<()>)|words")
             << standard[2] << 13 << 13 << QQuickTextInput::SelectWords << 13 << 13 << true;
     QTest::newRow("world<()>!)|words")
             << standard[2] << 12 << 12 << QQuickTextInput::SelectWords << 12 << 12 << true;
 
-    QTest::newRow("<(,)>olleH |words")
-            << standard[3] << 7 << 8 << QQuickTextInput::SelectWords << 7 << 8 << true;
+    QTest::newRow("<(,)>olleH |words,ltr")
+            << standard[3] << 7 << 8 << QQuickTextInput::SelectWords << 7 << 8 << false;
+    QTest::newRow("<(,)olleH> |words,rtl")
+            << standard[3] << 8 << 7 << QQuickTextInput::SelectWords << 7 << 13 << false;
     QTest::newRow("<dlrow( ,)>olleH|words,ltr")
             << standard[3] << 6 << 8 << QQuickTextInput::SelectWords << 1 << 8 << false;
-    QTest::newRow("dlrow<( ,)>olleH|words,rtl")
-            << standard[3] << 8 << 6 << QQuickTextInput::SelectWords << 6 << 8 << false;
+    QTest::newRow("dlrow<( ,)olleH>|words,rtl")
+            << standard[3] << 8 << 6 << QQuickTextInput::SelectWords << 6 << 13 << false;
     QTest::newRow("<dlrow( ,ol)leH>|words,ltr")
             << standard[3] << 6 << 10 << QQuickTextInput::SelectWords << 1 << 13 << false;
     QTest::newRow("dlrow<( ,ol)leH>|words,rtl")
@@ -884,20 +970,20 @@ void tst_qquicktextinput::moveCursorSelection_data()
             << standard[3] << 7 << 7 << QQuickTextInput::SelectWords << 7 << 7 << true;
     QTest::newRow("<dlrow( )>,olleH|words,ltr")
             << standard[3] << 6 << 7 << QQuickTextInput::SelectWords << 1 << 7 << false;
-    QTest::newRow("dlrow<( ),>olleH|words,rtl")
-            << standard[3] << 7 << 6 << QQuickTextInput::SelectWords << 6 << 8 << false;
-    QTest::newRow("<(dlrow )>,olleH|words,ltr")
-            << standard[3] << 1 << 7 << QQuickTextInput::SelectWords << 1 << 7 << false;
-    QTest::newRow("<(dlrow ),>olleH|words,rtl")
-            << standard[3] << 7 << 1 << QQuickTextInput::SelectWords << 1 << 8 << false;
-    QTest::newRow("<(!dlrow )>,olleH|words,ltr")
-            << standard[3] << 0 << 7 << QQuickTextInput::SelectWords << 0 << 7 << false;
-    QTest::newRow("<(!dlrow ),>olleH|words,rtl")
-            << standard[3] << 7 << 0 << QQuickTextInput::SelectWords << 0 << 8 << false;
-    QTest::newRow("(!dlrow ,)olleH|words")
-            << standard[3] << 0 << 8 << QQuickTextInput::SelectWords << 0 << 8 << true;
-    QTest::newRow("<(!)>dlrow|words")
-            << standard[3] << 0 << 1 << QQuickTextInput::SelectWords << 0 << 1 << true;
+    QTest::newRow("dlrow<( )>,olleH|words,rtl")
+            << standard[3] << 7 << 6 << QQuickTextInput::SelectWords << 6 << 7 << false;
+    QTest::newRow("<(dlrow )>,olleH|words")
+            << standard[3] << 1 << 7 << QQuickTextInput::SelectWords << 1 << 7 << true;
+    QTest::newRow("<(!dlrow )>,olleH|words")
+            << standard[3] << 0 << 7 << QQuickTextInput::SelectWords << 0 << 7 << true;
+    QTest::newRow("<(!dlrow ,)>olleH|words,ltr")
+            << standard[3] << 0 << 8 << QQuickTextInput::SelectWords << 0 << 8 << false;
+    QTest::newRow("<(!dlrow ,)olleH>|words,rtl")
+            << standard[3] << 8 << 0 << QQuickTextInput::SelectWords << 0 << 13 << false;
+    QTest::newRow("<(!)>dlrow|words,ltr")
+            << standard[3] << 0 << 1 << QQuickTextInput::SelectWords << 0 << 1 << false;
+    QTest::newRow("<(!)dlrow|words,rtl")
+            << standard[3] << 1 << 0 << QQuickTextInput::SelectWords << 0 << 6 << false;
     QTest::newRow("<()>!dlrow|words")
             << standard[3] << 0 << 0 << QQuickTextInput::SelectWords << 0 << 0 << true;
     QTest::newRow("!<()>dlrow|words")
@@ -906,16 +992,15 @@ void tst_qquicktextinput::moveCursorSelection_data()
     QTest::newRow(" <s(pac)ey>   text |words")
             << standard[4] << 1 << 4 << QQuickTextInput::SelectWords << 1 << 7 << true;
     QTest::newRow(" spacey   <t(ex)t> |words")
-            << standard[4] << 11 << 13 << QQuickTextInput::SelectWords << 10 << 14 << false; // Should be reversible. QTBUG-11365
+            << standard[4] << 11 << 13 << QQuickTextInput::SelectWords << 10 << 14 << true;
     QTest::newRow("<( )>spacey   text |words|ltr")
             << standard[4] << 0 << 1 << QQuickTextInput::SelectWords << 0 << 1 << false;
     QTest::newRow("<( )spacey>   text |words|rtl")
             << standard[4] << 1 << 0 << QQuickTextInput::SelectWords << 0 << 7 << false;
     QTest::newRow("spacey   <text( )>|words|ltr")
             << standard[4] << 14 << 15 << QQuickTextInput::SelectWords << 10 << 15 << false;
-//    QTBUG-11365
-//    QTest::newRow("spacey   text<( )>|words|rtl")
-//            << standard[4] << 15 << 14 << QQuickTextInput::SelectWords << 14 << 15 << false;
+    QTest::newRow("spacey   text<( )>|words|rtl")
+            << standard[4] << 15 << 14 << QQuickTextInput::SelectWords << 14 << 15 << false;
     QTest::newRow("<()> spacey   text |words")
             << standard[4] << 0 << 0 << QQuickTextInput::SelectWords << 0 << 0 << false;
     QTest::newRow(" spacey   text <()>|words")
@@ -1112,23 +1197,21 @@ void tst_qquicktextinput::moveCursorSelectionSequence_data()
             << 15 << 12 << 15
             << 10 << 15
             << 15 << 15;
-//    QTBUG-11365
-//    QTest::newRow(" spacey   <te(xt{^ )>}|rtl")
-//            << standard[4]
-//            << 15 << 12 << 14
-//            << 10 << 15
-//            << 14 << 15;
+    QTest::newRow(" spacey   <te(xt{^ )>}|rtl")
+            << standard[4]
+            << 15 << 12 << 14
+            << 10 << 15
+            << 14 << 15;
     QTest::newRow(" spacey   {<te(x^t} )>|ltr")
             << standard[4]
             << 12 << 15 << 13
             << 10 << 15
             << 10 << 14;
-//    QTBUG-11365
-//    QTest::newRow(" spacey   {<te(xt^} )>|ltr")
-//            << standard[4]
-//            << 12 << 15 << 14
-//            << 10 << 15
-//            << 10 << 14;
+    QTest::newRow(" spacey   {<te(xt^} )>|ltr")
+            << standard[4]
+            << 12 << 15 << 14
+            << 10 << 15
+            << 10 << 14;
 }
 
 void tst_qquicktextinput::moveCursorSelectionSequence()
@@ -1167,25 +1250,23 @@ void tst_qquicktextinput::dragMouseSelection()
 {
     QString qmlfile = testFile("mouseselection_true.qml");
 
-    QQuickView canvas(QUrl::fromLocalFile(qmlfile));
+    QQuickView window(QUrl::fromLocalFile(qmlfile));
 
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
 
-    QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
-
-    QVERIFY(canvas.rootObject() != 0);
-    QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+    QVERIFY(window.rootObject() != 0);
+    QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput *>(window.rootObject());
     QVERIFY(textInputObject != 0);
 
     // press-and-drag-and-release from x1 to x2
     int x1 = 10;
     int x2 = 70;
     int y = textInputObject->height()/2;
-    QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(x1,y));
-    QTest::mouseMove(&canvas, QPoint(x2, y));
-    QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(x2,y));
+    QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(x1,y));
+    QTest::mouseMove(&window, QPoint(x2, y));
+    QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(x2,y));
     QTest::qWait(100);
     QString str1;
     QVERIFY((str1 = textInputObject->selectedText()).length() > 3);
@@ -1194,9 +1275,9 @@ void tst_qquicktextinput::dragMouseSelection()
     // press and drag the current selection.
     x1 = 40;
     x2 = 100;
-    QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(x1,y));
-    QTest::mouseMove(&canvas, QPoint(x2, y));
-    QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(x2,y));
+    QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(x1,y));
+    QTest::mouseMove(&window, QPoint(x2, y));
+    QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(x2,y));
     QTest::qWait(300);
     QString str2 = textInputObject->selectedText();
     QVERIFY(str2.length() > 3);
@@ -1232,15 +1313,14 @@ void tst_qquicktextinput::mouseSelectionMode()
 
     QString text = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
-    QQuickView canvas(QUrl::fromLocalFile(qmlfile));
+    QQuickView window(QUrl::fromLocalFile(qmlfile));
 
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
 
-    QVERIFY(canvas.rootObject() != 0);
-    QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+    QVERIFY(window.rootObject() != 0);
+    QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput *>(window.rootObject());
     QVERIFY(textInputObject != 0);
 
     textInputObject->setFocus(focus);
@@ -1250,9 +1330,9 @@ void tst_qquicktextinput::mouseSelectionMode()
     int x1 = 10;
     int x2 = 70;
     int y = textInputObject->height()/2;
-    QTest::mousePress(&canvas, Qt::LeftButton, 0, QPoint(x1,y));
-    QTest::mouseMove(&canvas, QPoint(x2,y)); // doesn't work
-    QTest::mouseRelease(&canvas, Qt::LeftButton, 0, QPoint(x2,y));
+    QTest::mousePress(&window, Qt::LeftButton, 0, QPoint(x1,y));
+    QTest::mouseMove(&window, QPoint(x2,y)); // doesn't work
+    QTest::mouseRelease(&window, Qt::LeftButton, 0, QPoint(x2,y));
     QTest::qWait(300);
     if (selectWords) {
         QTRY_COMPARE(textInputObject->selectedText(), text);
@@ -1262,39 +1342,78 @@ void tst_qquicktextinput::mouseSelectionMode()
     }
 }
 
-void tst_qquicktextinput::horizontalAlignment_data()
+void tst_qquicktextinput::mouseSelectionMode_accessors()
 {
-    QTest::addColumn<int>("hAlign");
-    QTest::addColumn<QString>("expectfile");
+    QQmlComponent component(&engine);
+    component.setData("import QtQuick 2.0\n TextInput {}", QUrl());
+    QScopedPointer<QObject> object(component.create());
+    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(object.data());
+    QVERIFY(input);
+
+    QSignalSpy spy(input, SIGNAL(mouseSelectionModeChanged(SelectionMode)));
+
+    QCOMPARE(input->mouseSelectionMode(), QQuickTextInput::SelectCharacters);
+
+    input->setMouseSelectionMode(QQuickTextInput::SelectWords);
+    QCOMPARE(input->mouseSelectionMode(), QQuickTextInput::SelectWords);
+    QCOMPARE(spy.count(), 1);
+
+    input->setMouseSelectionMode(QQuickTextInput::SelectWords);
+    QCOMPARE(spy.count(), 1);
 
-    QTest::newRow("L") << int(Qt::AlignLeft) << "halign_left";
-    QTest::newRow("R") << int(Qt::AlignRight) << "halign_right";
-    QTest::newRow("C") << int(Qt::AlignHCenter) << "halign_center";
+    input->setMouseSelectionMode(QQuickTextInput::SelectCharacters);
+    QCOMPARE(input->mouseSelectionMode(), QQuickTextInput::SelectCharacters);
+    QCOMPARE(spy.count(), 2);
 }
 
-void tst_qquicktextinput::horizontalAlignment()
+void tst_qquicktextinput::selectByMouse()
 {
-    QSKIP("Image comparison of text is almost guaranteed to fail during development");
+    QQmlComponent component(&engine);
+    component.setData("import QtQuick 2.0\n TextInput {}", QUrl());
+    QScopedPointer<QObject> object(component.create());
+    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(object.data());
+    QVERIFY(input);
 
-    QFETCH(int, hAlign);
-    QFETCH(QString, expectfile);
+    QSignalSpy spy(input, SIGNAL(selectByMouseChanged(bool)));
 
-    QQuickView canvas(testFileUrl("horizontalAlignment.qml"));
+    QCOMPARE(input->selectByMouse(), false);
 
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
-    QObject *ob = canvas.rootObject();
-    QVERIFY(ob != 0);
-    ob->setProperty("horizontalAlignment",hAlign);
-    QImage actual = canvas.grabFrameBuffer();
+    input->setSelectByMouse(true);
+    QCOMPARE(input->selectByMouse(), true);
+    QCOMPARE(spy.count(), 1);
+    QCOMPARE(spy.at(0).at(0).toBool(), true);
 
-    expectfile = createExpectedFileIfNotFound(expectfile, actual);
+    input->setSelectByMouse(true);
+    QCOMPARE(spy.count(), 1);
 
-    QImage expect(expectfile);
+    input->setSelectByMouse(false);
+    QCOMPARE(input->selectByMouse(), false);
+    QCOMPARE(spy.count(), 2);
+    QCOMPARE(spy.at(1).at(0).toBool(), false);
+}
 
-    QCOMPARE(actual,expect);
+void tst_qquicktextinput::renderType()
+{
+    QQmlComponent component(&engine);
+    component.setData("import QtQuick 2.0\n TextInput {}", QUrl());
+    QScopedPointer<QObject> object(component.create());
+    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(object.data());
+    QVERIFY(input);
+
+    QSignalSpy spy(input, SIGNAL(renderTypeChanged()));
+
+    QCOMPARE(input->renderType(), QQuickTextInput::QtRendering);
+
+    input->setRenderType(QQuickTextInput::NativeRendering);
+    QCOMPARE(input->renderType(), QQuickTextInput::NativeRendering);
+    QCOMPARE(spy.count(), 1);
+
+    input->setRenderType(QQuickTextInput::NativeRendering);
+    QCOMPARE(spy.count(), 1);
+
+    input->setRenderType(QQuickTextInput::QtRendering);
+    QCOMPARE(input->renderType(), QQuickTextInput::QtRendering);
+    QCOMPARE(spy.count(), 2);
 }
 
 void tst_qquicktextinput::horizontalAlignment_RightToLeft()
@@ -1303,10 +1422,10 @@ void tst_qquicktextinput::horizontalAlignment_RightToLeft()
     QInputMethodPrivate *inputMethodPrivate = QInputMethodPrivate::get(qApp->inputMethod());
     inputMethodPrivate->testContext = &platformInputContext;
 
-    QQuickView canvas(testFileUrl("horizontalAlignment_RightToLeft.qml"));
-    QQuickTextInput *textInput = canvas.rootObject()->findChild<QQuickTextInput*>("text");
+    QQuickView window(testFileUrl("horizontalAlignment_RightToLeft.qml"));
+    QQuickTextInput *textInput = window.rootObject()->findChild<QQuickTextInput*>("text");
     QVERIFY(textInput != 0);
-    canvas.show();
+    window.show();
 
     const QString rtlText = textInput->text();
 
@@ -1378,20 +1497,20 @@ void tst_qquicktextinput::horizontalAlignment_RightToLeft()
     QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignLeft);
     QCOMPARE(textInput->boundingRect().left(), qreal(0));
 
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
+    QVERIFY(textInput->hasActiveFocus());
 
-    // If there is no commited text, the preedit text should determine the alignment.
+    // If there is no committed text, the preedit text should determine the alignment.
     textInput->setText(QString());
-    { QInputMethodEvent ev(rtlText, QList<QInputMethodEvent::Attribute>()); QGuiApplication::sendEvent(qGuiApp->focusObject(), &ev); }
+    { QInputMethodEvent ev(rtlText, QList<QInputMethodEvent::Attribute>()); QGuiApplication::sendEvent(textInput, &ev); }
     QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignRight);
-    { QInputMethodEvent ev("Hello world!", QList<QInputMethodEvent::Attribute>()); QGuiApplication::sendEvent(qGuiApp->focusObject(), &ev); }
+    { QInputMethodEvent ev("Hello world!", QList<QInputMethodEvent::Attribute>()); QGuiApplication::sendEvent(textInput, &ev); }
     QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignLeft);
 
     // Clear pre-edit text.  TextInput should maybe do this itself on setText, but that may be
     // redundant as an actual input method may take care of it.
-    { QInputMethodEvent ev; QGuiApplication::sendEvent(qGuiApp->focusObject(), &ev); }
+    { QInputMethodEvent ev; QGuiApplication::sendEvent(textInput, &ev); }
 
     // empty text with implicit alignment follows the system locale-based
     // keyboard input direction from QInputMethod::inputDirection()
@@ -1413,7 +1532,7 @@ void tst_qquicktextinput::horizontalAlignment_RightToLeft()
     platformInputContext.setInputDirection(Qt::LeftToRight);
     textInput->setText("a");
     platformInputContext.setInputDirection(Qt::RightToLeft);
-    QTest::keyClick(&canvas, Qt::Key_Backspace);
+    QTest::keyClick(&window, Qt::Key_Backspace);
     QVERIFY(textInput->text().isEmpty());
     QCOMPARE(textInput->hAlign(), QQuickTextInput::AlignRight);
     QVERIFY(textInput->boundingRect().right() >= textInput->width() - 1);
@@ -1450,32 +1569,32 @@ void tst_qquicktextinput::horizontalAlignment_RightToLeft()
 
 void tst_qquicktextinput::verticalAlignment()
 {
-    QQuickView canvas(testFileUrl("horizontalAlignment.qml"));
-    QQuickTextInput *textInput = canvas.rootObject()->findChild<QQuickTextInput*>("text");
+    QQuickView window(testFileUrl("horizontalAlignment.qml"));
+    QQuickTextInput *textInput = window.rootObject()->findChild<QQuickTextInput*>("text");
     QVERIFY(textInput != 0);
-    canvas.show();
+    window.show();
 
     QCOMPARE(textInput->vAlign(), QQuickTextInput::AlignTop);
-    QVERIFY(textInput->boundingRect().bottom() < canvas.height() / 2);
-    QVERIFY(textInput->cursorRectangle().bottom() < canvas.height() / 2);
-    QVERIFY(textInput->positionToRectangle(0).bottom() < canvas.height() / 2);
+    QVERIFY(textInput->boundingRect().bottom() < window.height() / 2);
+    QVERIFY(textInput->cursorRectangle().bottom() < window.height() / 2);
+    QVERIFY(textInput->positionToRectangle(0).bottom() < window.height() / 2);
 
     // bottom aligned
     textInput->setVAlign(QQuickTextInput::AlignBottom);
     QCOMPARE(textInput->vAlign(), QQuickTextInput::AlignBottom);
-    QVERIFY(textInput->boundingRect().top() > canvas.height() / 2);
-    QVERIFY(textInput->cursorRectangle().top() > canvas.height() / 2);
-    QVERIFY(textInput->positionToRectangle(0).top() > canvas.height() / 2);
+    QVERIFY(textInput->boundingRect().top() > window.height() / 2);
+    QVERIFY(textInput->cursorRectangle().top() > window.height() / 2);
+    QVERIFY(textInput->positionToRectangle(0).top() > window.height() / 2);
 
     // explicitly center aligned
     textInput->setVAlign(QQuickTextInput::AlignVCenter);
     QCOMPARE(textInput->vAlign(), QQuickTextInput::AlignVCenter);
-    QVERIFY(textInput->boundingRect().top() < canvas.height() / 2);
-    QVERIFY(textInput->boundingRect().bottom() > canvas.height() / 2);
-    QVERIFY(textInput->cursorRectangle().top() < canvas.height() / 2);
-    QVERIFY(textInput->cursorRectangle().bottom() > canvas.height() / 2);
-    QVERIFY(textInput->positionToRectangle(0).top() < canvas.height() / 2);
-    QVERIFY(textInput->positionToRectangle(0).bottom() > canvas.height() / 2);
+    QVERIFY(textInput->boundingRect().top() < window.height() / 2);
+    QVERIFY(textInput->boundingRect().bottom() > window.height() / 2);
+    QVERIFY(textInput->cursorRectangle().top() < window.height() / 2);
+    QVERIFY(textInput->cursorRectangle().bottom() > window.height() / 2);
+    QVERIFY(textInput->positionToRectangle(0).top() < window.height() / 2);
+    QVERIFY(textInput->positionToRectangle(0).bottom() > window.height() / 2);
 }
 
 void tst_qquicktextinput::clipRect()
@@ -1638,13 +1757,13 @@ void tst_qquicktextinput::boundingRect()
 
 void tst_qquicktextinput::positionAt()
 {
-    QQuickView canvas(testFileUrl("positionAt.qml"));
-    QVERIFY(canvas.rootObject() != 0);
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
+    QQuickView window(testFileUrl("positionAt.qml"));
+    QVERIFY(window.rootObject() != 0);
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
 
-    QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+    QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(window.rootObject());
     QVERIFY(textinputObject != 0);
 
     // Check autoscrolled...
@@ -1697,7 +1816,7 @@ void tst_qquicktextinput::positionAt()
 
     {   QInputMethodEvent inputEvent(preeditText, QList<QInputMethodEvent::Attribute>());
         QVERIFY(qGuiApp->focusObject());
-        QGuiApplication::sendEvent(qGuiApp->focusObject(), &inputEvent); }
+        QGuiApplication::sendEvent(textinputObject, &inputEvent); }
 
     // Check all points within the preedit text return the same position.
     QCOMPARE(evaluate<int>(textinputObject, QString("positionAt(%1)").arg(0)), 0);
@@ -1710,7 +1829,7 @@ void tst_qquicktextinput::positionAt()
 
     {   QInputMethodEvent inputEvent;
         QVERIFY(qGuiApp->focusObject());
-        QGuiApplication::sendEvent(qGuiApp->focusObject(), &inputEvent); }
+        QGuiApplication::sendEvent(textinputObject, &inputEvent); }
 
     // With wrapping.
     textinputObject->setWrapMode(QQuickTextInput::WrapAnywhere);
@@ -1728,13 +1847,13 @@ void tst_qquicktextinput::positionAt()
 
 void tst_qquicktextinput::maxLength()
 {
-    QQuickView canvas(testFileUrl("maxLength.qml"));
-    QVERIFY(canvas.rootObject() != 0);
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
+    QQuickView window(testFileUrl("maxLength.qml"));
+    QVERIFY(window.rootObject() != 0);
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
 
-    QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+    QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(window.rootObject());
     QVERIFY(textinputObject != 0);
     QVERIFY(textinputObject->text().isEmpty());
     QVERIFY(textinputObject->maxLength() == 10);
@@ -1748,9 +1867,9 @@ void tst_qquicktextinput::maxLength()
     QTRY_VERIFY(textinputObject->hasActiveFocus() == true);
     for (int i=0; i<20; i++) {
         QTRY_COMPARE(textinputObject->text().length(), qMin(i,10));
-        //simulateKey(&canvas, Qt::Key_A);
-        QTest::keyPress(&canvas, Qt::Key_A);
-        QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+        //simulateKey(&window, Qt::Key_A);
+        QTest::keyPress(&window, Qt::Key_A);
+        QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
         QTest::qWait(50);
     }
 }
@@ -1759,11 +1878,11 @@ void tst_qquicktextinput::masks()
 {
     //Not a comprehensive test of the possible masks, that's done elsewhere (QLineEdit)
     //QString componentStr = "import QtQuick 2.0\nTextInput {  inputMask: 'HHHHhhhh'; }";
-    QQuickView canvas(testFileUrl("masks.qml"));
-    canvas.show();
-    canvas.requestActivateWindow();
-    QVERIFY(canvas.rootObject() != 0);
-    QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+    QQuickView window(testFileUrl("masks.qml"));
+    window.show();
+    window.requestActivateWindow();
+    QVERIFY(window.rootObject() != 0);
+    QQuickTextInput *textinputObject = qobject_cast<QQuickTextInput *>(window.rootObject());
     QVERIFY(textinputObject != 0);
     QTRY_VERIFY(textinputObject->hasActiveFocus() == true);
     QVERIFY(textinputObject->text().length() == 0);
@@ -1775,9 +1894,9 @@ void tst_qquicktextinput::masks()
         QCOMPARE(textinputObject->getText(0, qMin(i, 8)), QString(qMin(i, 8), 'a'));
         QCOMPARE(textinputObject->getText(qMin(i, 8), 8), QString(8 - qMin(i, 8), ' '));
         QCOMPARE(i>=4, textinputObject->hasAcceptableInput());
-        //simulateKey(&canvas, Qt::Key_A);
-        QTest::keyPress(&canvas, Qt::Key_A);
-        QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+        //simulateKey(&window, Qt::Key_A);
+        QTest::keyPress(&window, Qt::Key_A);
+        QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
         QTest::qWait(50);
     }
 }
@@ -1790,17 +1909,18 @@ void tst_qquicktextinput::validators()
 
     QLocale::setDefault(QLocale(QStringLiteral("C")));
 
-    QQuickView canvas(testFileUrl("validators.qml"));
-    canvas.show();
-    canvas.requestActivateWindow();
+    QQuickView window(testFileUrl("validators.qml"));
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
 
-    QVERIFY(canvas.rootObject() != 0);
+    QVERIFY(window.rootObject() != 0);
 
     QLocale defaultLocale;
     QLocale enLocale("en");
     QLocale deLocale("de_DE");
 
-    QQuickTextInput *intInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("intInput")));
+    QQuickTextInput *intInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("intInput")));
     QVERIFY(intInput);
     QSignalSpy intSpy(intInput, SIGNAL(acceptableInputChanged()));
 
@@ -1819,63 +1939,63 @@ void tst_qquicktextinput::validators()
     QTRY_VERIFY(intInput->hasActiveFocus());
     QCOMPARE(intInput->hasAcceptableInput(), false);
     QCOMPARE(intInput->property("acceptable").toBool(), false);
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(intInput->text(), QLatin1String("1"));
     QCOMPARE(intInput->hasAcceptableInput(), false);
     QCOMPARE(intInput->property("acceptable").toBool(), false);
     QCOMPARE(intSpy.count(), 0);
-    QTest::keyPress(&canvas, Qt::Key_2);
-    QTest::keyRelease(&canvas, Qt::Key_2, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_2);
+    QTest::keyRelease(&window, Qt::Key_2, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(intInput->text(), QLatin1String("1"));
     QCOMPARE(intInput->hasAcceptableInput(), false);
     QCOMPARE(intInput->property("acceptable").toBool(), false);
     QCOMPARE(intSpy.count(), 0);
-    QTest::keyPress(&canvas, Qt::Key_Period);
-    QTest::keyRelease(&canvas, Qt::Key_Period, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Period);
+    QTest::keyRelease(&window, Qt::Key_Period, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(intInput->text(), QLatin1String("1"));
     QCOMPARE(intInput->hasAcceptableInput(), false);
-    QTest::keyPress(&canvas, Qt::Key_Comma);
-    QTest::keyRelease(&canvas, Qt::Key_Comma, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Comma);
+    QTest::keyRelease(&window, Qt::Key_Comma, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(intInput->text(), QLatin1String("1,"));
     QCOMPARE(intInput->hasAcceptableInput(), false);
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
-    QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Backspace);
+    QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(intInput->text(), QLatin1String("1"));
     QCOMPARE(intInput->hasAcceptableInput(), false);
     intValidator->setLocaleName(deLocale.name());
-    QTest::keyPress(&canvas, Qt::Key_Period);
-    QTest::keyRelease(&canvas, Qt::Key_Period, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Period);
+    QTest::keyRelease(&window, Qt::Key_Period, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(intInput->text(), QLatin1String("1."));
     QCOMPARE(intInput->hasAcceptableInput(), false);
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
-    QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Backspace);
+    QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(intInput->text(), QLatin1String("1"));
     QCOMPARE(intInput->hasAcceptableInput(), false);
     intValidator->resetLocaleName();
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QCOMPARE(intInput->text(), QLatin1String("11"));
     QCOMPARE(intInput->hasAcceptableInput(), true);
     QCOMPARE(intInput->property("acceptable").toBool(), true);
     QCOMPARE(intSpy.count(), 1);
-    QTest::keyPress(&canvas, Qt::Key_0);
-    QTest::keyRelease(&canvas, Qt::Key_0, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_0);
+    QTest::keyRelease(&window, Qt::Key_0, Qt::NoModifier ,10);
     QTest::qWait(50);
     QCOMPARE(intInput->text(), QLatin1String("11"));
     QCOMPARE(intInput->hasAcceptableInput(), true);
     QCOMPARE(intInput->property("acceptable").toBool(), true);
     QCOMPARE(intSpy.count(), 1);
 
-    QQuickTextInput *dblInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("dblInput")));
+    QQuickTextInput *dblInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("dblInput")));
     QVERIFY(dblInput);
     QSignalSpy dblSpy(dblInput, SIGNAL(acceptableInputChanged()));
 
@@ -1894,81 +2014,81 @@ void tst_qquicktextinput::validators()
     QVERIFY(dblInput->hasActiveFocus() == true);
     QCOMPARE(dblInput->hasAcceptableInput(), false);
     QCOMPARE(dblInput->property("acceptable").toBool(), false);
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("1"));
     QCOMPARE(dblInput->hasAcceptableInput(), false);
     QCOMPARE(dblInput->property("acceptable").toBool(), false);
     QCOMPARE(dblSpy.count(), 0);
-    QTest::keyPress(&canvas, Qt::Key_2);
-    QTest::keyRelease(&canvas, Qt::Key_2, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_2);
+    QTest::keyRelease(&window, Qt::Key_2, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12"));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
     QCOMPARE(dblInput->property("acceptable").toBool(), true);
     QCOMPARE(dblSpy.count(), 1);
-    QTest::keyPress(&canvas, Qt::Key_Comma);
-    QTest::keyRelease(&canvas, Qt::Key_Comma, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Comma);
+    QTest::keyRelease(&window, Qt::Key_Comma, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12,"));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12,"));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
     dblValidator->setLocaleName(deLocale.name());
     QCOMPARE(dblInput->hasAcceptableInput(), true);
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12,1"));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12,11"));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
-    QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Backspace);
+    QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12,1"));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
-    QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Backspace);
+    QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12,"));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
-    QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Backspace);
+    QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12"));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
     dblValidator->resetLocaleName();
-    QTest::keyPress(&canvas, Qt::Key_Period);
-    QTest::keyRelease(&canvas, Qt::Key_Period, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Period);
+    QTest::keyRelease(&window, Qt::Key_Period, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12."));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
     QCOMPARE(dblInput->property("acceptable").toBool(), true);
     QCOMPARE(dblSpy.count(), 1);
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12.1"));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
     QCOMPARE(dblInput->property("acceptable").toBool(), true);
     QCOMPARE(dblSpy.count(), 1);
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12.11"));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
     QCOMPARE(dblInput->property("acceptable").toBool(), true);
     QCOMPARE(dblSpy.count(), 1);
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12.11"));
     QCOMPARE(dblInput->hasAcceptableInput(), true);
@@ -1981,50 +2101,50 @@ void tst_qquicktextinput::validators()
     QCOMPARE(dblInput->hasAcceptableInput(), false);
     QCOMPARE(dblInput->property("acceptable").toBool(), false);
     QCOMPARE(dblSpy.count(), 2);
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
-    QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Backspace);
+    QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12.1"));
     QCOMPARE(dblInput->hasAcceptableInput(), false);
     QCOMPARE(dblInput->property("acceptable").toBool(), false);
     QCOMPARE(dblSpy.count(), 2);
     // Once unacceptable input is in anything goes until it reaches an acceptable state again.
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12.11"));
     QCOMPARE(dblInput->hasAcceptableInput(), false);
     QCOMPARE(dblSpy.count(), 2);
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
-    QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Backspace);
+    QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12.1"));
     QCOMPARE(dblInput->hasAcceptableInput(), false);
     QCOMPARE(dblInput->property("acceptable").toBool(), false);
     QCOMPARE(dblSpy.count(), 2);
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
-    QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Backspace);
+    QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12."));
     QCOMPARE(dblInput->hasAcceptableInput(), false);
     QCOMPARE(dblInput->property("acceptable").toBool(), false);
     QCOMPARE(dblSpy.count(), 2);
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
-    QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Backspace);
+    QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("12"));
     QCOMPARE(dblInput->hasAcceptableInput(), false);
     QCOMPARE(dblInput->property("acceptable").toBool(), false);
     QCOMPARE(dblSpy.count(), 2);
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
-    QTest::keyRelease(&canvas, Qt::Key_Backspace, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_Backspace);
+    QTest::keyRelease(&window, Qt::Key_Backspace, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(dblInput->text(), QLatin1String("1"));
     QCOMPARE(dblInput->hasAcceptableInput(), false);
     QCOMPARE(dblInput->property("acceptable").toBool(), false);
     QCOMPARE(dblSpy.count(), 2);
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QCOMPARE(dblInput->text(), QLatin1String("11"));
     QCOMPARE(dblInput->property("acceptable").toBool(), true);
@@ -2041,72 +2161,72 @@ void tst_qquicktextinput::validators()
     QCOMPARE(dblInput->hasAcceptableInput(), true);
     QCOMPARE(dblSpy.count(), 5);
 
-    QQuickTextInput *strInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("strInput")));
+    QQuickTextInput *strInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("strInput")));
     QVERIFY(strInput);
     QSignalSpy strSpy(strInput, SIGNAL(acceptableInputChanged()));
     strInput->setFocus(true);
     QVERIFY(strInput->hasActiveFocus() == true);
     QCOMPARE(strInput->hasAcceptableInput(), false);
     QCOMPARE(strInput->property("acceptable").toBool(), false);
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(strInput->text(), QLatin1String(""));
     QCOMPARE(strInput->hasAcceptableInput(), false);
     QCOMPARE(strInput->property("acceptable").toBool(), false);
     QCOMPARE(strSpy.count(), 0);
-    QTest::keyPress(&canvas, Qt::Key_A);
-    QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_A);
+    QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(strInput->text(), QLatin1String("a"));
     QCOMPARE(strInput->hasAcceptableInput(), false);
     QCOMPARE(strInput->property("acceptable").toBool(), false);
     QCOMPARE(strSpy.count(), 0);
-    QTest::keyPress(&canvas, Qt::Key_A);
-    QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_A);
+    QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(strInput->text(), QLatin1String("aa"));
     QCOMPARE(strInput->hasAcceptableInput(), true);
     QCOMPARE(strInput->property("acceptable").toBool(), true);
     QCOMPARE(strSpy.count(), 1);
-    QTest::keyPress(&canvas, Qt::Key_A);
-    QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_A);
+    QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(strInput->text(), QLatin1String("aaa"));
     QCOMPARE(strInput->hasAcceptableInput(), true);
     QCOMPARE(strInput->property("acceptable").toBool(), true);
     QCOMPARE(strSpy.count(), 1);
-    QTest::keyPress(&canvas, Qt::Key_A);
-    QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_A);
+    QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(strInput->text(), QLatin1String("aaaa"));
     QCOMPARE(strInput->hasAcceptableInput(), true);
     QCOMPARE(strInput->property("acceptable").toBool(), true);
     QCOMPARE(strSpy.count(), 1);
-    QTest::keyPress(&canvas, Qt::Key_A);
-    QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_A);
+    QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(strInput->text(), QLatin1String("aaaa"));
     QCOMPARE(strInput->hasAcceptableInput(), true);
     QCOMPARE(strInput->property("acceptable").toBool(), true);
     QCOMPARE(strSpy.count(), 1);
 
-    QQuickTextInput *unvalidatedInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("unvalidatedInput")));
+    QQuickTextInput *unvalidatedInput = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("unvalidatedInput")));
     QVERIFY(unvalidatedInput);
     QSignalSpy unvalidatedSpy(unvalidatedInput, SIGNAL(acceptableInputChanged()));
     unvalidatedInput->setFocus(true);
     QVERIFY(unvalidatedInput->hasActiveFocus() == true);
     QCOMPARE(unvalidatedInput->hasAcceptableInput(), true);
     QCOMPARE(unvalidatedInput->property("acceptable").toBool(), true);
-    QTest::keyPress(&canvas, Qt::Key_1);
-    QTest::keyRelease(&canvas, Qt::Key_1, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_1);
+    QTest::keyRelease(&window, Qt::Key_1, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(unvalidatedInput->text(), QLatin1String("1"));
     QCOMPARE(unvalidatedInput->hasAcceptableInput(), true);
     QCOMPARE(unvalidatedInput->property("acceptable").toBool(), true);
     QCOMPARE(unvalidatedSpy.count(), 0);
-    QTest::keyPress(&canvas, Qt::Key_A);
-    QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_A);
+    QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
     QTest::qWait(50);
     QTRY_COMPARE(unvalidatedInput->text(), QLatin1String("1a"));
     QCOMPARE(unvalidatedInput->hasAcceptableInput(), true);
@@ -2116,14 +2236,14 @@ void tst_qquicktextinput::validators()
 
 void tst_qquicktextinput::inputMethods()
 {
-    QQuickView canvas(testFileUrl("inputmethods.qml"));
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
+    QQuickView window(testFileUrl("inputmethods.qml"));
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
 
     // test input method hints
-    QVERIFY(canvas.rootObject() != 0);
-    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(canvas.rootObject());
+    QVERIFY(window.rootObject() != 0);
+    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(window.rootObject());
     QVERIFY(input != 0);
     QVERIFY(input->inputMethodHints() & Qt::ImhNoPredictiveText);
     QSignalSpy inputMethodHintSpy(input, SIGNAL(inputMethodHintsChanged()));
@@ -2143,24 +2263,24 @@ void tst_qquicktextinput::inputMethods()
     QInputMethodEvent event;
     event.setCommitString( "My ", -12, 0);
     QTRY_COMPARE(qGuiApp->focusObject(), input);
-    QGuiApplication::sendEvent(qGuiApp->focusObject(), &event);
+    QGuiApplication::sendEvent(input, &event);
     QCOMPARE(input->text(), QString("My Hello world!"));
 
     input->setCursorPosition(2);
     event.setCommitString("Your", -2, 2);
-    QGuiApplication::sendEvent(qGuiApp->focusObject(), &event);
+    QGuiApplication::sendEvent(input, &event);
     QCOMPARE(input->text(), QString("Your Hello world!"));
     QCOMPARE(input->cursorPosition(), 4);
 
     input->setCursorPosition(7);
     event.setCommitString("Goodbye", -2, 5);
-    QGuiApplication::sendEvent(qGuiApp->focusObject(), &event);
+    QGuiApplication::sendEvent(input, &event);
     QCOMPARE(input->text(), QString("Your Goodbye world!"));
     QCOMPARE(input->cursorPosition(), 12);
 
     input->setCursorPosition(8);
     event.setCommitString("Our", -8, 4);
-    QGuiApplication::sendEvent(qGuiApp->focusObject(), &event);
+    QGuiApplication::sendEvent(input, &event);
     QCOMPARE(input->text(), QString("Our Goodbye world!"));
     QCOMPARE(input->cursorPosition(), 7);
 
@@ -2169,7 +2289,7 @@ void tst_qquicktextinput::inputMethods()
     input->setCursorPosition(0);
     input->moveCursorSelection(input->text().length());
     event.setCommitString("replacement", -input->text().length(), input->text().length());
-    QGuiApplication::sendEvent(qGuiApp->focusObject(), &event);
+    QGuiApplication::sendEvent(input, &event);
     QCOMPARE(input->selectionStart(), input->selectionEnd());
 
     QInputMethodQueryEvent enabledQueryEvent(Qt::ImEnabled);
@@ -2188,62 +2308,62 @@ the extent of the text, then they should ignore the keys.
 */
 void tst_qquicktextinput::navigation()
 {
-    QQuickView canvas(testFileUrl("navigation.qml"));
-    canvas.show();
-    canvas.requestActivateWindow();
+    QQuickView window(testFileUrl("navigation.qml"));
+    window.show();
+    window.requestActivateWindow();
 
-    QVERIFY(canvas.rootObject() != 0);
+    QVERIFY(window.rootObject() != 0);
 
-    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
 
     QVERIFY(input != 0);
     input->setCursorPosition(0);
     QTRY_VERIFY(input->hasActiveFocus() == true);
-    simulateKey(&canvas, Qt::Key_Left);
+    simulateKey(&window, Qt::Key_Left);
     QVERIFY(input->hasActiveFocus() == false);
-    simulateKey(&canvas, Qt::Key_Right);
+    simulateKey(&window, Qt::Key_Right);
     QVERIFY(input->hasActiveFocus() == true);
     //QT-2944: If text is selected, ensure we deselect upon cursor motion
     input->setCursorPosition(input->text().length());
     input->select(0,input->text().length());
     QVERIFY(input->selectionStart() != input->selectionEnd());
-    simulateKey(&canvas, Qt::Key_Right);
+    simulateKey(&window, Qt::Key_Right);
     QVERIFY(input->selectionStart() == input->selectionEnd());
     QVERIFY(input->selectionStart() == input->text().length());
     QVERIFY(input->hasActiveFocus() == true);
-    simulateKey(&canvas, Qt::Key_Right);
+    simulateKey(&window, Qt::Key_Right);
     QVERIFY(input->hasActiveFocus() == false);
-    simulateKey(&canvas, Qt::Key_Left);
+    simulateKey(&window, Qt::Key_Left);
     QVERIFY(input->hasActiveFocus() == true);
 
     // Up and Down should NOT do Home/End, even on Mac OS X (QTBUG-10438).
     input->setCursorPosition(2);
     QCOMPARE(input->cursorPosition(),2);
-    simulateKey(&canvas, Qt::Key_Up);
+    simulateKey(&window, Qt::Key_Up);
     QCOMPARE(input->cursorPosition(),2);
-    simulateKey(&canvas, Qt::Key_Down);
+    simulateKey(&window, Qt::Key_Down);
     QCOMPARE(input->cursorPosition(),2);
 
     // Test left and right navigation works if the TextInput is empty (QTBUG-25447).
     input->setText(QString());
     QCOMPARE(input->cursorPosition(), 0);
-    simulateKey(&canvas, Qt::Key_Right);
+    simulateKey(&window, Qt::Key_Right);
     QCOMPARE(input->hasActiveFocus(), false);
-    simulateKey(&canvas, Qt::Key_Left);
+    simulateKey(&window, Qt::Key_Left);
     QCOMPARE(input->hasActiveFocus(), true);
-    simulateKey(&canvas, Qt::Key_Left);
+    simulateKey(&window, Qt::Key_Left);
     QCOMPARE(input->hasActiveFocus(), false);
 }
 
 void tst_qquicktextinput::navigation_RTL()
 {
-    QQuickView canvas(testFileUrl("navigation.qml"));
-    canvas.show();
-    canvas.requestActivateWindow();
+    QQuickView window(testFileUrl("navigation.qml"));
+    window.show();
+    window.requestActivateWindow();
 
-    QVERIFY(canvas.rootObject() != 0);
+    QVERIFY(window.rootObject() != 0);
 
-    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
 
     QVERIFY(input != 0);
     const quint16 arabic_str[] = { 0x0638, 0x0643, 0x00646, 0x0647, 0x0633, 0x0638, 0x0643, 0x00646, 0x0647, 0x0633, 0x0647};
@@ -2253,38 +2373,30 @@ void tst_qquicktextinput::navigation_RTL()
     QTRY_VERIFY(input->hasActiveFocus() == true);
 
     // move off
-    simulateKey(&canvas, Qt::Key_Right);
+    simulateKey(&window, Qt::Key_Right);
     QVERIFY(input->hasActiveFocus() == false);
 
     // move back
-    simulateKey(&canvas, Qt::Key_Left);
+    simulateKey(&window, Qt::Key_Left);
     QVERIFY(input->hasActiveFocus() == true);
 
     input->setCursorPosition(input->text().length());
     QVERIFY(input->hasActiveFocus() == true);
 
     // move off
-    simulateKey(&canvas, Qt::Key_Left);
+    simulateKey(&window, Qt::Key_Left);
     QVERIFY(input->hasActiveFocus() == false);
 
     // move back
-    simulateKey(&canvas, Qt::Key_Right);
+    simulateKey(&window, Qt::Key_Right);
     QVERIFY(input->hasActiveFocus() == true);
 }
 
-void tst_qquicktextinput::copyAndPaste() {
 #ifndef QT_NO_CLIPBOARD
-
-#ifdef Q_OS_MAC
-    {
-        PasteboardRef pasteboard;
-        OSStatus status = PasteboardCreate(0, &pasteboard);
-        if (status == noErr)
-            CFRelease(pasteboard);
-        else
-            QSKIP("This machine doesn't support the clipboard");
-    }
-#endif
+void tst_qquicktextinput::copyAndPaste()
+{
+    if (!PlatformQuirks::isClipboardAvailable())
+        QSKIP("This machine doesn't support the clipboard");
 
     QString componentStr = "import QtQuick 2.0\nTextInput { text: \"Hello world!\" }";
     QQmlComponent textInputComponent(&engine);
@@ -2308,14 +2420,27 @@ void tst_qquicktextinput::copyAndPaste() {
     QVERIFY(textInput->canPaste());
     textInput->setReadOnly(true);
     QVERIFY(!textInput->canPaste());
+    textInput->paste();
+    QCOMPARE(textInput->text(), QString("Hello world!Hello world!"));
+    QCOMPARE(textInput->text().length(), 24);
     textInput->setReadOnly(false);
     QVERIFY(textInput->canPaste());
 
+    // cut: no selection
+    textInput->cut();
+    QCOMPARE(textInput->text(), QString("Hello world!Hello world!"));
+
     // select word
     textInput->setCursorPosition(0);
     textInput->selectWord();
     QCOMPARE(textInput->selectedText(), QString("Hello"));
 
+    // cut: read only.
+    textInput->setReadOnly(true);
+    textInput->cut();
+    QCOMPARE(textInput->text(), QString("Hello world!Hello world!"));
+    textInput->setReadOnly(false);
+
     // select all and cut
     textInput->selectAll();
     textInput->cut();
@@ -2324,6 +2449,18 @@ void tst_qquicktextinput::copyAndPaste() {
     QCOMPARE(textInput->text(), QString("Hello world!Hello world!"));
     QCOMPARE(textInput->text().length(), 24);
 
+    // Copy first word.
+    textInput->setCursorPosition(0);
+    textInput->selectWord();
+    textInput->copy();
+    // copy: no selection, previous copy retained;
+    textInput->setCursorPosition(0);
+    QCOMPARE(textInput->selectedText(), QString());
+    textInput->copy();
+    textInput->setText(QString());
+    textInput->paste();
+    QCOMPARE(textInput->text(), QString("Hello"));
+
     // clear copy buffer
     QClipboard *clipboard = QGuiApplication::clipboard();
     QVERIFY(clipboard);
@@ -2350,22 +2487,14 @@ void tst_qquicktextinput::copyAndPaste() {
     }
 
     delete textInput;
-#endif
 }
+#endif
 
-void tst_qquicktextinput::copyAndPasteKeySequence() {
 #ifndef QT_NO_CLIPBOARD
-
-#ifdef Q_OS_MAC
-    {
-        PasteboardRef pasteboard;
-        OSStatus status = PasteboardCreate(0, &pasteboard);
-        if (status == noErr)
-            CFRelease(pasteboard);
-        else
-            QSKIP("This machine doesn't support the clipboard");
-    }
-#endif
+void tst_qquicktextinput::copyAndPasteKeySequence()
+{
+    if (!PlatformQuirks::isClipboardAvailable())
+        QSKIP("This machine doesn't support the clipboard");
 
     QString componentStr = "import QtQuick 2.0\nTextInput { text: \"Hello world!\"; focus: true }";
     QQmlComponent textInputComponent(&engine);
@@ -2373,31 +2502,30 @@ void tst_qquicktextinput::copyAndPasteKeySequence() {
     QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
     QVERIFY(textInput != 0);
 
-    QQuickCanvas canvas;
-    textInput->setParentItem(canvas.rootItem());
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(QGuiApplication::focusWindow(), &canvas);
+    QQuickWindow window;
+    textInput->setParentItem(window.contentItem());
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
 
     // copy and paste
     QVERIFY(textInput->hasActiveFocus());
     QCOMPARE(textInput->text().length(), 12);
     textInput->select(0, textInput->text().length());
-    simulateKeys(&canvas, QKeySequence::Copy);
+    simulateKeys(&window, QKeySequence::Copy);
     QCOMPARE(textInput->selectedText(), QString("Hello world!"));
     QCOMPARE(textInput->selectedText().length(), 12);
     textInput->setCursorPosition(0);
     QVERIFY(textInput->canPaste());
-    simulateKeys(&canvas, QKeySequence::Paste);
+    simulateKeys(&window, QKeySequence::Paste);
     QCOMPARE(textInput->text(), QString("Hello world!Hello world!"));
     QCOMPARE(textInput->text().length(), 24);
 
     // select all and cut
-    simulateKeys(&canvas, QKeySequence::SelectAll);
-    simulateKeys(&canvas, QKeySequence::Cut);
+    simulateKeys(&window, QKeySequence::SelectAll);
+    simulateKeys(&window, QKeySequence::Cut);
     QCOMPARE(textInput->text().length(), 0);
-    simulateKeys(&canvas, QKeySequence::Paste);
+    simulateKeys(&window, QKeySequence::Paste);
     QCOMPARE(textInput->text(), QString("Hello world!Hello world!"));
     QCOMPARE(textInput->text().length(), 24);
 
@@ -2415,7 +2543,7 @@ void tst_qquicktextinput::copyAndPasteKeySequence() {
         textInput->setEchoMode(echoMode);
         textInput->setText("My password");
         textInput->select(0, textInput->text().length());
-        simulateKeys(&canvas, QKeySequence::Copy);
+        simulateKeys(&window, QKeySequence::Copy);
         if (echoMode == QQuickTextInput::Normal) {
             QVERIFY(!clipboard->text().isEmpty());
             QCOMPARE(clipboard->text(), QString("My password"));
@@ -2427,12 +2555,12 @@ void tst_qquicktextinput::copyAndPasteKeySequence() {
     }
 
     delete textInput;
-#endif
 }
+#endif
 
-void tst_qquicktextinput::canPasteEmpty() {
 #ifndef QT_NO_CLIPBOARD
-
+void tst_qquicktextinput::canPasteEmpty()
+{
     QGuiApplication::clipboard()->clear();
 
     QString componentStr = "import QtQuick 2.0\nTextInput { text: \"Hello world!\" }";
@@ -2443,13 +2571,12 @@ void tst_qquicktextinput::canPasteEmpty() {
 
     bool cp = !textInput->isReadOnly() && QGuiApplication::clipboard()->text().length() != 0;
     QCOMPARE(textInput->canPaste(), cp);
-
-#endif
 }
+#endif
 
-void tst_qquicktextinput::canPaste() {
 #ifndef QT_NO_CLIPBOARD
-
+void tst_qquicktextinput::canPaste()
+{
     QGuiApplication::clipboard()->setText("Some text");
 
     QString componentStr = "import QtQuick 2.0\nTextInput { text: \"Hello world!\" }";
@@ -2460,9 +2587,51 @@ void tst_qquicktextinput::canPaste() {
 
     bool cp = !textInput->isReadOnly() && QGuiApplication::clipboard()->text().length() != 0;
     QCOMPARE(textInput->canPaste(), cp);
-
+}
 #endif
+
+#ifndef QT_NO_CLIPBOARD
+void tst_qquicktextinput::middleClickPaste()
+{
+    if (!PlatformQuirks::isClipboardAvailable())
+        QSKIP("This machine doesn't support the clipboard");
+
+    QQuickView window(testFileUrl("mouseselection_true.qml"));
+
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
+
+    QVERIFY(window.rootObject() != 0);
+    QQuickTextInput *textInputObject = qobject_cast<QQuickTextInput *>(window.rootObject());
+    QVERIFY(textInputObject != 0);
+
+    textInputObject->setFocus(true);
+
+    QString originalText = textInputObject->text();
+    QString selectedText = "234567";
+
+    // press-and-drag-and-release from x1 to x2
+    const QPoint p1 = textInputObject->positionToRectangle(2).center().toPoint();
+    const QPoint p2 = textInputObject->positionToRectangle(8).center().toPoint();
+    const QPoint p3 = textInputObject->positionToRectangle(1).center().toPoint();
+    QTest::mousePress(&window, Qt::LeftButton, Qt::NoModifier, p1);
+    QTest::mouseMove(&window, p2);
+    QTest::mouseRelease(&window, Qt::LeftButton, Qt::NoModifier, p2);
+    QTRY_COMPARE(textInputObject->selectedText(), selectedText);
+
+    // Middle click pastes the selected text, assuming the platform supports it.
+    QTest::mouseClick(&window, Qt::MiddleButton, Qt::NoModifier, p3);
+
+    // ### This is to prevent double click detection from carrying over to the next test.
+    QTest::qWait(QGuiApplication::styleHints()->mouseDoubleClickInterval() + 10);
+
+    if (QGuiApplication::clipboard()->supportsSelection())
+        QCOMPARE(textInputObject->text().mid(1, selectedText.length()), selectedText);
+    else
+        QCOMPARE(textInputObject->text(), originalText);
 }
+#endif
 
 void tst_qquicktextinput::passwordCharacter()
 {
@@ -2602,6 +2771,38 @@ void tst_qquicktextinput::cursorDelegate()
     QVERIFY(!textInputObject->findChild<QQuickItem*>("cursorInstance"));
 }
 
+void tst_qquicktextinput::remoteCursorDelegate()
+{
+    TestHTTPServer server(SERVER_PORT);
+    server.serveDirectory(dataDirectory());
+
+    QQuickView view;
+
+    QQmlComponent component(view.engine(), QUrl(SERVER_ADDR "/RemoteCursor.qml"));
+
+    view.rootContext()->setContextProperty("contextDelegate", &component);
+    view.setSource(testFileUrl("cursorTestRemote.qml"));
+    view.show();
+    view.requestActivateWindow();
+    QQuickTextInput *textInputObject = view.rootObject()->findChild<QQuickTextInput*>("textInputObject");
+    QVERIFY(textInputObject != 0);
+
+    // Delegate is created on demand, and so won't be available immediately.  Focus in or
+    // setCursorVisible(true) will trigger creation.
+    QTRY_VERIFY(!textInputObject->findChild<QQuickItem*>("cursorInstance"));
+    QVERIFY(!textInputObject->isCursorVisible());
+
+    textInputObject->setFocus(true);
+    QVERIFY(textInputObject->isCursorVisible());
+
+    QCOMPARE(component.status(), QQmlComponent::Loading);
+    QVERIFY(!textInputObject->findChild<QQuickItem*>("cursorInstance"));
+
+    // Wait for component to load.
+    QTRY_COMPARE(component.status(), QQmlComponent::Ready);
+    QVERIFY(textInputObject->findChild<QQuickItem*>("cursorInstance"));
+}
+
 void tst_qquicktextinput::cursorVisible()
 {
     QQuickTextInput input;
@@ -2611,8 +2812,7 @@ void tst_qquicktextinput::cursorVisible()
     QQuickView view(testFileUrl("cursorVisible.qml"));
     view.show();
     view.requestActivateWindow();
-    QTest::qWaitForWindowShown(&view);
-    QTRY_COMPARE(&view, qGuiApp->focusWindow());
+    QTest::qWaitForWindowActive(&view);
 
     QCOMPARE(input.isCursorVisible(), false);
 
@@ -2640,16 +2840,16 @@ void tst_qquicktextinput::cursorVisible()
     QCOMPARE(input.isCursorVisible(), true);
     QCOMPARE(spy.count(), 5);
 
-    QWindow alternateView;
+    QQuickView alternateView;
     alternateView.show();
     alternateView.requestActivateWindow();
-    QTest::qWaitForWindowShown(&alternateView);
+    QTest::qWaitForWindowActive(&alternateView);
 
     QCOMPARE(input.isCursorVisible(), false);
     QCOMPARE(spy.count(), 6);
 
     view.requestActivateWindow();
-    QTest::qWaitForWindowShown(&view);
+    QTest::qWaitForWindowActive(&view);
     QCOMPARE(input.isCursorVisible(), true);
     QCOMPARE(spy.count(), 7);
 
@@ -2891,23 +3091,23 @@ void tst_qquicktextinput::cursorRectangle()
 
 void tst_qquicktextinput::readOnly()
 {
-    QQuickView canvas(testFileUrl("readOnly.qml"));
-    canvas.show();
-    canvas.requestActivateWindow();
+    QQuickView window(testFileUrl("readOnly.qml"));
+    window.show();
+    window.requestActivateWindow();
 
-    QVERIFY(canvas.rootObject() != 0);
+    QVERIFY(window.rootObject() != 0);
 
-    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
 
     QVERIFY(input != 0);
     QTRY_VERIFY(input->hasActiveFocus() == true);
     QVERIFY(input->isReadOnly() == true);
     QString initial = input->text();
     for (int k=Qt::Key_0; k<=Qt::Key_Z; k++)
-        simulateKey(&canvas, k);
-    simulateKey(&canvas, Qt::Key_Return);
-    simulateKey(&canvas, Qt::Key_Space);
-    simulateKey(&canvas, Qt::Key_Escape);
+        simulateKey(&window, k);
+    simulateKey(&window, Qt::Key_Return);
+    simulateKey(&window, Qt::Key_Space);
+    simulateKey(&window, Qt::Key_Escape);
     QCOMPARE(input->text(), initial);
 
     input->setCursorPosition(3);
@@ -2918,15 +3118,14 @@ void tst_qquicktextinput::readOnly()
 
 void tst_qquicktextinput::echoMode()
 {
-    QQuickView canvas(testFileUrl("echoMode.qml"));
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
+    QQuickView window(testFileUrl("echoMode.qml"));
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
 
-    QVERIFY(canvas.rootObject() != 0);
+    QVERIFY(window.rootObject() != 0);
 
-    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
 
     QVERIFY(input != 0);
     QTRY_VERIFY(input->hasActiveFocus() == true);
@@ -2969,8 +3168,8 @@ void tst_qquicktextinput::echoMode()
     QCOMPARE(input->text(), initial);
     QCOMPARE(input->displayText(), QLatin1String("QQQQQQQQ"));
     QCOMPARE(input->inputMethodQuery(Qt::ImSurroundingText).toString(), QLatin1String("QQQQQQQQ"));
-    QTest::keyPress(&canvas, Qt::Key_A);//Clearing previous entry is part of PasswordEchoOnEdit
-    QTest::keyRelease(&canvas, Qt::Key_A, Qt::NoModifier ,10);
+    QTest::keyPress(&window, Qt::Key_A);//Clearing previous entry is part of PasswordEchoOnEdit
+    QTest::keyRelease(&window, Qt::Key_A, Qt::NoModifier ,10);
     QCOMPARE(input->text(), QLatin1String("a"));
     QCOMPARE(input->displayText(), QLatin1String("a"));
     QCOMPARE(input->inputMethodQuery(Qt::ImSurroundingText).toString(), QLatin1String("a"));
@@ -2993,16 +3192,16 @@ void tst_qquicktextinput::passwordEchoDelay()
     int maskDelay = qGuiApp->styleHints()->passwordMaskDelay();
     if (maskDelay <= 0)
         QSKIP("No mask delay in use");
-    QQuickView canvas(testFileUrl("echoMode.qml"));
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(&canvas, qGuiApp->focusWindow());
+    QQuickView window(testFileUrl("echoMode.qml"));
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
 
-    QVERIFY(canvas.rootObject() != 0);
+    QVERIFY(window.rootObject() != 0);
 
-    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(canvas.rootObject()->property("myInput")));
+    QQuickTextInput *input = qobject_cast<QQuickTextInput *>(qvariant_cast<QObject *>(window.rootObject()->property("myInput")));
     QVERIFY(input);
+    QVERIFY(input->hasActiveFocus());
 
     QQuickItem *cursor = input->findChild<QQuickItem *>("cursor");
     QVERIFY(cursor);
@@ -3014,16 +3213,16 @@ void tst_qquicktextinput::passwordEchoDelay()
     input->setText(QString());
     QCOMPARE(input->displayText(), QString());
 
-    QTest::keyPress(&canvas, '0');
-    QTest::keyPress(&canvas, '1');
-    QTest::keyPress(&canvas, '2');
+    QTest::keyPress(&window, '0');
+    QTest::keyPress(&window, '1');
+    QTest::keyPress(&window, '2');
     QCOMPARE(input->displayText(), QString(2, fillChar) + QLatin1Char('2'));
-    QTest::keyPress(&canvas, '3');
-    QTest::keyPress(&canvas, '4');
+    QTest::keyPress(&window, '3');
+    QTest::keyPress(&window, '4');
     QCOMPARE(input->displayText(), QString(4, fillChar) + QLatin1Char('4'));
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
+    QTest::keyPress(&window, Qt::Key_Backspace);
     QCOMPARE(input->displayText(), QString(4, fillChar));
-    QTest::keyPress(&canvas, '4');
+    QTest::keyPress(&window, '4');
     QCOMPARE(input->displayText(), QString(4, fillChar) + QLatin1Char('4'));
     QCOMPARE(input->cursorRectangle().topLeft(), cursor->pos());
 
@@ -3036,7 +3235,7 @@ void tst_qquicktextinput::passwordEchoDelay()
     QCOMPARE(cursorSpy.count(), 1);
     QCOMPARE(input->cursorRectangle().topLeft(), cursor->pos());
 
-    QTest::keyPress(&canvas, '5');
+    QTest::keyPress(&window, '5');
     QCOMPARE(input->displayText(), QString(5, fillChar) + QLatin1Char('5'));
     input->setFocus(false);
     QVERIFY(!input->hasFocus());
@@ -3044,19 +3243,19 @@ void tst_qquicktextinput::passwordEchoDelay()
     input->setFocus(true);
     QTRY_VERIFY(input->hasFocus());
     QCOMPARE(input->displayText(), QString(6, fillChar));
-    QTest::keyPress(&canvas, '6');
+    QTest::keyPress(&window, '6');
     QCOMPARE(input->displayText(), QString(6, fillChar) + QLatin1Char('6'));
 
     QInputMethodEvent ev;
     ev.setCommitString(QLatin1String("7"));
-    QGuiApplication::sendEvent(qGuiApp->focusObject(), &ev);
+    QGuiApplication::sendEvent(input, &ev);
     QCOMPARE(input->displayText(), QString(7, fillChar) + QLatin1Char('7'));
 
     input->setCursorPosition(3);
     QCOMPARE(input->displayText(), QString(7, fillChar) + QLatin1Char('7'));
-    QTest::keyPress(&canvas, 'a');
+    QTest::keyPress(&window, 'a');
     QCOMPARE(input->displayText(), QString(3, fillChar) + QLatin1Char('a') + QString(5, fillChar));
-    QTest::keyPress(&canvas, Qt::Key_Backspace);
+    QTest::keyPress(&window, Qt::Key_Backspace);
     QCOMPARE(input->displayText(), QString(8, fillChar));
 }
 
@@ -3097,27 +3296,26 @@ void tst_qquicktextinput::focusOnPress()
     QCOMPARE(textInputObject->focusOnPress(), true);
     QCOMPARE(activeFocusOnPressSpy.count(), 0);
 
-    QQuickCanvas canvas;
-    canvas.resize(100, 50);
-    textInputObject->setParentItem(canvas.rootItem());
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(QGuiApplication::focusWindow(), &canvas);
+    QQuickWindow window;
+    window.resize(100, 50);
+    textInputObject->setParentItem(window.contentItem());
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
 
     QCOMPARE(textInputObject->hasFocus(), false);
     QCOMPARE(textInputObject->hasActiveFocus(), false);
 
-    QPoint centerPoint(canvas.width()/2, canvas.height()/2);
+    QPoint centerPoint(window.width()/2, window.height()/2);
     Qt::KeyboardModifiers noModifiers = 0;
-    QTest::mousePress(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+    QTest::mousePress(&window, Qt::LeftButton, noModifiers, centerPoint);
     QGuiApplication::processEvents();
     QCOMPARE(textInputObject->hasFocus(), true);
     QCOMPARE(textInputObject->hasActiveFocus(), true);
     QCOMPARE(focusSpy.count(), 1);
     QCOMPARE(activeFocusSpy.count(), 1);
     QCOMPARE(textInputObject->selectedText(), QString());
-    QTest::mouseRelease(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+    QTest::mouseRelease(&window, Qt::LeftButton, noModifiers, centerPoint);
 
     textInputObject->setFocusOnPress(false);
     QCOMPARE(textInputObject->focusOnPress(), false);
@@ -3131,13 +3329,13 @@ void tst_qquicktextinput::focusOnPress()
 
     // Wait for double click timeout to expire before clicking again.
     QTest::qWait(400);
-    QTest::mousePress(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+    QTest::mousePress(&window, Qt::LeftButton, noModifiers, centerPoint);
     QGuiApplication::processEvents();
     QCOMPARE(textInputObject->hasFocus(), false);
     QCOMPARE(textInputObject->hasActiveFocus(), false);
     QCOMPARE(focusSpy.count(), 2);
     QCOMPARE(activeFocusSpy.count(), 2);
-    QTest::mouseRelease(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+    QTest::mouseRelease(&window, Qt::LeftButton, noModifiers, centerPoint);
 
     textInputObject->setFocusOnPress(true);
     QCOMPARE(textInputObject->focusOnPress(), true);
@@ -3147,14 +3345,14 @@ void tst_qquicktextinput::focusOnPress()
     textInputObject->setProperty("selectOnFocus", true);
 
     QTest::qWait(400);
-    QTest::mousePress(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+    QTest::mousePress(&window, Qt::LeftButton, noModifiers, centerPoint);
     QGuiApplication::processEvents();
     QCOMPARE(textInputObject->hasFocus(), true);
     QCOMPARE(textInputObject->hasActiveFocus(), true);
     QCOMPARE(focusSpy.count(), 3);
     QCOMPARE(activeFocusSpy.count(), 3);
     QCOMPARE(textInputObject->selectedText(), textInputObject->text());
-    QTest::mouseRelease(&canvas, Qt::LeftButton, noModifiers, centerPoint);
+    QTest::mouseRelease(&window, Qt::LeftButton, noModifiers, centerPoint);
 }
 
 void tst_qquicktextinput::openInputPanel()
@@ -3166,8 +3364,7 @@ void tst_qquicktextinput::openInputPanel()
     QQuickView view(testFileUrl("openInputPanel.qml"));
     view.show();
     view.requestActivateWindow();
-    QTest::qWaitForWindowShown(&view);
-    QTRY_COMPARE(&view, qGuiApp->focusWindow());
+    QTest::qWaitForWindowActive(&view);
 
     QQuickTextInput *input = qobject_cast<QQuickTextInput *>(view.rootObject());
     QVERIFY(input);
@@ -3209,7 +3406,7 @@ void tst_qquicktextinput::openInputPanel()
 
     anotherInput.setFocus(false);
     QVERIFY(qApp->focusObject() != &anotherInput);
-    QCOMPARE(view.activeFocusItem(), view.rootItem());
+    QCOMPARE(view.activeFocusItem(), view.contentItem());
     anotherInput.setFocus(true);
 
     qApp->inputMethod()->hide();
@@ -3253,10 +3450,10 @@ void tst_qquicktextinput::setHAlignClearCache()
     QQuickView view;
     MyTextInput input;
     input.setText("Hello world");
-    input.setParentItem(view.rootItem());
+    input.setParentItem(view.contentItem());
     view.show();
     view.requestActivateWindow();
-    QTest::qWaitForWindowShown(&view);
+    QTest::qWaitForWindowActive(&view);
 #ifdef Q_OS_MAC
     QEXPECT_FAIL("", "QTBUG-23485", Abort);
 #endif
@@ -3273,13 +3470,14 @@ void tst_qquicktextinput::focusOutClearSelection()
     QQuickTextInput input2;
     input.setText(QLatin1String("Hello world"));
     input.setFocus(true);
-    input2.setParentItem(view.rootItem());
-    input.setParentItem(view.rootItem());
+    input2.setParentItem(view.contentItem());
+    input.setParentItem(view.contentItem());
     input.componentComplete();
     input2.componentComplete();
     view.show();
     view.requestActivateWindow();
-    QTest::qWaitForWindowShown(&view);
+    QTest::qWaitForWindowActive(&view);
+    QVERIFY(input.hasActiveFocus());
     input.select(2,5);
     //The selection should work
     QTRY_COMPARE(input.selectedText(), QLatin1String("llo"));
@@ -3334,11 +3532,11 @@ void tst_qquicktextinput::contentSize()
     }
 }
 
-static void sendPreeditText(const QString &text, int cursor)
+static void sendPreeditText(QQuickItem *item, const QString &text, int cursor)
 {
     QInputMethodEvent event(text, QList<QInputMethodEvent::Attribute>()
             << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, cursor, text.length(), QVariant()));
-    QCoreApplication::sendEvent(qGuiApp->focusObject(), &event);
+    QCoreApplication::sendEvent(item, &event);
 }
 
 void tst_qquicktextinput::preeditAutoScroll()
@@ -3348,8 +3546,7 @@ void tst_qquicktextinput::preeditAutoScroll()
     QQuickView view(testFileUrl("preeditAutoScroll.qml"));
     view.show();
     view.requestActivateWindow();
-    QTest::qWaitForWindowShown(&view);
-    QTRY_COMPARE(&view, qGuiApp->focusWindow());
+    QTest::qWaitForWindowActive(&view);
     QQuickTextInput *input = qobject_cast<QQuickTextInput *>(view.rootObject());
     QVERIFY(input);
     QVERIFY(input->hasActiveFocus());
@@ -3360,14 +3557,14 @@ void tst_qquicktextinput::preeditAutoScroll()
     int cursorRectangleChanges = 0;
 
     // test the text is scrolled so the preedit is visible.
-    sendPreeditText(preeditText.mid(0, 3), 1);
+    sendPreeditText(input, preeditText.mid(0, 3), 1);
     QVERIFY(evaluate<int>(input, QString("positionAt(0)")) != 0);
     QVERIFY(input->cursorRectangle().left() < input->boundingRect().width());
     QCOMPARE(cursorRectangleSpy.count(), ++cursorRectangleChanges);
 
     // test the text is scrolled back when the preedit is removed.
     QInputMethodEvent imEvent;
-    QCoreApplication::sendEvent(qGuiApp->focusObject(), &imEvent);
+    QCoreApplication::sendEvent(input, &imEvent);
     QCOMPARE(evaluate<int>(input, QString("positionAt(%1)").arg(0)), 0);
     QCOMPARE(evaluate<int>(input, QString("positionAt(%1)").arg(input->width())), 5);
     QCOMPARE(cursorRectangleSpy.count(), ++cursorRectangleChanges);
@@ -3387,7 +3584,7 @@ void tst_qquicktextinput::preeditAutoScroll()
     // character preceding the cursor is still visible.
     qreal x = input->positionToRectangle(0).x();
     for (int i = 0; i < 3; ++i) {
-        sendPreeditText(preeditText, i + 1);
+        sendPreeditText(input, preeditText, i + 1);
         int width = ceil(line.cursorToX(i, QTextLine::Trailing)) - floor(line.cursorToX(i));
         QVERIFY(input->cursorRectangle().right() >= width - 3);
         QVERIFY(input->positionToRectangle(0).x() < x);
@@ -3395,7 +3592,7 @@ void tst_qquicktextinput::preeditAutoScroll()
         x = input->positionToRectangle(0).x();
     }
     for (int i = 1; i >= 0; --i) {
-        sendPreeditText(preeditText, i + 1);
+        sendPreeditText(input, preeditText, i + 1);
         int width = ceil(line.cursorToX(i, QTextLine::Trailing)) - floor(line.cursorToX(i));
         QVERIFY(input->cursorRectangle().right() >= width - 3);
         QVERIFY(input->positionToRectangle(0).x() > x);
@@ -3405,25 +3602,25 @@ void tst_qquicktextinput::preeditAutoScroll()
 
     // Test incrementing the preedit cursor doesn't cause further
     // scrolling when right most text is visible.
-    sendPreeditText(preeditText, preeditText.length() - 3);
+    sendPreeditText(input, preeditText, preeditText.length() - 3);
     QCOMPARE(cursorRectangleSpy.count(), ++cursorRectangleChanges);
     x = input->positionToRectangle(0).x();
     for (int i = 2; i >= 0; --i) {
-        sendPreeditText(preeditText, preeditText.length() - i);
+        sendPreeditText(input, preeditText, preeditText.length() - i);
         QCOMPARE(input->positionToRectangle(0).x(), x);
         QCOMPARE(cursorRectangleSpy.count(), ++cursorRectangleChanges);
     }
     for (int i = 1; i <  3; ++i) {
-        sendPreeditText(preeditText, preeditText.length() - i);
+        sendPreeditText(input, preeditText, preeditText.length() - i);
         QCOMPARE(input->positionToRectangle(0).x(), x);
         QCOMPARE(cursorRectangleSpy.count(), ++cursorRectangleChanges);
     }
 
     // Test disabling auto scroll.
-    QCoreApplication::sendEvent(qGuiApp->focusObject(), &imEvent);
+    QCoreApplication::sendEvent(input, &imEvent);
 
     input->setAutoScroll(false);
-    sendPreeditText(preeditText.mid(0, 3), 1);
+    sendPreeditText(input, preeditText.mid(0, 3), 1);
     QCOMPARE(evaluate<int>(input, QString("positionAt(%1)").arg(0)), 0);
     QCOMPARE(evaluate<int>(input, QString("positionAt(%1)").arg(input->width())), 5);
 }
@@ -3435,10 +3632,10 @@ void tst_qquicktextinput::preeditCursorRectangle()
     QQuickView view(testFileUrl("inputMethodEvent.qml"));
     view.show();
     view.requestActivateWindow();
-    QTest::qWaitForWindowShown(&view);
-    QTRY_COMPARE(&view, qGuiApp->focusWindow());
+    QTest::qWaitForWindowActive(&view);
     QQuickTextInput *input = qobject_cast<QQuickTextInput *>(view.rootObject());
     QVERIFY(input);
+    QVERIFY(input->hasActiveFocus());
 
     QQuickItem *cursor = input->findChild<QQuickItem *>("cursor");
     QVERIFY(cursor);
@@ -3446,13 +3643,13 @@ void tst_qquicktextinput::preeditCursorRectangle()
     QRectF currentRect;
 
     QInputMethodQueryEvent query(Qt::ImCursorRectangle);
-    QCoreApplication::sendEvent(qGuiApp->focusObject(), &query);
+    QCoreApplication::sendEvent(input, &query);
     QRectF previousRect = query.value(Qt::ImCursorRectangle).toRectF();
 
     // Verify that the micro focus rect is positioned the same for position 0 as
     // it would be if there was no preedit text.
-    sendPreeditText(preeditText, 0);
-    QCoreApplication::sendEvent(qGuiApp->focusObject(), &query);
+    sendPreeditText(input, preeditText, 0);
+    QCoreApplication::sendEvent(input, &query);
     currentRect = query.value(Qt::ImCursorRectangle).toRectF();
     QCOMPARE(currentRect, previousRect);
     QCOMPARE(input->cursorRectangle(), currentRect);
@@ -3464,8 +3661,8 @@ void tst_qquicktextinput::preeditCursorRectangle()
     // Verify that the micro focus rect moves to the left as the cursor position
     // is incremented.
     for (int i = 1; i <= 5; ++i) {
-        sendPreeditText(preeditText, i);
-        QCoreApplication::sendEvent(qGuiApp->focusObject(), &query);
+        sendPreeditText(input, preeditText, i);
+        QCoreApplication::sendEvent(input, &query);
         currentRect = query.value(Qt::ImCursorRectangle).toRectF();
         QVERIFY(previousRect.left() < currentRect.left());
         QCOMPARE(input->cursorRectangle(), currentRect);
@@ -3479,8 +3676,8 @@ void tst_qquicktextinput::preeditCursorRectangle()
     // but the (non-zero) cursor position is the same.
     inputSpy.clear();
     panelSpy.clear();
-    sendPreeditText("wwwww", 5);
-    QCoreApplication::sendEvent(qGuiApp->focusObject(), &query);
+    sendPreeditText(input, "wwwww", 5);
+    QCoreApplication::sendEvent(input, &query);
     currentRect = query.value(Qt::ImCursorRectangle).toRectF();
     QCOMPARE(input->cursorRectangle(), currentRect);
     QCOMPARE(cursor->pos(), currentRect.topLeft());
@@ -3492,8 +3689,8 @@ void tst_qquicktextinput::preeditCursorRectangle()
     inputSpy.clear();
     panelSpy.clear();
     {   QInputMethodEvent imEvent(preeditText, QList<QInputMethodEvent::Attribute>());
-        QCoreApplication::sendEvent(qGuiApp->focusObject(), &imEvent); }
-    QCoreApplication::sendEvent(qGuiApp->focusObject(), &query);
+        QCoreApplication::sendEvent(input, &imEvent); }
+    QCoreApplication::sendEvent(input, &query);
     currentRect = query.value(Qt::ImCursorRectangle).toRectF();
     QCOMPARE(currentRect, previousRect);
     QCOMPARE(input->cursorRectangle(), currentRect);
@@ -3518,8 +3715,7 @@ void tst_qquicktextinput::inputContextMouseHandler()
 
     view.show();
     view.requestActivateWindow();
-    QTest::qWaitForWindowShown(&view);
-    QTRY_COMPARE(&view, qGuiApp->focusWindow());
+    QTest::qWaitForWindowActive(&view);
 
     QTextLayout layout(text);
     layout.setFont(input->font());
@@ -3555,10 +3751,10 @@ void tst_qquicktextinput::inputMethodComposing()
     QQuickView view(testFileUrl("inputContext.qml"));
     view.show();
     view.requestActivateWindow();
-    QTest::qWaitForWindowShown(&view);
-    QTRY_COMPARE(&view, qGuiApp->focusWindow());
+    QTest::qWaitForWindowActive(&view);
     QQuickTextInput *input = qobject_cast<QQuickTextInput *>(view.rootObject());
     QVERIFY(input);
+    QVERIFY(input->hasActiveFocus());
     QSignalSpy spy(input, SIGNAL(inputMethodComposingChanged()));
 
     QCOMPARE(input->isInputMethodComposing(), false);
@@ -3661,10 +3857,10 @@ void tst_qquicktextinput::inputMethodUpdate()
     QQuickView view(testFileUrl("inputContext.qml"));
     view.show();
     view.requestActivateWindow();
-    QTest::qWaitForWindowShown(&view);
-    QTRY_COMPARE(&view, qGuiApp->focusWindow());
+    QTest::qWaitForWindowActive(&view);
     QQuickTextInput *input = qobject_cast<QQuickTextInput *>(view.rootObject());
     QVERIFY(input);
+    QVERIFY(input->hasActiveFocus());
 
     // text change even without cursor position change needs to trigger update
     input->setText("test");
@@ -3739,9 +3935,9 @@ void tst_qquicktextinput::inputMethodUpdate()
 
 void tst_qquicktextinput::cursorRectangleSize()
 {
-    QQuickView *canvas = new QQuickView(testFileUrl("positionAt.qml"));
-    QVERIFY(canvas->rootObject() != 0);
-    QQuickTextInput *textInput = qobject_cast<QQuickTextInput *>(canvas->rootObject());
+    QQuickView *window = new QQuickView(testFileUrl("positionAt.qml"));
+    QVERIFY(window->rootObject() != 0);
+    QQuickTextInput *textInput = qobject_cast<QQuickTextInput *>(window->rootObject());
 
     // make sure cursor rectangle is not at (0,0)
     textInput->setX(10);
@@ -3749,13 +3945,13 @@ void tst_qquicktextinput::cursorRectangleSize()
     textInput->setCursorPosition(3);
     QVERIFY(textInput != 0);
     textInput->setFocus(true);
-    canvas->show();
-    canvas->requestActivateWindow();
-    QTest::qWaitForWindowShown(canvas);
-    QTRY_VERIFY(qApp->focusObject());
+    window->show();
+    window->requestActivateWindow();
+    QTest::qWaitForWindowActive(window);
+    QVERIFY(textInput->hasActiveFocus());
 
     QInputMethodQueryEvent event(Qt::ImCursorRectangle);
-    qApp->sendEvent(qApp->focusObject(), &event);
+    qApp->sendEvent(textInput, &event);
     QRectF cursorRectFromQuery = event.value(Qt::ImCursorRectangle).toRectF();
 
     QRectF cursorRectFromItem = textInput->cursorRectangle();
@@ -3767,14 +3963,14 @@ void tst_qquicktextinput::cursorRectangleSize()
     // item cursor rectangle and positionToRectangle calculations match
     QCOMPARE(cursorRectFromItem, cursorRectFromPositionToRectangle);
 
-    // item-canvas transform and input item transform match
-    QCOMPARE(QQuickItemPrivate::get(textInput)->itemToCanvasTransform(), qApp->inputMethod()->inputItemTransform());
+    // item-window transform and input item transform match
+    QCOMPARE(QQuickItemPrivate::get(textInput)->itemToWindowTransform(), qApp->inputMethod()->inputItemTransform());
 
     // input panel cursorRectangle property and tranformed item cursor rectangle match
-    QRectF sceneCursorRect = QQuickItemPrivate::get(textInput)->itemToCanvasTransform().mapRect(cursorRectFromItem);
+    QRectF sceneCursorRect = QQuickItemPrivate::get(textInput)->itemToWindowTransform().mapRect(cursorRectFromItem);
     QCOMPARE(sceneCursorRect, qApp->inputMethod()->cursorRectangle());
 
-    delete canvas;
+    delete window;
 }
 
 void tst_qquicktextinput::tripleClickSelectsAll()
@@ -3783,9 +3979,7 @@ void tst_qquicktextinput::tripleClickSelectsAll()
     QQuickView view(QUrl::fromLocalFile(qmlfile));
     view.show();
     view.requestActivateWindow();
-    QTest::qWaitForWindowShown(&view);
-
-    QTRY_COMPARE(&view, qGuiApp->focusWindow());
+    QTest::qWaitForWindowActive(&view);
 
     QQuickTextInput* input = qobject_cast<QQuickTextInput*>(view.rootObject());
     QVERIFY(input);
@@ -4773,18 +4967,18 @@ void tst_qquicktextinput::keySequence()
     QVERIFY(textInput != 0);
     textInput->setEchoMode(echoMode);
 
-    QQuickCanvas canvas;
-    textInput->setParentItem(canvas.rootItem());
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(QGuiApplication::focusWindow(), &canvas);
+    QQuickWindow window;
+    textInput->setParentItem(window.contentItem());
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
+    QVERIFY(textInput->hasActiveFocus());
 
-    simulateKey(&canvas, layoutDirection);
+    simulateKey(&window, layoutDirection);
 
     textInput->select(selectionStart, selectionEnd);
 
-    simulateKeys(&canvas, sequence);
+    simulateKeys(&window, sequence);
 
     QCOMPARE(textInput->cursorPosition(), cursorPosition);
     QCOMPARE(textInput->text(), expectedText);
@@ -4934,12 +5128,12 @@ void tst_qquicktextinput::undo()
     QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
     QVERIFY(textInput != 0);
 
-    QQuickCanvas canvas;
-    textInput->setParentItem(canvas.rootItem());
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(QGuiApplication::focusWindow(), &canvas);
+    QQuickWindow window;
+    textInput->setParentItem(window.contentItem());
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
+    QVERIFY(textInput->hasActiveFocus());
 
     QVERIFY(!textInput->canUndo());
 
@@ -4961,7 +5155,7 @@ void tst_qquicktextinput::undo()
         }
 
         for (int j = 0; j < insertString.at(i).length(); j++)
-            QTest::keyClick(&canvas, insertString.at(i).at(j).toLatin1());
+            QTest::keyClick(&window, insertString.at(i).at(j).toLatin1());
     }
 
     QCOMPARE(spy.count(), 1);
@@ -5020,13 +5214,13 @@ void tst_qquicktextinput::redo()
     QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
     QVERIFY(textInput != 0);
 
-    QQuickCanvas canvas;
-    textInput->setParentItem(canvas.rootItem());
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(QGuiApplication::focusWindow(), &canvas);
+    QQuickWindow window;
+    textInput->setParentItem(window.contentItem());
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
 
+    QVERIFY(textInput->hasActiveFocus());
     QVERIFY(!textInput->canUndo());
     QVERIFY(!textInput->canRedo());
 
@@ -5038,7 +5232,7 @@ void tst_qquicktextinput::redo()
         if (insertIndex[i] > -1)
             textInput->setCursorPosition(insertIndex[i]);
         for (int j = 0; j < insertString.at(i).length(); j++)
-            QTest::keyClick(&canvas, insertString.at(i).at(j).toLatin1());
+            QTest::keyClick(&window, insertString.at(i).at(j).toLatin1());
         QVERIFY(textInput->canUndo());
         QVERIFY(!textInput->canRedo());
     }
@@ -5116,7 +5310,7 @@ void tst_qquicktextinput::undo_keypressevents_data()
                 << QKeySequence::MoveToStartOfLine
                 // selecting 'AB'
                 << (Qt::Key_Right | Qt::ShiftModifier) << (Qt::Key_Right | Qt::ShiftModifier)
-                << Qt::Key_Delete
+                << Qt::Key_Backspace
                 << QKeySequence::Undo
                 << Qt::Key_Right
                 << (Qt::Key_Right | Qt::ShiftModifier) << (Qt::Key_Right | Qt::ShiftModifier)
@@ -5191,7 +5385,6 @@ void tst_qquicktextinput::undo_keypressevents_data()
              << "ABC";
 
         expectedString << "ABC";
-        // for versions previous to 3.2 we overwrite needed two undo operations
         expectedString << "123";
 
         QTest::newRow("Inserts,moving,selection and overwriting") << keys << expectedString;
@@ -5208,6 +5401,137 @@ void tst_qquicktextinput::undo_keypressevents_data()
         expectedString << QString();
 
         QTest::newRow("Insert,undo,redo") << keys << expectedString;
+    } {
+        KeyList keys;
+        QStringList expectedString;
+
+        keys << "hello world"
+             << (Qt::Key_Backspace | Qt::ControlModifier)
+             << QKeySequence::Undo
+             << QKeySequence::Redo
+             << "hello";
+
+        expectedString
+                << "hello hello"
+                << "hello "
+                << "hello world"
+                << QString();
+
+        QTest::newRow("Insert,delete previous word,undo,redo,insert") << keys << expectedString;
+    } {
+        KeyList keys;
+        QStringList expectedString;
+
+        keys << "hello world"
+             << QKeySequence::SelectPreviousWord
+             << (Qt::Key_Backspace)
+             << QKeySequence::Undo
+             << "hello";
+
+        expectedString
+                << "hello hello"
+                << "hello world"
+                << QString();
+
+        QTest::newRow("Insert,select previous word,remove,undo,insert") << keys << expectedString;
+    } {
+        KeyList keys;
+        QStringList expectedString;
+
+        keys << "hello world"
+             << QKeySequence::DeleteStartOfWord
+             << QKeySequence::Undo
+             << "hello";
+
+        expectedString
+                << "hello worldhello"
+                << "hello world"
+                << QString();
+
+        QTest::newRow("Insert,delete previous word,undo,insert") << keys << expectedString;
+    } {
+        KeyList keys;
+        QStringList expectedString;
+
+        keys << "hello world"
+             << QKeySequence::MoveToPreviousWord
+             << QKeySequence::DeleteEndOfWord
+             << QKeySequence::Undo
+             << "hello";
+
+        expectedString
+                << "hello helloworld"
+                << "hello world"
+                << QString();
+
+        QTest::newRow("Insert,move,delete next word,undo,insert") << keys << expectedString;
+    }
+    if (!QKeySequence(QKeySequence::DeleteEndOfLine).isEmpty()) {   // X11 only.
+        KeyList keys;
+        QStringList expectedString;
+
+        keys << "hello world"
+             << QKeySequence::MoveToStartOfLine
+             << Qt::Key_Right
+             << QKeySequence::DeleteEndOfLine
+             << QKeySequence::Undo
+             << "hello";
+
+        expectedString
+                << "hhelloello world"
+                << "hello world"
+                << QString();
+
+        QTest::newRow("Insert,move,delete end of line,undo,insert") << keys << expectedString;
+    } {
+        KeyList keys;
+        QStringList expectedString;
+
+        keys << "hello world"
+             << QKeySequence::MoveToPreviousWord
+             << (Qt::Key_Left | Qt::ShiftModifier)
+             << (Qt::Key_Left | Qt::ShiftModifier)
+             << QKeySequence::DeleteEndOfWord
+             << QKeySequence::Undo
+             << "hello";
+
+        expectedString
+                << "hellhelloworld"
+                << "hello world"
+                << QString();
+
+        QTest::newRow("Insert,move,select,delete next word,undo,insert") << keys << expectedString;
+    }
+
+    bool canCopyPaste = PlatformQuirks::isClipboardAvailable();
+
+    if (canCopyPaste) {
+        KeyList keys;
+        keys    << "123"
+                << QKeySequence(QKeySequence::SelectStartOfLine)
+                << QKeySequence(QKeySequence::Cut)
+                << "ABC"
+                << QKeySequence(QKeySequence::Paste);
+        QStringList expectedString = QStringList()
+                << "ABC123"
+                << "ABC"
+                // TextEdit: ""
+                << "123";
+        QTest::newRow("Cut,paste") << keys << expectedString;
+    }
+    if (canCopyPaste) {
+        KeyList keys;
+        keys    << "123"
+                << QKeySequence(QKeySequence::SelectStartOfLine)
+                << QKeySequence(QKeySequence::Copy)
+                << "ABC"
+                << QKeySequence(QKeySequence::Paste);
+        QStringList expectedString = QStringList()
+                << "ABC123"
+                << "ABC"
+                // TextEdit: "A"
+                << "123";
+        QTest::newRow("Copy,paste") << keys << expectedString;
     }
 }
 
@@ -5222,14 +5546,14 @@ void tst_qquicktextinput::undo_keypressevents()
     QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
     QVERIFY(textInput != 0);
 
-    QQuickCanvas canvas;
-    textInput->setParentItem(canvas.rootItem());
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(QGuiApplication::focusWindow(), &canvas);
+    QQuickWindow window;
+    textInput->setParentItem(window.contentItem());
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
+    QVERIFY(textInput->hasActiveFocus());
 
-    simulateKeys(&canvas, keys);
+    simulateKeys(&window, keys);
 
     for (int i = 0; i < expectedString.size(); ++i) {
         QCOMPARE(textInput->text() , expectedString[i]);
@@ -5238,40 +5562,77 @@ void tst_qquicktextinput::undo_keypressevents()
     QVERIFY(textInput->text().isEmpty());
 }
 
+void tst_qquicktextinput::backspaceSurrogatePairs()
+{
+    // Test backspace, and delete remove both characters in a surrogate pair.
+    static const quint16 textData[] = { 0xd800, 0xdf00, 0xd800, 0xdf01, 0xd800, 0xdf02, 0xd800, 0xdf03, 0xd800, 0xdf04 };
+    const QString text = QString::fromUtf16(textData, lengthOf(textData));
+
+    QString componentStr = "import QtQuick 2.0\nTextInput { focus: true }";
+    QQmlComponent textInputComponent(&engine);
+    textInputComponent.setData(componentStr.toLatin1(), QUrl());
+    QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
+    QVERIFY(textInput != 0);
+    textInput->setText(text);
+    textInput->setCursorPosition(text.length());
+
+    QQuickWindow window;
+    textInput->setParentItem(window.contentItem());
+    window.show();
+    window.requestActivateWindow();
+    QVERIFY(QTest::qWaitForWindowActive(&window));
+    QCOMPARE(QGuiApplication::focusWindow(), &window);
+
+    for (int i = text.length(); i >= 0; i -= 2) {
+        QCOMPARE(textInput->text(), text.mid(0, i));
+        QTest::keyClick(&window, Qt::Key_Backspace, Qt::NoModifier);
+    }
+    QCOMPARE(textInput->text(), QString());
+
+    textInput->setText(text);
+    textInput->setCursorPosition(0);
+
+    for (int i = 0; i < text.length(); i += 2) {
+        QCOMPARE(textInput->text(), text.mid(i));
+        QTest::keyClick(&window, Qt::Key_Delete, Qt::NoModifier);
+    }
+    QCOMPARE(textInput->text(), QString());
+}
+
 void tst_qquicktextinput::QTBUG_19956()
 {
     QFETCH(QString, url);
 
-    QQuickView canvas(testFileUrl(url));
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QVERIFY(canvas.rootObject() != 0);
-    QQuickTextInput *input = qobject_cast<QQuickTextInput*>(canvas.rootObject());
+    QQuickView window(testFileUrl(url));
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
+    QVERIFY(window.rootObject() != 0);
+    QQuickTextInput *input = qobject_cast<QQuickTextInput*>(window.rootObject());
     QVERIFY(input);
     input->setFocus(true);
     QVERIFY(input->hasActiveFocus());
 
-    QCOMPARE(canvas.rootObject()->property("topvalue").toInt(), 30);
-    QCOMPARE(canvas.rootObject()->property("bottomvalue").toInt(), 10);
-    QCOMPARE(canvas.rootObject()->property("text").toString(), QString("20"));
-    QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
+    QCOMPARE(window.rootObject()->property("topvalue").toInt(), 30);
+    QCOMPARE(window.rootObject()->property("bottomvalue").toInt(), 10);
+    QCOMPARE(window.rootObject()->property("text").toString(), QString("20"));
+    QVERIFY(window.rootObject()->property("acceptableInput").toBool());
 
-    canvas.rootObject()->setProperty("topvalue", 15);
-    QCOMPARE(canvas.rootObject()->property("topvalue").toInt(), 15);
-    QVERIFY(!canvas.rootObject()->property("acceptableInput").toBool());
+    window.rootObject()->setProperty("topvalue", 15);
+    QCOMPARE(window.rootObject()->property("topvalue").toInt(), 15);
+    QVERIFY(!window.rootObject()->property("acceptableInput").toBool());
 
-    canvas.rootObject()->setProperty("topvalue", 25);
-    QCOMPARE(canvas.rootObject()->property("topvalue").toInt(), 25);
-    QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
+    window.rootObject()->setProperty("topvalue", 25);
+    QCOMPARE(window.rootObject()->property("topvalue").toInt(), 25);
+    QVERIFY(window.rootObject()->property("acceptableInput").toBool());
 
-    canvas.rootObject()->setProperty("bottomvalue", 21);
-    QCOMPARE(canvas.rootObject()->property("bottomvalue").toInt(), 21);
-    QVERIFY(!canvas.rootObject()->property("acceptableInput").toBool());
+    window.rootObject()->setProperty("bottomvalue", 21);
+    QCOMPARE(window.rootObject()->property("bottomvalue").toInt(), 21);
+    QVERIFY(!window.rootObject()->property("acceptableInput").toBool());
 
-    canvas.rootObject()->setProperty("bottomvalue", 10);
-    QCOMPARE(canvas.rootObject()->property("bottomvalue").toInt(), 10);
-    QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
+    window.rootObject()->setProperty("bottomvalue", 10);
+    QCOMPARE(window.rootObject()->property("bottomvalue").toInt(), 10);
+    QVERIFY(window.rootObject()->property("acceptableInput").toBool());
 }
 
 void tst_qquicktextinput::QTBUG_19956_regexp()
@@ -5281,28 +5642,28 @@ void tst_qquicktextinput::QTBUG_19956_regexp()
     QString warning = url.toString() + ":11: Unable to assign [undefined] to QRegExp";
     QTest::ignoreMessage(QtWarningMsg, qPrintable(warning));
 
-    QQuickView canvas(url);
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QVERIFY(canvas.rootObject() != 0);
-    QQuickTextInput *input = qobject_cast<QQuickTextInput*>(canvas.rootObject());
+    QQuickView window(url);
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
+    QVERIFY(window.rootObject() != 0);
+    QQuickTextInput *input = qobject_cast<QQuickTextInput*>(window.rootObject());
     QVERIFY(input);
     input->setFocus(true);
     QVERIFY(input->hasActiveFocus());
 
-    canvas.rootObject()->setProperty("regexvalue", QRegExp("abc"));
-    QCOMPARE(canvas.rootObject()->property("regexvalue").toRegExp(), QRegExp("abc"));
-    QCOMPARE(canvas.rootObject()->property("text").toString(), QString("abc"));
-    QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
+    window.rootObject()->setProperty("regexvalue", QRegExp("abc"));
+    QCOMPARE(window.rootObject()->property("regexvalue").toRegExp(), QRegExp("abc"));
+    QCOMPARE(window.rootObject()->property("text").toString(), QString("abc"));
+    QVERIFY(window.rootObject()->property("acceptableInput").toBool());
 
-    canvas.rootObject()->setProperty("regexvalue", QRegExp("abcd"));
-    QCOMPARE(canvas.rootObject()->property("regexvalue").toRegExp(), QRegExp("abcd"));
-    QVERIFY(!canvas.rootObject()->property("acceptableInput").toBool());
+    window.rootObject()->setProperty("regexvalue", QRegExp("abcd"));
+    QCOMPARE(window.rootObject()->property("regexvalue").toRegExp(), QRegExp("abcd"));
+    QVERIFY(!window.rootObject()->property("acceptableInput").toBool());
 
-    canvas.rootObject()->setProperty("regexvalue", QRegExp("abc"));
-    QCOMPARE(canvas.rootObject()->property("regexvalue").toRegExp(), QRegExp("abc"));
-    QVERIFY(canvas.rootObject()->property("acceptableInput").toBool());
+    window.rootObject()->setProperty("regexvalue", QRegExp("abc"));
+    QCOMPARE(window.rootObject()->property("regexvalue").toRegExp(), QRegExp("abc"));
+    QVERIFY(window.rootObject()->property("acceptableInput").toBool());
 }
 
 void tst_qquicktextinput::implicitSize_data()
@@ -5592,16 +5953,16 @@ void tst_qquicktextinput::setInputMask()
     if (insert_text) {
         textInput->insert(0, input);
     } else {
-        QQuickCanvas canvas;
-        textInput->setParentItem(canvas.rootItem());
-        canvas.show();
-        canvas.requestActivateWindow();
-        QTest::qWaitForWindowShown(&canvas);
-        QTRY_COMPARE(QGuiApplication::focusWindow(), &canvas);
-
-        simulateKey(&canvas, Qt::Key_Home);
+        QQuickWindow window;
+        textInput->setParentItem(window.contentItem());
+        window.show();
+        window.requestActivateWindow();
+        QTest::qWaitForWindowActive(&window);
+        QVERIFY(textInput->hasActiveFocus());
+
+        simulateKey(&window, Qt::Key_Home);
         for (int i = 0; i < input.length(); i++)
-            QTest::keyClick(&canvas, input.at(i).toLatin1());
+            QTest::keyClick(&window, input.at(i).toLatin1());
     }
 
     QEXPECT_FAIL( "keys blank=input", "To eat blanks or not? Known issue. Task 43172", Abort);
@@ -5656,7 +6017,7 @@ void tst_qquicktextinput::clearInputMask()
     QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
     QVERIFY(textInput != 0);
 
-    QVERIFY(textInput->inputMask() != QString());
+    QVERIFY(!textInput->inputMask().isEmpty());
     textInput->setInputMask(QString());
     QCOMPARE(textInput->inputMask(), QString());
 }
@@ -5722,14 +6083,14 @@ void tst_qquicktextinput::keypress_inputMask()
     QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
     QVERIFY(textInput != 0);
 
-    QQuickCanvas canvas;
-    textInput->setParentItem(canvas.rootItem());
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(QGuiApplication::focusWindow(), &canvas);
+    QQuickWindow window;
+    textInput->setParentItem(window.contentItem());
+    window.show();
+    window.requestActivateWindow();
+    QTest::qWaitForWindowActive(&window);
+    QVERIFY(textInput->hasActiveFocus());
 
-    simulateKeys(&canvas, keys);
+    simulateKeys(&window, keys);
 
     QCOMPARE(textInput->text(), expectedText);
     QCOMPARE(textInput->displayText(), expectedDisplayText);
@@ -5762,19 +6123,12 @@ void tst_qquicktextinput::hasAcceptableInputMask()
     QFETCH(QString, invalid);
     QFETCH(QString, valid);
 
-    QString componentStr = "import QtQuick 2.0\nTextInput { focus: true; inputMask: \"" + optionalMask + "\" }";
+    QString componentStr = "import QtQuick 2.0\nTextInput { inputMask: \"" + optionalMask + "\" }";
     QQmlComponent textInputComponent(&engine);
     textInputComponent.setData(componentStr.toLatin1(), QUrl());
     QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
     QVERIFY(textInput != 0);
 
-    QQuickCanvas canvas;
-    textInput->setParentItem(canvas.rootItem());
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(QGuiApplication::focusWindow(), &canvas);
-
     // test that invalid input (for required) work for optionalMask
     textInput->setText(invalid);
     QVERIFY(textInput->hasAcceptableInput());
@@ -5825,19 +6179,12 @@ void tst_qquicktextinput::maskCharacter()
     QFETCH(QString, input);
     QFETCH(bool, expectedValid);
 
-    QString componentStr = "import QtQuick 2.0\nTextInput { focus: true; inputMask: \"" + mask + "\" }";
+    QString componentStr = "import QtQuick 2.0\nTextInput { inputMask: \"" + mask + "\" }";
     QQmlComponent textInputComponent(&engine);
     textInputComponent.setData(componentStr.toLatin1(), QUrl());
     QQuickTextInput *textInput = qobject_cast<QQuickTextInput*>(textInputComponent.create());
     QVERIFY(textInput != 0);
 
-    QQuickCanvas canvas;
-    textInput->setParentItem(canvas.rootItem());
-    canvas.show();
-    canvas.requestActivateWindow();
-    QTest::qWaitForWindowShown(&canvas);
-    QTRY_COMPARE(QGuiApplication::focusWindow(), &canvas);
-
     for (int i = 0; i < input.size(); ++i) {
         QString in = QString(input.at(i));
         QString expected = expectedValid ? in : QString();