Unity 8

Merge lp:~mzanetti/unity8/tune-right-edge-push into lp:unity8

tune-right-edge-push
Merge into trunk

Proposed by Michael Zanetti on 2016-11-22

Status:

Superseded

Proposed branch:

lp:~mzanetti/unity8/tune-right-edge-push

Merge into:

lp:unity8

Diff against target:

3039 lines (+1686/-421)

50 files modified

data/com.canonical.Unity8.gschema.xml (+2/-2)
debian/control (+3/-1)
plugins/Greeter/Unity/Launcher/CMakeLists.txt (+1/-1)
plugins/Greeter/Unity/Launcher/launcheritem.cpp (+13/-0)
plugins/Greeter/Unity/Launcher/launcheritem.h (+3/-0)
plugins/Unity/Launcher/CMakeLists.txt (+4/-1)
plugins/Unity/Launcher/appdrawermodel.cpp (+62/-0)
plugins/Unity/Launcher/appdrawermodel.h (+33/-0)
plugins/Unity/Launcher/launcheritem.cpp (+13/-0)
plugins/Unity/Launcher/launcheritem.h (+4/-0)
plugins/Unity/Launcher/launchermodel.cpp (+6/-37)
plugins/Unity/Launcher/launchermodel.h (+0/-14)
plugins/Unity/Launcher/plugin.cpp (+2/-1)
plugins/Unity/Launcher/ualwrapper.cpp (+73/-0)
plugins/Unity/Launcher/ualwrapper.h (+35/-0)
plugins/Utils/CMakeLists.txt (+4/-0)
plugins/Utils/appdrawerproxymodel.cpp (+189/-0)
plugins/Utils/appdrawerproxymodel.h (+87/-0)
plugins/Utils/plugin.cpp (+2/-0)
qml/Components/KeyboardShortcutsOverlay.qml (+13/-0)
qml/Launcher/BackgroundBlur.qml (+81/-0)
qml/Launcher/Drawer.qml (+306/-0)
qml/Launcher/DrawerGridView.qml (+47/-0)
qml/Launcher/DrawerListView.qml (+32/-0)
qml/Launcher/Launcher.qml (+173/-31)
qml/Launcher/MoreAppsHeader.qml (+46/-0)
qml/Shell.qml (+10/-34)
qml/Stage/Spread/WindowedRightEdgeMaths.qml (+19/-4)
qml/Stage/Stage.qml (+4/-6)
qml/Stage/StageMaths.qml (+2/-7)
qml/Tutorial/TutorialLeftLong.qml (+1/-1)
tests/mocks/Unity/Launcher/CMakeLists.txt (+5/-1)
tests/mocks/Unity/Launcher/MockAppDrawerModel.cpp (+75/-0)
tests/mocks/Unity/Launcher/MockAppDrawerModel.h (+32/-0)
tests/mocks/Unity/Launcher/MockLauncherItem.cpp (+13/-0)
tests/mocks/Unity/Launcher/MockLauncherItem.h (+6/-0)
tests/mocks/Unity/Launcher/MockLauncherModel.cpp (+3/-0)
tests/mocks/Unity/Launcher/plugin.cpp (+4/-0)
tests/mocks/Utils/CMakeLists.txt (+4/-0)
tests/mocks/Utils/plugin.cpp (+2/-0)
tests/plugins/Greeter/Unity/Launcher/CMakeLists.txt (+1/-1)
tests/plugins/Unity/Launcher/CMakeLists.txt (+2/-1)
tests/qmltests/CMakeLists.txt (+1/-0)
tests/qmltests/Dash/tst_DashShell.qml (+0/-29)
tests/qmltests/Launcher/tst_Drawer.qml (+264/-0)
tests/qmltests/Launcher/tst_Launcher.qml (+1/-1)
tests/qmltests/Stage/tst_PhoneStage.qml (+0/-26)
tests/qmltests/tst_OrientedShell.qml (+1/-13)
tests/qmltests/tst_Shell.qml (+2/-143)
tests/qmltests/tst_ShellWithPin.qml (+0/-66)

To merge this branch:

bzr merge lp:~mzanetti/unity8/tune-right-edge-push

Related bugs:

Bug #1604062: too easy to trigger the apps switcher / spread on desktop	Undecided	Fix Released
Bug #1646094: [M10 FHD / HD] Multi-task is displayed too quickly when you approximate pointer to right side in desktop mode.	Undecided	Confirmed

Link a bug report

Reviewer	Review Type	Date Requested	Status
Unity8 CI Bot	continuous-integration		Approve on 2016-11-28
Albert Astals Cid (community)		2016-11-22	Approve on 2016-11-28
Review via email: mp+311536@code.launchpad.net

This proposal has been superseded by a proposal from 2016-12-06.

Commit message

tune right edge push

make it less intrusive when accidentally hitting the edge with the mouse
tweak visuals for the mouse case

Description of the change

* Are there any related MPs required for this MP to build/function as expected? Please list.
no
* Did you perform an exploratory manual test run of your code change and any related functionality?
yes
* If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
no
* If you changed the UI, has there been a design review?
Showed a video to Vesa, he likes it. Added him as reviewer for confirmation

lp:~mzanetti/unity8/tune-right-edge-push updated on 2016-11-22

2704. By Michael Zanetti on 2016-11-30: tune right edge push as per design request

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-22:

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

review: Approve (continuous-integration)

Revision history for this message

Albert Astals Cid (aacid) wrote on 2016-11-28:

Feels better, but please make progress a readonly property.

review: Needs Fixing

lp:~mzanetti/unity8/tune-right-edge-push updated on 2016-11-28

2705. By Michael Zanetti on 2016-11-28: make property readonly

Revision history for this message

Albert Astals Cid (aacid) wrote on 2016-11-28:

* 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

review: Approve

Revision history for this message

Unity8 CI Bot (unity8-ci-bot) wrote on 2016-11-28:

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

review: Approve (continuous-integration)

lp:~mzanetti/unity8/tune-right-edge-push updated on 2016-12-06

2706. By Michael Zanetti on 2016-12-06: merge appdrawer as prereq

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:

Michael Zanetti

Mohammad Rakibul Hasan

Unity Team

 === modified file 'data/com.canonical.Unity8.gschema.xml'
 --- data/com.canonical.Unity8.gschema.xml	2016-11-16 05:54:50 +0000
 +++ data/com.canonical.Unity8.gschema.xml	2016-12-06 13:47:05 +0000
@@ -12,7 +12,7 @@
        <description>The usage mode chosen will affect the Window Management behaviour.</description>
      </key>
      <key type="y" name="edge-barrier-sensitivity">
--      <default>35</default>
++      <default>50</default>
        <range min="1" max="100"/>
        <summary>Sensitivity of screen edge barriers for the mouse pointer.</summary>
        <description>Some UI actions like revealing the launcher or the applications spread are triggered by pushing the mouse pointer against a screen edge. This key defines how much you have to push in order to trigger the associated action.</description>
@@ -23,7 +23,7 @@
        <description>How much you have to push  (in grid units)the mouse against an edge barrier when sensibility is 100.</description>
      </key>
      <key type="u" name="edge-barrier-max-push">
--      <default>60</default>
++      <default>120</default>
        <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>
 === modified file 'debian/control'
 --- debian/control	2016-11-29 09:40:16 +0000
 +++ debian/control	2016-12-06 13:47:05 +0000
@@ -38,7 +38,7 @@
                 libubuntugestures5-private-dev (>= 1.3.2030),
                 libudev-dev,
                 libudm-common-dev,
--               libunity-api-dev (>= 7.120),
++               libunity-api-dev (>= 7.121),
                 libusermetricsoutput1-dev,
  # Need those X11 libs touch emulation from mouse events in manual QML tests on a X11 desktop
                 libx11-dev[!arm64 !armhf],
@@ -49,6 +49,7 @@
                 python3-all:any,
                 python3-setuptools,
                 qml-module-qt-labs-folderlistmodel,
++               qml-module-qt-labs-settings,
                 qml-module-qtqml-statemachine,
                 qml-module-qtmultimedia (>= 5.4.1-1ubuntu19~overlay2),
                 qml-module-qtquick-layouts,
@@ -122,6 +123,7 @@
           qmenumodel-qml (>= 0.2.10),
           qml-module-biometryd,
           qml-module-qt-labs-folderlistmodel,
++         qml-module-qt-labs-settings,
           qml-module-qtqml-statemachine,
           qml-module-qtquick-xmllistmodel,
           qml-module-qtsysteminfo,
 === modified file 'plugins/Greeter/Unity/Launcher/CMakeLists.txt'
 --- plugins/Greeter/Unity/Launcher/CMakeLists.txt	2016-10-28 12:08:59 +0000
 +++ plugins/Greeter/Unity/Launcher/CMakeLists.txt	2016-12-06 13:47:05 +0000
@@ -1,4 +1,4 @@
--pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=10)
++pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=11)
  pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
  add_definitions(-DSM_BUSNAME=systemBus)
 === modified file 'plugins/Greeter/Unity/Launcher/launcheritem.cpp'
 --- plugins/Greeter/Unity/Launcher/launcheritem.cpp	2016-05-10 16:23:34 +0000
 +++ plugins/Greeter/Unity/Launcher/launcheritem.cpp	2016-12-06 13:47:05 +0000
@@ -76,6 +76,19 @@
+     }
+ }
++QStringList LauncherItem::keywords() const
++{
++    return m_keywords;
++}
++
++void LauncherItem::setKeywords(const QStringList &keywords)
++{
++    if (m_keywords != keywords) {
++        m_keywords = keywords;
++        Q_EMIT keywordsChanged(keywords);
++    }
++}
++
  bool LauncherItem::pinned() const
+ {
      return m_pinned;
 === modified file 'plugins/Greeter/Unity/Launcher/launcheritem.h'
 --- plugins/Greeter/Unity/Launcher/launcheritem.h	2016-05-10 15:51:00 +0000
 +++ plugins/Greeter/Unity/Launcher/launcheritem.h	2016-12-06 13:47:05 +0000
@@ -34,6 +34,7 @@
      QString appId() const override;
      QString name() const override;
      QString icon() const override;
++    QStringList keywords() const override;
      bool pinned() const override;
      bool running() const override;
      bool recent() const override;
@@ -49,6 +50,7 @@
  private:
      void setName(const QString &name);
      void setIcon(const QString &icon);
++    void setKeywords(const QStringList &keywords);
      void setPinned(bool pinned);
      void setRunning(bool running);
      void setRecent(bool recent);
@@ -63,6 +65,7 @@
      QString m_appId;
      QString m_name;
      QString m_icon;
++    QStringList m_keywords;
      bool m_pinned;
      bool m_running;
      bool m_recent;
 === modified file 'plugins/Unity/Launcher/CMakeLists.txt'
 --- plugins/Unity/Launcher/CMakeLists.txt	2016-10-28 12:08:59 +0000
 +++ plugins/Unity/Launcher/CMakeLists.txt	2016-12-06 13:47:05 +0000
@@ -1,4 +1,4 @@
--pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=10)
++pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=11)
  pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
  add_definitions(-DSM_BUSNAME=systemBus)
@@ -25,6 +25,8 @@
      dbusinterface.cpp
      gsettings.cpp
      asadapter.cpp
++    appdrawermodel.cpp
++    ualwrapper.cpp
      ${CMAKE_SOURCE_DIR}/plugins/AccountsService/AccountsServiceDBusAdaptor.cpp
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h
@@ -32,6 +34,7 @@
      ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/LauncherItemInterface.h
      ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/LauncherModelInterface.h
      ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/QuickListModelInterface.h
++    ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/AppDrawerModelInterface.h
+     )
  add_library(UnityLauncher-qml MODULE
 === added file 'plugins/Unity/Launcher/appdrawermodel.cpp'
 --- plugins/Unity/Launcher/appdrawermodel.cpp	1970-01-01 00:00:00 +0000
 +++ plugins/Unity/Launcher/appdrawermodel.cpp	2016-12-06 13:47:05 +0000
@@ -0,0 +1,62 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "appdrawermodel.h"
++#include "ualwrapper.h"
++
++#include <QDebug>
++#include <QDateTime>
++
++AppDrawerModel::AppDrawerModel(QObject *parent):
++    AppDrawerModelInterface(parent)
++{
++    Q_FOREACH (const QString &appId, UalWrapper::installedApps()) {
++        UalWrapper::AppInfo info = UalWrapper::getApplicationInfo(appId);
++        if (!info.valid) {
++            qWarning() << "Failed to get app info for app" << appId;
++            continue;
++        }
++        m_list.append(new LauncherItem(appId, info.name, info.icon, this));
++        m_list.last()->setKeywords(info.keywords);
++    }
++    qsrand(QDateTime::currentMSecsSinceEpoch() / 100);
++}
++
++int AppDrawerModel::rowCount(const QModelIndex &parent) const
++{
++    Q_UNUSED(parent)
++    return m_list.count();
++}
++
++QVariant AppDrawerModel::data(const QModelIndex &index, int role) const
++{
++    switch (role) {
++    case RoleAppId:
++        return m_list.at(index.row())->appId();
++    case RoleName:
++        return m_list.at(index.row())->name();
++    case RoleIcon:
++        return m_list.at(index.row())->icon();
++    case RoleKeywords:
++        return m_list.at(index.row())->keywords();
++    case RoleUsage:
++        // FIXME: u-a-l needs to provide API for usage stats.
++        // don't forget to drop the qsrand() call in the ctor when dropping this.
++        return qrand();
++    }
++
++    return QVariant();
++}
 === added file 'plugins/Unity/Launcher/appdrawermodel.h'
 --- plugins/Unity/Launcher/appdrawermodel.h	1970-01-01 00:00:00 +0000
 +++ plugins/Unity/Launcher/appdrawermodel.h	2016-12-06 13:47:05 +0000
@@ -0,0 +1,33 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++
++#include <unity/shell/launcher/AppDrawerModelInterface.h>
++
++#include "launcheritem.h"
++
++class AppDrawerModel: public AppDrawerModelInterface
++{
++    Q_OBJECT
++public:
++    AppDrawerModel(QObject* parent = nullptr);
++
++    int rowCount(const QModelIndex &parent) const override;
++    QVariant data(const QModelIndex &index, int role) const override;
++
++private:
++    QList<LauncherItem*> m_list;
++};
 === modified file 'plugins/Unity/Launcher/launcheritem.cpp'
 --- plugins/Unity/Launcher/launcheritem.cpp	2016-10-28 11:54:16 +0000
 +++ plugins/Unity/Launcher/launcheritem.cpp	2016-12-06 13:47:05 +0000
@@ -90,6 +90,19 @@
+     }
+ }
++QStringList LauncherItem::keywords() const
++{
++    return m_keywords;
++}
++
++void LauncherItem::setKeywords(const QStringList &keywords)
++{
++    if (m_keywords != keywords) {
++        m_keywords = keywords;
++        Q_EMIT keywordsChanged(keywords);
++    }
++}
++
  bool LauncherItem::pinned() const
