Merge lp:~fboucault/ubuntu-terminal-app/tiled_view into lp:ubuntu-terminal-app

[Florian Boucault]

New feature: terminals can be organised as tiles.

New feature: terminals can be organised as tiles.

[lp:~fboucault/ubuntu-terminal-app/tiled_view]

333. By Florian Boucault on 2017-01-12

Added automated tests for tile resizing.

=== modified file 'po/com.ubuntu.terminal.pot'
--- po/com.ubuntu.terminal.pot	2017-01-06 08:39:01 +0000
+++ po/com.ubuntu.terminal.pot	2017-01-12 13:29:38 +0000
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: \n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2017-01-06 08:38+0000\n"
+"POT-Creation-Date: 2017-01-12 14:17+0100\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
@@ -29,15 +29,23 @@
 msgid "Paste"
 msgstr ""
 
-#: ../src/app/qml/AlternateActionPopover.qml:86 ../src/app/qml/TabsPage.qml:32
+#: ../src/app/qml/AlternateActionPopover.qml:86
+msgid "Split horizontally"
+msgstr ""
+
+#: ../src/app/qml/AlternateActionPopover.qml:92
+msgid "Split vertically"
+msgstr ""
+
+#: ../src/app/qml/AlternateActionPopover.qml:99 ../src/app/qml/TabsPage.qml:32
 msgid "New tab"
 msgstr ""
 
-#: ../src/app/qml/AlternateActionPopover.qml:91
+#: ../src/app/qml/AlternateActionPopover.qml:104
 msgid "New window"
 msgstr ""
 
-#: ../src/app/qml/AlternateActionPopover.qml:96
+#: ../src/app/qml/AlternateActionPopover.qml:109
 msgid "Close"
 msgstr ""
 
@@ -303,7 +311,7 @@
 msgid "Tabs"
 msgstr ""
 
-#: ../src/app/qml/TerminalPage.qml:252
+#: ../src/app/qml/TerminalPage.qml:132
 msgid "Selection Mode"
 msgstr ""
 

=== modified file 'src/app/qml/AlternateActionPopover.qml'
--- src/app/qml/AlternateActionPopover.qml	2017-01-06 08:38:45 +0000
+++ src/app/qml/AlternateActionPopover.qml	2017-01-12 13:29:38 +0000
@@ -83,6 +83,19 @@
             property bool divider: true
         }
         Action {
+            text: i18n.tr("Split horizontally")
+            onTriggered: tiledTerminalView.splitTerminal(terminal, Qt.Vertical)
+            shortcut: settings.shortcutSplitHorizontally
+            enabled: terminal.height >= 2 * tiledTerminalView.minimumTileHeight
+        }
+        Action {
+            text: i18n.tr("Split vertically")
+            onTriggered: tiledTerminalView.splitTerminal(terminal, Qt.Horizontal)
+            shortcut: settings.shortcutSplitVertically
+            enabled: terminal.width >= 2 * tiledTerminalView.minimumTileWidth
+            property bool divider: true
+        }
+        Action {
             text: i18n.tr("New tab")
             onTriggered: tabsModel.addTerminalTab()
             shortcut: settings.shortcutNewTab
@@ -94,7 +107,7 @@
         }
         Action {
             text: i18n.tr("Close")
-            onTriggered: tabsModel.removeItem(tabsModel.indexOf(tabsModel.currentItem))
+            onTriggered: terminal.finished()
             shortcut: settings.shortcutCloseTab
         }
     }

=== modified file 'src/app/qml/Settings/SettingsShortcutsSection.qml'
--- src/app/qml/Settings/SettingsShortcutsSection.qml	2016-11-30 22:56:25 +0000
+++ src/app/qml/Settings/SettingsShortcutsSection.qml	2017-01-12 13:29:38 +0000
@@ -186,6 +186,36 @@
                         actionLabel: QT_TR_NOOP("Toggle fullscreen")
                         shortcutSetting: "shortcutFullscreen"
                     }
+                    ListElement {
+                        section: QT_TR_NOOP("View")
+                        actionLabel: QT_TR_NOOP("Split terminal horizontally")
+                        shortcutSetting: "shortcutSplitHorizontally"
+                    }
+                    ListElement {
+                        section: QT_TR_NOOP("View")
+                        actionLabel: QT_TR_NOOP("Split terminal vertically")
+                        shortcutSetting: "shortcutSplitVertically"
+                    }
+                    ListElement {
+                        section: QT_TR_NOOP("View")
+                        actionLabel: QT_TR_NOOP("Navigate to terminal above")
+                        shortcutSetting: "shortcutMoveToTileAbove"
+                    }
+                    ListElement {
+                        section: QT_TR_NOOP("View")
+                        actionLabel: QT_TR_NOOP("Navigate to terminal below")
+                        shortcutSetting: "shortcutMoveToTileBelow"
+                    }
+                    ListElement {
+                        section: QT_TR_NOOP("View")
+                        actionLabel: QT_TR_NOOP("Navigate to terminal on the left")
+                        shortcutSetting: "shortcutMoveToTileLeft"
+                    }
+                    ListElement {
+                        section: QT_TR_NOOP("View")
+                        actionLabel: QT_TR_NOOP("Navigate to terminal on the right")
+                        shortcutSetting: "shortcutMoveToTileRight"
+                    }
                 }
 
                 delegate: ShortcutRow {

=== modified file 'src/app/qml/TabsModel.qml'
--- src/app/qml/TabsModel.qml	2016-12-12 21:18:17 +0000
+++ src/app/qml/TabsModel.qml	2017-01-12 13:29:38 +0000
@@ -34,17 +34,18 @@
         moveItem(from, to);
     }
 
-    property Component terminalComponent: TerminalComponent {}
+    property Component tiledViewComponent: TiledTerminalView {}
 
     function addTerminalTab(initialWorkingDirectory) {
         if (currentItem) {
-            initialWorkingDirectory = currentItem.session.getWorkingDirectory();
+            initialWorkingDirectory = currentItem.focusedTerminal.session.getWorkingDirectory();
         }
 
-        var termObject = terminalComponent.createObject(terminalPage.terminalContainer,
+        var tiledView = tiledViewComponent.createObject(terminalPage.terminalContainer,
                                                         {"initialWorkingDirectory": initialWorkingDirectory,
-                                                         "visible": Qt.binding(function () { return tabsModel.currentItem === termObject})});
-        tabsModel.addItem(termObject);
+                                                         "visible": Qt.binding(function () { return tabsModel.currentItem === tiledView})});
+        tiledView.emptied.connect(function () {tabsModel.removeItem(tabsModel.indexOf(tiledView));})
+        tabsModel.addItem(tiledView);
         currentIndex = tabsModel.count - 1;
     }
 

=== modified file 'src/app/qml/TabsPage.qml'
--- src/app/qml/TabsPage.qml	2016-12-12 12:44:22 +0000
+++ src/app/qml/TabsPage.qml	2017-01-12 13:29:38 +0000
@@ -103,7 +103,7 @@
                     Label {
                         anchors { fill: blackRect; margins: units.dp(2) }
                         property var tab: tabsModel.itemAt(index)
-                        text: tab ? tab.session.title : ""
+                        text: tab && tab.focusedTerminal ? tab.focusedTerminal.session.title : ""
                         wrapMode: Text.Wrap
                         color: "white"
                     }

=== renamed file 'src/app/qml/TerminalComponent.qml' => 'src/app/qml/Terminal.qml'
--- src/app/qml/TerminalComponent.qml	2016-12-12 12:44:22 +0000
+++ src/app/qml/Terminal.qml	2017-01-12 13:29:38 +0000
@@ -17,20 +17,21 @@
  */
 import QtQuick 2.4
 import Ubuntu.Components 1.3
