Unity 8

Merge lp:~aacid/unity8/desktopRotatedCamera into lp:unity8

desktopRotatedCamera
Merge into trunk

Proposed by Albert Astals Cid on 2016-02-25

Status:

Superseded

Proposed branch:

lp:~aacid/unity8/desktopRotatedCamera

Merge into:

lp:unity8

Diff against target:

2267 lines (+1060/-168)

18 files modified

data/com.canonical.Unity8.gschema.xml (+11/-0)
qml/Components/PhysicalKeysMapper.qml (+24/-0)
qml/Launcher/Launcher.qml (+141/-9)
qml/Launcher/LauncherDelegate.qml (+54/-20)
qml/Launcher/LauncherPanel.qml (+122/-51)
qml/Launcher/graphics/launcher-app-focus-ring.svg (+12/-0)
qml/Shell.qml (+51/-1)
qml/Stages/AbstractStage.qml (+2/-0)
qml/Stages/DecoratedWindow.qml (+27/-10)
qml/Stages/DesktopStage.qml (+49/-18)
qml/Stages/WindowResizeArea.qml (+7/-4)
tests/mocks/GSettings.1.0/fake_gsettings.cpp (+64/-0)
tests/mocks/GSettings.1.0/fake_gsettings.h (+18/-0)
tests/mocks/Unity/Application/ApplicationManager.cpp (+12/-0)
tests/mocks/Unity/Launcher/MockLauncherModel.cpp (+5/-0)
tests/qmltests/Launcher/tst_Launcher.qml (+244/-18)
tests/qmltests/tst_OrientedShell.qml (+13/-1)
tests/qmltests/tst_Shell.qml (+204/-36)

To merge this branch:

bzr merge lp:~aacid/unity8/desktopRotatedCamera

High

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
Lukáš Tinkl (community)		2016-02-25	Approve on 2016-03-08
PS Jenkins bot	continuous-integration		Needs Fixing on 2016-02-26
Unity8 CI Bot	continuous-integration		Needs Fixing on 2016-02-26
Review via email: mp+287137@code.launchpad.net

This proposal has been superseded by a proposal from 2016-03-10.

Commit Message

Desktop stage: Support rotatesWindowContents

Description of the Change

* Are there any related MPs required for this MP to build/function as expected?
No

* Did you perform an exploratory manual test run of your code change and any related functionality?
Yes

* Did you make sure that your branch does not contain spurious tags?
Yes

* If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
N/A

* If you changed the UI, has there been a design review?
N/A

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-02-25:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/481/rebuild

review: Approve (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2016-02-25:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/7411/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-02-26:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/499/rebuild

review: Needs Fixing (continuous-integration)

Lukáš Tinkl (lukas-kde) wrote on 2016-02-26:

Left some inline comments, also seems you want to rotate just the ApplicationWindow inside the delegate, why not do it directly there instead of doing the calculations to take the decoration into account?

Lukáš Tinkl (lukas-kde) wrote on 2016-02-26:

Also, shouldn't there be some transition/animation when the window rotates?

PS Jenkins bot (ps-jenkins) wrote on 2016-02-26:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/7429/rebuild

review: Needs Fixing (continuous-integration)

Albert Astals Cid (aacid) wrote on 2016-02-26:

> Left some inline comments, also seems you want to rotate just the
> ApplicationWindow inside the delegate, why not do it directly there instead of
> doing the calculations to take the decoration into account?

Yes, only the ApplicationWindow needs rotating and that's what i'm rotating only, no? I'm not sure what you mean with "there" means as instead of what i'm doing now.

Albert Astals Cid (aacid) wrote on 2016-02-26:

> Also, shouldn't there be some transition/animation when the window rotates?

The window doesn't really rotate, you move the phone and the window stays "the same" visually

Lukáš Tinkl (lukas-kde) wrote on 2016-02-26:

> > Left some inline comments, also seems you want to rotate just the
> > ApplicationWindow inside the delegate, why not do it directly there instead
> of
> > doing the calculations to take the decoration into account?
>
> Yes, only the ApplicationWindow needs rotating and that's what i'm rotating
> only, no? I'm not sure what you mean with "there" means as instead of what i'm
> doing now.

Yup sorry, that's what I meant, blaming launchpad diff for not being to show/expand the context...

Albert Astals Cid (aacid) wrote on 2016-02-26:

> Why not just use "rotation: rotationAngle" instead of constructing the Rotation Transform? The "transformOrigin" is by default Item.Center

Because it doesn't work, see current code http://i.imgur.com/SeDA0n4.png vs using rotation as you say http://i.imgur.com/ptyxvQL.png

You need the correct origin otherwise the rotation sends the item away from the rest of the item

Albert Astals Cid (aacid) wrote on 2016-02-26:

> What about other states like "maximized", shouldn't we care about them as well?

They do work already, see tryOrientedShell, mako, windowed, start the second camera app and maximize it, then go to invertedlandscape and see how it works fine

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-02-26:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/501/rebuild

review: Needs Fixing (continuous-integration)

Daniel d'Andrada (dandrader) wrote on 2016-02-26:

Maybe we would make camera-app not be fullscreen when in desktop mode (have code somewhere calling cameraApplication->setFullcreen(false)) instead of creating another app.

Daniel d'Andrada (dandrader) wrote on 2016-02-26:

Good work, by the way. Completely forgot about implementing RotatesWindowContents in DesktopStage.

Another thing:
"""
{tag: "mako_windowed", deviceName: "mako", orientationAngleAfterRotation: 90, windowed: true},
"""

Wouldn't a "manta_windowed" make more sense? (larger display area)

Daniel d'Andrada (dandrader) wrote on 2016-02-26:

> Maybe we would make camera-app not be fullscreen when in desktop mode (have
> code somewhere calling cameraApplication->setFullcreen(false)) instead of
> creating another app.

By the way, that would mimic the magic that will (or already does, don't recall trying) happen on the device.

Albert Astals Cid (aacid) wrote on 2016-02-26:

> Wouldn't a "manta_windowed" make more sense? (larger display area)

Does it matter? I guess the point is that it works on one it "should" work on all, maybe i can just add all three?

Albert Astals Cid (aacid) wrote on 2016-02-26:

> Maybe we would make camera-app not be fullscreen when in desktop mode (have code somewhere
> calling cameraApplication->setFullcreen(false)) instead of creating another app.

This has advantage that we kind of test the "same" camera app that we [will] have on the real world, the disadvantage is that we lose the hability to try/test pure fullscreen apps on the destkop stage (which i guess at some point makes sense too).

That's why i decided to go for the duplication case, but can make it the other way if you prefer.

Daniel d'Andrada (dandrader) wrote on 2016-02-26:

On 26/02/2016 10:36, Albert Astals Cid wrote:
>> Wouldn't a "manta_windowed" make more sense? (larger display area)
> Does it matter? I guess the point is that it works on one it "should" work on all, maybe i can just add all three?

just sugar on top. makes more sense when you look at it or try it out
manually.

Daniel d'Andrada (dandrader) wrote on 2016-02-26:

On 26/02/2016 10:43, Albert Astals Cid wrote:
> This has advantage that we kind of test the "same" camera app that we [will] have on the real world, the disadvantage is that we lose the hability to try/test pure fullscreen apps on the destkop stage (which i guess at some point makes sense too).

We already have other fullscreen apps there: gallery-app, webbrowser-app

Albert Astals Cid (aacid) wrote on 2016-02-26:

> We already have other fullscreen apps there: gallery-app, webbrowser-app

Sure, but they do not have rotatesWindowContents set

PS Jenkins bot (ps-jenkins) wrote on 2016-02-26:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/7430/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-02-26:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-unity8-1-ci/504/rebuild

review: Needs Fixing (continuous-integration)

PS Jenkins bot (ps-jenkins) wrote on 2016-02-26:

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity8-ci/7432/rebuild

review: Needs Fixing (continuous-integration)

lp:~aacid/unity8/desktopRotatedCamera updated on 2016-02-29

2091. By Lukáš Tinkl on 2016-02-29: fix for fullscreen apps in desktop mode
2092. By Lukáš Tinkl on 2016-02-29: similar fix to height...

Lukáš Tinkl (lukas-kde) wrote on 2016-03-08:

Worked fine from my testing

* Did you perform an exploratory manual test run of the code change and any related functionality?

Yes

* Did CI run pass? If not, please explain why.

Yes, unrelated failures

* Did you make sure that the branch does not contain spurious tags?

Yes

review: Approve

lp:~aacid/unity8/desktopRotatedCamera updated on 2016-06-02

2093. By Albert Astals Cid on 2016-03-10: Desktop stage: Support rotatesWindowContents
2094. By Albert Astals Cid on 2016-03-10: Make it work on non fullscreen windows too
2095. By Albert Astals Cid on 2016-03-10: Add SurfaceManagerControls
2096. By Albert Astals Cid on 2016-03-10: These are readonly too (i think)
2097. By Albert Astals Cid on 2016-03-10: add the other two windowed variants too
2098. By Albert Astals Cid on 2016-03-10: also switch the min/maxwidth/height
2099. By Albert Astals Cid on 2016-03-11: Merge makeMakeTryOrientedShellWork
2100. By Albert Astals Cid on 2016-03-11: account for 180
2101. By Albert Astals Cid on 2016-03-14: Merge
2102. By Albert Astals Cid on 2016-03-24: Merge
2103. By Albert Astals Cid on 2016-04-26: Merge
2104. By Albert Astals Cid on 2016-04-27: Change to windowed/not windowed before starting the app
2105. By Albert Astals Cid on 2016-05-09: Merge
2106. By Albert Astals Cid on 2016-05-23: Merge
2107. By Albert Astals Cid on 2016-05-23: "compile"
2108. By Albert Astals Cid on 2016-05-23: fix startup of non rotatesWindowContents apps
2109. By Albert Astals Cid on 2016-05-24: Revert change infected from other branch
2110. By Albert Astals Cid on 2016-06-02: Merge

Unmerged revisions

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Albert Astals Cid

Mohammad Rakibul Hasan

Unity Team

 === modified file 'data/com.canonical.Unity8.gschema.xml'
 --- data/com.canonical.Unity8.gschema.xml	2015-11-24 17:44:18 +0000
 +++ data/com.canonical.Unity8.gschema.xml	2016-03-10 09:37:58 +0000
@@ -27,6 +27,17 @@
        <summary>Maximum push needed to overcome edge barrier</summary>
        <description>How much you have to push (in grid units) the mouse against an edge barrier when sensibility is 1.</description>
      </key>
++    <key type="b" name="autohide-launcher">
++      <default>true</default>
++      <summary>Autohide the launcher</summary>
++      <description>This will only be applied in windowed mode. In staged mode, the launcher will always hide.</description>
++    </key>
++    <key type="u" name="launcher-width">
++      <default>8</default>
++      <range min="6" max="12"/>
++      <summary>Width of the launcher in grid units.</summary>
++      <description>Changes the width of the launcher in all usage modes.</description>
++    </key>
    </schema>
    <schema path="/com/canonical/unity8/greeter/" id="com.canonical.Unity8.Greeter" gettext-domain="unity8">
 === modified file 'qml/Components/PhysicalKeysMapper.qml'
 --- qml/Components/PhysicalKeysMapper.qml	2016-01-13 18:43:34 +0000
 +++ qml/Components/PhysicalKeysMapper.qml	2016-03-10 09:37:58 +0000
@@ -42,12 +42,15 @@
      signal screenshotTriggered;
      readonly property bool altTabPressed: d.altTabPressed
++    readonly property bool superPressed: d.superPressed
++    readonly property bool superTabPressed: d.superTabPressed
      property int powerKeyLongPressTime: 2000
      // For testing. If running windowed (e.g. tryShell), Alt+Tab is taken by the
      // running desktop, set this to true to use Ctrl+Tab instead.
      property bool controlInsteadOfAlt: false
++    property bool controlInsteadOfSuper: false
      QtObject {
          id: d
@@ -59,6 +62,9 @@
          property bool altPressed: false
          property bool altTabPressed: false
++        property bool superPressed: false
++        property bool superTabPressed: false
++
          property var powerButtonPressStart: 0
          // We need to eat ALT presses until we know what they're for (Alt+Tab or going to the app?)
@@ -119,11 +125,23 @@
                  event.accepted = true;
                  d.altPressInjected = false;
+             }
++
++        // Adding MetaModifier here because that's what keyboards do. Pressing Super_L actually gives
++        // Super_L + MetaModifier. This helps to make sure we only invoke superPressed if no other
++        // Modifier is pressed too.
++        } else if (((event.key == Qt.Key_Super_L || event.key == Qt.Key_Super_R) && event.modifiers === Qt.MetaModifier)
++                    || (root.controlInsteadOfSuper && event.key == Qt.Key_Control)
++                    ) {
++            d.superPressed = true;
          } else if (event.key == Qt.Key_Tab) {
              if (d.altPressed && !d.altTabPressed) {
                  d.altTabPressed = true;
                  event.accepted = true;
+             }
++            if (d.superPressed && !d.superTabPressed) {
++                d.superTabPressed = true;
++                event.accepted = true;
++            }
+         }
+     }
@@ -154,6 +172,12 @@
              if (d.altTabPressed) {
                  event.accepted = true;
+             }
++        } else if (event.key == Qt.Key_Super_L || event.key == Qt.Key_Super_R || (root.controlInsteadOfSuper && event.key == Qt.Key_Control)) {
++            d.superPressed = false;
++            if (d.superTabPressed) {
++                d.superTabPressed = false;
++                event.accepted = true;
++            }
+         }
+     }
+ }
 === modified file 'qml/Launcher/Launcher.qml'
 --- qml/Launcher/Launcher.qml	2016-01-19 15:26:15 +0000
 +++ qml/Launcher/Launcher.qml	2016-03-10 09:37:58 +0000