+ {
      return m_pinned;
 === modified file 'plugins/Unity/Launcher/launcheritem.h'
 --- plugins/Unity/Launcher/launcheritem.h	2016-05-10 15:51:00 +0000
 +++ plugins/Unity/Launcher/launcheritem.h	2016-12-06 13:47:05 +0000
@@ -37,6 +37,7 @@
      QString appId() const override;
      QString name() const override;
      QString icon() const override;
++    QStringList keywords() const override;
      bool pinned() const override;
      bool running() const override;
      bool recent() const override;
@@ -52,6 +53,7 @@
  private:
      void setName(const QString &name);
      void setIcon(const QString &icon);
++    void setKeywords(const QStringList &keywords);
      void setPinned(bool pinned);
      void setRunning(bool running);
      void setRecent(bool recent);
@@ -66,6 +68,7 @@
      QString m_appId;
      QString m_name;
      QString m_icon;
++    QStringList m_keywords;
      bool m_pinned;
      bool m_running;
      bool m_recent;
@@ -79,6 +82,7 @@
      QuickListEntry m_quitAction;
      friend class LauncherModel;
++    friend class AppDrawerModel;
  };
  #endif // LAUNCHERITEM_H
 === modified file 'plugins/Unity/Launcher/launchermodel.cpp'
 --- plugins/Unity/Launcher/launchermodel.cpp	2016-09-23 15:10:26 +0000
 +++ plugins/Unity/Launcher/launchermodel.cpp	2016-12-06 13:47:05 +0000
@@ -19,18 +19,14 @@
  #include "gsettings.h"
  #include "dbusinterface.h"
  #include "asadapter.h"
++#include "ualwrapper.h"
--#include <ubuntu-app-launch/appid.h>
--#include <ubuntu-app-launch/application.h>
--#include <ubuntu-app-launch/registry.h>
  #include <unity/shell/application/ApplicationInfoInterface.h>
  #include <unity/shell/application/MirSurfaceListInterface.h>
  #include <QDesktopServices>
  #include <QDebug>
--namespace ual = ubuntu::app_launch;
--
  using namespace unity::shell::application;
  LauncherModel::LauncherModel(QObject *parent):
@@ -38,8 +34,7 @@
      m_settings(new GSettings(this)),
      m_dbusIface(new DBusInterface(this)),
      m_asAdapter(new ASAdapter()),
--    m_appManager(nullptr),
--    m_ualRegistry(std::make_shared<ual::Registry>())
++    m_appManager(nullptr)
+ {
      connect(m_dbusIface, &DBusInterface::countChanged, this, &LauncherModel::countChanged);
      connect(m_dbusIface, &DBusInterface::countVisibleChanged, this, &LauncherModel::countVisibleChanged);
@@ -159,7 +154,7 @@
              index = m_list.count();
+         }
--        auto appInfo = getApplicationInfo(appId);
++        UalWrapper::AppInfo appInfo = UalWrapper::getApplicationInfo(appId);
          if (!appInfo.valid) {
              qWarning() << "Can't pin application, appId not found:" << appId;
              return;
@@ -335,32 +330,6 @@
      return -1;
+ }
--LauncherModel::AppInfo LauncherModel::getApplicationInfo(const QString &appId)
--{
--    AppInfo info;
--
--    ual::AppID ualAppId = ual::AppID::find(m_ualRegistry, appId.toStdString());
--    if (ualAppId.empty()) {
--        return info;
--    }
--
--    std::shared_ptr<ual::Application> ualApp;
--    try
--    {
--        ualApp = ual::Application::create(ualAppId, m_ualRegistry);
--    }
--    catch (std::runtime_error &e)
--    {
--        qWarning() << "Couldn't find application info for" << appId << "-" << e.what();
--        return info;
--    }
--
--    info.valid = true;
--    info.name = QString::fromStdString(ualApp->info()->name());
--    info.icon = QString::fromStdString(ualApp->info()->iconPath());
--    return info;
--}
--
  void LauncherModel::progressChanged(const QString &appId, int progress)