+import Ubuntu.Components.Popups 1.3
 import QMLTermWidget 1.0
 import Terminal 0.1
 
 QMLTermWidget {
     id: terminal
-    width: parent.width
-    height: parent.height
 
     colorScheme: settings.colorScheme
     font.family: settings.fontStyle
     font.pixelSize: FontUtils.sizeToPixels("medium") * settings.fontSize / 10
 
+    property bool isDarkBackground: ColorUtils.luminance(backgroundColor) <= 0.85
+    property color contourColor: isDarkBackground ? Qt.rgba(1.0, 1.0, 1.0, 0.4) : Qt.rgba(0.0, 0.0, 0.0, 0.2)
     property string initialWorkingDirectory
-    signal sessionFinished(var session);
+    signal finished()
 
     session: QMLTermSession {
         id: terminalSession
@@ -68,7 +69,7 @@
              "-o", "LogLevel=Error",
              "mkdir -p `dirname %1`; echo -n $$ > %1; cd %2; bash".arg(sshShellPidFile).arg(initialWorkingDirectory)]
             : [])
-        onFinished: tabsModel.removeItem(tabsModel.indexOf(terminal))
+        onFinished: terminal.finished()
     }
 
     property int totalLines: terminal.scrollbarMaximum - terminal.scrollbarMinimum + terminal.lines
@@ -77,4 +78,116 @@
         terminalSession.startShellProgram();
         forceActiveFocus();
     }
+
+    // TODO: This invisible button is used to position the popover where the
+    // alternate action was called. Terrible terrible workaround!
+    Item {
+        id: hiddenButton
+        width: 1
+        height: 1
+        visible: false
+        enabled: false
+    }
+
+    TerminalInputArea {
+        id: inputArea
+        enabled: terminalPage.state != "SELECTION"
+        anchors.fill: parent
+        // FIXME: should anchor to the bottom of the window to cater for the case when the OSK is up
+
+        // This is the minimum wheel event registered by the plugin (with the current settings).
+        property real wheelValue: 40
+
+        // This is needed to fake a "flickable" scrolling.
+        swipeDelta: terminal.fontMetrics.height
+
+        // Mouse actions
+        onMouseMoveDetected: terminal.simulateMouseMove(x, y, button, buttons, modifiers);
+        onDoubleClickDetected: terminal.simulateMouseDoubleClick(x, y, button, buttons, modifiers);
+        onMousePressDetected: {
+            terminal.forceActiveFocus();
+            terminal.simulateMousePress(x, y, button, buttons, modifiers);
+        }
+        onMouseReleaseDetected: terminal.simulateMouseRelease(x, y, button, buttons, modifiers);
+        onMouseWheelDetected: terminal.simulateWheel(x, y, buttons, modifiers, angleDelta);
+
+        // Touch actions
+        onTouchPress: terminal.forceActiveFocus()
+        onTouchClick: terminal.simulateKeyPress(Qt.Key_Tab, Qt.NoModifier, true, 0, "");
+        onTouchPressAndHold: alternateAction(x, y);
+
+        // Swipe actions
+        onSwipeYDetected: {
+            if (steps > 0) {
+                simulateSwipeDown(steps);
+            } else {
+                simulateSwipeUp(-steps);
+            }
+        }
+        onSwipeXDetected: {
+            if (steps > 0) {
+                simulateSwipeRight(steps);
+            } else {
+                simulateSwipeLeft(-steps);
+            }
+        }
+        onTwoFingerSwipeYDetected: {
+            if (steps > 0) {
+                simulateDualSwipeDown(steps);
+            } else {
+                simulateDualSwipeUp(-steps);
+            }
+        }
+
+        function simulateSwipeUp(steps) {
+            while(steps > 0) {
+                terminal.simulateKeyPress(Qt.Key_Up, Qt.NoModifier, true, 0, "");
+                steps--;
+            }
+        }
+        function simulateSwipeDown(steps) {
+            while(steps > 0) {
+                terminal.simulateKeyPress(Qt.Key_Down, Qt.NoModifier, true, 0, "");
+                steps--;
+            }
+        }
+        function simulateSwipeLeft(steps) {
+            while(steps > 0) {
+                terminal.simulateKeyPress(Qt.Key_Left, Qt.NoModifier, true, 0, "");
+                steps--;
+            }
+        }
+        function simulateSwipeRight(steps) {
+            while(steps > 0) {
+                terminal.simulateKeyPress(Qt.Key_Right, Qt.NoModifier, true, 0, "");
+                steps--;
+            }
+        }
+        function simulateDualSwipeUp(steps) {
+            while(steps > 0) {
+                terminal.simulateWheel(width * 0.5, height * 0.5, Qt.NoButton, Qt.NoModifier, Qt.point(0, -wheelValue));
+                steps--;
+            }
+        }
+        function simulateDualSwipeDown(steps) {
+            while(steps > 0) {
+                terminal.simulateWheel(width * 0.5, height * 0.5, Qt.NoButton, Qt.NoModifier, Qt.point(0, wheelValue));
+                steps--;
+            }
+        }
+
+        // Semantic actions
+        onAlternateAction: {
+            // Force the hiddenButton in the event position.
+            hiddenButton.x = x;
+            hiddenButton.y = y;
+            PopupUtils.open(Qt.resolvedUrl("AlternateActionPopover.qml"),
+                            hiddenButton);
+        }
+    }
+
+    QMLTermScrollbar {
+        anchors.fill: parent
+        terminal: terminal
+    }
 }

=== modified file 'src/app/qml/TerminalPage.qml'
--- src/app/qml/TerminalPage.qml	2017-01-06 08:37:39 +0000
+++ src/app/qml/TerminalPage.qml	2017-01-12 13:29:38 +0000
@@ -27,7 +27,7 @@
 Page {
     id: terminalPage
     property alias terminalContainer: terminalContainer
-    property Item terminal
+    property Terminal terminal
     property var tabsModel
     property bool narrowLayout
     theme: ThemeSettings {
@@ -50,15 +50,15 @@
             top: parent.top
             right: parent.right
         }
-        property bool isDarkBackground: ColorUtils.luminance(backgroundColor) <= 0.85
+        property bool isDarkBackground: terminalPage.terminal && terminalPage.terminal.isDarkBackground
         actionColor: isDarkBackground ? "white" : "black"
         backgroundColor: terminalPage.terminal ? terminalPage.terminal.backgroundColor : ""
         foregroundColor: terminalPage.terminal ? terminalPage.terminal.foregroundColor : ""
-        contourColor: isDarkBackground ? Qt.rgba(1.0, 1.0, 1.0, 0.4) : Qt.rgba(0.0, 0.0, 0.0, 0.2)
+        contourColor: terminalPage.terminal ? terminalPage.terminal.contourColor : ""
         color: isDarkBackground ? Qt.tint(backgroundColor, "#0DFFFFFF") : Qt.tint(backgroundColor, "#0D000000")
         model: terminalPage.tabsModel
         function titleFromModelItem(modelItem) {
-            return modelItem.session.title;
+            return modelItem.focusedTerminal ? modelItem.focusedTerminal.session.title : "";
         }
 
         actions: [
@@ -84,7 +84,6 @@
             top: terminalPage.narrowLayout ? parent.top : tabsBar.bottom;
             right: parent.right;
             bottom: keyboardBarLoader.top
-            margins: units.gu(1)
         }
 
         Binding {
@@ -94,125 +93,6 @@
         }
     }
 