@@ -19,21 +19,26 @@
  import Ubuntu.Components 1.3
  import Ubuntu.Gestures 0.1
  import Unity.Launcher 0.1
++import GlobalShortcut 1.0
--Item {
++FocusScope {
      id: root
      property bool autohideEnabled: false
++    property bool lockedVisible: false
      property bool available: true // can be used to disable all interactions
      property alias inverted: panel.inverted
      property bool shadeBackground: true // can be used to disable background shade when launcher is visible
--    property int panelWidth: units.gu(8)
++    property int panelWidth: units.gu(10)
      property int dragAreaWidth: units.gu(1)
      property int minimizeDistance: units.gu(26)
      property real progress: dragArea.dragging && dragArea.touchX > panelWidth ?
                                  (width * (dragArea.touchX-panelWidth) / (width - panelWidth)) : 0
++    property bool superPressed: false
++    property bool superTabPressed: false
++
      readonly property bool dragging: dragArea.dragging
      readonly property real dragDistance: dragArea.dragging ? dragArea.touchX : 0
      readonly property real visibleWidth: panel.width + panel.x
@@ -57,12 +62,55 @@
+         }
+     }
++    onSuperPressedChanged: {
++        if (superPressed) {
++            superPressTimer.start();
++            superLongPressTimer.start();
++        } else {
++            superPressTimer.stop();
++            superLongPressTimer.stop();
++            launcher.switchToNextState("");
++            panel.shortcutHintsShown = false;
++        }
++    }
++
++    onSuperTabPressedChanged: {
++        if (superTabPressed) {
++            switchToNextState("visible")
++            panel.highlightIndex = -1;
++            root.focus = true;
++            superPressTimer.stop();
++            superLongPressTimer.stop();
++        } else {
++            if (panel.highlightIndex == -1) {
++                showDashHome();
++            } else if (panel.highlightIndex >= 0){
++                launcherApplicationSelected(LauncherModel.get(panel.highlightIndex).appId);
++            }
++            panel.highlightIndex = -2;
++            switchToNextState("");
++            root.focus = false;
++        }
++    }
++
++    onLockedVisibleChanged: {
++        if (lockedVisible && state == "") {
++            panel.dismissTimer.stop();
++            fadeOutAnimation.stop();
++            switchToNextState("visible")
++        } else if (!lockedVisible && state == "visible") {
++            hide();
++        }
++    }
++
      function hide() {
          switchToNextState("")
+     }
      function fadeOut() {
--        fadeOutAnimation.start();
++        if (!root.lockedVisible) {
++            fadeOutAnimation.start();
++        }
+     }
      function switchToNextState(state) {
@@ -90,6 +138,76 @@
+         }
+     }
++    function openForKeyboardNavigation() {
++        panel.highlightIndex = -1; // The BFB
++        root.focus = true;
++        switchToNextState("visible")
++    }
++
++    Keys.onPressed: {
++        switch (event.key) {
++        case Qt.Key_Backtab:
++            panel.highlightPrevious();
++            event.accepted = true;
++            break;
++        case Qt.Key_Up:
++            if (root.inverted) {
++                panel.highlightNext()
++            } else {
++                panel.highlightPrevious();
++            }
++            event.accepted = true;
++            break;
++        case Qt.Key_Tab:
++            panel.highlightNext();
++            event.accepted = true;
++            break;
++        case Qt.Key_Down:
++            if (root.inverted) {
++                panel.highlightPrevious();
++            } else {
++                panel.highlightNext();
++            }
++            event.accepted = true;
++            break;
++        case Qt.Key_Right:
++            panel.openQuicklist(panel.highlightIndex)
++            event.accepted = true;
++            break;
++        case Qt.Key_Escape:
++            panel.highlightIndex = -2
++            // Falling through intentionally
++        case Qt.Key_Enter:
++        case Qt.Key_Return:
++        case Qt.Key_Space:
++            if (panel.highlightIndex == -1) {
++                showDashHome();
++            } else if (panel.highlightIndex >= 0) {
++                launcherApplicationSelected(LauncherModel.get(panel.highlightIndex).appId);
++            }
++            root.hide();
++            event.accepted = true;
++            root.focus = false;
++        }
++    }
++
++    Timer {
++        id: superPressTimer
++        interval: 200
++        onTriggered: {
++            switchToNextState("visible")
++        }
++    }
++
++    Timer {
++        id: superLongPressTimer
++        interval: 1000
++        onTriggered: {
++            switchToNextState("visible")
++            panel.shortcutHintsShown = true;
++        }
++    }
++
      Timer {
          id: teaseTimer
          interval: mode == "teasing" ? 200 : 300
@@ -106,6 +224,13 @@
          interval: 1
          property string nextState: ""
          onTriggered: {
++            if (root.lockedVisible && nextState == "") {
++                // Due to binding updates when switching between modes
++                // it could happen that our request to show will be overwritten
++                // with a hide request. Rewrite it when we know hiding is not allowed.
++                nextState = "visible"
++            }
++
              // switching to an intermediate state here to make sure all the
              // values are restored, even if we were already in the target state
              root.state = "tmp"
@@ -151,7 +276,7 @@
      MouseArea {
          id: launcherDragArea
--        enabled: root.available && (root.state == "visible" || root.state == "visibleTemporary")
++        enabled: root.available && (root.state == "visible" || root.state == "visibleTemporary") && !root.lockedVisible
          anchors.fill: panel
          anchors.rightMargin: -units.gu(2)
          drag {
@@ -172,9 +297,10 @@
      InverseMouseArea {
          id: closeMouseArea
          anchors.fill: panel
--        enabled: root.shadeBackground && root.state == "visible"
++        enabled: root.shadeBackground && root.state == "visible" && (!root.lockedVisible || panel.highlightIndex >= -1)
          visible: enabled
          onPressed: {
++            panel.highlightIndex = -2
              root.hide();
+         }
+     }
@@ -183,7 +309,7 @@
          id: backgroundShade
          anchors.fill: parent
          color: "black"
--        opacity: root.shadeBackground && root.state == "visible" ? 0.6 : 0
++        opacity: root.shadeBackground && root.state == "visible" && !root.lockedVisible ? 0.6 : 0
          Behavior on opacity { NumberAnimation { duration: UbuntuAnimation.BriskDuration } }
+     }
@@ -227,7 +353,7 @@
          Connections {
              target: panel.dismissTimer
              onTriggered: {
--                if (root.autohideEnabled) {
++                if (root.autohideEnabled && !root.lockedVisible) {
                      if (!panel.preventHiding) {
                          root.state = ""
                      } else {
@@ -240,11 +366,11 @@
          property bool animate: true
          onApplicationSelected: {
--            root.state = ""
++            root.hide();
              launcherApplicationSelected(appId)
+         }
          onShowDashHome: {
--            root.state = ""
++            root.hide();
              root.showDashHome();
+         }
@@ -254,6 +380,12 @@
+             }
+         }
++        onKbdNavigationCancelled: {
++            panel.highlightIndex = -2;
++            root.hide();
++            root.focus = false;
++        }
++
          Behavior on x {
              enabled: !dragArea.dragging && !launcherDragArea.drag.active && panel.animate;
              NumberAnimation {
 === modified file 'qml/Launcher/LauncherDelegate.qml'
 --- qml/Launcher/LauncherDelegate.qml	2015-11-19 16:55:31 +0000
 +++ qml/Launcher/LauncherDelegate.qml	2016-03-10 09:37:58 +0000
@@ -20,6 +20,7 @@
  Item {
      id: root
++    property int itemIndex: 0
      property string iconName
      property int count: 0
      property bool countVisible: false
@@ -29,10 +30,12 @@
      property real maxAngle: 0
      property bool inverted: false
      property bool alerting: false
--    readonly property alias wiggling: wiggleAnim.running
++    property bool highlighted: false
++    property bool shortcutHintShown: false
      readonly property int effectiveHeight: Math.cos(angle * Math.PI / 180) * itemHeight
      readonly property real foldedHeight: Math.cos(maxAngle * Math.PI / 180) * itemHeight
++    readonly property alias wiggling: wiggleAnim.running
      property int itemWidth
      property int itemHeight
@@ -121,14 +124,25 @@
      Item {
          id: iconItem
--        width: parent.itemWidth + units.gu(1)
++        width: root.width
          height: parent.itemHeight + units.gu(1)
          anchors.centerIn: parent
++        Image {
++            objectName: "focusRing"
++            anchors.centerIn: iconShape
++            height: width * 15 / 16
++            width: iconShape.width + units.gu(1)
++            source: "graphics/launcher-app-focus-ring.svg"
++            sourceSize.width: width
++            sourceSize.height: height
++            visible: root.highlighted
++        }
++
          ProportionalShape {
              id: iconShape
              anchors.centerIn: parent
--            width: parent.width - units.gu(2)
++            width: root.itemWidth
              aspect: UbuntuShape.DropShadow
              source: Image {
                  id: iconImage
@@ -144,7 +158,8 @@
              anchors {
                  right: parent.right
                  bottom: parent.bottom
--                margins: units.dp(3)
++                rightMargin: (iconItem.width - root.itemWidth) / 2 - units.dp(2)
++                margins: units.dp(5)
+             }
              width: Math.min(root.itemWidth, Math.max(units.gu(2), countLabel.implicitWidth + units.gu(1)))
              height: units.gu(2)
@@ -172,16 +187,11 @@
              id: progressOverlay
              objectName: "progressOverlay"
--            anchors {
--                left: iconItem.left
--                right: iconItem.right
--                verticalCenter: parent.verticalCenter
--                leftMargin: units.gu(1.5)
--                rightMargin: units.gu(1.5)
--            }
++            anchors.centerIn: parent
++            width: root.itemWidth * .8
              height: units.gu(1)
              visible: root.progress > -1
--            color: UbuntuColors.darkGrey
++            backgroundColor: UbuntuColors.darkGrey
              borderSource: "none"
              Item {
@@ -199,32 +209,56 @@
                          top: parent.top
                          bottom: parent.bottom
+                     }
--                    color: "white"
++                    backgroundColor: "white"
                      borderSource: "none"
                      width: progressOverlay.width
+                 }
+             }
+         }
--        Image {
--            objectName: "runningHighlight"
++        Column {
              anchors {
                  left: parent.left
                  verticalCenter: parent.verticalCenter
+             }
--            visible: root.itemRunning
--            rotation: 180
--            source: "graphics/focused_app_arrow.png"
++            spacing: units.gu(.5)
++            Repeater {
++                model: 1 // TODO: This should be "Math.min(3, app.surfaceCount)" once we have multiple surfaces
++                Rectangle {
++                    objectName: "runningHighlight" + index
++                    width: units.gu(0.25)
++                    height: units.gu(.5)
++                    color: "white"
++                    visible: root.itemRunning
++                }
++            }
+         }
--        Image {
++        Rectangle {
              objectName: "focusedHighlight"
              anchors {
                  right: parent.right
                  verticalCenter: parent.verticalCenter
+             }
++            width: units.gu(0.25)
++            height: units.gu(.5)
++            color: "white"
              visible: root.itemFocused
--            source: "graphics/focused_app_arrow.png"
++        }
++
++        Rectangle {
++            objectName: "shortcutHint"
++            anchors.centerIn: parent
++            width: units.gu(3)
++            height: width
++            color: "#E0292929"
++            visible: root.shortcutHintShown
++            Label {
++                anchors.centerIn: parent
++                text: (itemIndex + 1) % 10
++                color: "white"
++                font.weight: Font.DemiBold
++            }
+         }
+     }
 === modified file 'qml/Launcher/LauncherPanel.qml'
 --- qml/Launcher/LauncherPanel.qml	2016-01-11 17:38:19 +0000
 +++ qml/Launcher/LauncherPanel.qml	2016-03-10 09:37:58 +0000
@@ -19,12 +19,13 @@
  import Ubuntu.Components.ListItems 1.3 as ListItems
  import Unity.Launcher 0.1
  import Ubuntu.Components.Popups 1.3
++import GlobalShortcut 1.0
  import "../Components/ListItems"
  import "../Components/"
  Rectangle {
      id: root
--    color: "#B2000000"
++    color: "#E0292929"
      rotation: inverted ? 180 : 0
@@ -33,11 +34,13 @@
      property bool dragging: false
      property bool moving: launcherListView.moving || launcherListView.flicking
      property bool preventHiding: moving || dndArea.draggedIndex >= 0 || quickList.state === "open" || dndArea.pressed
--                              || mouseEventEater.containsMouse || dashItem.hovered
--    property int highlightIndex: -1
++                                 || mouseEventEater.containsMouse || dashItem.hovered
++    property int highlightIndex: -2
++    property bool shortcutHintsShown: false
      signal applicationSelected(string appId)
      signal showDashHome()
++    signal kbdNavigationCancelled()
      onXChanged: {
          if (quickList.state == "open") {
@@ -45,6 +48,26 @@
+         }
+     }
++    function highlightNext() {
++        highlightIndex++;
++        if (highlightIndex >= launcherListView.count) {
++            highlightIndex = -1;
++        }
++        launcherListView.moveToIndex(Math.max(highlightIndex, 0));
++    }
++    function highlightPrevious() {
++        highlightIndex--;
++        if (highlightIndex <= -2) {
++            highlightIndex = launcherListView.count - 1;
++        }
++        launcherListView.moveToIndex(Math.max(highlightIndex, 0));
++    }
++    function openQuicklist(index) {
++        quickList.open(index);
++        quickList.selectedIndex = 0;
++        quickList.focus = true;
++    }
++
      MouseArea {
          id: mouseEventEater
          anchors.fill: parent
@@ -57,24 +80,16 @@
              fill: parent
+         }
--        Item {
++        Rectangle {
              objectName: "buttonShowDashHome"
              width: parent.width
--            height: units.gu(7)
--            clip: true
--
--            UbuntuShape {
--                anchors {
--                    fill: parent
--                    topMargin: -units.gu(2)
--                }
--                aspect: UbuntuShape.Flat
--                backgroundColor: UbuntuColors.orange
--            }
++            height: width * .9
++            color: UbuntuColors.orange
++            readonly property bool highlighted: root.highlightIndex == -1;
              Image {
                  objectName: "dashItem"
--                width: units.gu(5)
++                width: parent.width * .6
                  height: width
                  anchors.centerIn: parent
                  source: "graphics/home.png"
@@ -85,6 +100,14 @@
                  anchors.fill: parent
                  onClicked: root.showDashHome()
+             }
++            Rectangle {
++                objectName: "bfbFocusHighlight"
++                anchors.fill: parent
++                border.color: "white"
++                border.width: units.dp(1)
++                color: "transparent"
++                visible: parent.highlighted
++            }
+         }
          Item {
@@ -102,10 +125,8 @@
                      objectName: "launcherListView"
                      anchors {
                          fill: parent
--                        topMargin: -extensionSize + units.gu(0.5)
--                        bottomMargin: -extensionSize + units.gu(1)
--                        leftMargin: units.gu(0.5)
--                        rightMargin: units.gu(0.5)
++                        topMargin: -extensionSize + width * .15
++                        bottomMargin: -extensionSize + width * .15
+                     }
                      topMargin: extensionSize
                      bottomMargin: extensionSize
@@ -140,11 +161,11 @@
+                     }
                      // The height of the area where icons start getting folded
--                    property int foldingStartHeight: units.gu(6.5)
++                    property int foldingStartHeight: itemHeight
                      // The height of the area where the items reach the final folding angle
                      property int foldingStopHeight: foldingStartHeight - itemHeight - spacing
--                    property int itemWidth: units.gu(7)
--                    property int itemHeight: units.gu(6.5)
++                    property int itemWidth: width * .75
++                    property int itemHeight: itemWidth * 15 / 16 + units.gu(1)
                      property int clickFlickSpeed: units.gu(60)
                      property int draggedIndex: dndArea.draggedIndex
                      property real realContentY: contentY - originY + topMargin
@@ -172,12 +193,24 @@
                      UbuntuNumberAnimation {
                          id: moveAnimation
++                        objectName: "moveAnimation"
                          target: launcherListView
                          property: "contentY"
                          function moveTo(contentY) {
                              from = launcherListView.contentY;
                              to = contentY;
--                            start();
++                            restart();
++                        }
++                    }
++                    function moveToIndex(index) {
++                        var totalItemHeight = launcherListView.itemHeight + launcherListView.spacing
++                        var itemPosition = index * totalItemHeight;
++                        var height = launcherListView.height - launcherListView.topMargin - launcherListView.bottomMargin
++                        var distanceToEnd = index == 0 || index == launcherListView.count - 1 ? 0 : totalItemHeight
++                        if (itemPosition + totalItemHeight + distanceToEnd > launcherListView.contentY + launcherListView.originY + launcherListView.topMargin + height) {
++                            moveAnimation.moveTo(itemPosition + launcherListView.itemHeight - launcherListView.topMargin - height + distanceToEnd - launcherListView.originY);
++                        } else if (itemPosition - distanceToEnd < launcherListView.contentY - launcherListView.originY + launcherListView.topMargin) {
++                            moveAnimation.moveTo(itemPosition - distanceToEnd - launcherListView.topMargin + launcherListView.originY);
+                         }
+                     }
@@ -192,9 +225,10 @@
                          // the right app when running autopilot tests for
                          // multiple apps.
                          readonly property string appId: model.appId
++                        itemIndex: index
                          itemHeight: launcherListView.itemHeight
                          itemWidth: launcherListView.itemWidth
--                        width: itemWidth
++                        width: parent.width
                          height: itemHeight
                          iconName: model.icon
                          count: model.count
@@ -204,6 +238,8 @@
                          itemFocused: model.focused
                          inverted: root.inverted
                          alerting: model.alerting
++                        highlighted: root.highlightIndex == index
++                        shortcutHintShown: root.shortcutHintsShown && index <= 9
                          z: -Math.abs(offset)
                          maxAngle: 55
                          property bool dragging: false
@@ -241,14 +277,7 @@
                          onAlertingChanged: {
                              if(alerting) {
                                  if (!dragging && (launcherListView.peekingIndex === -1 || launcher.visibleWidth > 0)) {
--                                      var itemPosition = index * launcherListView.itemHeight;
--                                      var height = launcherListView.height - launcherListView.topMargin - launcherListView.bottomMargin
--                                      var distanceToEnd = index == 0 || index == launcherListView.count - 1 ? 0 : launcherListView.itemHeight
--                                      if (itemPosition + launcherListView.itemHeight + distanceToEnd > launcherListView.contentY + launcherListView.topMargin + height) {
--                                          moveAnimation.moveTo(itemPosition + launcherListView.itemHeight - launcherListView.topMargin - height + distanceToEnd);
--                                      } else if (itemPosition - distanceToEnd < launcherListView.contentY + launcherListView.topMargin) {
--                                          moveAnimation.moveTo(itemPosition - distanceToEnd - launcherListView.topMargin);
--                                      }
++                                    launcherListView.moveToIndex(index)
                                      if (!dragging && launcher.state !== "visible") {
                                          peekingAnimation.start()
+                                     }
@@ -402,10 +431,7 @@
                              if (mouse.button & Qt.RightButton) { // context menu
                                  // Opening QuickList
--                                quickList.item = clickedItem;
--                                quickList.model = launcherListView.model.get(index).quickList;
--                                quickList.appId = launcherListView.model.get(index).appId;
--                                quickList.state = "open";
++                                quickList.open(index);
                                  return;
+                             }
@@ -413,10 +439,8 @@
                              // First/last item do the scrolling at more than 12 degrees
                              if (index == 0 || index == launcherListView.count - 1) {
--                                if (clickedItem.angle > 12) {
--                                    launcherListView.flick(0, -launcherListView.clickFlickSpeed);
--                                } else if (clickedItem.angle < -12) {
--                                    launcherListView.flick(0, launcherListView.clickFlickSpeed);
++                                if (clickedItem.angle > 12 || clickedItem.angle < -12) {
++                                    launcherListView.moveToIndex(index);
                                  } else {
                                      root.applicationSelected(LauncherModel.get(index).appId);
+                                 }
@@ -424,10 +448,8 @@
+                             }
                              // the rest launches apps up to an angle of 30 degrees
--                            if (clickedItem.angle > 30) {
--                                launcherListView.flick(0, -launcherListView.clickFlickSpeed);
--                            } else if (clickedItem.angle < -30) {
--                                launcherListView.flick(0, launcherListView.clickFlickSpeed);
++                            if (clickedItem.angle > 30 || clickedItem.angle < -30) {
++                                launcherListView.moveToIndex(index);
                              } else {
                                  root.applicationSelected(LauncherModel.get(index).appId);
+                             }
@@ -481,11 +503,7 @@
                              draggedIndex = Math.floor((mouse.y + launcherListView.realContentY) / launcherListView.realItemHeight);
--                            // Opening QuickList
--                            quickList.item = selectedItem;
--                            quickList.model = launcherListView.model.get(draggedIndex).quickList;
--                            quickList.appId = launcherListView.model.get(draggedIndex).appId;
--                            quickList.state = "open";
++                            quickList.open(draggedIndex)
                              launcherListView.interactive = false
@@ -644,7 +662,9 @@
          enabled: quickList.state == "open" || pressed
          onClicked: {
--            quickList.state = ""
++            quickList.state = "";
++            quickList.focus = false;
++            root.kbdNavigationCancelled();
+         }
          // Forward for dragging to work when quickList is open
@@ -693,12 +713,60 @@
          property var model
          property string appId
          property var item
++        property int selectedIndex: -1
++
++        Keys.onPressed: {
++            switch (event.key) {
++            case Qt.Key_Down:
++                selectedIndex++;
++                if (selectedIndex >= popoverRepeater.count) {
++                    selectedIndex = 0;
++                }
++                event.accepted = true;
++                break;
++            case Qt.Key_Up:
++                selectedIndex--;
++                if (selectedIndex < 0) {
++                    selectedIndex = popoverRepeater.count - 1;
++                }
++                event.accepted = true;
++                break;
++            case Qt.Key_Left:
++            case Qt.Key_Escape:
++                quickList.selectedIndex = -1;
++                quickList.focus = false;
++                quickList.state = ""
++                event.accepted = true;
++                break;
++            case Qt.Key_Enter:
++            case Qt.Key_Return:
++            case Qt.Key_Space:
++                if (quickList.selectedIndex >= 0) {
++                    LauncherModel.quickListActionInvoked(quickList.appId, quickList.selectedIndex)
++                }
++                quickList.selectedIndex = -1;
++                quickList.focus = false;
++                quickList.state = ""
++                root.kbdNavigationCancelled();
++                event.accepted = true;
++                break;
++            }
++        }
          // internal
          property int itemCenter: item ? root.mapFromItem(quickList.item).y + (item.height / 2) + quickList.item.offset : units.gu(1)
          property int offset: itemCenter + (height/2) + units.gu(1) > parent.height ? -itemCenter - (height/2) - units.gu(1) + parent.height :
                               itemCenter - (height/2) < units.gu(1) ? (height/2) - itemCenter + units.gu(1) : 0
++        function open(index) {
++            var itemPosition = index * launcherListView.itemHeight;
++            var height = launcherListView.height - launcherListView.topMargin - launcherListView.bottomMargin
++            item = launcherListView.itemAt(launcherListView.width / 2, itemPosition + launcherListView.itemHeight / 2);
++            quickList.model = launcherListView.model.get(index).quickList;
++            quickList.appId = launcherListView.model.get(index).appId;
++            quickList.state = "open";
++        }
++
          Column {
              id: quickListColumn
              width: parent.width
@@ -712,6 +780,7 @@
                      objectName: "quickListEntry" + index
                      text: (model.clickable ? "" : "<b>") + model.label + (model.clickable ? "" : "</b>")
                      highlightWhenPressed: model.clickable
++                    selected: index === quickList.selectedIndex
                      // FIXME: This is a workaround for the theme not being context sensitive. I.e. the
                      // ListItems don't know that they are sitting in a themed Popover where the color
@@ -727,6 +796,8 @@
                          // Unsetting model to prevent showing changing entries during fading out
                          // that may happen because of triggering an action.
                          LauncherModel.quickListActionInvoked(quickList.appId, index);
++                        quickList.focus = false;
++                        root.kbdNavigationCancelled();
                          quickList.model = undefined;
+                     }
+                 }
 === added file 'qml/Launcher/graphics/launcher-app-focus-ring.svg'
 --- qml/Launcher/graphics/launcher-app-focus-ring.svg	1970-01-01 00:00:00 +0000
 +++ qml/Launcher/graphics/launcher-app-focus-ring.svg	2016-03-10 09:37:58 +0000
@@ -0,0 +1,12 @@
++<?xml version="1.0" encoding="UTF-8" standalone="no"?>
++<svg width="172px" height="163px" viewBox="0 0 172 163" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:sketch="http://www.bohemiancoding.com/sketch/ns">
++    <!-- Generator: Sketch 3.4.4 (17249) - http://www.bohemiancoding.com/sketch -->
++    <title>Shape</title>
++    <desc>Created with Sketch.</desc>
++    <defs></defs>
++    <g id="•-Launcher" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd" sketch:type="MSPage">
++        <g id="Artboard-9" sketch:type="MSArtboardGroup" transform="translate(-163.000000, -1436.000000)" fill="#E95420">
++            <path d="M221.983432,1440 L221.983432,1440 C195.6127,1440 184.708233,1442.4723 177.107949,1450.10734 C169.476819,1457.77336 167,1468.79245 167,1495.3481 L167,1538.9019 C167,1565.45755 169.476819,1576.47664 177.107949,1584.14266 C184.708233,1591.7777 195.6127,1594.25 221.983432,1594.25 L276.016868,1594.25 C302.387595,1594.25 313.291998,1591.77771 320.892221,1584.14264 C328.523252,1576.47663 331,1565.45769 331,1538.9019 L331,1495.3481 C331,1468.79231 328.523252,1457.77337 320.892221,1450.10736 C313.291998,1442.47229 302.387595,1440 276.016868,1440 L221.983432,1440 Z M221.983432,1436 L276.016868,1436 C302.345315,1436 314.848953,1438.36655 323.727108,1447.2854 C332.633306,1456.23243 335,1468.85167 335,1495.3481 L335,1538.9019 C335,1565.39833 332.633306,1578.01757 323.727108,1586.9646 C314.848953,1595.88345 302.345315,1598.25 276.016868,1598.25 L221.983432,1598.25 C195.654985,1598.25 183.151291,1595.88345 174.273077,1586.96463 C165.366772,1578.0176 163,1565.39822 163,1538.9019 L163,1495.3481 C163,1468.85178 165.366772,1456.2324 174.273077,1447.28537 C183.151291,1438.36655 195.654985,1436 221.983432,1436 L221.983432,1436 Z" id="Shape" sketch:type="MSShapeGroup"></path>
++        </g>
++    </g>
++</svg>
 \ No newline at end of file
 === modified file 'qml/Shell.qml'
 --- qml/Shell.qml	2016-03-08 20:59:08 +0000
 +++ qml/Shell.qml	2016-03-10 09:37:58 +0000
@@ -25,6 +25,7 @@
  import Unity.Connectivity 0.1
  import Unity.Launcher 0.1
  import GlobalShortcut 1.0 // has to be before Utils, because of WindowKeysFilter
++import GSettings 1.0
  import Utils 0.1
  import Powerd 0.1
  import SessionBroadcast 0.1
@@ -187,6 +188,11 @@
+         }
+     }
++    GSettings {
++        id: settings
++        schema.id: "com.canonical.Unity8"
++    }
++
      Item {
          id: stages
          objectName: "stages"
@@ -343,6 +349,11 @@
                  property: "altTabPressed"
                  value: physicalKeysMapper.altTabPressed
+             }
++            Binding {
++                target: applicationsDisplayLoader.item
++                property: "leftMargin"
++                value: shell.usageScenario == "desktop" && !settings.autohideLauncher ? launcher.panelWidth: 0
++            }
+         }
          Tutorial {
@@ -373,7 +384,11 @@
      InputMethod {
          id: inputMethod
          objectName: "inputMethod"
--        anchors { fill: parent; topMargin: panel.panelHeight }
++        anchors {
++            fill: parent
++            topMargin: panel.panelHeight
++            leftMargin: launcher.lockedVisible ? launcher.panelWidth : 0
++        }
          z: notifications.useModal || panel.indicators.shown || wizard.active ? overlay.z + 1 : overlay.z - 1
+     }
@@ -557,6 +572,10 @@
                      && !greeter.hasLockedApp
              inverted: shell.usageScenario !== "desktop"
              shadeBackground: !tutorial.running
++            superPressed: physicalKeysMapper.superPressed
++            superTabPressed: physicalKeysMapper.superTabPressed
++            panelWidth: units.gu(settings.launcherWidth)
++            lockedVisible: shell.usageScenario == "desktop" && !settings.autohideLauncher && !panel.fullscreenMode
              onShowDashHome: showHome()
              onDash: showDash()
@@ -576,6 +595,37 @@
                      panel.indicators.hide()
+                 }
+             }
++            onFocusChanged: {
++                if (!focus) {
++                    applicationsDisplayLoader.focus = true;
++                }
++            }
++
++            GlobalShortcut {
++                shortcut: Qt.AltModifier | Qt.Key_F1
++                onTriggered: {
++                    launcher.openForKeyboardNavigation();
++                }
++            }
++            GlobalShortcut {
++                shortcut: Qt.MetaModifier | Qt.Key_0
++                onTriggered: {
++                    if (LauncherModel.get(9)) {
++                        activateApplication(LauncherModel.get(9).appId);
++                    }
++                }
++            }
++            Repeater {
++                model: 9
++                GlobalShortcut {
++                    shortcut: Qt.MetaModifier | (Qt.Key_1 + index)
++                    onTriggered: {
++                        if (LauncherModel.get(index)) {
++                            activateApplication(LauncherModel.get(index).appId);
++                        }
++                    }
++                }
++            }
+         }
          Wizard {
 === modified file 'qml/Stages/AbstractStage.qml'
 --- qml/Stages/AbstractStage.qml	2016-01-14 13:03:20 +0000
 +++ qml/Stages/AbstractStage.qml	2016-03-10 09:37:58 +0000
@@ -39,6 +39,8 @@
      property int shellOrientationAngle
      property bool spreadEnabled: true // If false, animations and right edge will be disabled
      property bool suspended
++     // A Stage should paint a wallpaper etc over its full size but not use the margins for window placement
++    property int leftMargin: 0
      // To be read from outside
      property var mainApp: null
 === modified file 'qml/Stages/DecoratedWindow.qml'
 --- qml/Stages/DecoratedWindow.qml	2015-11-30 18:25:47 +0000
 +++ qml/Stages/DecoratedWindow.qml	2016-03-10 09:37:58 +0000
@@ -23,8 +23,8 @@
  FocusScope {
      id: root
--    width: applicationWindow.width
--    height: (decorationShown ? decoration.height : 0) + applicationWindow.height
++    width: !counterRotate ? applicationWindow.width : applicationWindow.height
++    height: visibleDecorationHeight + (!counterRotate ? applicationWindow.height : applicationWindow.width)
      property alias window: applicationWindow
      property alias application: applicationWindow.application
@@ -36,15 +36,18 @@
      property bool highlightShown: false
      property real shadowOpacity: 1
--    property alias requestedWidth: applicationWindow.requestedWidth
++    property real requestedWidth
      property real requestedHeight
++    property alias surfaceOrientationAngle: applicationWindow.surfaceOrientationAngle
++    readonly property real visibleDecorationHeight: root.decorationShown ? decoration.height : 0
++    readonly property bool counterRotate: surfaceOrientationAngle != 0 && surfaceOrientationAngle != 180
--    property alias minimumWidth: applicationWindow.minimumWidth
--    readonly property int minimumHeight: (root.decorationShown ? decoration.height : 0) + applicationWindow.minimumHeight
--    property alias maximumWidth: applicationWindow.maximumWidth
--    readonly property int maximumHeight: (root.decorationShown ? decoration.height : 0) + applicationWindow.maximumHeight
--    property alias widthIncrement: applicationWindow.widthIncrement
--    property alias heightIncrement: applicationWindow.heightIncrement
++    readonly property int minimumWidth: !counterRotate ? applicationWindow.minimumWidth : applicationWindow.minimumHeight
++    readonly property int minimumHeight: visibleDecorationHeight + (!counterRotate ? applicationWindow.minimumHeight : applicationWindow.minimumWidth)
++    readonly property int maximumWidth: !counterRotate ? applicationWindow.maximumWidth : applicationWindow.maximumHeight
++    readonly property int maximumHeight: visibleDecorationHeight + (!counterRotate ? applicationWindow.maximumHeight : applicationWindow.maximumWidth)
++    readonly property int widthIncrement: !counterRotate ? applicationWindow.widthIncrement : applicationWindow.heightIncrement
++    readonly property int heightIncrement: !counterRotate ? applicationWindow.heightIncrement : applicationWindow.widthIncrement
      signal close()
      signal maximize()
@@ -98,8 +101,22 @@
          anchors.top: parent.top
          anchors.topMargin: decoration.height
          anchors.left: parent.left
--        requestedHeight: root.requestedHeight - (root.decorationShown ? decoration.height : 0)
++        readonly property real requestedHeightMinusDecoration: root.requestedHeight - root.visibleDecorationHeight
++        requestedHeight: !counterRotate ? requestedHeightMinusDecoration : root.requestedWidth
++        requestedWidth: !counterRotate ? root.requestedWidth : requestedHeightMinusDecoration
          interactive: true
          focus: true
++
++        transform: Rotation {
++                readonly property int rotationAngle: applicationWindow.application &&
++                                                     applicationWindow.application.rotatesWindowContents
++                                                     ? ((360 - applicationWindow.surfaceOrientationAngle) % 360) : 0
++                readonly property real rotationOrigin: rotationAngle == 90 ? applicationWindow.height / 2
++                                                                           : rotationAngle == 270 ? applicationWindow.width / 2
++                                                                                                  : 0
++                origin.x: rotationOrigin
++                origin.y: rotationOrigin
++                angle: rotationAngle
++        }
+     }
+ }
 === modified file 'qml/Stages/DesktopStage.qml'
 --- qml/Stages/DesktopStage.qml	2016-02-03 14:00:47 +0000
 +++ qml/Stages/DesktopStage.qml	2016-03-10 09:37:58 +0000
@@ -224,6 +224,7 @@
          PanelState.dropShadow = false;
+     }
++
      FocusScope {
          id: appContainer
          objectName: "appContainer"
@@ -254,14 +255,40 @@
                  focus: appId === priv.focusedAppId
                  width: decoratedWindow.width
                  height: decoratedWindow.height
++
++                Connections {
++                    target: root
++                    onShellOrientationAngleChanged: {
++                        // at this point decoratedWindow.surfaceOrientationAngle is the old shellOrientationAngle
++                        if (application && application.rotatesWindowContents) {
++                            if (state == "normal") {
++                                var angleDiff = decoratedWindow.surfaceOrientationAngle - shellOrientationAngle;
++                                angleDiff = (360 + angleDiff) % 360;
++                                if (angleDiff === 90 || angleDiff === 270) {
++                                    var aux = decoratedWindow.requestedHeight;
++                                    decoratedWindow.requestedHeight = decoratedWindow.requestedWidth + decoratedWindow.visibleDecorationHeight;
++                                    decoratedWindow.requestedWidth = aux - decoratedWindow.visibleDecorationHeight;
++                                }
++                            }
++                            decoratedWindow.surfaceOrientationAngle = shellOrientationAngle;
++                        } else {
++                            decoratedWindow.surfaceOrientationAngle = 0;
++                        }
++                    }
++                }
++                Component.onCompleted: {
++                    decoratedWindow.surfaceOrientationAngle = shellOrientationAngle;
++                }
++
++                readonly property alias application: decoratedWindow.application
++                readonly property alias minimumWidth: decoratedWindow.minimumWidth
++                readonly property alias minimumHeight: decoratedWindow.minimumHeight
++                readonly property alias maximumWidth: decoratedWindow.maximumWidth
++                readonly property alias maximumHeight: decoratedWindow.maximumHeight
++                readonly property alias widthIncrement: decoratedWindow.widthIncrement
++                readonly property alias heightIncrement: decoratedWindow.heightIncrement
                  property alias requestedWidth: decoratedWindow.requestedWidth
                  property alias requestedHeight: decoratedWindow.requestedHeight
--                property alias minimumWidth: decoratedWindow.minimumWidth
--                property alias minimumHeight: decoratedWindow.minimumHeight
--                property alias maximumWidth: decoratedWindow.maximumWidth
--                property alias maximumHeight: decoratedWindow.maximumHeight
--                property alias widthIncrement: decoratedWindow.widthIncrement
--                property alias heightIncrement: decoratedWindow.heightIncrement
                  QtObject {
                      id: appDelegatePrivate
@@ -274,6 +301,7 @@
                  readonly property alias maximizedLeft: appDelegatePrivate.maximizedLeft
                  readonly property alias maximizedRight: appDelegatePrivate.maximizedRight
                  readonly property alias minimized: appDelegatePrivate.minimized
++                readonly property alias fullscreen: decoratedWindow.fullscreen
                  readonly property string appId: model.appId
                  property bool animationsEnabled: true
@@ -293,6 +321,7 @@
                  visible: !visuallyMinimized &&
                           !greeter.fullyShown &&
                           (priv.foregroundMaximizedAppZ === -1 || priv.foregroundMaximizedAppZ <= z) ||
++                         decoratedWindow.fullscreen ||
                           (spread.state == "altTab" && index === spread.highlightedIndex)
                  Binding {
@@ -351,10 +380,11 @@
                  states: [
                      State {
                          name: "fullscreen"; when: decoratedWindow.fullscreen
--                        extend: "maximized"
                          PropertyChanges {
                              target: appDelegate;
--                            y: -PanelState.panelHeight
++                            x: rotation == 0 ? 0 : (parent.width - width) / 2 + (shellOrientationAngle == 90 ? -PanelState.panelHeight : PanelState.panelHeight)
++                            y: rotation == 0 ? -PanelState.panelHeight : (parent.height - height) / 2
++                            requestedWidth: appContainer.width; requestedHeight: appContainer.height;
+                         }
                      },
                      State {
@@ -371,21 +401,21 @@
                          name: "maximized"; when: appDelegate.maximized && !appDelegate.minimized
                          PropertyChanges {
                              target: appDelegate;
--                            x: 0; y: 0;
--                            requestedWidth: root.width; requestedHeight: root.height;
++                            x: root.leftMargin; y: 0;
++                            requestedWidth: appContainer.width - root.leftMargin; requestedHeight: appContainer.height;
                              visuallyMinimized: false;
                              visuallyMaximized: true
+                         }
                      },
                      State {
                          name: "maximizedLeft"; when: appDelegate.maximizedLeft && !appDelegate.minimized
--                        PropertyChanges { target: appDelegate; x: 0; y: PanelState.panelHeight;
--                            requestedWidth: root.width/2; requestedHeight: root.height - PanelState.panelHeight }
++                        PropertyChanges { target: appDelegate; x: root.leftMargin; y: PanelState.panelHeight;
++                            requestedWidth: (appContainer.width - root.leftMargin)/2; requestedHeight: appContainer.height - PanelState.panelHeight }
                      },
                      State {
                          name: "maximizedRight"; when: appDelegate.maximizedRight && !appDelegate.minimized
--                        PropertyChanges { target: appDelegate; x: root.width/2; y: PanelState.panelHeight;
--                            requestedWidth: root.width/2; requestedHeight: root.height - PanelState.panelHeight }
++                        PropertyChanges { target: appDelegate; x: (appContainer.width + root.leftMargin)/2; y: PanelState.panelHeight;
++                            requestedWidth: (appContainer.width - root.leftMargin)/2; requestedHeight: appContainer.height - PanelState.panelHeight }
                      },
                      State {
                          name: "minimized"; when: appDelegate.minimized
@@ -448,8 +478,9 @@
                      minHeight: units.gu(10)
                      borderThickness: units.gu(2)
                      windowId: model.appId // FIXME: Change this to point to windowId once we have such a thing
--                    screenWidth: root.width
--                    screenHeight: root.height
++                    screenWidth: appContainer.width
++                    screenHeight: appContainer.height
++                    leftMargin: root.leftMargin
                      onPressed: { ApplicationManager.focusApplication(model.appId) }
+                 }
@@ -475,7 +506,7 @@
      BlurLayer {
          id: blurLayer
--        anchors.fill: parent
++        anchors.fill: appContainer
          source: appContainer
          visible: false
+     }
@@ -527,7 +558,7 @@
      DesktopSpread {
          id: spread
          objectName: "spread"
--        anchors.fill: parent
++        anchors.fill: appContainer
          workspace: appContainer
          focus: state == "altTab"
          altTabPressed: root.altTabPressed
 === modified file 'qml/Stages/WindowResizeArea.qml'
 --- qml/Stages/WindowResizeArea.qml	2016-02-03 14:00:47 +0000
 +++ qml/Stages/WindowResizeArea.qml	2016-03-10 09:37:58 +0000
@@ -40,6 +40,7 @@
      property int defaultHeight: units.gu(50)
      property int screenWidth: 0
      property int screenHeight: 0
++    property int leftMargin: 0
      QtObject {
          id: priv
@@ -72,10 +73,12 @@
          var windowGeometry = windowStateStorage.getGeometry(root.windowId,
                                                              Qt.rect(target.x, target.y, defaultWidth, defaultHeight));
--        target.requestedWidth = Math.min(Math.max(windowGeometry.width, d.minimumWidth), screenWidth);
--        target.requestedHeight = Math.min(Math.max(windowGeometry.height, d.minimumHeight), root.screenHeight - PanelState.panelHeight);
--        target.x = Math.max(Math.min(windowGeometry.x, root.screenWidth - target.requestedWidth), 0)
--        target.y = Math.max(Math.min(windowGeometry.y, root.screenHeight - target.requestedHeight), PanelState.panelHeight)
++        target.requestedWidth = Qt.binding(function() { return Math.min(Math.max(windowGeometry.width, d.minimumWidth), screenWidth - root.leftMargin); });
++        target.requestedHeight = Qt.binding(function() { return Math.min(Math.max(windowGeometry.height, d.minimumHeight),
++                                                                         root.screenHeight - (target.fullscreen ? 0 : PanelState.panelHeight)); });
++        target.x = Qt.binding(function() { return Math.max(Math.min(windowGeometry.x, root.screenWidth - root.leftMargin - target.requestedWidth),
++                                                           (target.fullscreen ? 0 : root.leftMargin)); });
++        target.y = Qt.binding(function() { return Math.max(Math.min(windowGeometry.y, root.screenHeight - target.requestedHeight), PanelState.panelHeight); });
          var windowState = windowStateStorage.getState(root.windowId, WindowStateStorage.WindowStateNormal)
          if (windowState === WindowStateStorage.WindowStateMaximized) {
 === modified file 'tests/mocks/GSettings.1.0/fake_gsettings.cpp'
 --- tests/mocks/GSettings.1.0/fake_gsettings.cpp	2015-09-29 20:19:56 +0000
 +++ tests/mocks/GSettings.1.0/fake_gsettings.cpp	2016-03-10 09:37:58 +0000
@@ -22,6 +22,8 @@
  GSettingsControllerQml::GSettingsControllerQml()
      : m_usageMode("Staged")
++    , m_autohideLauncher(false)
++    , m_launcherWidth(8)
+ {
+ }
@@ -88,6 +90,32 @@
+     }
+ }
++bool GSettingsControllerQml::autohideLauncher() const
++{
++    return m_autohideLauncher;
++}
++
++void GSettingsControllerQml::setAutohideLauncher(bool autohideLauncher)
++{
++    if (m_autohideLauncher != autohideLauncher) {
++        m_autohideLauncher = autohideLauncher;
++        Q_EMIT autohideLauncherChanged(autohideLauncher);
++    }
++}
++
++int GSettingsControllerQml::launcherWidth() const
++{
++    return m_launcherWidth;
++}
++
++void GSettingsControllerQml::setLauncherWidth(int launcherWidth)
++{
++    if (m_launcherWidth != launcherWidth) {
++        m_launcherWidth = launcherWidth;
++        Q_EMIT launcherWidthChanged(launcherWidth);
++    }
++}
++
  GSettingsSchemaQml::GSettingsSchemaQml(QObject *parent): QObject(parent) {
+ }
@@ -129,6 +157,10 @@
              this, &GSettingsQml::lockedOutTimeChanged);
      connect(GSettingsControllerQml::instance(), &GSettingsControllerQml::lifecycleExemptAppidsChanged,
              this, &GSettingsQml::lifecycleExemptAppidsChanged);
++    connect(GSettingsControllerQml::instance(), &GSettingsControllerQml::autohideLauncherChanged,
++            this, &GSettingsQml::autohideLauncherChanged);
++    connect(GSettingsControllerQml::instance(), &GSettingsControllerQml::launcherWidthChanged,
++            this, &GSettingsQml::launcherWidthChanged);
+ }
  GSettingsSchemaQml * GSettingsQml::schema() const {
@@ -192,9 +224,41 @@
+     }
+ }
++bool GSettingsQml::autohideLauncher() const
++{
++    if (m_schema->id() == "com.canonical.Unity8") {
++        return GSettingsControllerQml::instance()->autohideLauncher();
++    } else {
++        return false;
++    }
++}
++
++int GSettingsQml::launcherWidth() const
++{
++    if (m_schema->id() == "com.canonical.Unity8") {
++        return GSettingsControllerQml::instance()->launcherWidth();
++    } else {
++        return false;
++    }
++}
++
  void GSettingsQml::setLifecycleExemptAppids(const QStringList &appIds)
+ {
      if (m_schema->id() == "com.canonical.qtmir") {
          GSettingsControllerQml::instance()->setLifecycleExemptAppids(appIds);
+     }
+ }
++
++void GSettingsQml::setAutohideLauncher(bool autohideLauncher)
++{
++    if (m_schema->id() == "com.canonical.Unity8") {
++        GSettingsControllerQml::instance()->setAutohideLauncher(autohideLauncher);
++    }
++}
++
++void GSettingsQml::setLauncherWidth(int launcherWidth)
++{
++    if (m_schema->id() == "com.canonical.Unity8") {
++        GSettingsControllerQml::instance()->setLauncherWidth(launcherWidth);
++    }
++}
 === modified file 'tests/mocks/GSettings.1.0/fake_gsettings.h'
 --- tests/mocks/GSettings.1.0/fake_gsettings.h	2015-09-29 20:19:56 +0000
 +++ tests/mocks/GSettings.1.0/fake_gsettings.h	2016-03-10 09:37:58 +0000
@@ -50,6 +50,8 @@
      Q_PROPERTY(QString usageMode READ usageMode WRITE setUsageMode NOTIFY usageModeChanged)
      Q_PROPERTY(qint64 lockedOutTime READ lockedOutTime WRITE setLockedOutTime NOTIFY lockedOutTimeChanged)
      Q_PROPERTY(QStringList lifecycleExemptAppids READ lifecycleExemptAppids WRITE setLifecycleExemptAppids NOTIFY lifecycleExemptAppidsChanged)
++    Q_PROPERTY(bool autohideLauncher READ autohideLauncher WRITE setAutohideLauncher NOTIFY autohideLauncherChanged)
++    Q_PROPERTY(int launcherWidth READ launcherWidth WRITE setLauncherWidth NOTIFY launcherWidthChanged)
  public:
      GSettingsQml(QObject *parent = nullptr);
@@ -59,11 +61,15 @@
      QString usageMode() const;
      qint64 lockedOutTime() const;
      QStringList lifecycleExemptAppids() const;
++    bool autohideLauncher() const;
++    int launcherWidth() const;
      void setPictureUri(const QString &str);
      void setUsageMode(const QString &usageMode);
      void setLockedOutTime(qint64 timestamp);
      void setLifecycleExemptAppids(const QStringList &appIds);
++    void setAutohideLauncher(bool autohideLauncher);
++    void setLauncherWidth(int launcherWidth);
  Q_SIGNALS:
      void schemaChanged();
@@ -71,6 +77,8 @@
      void usageModeChanged(const QString&);
      void lockedOutTimeChanged(qint64);
      void lifecycleExemptAppidsChanged(const QStringList &);
++    void autohideLauncherChanged(bool);
++    void launcherWidthChanged(int launcherWidth);
  private:
      GSettingsSchemaQml* m_schema;
@@ -98,11 +106,19 @@
      QStringList lifecycleExemptAppids() const;
      Q_INVOKABLE void setLifecycleExemptAppids(const QStringList &appIds);
++    bool autohideLauncher() const;
++    Q_INVOKABLE void setAutohideLauncher(bool autohideLauncher);
++
++    int launcherWidth() const;
++    Q_INVOKABLE void setLauncherWidth(int launcherWidth);
++
  Q_SIGNALS:
      void pictureUriChanged(const QString&);
      void usageModeChanged(const QString&);
      void lockedOutTimeChanged(qint64 timestamp);
      void lifecycleExemptAppidsChanged(const QStringList&);
++    void autohideLauncherChanged(bool autohideLauncher);
++    void launcherWidthChanged(int launcherWidth);
  private:
      GSettingsControllerQml();
@@ -111,6 +127,8 @@
      QString m_usageMode;
      qint64 m_lockedOutTime;
      QStringList m_lifecycleExemptAppids;
++    bool m_autohideLauncher;
++    int m_launcherWidth;
      static GSettingsControllerQml* s_controllerInstance;
      QList<GSettingsQml *> m_registeredGSettings;
 === modified file 'tests/mocks/Unity/Application/ApplicationManager.cpp'
 --- tests/mocks/Unity/Application/ApplicationManager.cpp	2015-12-03 18:10:39 +0000
 +++ tests/mocks/Unity/Application/ApplicationManager.cpp	2016-03-10 09:37:58 +0000
@@ -345,6 +345,18 @@
      m_availableApplications.append(application);
      application = new ApplicationInfo(this);
++    application->setAppId("camera-app2");
++    application->setName("Camera2");
++    application->setScreenshotId("camera");
++    application->setIconId("camera");
++    application->setSupportedOrientations(Qt::PortraitOrientation
++                                        | Qt::LandscapeOrientation
++                                        | Qt::InvertedPortraitOrientation
++                                        | Qt::InvertedLandscapeOrientation);
++    application->setRotatesWindowContents(true);
++    m_availableApplications.append(application);
++
++    application = new ApplicationInfo(this);
      application->setAppId("gallery-app");
      application->setName("Gallery");
      application->setScreenshotId("gallery");
 === modified file 'tests/mocks/Unity/Launcher/MockLauncherModel.cpp'
 --- tests/mocks/Unity/Launcher/MockLauncherModel.cpp	2015-11-04 11:29:16 +0000
 +++ tests/mocks/Unity/Launcher/MockLauncherModel.cpp	2016-03-10 09:37:58 +0000
@@ -25,15 +25,20 @@
      MockLauncherItem *item = new MockLauncherItem("dialer-app", "/usr/share/applications/dialer-app.desktop", "Dialer", "dialer-app", this);
      item->setProgress(0);
      item->setPinned(true);
++    item->setRunning(true);
      item->setFocused(true);
      m_list.append(item);
      item = new MockLauncherItem("camera-app", "/usr/share/applications/camera-app.desktop", "Camera", "camera", this);
      item->setProgress(10);
      item->setPinned(true);
      m_list.append(item);
++    item = new MockLauncherItem("camera-app2", "/usr/share/applications/camera-app2.desktop", "Camera2", "camera", this);
++    item->setPinned(true);
++    m_list.append(item);
      item = new MockLauncherItem("gallery-app", "/usr/share/applications/gallery-app.desktop", "Gallery", "gallery", this);
      item->setProgress(50);
      item->setCountVisible(true);
++    item->setRunning(true);
      item->setAlerting(false);
      m_list.append(item);
      item = new MockLauncherItem("music-app", "/usr/share/applications/music-app.desktop", "Music", "soundcloud", this);
 === modified file 'tests/qmltests/Launcher/tst_Launcher.qml'
 --- tests/qmltests/Launcher/tst_Launcher.qml	2016-01-19 15:36:15 +0000
 +++ tests/qmltests/Launcher/tst_Launcher.qml	2016-03-10 09:37:58 +0000
@@ -28,12 +28,13 @@
     launcher. */
  Item {
      id: root
--    width: units.gu(50)
--    height: units.gu(55)
++    width: units.gu(140)
++    height: units.gu(70)
      Loader {
          id: launcherLoader
          anchors.fill: parent
++        focus: true
          property bool itemDestroyed: false
          sourceComponent: Component {
              Launcher {
@@ -68,6 +69,7 @@
                  Component.onCompleted: {
                      launcherLoader.itemDestroyed = false;
++                    launcherLoader.focus = true
                      edgeBarrierControls.target = testCase.findChild(this, "edgeBarrierController");
+                 }
                  Component.onDestruction: {
@@ -77,11 +79,40 @@
+         }
+     }
++    Binding {
++        target: launcherLoader.item
++        property: "lockedVisible"
++        value: lockedVisibleCheckBox.checked
++    }
++    Binding {
++        target: launcherLoader.item
++        property: "panelWidth"
++        value: units.gu(Math.round(widthSlider.value))
++    }
++
      ColumnLayout {
          anchors { bottom: parent.bottom; right: parent.right; margins: units.gu(1) }
          spacing: units.gu(1)
          width: childrenRect.width
++        RowLayout {
++            CheckBox {
++                id: lockedVisibleCheckBox
++                checked: false
++            }
++            Label {
++                text: "Launcher always visible"
++            }
++        }
++
++        Slider {
++            id: widthSlider
++            Layout.fillWidth: true
++            minimumValue: 6
++            maximumValue: 12
++            value: 10
++        }
++
          MouseTouchEmulationCheckbox {}
          EdgeBarrierControls {
@@ -102,6 +133,15 @@
              Layout.fillWidth: true
+         }
++        Button {
++            text: "open for kbd navigation"
++            onClicked: {
++                launcherLoader.item.openForKeyboardNavigation()
++                launcherLoader.item.forceActiveFocus();// = true
++            }
++            Layout.fillWidth: true
++        }
++
          Row {
              spacing: units.gu(1)
@@ -206,10 +246,6 @@
              // growing while populating it with icons etc.
              tryCompare(listView, "flicking", false);
--            // Make sure noone changed the height of the window. The issue this test case
--            // is verifying only happens on certain heights of the Launcher
--            compare(root.height, units.gu(55));
--
              compare(listView.contentY, -listView.topMargin, "Launcher did not start up with first item unfolded");
              // Now do check that snapping is in fact enabled
@@ -266,13 +302,32 @@
          function positionLauncherListAtBeginning() {
              var listView = testCase.findChild(launcherLoader.item, "launcherListView");
--            listView.contentY = -listView.topMargin;
++            var moveAnimation = findInvisibleChild(listView, "moveAnimation")
++
++            listView.moveToIndex(0);
++
++            waitForRendering(listView);
++            tryCompare(moveAnimation, "running", false);
+         }
          function positionLauncherListAtEnd() {
              var listView = testCase.findChild(launcherLoader.item, "launcherListView");
--            if ((listView.contentHeight + listView.topMargin + listView.bottomMargin) > listView.height) {
--                listView.contentY = listView.topMargin + listView.contentHeight
--                    - listView.height;
++            var moveAnimation = findInvisibleChild(listView, "moveAnimation")
++
++            listView.moveToIndex(listView.count -1);
++
++            waitForRendering(listView);
++            tryCompare(moveAnimation, "running", false);
++        }
++
++        function assertFocusOnIndex(index) {
++            var launcherListView = findChild(launcher, "launcherListView");
++            var bfbFocusHighlight = findChild(launcher, "bfbFocusHighlight");
++
++            waitForRendering(launcher);
++            compare(bfbFocusHighlight.visible, index === -1);
++            for (var i = 0; i < launcherListView.count; i++) {
++                var focusRing = findChild(findChild(launcher, "launcherDelegate" + i), "focusRing")
++                compare(focusRing.visible, index === i);
+             }
+         }
@@ -290,10 +345,10 @@
              dragLauncherIntoView()
              // tapping on the center of the screen should dismiss the launcher
--            mouseClick(launcher)
++            mouseClick(launcher, panel.width + units.gu(5), launcher.height / 2)
              // should eventually get fully retracted (hidden)
--            tryCompare(panel, "x", -launcher.panelWidth, 1000)
++            tryCompare(panel, "x", -launcher.panelWidth, 2000)
+         }
          /* If I click on the icon of an application on the launcher
@@ -377,6 +432,7 @@
                  wait(100)
                  compare(launcher.maxPanelX, -launcher.panelWidth, "Launcher moved even if it shouldn't")
+             }
++
              waitUntilLauncherDisappears();
              launcher.available = true;
+         }
@@ -400,6 +456,8 @@
              dragLauncherIntoView();
              var launcherListView = findChild(launcher, "launcherListView");
              for (var i = 0; i < launcherListView.count; ++i) {
++                launcherListView.moveToIndex(i);
++                waitForRendering(launcherListView);
                  var delegate = findChild(launcherListView, "launcherDelegate" + i)
                  compare(findChild(delegate, "countEmblem").visible, LauncherModel.get(i).countVisible)
                  // Intentionally allow type coercion (string/number)
@@ -421,7 +479,7 @@
              var launcherListView = findChild(launcher, "launcherListView");
              for (var i = 0; i < launcherListView.count; ++i) {
                  var delegate = findChild(launcherListView, "launcherDelegate" + i)
--                compare(findChild(delegate, "runningHighlight").visible, LauncherModel.get(i).running)
++                compare(findChild(delegate, "runningHighlight0").visible, LauncherModel.get(i).running)
+             }
+         }
@@ -460,6 +518,7 @@
              launcher.lastSelectedApplication = "";
              dragLauncherIntoView();
              var listView = findChild(launcher, "launcherListView");
++            var moveAnimation = findInvisibleChild(listView, "moveAnimation")
              // flicking is unreliable. sometimes it works, sometimes the
              // list view moves just a tiny bit or not at all, making tests fail.
@@ -470,12 +529,14 @@
              } else {
                  positionLauncherListAtEnd();
+             }
--            tryCompare(listView, "flicking", false);
--
              var oldY = listView.contentY;
              mouseClick(listView, listView.width / 2, data.clickY);
--            tryCompare(listView, "flicking", false);
++
++            if (data.expectFlick) {
++                tryCompare(moveAnimation, "running", true);
++            }
++            tryCompare(moveAnimation, "running", false);
              if (data.expectFlick) {
                  verify(listView.contentY != oldY);
@@ -764,14 +825,15 @@
          function test_launcher_dismiss() {
              dragLauncherIntoView();
              verify(launcher.state == "visible");
--            mouseClick(root);
++
++            mouseClick(root, root.width / 2, units.gu(1));
              waitUntilLauncherDisappears();
              verify(launcher.state == "");
              // and repeat, as a test for regression in lpbug#1531339
              dragLauncherIntoView();
              verify(launcher.state == "visible");
--            mouseClick(root);
++            mouseClick(root, root.width / 2, units.gu(1));
              waitUntilLauncherDisappears();
              verify(launcher.state == "");
+         }
@@ -1044,5 +1106,169 @@
              LauncherModel.setCountVisible(LauncherModel.get(1).appId, 0)
              LauncherModel.setCount(LauncherModel.get(1).appId, oldCount)
+         }
++
++        function test_longpressSuperKeyShowsHints() {
++            var shortCutHint0 = findChild(findChild(launcher, "launcherDelegate0"), "shortcutHint");
++
++            tryCompare(shortCutHint0, "visible", false);
++
++            launcher.superPressed = true;
++            tryCompare(launcher, "state", "visible");
++            tryCompare(shortCutHint0, "visible", true);
++
++            launcher.superPressed = false;
++            tryCompare(launcher, "state", "");
++            tryCompare(shortCutHint0, "visible", false);
++        }
++
++        function test_keyboardNavigation() {
++            var bfbFocusHighlight = findChild(launcher, "bfbFocusHighlight");
++            var quickList = findChild(launcher, "quickList");
++            var launcherPanel = findChild(launcher, "launcherPanel");
++            var launcherListView = findChild(launcher, "launcherListView");
++            var last = launcherListView.count - 1;
++
++            compare(bfbFocusHighlight.visible, false);
++
++            launcher.openForKeyboardNavigation();
++            tryCompare(launcherPanel, "x", 0);
++            waitForRendering(launcher);
++
++            assertFocusOnIndex(-1);
++
++            // Down should go down
++            keyClick(Qt.Key_Down);
++            assertFocusOnIndex(0);
++
++            // Tab should go down
++            keyClick(Qt.Key_Tab);
++            assertFocusOnIndex(1);
++
++            // Up should go up
++            keyClick(Qt.Key_Up);
++            assertFocusOnIndex(0);
++
++            // Backtab should go up
++            keyClick(Qt.Key_Backtab);
++            assertFocusOnIndex(-1); // BFB
++
++            // The list should wrap around
++            keyClick(Qt.Key_Up);
++            assertFocusOnIndex(last);
++
++            keyClick(Qt.Key_Down);
++            waitForRendering(launcher);
++            keyClick(Qt.Key_Down);
++            assertFocusOnIndex(0); // Back to Top
++
++            // Right opens the quicklist
++            keyClick(Qt.Key_Right);
++            assertFocusOnIndex(0); // Navigating the quicklist... the launcher focus should not move
++            tryCompare(quickList, "visible", true);
++            tryCompare(quickList, "selectedIndex", 0)
++
++            // Down should move down the quicklist
++            keyClick(Qt.Key_Down);
++            tryCompare(quickList, "selectedIndex", 1)
++
++            // The quicklist should wrap around too
++            keyClick(Qt.Key_Down);
++            keyClick(Qt.Key_Down);
++            keyClick(Qt.Key_Down);
++            tryCompare(quickList, "selectedIndex", 0)
++
++            // Left gets us back to the launcher
++            keyClick(Qt.Key_Left);
++            assertFocusOnIndex(0);
++            tryCompare(quickList, "visible", false);
++
++            // Launcher navigation should still work
++            // Go bar to top by wrapping around
++            keyClick(Qt.Key_Down);
++            assertFocusOnIndex(1);
++        }
++
++        function test_selectQuicklistItemByKeyboard() {
++            launcher.openForKeyboardNavigation();
++            waitForRendering(launcher);
++
++            signalSpy.clear();
++            signalSpy.signalName = "quickListTriggered"
++
++            keyClick(Qt.Key_Down); // Down to launcher item 0
++            keyClick(Qt.Key_Down); // Down to launcher item 1
++            keyClick(Qt.Key_Right); // Into quicklist
++            keyClick(Qt.Key_Down); // Down to quicklist item 1
++            keyClick(Qt.Key_Down); // Down to quicklist item 2
++            keyClick(Qt.Key_Enter); // Trigger it
++
++            compare(signalSpy.count, 1, "Quicklist signal wasn't triggered")
++            compare(signalSpy.signalArguments[0][0], LauncherModel.get(1).appId)
++            compare(signalSpy.signalArguments[0][1], 2)
++            assertFocusOnIndex(-2);
++        }
++
++        function test_hideNotWorkingWhenLockedOut_data() {
++            return [
++                {tag: "locked visible", locked: true},
++                {tag: "no locked visible", locked: false},
++            ]
++        }
++
++        function test_hideNotWorkingWhenLockedOut(data) {
++            launcher.lockedVisible = data.locked;
++            if (data.locked) {
++                tryCompare(launcher, "state", "visible");
++            } else {
++                tryCompare(launcher, "state", "");
++            }
++
++            launcher.hide();
++            waitForRendering(launcher);
++            if (data.locked) {
++                verify(launcher.state == "visible");
++            } else {
++                verify(launcher.state == "");
++            }
++        }
++
++        function test_cancelKbdNavigationWitMouse_data() {
++            return [
++                        {tag: "locked out - no quicklist", autohide: false, withQuickList: false },
++                        {tag: "locked out - with quicklist", autohide: false, withQuickList: true },
++                        {tag: "autohide - no quicklist", autohide: true, withQuickList: false },
++                        {tag: "autohide - with quicklist", autohide: true, withQuickList: true },
++            ]
++        }
++
++        function test_cancelKbdNavigationWitMouse(data) {
++            launcher.autohideEnabled = data.autohide;
++            launcher.openForKeyboardNavigation();
++            waitForRendering(launcher);
++
++            var launcherPanel = findChild(launcher, "launcherPanel");
++            tryCompare(launcherPanel, "x", 0);
++
++            var quickList = findChild(launcher, "quickList");
++
++            keyClick(Qt.Key_Down); // Down to launcher item 0
++            keyClick(Qt.Key_Down); // Down to launcher item 1
++
++            if (data.withQuickList) {
++                keyClick(Qt.Key_Right); // Into quicklist
++                tryCompare(quickList, "visible", true)
++            }
++            waitForRendering(launcher)
++
++            mouseClick(root);
++
++            if (data.autohide) {
++                tryCompare(launcher, "state", "");
++            } else {
++                tryCompare(launcher, "state", "visible");
++            }
++
++            assertFocusOnIndex(-2);
++        }
+     }
+ }
 === modified file 'tests/qmltests/tst_OrientedShell.qml'
 --- tests/qmltests/tst_OrientedShell.qml	2016-01-28 11:31:48 +0000
 +++ tests/qmltests/tst_OrientedShell.qml	2016-03-10 09:37:58 +0000
@@ -26,6 +26,7 @@
  import Unity.InputInfo 0.1
  import "../../qml"
++import "Stages"
  Rectangle {
      id: root
@@ -406,6 +407,8 @@
+                     }
+                 }
+             }
++
++            SurfaceManagerControls { textColor: "white" }
+         }
+     }
@@ -551,8 +554,11 @@
          function test_appRotatesWindowContents_data() {
              return [
                  {tag: "mako", deviceName: "mako", orientationAngleAfterRotation: 90},
++                {tag: "mako_windowed", deviceName: "mako", orientationAngleAfterRotation: 90, windowed: true},
                  {tag: "manta", deviceName: "manta", orientationAngleAfterRotation: 90},
--                {tag: "flo", deviceName: "flo", orientationAngleAfterRotation: 180}
++                {tag: "manta_windowed", deviceName: "manta", orientationAngleAfterRotation: 90, windowed: true},
++                {tag: "flo", deviceName: "flo", orientationAngleAfterRotation: 180},
++                {tag: "flo_windowed", deviceName: "flo", orientationAngleAfterRotation: 180, windowed: true}
              ];
+         }
          function test_appRotatesWindowContents(data) {
@@ -560,6 +566,12 @@
              var cameraApp = ApplicationManager.startApplication("camera-app");
              verify(cameraApp);
++            if (data.windowed) {
++                usageModeSelector.selectWindowed();
++            } else {
++                usageModeSelector.selectStaged();
++            }
++
              // ensure the mock camera-app is as we expect
              compare(cameraApp.fullscreen, true);
              compare(cameraApp.rotatesWindowContents, true);
 === modified file 'tests/qmltests/tst_Shell.qml'
 --- tests/qmltests/tst_Shell.qml	2016-02-12 00:11:28 +0000
 +++ tests/qmltests/tst_Shell.qml	2016-03-10 09:37:58 +0000
@@ -26,6 +26,7 @@
  import Unity.Connectivity 0.1
  import Unity.Indicators 0.1
  import Unity.Notifications 1.0
++import Unity.Launcher 0.1
  import Unity.Test 0.1
  import Powerd 0.1
  import Wizard 0.1 as Wizard
@@ -121,10 +122,6 @@
                      Component.onDestruction: {
                          shellLoader.itemDestroyed = true;
+                     }
--                    Component.onCompleted: {
--                        var keyMapper = testCase.findChild(__shell, "physicalKeysMapper");
--                        keyMapper.controlInsteadOfAlt = true;
--                    }
+                 }
+             }
+         }
@@ -213,6 +210,31 @@
                      checked: true
                      color: "white"
+                 }
++                ListItem.ItemSelector {
++                    id: ctrlModifier
++                    anchors { left: parent.left; right: parent.right }
++                    activeFocusOnPress: false
++                    text: "Ctrl key as"
++                    model: ["Ctrl", "Alt", "Super"]
++                    onSelectedIndexChanged: {
++                        var keyMapper = testCase.findChild(shellContainer, "physicalKeysMapper");
++                        keyMapper.controlInsteadOfAlt = selectedIndex == 1;
++                        keyMapper.controlInsteadOfSuper = selectedIndex == 2;
++                    }
++                }
++
++                Row {
++                    anchors { left: parent.left; right: parent.right }
++                    CheckBox {
++                        id: autohideLauncherCheckbox
++                        onCheckedChanged:  {
++                            GSettingsController.setAutohideLauncher(checked)
++                        }
++                    }
++                    Label {
++                        text: "Autohide launcher"
++                    }
++                }
                  Label { text: "Applications"; font.bold: true }
@@ -912,6 +934,7 @@
          function dragLauncherIntoView() {
              var launcher = findChild(shell, "launcher");
              var launcherPanel = findChild(launcher, "launcherPanel");
++            waitForRendering(launcher);
              verify(launcherPanel.x = - launcherPanel.width);
              var touchStartX = 2;
@@ -1441,7 +1464,7 @@
              // Do a quick alt-tab and see if focus changes
              tryCompare(app3.session.lastSurface, "activeFocus", true)
--            keyClick(Qt.Key_Tab, Qt.ControlModifier)
++            keyClick(Qt.Key_Tab, Qt.AltModifier)
              tryCompare(app2.session.lastSurface, "activeFocus", true)
              var desktopSpread = findChild(shell, "spread")
@@ -1449,12 +1472,12 @@
              tryCompare(desktopSpread, "state", "")
              // Just press Alt, make sure the spread comes up
--            keyPress(Qt.Key_Control);
++            keyPress(Qt.Key_Alt);
              keyClick(Qt.Key_Tab);
              tryCompare(desktopSpread, "state", "altTab")
              // Release control, check if spread disappears
--            keyRelease(Qt.Key_Control)
++            keyRelease(Qt.Key_Alt)
              tryCompare(desktopSpread, "state", "")
              // Focus should have switched back now
@@ -1482,7 +1505,7 @@
              tryCompare(desktopSpread, "state", "")
              // Just press Alt, make sure the spread comes up
--            keyPress(Qt.Key_Control);
++            keyPress(Qt.Key_Alt);
              keyClick(Qt.Key_Tab);
              tryCompare(desktopSpread, "state", "altTab")
              tryCompare(spreadRepeater, "highlightedIndex", 1)
@@ -1503,7 +1526,7 @@
              tryCompare(spreadRepeater, "highlightedIndex", 0)
              // Release control, check if spread disappears
--            keyRelease(Qt.Key_Control)
++            keyRelease(Qt.Key_Alt)
              tryCompare(desktopSpread, "state", "")
              // Make sure that after wrapping around once, we have the same one focused as at the beginning
@@ -1516,7 +1539,7 @@
              var spreadRepeater = findInvisibleChild(shell, "spreadRepeater");
              verify(spreadRepeater !== null);
--            keyPress(Qt.Key_Control)
++            keyPress(Qt.Key_Alt)
              keyClick(Qt.Key_Tab);
              tryCompare(spreadRepeater, "highlightedIndex", 1);
@@ -1538,7 +1561,7 @@
              keyClick(Qt.Key_Backtab);
              tryCompare(spreadRepeater, "highlightedIndex", 1);
--            keyRelease(Qt.Key_Control);
++            keyRelease(Qt.Key_Alt);
+         }
          function test_highlightFollowsMouse() {
@@ -1547,7 +1570,7 @@
              var spreadRepeater = findInvisibleChild(shell, "spreadRepeater");
              verify(spreadRepeater !== null);
--            keyPress(Qt.Key_Control)
++            keyPress(Qt.Key_Alt)
              keyClick(Qt.Key_Tab);
              tryCompare(spreadRepeater, "highlightedIndex", 1);
@@ -1566,7 +1589,7 @@
              verify(y < 4000);
--            keyRelease(Qt.Key_Control);
++            keyRelease(Qt.Key_Alt);
+         }
          function test_closeFromSpread() {
@@ -1575,7 +1598,7 @@
              var spreadRepeater = findInvisibleChild(shell, "spreadRepeater");
              verify(spreadRepeater !== null);
--            keyPress(Qt.Key_Control)
++            keyPress(Qt.Key_Alt)
              keyClick(Qt.Key_Tab);
              appRemovedSpy.clear();
@@ -1602,7 +1625,7 @@
              tryCompare(appRemovedSpy, "count", 1)
              compare(appRemovedSpy.signalArguments[0][0], closedAppId);
--            keyRelease(Qt.Key_Control);
++            keyRelease(Qt.Key_Alt);
+         }
          function test_selectFromSpreadWithMouse_data() {
@@ -1622,7 +1645,7 @@
              var spreadRepeater = findInvisibleChild(shell, "spreadRepeater");
              verify(spreadRepeater !== null);
--            keyPress(Qt.Key_Control)
++            keyPress(Qt.Key_Alt)
              keyClick(Qt.Key_Tab);
              var focusAppId = ApplicationManager.get(2).appId;
@@ -1649,7 +1672,7 @@
              tryCompare(stage, "state", "");
              tryCompare(ApplicationManager, "focusedApplicationId", focusAppId);
--            keyRelease(Qt.Key_Control);
++            keyRelease(Qt.Key_Alt);
+         }
          function test_progressiveAutoScrolling() {
@@ -1658,7 +1681,7 @@
              var appRepeater = findInvisibleChild(shell, "appRepeater");
              verify(appRepeater !== null);
--            keyPress(Qt.Key_Control)
++            keyPress(Qt.Key_Alt)
              keyClick(Qt.Key_Tab);
              var spreadFlickable = findChild(shell, "spreadFlickable")
@@ -1669,7 +1692,7 @@
              var x = 0;
              var y = shell.height * .5
              mouseMove(shell, x, y)
--            while (x <= spreadFlickable.width) {
++            while (x <= shell.width) {
                  x+=10;
                  mouseMove(shell, x, y)
                  wait(0); // spin the loop so bindings get evaluated
@@ -1684,7 +1707,7 @@
+             }
              tryCompare(spreadFlickable, "contentX", 0);
--            keyRelease(Qt.Key_Control);
++            keyRelease(Qt.Key_Alt);
+         }
          // This makes sure the hoverMouseArea is set to invisible AND disabled
@@ -1696,13 +1719,13 @@
              tryCompare(hoverMouseArea, "enabled", false)
              tryCompare(hoverMouseArea, "visible", false)
--            keyPress(Qt.Key_Control)
++            keyPress(Qt.Key_Alt)
              keyClick(Qt.Key_Tab);
              tryCompare(hoverMouseArea, "enabled", true)
              tryCompare(hoverMouseArea, "visible", true)
--            keyRelease(Qt.Key_Control)
++            keyRelease(Qt.Key_Alt)
              tryCompare(hoverMouseArea, "enabled", false)
              tryCompare(hoverMouseArea, "visible", false)
@@ -1719,7 +1742,7 @@
              var appRepeater = findInvisibleChild(shell, "appRepeater");
              verify(appRepeater !== null);
--            keyPress(Qt.Key_Control)
++            keyPress(Qt.Key_Alt)
              keyClick(Qt.Key_Tab);
              tryCompare(spreadRepeater, "highlightedIndex", 1);
@@ -1740,33 +1763,46 @@
              verify(y < 4000);
--            keyRelease(Qt.Key_Control);
--        }
--
--        function test_focusAppFromLauncherExitsSpread() {
++            keyRelease(Qt.Key_Alt);
++        }
++
++        function test_focusAppFromLauncherExitsSpread_data() {
++            return [
++                {tag: "autohide launcher", launcherLocked: false },
++                {tag: "locked launcher", launcherLocked: true }
++            ]
++        }
++
++        function test_focusAppFromLauncherExitsSpread(data) {
              loadDesktopShellWithApps()
--
++            var launcher = findChild(shell, "launcher");
              var desktopSpread = findChild(shell, "spread");
--            var launcher = findChild(shell, "launcher");
              var bfb = findChild(launcher, "buttonShowDashHome");
--            keyPress(Qt.Key_Control)
++            GSettingsController.setAutohideLauncher(!data.launcherLocked);
++            waitForRendering(shell);
++
++            keyPress(Qt.Key_Alt)
              keyClick(Qt.Key_Tab);
              tryCompare(desktopSpread, "state", "altTab")
--            revealLauncherByEdgePushWithMouse();
--            tryCompare(launcher, "x", 0);
--            mouseMove(bfb, bfb.width / 2, bfb.height / 2)
--            waitForRendering(shell)
++            if (!data.launcherLocked) {
++                revealLauncherByEdgePushWithMouse();
++                tryCompare(launcher, "x", 0);
++                mouseMove(bfb, bfb.width / 2, bfb.height / 2)
++                waitForRendering(shell)
++            }
              mouseClick(bfb, bfb.width / 2, bfb.height / 2)
--            tryCompare(launcher, "state", "")
++            if (!data.launcherLocked) {
++                tryCompare(launcher, "state", "")
++            }
              tryCompare(desktopSpread, "state", "")
              tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash")
--            keyRelease(Qt.Key_Control);
++            keyRelease(Qt.Key_Alt);
+         }
          // regression test for http://pad.lv/1443319
@@ -1989,6 +2025,138 @@
+             }
+         }
++        function test_superTabToCycleLauncher_data() {
++            return [
++                {tag: "autohide launcher", launcherLocked: false},
++                {tag: "locked launcher", launcherLocked: true}
++            ]
++        }
++
++        function test_superTabToCycleLauncher(data) {
++            loadShell("desktop");
++            shell.usageScenario = "desktop";
++            GSettingsController.setAutohideLauncher(!data.launcherLocked);
++            waitForRendering(shell);
++
++            var launcher = findChild(shell, "launcher");
++            var launcherPanel = findChild(launcher, "launcherPanel");
++            var firstAppInLauncher = LauncherModel.get(0).appId;
++
++            compare(launcher.state, data.launcherLocked ? "visible": "");
++            compare(launcherPanel.highlightIndex, -2);
++            compare(ApplicationManager.focusedApplicationId, "unity8-dash");
++
++            // Use Super + Tab Tab to cycle to the first entry in the launcher
++            keyPress(Qt.Key_Super_L, Qt.MetaModifier);
++            keyClick(Qt.Key_Tab);
++            tryCompare(launcher, "state", "visible");
++            tryCompare(launcherPanel, "highlightIndex", -1);
++            keyClick(Qt.Key_Tab);
++            tryCompare(launcherPanel, "highlightIndex", 0);
++            keyRelease(Qt.Key_Super_L, Qt.MetaModifier);
++            tryCompare(launcher, "state", data.launcherLocked ? "visible" : "");
++            tryCompare(launcherPanel, "highlightIndex", -2);
++            tryCompare(ApplicationManager, "focusedApplicationId", firstAppInLauncher);
++
++            // Now go back to the dash
++            keyPress(Qt.Key_Super_L, Qt.MetaModifier);
++            keyClick(Qt.Key_Tab);
++            tryCompare(launcher, "state", "visible");
++            tryCompare(launcherPanel, "highlightIndex", -1);
++            keyRelease(Qt.Key_Super_L, Qt.MetaModifier);
++            tryCompare(launcher, "state", data.launcherLocked ? "visible" : "");
++            tryCompare(launcherPanel, "highlightIndex", -2);
++            tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");
++        }
++
++        function test_longpressSuperOpensLauncher() {
++            loadShell("desktop");
++            var launcher = findChild(shell, "launcher");
++            var shortcutHint = findChild(findChild(launcher, "launcherDelegate0"), "shortcutHint")
++
++            compare(launcher.state, "");
++            keyPress(Qt.Key_Super_L, Qt.MetaModifier);
++            tryCompare(launcher, "state", "visible");
++            tryCompare(shortcutHint, "visible", true);
++
++            keyRelease(Qt.Key_Super_L, Qt.MetaModifier);
++            tryCompare(launcher, "state", "");
++            tryCompare(shortcutHint, "visible", false);
++        }
++
++        function test_metaNumberLaunchesFromLauncher_data() {
++            return [
++                {tag: "Meta+1", key: Qt.Key_1, index: 0},
++                {tag: "Meta+2", key: Qt.Key_2, index: 1},
++                {tag: "Meta+4", key: Qt.Key_5, index: 4},
++                {tag: "Meta+0", key: Qt.Key_0, index: 9},
++            ]
++        }
++
++        function test_metaNumberLaunchesFromLauncher(data) {
++            loadShell("desktop");
++            var launcher = findChild(shell, "launcher");
++            var appId = LauncherModel.get(data.index).appId;
++            waitForRendering(shell);
++
++            keyClick(data.key, Qt.MetaModifier);
++            tryCompare(ApplicationManager, "focusedApplicationId", appId);
++        }
++
++        function test_altF1OpensLauncherForKeyboardNavigation() {
++            loadShell("desktop");
++            waitForRendering(shell);
++            var launcher = findChild(shell, "launcher");
++
++            keyClick(Qt.Key_F1, Qt.AltModifier);
++            tryCompare(launcher, "state", "visible");
++            tryCompare(launcher, "focus", true)
++        }
++
++        function test_lockedOutLauncherAddsMarginsToMaximized() {
++            loadShell("desktop");
++            shell.usageScenario = "desktop";
++            waitForRendering(shell);
++            var appContainer = findChild(shell, "appContainer");
++            var launcher = findChild(shell, "launcher");
++
++            var app = ApplicationManager.startApplication("music-app");
++            waitUntilAppWindowIsFullyLoaded(app);
++            var appDelegate = findChild(appContainer, "appDelegate_music-app");
++            appDelegate.maximize();
++            tryCompare(appDelegate, "visuallyMaximized", true);
++            waitForRendering(shell);
++
++            GSettingsController.setAutohideLauncher(true);
++            waitForRendering(shell)
++            var hiddenSize = appDelegate.width;
++
++            GSettingsController.setAutohideLauncher(false);
++            waitForRendering(shell)
++            var shownSize = appDelegate.width;
++
++            compare(shownSize + launcher.panelWidth, hiddenSize);
++        }
++
++        function test_fullscreenAppHidesLockedOutLauncher() {
++            loadShell("desktop");
++            shell.usageScenario = "desktop";
++
++            var launcher = findChild(shell, "launcher");
++            var launcherPanel = findChild(launcher, "launcherPanel");
++
++            GSettingsController.setAutohideLauncher(false);
++            waitForRendering(shell)
++
++            tryCompare(launcher, "lockedVisible", true);
++
++            var cameraApp = ApplicationManager.startApplication("camera-app");
++            waitUntilAppWindowIsFullyLoaded(cameraApp);
++
++            tryCompare(launcher, "lockedVisible", false);
++        }
++
++
          function test_inputEventsOnEdgesEndUpInAppSurface_data() {
              return [
                  { tag: "phone", repeaterName: "spreadRepeater" },