+ {
      const int idx = findApplication(appId);
@@ -408,7 +377,7 @@
+         }
      } else {
          // Need to create a new LauncherItem and show the highlight
--        auto appInfo = getApplicationInfo(appId);
++        UalWrapper::AppInfo appInfo = UalWrapper::getApplicationInfo(appId);
          if (countVisible && appInfo.valid) {
              LauncherItem *item = new LauncherItem(appId,
                                                    appInfo.name,
@@ -428,7 +397,7 @@
      // First walk through all the existing items and see if we need to remove something
      QList<LauncherItem*> toBeRemoved;
      Q_FOREACH (LauncherItem* item, m_list) {
--        auto appInfo = getApplicationInfo(item->appId());
++        UalWrapper::AppInfo appInfo = UalWrapper::getApplicationInfo(item->appId());
          if (!appInfo.valid) {
              // Application no longer available => drop it!
              toBeRemoved << item;
@@ -480,7 +449,7 @@
          if (itemIndex == -1) {
              // Need to add it. Just add it into the addedIndex to keep same ordering as the list
              // in the settings.
--            auto appInfo = getApplicationInfo(entry);
++            UalWrapper::AppInfo appInfo = UalWrapper::getApplicationInfo(entry);
              if (!appInfo.valid) {
                  continue;
+             }
 === modified file 'plugins/Unity/Launcher/launchermodel.h'
 --- plugins/Unity/Launcher/launchermodel.h	2016-09-23 14:44:26 +0000
 +++ plugins/Unity/Launcher/launchermodel.h	2016-12-06 13:47:05 +0000
@@ -27,12 +27,6 @@
  class DBusInterface;
  class ASAdapter;
--namespace ubuntu {
--    namespace app_launch {
--        class Registry;
--    }
--}
--
  using namespace unity::shell::launcher;
  using namespace unity::shell::application;
@@ -73,13 +67,6 @@
      void unpin(const QString &appId);
--    struct AppInfo {
--        bool valid = false;
--        QString name;
--        QString icon;
--    };
--    AppInfo getApplicationInfo(const QString &appId);
--
  private Q_SLOTS:
      void countChanged(const QString &appId, int count);
      void countVisibleChanged(const QString &appId, bool count);
@@ -98,7 +85,6 @@
      ASAdapter *m_asAdapter;
      ApplicationManagerInterface *m_appManager;
--    std::shared_ptr<ubuntu::app_launch::Registry> m_ualRegistry;
      friend class LauncherModelTest;
  };
 === modified file 'plugins/Unity/Launcher/plugin.cpp'
 --- plugins/Unity/Launcher/plugin.cpp	2015-09-14 09:11:08 +0000
 +++ plugins/Unity/Launcher/plugin.cpp	2016-12-06 13:47:05 +0000
@@ -26,7 +26,7 @@
  // local
  #include "launchermodel.h"
  #include "launcheritem.h"
--
++#include "appdrawermodel.h"
  using namespace unity::shell::launcher;
@@ -46,4 +46,5 @@
      qmlRegisterSingletonType<LauncherModel>(uri, 0, 1, "LauncherModel", modelProvider);
      qmlRegisterUncreatableType<LauncherItem>(uri, 0, 1, "LauncherItem", QStringLiteral("Can't create new Launcher Items in QML. Get them from the LauncherModel."));
      qmlRegisterUncreatableType<QuickListModel>(uri, 0, 1, "QuickListModel", QStringLiteral("Can't create a QuickListModel in QML. Get them from the LauncherItems."));
++    qmlRegisterType<AppDrawerModel>(uri, 0, 1, "AppDrawerModel");
+ }
 === added file 'plugins/Unity/Launcher/ualwrapper.cpp'
 --- plugins/Unity/Launcher/ualwrapper.cpp	1970-01-01 00:00:00 +0000
 +++ plugins/Unity/Launcher/ualwrapper.cpp	2016-12-06 13:47:05 +0000
@@ -0,0 +1,73 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include <QDebug>
++
++#include "ualwrapper.h"
++
++#include <ubuntu-app-launch/registry.h>
++using namespace ubuntu::app_launch;
++
++UalWrapper::UalWrapper(QObject *parent):
++    QObject(parent)
++{
++
++}
++
++QStringList UalWrapper::installedApps()
++{
++    QStringList appIds;
++    try {
++        for (const std::shared_ptr<Application> &app : Registry::installedApps()) {
++            if (!app->appId().package.value().empty()) {
++                appIds << QString::fromStdString(app->appId().package.value() + "_" + app->appId().appname.value());
++            } else {
++                appIds << QString::fromStdString(app->appId().appname);
++            }
++        }
++    } catch (const std::runtime_error &e) {
++        qWarning() << "ubuntu-all-launch threw an exception listing apps:" << e.what();
++    }
++
++    return appIds;
++}
++
++UalWrapper::AppInfo UalWrapper::getApplicationInfo(const QString &appId)
++{
++    AppInfo info;
++
++    try {
++        AppID ualAppId = AppID::find(appId.toStdString());
++        if (ualAppId.empty()) {
++            qWarning() << "Empty ualAppId result for" << appId;
++            return info;
++        }
++
++        std::shared_ptr<Application> ualApp;
++        ualApp = Application::create(ualAppId, Registry::getDefault());
++
++        info.name = QString::fromStdString(ualApp->info()->name());
++        info.icon = QString::fromStdString(ualApp->info()->iconPath());
++        for (const std::string &keyword : ualApp->info()->keywords().value()) {
++            info.keywords << QString::fromStdString(keyword);
++        }
++        info.valid = true;
++    } catch (const std::runtime_error &e) {
++        qWarning() << "ubuntu-app-launch threw an exception getting app info for appId:" << appId << ":" << e.what();
++    }
++
++    return info;
++}
 === added file 'plugins/Unity/Launcher/ualwrapper.h'
 --- plugins/Unity/Launcher/ualwrapper.h	1970-01-01 00:00:00 +0000
 +++ plugins/Unity/Launcher/ualwrapper.h	2016-12-06 13:47:05 +0000
@@ -0,0 +1,35 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include <QObject>
++
++class UalWrapper: public QObject
++{
++    Q_OBJECT
++public:
++    struct AppInfo {
++        bool valid = false;
++        QString name;
++        QString icon;
++        QStringList keywords;
++    };
++
++    UalWrapper(QObject* parent = nullptr);
++
++    static QStringList installedApps();
++    static AppInfo getApplicationInfo(const QString &appId);
++
++};
 === modified file 'plugins/Utils/CMakeLists.txt'
 --- plugins/Utils/CMakeLists.txt	2016-06-29 18:05:44 +0000
 +++ plugins/Utils/CMakeLists.txt	2016-12-06 13:47:05 +0000
@@ -15,6 +15,10 @@
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h
      applicationsfiltermodel.cpp
++    ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/AppDrawerModelInterface.h
++    ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/LauncherItemInterface.h
++    ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/LauncherModelInterface.h
++    appdrawerproxymodel.cpp
      constants.cpp
      WindowInputMonitor.cpp
      inputwatcher.cpp
 === added file 'plugins/Utils/appdrawerproxymodel.cpp'
 --- plugins/Utils/appdrawerproxymodel.cpp	1970-01-01 00:00:00 +0000
 +++ plugins/Utils/appdrawerproxymodel.cpp	2016-12-06 13:47:05 +0000
@@ -0,0 +1,189 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "appdrawerproxymodel.h"
++
++#include <unity/shell/launcher/LauncherItemInterface.h>
++
++#include <QDebug>
++
++AppDrawerProxyModel::AppDrawerProxyModel(QObject *parent):
++    QSortFilterProxyModel(parent)
++{
++    setSortRole(AppDrawerModelInterface::RoleName);
++    setSortLocaleAware(true);
++    sort(0);
++
++    connect(this, &QAbstractListModel::rowsInserted, this, &AppDrawerProxyModel::countChanged);
++    connect(this, &QAbstractListModel::rowsRemoved, this, &AppDrawerProxyModel::countChanged);
++    connect(this, &QAbstractListModel::layoutChanged, this, &AppDrawerProxyModel::countChanged);
++}
++
++QAbstractItemModel *AppDrawerProxyModel::source() const
++{
++    return m_source;
++}
++
++void AppDrawerProxyModel::setSource(QAbstractItemModel *source)
++{
++    if (m_source != source) {
++        m_source = source;
++        setSourceModel(m_source);
++        setSortRole(m_sortBy == SortByAToZ ? AppDrawerModelInterface::RoleName : AppDrawerModelInterface::RoleUsage);
++        connect(m_source, &QAbstractItemModel::rowsRemoved, this, &AppDrawerProxyModel::invalidateFilter);
++        connect(m_source, &QAbstractItemModel::rowsInserted, this, &AppDrawerProxyModel::invalidateFilter);
++        Q_EMIT sourceChanged();
++    }
++}
++
++AppDrawerProxyModel::GroupBy AppDrawerProxyModel::group() const
++{
++    return m_group;
++}
++
++void AppDrawerProxyModel::setGroup(AppDrawerProxyModel::GroupBy group)
++{
++    if (m_group != group) {
++        m_group = group;
++        Q_EMIT groupChanged();
++        invalidateFilter();
++    }
++}
++
++QString AppDrawerProxyModel::filterLetter() const
++{
++    return m_filterLetter;
++}
++
++void AppDrawerProxyModel::setFilterLetter(const QString &filterLetter)
++{
++    if (m_filterLetter != filterLetter) {
++        m_filterLetter = filterLetter;
++        Q_EMIT filterLetterChanged();
++        invalidateFilter();
++    }
++}
++
++QString AppDrawerProxyModel::filterString() const
++{
++    return m_filterString;
++}
++
++void AppDrawerProxyModel::setFilterString(const QString &filterString)
++{
++    if (m_filterString != filterString) {
++        m_filterString = filterString;
++        Q_EMIT filterStringChanged();
++        invalidateFilter();
++    }
++}
++
++AppDrawerProxyModel::SortBy AppDrawerProxyModel::sortBy() const
++{
++    return m_sortBy;
++}
++
++void AppDrawerProxyModel::setSortBy(AppDrawerProxyModel::SortBy sortBy)
++{
++    if (m_sortBy != sortBy) {
++        m_sortBy = sortBy;
++        Q_EMIT sortByChanged();
++        setSortRole(m_sortBy == SortByAToZ ? AppDrawerModelInterface::RoleName : AppDrawerModelInterface::RoleUsage);
++        sort(0);
++    }
++}
++
++int AppDrawerProxyModel::count() const
++{
++    return rowCount();
++}
++
++QVariant AppDrawerProxyModel::data(const QModelIndex &index, int role) const
++{
++    QModelIndex idx = mapToSource(index);
++    if (role == Qt::UserRole) {
++        QString name = m_source->data(idx, AppDrawerModelInterface::RoleName).toString();
++        return name.length() > 0 ? QString(name.at(0)).toUpper() : QChar();
++    }
++    return m_source->data(idx, role);
++}
++
++QHash<int, QByteArray> AppDrawerProxyModel::roleNames() const
++{
++    if (m_source) {
++        QHash<int, QByteArray> roles = m_source->roleNames();
++        roles.insert(Qt::UserRole, "letter");
++        return roles;
++    }
++    return QHash<int, QByteArray>();
++}
++
++bool AppDrawerProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const
++{
++    Q_UNUSED(source_parent)
++
++    if (m_group == GroupByAToZ && source_row > 0) {
++        QString currentName = m_source->data(m_source->index(source_row, 0), AppDrawerModelInterface::RoleName).toString();
++        QChar currentLetter = currentName.length() > 0 ? currentName.at(0) : QChar();
++        QString previousName = m_source->data(m_source->index(source_row - 1,0 ), AppDrawerModelInterface::RoleName).toString();
++        QChar previousLetter = previousName.length() > 0 ? previousName.at(0) : QChar();
++        if (currentLetter.toLower() == previousLetter.toLower()) {
++            return false;
++        }
++    } else if(m_group == GroupByAll && source_row > 0) {
++        return false;
++    }
++    if (!m_filterLetter.isEmpty()) {
++        QString currentName = m_source->data(m_source->index(source_row, 0), AppDrawerModelInterface::RoleName).toString();
++        QString currentLetter = currentName.length() > 0 ? QString(currentName.at(0)) : QString();
++        if (currentLetter.toLower() != m_filterLetter.toLower()) {
++            return false;
++        }
++    }
++    if (!m_filterString.isEmpty()) {
++        QStringList allWords = m_source->data(m_source->index(source_row, 0), AppDrawerModelInterface::RoleKeywords).toStringList();
++        allWords.prepend(m_source->data(m_source->index(source_row, 0), AppDrawerModelInterface::RoleName).toString());
++        bool found = false;
++        Q_FOREACH (const QString currentWord, allWords) {
++            if (currentWord.toLower().startsWith(m_filterString.toLower())) {
++                found = true;
++                break;
++            }
++        }
++        if (!found) {
++            return false;
++        }
++    }
++    return true;
++}
++
++QString AppDrawerProxyModel::appId(int index) const
++{
++    if (index >= 0 && index < rowCount()) {
++        QModelIndex sourceIndex = mapToSource(this->index(index, 0));
++
++        AppDrawerModelInterface* adm = dynamic_cast<AppDrawerModelInterface*>(m_source);
++        if (adm) {
++            return adm->data(sourceIndex, AppDrawerModelInterface::RoleAppId).toString();
++        }
++
++        AppDrawerProxyModel* adpm = qobject_cast<AppDrawerProxyModel*>(m_source);
++        if (adpm) {
++            return adpm->appId(sourceIndex.row());
++        }
++    }
++    return nullptr;
++}
 === added file 'plugins/Utils/appdrawerproxymodel.h'
 --- plugins/Utils/appdrawerproxymodel.h	1970-01-01 00:00:00 +0000
 +++ plugins/Utils/appdrawerproxymodel.h	2016-12-06 13:47:05 +0000
@@ -0,0 +1,87 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include <QSortFilterProxyModel>
++
++#include <unity/shell/launcher/AppDrawerModelInterface.h>
++
++using namespace unity::shell::launcher;
++
++class AppDrawerProxyModel: public QSortFilterProxyModel
++{
++    Q_OBJECT
++    Q_ENUMS(GroupBy)
++    Q_ENUMS(SortBy)
++    Q_PROPERTY(QAbstractItemModel* source READ source WRITE setSource NOTIFY sourceChanged)
++    Q_PROPERTY(GroupBy group READ group WRITE setGroup NOTIFY groupChanged)
++    Q_PROPERTY(QString filterLetter READ filterLetter WRITE setFilterLetter NOTIFY filterLetterChanged)
++    Q_PROPERTY(QString filterString READ filterString WRITE setFilterString NOTIFY filterStringChanged)
++    Q_PROPERTY(SortBy sortBy READ sortBy WRITE setSortBy NOTIFY sortByChanged)
++    Q_PROPERTY(int count READ count NOTIFY countChanged)
++
++public:
++    enum GroupBy {
++        GroupByNone,
++        GroupByAll,
++        GroupByAToZ
++    };
++    enum SortBy {
++        SortByAToZ,
++        SortByUsage
++    };
++
++    AppDrawerProxyModel(QObject* parent = nullptr);
++
++    QAbstractItemModel* source() const;
++    void setSource(QAbstractItemModel* source);
++
++    GroupBy group() const;
++    void setGroup(GroupBy group);
++
++    QString filterLetter() const;
++    void setFilterLetter(const QString &filterLetter);
++
++    QString filterString() const;
++    void setFilterString(const QString &filterString);
++
++    SortBy sortBy() const;
++    void setSortBy(SortBy sortBy);
++
++    int count() const;
++
++    QVariant data(const QModelIndex &index, int role) const override;
++    QHash<int, QByteArray> roleNames() const override;
++
++    Q_INVOKABLE QString appId(int index) const;
++
++protected:
++    bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override;
++
++Q_SIGNALS:
++    void sourceChanged();
++    void groupChanged();
++    void filterLetterChanged();
++    void filterStringChanged();
++    void sortByChanged();
++    void countChanged();
++
++private:
++    QAbstractItemModel* m_source = nullptr;
++    GroupBy m_group = GroupByNone;
++    QString m_filterLetter;
++    QString m_filterString;
++    SortBy m_sortBy = SortByAToZ;
++};
 === modified file 'plugins/Utils/plugin.cpp'
 --- plugins/Utils/plugin.cpp	2016-06-28 20:38:00 +0000
 +++ plugins/Utils/plugin.cpp	2016-12-06 13:47:05 +0000
@@ -39,6 +39,7 @@
  #include "deviceconfigparser.h"
  #include "globalfunctions.h"
  #include "URLDispatcher.h"
++#include "appdrawerproxymodel.h"
  static QObject *createWindowStateStorage(QQmlEngine *engine, QJSEngine *scriptEngine)
+ {
@@ -82,4 +83,5 @@
      qmlRegisterType<DeviceConfigParser>(uri, 0, 1, "DeviceConfigParser");
      qmlRegisterSingletonType<GlobalFunctions>(uri, 0, 1, "Functions", createGlobalFunctions);
      qmlRegisterType<URLDispatcher>(uri, 0, 1, "URLDispatcher");
++    qmlRegisterType<AppDrawerProxyModel>(uri, 0, 1, "AppDrawerProxyModel");
+ }
 === modified file 'qml/Components/KeyboardShortcutsOverlay.qml'
 --- qml/Components/KeyboardShortcutsOverlay.qml	2016-05-11 11:09:42 +0000
 +++ qml/Components/KeyboardShortcutsOverlay.qml	2016-12-06 13:47:05 +0000
@@ -173,6 +173,19 @@
                      Layout.maximumWidth: maxTextSize
+                 }
++                Label {
++                    text: i18n.tr("Super + A")
++                    fontSize: "small"
++                    font.weight: Font.Medium
++                }
++                Label {
++                    text: i18n.tr("Opens the Application Drawer.")
++                    fontSize: "small"
++                    font.weight: Font.Light
++                    wrapMode: Text.Wrap
++                    Layout.maximumWidth: maxTextSize
++                }
++
                  // Scopes section
                  Item { Layout.columnSpan: 2; height: units.gu(2) }
 === added file 'qml/Launcher/BackgroundBlur.qml'
 --- qml/Launcher/BackgroundBlur.qml	1970-01-01 00:00:00 +0000
 +++ qml/Launcher/BackgroundBlur.qml	2016-12-06 13:47:05 +0000
@@ -0,0 +1,81 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.4
++import Ubuntu.Components 1.3
++import QtGraphicalEffects 1.0
++
++Item {
++    id: root
++
++    property int blurAmount: 32
++    property Item sourceItem
++    property rect blurRect: Qt.rect(0,0,0,0)
++    property alias cached: fastBlur.cached
++
++    Rectangle {
++        id: blurMask
++        color: "yellow"
++        x: blurRect.x
++        y: blurRect.y
++        width: blurRect.width
++        height: blurRect.height
++    }
++
++    ShaderEffect {
++        id: maskedBlurEffect
++        x: blurRect.x
++        y: blurRect.y
++        width: blurRect.width
++        height: blurRect.height
++
++        property variant source: ShaderEffectSource {
++            id: shaderEffectSource
++            sourceItem: root.sourceItem
++            hideSource: false
++            sourceRect: root.blurRect
++        }
++
++        property var mask: ShaderEffectSource {
++            sourceItem: blurMask
++            hideSource: true
++        }
++
++        fragmentShader: "
++            varying highp vec2 qt_TexCoord0;
++            uniform sampler2D source;
++            uniform sampler2D mask;
++            void main(void)
++            {
++                highp vec4 sourceColor = texture2D(source, qt_TexCoord0);
++                highp vec4 maskColor = texture2D(mask, qt_TexCoord0);
++
++                sourceColor *= maskColor.a;
++
++                gl_FragColor = sourceColor;
++            }"
++    }
++
++    FastBlur {
++        id: fastBlur
++        x: blurRect.x
++        y: blurRect.y
++        width: blurRect.width
++        height: blurRect.height
++        source: maskedBlurEffect
++        radius: Math.min(blurAmount, 128)
++    }
++ }
 === added file 'qml/Launcher/Drawer.qml'
 --- qml/Launcher/Drawer.qml	1970-01-01 00:00:00 +0000
 +++ qml/Launcher/Drawer.qml	2016-12-06 13:47:05 +0000
@@ -0,0 +1,306 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.4
++import Ubuntu.Components 1.3
++import Unity.Launcher 0.1
++import Utils 0.1
++import "../Components"
++import Qt.labs.settings 1.0
++
++FocusScope {
++    id: root
++
++    property int panelWidth: 0
++    readonly property bool moving: listLoader.item && listLoader.item.moving
++
++    signal applicationSelected(string appId)
++
++    property bool draggingHorizontally: false
++    property int dragDistance: 0
++
++    onFocusChanged: {
++        if (focus) {
++            searchField.selectAll();
++        }
++    }
++
++    function focusInput() {
++        searchField.selectAll();
++        searchField.focus = true;
++    }
++
++    Settings {
++        property alias selectedTab: sections.selectedIndex
++    }
++
++    MouseArea {
++        anchors.fill: parent
++        hoverEnabled: true
++        acceptedButtons: Qt.AllButtons
++        onWheel: wheel.accepted = true
++    }
++
++    Rectangle {
++        anchors.fill: parent
++        color: "#BF000000"
++
++        AppDrawerModel {
++            id: appDrawerModel
++        }
++
++        AppDrawerProxyModel {
++            id: sortProxyModel
++            source: appDrawerModel
++            filterString: searchField.displayText
++            sortBy: AppDrawerProxyModel.SortByAToZ
++        }
++
++        Item {
++            id: contentContainer
++            anchors.fill: parent
++            anchors.leftMargin: root.panelWidth
++
++            TextField {
++                id: searchField
++                anchors { left: parent.left; top: parent.top; right: parent.right; margins: units.gu(1) }
++                placeholderText: i18n.tr("Search…")
++                focus: true
++                onAccepted: {
++                    if (searchField.displayText != "" && listLoader.item && listLoader.item.currentItem) {
++                        root.applicationSelected(listLoader.item.getFirstAppId());
++                    }
++                }
++            }
++
++            Item {
++                id: sectionsContainer
++                anchors { left: parent.left; top: searchField.bottom; right: parent.right; }
++                height: sections.height
++                clip: true
++                z: 2
++
++                Sections {
++                    id: sections
++                    width: parent.width
++                    actions: [
++                        Action {
++                            text: i18n.ctr("Apps sorted alphabetically", "A-Z")
++                        // TODO: Disabling this for now as we don't get the right input from u-a-l yet.
++//                        },
++//                        Action {
++//                            text: i18n.ctr("Most used apps", "Most used")
++                        }
++                    ]
++
++                    Rectangle {
++                        anchors.bottom: parent.bottom
++                        height: units.dp(1)
++                        color: 'gray'
++                        width: contentContainer.width
++                    }
++                }
++            }
++
++            Loader {
++                id: listLoader
++                anchors { left: parent.left; top: sectionsContainer.bottom; right: parent.right; bottom: parent.bottom; leftMargin: units.gu(1); rightMargin: units.gu(1) }
++                sourceComponent: {
++                    switch (sections.selectedIndex) {
++                    case 0: return aToZComponent;
++                    case 1: return mostUsedComponent;
++                    }
++                }
++                Binding {
++                    target: listLoader.item || null
++                    property: "objectName"
++                    value: "drawerItemList"
++                }
++            }
++
++            MouseArea {
++                parent: listLoader.item ? listLoader.item : null
++                anchors.fill: parent
++                propagateComposedEvents: true
++                property int oldX: 0
++                onPressed: {
++                    oldX = mouseX;
++                }
++                onMouseXChanged: {
++                    var diff = oldX - mouseX;
++                    root.draggingHorizontally |= diff > units.gu(2);
++                    if (!root.draggingHorizontally) {
++                        return;
++                    }
++                    propagateComposedEvents = false;
++                    parent.interactive = false;
++                    root.dragDistance += diff;
++                    oldX = mouseX
++                }
++                onReleased: {
++                    if (root.draggingHorizontally) {
++                        root.draggingHorizontally = false;
++                        parent.interactive = true;
++                    }
++                    reactivateTimer.start();
++                }
++                Timer {
++                    id: reactivateTimer
++                    interval: 0
++                    onTriggered: parent.propagateComposedEvents = true;
++                }
++            }
++
++            Component {
++                id: mostUsedComponent
++                DrawerListView {
++
++                    header: MoreAppsHeader {
++                        width: parent.width
++                        height: units.gu(6)
++                    }
++
++                    model: AppDrawerProxyModel {
++                        source: sortProxyModel
++                        group: AppDrawerProxyModel.GroupByAll
++                        sortBy: AppDrawerProxyModel.SortByUsage
++                    }
++
++                    delegate: UbuntuShape {
++                        width: parent.width
++                        color: "#20ffffff"
++                        aspect: UbuntuShape.Flat
++                        // NOTE: Cannot use gridView.rows here as it would evaluate to 0 at first and only update later,
++                        // which messes up the ListView.
++                        height: (Math.ceil(mostUsedGridView.model.count / mostUsedGridView.columns) * mostUsedGridView.delegateHeight) + units.gu(2)
++
++                        readonly property string appId: model.appId
++
++                        DrawerGridView {
++                            id: mostUsedGridView
++                            anchors.fill: parent
++                            topMargin: units.gu(1)
++                            bottomMargin: units.gu(1)
++                            clip: true
++
++                            model: sortProxyModel
++
++                            delegateWidth: units.gu(8)
++                            delegateHeight: units.gu(10)
++                            delegate: drawerDelegateComponent
++                        }
++                    }
++                }
++            }
++
++            Component {
++                id: aToZComponent
++                DrawerListView {
++
++                    header: MoreAppsHeader {
++                        width: parent.width
++                        height: units.gu(6)
++                    }
++
++                    model: AppDrawerProxyModel {
++                        source: sortProxyModel
++                        sortBy: AppDrawerProxyModel.SortByAToZ
++                        group: AppDrawerProxyModel.GroupByAToZ
++                    }
++
++                    delegate: UbuntuShape {
++                        width: parent.width
++                        color: "#20ffffff"
++                        aspect: UbuntuShape.Flat
++
++                        readonly property string appId: model.appId
++
++                        // NOTE: Cannot use gridView.rows here as it would evaluate to 0 at first and only update later,
++                        // which messes up the ListView.
++                        height: (Math.ceil(gridView.model.count / gridView.columns) * gridView.delegateHeight) +
++                                categoryNameLabel.implicitHeight + units.gu(2)
++
++                        Label {
++                            id: categoryNameLabel
++                            anchors { left: parent.left; top: parent.top; right: parent.right; margins: units.gu(1) }
++                            text: model.letter
++                        }
++
++                        DrawerGridView {
++                            id: gridView
++                            anchors { left: parent.left; top: categoryNameLabel.bottom; right: parent.right; topMargin: units.gu(1) }
++                            height: rows * delegateHeight
++
++                            interactive: false
++
++                            model: AppDrawerProxyModel {
++                                id: categoryModel
++                                source: sortProxyModel
++                                filterLetter: model.letter
++                            }
++                            delegateWidth: units.gu(8)
++                            delegateHeight: units.gu(10)
++                            delegate: drawerDelegateComponent
++                        }
++                    }
++                }
++            }
++        }
++
++        Component {
++            id: drawerDelegateComponent
++            AbstractButton {
++                width: GridView.view.cellWidth
++                height: units.gu(10)
++                objectName: "drawerItem_" + model.appId
++
++                onClicked: root.applicationSelected(model.appId)
++
++                Column {
++                    width: units.gu(8)
++                    anchors.horizontalCenter: parent.horizontalCenter
++                    height: childrenRect.height
++                    spacing: units.gu(1)
++
++                    UbuntuShape {
++                        id: appIcon
++                        width: units.gu(6)
++                        height: 7.5 / 8 * width
++                        anchors.horizontalCenter: parent.horizontalCenter
++                        backgroundMode: UbuntuShape.SolidColor
++                        backgroundColor: UbuntuColors.lightGrey
++                        radius: "medium"
++                        borderSource: 'undefined'
++                        source: Image {
++                            id: sourceImage
++                            sourceSize.width: appIcon.width
++                            source: model.icon
++                        }
++                        sourceFillMode: UbuntuShape.PreserveAspectCrop
++                    }
++
++                    Label {
++                        text: model.name
++                        width: parent.width
++                        horizontalAlignment: Text.AlignHCenter
++                        fontSize: "small"
++                        elide: Text.ElideRight
++                    }
++                }
++            }
++        }
++    }
++}
 === added file 'qml/Launcher/DrawerGridView.qml'
 --- qml/Launcher/DrawerGridView.qml	1970-01-01 00:00:00 +0000
 +++ qml/Launcher/DrawerGridView.qml	2016-12-06 13:47:05 +0000
@@ -0,0 +1,47 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.4
++import "../Components"
++
++Item {
++    id: root
++
++    property int delegateWidth: units.gu(10)
++    property int delegateHeight: units.gu(10)
++    property alias delegate: gridView.delegate
++    property alias model: gridView.model
++    property alias interactive: gridView.interactive
++
++    property alias header: gridView.header
++    property alias topMargin: gridView.topMargin
++    property alias bottomMargin: gridView.bottomMargin
++
++    readonly property int columns: width / delegateWidth
++    readonly property int rows: Math.ceil(gridView.model.count / root.columns)
++
++    GridView {
++        id: gridView
++        anchors.fill: parent
++        leftMargin: spacing
++
++        readonly property int overflow: width - (root.columns * root.delegateWidth)
++        readonly property real spacing: overflow / (root.columns)
++
++        cellWidth: root.delegateWidth + spacing
++        cellHeight: root.delegateHeight
++    }
++}
 === added file 'qml/Launcher/DrawerListView.qml'
 --- qml/Launcher/DrawerListView.qml	1970-01-01 00:00:00 +0000
 +++ qml/Launcher/DrawerListView.qml	2016-12-06 13:47:05 +0000
@@ -0,0 +1,32 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.4
++import Ubuntu.Components 1.3
++import "../Components"
++
++ListView {
++    id: root
++    anchors.fill: parent
++    topMargin: units.gu(1)
++    bottomMargin: units.gu(1)
++    spacing: units.gu(1)
++    clip: true
++
++    function getFirstAppId() {
++        return model.appId(0);
++    }
++}
 === modified file 'qml/Launcher/Launcher.qml'
 --- qml/Launcher/Launcher.qml	2016-09-22 10:14:18 +0000
 +++ qml/Launcher/Launcher.qml	2016-12-06 13:47:05 +0000
@@ -27,10 +27,12 @@
      property bool lockedVisible: false
      property bool available: true // can be used to disable all interactions
      property alias inverted: panel.inverted
++    property Item blurSource: null
++    property int topPanelHeight: 0
++    property bool drawerEnabled: true
      property int panelWidth: units.gu(10)
      property int dragAreaWidth: units.gu(1)
--    property int minimizeDistance: units.gu(26)
      property real progress: dragArea.dragging && dragArea.touchPosition.x > panelWidth ?
                                  (width * (dragArea.touchPosition.x-panelWidth) / (width - panelWidth)) : 0
@@ -43,13 +45,11 @@
      readonly property alias shortcutHintsShown: panel.shortcutHintsShown
      readonly property bool shown: panel.x > -panel.width
++    readonly property bool drawerShown: drawer.x == 0
      // emitted when an application is selected
      signal launcherApplicationSelected(string appId)
--    // emitted when the apps dash should be shown because of a swipe gesture
--    signal dash()
--
      // emitted when the dash icon in the launcher has been tapped
      signal showDashHome()
@@ -62,6 +62,9 @@
+     }
      onSuperPressedChanged: {
++        if (state == "drawer")
++            return;
++
          if (superPressed) {
              superPressTimer.start();
              superLongPressTimer.start();
@@ -132,7 +135,7 @@
+     }
      function pushEdge(amount) {
--        if (root.state === "") {
++        if (root.state === "" || root.state == "visible" || root.state == "visibleTemporary") {
              edgeBarrier.push(amount);
+         }
+     }
@@ -143,6 +146,22 @@
          switchToNextState("visible")
+     }
++    function openDrawer(focusInputField) {
++        if (!drawerEnabled) {
++            return;
++        }
++
++        panel.shortcutHintsShown = false;
++        superPressTimer.stop();
++        superLongPressTimer.stop();
++        root.focus = true;
++        drawer.focus = true;
++        if (focusInputField) {
++            drawer.focusInput();
++        }
++        switchToNextState("drawer")
++    }
++
      Keys.onPressed: {
          switch (event.key) {
          case Qt.Key_Backtab:
@@ -278,7 +297,7 @@
      InverseMouseArea {
          id: closeMouseArea
          anchors.fill: panel
--        enabled: root.state == "visible" && (!root.lockedVisible || panel.highlightIndex >= -1)
++        enabled: root.state == "visible" || root.state == "drawer"
          visible: enabled
          onPressed: {
              mouse.accepted = false;
@@ -307,23 +326,61 @@
+         }
+     }
--    EdgeBarrier {
--        id: edgeBarrier
--        edge: Qt.LeftEdge
--        target: parent
--        enabled: root.available
--        onPassed: { root.switchToNextState("visibleTemporary"); }
--        material: Component {
--            Item {
--                Rectangle {
--                    width: parent.height
--                    height: parent.width
--                    rotation: -90
--                    anchors.centerIn: parent
--                    gradient: Gradient {
--                        GradientStop { position: 0.0; color: Qt.rgba(panel.color.r, panel.color.g, panel.color.b, .5)}
--                        GradientStop { position: 1.0; color: Qt.rgba(panel.color.r,panel.color.g,panel.color.b,0)}
--                    }
++    BackgroundBlur {
++        id: backgroundBlur
++        anchors.fill: parent
++        anchors.topMargin: root.inverted ? 0 : -root.topPanelHeight
++        visible: root.blurSource && drawer.x > -drawer.width
++        blurAmount: units.gu(6)
++        sourceItem: root.blurSource
++        blurRect: Qt.rect(panel.width,
++                          root.topPanelHeight,
++                          drawer.width + drawer.x - panel.width,
++                          height - root.topPanelHeight)
++        cached: drawer.moving
++    }
++
++    Drawer {
++        id: drawer
++        objectName: "drawer"
++        anchors {
++            top: parent.top
++            topMargin: root.inverted ? root.topPanelHeight : 0
++            bottom: parent.bottom
++            right: parent.left
++        }
++        width: Math.min(root.width, units.gu(90)) * .9
++        panelWidth: panel.width
++        visible: x > -width
++
++        Behavior on anchors.rightMargin {
++            enabled: !dragArea.dragging && !launcherDragArea.drag.active && panel.animate && !drawer.draggingHorizontally
++            NumberAnimation {
++                duration: 300
++                easing.type: Easing.OutCubic
++            }
++        }
++
++        onApplicationSelected: {
++            root.hide();
++            root.launcherApplicationSelected(appId)
++            root.focus = false;
++        }
++
++        Keys.onEscapePressed: {
++            switchToNextState("");
++            root.focus = false;
++        }
++
++        onDragDistanceChanged: {
++            anchors.rightMargin = Math.max(-drawer.width, anchors.rightMargin + dragDistance);
++        }
++        onDraggingHorizontallyChanged: {
++            if (!draggingHorizontally) {
++                if (drawer.x < -units.gu(10)) {
++                    root.hide();
++                } else {
++                    root.openDrawer();
+                 }
+             }
+         }
@@ -332,7 +389,7 @@
      LauncherPanel {
          id: panel
          objectName: "launcherPanel"
--        enabled: root.available && root.state == "visible" || root.state == "visibleTemporary"
++        enabled: root.available && (root.state == "visible" || root.state == "visibleTemporary" || root.state == "drawer")
          width: root.panelWidth
          anchors {
              top: parent.top
@@ -394,6 +451,38 @@
+         }
+     }
++    EdgeBarrier {
++        id: edgeBarrier
++        edge: Qt.LeftEdge
++        target: parent
++        enabled: root.available
++        onProgressChanged: {
++            if (progress > .5 && root.state != "visibleTemporary" && root.state != "drawer" && root.state != "visible") {
++                root.switchToNextState("visibleTemporary");
++            }
++        }
++        onPassed: {
++            if (root.drawerEnabled) {
++                root.switchToNextState("drawer");
++            }
++        }
++
++        material: Component {
++            Item {
++                Rectangle {
++                    width: parent.height
++                    height: parent.width
++                    rotation: -90
++                    anchors.centerIn: parent
++                    gradient: Gradient {
++                        GradientStop { position: 0.0; color: Qt.rgba(panel.color.r, panel.color.g, panel.color.b, .5)}
++                        GradientStop { position: 1.0; color: Qt.rgba(panel.color.r,panel.color.g,panel.color.b,0)}
++                    }
++                }
++            }
++        }
++    }
++
      SwipeArea {
          id: dragArea
          objectName: "launcherDragArea"
@@ -405,25 +494,62 @@
          width: root.dragAreaWidth
          height: root.height
++        function easeInOutCubic(t) { return t<.5 ? 4*t*t*t : (t-1)*(2*t-2)*(2*t-2)+1 }
++
++        property var lastDragPoints: []
++
++        function dragDirection() {
++            if (lastDragPoints.length < 5) {
++                return "unknown";
++            }
++
++            var toRight = true;
++            var toLeft = true;
++            for (var i = lastDragPoints.length - 5; i < lastDragPoints.length; i++) {
++                if (toRight && lastDragPoints[i] < lastDragPoints[i-1]) {
++                    toRight = false;
++                }
++                if (toLeft && lastDragPoints[i] > lastDragPoints[i-1]) {
++                    toLeft = false;
++                }
++            }
++            return toRight ? "right" : toLeft ? "left" : "unknown";
++        }
++
          onDistanceChanged: {
--            if (!dragging || launcher.state == "visible")
--                return;
++            if (dragging && launcher.state != "visible" && launcher.state != "drawer") {
++                panel.x = -panel.width + Math.min(Math.max(0, distance), panel.width);
++            }
--            panel.x = -panel.width + Math.min(Math.max(0, distance), panel.width);
++            if (root.drawerEnabled && dragging && launcher.state != "drawer") {
++                lastDragPoints.push(distance)
++                var drawerHintDistance = panel.width + units.gu(1)
++                if (distance < drawerHintDistance) {
++                    drawer.anchors.rightMargin = -Math.min(Math.max(0, distance), drawer.width);
++                } else {
++                    var linearDrawerX = Math.min(Math.max(0, distance - drawerHintDistance), drawer.width);
++                    var linearDrawerProgress = linearDrawerX / (drawer.width)
++                    var easedDrawerProgress = easeInOutCubic(linearDrawerProgress);
++                    drawer.anchors.rightMargin = -(drawerHintDistance + easedDrawerProgress * (drawer.width - drawerHintDistance));
++                }
++            }
+         }
          onDraggingChanged: {
              if (!dragging) {
                  if (distance > panel.width / 2) {
--                    root.switchToNextState("visible")
--                    if (distance > minimizeDistance) {
--                        root.dash();
++                    if (root.drawerEnabled && distance > panel.width * 3 && dragDirection() !== "left") {
++                        root.switchToNextState("drawer");
++                        root.focus = true;
++                    } else {
++                        root.switchToNextState("visible");
+                     }
                  } else if (root.state === "") {
                      // didn't drag far enough. rollback
--                    root.switchToNextState("")
++                    root.switchToNextState("");
+                 }
+             }
++            lastDragPoints = [];
+         }
+     }
@@ -434,6 +560,10 @@
                  target: panel
                  x: -root.panelWidth
+             }
++            PropertyChanges {
++                target: drawer
++                anchors.rightMargin: 0
++            }
          },
          State {
              name: "visible"
@@ -441,6 +571,18 @@
                  target: panel
                  x: -root.x // so we never go past panelWidth, even when teased by tutorial
+             }
++            PropertyChanges {
++                target: drawer
++                anchors.rightMargin: 0
++            }
++        },
++        State {
++            name: "drawer"
++            extend: "visible"
++            PropertyChanges {
++                target: drawer
++                anchors.rightMargin: -drawer.width + root.x // so we never go past panelWidth, even when teased by tutorial
++            }
          },
          State {
              name: "visibleTemporary"
 === added file 'qml/Launcher/MoreAppsHeader.qml'
 --- qml/Launcher/MoreAppsHeader.qml	1970-01-01 00:00:00 +0000
 +++ qml/Launcher/MoreAppsHeader.qml	2016-12-06 13:47:05 +0000
@@ -0,0 +1,46 @@
++import QtQuick 2.4
++import Ubuntu.Components 1.3
++
++AbstractButton {
++    id: root
++
++    onClicked: {
++        // TODO: Make this point to the snappy store as soon as we stop landing to vivid
++        Qt.openUrlExternally("scope://com.canonical.scopes.clickstore")
++    }
++
++    UbuntuShape {
++        width: parent.width
++        height: parent.height - units.gu(1)
++        color: "#20ffffff"
++        aspect: UbuntuShape.Flat
++
++        Row {
++            anchors.fill: parent
++            anchors.margins: units.gu(1)
++            spacing: units.gu(1)
++
++            Icon {
++                height: units.gu(2.2)
++                width: height
++                name: "stock_application"
++                anchors.verticalCenter: parent.verticalCenter
++                color: "white"
++            }
++
++            Label {
++                text: i18n.tr("More apps in the store")
++                anchors.verticalCenter: parent.verticalCenter
++                fontSize: "small"
++            }
++
++            Icon {
++                height: units.gu(2.5)
++                width: height
++                anchors.verticalCenter: parent.verticalCenter
++                name: "go-next"
++                color: "white"
++            }
++        }
++    }
++}
 === modified file 'qml/Shell.qml'
 --- qml/Shell.qml	2016-11-29 09:39:56 +0000
 +++ qml/Shell.qml	2016-12-06 13:47:05 +0000
@@ -278,8 +278,6 @@
              dragAreaWidth: shell.edgeSize
              background: wallpaperResolver.background
--            leftEdgeDragProgress: !greeter || greeter.locked || !tutorial.launcherLongSwipeEnabled ? 0 :
--                                Math.max(0, (launcher.dragDistance * (stage.width - launcher.panelWidth) / stage.width) - launcher.panelWidth)
              applicationManager: ApplicationManager
              topLevelSurfaceList: topLevelSurfaceList
@@ -301,14 +299,12 @@
              interactive: (!greeter || !greeter.shown)
                      && panel.indicators.fullyClosed
--                    && launcher.progress == 0
                      && !notifications.useModal
              onInteractiveChanged: { if (interactive) { focus = true; } }
              leftMargin: shell.usageScenario == "desktop" && !settings.autohideLauncher ? launcher.panelWidth: 0
              suspended: greeter.shown
--            keepDashRunning: launcher.shown || launcher.dashSwipe
              altTabPressed: physicalKeysMapper.altTabPressed
              oskEnabled: shell.oskEnabled
              spreadEnabled: tutorial.spreadEnabled && (!greeter || (!greeter.hasLockedApp && !greeter.shown))
@@ -323,7 +319,7 @@
              topMargin: panel.panelHeight
              leftMargin: launcher.lockedVisible ? launcher.panelWidth : 0
+         }
--        z: notifications.useModal || panel.indicators.shown || wizard.active || tutorial.running ? overlay.z + 1 : overlay.z - 1
++        z: notifications.useModal || panel.indicators.shown || wizard.active || tutorial.running || launcher.drawerShown ? overlay.z + 1 : overlay.z - 1
+     }
      Loader {
@@ -345,7 +341,6 @@
              enabled: panel.indicators.fullyClosed // hides OSK when panel is open
              hides: [launcher, panel.indicators]
              tabletMode: shell.usageScenario != "phone"
--            launcherOffset: launcher.progress
              forcedUnlock: wizard.active || shell.mode === "full-shell"
              background: wallpaperResolver.cachedBackground
              hasCustomBackground: wallpaperResolver.hasCustomBackground
@@ -434,19 +429,6 @@
+         }
+     }
--    function showDash() {
--        if (greeter.notifyShowingDashFromDrag()) {
--            launcher.fadeOut();
--        }
--
--        if (!greeter.locked && tutorial.launcherLongSwipeEnabled
--            && (ApplicationManager.focusedApplicationId != "unity8-dash" || stage.spreadShown)) {
--            ApplicationManager.requestFocusApplication("unity8-dash")
--            launcher.fadeOut();
--            stage.closeSpread();
--        }
--    }
--
      Item {
          id: overlay
          z: 10
@@ -497,15 +479,6 @@
              id: launcher
              objectName: "launcher"
--            /*
--             * Since the Dash doesn't have the same controll over surfaces that the
--             * Shell does, it can't slowly move the scope out of the way, as the shell
--             * does  with apps, and the dash is show instantly. This allows for some
--             * leeway and prevents accidental home swipes.
--             */
--            readonly property real offset: shell.focusedApplicationId == "unity8-dash" ? units.gu(12) : 0
--            readonly property bool dashSwipe: progress > offset
--
              anchors.top: parent.top
              anchors.topMargin: inverted ? 0 : panel.panelHeight
              anchors.bottom: parent.bottom
@@ -521,14 +494,11 @@
              superTabPressed: physicalKeysMapper.superTabPressed
              panelWidth: units.gu(settings.launcherWidth)
              lockedVisible: shell.usageScenario == "desktop" && !settings.autohideLauncher && !panel.fullscreenMode
++            blurSource: greeter.shown ? greeter : stages
++            topPanelHeight: panel.panelHeight
++            drawerEnabled: !greeter.shown
              onShowDashHome: showHome()
--            onDash: showDash()
--            onDashSwipeChanged: {
--                if (dashSwipe) {
--                    dash.setCurrentScope(0, false, true)
--                }
--            }
              onLauncherApplicationSelected: {
                  greeter.notifyUserRequestedApp();
                  shell.activateApplication(appId);
@@ -545,6 +515,12 @@
+             }
              GlobalShortcut {
++                shortcut: Qt.MetaModifier | Qt.Key_A
++                onTriggered: {
++                    launcher.openDrawer(true);
++                }
++            }
++            GlobalShortcut {
                  shortcut: Qt.AltModifier | Qt.Key_F1
                  onTriggered: {
                      launcher.openForKeyboardNavigation();
 === modified file 'qml/Stage/Spread/WindowedRightEdgeMaths.qml'
 --- qml/Stage/Spread/WindowedRightEdgeMaths.qml	2016-09-20 12:03:51 +0000
 +++ qml/Stage/Spread/WindowedRightEdgeMaths.qml	2016-12-06 13:47:05 +0000
@@ -25,21 +25,31 @@
      // Input
      property int itemIndex: 0
      property int normalZ: 0
--    property real progress: 0
      property int startWidth: 0
      property int startHeight: 0
      property int startX: 0
      property int targetX: 0
      property int startY: 0
      property int targetY: 0
--//    property real startAngle: 40
      property real targetAngle: 0
      property int targetHeight: 0
      property real targetScale: 0
++    property real swipeProgress: 0
++    property real pushProgress: 0
      // Config
      property real breakPoint: 0.4
++    // internal
++    readonly property real progress: {
++        if (pushProgress > 0) {
++            // we don't do the full animation when pushing, just a little bit
++            return MathUtils.linearAnimation(0, 1, 0, breakPoint + .1, pushProgress)
++        } else {
++            return swipeProgress;
++        }
++    }
++
      // Output
      readonly property real scaleToPreviewProgress: {
@@ -68,12 +78,17 @@
      readonly property int animatedZ: {
          if (progress < breakPoint + (1 - breakPoint) / 2) {
--            return itemIndex == 1 ? normalZ + 2 : normalZ
++            if (swipeProgress > 0) {
++                return itemIndex == 1 ? normalZ + 2 : normalZ
++            }
++            if (pushProgress > 0) {
++                return normalZ;
++            }
+         }
          return itemIndex
+     }
--    readonly property real opacityMask: itemIndex == 1 ? MathUtils.linearAnimation(0, breakPoint, 0, 1, progress) : 1
++    readonly property real opacityMask: (swipeProgress > 0 && itemIndex == 1) ? MathUtils.linearAnimation(0, breakPoint, 0, 1, progress) : 1
      readonly property real animatedScale: progress < breakPoint ? 1 : MathUtils.linearAnimation(breakPoint, 1, 1, targetScale, progress)
 === modified file 'qml/Stage/Stage.qml'
 --- qml/Stage/Stage.qml	2016-11-29 09:39:25 +0000
 +++ qml/Stage/Stage.qml	2016-12-06 13:47:05 +0000
@@ -36,7 +36,6 @@
      property url background
      property int dragAreaWidth
      property bool interactive
--    property bool keepDashRunning: true
      property real nativeHeight
      property real nativeWidth
      property QtObject orientations
@@ -50,7 +49,6 @@
      // Configuration
      property string mode: "staged"
--    property real leftEdgeDragProgress: 0
      // Used by the tutorial code
      readonly property real rightEdgeDragProgress: rightEdgeDragArea.dragging ? rightEdgeDragArea.progress : 0 // How far left the stage has been dragged
@@ -415,7 +413,7 @@
                  //       in staged mode, when it switches to Windowed mode it will suddenly
                  //       resume all those apps at once. We might want to avoid that.
                  value: root.mode === "windowed"
--                       || (isDash && root.keepDashRunning)
++                       || isDash
                         || (!root.suspended && model.application && priv.focusedAppDelegate &&
                             (priv.focusedAppDelegate.appId === model.application.appId ||
                              priv.mainStageAppId === model.application.appId ||
@@ -478,7 +476,7 @@
                  visible: true
                  blurRadius: 32
                  brightness: .65
--                opacity: MathUtils.linearAnimation(spreadItem.rightEdgeBreakPoint, 1, 0, 1, Math.max(rightEdgeDragArea.progress, edgeBarrier.progress))
++                opacity: MathUtils.linearAnimation(spreadItem.rightEdgeBreakPoint, 1, 0, 1, Math.max(rightEdgeDragArea.dragging ? rightEdgeDragArea.progress : 0, edgeBarrier.progress))
+             }
          },
          State {
@@ -1061,7 +1059,6 @@
                      sideStageX: sideStage.x
                      itemIndex: appDelegate.itemIndex
                      nextInStack: priv.nextInStack
--                    leftEdgeDragProgress: root.leftEdgeDragProgress
+                 }
                  StagedRightEdgeMaths {
@@ -1164,7 +1161,8 @@
                          when: root.mode == "windowed" && (root.state == "windowedRightEdge" || rightEdgeFocusAnimation.running || hidingAnimation.running || edgeBarrier.progress > 0)
                          PropertyChanges {
                              target: windowedRightEdgeMaths
--                            progress: Math.max(rightEdgeDragArea.progress, edgeBarrier.progress)
++                            swipeProgress: rightEdgeDragArea.dragging ? rightEdgeDragArea.progress : 0
++                            pushProgress: edgeBarrier.progress
+                         }
                          PropertyChanges {
                              target: appDelegate
 === modified file 'qml/Stage/StageMaths.qml'
 --- qml/Stage/StageMaths.qml	2016-09-13 13:15:09 +0000
 +++ qml/Stage/StageMaths.qml	2016-12-06 13:47:05 +0000
@@ -12,7 +12,6 @@
      property int sideStageWidth: 0
      property int sideStageX: sceneWidth
      property bool animateX: false
--    property int leftEdgeDragProgress: 0
      property int stage: ApplicationInfoInterface.MainStage
      property var thisDelegate: null
@@ -26,10 +25,6 @@
      // of the last focused order.
      readonly property int itemZ: {
          // only shuffle when we've got a main and side stage
--        if (thisDelegate.isDash && thisDelegate != mainStageDelegate && leftEdgeDragProgress > 0) {
--            return -1; // Keep the dash behind all other apps for the left edge gesture
--        }
--
          if (!sideStageDelegate) return itemIndex;
          // don't shuffle indexes greater than "actives or next"
@@ -64,12 +59,12 @@
      property int itemX: {
          if (mainStageDelegate == thisDelegate) {
--            return thisDelegate.isDash ? 0 : leftEdgeDragProgress;
++            return 0
+         }
          if (sideStageDelegate == thisDelegate) {
              return sideStageX;
+         }
--        return thisDelegate.isDash && leftEdgeDragProgress > 0 ? 0 : sceneWidth;
++        return sceneWidth;
+     }
      Behavior on itemX { enabled: root.animateX; UbuntuNumberAnimation {} }
 === modified file 'qml/Tutorial/TutorialLeftLong.qml'
 --- qml/Tutorial/TutorialLeftLong.qml	2016-04-29 09:12:21 +0000
 +++ qml/Tutorial/TutorialLeftLong.qml	2016-12-06 13:47:05 +0000
@@ -25,7 +25,7 @@
      // Unlike other tutorials, this one can't be skipped before we show it, so
      // only set opacityOverride if we're already shown.
--    opacityOverride: shown ? 1 - launcher.dragDistance / launcher.minimizeDistance : 1
++    opacityOverride: shown ? 1 - launcher.dragDistance / (launcher.panelWidth * 3) : 1
      mouseArea {
          anchors.leftMargin: launcher.dragAreaWidth
 === modified file 'tests/mocks/Unity/Launcher/CMakeLists.txt'
 --- tests/mocks/Unity/Launcher/CMakeLists.txt	2016-10-28 12:08:59 +0000
 +++ tests/mocks/Unity/Launcher/CMakeLists.txt	2016-12-06 13:47:05 +0000
@@ -1,7 +1,8 @@
--pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=10)
++pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=11)
  include_directories(
      ${CMAKE_CURRENT_SOURCE_DIR}
++    ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher/
+ )
  set(MockLauncherModel_SOURCES
@@ -9,10 +10,13 @@
      ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/LauncherItemInterface.h
      ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/LauncherModelInterface.h
      ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/QuickListModelInterface.h
++    ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/AppDrawerModelInterface.h
      plugin.cpp
      MockLauncherModel.cpp
      MockLauncherItem.cpp
      MockQuickListModel.cpp
++    MockAppDrawerModel.cpp
++    ${CMAKE_SOURCE_DIR}/plugins/Utils/applicationsfiltermodel.cpp
+ )
  add_library(MockLauncherPlugin MODULE ${MockLauncherModel_SOURCES})
 === added file 'tests/mocks/Unity/Launcher/MockAppDrawerModel.cpp'
 --- tests/mocks/Unity/Launcher/MockAppDrawerModel.cpp	1970-01-01 00:00:00 +0000
 +++ tests/mocks/Unity/Launcher/MockAppDrawerModel.cpp	2016-12-06 13:47:05 +0000
@@ -0,0 +1,75 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include "MockAppDrawerModel.h"
++
++#include <QDebug>
++#include <QDateTime>
++
++MockAppDrawerModel::MockAppDrawerModel(QObject *parent):
++    AppDrawerModelInterface(parent)
++{
++    MockLauncherItem *item = new MockLauncherItem("dialer-app", "/usr/share/applications/dialer-app.desktop", "Dialer", "dialer-app", this);
++    m_list.append(item);
++    item = new MockLauncherItem("camera-app", "/usr/share/applications/camera-app.desktop", "Camera", "camera", this);
++    m_list.append(item);
++    item = new MockLauncherItem("camera-app2", "/usr/share/applications/camera-app2.desktop", "Camera2", "camera", this);
++    m_list.append(item);
++    item = new MockLauncherItem("gallery-app", "/usr/share/applications/gallery-app.desktop", "Gallery", "gallery", this);
++    m_list.append(item);
++    item = new MockLauncherItem("music-app", "/usr/share/applications/music-app.desktop", "Music", "soundcloud", this);
++    m_list.append(item);
++    item = new MockLauncherItem("facebook-webapp", "/usr/share/applications/facebook-webapp.desktop", "Facebook", "facebook", this);
++    m_list.append(item);
++    item = new MockLauncherItem("webbrowser-app", "/usr/share/applications/webbrowser-app.desktop", "Browser", "browser", this);
++    m_list.append(item);
++    item = new MockLauncherItem("twitter-webapp", "/usr/share/applications/twitter-webapp.desktop", "Twitter", "twitter", this);
++    m_list.append(item);
++    item = new MockLauncherItem("gmail-webapp", "/usr/share/applications/gmail-webapp.desktop", "GMail", "gmail", this);
++    m_list.append(item);
++    item = new MockLauncherItem("ubuntu-weather-app", "/usr/share/applications/ubuntu-weather-app.desktop", "Weather", "weather", this);
++    m_list.append(item);
++    item = new MockLauncherItem("notes-app", "/usr/share/applications/notes-app.desktop", "Notepad", "notepad", this);
++    m_list.append(item);
++    item = new MockLauncherItem("calendar-app", "/usr/share/applications/calendar-app.desktop","Calendar", "calendar", this);
++    m_list.append(item);
++    item = new MockLauncherItem("libreoffice", "/usr/share/applications/libreoffice.desktop","Libre Office", "libreoffice", this);
++    m_list.append(item);
++    qDebug() << "mock model created";
++
++    qsrand(QDateTime::currentMSecsSinceEpoch() / 1000);
++}
++
++int MockAppDrawerModel::rowCount(const QModelIndex &parent) const
++{
++    return m_list.count();
++}
++
++QVariant MockAppDrawerModel::data(const QModelIndex &index, int role) const
++{
++    switch (role) {
++    case RoleAppId:
++        return m_list.at(index.row())->appId();
++    case RoleName:
++        return m_list.at(index.row())->name();
++    case RoleIcon:
++        return m_list.at(index.row())->icon();
++    case RoleUsage:
++        return qrand();
++    }
++
++    return QVariant();
++}
 === added file 'tests/mocks/Unity/Launcher/MockAppDrawerModel.h'
 --- tests/mocks/Unity/Launcher/MockAppDrawerModel.h	1970-01-01 00:00:00 +0000
 +++ tests/mocks/Unity/Launcher/MockAppDrawerModel.h	2016-12-06 13:47:05 +0000
@@ -0,0 +1,32 @@
++/*
++ * Copyright (C) 2016 Canonical, Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include <unity/shell/launcher/AppDrawerModelInterface.h>
++
++#include "MockLauncherItem.h"
++
++class MockAppDrawerModel: public AppDrawerModelInterface
++{
++    Q_OBJECT
++public:
++    MockAppDrawerModel(QObject* parent = nullptr);
++
++    int rowCount(const QModelIndex &parent) const override;
++    QVariant data(const QModelIndex &index, int role) const override;
++
++private:
++    QList<MockLauncherItem*> m_list;
++};
 === modified file 'tests/mocks/Unity/Launcher/MockLauncherItem.cpp'
 --- tests/mocks/Unity/Launcher/MockLauncherItem.cpp	2016-05-13 11:28:56 +0000
 +++ tests/mocks/Unity/Launcher/MockLauncherItem.cpp	2016-12-06 13:47:05 +0000
@@ -67,6 +67,11 @@
      return m_icon;
+ }
++QStringList MockLauncherItem::keywords() const
++{
++    return m_keywords;
++}
++
  bool MockLauncherItem::pinned() const
+ {
      return m_pinned;
@@ -200,3 +205,11 @@
+ {
      return m_quickList;
+ }
++
++void MockLauncherItem::setKeywords(const QStringList &keywords)
++{
++    if (m_keywords != keywords) {
++        m_keywords = keywords;
++        Q_EMIT keywordsChanged(keywords);
++    }
++}
 === modified file 'tests/mocks/Unity/Launcher/MockLauncherItem.h'
 --- tests/mocks/Unity/Launcher/MockLauncherItem.h	2016-05-10 15:51:00 +0000
 +++ tests/mocks/Unity/Launcher/MockLauncherItem.h	2016-12-06 13:47:05 +0000
@@ -22,6 +22,8 @@
  #include <unity/shell/launcher/LauncherItemInterface.h>
++#include <QStringList>
++
  class MockQuickListModel;
  using namespace unity::shell::launcher;
@@ -37,6 +39,7 @@
      QString desktopFile() const;
      QString name() const override;
      QString icon() const override;
++    QStringList keywords() const override;
      bool pinned() const override;
      bool running() const override;
@@ -51,6 +54,7 @@
      unity::shell::launcher::QuickListModelInterface *quickList() const override;
  private:
++    void setKeywords(const QStringList &keywords);
      void setPinned(bool pinned);
      void setRunning(bool running);
      void setRecent(bool recent);
@@ -65,6 +69,7 @@
      QString m_desktopFile;
      QString m_name;
      QString m_icon;
++    QStringList m_keywords;
      bool m_pinned;
      bool m_running;
      bool m_recent;
@@ -77,6 +82,7 @@
      MockQuickListModel *m_quickList;
      friend class MockLauncherModel;
++    friend class MockAppDrawerModel;
  };
  #endif // MOCKLAUNCHERITEM_H
 === modified file 'tests/mocks/Unity/Launcher/MockLauncherModel.cpp'
 --- tests/mocks/Unity/Launcher/MockLauncherModel.cpp	2016-06-17 01:13:55 +0000
 +++ tests/mocks/Unity/Launcher/MockLauncherModel.cpp	2016-12-06 13:47:05 +0000
@@ -36,6 +36,9 @@
      item = new MockLauncherItem("camera-app2", "/usr/share/applications/camera-app2.desktop", "Camera2", "camera", this);
      item->setPinned(true);
      m_list.append(item);
++    item = new MockLauncherItem("camera-app3", "/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);
 === modified file 'tests/mocks/Unity/Launcher/plugin.cpp'
 --- tests/mocks/Unity/Launcher/plugin.cpp	2013-08-19 15:10:58 +0000
 +++ tests/mocks/Unity/Launcher/plugin.cpp	2016-12-06 13:47:05 +0000
@@ -21,9 +21,11 @@
  #include "MockLauncherModel.h"
  #include "MockLauncherItem.h"
  #include "MockQuickListModel.h"
++#include "MockAppDrawerModel.h"
  #include <unity/shell/launcher/LauncherModelInterface.h>
  #include <unity/shell/launcher/LauncherItemInterface.h>
++#include <unity/shell/launcher/AppDrawerModelInterface.h>
  #include <QtQml/qqml.h>
@@ -41,8 +43,10 @@
      qmlRegisterUncreatableType<LauncherModelInterface>(uri, 0, 1, "LauncherModelInterface", "Abstract Interface. Cannot be instantiated.");
      qmlRegisterUncreatableType<LauncherItemInterface>(uri, 0, 1, "LauncherItemInterface", "Abstract Interface. Cannot be instantiated.");
      qmlRegisterUncreatableType<QuickListModelInterface>(uri, 0, 1, "QuickListModelInterface", "Abstract Interface. Cannot be instantiated.");
++    qmlRegisterUncreatableType<AppDrawerModelInterface>(uri, 0, 1, "AppDrawerModelInterface", "Abstract Interface. Cannot be instantiated.");
      qmlRegisterSingletonType<MockLauncherModel>(uri, 0, 1, "LauncherModel", modelProvider);
      qmlRegisterUncreatableType<MockLauncherItem>(uri, 0, 1, "LauncherItem", "Can't create LauncherItems in QML. Get them from the LauncherModel");
      qmlRegisterUncreatableType<MockQuickListModel>(uri, 0, 1, "QuickListModel", "Can't create QuickLists in QML. Get them from the LauncherItems");
++    qmlRegisterType<MockAppDrawerModel>(uri, 0, 1, "AppDrawerModel");
+ }
 === modified file 'tests/mocks/Utils/CMakeLists.txt'
 --- tests/mocks/Utils/CMakeLists.txt	2016-06-29 18:05:44 +0000
 +++ tests/mocks/Utils/CMakeLists.txt	2016-12-06 13:47:05 +0000
@@ -24,11 +24,15 @@
      ${CMAKE_SOURCE_DIR}/plugins/Utils/inputeventgenerator.cpp
      ${CMAKE_SOURCE_DIR}/plugins/Utils/deviceconfigparser.cpp
      ${CMAKE_SOURCE_DIR}/plugins/Utils/globalfunctions.cpp
++    ${CMAKE_SOURCE_DIR}/plugins/Utils/appdrawerproxymodel.cpp
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationManagerInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/ApplicationInfoInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirSurfaceListInterface.h
      ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/Mir.h
++    ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/AppDrawerModelInterface.h
++    ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/LauncherModelInterface.h
++    ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/LauncherItemInterface.h
      constants.cpp
      plugin.cpp
      windowstatestorage.cpp
 === modified file 'tests/mocks/Utils/plugin.cpp'
 --- tests/mocks/Utils/plugin.cpp	2016-06-28 20:38:00 +0000
 +++ tests/mocks/Utils/plugin.cpp	2016-12-06 13:47:05 +0000
@@ -40,6 +40,7 @@
  #include <inputeventgenerator.h>
  #include <deviceconfigparser.h>
  #include <globalfunctions.h>
++#include <appdrawerproxymodel.h>
  static QObject *createWindowStateStorage(QQmlEngine *engine, QJSEngine *scriptEngine)
+ {
@@ -82,4 +83,5 @@
      qmlRegisterType<DeviceConfigParser>(uri, 0, 1, "DeviceConfigParser");
      qmlRegisterSingletonType<GlobalFunctions>(uri, 0, 1, "Functions", createGlobalFunctions);
      qmlRegisterType<URLDispatcher>(uri, 0, 1, "URLDispatcher");
++    qmlRegisterType<AppDrawerProxyModel>(uri, 0, 1, "AppDrawerProxyModel");
+ }
 === modified file 'tests/plugins/Greeter/Unity/Launcher/CMakeLists.txt'
 --- tests/plugins/Greeter/Unity/Launcher/CMakeLists.txt	2016-10-28 12:08:59 +0000
 +++ tests/plugins/Greeter/Unity/Launcher/CMakeLists.txt	2016-12-06 13:47:05 +0000
@@ -1,4 +1,4 @@
--pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=10)
++pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=11)
  include_directories(
      ${CMAKE_CURRENT_SOURCE_DIR}
 === modified file 'tests/plugins/Unity/Launcher/CMakeLists.txt'
 --- tests/plugins/Unity/Launcher/CMakeLists.txt	2016-10-28 12:08:59 +0000
 +++ tests/plugins/Unity/Launcher/CMakeLists.txt	2016-12-06 13:47:05 +0000
@@ -1,5 +1,5 @@
  pkg_check_modules(GSETTINGS_QT REQUIRED gsettings-qt)
--pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=10)
++pkg_check_modules(LAUNCHER_API REQUIRED unity-shell-launcher=11)
  include_directories(
      ${CMAKE_CURRENT_SOURCE_DIR}
@@ -30,6 +30,7 @@
      ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher/quicklistmodel.cpp
      ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher/dbusinterface.cpp
      ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher/quicklistentry.cpp
++    ${CMAKE_SOURCE_DIR}/plugins/Unity/Launcher/ualwrapper.cpp
      ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/LauncherItemInterface.h
      ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/LauncherModelInterface.h
      ${LAUNCHER_API_INCLUDEDIR}/unity/shell/launcher/QuickListModelInterface.h
 === modified file 'tests/qmltests/CMakeLists.txt'
 --- tests/qmltests/CMakeLists.txt	2016-09-22 14:19:36 +0000
 +++ tests/qmltests/CMakeLists.txt	2016-12-06 13:47:05 +0000
@@ -71,6 +71,7 @@
  add_unity8_qmltest(Greeter NarrowView)
  add_unity8_qmltest(Greeter WideView)
  add_unity8_qmltest(Launcher Launcher)
++add_unity8_qmltest(Launcher Drawer)
  add_unity8_qmltest(Notifications Notifications)
  add_unity8_qmltest(Notifications VisualSnapDecisionsQueue)
  add_unity8_qmltest(Notifications OptionToggle)
 === modified file 'tests/qmltests/Dash/tst_DashShell.qml'
 --- tests/qmltests/Dash/tst_DashShell.qml	2016-07-08 20:44:09 +0000
 +++ tests/qmltests/Dash/tst_DashShell.qml	2016-12-06 13:47:05 +0000
@@ -112,34 +112,5 @@
              mouseClick(buttonShowDashHome);
              tryCompare(dashContentList, "currentIndex", 0);
+         }
--
--        function test_setShortLauncherMoveResetNonActiveDash() {
--            var dashContentList = findChild(dash, "dashContentList");
--            var startX = dash.width - units.gu(1);
--            var startY = dash.height / 2;
--            var stopX = units.gu(1)
--            var stopY = startY;
--            waitForRendering(dashContentList);
--            touchFlick(dash, startX, startY, stopX, stopY);
--            touchFlick(dash, startX, startY, stopX, stopY);
--            compare(dashContentList.currentIndex, 2, "Could not flick to scope id 2");
--
--            // Pretend the dash is not active
--            dash.windowActive = false;
--
--            // Flick the greeter away
--            var startX = shell.width - units.gu(1);
--            var startY = shell.height / 2;
--            var stopX = units.gu(1)
--            var stopY = startY;
--            touchFlick(shell, startX, startY, stopX, stopY);
--
--            var greeter = findChild(shell, "greeter");
--            tryCompare(greeter, "shown", false);
--
--            // Now do a small launcher movement
--            touchFlick(shell, stopX, startY, startX, stopY);
--            compare(dashContentList.currentIndex, 0, "Small launcher move did not reset dash on non active window");
--        }
+     }
+ }
 === added file 'tests/qmltests/Launcher/tst_Drawer.qml'
 --- tests/qmltests/Launcher/tst_Drawer.qml	1970-01-01 00:00:00 +0000
 +++ tests/qmltests/Launcher/tst_Drawer.qml	2016-12-06 13:47:05 +0000
@@ -0,0 +1,264 @@
++/*
++ * Copyright 2013-2016 Canonical Ltd.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation; version 3.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++ * GNU General Public License for more details.
++ *
++ * You should have received a copy of the GNU General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ */
++
++import QtQuick 2.4
++import QtQuick.Layouts 1.1
++import Ubuntu.Components 1.3
++import ".."
++import "../../../qml/Launcher"
++import Unity.Launcher 0.1
++import Utils 0.1 // For EdgeBarrierSettings
++import Unity.Test 0.1
++
++StyledItem {
++    id: root
++    theme.name: "Ubuntu.Components.Themes.SuruDark"
++
++    width: units.gu(140)
++    height: units.gu(70)
++    Rectangle {
++        anchors.fill: parent
++        color: UbuntuColors.graphite // something neither white nor black
++    }
++
++    Launcher {
++        id: launcher
++        x: 0
++        y: 0
++        width: units.gu(40)
++        height: root.height
++
++        lockedVisible: lockedVisibleCheckBox.checked
++
++        property string lastSelectedApplication
++        onLauncherApplicationSelected: {
++            lastSelectedApplication = appId
++        }
++
++        Component.onCompleted: {
++            launcher.focus = true
++            edgeBarrierControls.target = testCase.findChild(this, "edgeBarrierController");
++        }
++    }
++
++    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 {
++            id: edgeBarrierControls
++            text: "Drag here to pull out launcher"
++            onDragged: { launcher.pushEdge(amount); }
++        }
++    }
++
++    UnityTestCase {
++        id: testCase
++        when: windowShown
++        name: "Drawer"
++
++        function dragDrawerIntoView() {
++            var startX = launcher.dragAreaWidth/2;
++            var startY = launcher.height/2;
++            touchFlick(launcher,
++                       startX, startY,
++                       startX+units.gu(35), startY);
++
++            var drawer = findChild(launcher, "drawer");
++            verify(!!drawer);
++
++            // wait until it gets fully extended
++            // a tryCompare doesn't work since
++            //    compare(-0.000005917593600024418, 0);
++            // is true and in this case we want exactly 0 or will have pain later on
++            tryCompareFunction( function(){ return drawer.x === 0; }, true );
++            tryCompare(launcher, "state", "drawer");
++            tryCompare(launcher, "drawerShown", true);
++        }
++
++        function revealByEdgePush() {
++            // Place the mouse against the window/screen edge and push beyond the barrier threshold
++            // If the mouse did not move between two revealByEdgePush(), we need it to move out the
++            // area to make sure we're not just accumulating to the previous push
++            mouseMove(root, root.width, root.height / 2);
++            mouseMove(root, 1, root.height / 2);
++
++            launcher.pushEdge(EdgeBarrierSettings.pushThreshold * 1.1);
++
++            var drawer = findChild(launcher, "drawer");
++            verify(!!drawer);
++
++            // wait until it gets fully extended
++            tryCompare(drawer, "x", 0);
++            tryCompare(launcher, "state", "drawer");
++            tryCompare(launcher, "drawerShown", true);
++        }
++
++        function init() {
++            launcher.lastSelectedApplication = "";
++            launcher.lockedVisible = false;
++            launcher.hide();
++            var drawer = findChild(launcher, "drawer");
++            tryCompare(drawer, "x", -drawer.width);
++        }
++
++        function test_revealByEdgeDrag() {
++            dragDrawerIntoView();
++        }
++
++        function test_revealByEdgePush_data() {
++            return [
++                { tag: "autohide launcher", autohide: true },
++                { tag: "locked launcher", autohide: false }
++            ]
++        }
++
++        function test_revealByEdgePush(data) {
++            launcher.lockedVisible = !data.autohide;
++
++            var panel = findChild(launcher, "launcherPanel");
++            tryCompare(panel, "x", data.autohide ? -panel.width : 0);
++            tryCompare(launcher, "state", data.autohide ? "" : "visible");
++            waitForRendering(launcher)
++
++            revealByEdgePush();
++        }
++
++        function test_hideByDraggingDrawer_data() {
++            return [
++                {tag: "autohide", autohide: true, endState: ""},
++                {tag: "locked", autohide: false, endState: "visible"}
++            ]
++        }
++
++        function test_hideByDraggingDrawer(data) {
++            launcher.lockedVisible = !data.autohide;
++
++            dragDrawerIntoView();
++            waitForRendering(launcher);
++
++            var drawer = findChild(launcher, "drawer");
++
++            mouseFlick(root, drawer.width - units.gu(1), drawer.height / 2, units.gu(2), drawer.height / 2, true, true);
++
++            tryCompare(drawer.anchors, "rightMargin", 0);
++            tryCompare(launcher, "state", data.endState);
++            launcher.lockedVisible = false;
++        }
++
++        function test_hideByClickingOutside() {
++            dragDrawerIntoView();
++
++            var drawer = findChild(launcher, "drawer");
++
++            mouseClick(root, drawer.width + units.gu(1), root.height / 2);
++
++            tryCompare(launcher, "state", "");
++        }
++
++        function test_launchAppFromDrawer() {
++            dragDrawerIntoView();
++
++            var drawerList = findChild(launcher, "drawerItemList");
++            var dialerApp = findChild(drawerList, "drawerItem_dialer-app");
++            mouseClick(dialerApp, dialerApp.width / 2, dialerApp.height / 2);
++
++            tryCompare(launcher, "lastSelectedApplication", "dialer-app");
++
++            tryCompare(launcher, "state", "");
++        }
++
++        function test_launcherGivesUpFocusAfterLaunchingFromDrawer() {
++            dragDrawerIntoView();
++
++            tryCompare(launcher, "focus", true);
++
++            var drawerList = findChild(launcher, "drawerItemList");
++            var dialerApp = findChild(drawerList, "drawerItem_dialer-app");
++            mouseClick(dialerApp, dialerApp.width / 2, dialerApp.height / 2);
++
++            tryCompare(launcher, "focus", false);
++        }
++
++        function test_drawerDisabled() {
++            launcher.drawerEnabled = false;
++
++            var startX = launcher.dragAreaWidth/2;
++            var startY = launcher.height/2;
++            touchFlick(launcher,
++                       startX, startY,
++                       startX+units.gu(35), startY);
++
++            var drawer = findChild(launcher, "drawer");
++            verify(!!drawer);
++
++            tryCompare(launcher, "state", "visible");
++            tryCompare(launcher, "drawerShown", false);
++
++            launcher.drawerEnabled = true;
++        }
++
++        function test_search() {
++            compare(launcher.lastSelectedApplication, "");
++
++            launcher.openDrawer(true)
++            typeString("cam");
++            keyClick(Qt.Key_Enter);
++
++            compare(launcher.lastSelectedApplication, "camera-app");
++        }
++
++        function test_dragDirectionOnLeftEdgeDrag_data() {
++            return [
++                { tag: "reveal", direction: "right", endState: "drawer" },
++                { tag: "cancel", direction: "left", endState: "visible" },
++            ]
++        }
++
++        function test_dragDirectionOnLeftEdgeDrag(data) {
++            var startX = launcher.dragAreaWidth/2;
++            var startY = launcher.height/2;
++            var stopX = startX + units.gu(35);
++            var endX = stopX + (units.gu(4) * (data.direction === "left" ? -1 : 1))
++
++            touchFlick(launcher, startX, startY, stopX, startY, true, false);
++            touchFlick(launcher, stopX, startY, endX, startY, false, true);
++
++            tryCompare(launcher, "state", data.endState)
++        }
++    }
++}
 === modified file 'tests/qmltests/Launcher/tst_Launcher.qml'
 --- tests/qmltests/Launcher/tst_Launcher.qml	2016-11-24 16:06:15 +0000
 +++ tests/qmltests/Launcher/tst_Launcher.qml	2016-12-06 13:47:05 +0000
@@ -322,7 +322,7 @@
          function revealByEdgePush() {
              // Place the mouse against the window/screen edge and push beyond the barrier threshold
              mouseMove(root, 1, root.height / 2);
--            launcher.pushEdge(EdgeBarrierSettings.pushThreshold * 1.1);
++            launcher.pushEdge(EdgeBarrierSettings.pushThreshold * .6);
              var panel = findChild(launcher, "launcherPanel");
              verify(!!panel);
 === modified file 'tests/qmltests/Stage/tst_PhoneStage.qml'
 --- tests/qmltests/Stage/tst_PhoneStage.qml	2016-10-08 16:45:37 +0000
 +++ tests/qmltests/Stage/tst_PhoneStage.qml	2016-12-06 13:47:05 +0000
@@ -334,32 +334,6 @@
              tryCompare(firstApp, "focused", true);
+         }
--        function test_leftEdge_data() {
--            return [
--                { tag: "normal", inSpread: false, leftEdgeDragWidth: units.gu(20), shouldMoveApp: true },
--                { tag: "inSpread", inSpread: true, leftEdgeDragWidth: units.gu(5), shouldMoveApp: false }
--            ]
--        }
--
--        function test_leftEdge(data) {
--            addApps(2);
--
--            if (data.inSpread) {
--                performEdgeSwipeToShowAppSpread();
--            }
--
--            var focusedDelegate = findChild(stage, "appDelegate_" + topLevelSurfaceList.idAt(0));
--            var currentX = focusedDelegate.x;
--
--            stage.leftEdgeDragProgress = data.leftEdgeDragWidth;
--
--            tryCompare(focusedDelegate, "x", data.shouldMoveApp ? data.leftEdgeDragWidth : currentX);
--
--            stage.leftEdgeDragProgress = 0;
--
--            tryCompare(focusedDelegate, "x", currentX);
--        }
--
          function test_focusedAppIsTheOnlyRunningApp() {
              addApps(2);
 === modified file 'tests/qmltests/tst_OrientedShell.qml'
 --- tests/qmltests/tst_OrientedShell.qml	2016-11-14 01:39:43 +0000
 +++ tests/qmltests/tst_OrientedShell.qml	2016-12-06 13:47:05 +0000
@@ -999,7 +999,7 @@
              var rotationStates = findInvisibleChild(orientedShell, "rotationStates");
              waitUntilTransitionsEnd(rotationStates);
--            performLeftEdgeSwipeToSwitchToDash();
++            ApplicationManager.requestFocusApplication("unity8-dash");
              // Should be back to portrait
              tryCompare(shell, "transformRotationAngle", 0);
@@ -1391,18 +1391,6 @@
              waitUntilTransitionsEnd(rotationStates);
+         }
--        function performLeftEdgeSwipeToSwitchToDash() {
--            var swipeLength = shell.width * 0.7;
--
--            var touchStartX = 1;
--            var touchStartY = shell.height / 2;
--            touchFlick(shell,
--                       touchStartX, touchStartY,
--                       touchStartX + swipeLength, touchStartY);
--
--            tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");
--        }
--
          function performEdgeSwipeToSwitchToPreviousApp() {
              // swipe just enough to ensure an app switch action.
              // If we swipe too much we will trigger the spread mode
 === modified file 'tests/qmltests/tst_Shell.qml'
 --- tests/qmltests/tst_Shell.qml	2016-11-22 17:00:33 +0000
 +++ tests/qmltests/tst_Shell.qml	2016-12-06 13:47:05 +0000
@@ -605,38 +605,6 @@
              compare(ApplicationManager.get(0).appId, "unity8-dash");
+         }
--        function test_phoneLeftEdgeDrag_data() {
--            return [
--                {tag: "without launcher",
--                 revealLauncher: false, swipeLength: units.gu(30), appHides: true, focusedApp: "dialer-app",
--                 launcherHides: true, greeterShown: false},
--
--                {tag: "with launcher",
--                 revealLauncher: true, swipeLength: units.gu(30), appHides: true, focusedApp: "dialer-app",
--                 launcherHides: true, greeterShown: false},
--
--                {tag: "small swipe",
--                 revealLauncher: false, swipeLength: units.gu(25), appHides: false, focusedApp: "dialer-app",
--                 launcherHides: false, greeterShown: false},
--
--                {tag: "long swipe",
--                 revealLauncher: false, swipeLength: units.gu(30), appHides: true, focusedApp: "dialer-app",
--                 launcherHides: true, greeterShown: false},
--
--                {tag: "small swipe with greeter",
--                 revealLauncher: false, swipeLength: units.gu(25), appHides: false, focusedApp: "dialer-app",
--                 launcherHides: false, greeterShown: true},
--
--                {tag: "long swipe with greeter",
--                 revealLauncher: false, swipeLength: units.gu(30), appHides: true, focusedApp: "dialer-app",
--                 launcherHides: true, greeterShown: true},
--
--                {tag: "swipe over dash",
--                 revealLauncher: false, swipeLength: units.gu(30), appHides: true, focusedApp: "unity8-dash",
--                 launcherHides: false, greeterShown: false},
--            ];
--        }
--
          function test_snapDecisionDismissalReturnsFocus() {
              loadShell("phone");
              swipeAwayGreeter();
@@ -701,80 +669,6 @@
              mockNotificationsModel.append(n)
+         }
--        function test_phoneLeftEdgeDrag(data) {
--            loadShell("phone");
--            swipeAwayGreeter();
--            dragLauncherIntoView();
--            var appSurfaceId = topLevelSurfaceList.nextId;
--            tapOnAppIconInLauncher();
--            waitUntilAppWindowIsFullyLoaded(appSurfaceId);
--
--            var greeter = findChild(shell, "greeter");
--            if (data.greeterShown) {
--                showGreeter();
--            }
--
--            if (data.revealLauncher) {
--                dragLauncherIntoView();
--            }
--
--            swipeFromLeftEdge(data.swipeLength);
--            if (data.appHides) {
--                waitUntilDashIsFocused();
--                tryCompare(greeter, "shown", false);
--            } else {
--                tryCompare(greeter, "fullyShown", data.greeterShown);
--            }
--
--            var launcher = findChild(shell, "launcherPanel");
--            tryCompare(launcher, "x", data.launcherHides ? -launcher.width : 0)
--
--            //FIXME: This check fails. Don't understand the rationale behind it.
--            /*
--            // Make sure the helper for sliding out the launcher wasn't touched. We want to fade it out here.
--            var animateTimer = findInvisibleChild(shell, "animateTimer");
--            compare(animateTimer.nextState, "visible");
--            */
--        }
--
--        function test_tabletLeftEdgeDrag_data() {
--            return [
--                {tag: "without password", user: "no-password", loggedIn: true},
--                {tag: "with password", user: "has-password", loggedIn: false},
--            ]
--        }
--
--        function test_tabletLeftEdgeDrag(data) {
--            setLightDMMockMode("full");
--            loadShell("tablet");
--
--            selectUser(data.user)
--
--            swipeFromLeftEdge(shell.width * 0.75)
--            wait(500) // to give time to handle dash() signal from Launcher
--            confirmLoggedIn(data.loggedIn)
--        }
--
--        function test_longLeftEdgeSwipeTakesToAppsAndResetSearchString() {
--            loadShell("phone");
--            swipeAwayGreeter();
--            dragLauncherIntoView();
--            dashCommunicatorSpy.clear();
--
--            var appSurfaceId = topLevelSurfaceList.nextId;
--            tapOnAppIconInLauncher();
--            waitUntilAppWindowIsFullyLoaded(appSurfaceId);
--
--            tryCompareFunction(function() { return ApplicationManager.focusedApplicationId !== "unity8-dash"; }, true);
--
--            //Long left swipe
--            swipeFromLeftEdge(units.gu(30));
--
--            tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");
--
--            compare(dashCommunicatorSpy.count, 1);
--        }
--
          function test_ClickUbuntuIconInLauncherTakesToAppsAndResetSearchString() {
              loadShell("phone");
              swipeAwayGreeter();
@@ -913,39 +807,6 @@
              LightDM.Users.mockMode = mode;
+         }
--        /*
--          Regression test for bug https://bugs.launchpad.net/touch-preview-images/+bug/1193419
--
--          When the user minimizes an application (left-edge swipe) he should always end up in the
--          "Applications" scope view.
--
--          Steps:
--          - reveal launcher and launch an app that covers the dash
--          - perform long left edge swipe to go minimize the app and go back to the dash.
--          - verify the setCurrentScope() D-Bus call to the dash has been called for the correct scope id.
--         */
--        function test_minimizingAppTakesToDashApps() {
--            loadShell("phone");
--            swipeAwayGreeter();
--            dragLauncherIntoView();
--
--            // Launch an app from the launcher
--            var appSurfaceId = topLevelSurfaceList.nextId;
--            tapOnAppIconInLauncher();
--            waitUntilAppWindowIsFullyLoaded(appSurfaceId);
--
--            verify(ApplicationManager.focusedApplicationId !== "unity8-dash")
--
--            dashCommunicatorSpy.clear();
--            // Minimize the application we just launched
--            swipeFromLeftEdge(shell.width * 0.75);
--
--            tryCompare(ApplicationManager, "focusedApplicationId", "unity8-dash");
--
--            compare(dashCommunicatorSpy.count, 1);
--            compare(dashCommunicatorSpy.signalArguments[0][0], 0);
--        }
--
          function test_showInputMethod() {
              loadShell("phone");
              swipeAwayGreeter();
@@ -1166,7 +1027,7 @@
              // Place the mouse against the window/screen edge and push beyond the barrier threshold
              mouseMove(shell, 0, shell.height / 2);
--            launcher.pushEdge(EdgeBarrierSettings.pushThreshold * 1.1);
++            launcher.pushEdge(EdgeBarrierSettings.pushThreshold * .8);
              var panel = findChild(launcher, "launcherPanel");
              verify(panel);
@@ -1186,9 +1047,7 @@
              waitUntilAppWindowIsFullyLoaded(appSurfaceId);
              // Minimize the application we just launched
--            swipeFromLeftEdge(shell.width * 0.75);
--
--            waitUntilDashIsFocused();
++            swipeFromLeftEdge(units.gu(15));
              showGreeter();
 === modified file 'tests/qmltests/tst_ShellWithPin.qml'
 --- tests/qmltests/tst_ShellWithPin.qml	2016-09-22 10:33:39 +0000
 +++ tests/qmltests/tst_ShellWithPin.qml	2016-12-06 13:47:05 +0000
@@ -547,71 +547,5 @@
              var lockscreen = findChild(shell, "lockscreen");
              verify(lockscreen.shown);
+         }
--
--        /*
--            Regression test for https://bugs.launchpad.net/ubuntu/+source/unity8/+bug/1393447
--
--            Do a left edge drag that is long enough to start displacing the greeter
--            but short engough so that the greeter comes back into place once the
--            finger is lifted.
--
--            In this situation the launcher should remaing fully shown and hide itself
--            only after its idle timeout is triggered.
--         */
--        function test_shortLeftEdgeSwipeMakesLauncherStayVisible() {
--            showGreeter();
--
--            var launcher = testCase.findChild(shell, "launcher")
--            var launcherPanel = testCase.findChild(launcher, "launcherPanel");
--
--            var toX = shell.width * 0.45;
--            touchFlick(shell,
--                    1 /* fromX */, shell.height * 0.5 /* fromY */,
--                    toX /* toX */, shell.height * 0.5 /* toY */,
--                    true /* beginTouch */, false /* endTouch */,
--                    50, 100);
--
--            // Launcher must be fully shown by now
--            tryCompare(launcherPanel, "x", 0);
--
--            // Greeter should be displaced
--            var coverPage = findChild(shell, "coverPage");
--            tryCompareFunction(function() { return coverPage.mapToItem(shell, 0, 0).x > shell.width*0.2; }, true);
--
--            touchRelease(shell, toX, shell.height * 0.5);
--
--            // Upon release the greeter should have slid back into full view
--            tryCompareFunction(function() { return coverPage.mapToItem(shell, 0, 0).x === 0; }, true);
--
--            // And the launcher should stay fully shown
--            for (var i = 0; i < 10; ++i) {
--                wait(50);
--                compare(launcherPanel.x, 0);
--            }
--        }
--
--        function test_longLeftEdgeDrags() {
--            var coverPage = findChild(shell, "coverPage");
--            var lockscreen = findChild(shell, "lockscreen");
--            var launcher = findChild(shell, "launcherPanel");
--            var galleryApp = ApplicationManager.startApplication("gallery-app");
--            tryCompare(shell, "mainApp", galleryApp);
--
--            // Show greeter
--            showGreeter();
--
--            // Swipe cover page away
--            touchFlick(shell, 2, shell.height / 2, units.gu(30), shell.height / 2);
--            tryCompare(launcher, "x", -launcher.width);
--            tryCompare(coverPage, "showProgress", 0);
--            compare(lockscreen.shown, true);
--            tryCompare(shell, "mainApp", galleryApp);
--
--            // Now attempt a swipe on lockscreen
--            touchFlick(shell, 2, shell.height / 2, units.gu(30), shell.height / 2);
--            tryCompare(launcher, "x", 0);
--            compare(lockscreen.shown, true);
--            tryCompare(shell, "mainApp", galleryApp);
--        }
+     }
+ }