-    QMLTermScrollbar {
-        anchors {
-            top: terminalContainer.anchors.top
-            bottom: terminalContainer.anchors.bottom
-            left: terminalContainer.anchors.left
-            right: terminalContainer.anchors.right
-        }
-
-        terminal: terminalPage.terminal
-        z: inputArea.z + 1
-    }
-
-    // TODO: This invisible button is used to position the popover where the
-    // alternate action was called. Terrible terrible workaround!
-    Button {
-        id: hiddenButton
-        width: 5
-        height: 5
-        visible: false
-        enabled: false
-    }
-
-    TerminalInputArea{
-        id: inputArea
-        anchors {
-            left: terminalContainer.anchors.left
-            top: terminalContainer.anchors.top
-            right: terminalContainer.anchors.right
-            bottom: parent.bottom
-            margins: terminalContainer.anchors.margins
-        }
-        enabled: terminal
-
-        // This is the minimum wheel event registered by the plugin (with the current settings).
-        property real wheelValue: 40
-
-        // This is needed to fake a "flickable" scrolling.
-        swipeDelta: terminal ? terminal.fontMetrics.height : 0
-
-        // Mouse actions
-        onMouseMoveDetected: terminal.simulateMouseMove(x, y, button, buttons, modifiers);
-        onDoubleClickDetected: terminal.simulateMouseDoubleClick(x, y, button, buttons, modifiers);
-        onMousePressDetected: terminal.simulateMousePress(x, y, button, buttons, modifiers);
-        onMouseReleaseDetected: terminal.simulateMouseRelease(x, y, button, buttons, modifiers);
-        onMouseWheelDetected: terminal.simulateWheel(x, y, buttons, modifiers, angleDelta);
-
-        // Touch actions
-        onTouchClick: terminal.simulateKeyPress(Qt.Key_Tab, Qt.NoModifier, true, 0, "");
-        onTouchPressAndHold: alternateAction(x, y);
-
-        // Swipe actions
-        onSwipeYDetected: {
-            if (steps > 0) {
-                simulateSwipeDown(steps);
-            } else {
-                simulateSwipeUp(-steps);
-            }
-        }
-        onSwipeXDetected: {
-            if (steps > 0) {
-                simulateSwipeRight(steps);
-            } else {
-                simulateSwipeLeft(-steps);
-            }
-        }
-        onTwoFingerSwipeYDetected: {
-            if (steps > 0) {
-                simulateDualSwipeDown(steps);
-            } else {
-                simulateDualSwipeUp(-steps);
-            }
-        }
-
-        function simulateSwipeUp(steps) {
-            while(steps > 0) {
-                terminal.simulateKeyPress(Qt.Key_Up, Qt.NoModifier, true, 0, "");
-                steps--;
-            }
-        }
-        function simulateSwipeDown(steps) {
-            while(steps > 0) {
-                terminal.simulateKeyPress(Qt.Key_Down, Qt.NoModifier, true, 0, "");
-                steps--;
-            }
-        }
-        function simulateSwipeLeft(steps) {
-            while(steps > 0) {
-                terminal.simulateKeyPress(Qt.Key_Left, Qt.NoModifier, true, 0, "");
-                steps--;
-            }
-        }
-        function simulateSwipeRight(steps) {
-            while(steps > 0) {
-                terminal.simulateKeyPress(Qt.Key_Right, Qt.NoModifier, true, 0, "");
-                steps--;
-            }
-        }
-        function simulateDualSwipeUp(steps) {
-            while(steps > 0) {
-                terminal.simulateWheel(width * 0.5, height * 0.5, Qt.NoButton, Qt.NoModifier, Qt.point(0, -wheelValue));
-                steps--;
-            }
-        }
-        function simulateDualSwipeDown(steps) {
-            while(steps > 0) {
-                terminal.simulateWheel(width * 0.5, height * 0.5, Qt.NoButton, Qt.NoModifier, Qt.point(0, wheelValue));
-                steps--;
-            }
-        }
-
-        // Semantic actions
-        onAlternateAction: {
-            // Force the hiddenButton in the event position.
-            hiddenButton.x = x;
-            hiddenButton.y = y;
-            PopupUtils.open(Qt.resolvedUrl("AlternateActionPopover.qml"), hiddenButton);
-        }
-    }
-
     Loader {
         id: keyboardBarLoader
         height: active ? units.gu(5) : 0
@@ -227,7 +107,7 @@
             backgroundColor: tabsBar.color
             foregroundColor: tabsBar.foregroundColor
             onSimulateKey: terminal.simulateKeyPress(key, mod, true, 0, "");
-            onSimulateCommand: terminal.session.sendText(command);
+            onSimulateCommand: terminal.focusedTerminal.session.sendText(command);
         }
     }
 
@@ -267,7 +147,7 @@
             iconName: "close"
             onTriggered: {
                 terminalPage.state = "DEFAULT";
-                PopupUtils.open(Qt.resolvedUrl("AlternateActionPopover.qml"), hiddenButton);
+                PopupUtils.open(Qt.resolvedUrl("AlternateActionPopover.qml"));
             }
         }
     }
@@ -333,7 +213,6 @@
             PropertyChanges { target: keyboardButton; visible: false }
             PropertyChanges { target: bottomMessage; active: true }
             PropertyChanges { target: keyboardBarLoader; enabled: false }
-            PropertyChanges { target: inputArea; enabled: false }
         }
     ]
 }

=== modified file 'src/app/qml/TerminalSettings.qml'
--- src/app/qml/TerminalSettings.qml	2016-11-30 09:17:02 +0000
+++ src/app/qml/TerminalSettings.qml	2017-01-12 13:29:38 +0000
@@ -34,6 +34,12 @@
     property alias shortcutCopy: innerSettings.shortcutCopy
     property alias shortcutPaste: innerSettings.shortcutPaste
     property alias shortcutFullscreen: innerSettings.shortcutFullscreen
+    property alias shortcutSplitHorizontally: innerSettings.shortcutSplitHorizontally
+    property alias shortcutSplitVertically: innerSettings.shortcutSplitVertically
+    property alias shortcutMoveToTileAbove: innerSettings.shortcutMoveToTileAbove
+    property alias shortcutMoveToTileBelow: innerSettings.shortcutMoveToTileBelow
+    property alias shortcutMoveToTileLeft: innerSettings.shortcutMoveToTileLeft
+    property alias shortcutMoveToTileRight: innerSettings.shortcutMoveToTileRight
 
     readonly property int defaultFontSize: 12
     readonly property int minFontSize: 4
@@ -73,6 +79,12 @@
         property string shortcutCopy: "Ctrl+Shift+C"
         property string shortcutPaste: "Ctrl+Shift+V"
         property string shortcutFullscreen: "F11"
+        property string shortcutSplitHorizontally: "Ctrl+Shift+E"
+        property string shortcutSplitVertically: "Ctrl+Shift+O"
+        property string shortcutMoveToTileAbove: "Alt+Up"
+        property string shortcutMoveToTileBelow: "Alt+Down"
+        property string shortcutMoveToTileLeft: "Alt+Left"
+        property string shortcutMoveToTileRight: "Alt+Right"
     }
 
     // Load the keyboard profiles.

=== modified file 'src/app/qml/TerminalWindow.qml'
--- src/app/qml/TerminalWindow.qml	2016-12-12 13:41:58 +0000
+++ src/app/qml/TerminalWindow.qml	2017-01-12 13:29:38 +0000
@@ -25,7 +25,7 @@
 Window {
     id: terminalWindow
 
-    title: tabsModel.currentItem ? tabsModel.currentItem.session.title : ""
+    title: tabsModel.currentItem && tabsModel.currentItem.focusedTerminal ? tabsModel.currentItem.focusedTerminal.session.title : ""
     color: terminalPage.active && terminalPage.terminal ? terminalPage.terminal.backgroundColor : theme.palette.selected.overlay
     contentOrientation: Screen.orientation
 
@@ -35,7 +35,7 @@
     Binding {
         target: terminalAppRoot
         property: "focusedTerminal"
-        value: tabsModel.currentItem
+        value: tabsModel.currentItem ? tabsModel.currentItem.focusedTerminal : null
         when: terminalWindow.active
     }
 
@@ -71,6 +71,21 @@
                         }
     }
 
+    property TiledTerminalView tiledTerminalView: tabsModel.currentItem
+    Shortcut {
+        sequence: settings.shortcutSplitVertically
+        onActivated: tiledTerminalView.splitTerminal(tiledTerminalView.focusedTerminal,
+                                                     Qt.Horizontal)
+        enabled: tiledTerminalView.focusedTerminal.width >= 2 * tiledTerminalView.minimumTileWidth
+    }
+
+    Shortcut {
+        sequence: settings.shortcutSplitHorizontally
+        onActivated: tiledTerminalView.splitTerminal(tiledTerminalView.focusedTerminal,
+                                                     Qt.Vertical)
+        enabled: tiledTerminalView.focusedTerminal.height >= 2 * tiledTerminalView.minimumTileHeight
+    }
+
     Shortcut {
         sequence: settings.shortcutNewTab
         onActivated: tabsModel.addTerminalTab()
@@ -98,12 +113,12 @@
 
     Shortcut {
         sequence: settings.shortcutCopy
-        onActivated: tabsModel.currentItem.copyClipboard()
+        onActivated: tabsModel.currentItem.focusedTerminal.copyClipboard()
     }
 
     Shortcut {
         sequence: settings.shortcutPaste
-        onActivated: tabsModel.currentItem.pasteClipboard()
+        onActivated: tabsModel.currentItem.focusedTerminal.pasteClipboard()
     }
 
     Shortcut {
@@ -141,7 +156,7 @@
         TerminalPage {
             id: terminalPage
             tabsModel: tabsModel
-            terminal: tabsModel.currentItem
+            terminal: tabsModel.currentItem ? tabsModel.currentItem.focusedTerminal : null
             narrowLayout: terminalWindow.narrowLayout
             // Hide terminal data when the access is still not granted
             layer.enabled: authService.isDialogVisible

=== added file 'src/app/qml/TiledTerminalView.qml'
--- src/app/qml/TiledTerminalView.qml	1970-01-01 00:00:00 +0000
+++ src/app/qml/TiledTerminalView.qml	2017-01-12 13:29:38 +0000
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2016-2017 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored-by: Florian Boucault <[e-mail]>
+ */
+import QtQuick 2.5
+import Ubuntu.Components 1.3
+
+TiledView {
+    id: tiledTerminalView
+    anchors.fill: parent
+
+    property string initialWorkingDirectory
+    property Terminal focusedTerminal
+    signal emptied
+    onCountChanged: if (count == 0) emptied()
+
+    function splitTerminal(terminal, orientation) {
+        var initialWorkingDirectory = focusedTerminal.session.getWorkingDirectory();
+        var newTerminal = terminalComponent.createObject(tiledTerminalView,
+                                                         {"initialWorkingDirectory": initialWorkingDirectory});
+        tiledTerminalView.setOrientation(terminal, orientation);
+        tiledTerminalView.add(terminal, newTerminal, Qt.AlignTrailing);
+    }
+
+    handleDelegate: Rectangle {
+        implicitWidth: units.dp(1)
+        implicitHeight: units.dp(1)
+        color: focusedTerminal ? focusedTerminal.contourColor : ""
+    }
+
+    Component.onCompleted: {
+        var newTerminal = terminalComponent.createObject(tiledTerminalView,
+                                                         {"initialWorkingDirectory": initialWorkingDirectory});
+        setRootItem(newTerminal);
+    }
+
+    function moveFocus(direction) {
+        var terminal = tiledTerminalView.closestTileInDirection(focusedTerminal, direction);
+        if (terminal) {
+            terminal.focus = true;
+        }
+    }
+
+    Shortcut {
+        sequence: settings.shortcutMoveToTileRight
+        enabled: tiledTerminalView.focus
+        onActivated: moveFocus(Qt.AlignRight)
+    }
+
+    Shortcut {
+        sequence: settings.shortcutMoveToTileLeft
+        enabled: tiledTerminalView.focus
+        onActivated: moveFocus(Qt.AlignLeft)
+    }
+
+    Shortcut {
+        sequence: settings.shortcutMoveToTileAbove
+        enabled: tiledTerminalView.focus
+        onActivated: moveFocus(Qt.AlignTop)
+    }
+
+    Shortcut {
+        sequence: settings.shortcutMoveToTileBelow
+        enabled: tiledTerminalView.focus
+        onActivated: moveFocus(Qt.AlignBottom)
+    }
+
+    property real minimumTileWidth: units.gu(10)
+    property real minimumTileHeight: units.gu(10)
+    property Component terminalComponent: Terminal {
+        id: terminal
+        Component.onCompleted: if (focus) tiledTerminalView.focusedTerminal = terminal
+        onFocusChanged: if (focus) tiledTerminalView.focusedTerminal = terminal
+        onFinished: {
+            if (terminal.focus) {
+                var nextTerminal = tiledTerminalView.closestTile(terminal);
+                if (nextTerminal) nextTerminal.focus = true;
+            }
+            tiledTerminalView.remove(terminal);
+            terminal.destroy();
+        }
+    }
+}

=== added file 'src/app/qml/TiledView.qml'
--- src/app/qml/TiledView.qml	1970-01-01 00:00:00 +0000
+++ src/app/qml/TiledView.qml	2017-01-12 13:29:38 +0000
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2016-2017 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored-by: Florian Boucault <[e-mail]>
+ */
+import QtQuick 2.5
+import "binarytree.js" as BinaryTree
+
+FocusScope {
+    id: tiledView
+
+    property Component handleDelegate: Rectangle {
+        implicitWidth: units.dp(1)
+        implicitHeight: units.dp(1)
+        color: "white"
+    }
+
+    property int count: 0
+
+    // FIXME: odd semantics: what if setRootItem is called later?
+    function setRootItem(rootItem) {
+        if (rootItem && rootItem === __rootNode.value) {
+            return null;
+        }
+
+        var oldRoot = __rootNode.value;
+        if (rootItem) {
+            count = 1;
+        } else {
+            count = 0;
+            __rootNode.cleanup();
+        }
+        __rootNode.setValue(rootItem);
+
+        return oldRoot;
+    }
+
+    property var __rootNode: new BinaryTree.Node()
+    Component.onDestruction: __rootNode.cleanup()
+
+    Component.onCompleted: {
+        __rootNode.setWidth(width);
+        __rootNode.setHeight(height);
+    }
+
+    onWidthChanged: __rootNode.setWidth(width)
+    onHeightChanged: __rootNode.setHeight(height)
+
+    Component {
+        id: separatorComponent
+        TiledViewSeparator {
+            handleDelegate: tiledView.handleDelegate
+        }
+    }
+
+    function add(obj, newObj, side) {
+        var node = __rootNode.findNodeWithValue(obj);
+        var otherSide;
+        if (side == Qt.AlignLeading) {
+            otherSide = Qt.AlignTrailing;
+        } else {
+            otherSide = Qt.AlignLeading;
+        }
+
+        node.value = null;
+        node.setLeftRatio(0.5);
+        var separator = separatorComponent.createObject(tiledView, {"node": node});
+        node.setSeparator(separator);
+
+        var nodeSide = new BinaryTree.Node();
+        nodeSide.setValue(newObj);
+        node.setChild(side, nodeSide);
+
+        var nodeOtherSide = new BinaryTree.Node();
+        nodeOtherSide.setValue(obj);
+        node.setChild(otherSide, nodeOtherSide);
+        count += 1;
+    }
+
+    function remove(obj) {
+        var node = __rootNode.findNodeWithValue(obj);
+        var sibling = node.getSibling();
+        if (sibling) {
+            node.parent.copy(sibling);
+        }
+        count -= 1;
+    }
+
+    function closestTile(obj) {
+        var node = __rootNode.findNodeWithValue(obj);
+        var sibling = node.closestNodeWithValue();
+        if (sibling) {
+            return sibling.value;
+        } else {
+            return null;
+        }
+    }
+
+    function closestTileInDirection(obj, direction) {
+        var node = __rootNode.findNodeWithValue(obj);
+        var closestNode = node.closestNodeWithValueInDirection(direction);
+        if (closestNode && closestNode.value) {
+            return closestNode.value;
+        } else {
+            return null;
+        }
+    }
+
+    function getOrientation(obj) {
+        var node = __rootNode.findNodeWithValue(obj);
+        return node.orientation;
+    }
+
+    function setOrientation(obj, orientation) {
+        var node = __rootNode.findNodeWithValue(obj);
+        node.setOrientation(orientation);
+    }
+
+    function move(obj, targetObj, side) {
+        remove(obj);
+        add(targetObj, obj, side);
+    }
+}

=== added file 'src/app/qml/TiledViewSeparator.qml'
--- src/app/qml/TiledViewSeparator.qml	1970-01-01 00:00:00 +0000
+++ src/app/qml/TiledViewSeparator.qml	2017-01-12 13:29:38 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2016-2017 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored-by: Florian Boucault <[e-mail]>
+ */
+import QtQuick 2.4
+import Ubuntu.Components 1.3
+
+Item {
+    id: separator
+
+    property int orientation: Qt.Horizontal
+    property var node
+    property Component handleDelegate
+
+    Loader {
+        id: handleLoader
+        sourceComponent: handleDelegate
+        anchors.fill: parent
+    }
+
+    implicitWidth: handleLoader.implicitWidth
+    implicitHeight: handleLoader.implicitHeight
+    z: 1
+
+    MouseArea {
+        anchors.centerIn: parent
+        width: orientation == Qt.Vertical ? units.gu(1) : parent.width
+        height: orientation == Qt.Vertical ? parent.height : units.gu(1)
+        cursorShape: orientation == Qt.Horizontal ? Qt.SizeVerCursor : Qt.SizeHorCursor
+        drag {
+            axis: orientation == Qt.Horizontal ? Drag.YAxis : Drag.XAxis
+            target: resizer
+            smoothed: false
+        }
+        onPressed: {
+            resizer.initialRatio = node.leftRatio;
+            resizer.x = 0;
+            resizer.y = 0;
+        }
+        enabled: separator.visible
+    }
+
+    function clamp(value, min, max) {
+        return Math.min(Math.max(min, value), max);
+    }
+
+    Item {
+        id: resizer
+        property real initialRatio
+        property real minimumRatio: 0.1
+        parent: null
+        onXChanged: {
+            var ratio = initialRatio + x / node.width;
+            ratio = clamp(ratio, minimumRatio, 1.0-minimumRatio);
+            node.setLeftRatio(ratio);
+        }
+        onYChanged: {
+            var ratio = initialRatio + y / node.height;
+            ratio = clamp(ratio, minimumRatio, 1.0-minimumRatio);
+            node.setLeftRatio(ratio);
+        }
+    }
+}

=== added file 'src/app/qml/binarytree.js'
--- src/app/qml/binarytree.js	1970-01-01 00:00:00 +0000
+++ src/app/qml/binarytree.js	2017-01-12 13:29:38 +0000
@@ -0,0 +1,378 @@
+/*
+ * Copyright (C) 2016-2017 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored-by: Florian Boucault <[e-mail]>
+ */
+.pragma library
+
+function Node() {
+    this.value = null;
+    this.parent = null;
+    this.left = null;
+    this.right = null;
+    this.separator = null;
+    this.leftRatio = 0.5;
+    this.rightRatio = 0.5;
+    this.orientation = Qt.Horizontal;
+    this.originX = 0;
+    this.originY = 0;
+    this.x = 0;
+    this.y = 0;
+    this.width = 0;
+    this.height = 0;
+}
+
+Node.prototype.cleanup = function cleanup(value) {
+    if (this.separator) {
+        this.separator.destroy();
+        this.separator = null;
+    }
+    this.parent = null;
+    this.value = null;
+    if (this.left) {
+        this.left.cleanup();
+        this.left = null;
+    }
+    if (this.right) {
+        this.right.cleanup();
+        this.right = null;
+    }
+}
+
+Node.prototype.setValue = function setValue(value) {
+    this.value = value;
+    this.updateX();
+    this.updateY();
+    this.updateWidth();
+    this.updateHeight();
+}
+
+Node.prototype.updateWidth = function updateWidth() {
+    if (this.value) {
+        this.value.width = this.width;
+    } else if (this.orientation == Qt.Horizontal) {
+        if (this.right && !this.left) {
+            this.right.setWidth(this.width);
+            this.right.setX(0);
+        }
+        if (this.left && !this.right) {
+            this.left.setWidth(this.width);
+            this.left.setX(0);
+        }
+        if (this.right && this.left) {
+            this.left.setWidth(this.width * this.leftRatio);
+            this.left.setX(0);
+            this.right.setWidth(this.width * this.rightRatio);
+            this.right.setX(this.left.width);
+        }
+    } else if (this.orientation == Qt.Vertical) {
+        if (this.left) {
+            this.left.setWidth(this.width);
+            this.left.setX(0);
+        }
+        if (this.right) {
+            this.right.setWidth(this.width);
+            this.right.setX(0);
+        }
+    }
+    this.updateSeparator();
+}
+
+Node.prototype.setWidth = function setWidth(width) {
+    this.width = width;
+    this.updateWidth();
+};
+
+Node.prototype.updateHeight = function updateHeight() {
+    if (this.value) {
+        this.value.height = this.height;
+    } else if (this.orientation == Qt.Vertical) {
+        if (this.right && !this.left) {
+            this.right.setHeight(this.height);
+            this.right.setY(0);
+        }
+        if (this.left && !this.right) {
+            this.left.setHeight(this.height);
+            this.left.setY(0);
+        }
+        if (this.right && this.left) {
+            this.left.setHeight(this.height * this.leftRatio);
+            this.left.setY(0);
+            this.right.setHeight(this.height * this.rightRatio);
+            this.right.setY(this.left.height);
+        }
+    } else if (this.orientation == Qt.Horizontal) {
+        if (this.left) {
+            this.left.setHeight(this.height);
+            this.left.setY(0);
+        }
+        if (this.right) {
+            this.right.setHeight(this.height);
+            this.right.setY(0);
+        }
+    }
+    this.updateSeparator();
+}
+
+Node.prototype.setHeight = function setHeight(height) {
+    this.height = height;
+    this.updateHeight();
+};
+
+Node.prototype.setLeftRatio = function setLeftRatio(ratio) {
+    this.leftRatio = ratio;
+    this.rightRatio = 1.0 - this.leftRatio;
+    if (this.orientation == Qt.Horizontal) {
+        this.updateWidth();
+    } else {
+        this.updateHeight();
+    }
+};
+
+Node.prototype.setRightRatio = function setRightRatio(ratio) {
+    this.rightRatio = ratio;
+    this.leftRatio = 1.0 - this.rightRatio;
+    if (this.orientation == Qt.Horizontal) {
+        this.updateWidth();
+    } else {
+        this.updateHeight();
+    }
+};
+
+Node.prototype.setChild = function setChild(side, childNode) {
+    switch (side) {
+        case Qt.AlignLeading:
+            if (this.left) {
+                // FIXME: breaks copy()
+//                this.left.cleanup();
+            }
+            this.left = childNode;
+            break;
+        case Qt.AlignTrailing:
+            if (this.right) {
+                // FIXME: breaks copy()
+//                this.right.cleanup();
+            }
+            this.right = childNode;
+            break;
+        default:
+            break;
+    }
+    if (childNode) {
+        childNode.parent = this;
+    }
+    this.updateX();
+    this.updateY();
+    this.updateWidth();
+    this.updateHeight();
+}
+
+Node.prototype.updateSeparator = function updateSeparator() {
+    if (this.separator) {
+        this.separator.orientation = this.orientation == Qt.Vertical ? Qt.Horizontal : Qt.Vertical;
+        if (this.left && this.right) {
+            // FIXME: separator should be centered
+            this.separator.x = this.right.originX + this.right.x;
+            this.separator.y = this.right.originY + this.right.y;
+            if (this.separator.orientation == Qt.Vertical) {
+                this.separator.width = this.separator.implicitWidth;
+                this.separator.height = this.right.height;
+            } else if (this.separator.orientation == Qt.Horizontal) {
+                this.separator.width = this.right.width;
+                this.separator.height = this.separator.implicitHeight;
+            }
+            this.separator.visible = true;
+        } else {
+            this.separator.visible = false;
+        }
+    }
+}
+
+Node.prototype.setSeparator = function setSeparator(separator) {
+    this.separator = separator;
+    this.updateSeparator();
+}
+
+Node.prototype.copy = function copy(otherNode) {
+    if (!otherNode) return;
+    var newParent = otherNode.parent;
+
+    this.orientation = otherNode.orientation;
+    this.setValue(otherNode.value);
+    this.setChild(Qt.AlignLeading, otherNode.left);
+    this.setChild(Qt.AlignTrailing, otherNode.right);
+
+    if (newParent.left === otherNode) {
+        newParent.setChild(Qt.AlignLeading, this);
+    } else if (otherNode.parent.right === otherNode) {
+        newParent.setChild(Qt.AlignTrailing, this);
+    }
+    otherNode.left = null;
+    otherNode.right = null;
+    otherNode.cleanup();
+    this.updateX();
+    this.updateY();
+    this.updateWidth();
+    this.updateHeight();
+}
+
+Node.prototype.setOrientation = function setOrientation(orientation) {
+    this.orientation = orientation;
+    this.updateWidth();
+    this.updateHeight();
+    this.updateSeparator();
+}
+
+Node.prototype.updateX = function updateX() {
+    var absoluteX = this.originX + this.x;
+    if (this.value) {
+        this.value.x = Math.round(absoluteX);
+    } else {
+        if (this.left) {
+            this.left.setOriginX(absoluteX);
+        }
+        if (this.right) {
+            this.right.setOriginX(absoluteX);
+        }
+    }
+    this.updateSeparator();
+}
+
+Node.prototype.setX = function setX(x) {
+    this.x = x;
+    this.updateX();
+};
+
+Node.prototype.setOriginX = function setOriginX(x) {
+    this.originX = x;
+    this.updateX();
+};
+
+Node.prototype.updateY = function updateY() {
+    var absoluteY = this.originY + this.y;
+    if (this.value) {
+        this.value.y = Math.round(absoluteY);
+    } else {
+        if (this.left) {
+            this.left.setOriginY(absoluteY);
+        }
+        if (this.right) {
+            this.right.setOriginY(absoluteY);
+        }
+    }
+    this.updateSeparator();
+}
+
+Node.prototype.setY = function setY(y) {
+    this.y = y;
+    this.updateY();
+};
+
+Node.prototype.setOriginY = function setOriginY(y) {
+    this.originY = y;
+    this.updateY();
+};
+
+Node.prototype.getSibling = function getSibling() {
+    if (this.parent) {
+        if (this.parent.left === this) {
+            return this.parent.right;
+        } else {
+            return this.parent.left;
+        }
+    }
+    return null;
+}
+
+Node.prototype.findNodeWithValue = function findNodeWithValue(value) {
+    if (this.value === value) return this;
+    var result;
+    if (this.left) {
+        result = this.left.findNodeWithValue(value);
+        if (result) {
+            return result;
+        }
+    }
+    if (this.right) {
+        result = this.right.findNodeWithValue(value);
+        if (result) {
+            return result;
+        }
+    }
+    return null;
+};
+
+Node.prototype.closestChildWithValue = function closestChildWithValue(sides) {
+    var currentLevelNodes = [this];
+    var nextLevelNodes = [];
+    while (currentLevelNodes.length != 0) {
+        for (var i=0; i<currentLevelNodes.length; i++) {
+            var node = currentLevelNodes[i];
+            if (node.value) {
+                return node;
+            }
+            if ((sides == undefined || sides & Qt.AlignLeading) && node.left) {
+                nextLevelNodes.push(node.left);
+            }
+            if ((sides == undefined || sides & Qt.AlignTrailing) && node.right) {
+                nextLevelNodes.push(node.right);
+            }
+        }
+        currentLevelNodes = nextLevelNodes;
+        nextLevelNodes = [];
+    }
+    return null;
+}
+
+Node.prototype.closestNodeWithValue = function closestNodeWithValue() {
+    // explore sibling hierarchy
+    var sibling = this.getSibling();
+    if (sibling) {
+        var closestChild = sibling.closestChildWithValue(Qt.AlignLeading | Qt.AlignTrailing);
+        if (closestChild) {
+            return closestChild;
+        }
+    }
+    // explore parent's sibling hierarchy
+    if (this.parent) {
+        var parentSibling = this.parent.getSibling();
+        if (parentSibling) {
+            var closestChild = parentSibling.closestChildWithValue(Qt.AlignLeading | Qt.AlignTrailing);
+            if (closestChild) {
+                return closestChild;
+            }
+        }
+    }
+    return null;
+};
+
+Node.prototype.closestNodeWithValueInDirection = function closestNodeWithValueInDirection(direction) {
+    if (this.parent) {
+        if (this.parent.left === this) {
+            if ((direction == Qt.AlignRight && this.parent.orientation == Qt.Horizontal) ||
+                (direction == Qt.AlignBottom && this.parent.orientation == Qt.Vertical)) {
+                return this.parent.right.closestChildWithValue(Qt.AlignLeading);
+            }
+        } else if (this.parent.right === this) {
+            if ((direction == Qt.AlignLeft && this.parent.orientation == Qt.Horizontal) ||
+                (direction == Qt.AlignTop && this.parent.orientation == Qt.Vertical)) {
+                return this.parent.left.closestChildWithValue(Qt.AlignTrailing);
+            }
+        }
+        return this.parent.closestNodeWithValueInDirection(direction);
+    } else {
+        return null;
+    }
+}

=== modified file 'src/plugin/qmltermwidget/lib/TerminalDisplay.h'
--- src/plugin/qmltermwidget/lib/TerminalDisplay.h	2017-01-06 08:37:18 +0000
+++ src/plugin/qmltermwidget/lib/TerminalDisplay.h	2017-01-12 13:29:38 +0000
@@ -898,8 +898,8 @@
 
     //the delay in milliseconds between redrawing blinking text
     static const int TEXT_BLINK_DELAY = 500;
-    static const int DEFAULT_LEFT_MARGIN = 1;
-    static const int DEFAULT_TOP_MARGIN = 1;
+    static const int DEFAULT_LEFT_MARGIN = 8;
+    static const int DEFAULT_TOP_MARGIN = 8;
 
     // QMLTermWidget port functions
     QFont m_font;

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2015-02-24 23:23:36 +0000
+++ tests/CMakeLists.txt	2017-01-12 13:29:38 +0000
@@ -1,1 +1,2 @@
 add_subdirectory(autopilot)
+add_subdirectory(qtquicktest)

=== added directory 'tests/qtquicktest'
=== added file 'tests/qtquicktest/CMakeLists.txt'
--- tests/qtquicktest/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ tests/qtquicktest/CMakeLists.txt	2017-01-12 13:29:38 +0000
@@ -0,0 +1,20 @@
+find_program(XVFB_RUN_BIN xvfb-run)
+if(NOT XVFB_RUN_BIN)
+  message(FATAL_ERROR "Could not find xvfb-run, please install the xvfb package")
+endif()
+set(XVFB_RUN_CMD ${XVFB_RUN_BIN} -a -s "-screen 0 1024x768x24")
+
+include(FindPkgConfig)
+find_package(Qt5Core)
+
+# copy qml test files to build directory
+if(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
+add_custom_target(qmlTestFiles ALL
+    COMMAND cp ${CMAKE_CURRENT_SOURCE_DIR}/*.qml ${CMAKE_CURRENT_BINARY_DIR}
+)
+endif(NOT "${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_BINARY_DIR}")
+
+set(QTQUICK_TEST tst_qtquicktest)
+add_executable(${QTQUICK_TEST} qtquicktest.cpp)
+qt5_use_modules(${QTQUICK_TEST} Core Qml Quick Test QuickTest)
+add_test(${QTQUICK_TEST} ${XVFB_RUN_CMD} ${CMAKE_CURRENT_BINARY_DIR}/${QTQUICK_TEST})

=== added file 'tests/qtquicktest/qtquicktest.cpp'
--- tests/qtquicktest/qtquicktest.cpp	1970-01-01 00:00:00 +0000
+++ tests/qtquicktest/qtquicktest.cpp	2017-01-12 13:29:38 +0000
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2012 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QtQuickTest/quicktest.h>
+QUICK_TEST_MAIN(qtquicktest)

=== added file 'tests/qtquicktest/tst_TiledView.qml'
--- tests/qtquicktest/tst_TiledView.qml	1970-01-01 00:00:00 +0000
+++ tests/qtquicktest/tst_TiledView.qml	2017-01-12 13:29:38 +0000
@@ -0,0 +1,468 @@
+/*
+ * Copyright (C) 2017 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored-by: Florian Boucault <[e-mail]>
+ */
+
+import QtQuick 2.4
+import QtTest 1.0
+import "../../src/app/qml"
+
+TiledView {
+    id: tiledView
+    width: 800
+    height: 600
+
+    TestCase {
+        name: "TiledView"
+        when: windowShown
+
+        property Component objectComponent: Rectangle {
+            width: 100
+            height: 50
+            color: "red"
+        }
+
+        SignalSpy {
+            id: countSpy
+            target: tiledView
+            signalName: "countChanged"
+        }
+
+        function init() {
+            countSpy.clear();
+        }
+
+        function test_defaults() {
+            compare(tiledView.count, 0);
+        }
+
+        function test_setRootItemValid() {
+            var rightObject = objectComponent.createObject(tiledView);
+            var oldRoot = tiledView.setRootItem(rightObject);
+            compare(oldRoot, null);
+            compare(countSpy.count, 1);
+            compare(tiledView.count, 1);
+            compare(rightObject.width, tiledView.width);
+            compare(rightObject.height, tiledView.height);
+            compare(tiledView.getOrientation(rightObject), Qt.Horizontal);
+            tiledView.setRootItem(null);
+            rightObject.destroy();
+        }
+
+        function test_setRootItemNull() {
+            var oldRoot = tiledView.setRootItem(null);
+            compare(oldRoot, null);
+            compare(countSpy.count, 0);
+            compare(tiledView.count, 0);
+        }
+
+        function test_resetRootItem() {
+            // set to new object
+            var rightObject = objectComponent.createObject(tiledView);
+            var oldRoot = tiledView.setRootItem(rightObject);
+            compare(oldRoot, null);
+            compare(countSpy.count, 1);
+            compare(tiledView.count, 1);
+
+            // set to same object
+            oldRoot = tiledView.setRootItem(rightObject);
+            compare(oldRoot, null);
+            compare(countSpy.count, 1);
+            compare(tiledView.count, 1);
+
+            // set to another new object
+            var rightObject2 = objectComponent.createObject(tiledView);
+            oldRoot = tiledView.setRootItem(rightObject2);
+            compare(oldRoot, rightObject);
+            compare(countSpy.count, 1);
+            compare(tiledView.count, 1);
+
+            // set to null
+            oldRoot = tiledView.setRootItem(null);
+            compare(oldRoot, rightObject2);
+            compare(countSpy.count, 2);
+            compare(tiledView.count, 0);
+
+            rightObject.destroy();
+            rightObject2.destroy();
+        }
+
+        function verifySetRootItem(object) {
+            tiledView.setRootItem(object);
+            compare(tiledView.count, 1);
+            compare(object.width, tiledView.width);
+            compare(object.height, tiledView.height);
+        }
+
+        function verifySetOrientation(object, orientation) {
+            tiledView.setOrientation(object, orientation);
+            compare(tiledView.getOrientation(object), orientation);
+        }
+
+        function verifyAdd(object, rightObject, side) {
+            var previousX = object.x;
+            var previousY = object.y;
+            var previousWidth = object.width;
+            var previousHeight = object.height;
+            var previousCount = tiledView.count;
+            var orientation = tiledView.getOrientation(object);
+
+            tiledView.add(object, rightObject, side);
+            compare(tiledView.count, previousCount+1);
+            compare(tiledView.getOrientation(object), Qt.Horizontal);
+            compare(tiledView.getOrientation(rightObject), Qt.Horizontal);
+
+            if (orientation == Qt.Horizontal) {
+                compare(object.width, previousWidth / 2);
+                compare(object.height, previousHeight);
+                compare(rightObject.width, previousWidth / 2);
+                compare(rightObject.height, previousHeight);
+                if (side == Qt.AlignTrailing) {
+                    compare(object.x, previousX);
+                    compare(object.y, previousY);
+                    compare(rightObject.x, previousX + Math.round(previousWidth / 2));
+                    compare(rightObject.y, previousY);
+                } else if (side == Qt.AlignLeading) {
+                    compare(rightObject.x, previousX);
+                    compare(rightObject.y, previousY);
+                    compare(object.x, previousX + Math.round(previousWidth / 2));
+                    compare(object.y, previousY);
+                }
+            } else if (orientation == Qt.Vertical) {
+                compare(object.width, previousWidth);
+                compare(object.height, previousHeight / 2);
+                compare(rightObject.width, previousWidth);
+                compare(rightObject.height, previousHeight / 2);
+                if (side == Qt.AlignTrailing) {
+                    compare(object.x, previousX);
+                    compare(object.y, previousY);
+                    compare(rightObject.x, previousX);
+                    compare(rightObject.y, previousY + Math.round(previousHeight / 2));
+                } else if (side == Qt.AlignLeading) {
+                    compare(rightObject.x, previousX);
+                    compare(rightObject.y, previousY);
+                    compare(object.x, previousX);
+                    compare(object.y, previousY + Math.round(previousHeight / 2));
+                }
+            }
+        }
+
+        function verifyRemove(object) {
+            var node = tiledView.__rootNode.findNodeWithValue(object);
+            var siblingNode = node.getSibling();
+            var siblingObject = siblingNode.value;
+
+            var side;
+            if (node.parent.left === node) {
+                side = Qt.AlignLeading;
+            } else {
+                side = Qt.AlignTrailing;
+            }
+            var orientation = node.parent.orientation;
+
+            var expectedX;
+            var expectedY;
+            var expectedWidth;
+            var expectedHeight;
+            if (orientation == Qt.Horizontal) {
+                expectedWidth = object.width + siblingNode.width;
+                expectedHeight = siblingNode.height;
+                if (side == Qt.AlignTrailing) {
+                    expectedX = siblingNode.x;
+                    expectedY = siblingNode.y;
+                } else if (side == Qt.AlignLeading) {
+                    expectedX = object.x;
+                    expectedY = siblingNode.y;
+                }
+            } else if (orientation == Qt.Vertical) {
+                expectedWidth = siblingNode.width;
+                expectedHeight = object.height + siblingNode.height;
+                if (side == Qt.AlignTrailing) {
+                    expectedX = siblingNode.x;
+                    expectedY = siblingNode.y;
+                } else if (side == Qt.AlignLeading) {
+                    expectedX = siblingNode.x;
+                    expectedY = object.y;
+                }
+            }
+
+            var previousCount = tiledView.count;
+
+            tiledView.remove(object);
+            // TODO: we verify that the resulting node has the correct x/y,width/height
+            // but we could go further and verify that all its children also do
+            var removeNode = tiledView.__rootNode.findNodeWithValue(siblingObject);
+            compare(tiledView.count, previousCount-1);
+            compare(removeNode.width, expectedWidth);
+            compare(removeNode.height, expectedHeight);
+            compare(removeNode.x, expectedX);
+            compare(removeNode.y, expectedY);
+        }
+
+        function test_simpleAdd_data() {
+            return [
+                        {orientation: Qt.Horizontal, side: Qt.AlignTrailing},
+                        {orientation: Qt.Vertical, side: Qt.AlignTrailing},
+                        {orientation: Qt.Horizontal, side: Qt.AlignLeading},
+                        {orientation: Qt.Vertical, side: Qt.AlignLeading},
+            ];
+        }
+
+        function test_simpleAdd(data) {
+            var rootObject = objectComponent.createObject(tiledView);
+            verifySetRootItem(rootObject);
+            verifySetOrientation(rootObject, data.orientation);
+
+            var rightObject = objectComponent.createObject(tiledView);
+            verifyAdd(rootObject, rightObject, data.side);
+
+            tiledView.setRootItem(null);
+            rootObject.destroy();
+            rightObject.destroy();
+        }
+
+        function test_nestedAdds() {
+            var objects = [];
+
+            objects["0"] = objectComponent.createObject(tiledView);
+            verifySetRootItem(objects["0"]);
+
+            objects["1"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["0"], Qt.Horizontal);
+            verifyAdd(objects["0"], objects["1"], Qt.AlignTrailing);
+
+            objects["2"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["1"], Qt.Horizontal);
+            verifyAdd(objects["1"], objects["2"], Qt.AlignTrailing);
+
+            objects["3"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["2"], Qt.Horizontal);
+            verifyAdd(objects["2"], objects["3"], Qt.AlignTrailing);
+
+            objects["4"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["3"], Qt.Horizontal);
+            verifyAdd(objects["3"], objects["4"], Qt.AlignTrailing);
+
+            objects["5"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["4"], Qt.Horizontal);
+            verifyAdd(objects["4"], objects["5"], Qt.AlignTrailing);
+
+            objects["6"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["5"], Qt.Horizontal);
+            verifyAdd(objects["5"], objects["6"], Qt.AlignTrailing);
+
+            tiledView.setRootItem(null);
+            for (var i=0; i<objects.length; i++) {
+                objects[i].destroy();
+            }
+        }
+
+        function test_resizeView() {
+            var leftObject = objectComponent.createObject(tiledView);
+            verifySetRootItem(leftObject);
+
+            var bottomRightObject = objectComponent.createObject(tiledView);
+            verifySetOrientation(leftObject, Qt.Horizontal);
+            verifyAdd(leftObject, bottomRightObject, Qt.AlignTrailing);
+
+            var topRightObject = objectComponent.createObject(tiledView);
+            verifySetOrientation(bottomRightObject, Qt.Vertical);
+            verifyAdd(bottomRightObject, topRightObject, Qt.AlignLeading);
+
+            var initialWidth = tiledView.width;
+            var initialHeight = tiledView.height;
+            var factor = 0.7;
+
+            // storing sizes before resizing
+            var sizes = {"leftObject": {"width": leftObject.width, "height": leftObject.height},
+                         "bottomRightObject": {"width": bottomRightObject.width, "height": bottomRightObject.height},
+                         "topRightObject": {"width": topRightObject.width, "height": topRightObject.height}};
+            tiledView.width = initialWidth * factor;
+            compare(leftObject.width, sizes.leftObject.width * factor);
+            compare(bottomRightObject.width, sizes.bottomRightObject.width * factor);
+            compare(topRightObject.width, sizes.topRightObject.width * factor);
+            compare(leftObject.height, sizes.leftObject.height);
+            compare(bottomRightObject.height, sizes.bottomRightObject.height);
+            compare(topRightObject.height, sizes.topRightObject.height);
+
+            tiledView.height = initialHeight * factor;
+            compare(leftObject.width, sizes.leftObject.width * factor);
+            compare(bottomRightObject.width, sizes.bottomRightObject.width * factor);
+            compare(topRightObject.width, sizes.topRightObject.width * factor);
+            compare(leftObject.height, sizes.leftObject.height * factor);
+            compare(bottomRightObject.height, sizes.bottomRightObject.height * factor);
+            compare(topRightObject.height, sizes.topRightObject.height * factor);
+
+            // resetting initial size
+            tiledView.width = initialWidth;
+            tiledView.height = initialHeight;
+            compare(leftObject.width, sizes.leftObject.width);
+            compare(bottomRightObject.width, sizes.bottomRightObject.width);
+            compare(topRightObject.width, sizes.topRightObject.width);
+            compare(leftObject.height, sizes.leftObject.height);
+            compare(bottomRightObject.height, sizes.bottomRightObject.height);
+            compare(topRightObject.height, sizes.topRightObject.height);
+
+            tiledView.setRootItem(null);
+            leftObject.destroy();
+            bottomRightObject.destroy();
+            topRightObject.destroy();
+        }
+
+        function test_simpleRemove_data() {
+            return [
+                        {orientation: Qt.Horizontal, side: Qt.AlignTrailing},
+                        {orientation: Qt.Vertical, side: Qt.AlignTrailing},
+                        {orientation: Qt.Horizontal, side: Qt.AlignLeading},
+                        {orientation: Qt.Vertical, side: Qt.AlignLeading},
+            ];
+        }
+
+        function test_simpleRemove(data) {
+            var rootObject = objectComponent.createObject(tiledView);
+            verifySetRootItem(rootObject);
+            verifySetOrientation(rootObject, data.orientation);
+
+            var rightObject = objectComponent.createObject(tiledView);
+            verifyAdd(rootObject, rightObject, data.side);
+            verifyRemove(rightObject);
+
+            verifyAdd(rootObject, rightObject, data.side);
+            verifyRemove(rootObject);
+
+            verifyAdd(rightObject, rootObject, data.side);
+            verifyRemove(rightObject);
+
+            tiledView.setRootItem(null);
+            rootObject.destroy();
+            rightObject.destroy();
+        }
+
+        function test_nestedAddsRemoveRoot() {
+            var objects = [];
+
+            objects["0"] = objectComponent.createObject(tiledView);
+            verifySetRootItem(objects["0"]);
+
+            objects["1"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["0"], Qt.Horizontal);
+            verifyAdd(objects["0"], objects["1"], Qt.AlignTrailing);
+
+            objects["2"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["1"], Qt.Horizontal);
+            verifyAdd(objects["1"], objects["2"], Qt.AlignTrailing);
+
+            // remove root
+            verifyRemove(objects["0"]);
+
+            // add further
+            objects["3"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["2"], Qt.Horizontal);
+            verifyAdd(objects["2"], objects["3"], Qt.AlignTrailing);
+
+            verifyRemove(objects["2"]);
+
+            objects["4"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["1"], Qt.Horizontal);
+            verifyAdd(objects["1"], objects["4"], Qt.AlignTrailing);
+
+            verifyRemove(objects["1"]);
+
+            tiledView.setRootItem(null);
+            for (var i=0; i<objects.length; i++) {
+                objects[i].destroy();
+            }
+        }
+
+        function test_addsVertical() {
+            var objects = [];
+
+            objects["0"] = objectComponent.createObject(tiledView);
+            verifySetRootItem(objects["0"]);
+
+            objects["1"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["0"], Qt.Vertical);
+            verifyAdd(objects["0"], objects["1"], Qt.AlignTrailing);
+
+            objects["2"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["1"], Qt.Vertical);
+            verifyAdd(objects["1"], objects["2"], Qt.AlignTrailing);
+
+            objects["3"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["2"], Qt.Vertical);
+            verifyAdd(objects["2"], objects["3"], Qt.AlignLeading);
+
+            objects["4"] = objectComponent.createObject(tiledView);
+            verifySetOrientation(objects["3"], Qt.Vertical);
+            verifyAdd(objects["3"], objects["4"], Qt.AlignTrailing);
+
+            tiledView.setRootItem(null);
+            for (var i=0; i<objects.length; i++) {
+                objects[i].destroy();
+            }
+        }
+
+        function verifyResize(leftObject, rightObject, orientation, dragDistance) {
+            var horizontalMove = (orientation == Qt.Horizontal ? dragDistance : 0);
+            var verticalMove = (orientation == Qt.Vertical ? dragDistance : 0);
+            var expectedLeft = {"x": leftObject.x,
+                                "y": leftObject.y,
+                                "width": leftObject.width + horizontalMove,
+                                "height": leftObject.height + verticalMove};
+            var expectedRight = {"x": rightObject.x + horizontalMove,
+                                 "y": rightObject.y + verticalMove,
+                                 "width": rightObject.width - horizontalMove,
+                                 "height": rightObject.height - verticalMove};
+
+            if (orientation == Qt.Horizontal) {
+                mouseDrag(tiledView, rightObject.x, rightObject.y/2, dragDistance, 0);
+            } else if (orientation == Qt.Vertical) {
+                mouseDrag(tiledView, rightObject.x/2, rightObject.y, 0, dragDistance);
+            }
+
+            compare(leftObject.x, expectedLeft.x);
+            compare(leftObject.y, expectedLeft.y);
+            compare(leftObject.width, expectedLeft.width);
+            compare(leftObject.height, expectedLeft.height);
+            compare(rightObject.x, expectedRight.x);
+            compare(rightObject.y, expectedRight.y);
+            compare(rightObject.width, expectedRight.width);
+            compare(rightObject.height, expectedRight.height);
+        }
+
+        function test_resizeSplit_data() {
+            return [
+                        {orientation: Qt.Horizontal, distance: 100},
+                        {orientation: Qt.Vertical, distance: 100},
+            ];
+        }
+
+        function test_resizeSplit(data) {
+            var leftObject = objectComponent.createObject(tiledView);
+            verifySetRootItem(leftObject);
+            verifySetOrientation(leftObject, data.orientation);
+
+            var rightObject = objectComponent.createObject(tiledView);
+            verifyAdd(leftObject, rightObject, Qt.AlignTrailing);
+
+            verifyResize(leftObject, rightObject, data.orientation, data.distance);
+
+            tiledView.setRootItem(null);
+            leftObject.destroy();
+            rightObject.destroy();
+        }
+    }
+}