Bring in multiscreen and workspace support

CMakeLists.txt

@@ -75,6 +75,7 @@ find_package(Qt5Network 5.6 REQUIRED)
 find_package(Qt5Xml 5.6 REQUIRED)
 
 pkg_check_modules(APPLICATION_API REQUIRED unity-shell-application=27)
+pkg_check_modules(QTMIRSERVER REQUIRED qtmirserver>=0.6.0)
 pkg_check_modules(GEONAMES REQUIRED geonames>=0.2)
 pkg_check_modules(GIO REQUIRED gio-2.0>=2.32)
 pkg_check_modules(GLIB REQUIRED glib-2.0>=2.32)
@@ -87,6 +88,7 @@ pkg_check_modules(QTDBUSTEST REQUIRED
     libqtdbustest-1
     libqtdbusmock-1
     )
+pkg_check_modules(MIRAL REQUIRED miral)
 
 ### Check UbuntuGestures private headers. No pkg-config (.pc) file is provided for them
 find_path(UBUNTUGESTUREPRIV
@@ -121,7 +123,9 @@ if(SHELL_PLUGINDIR STREQUAL "")
     message(FATAL_ERROR "Could not determine plugin import dir.")
 endif()
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-permissive -pedantic -Wall -Wextra")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-permissive -pedantic -Wall -Wextra")
+
+set (CMAKE_CXX_STANDARD 14)
 
 if ("${CMAKE_BUILD_TYPE}" STREQUAL "release" OR "${CMAKE_BUILD_TYPE}" STREQUAL "relwithdebinfo")
     option(Werror "Treat warnings as errors" ON)

data/com.canonical.Unity8.gschema.xml

@@ -63,6 +63,16 @@
       <summary>Whether the OSK switch should be visible</summary>
       <description>Toggle the visibility of the OSK switch</description>
     </key>
+    <key type="b" name="enable-workspace">
+      <default>false</default>
+      <summary>Enable or disable workspaces</summary>
+      <description>Toggle the availability of workspaces</description>
+    </key>
+    <key type="b" name="force-enable-workspace">
+      <default>false</default>
+      <summary>Force enable workspaces</summary>
+      <description>Forces workspaces availability even when not in windowed mode</description>
+    </key>
   </schema>
 
   <schema path="/com/canonical/unity8/greeter/" id="com.canonical.Unity8.Greeter" gettext-domain="unity8">

debian/control

@@ -29,6 +29,7 @@ Build-Depends:
  libpam0g-dev,
  libpulse-dev,
  libqmenumodel-dev (>= 0.2.12),
+ libqtmirserver-dev (>= 0.6.0),
  libqt5sql5-sqlite,
  libqt5svg5-dev,
  libqt5xmlpatterns5-dev,
@@ -46,6 +47,7 @@ Build-Depends:
  libx11-dev[!arm64 !armhf],
  libxcb1-dev[!arm64 !armhf],
  libxi-dev[!arm64 !armhf],
+ mirtest-dev,
  pkg-config,
  python3-all:any,
  python3-setuptools,
@@ -73,6 +75,9 @@ Build-Depends:
  ttf-ubuntu-font-family,
  ubports-wallpapers,
  xvfb,
+# mirtest pkgconfig requires these, but doesn't have a deb dependency. Bug lp:1633537
+ libboost-filesystem-dev,
+ libboost-system-dev,
 Standards-Version: 3.9.4
 Homepage: https://github.com/ubports/unity8
 Vcs-Git: https://github.com/ubports/unity8
@@ -122,6 +127,7 @@ Depends:
  qml-module-qtsysteminfo,
  qtdeclarative5-qtmir-plugin (>= 0.4.8),
  qtdeclarative5-ubuntu-telephony0.1,
+ qtmir-desktop (>= 0.6.0) | qtmir-android (>= 0.6.0), 
  ubuntu-system-settings (>= 0.4),
  unity-launcher-impl-13,
  unity8-common (= ${source:Version}),

debian/unity8.install

@@ -12,7 +12,12 @@ usr/share/unity8/Launcher
 usr/share/unity8/OrientedShell.qml
 usr/share/unity8/Panel
 usr/share/unity8/Rotation
+usr/share/unity8/ErrorApplication.qml
+usr/share/unity8/qmldir
 usr/share/unity8/Shell.qml
+usr/share/unity8/ShellApplication.qml
+usr/share/unity8/ShellNotifier.qml
+usr/share/unity8/ShellScreen.qml
 usr/share/unity8/Stage
 usr/share/unity8/Tutorial
 usr/share/unity8/Wizard

plugins/Cursor/CMakeLists.txt

@@ -15,6 +15,7 @@ set(QMLPLUGIN_SRC
     CursorImageInfo.cpp
     CursorImageProvider.cpp
     MousePointer.cpp
+    InputDispatcherFilter.cpp
     # We need to run moc on this header
     ${APPLICATION_API_INCLUDEDIR}/unity/shell/application/MirMousePointerInterface.h
     )

plugins/Cursor/InputDispatcherFilter.cpp

@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "InputDispatcherFilter.h"
+#include "MousePointer.h"
+
+#include <QEvent>
+#include <QGuiApplication>
+#include <QQuickWindow>
+#include <QScreen>
+#include <QtMath>
+#include <qpa/qplatformnativeinterface.h>
+#include <qpa/qplatformscreen.h>
+
+InputDispatcherFilter *InputDispatcherFilter::instance()
+{
+    static InputDispatcherFilter filter;
+    return &filter;
+}
+
+InputDispatcherFilter::InputDispatcherFilter(QObject *parent)
+    : QObject(parent)
+    , m_pushing(false)
+{
+    QPlatformNativeInterface *ni = QGuiApplication::platformNativeInterface();
+    m_inputDispatcher = static_cast<QObject*>(ni->nativeResourceForIntegration("InputDispatcher"));
+    if (m_inputDispatcher) {
+        m_inputDispatcher->installEventFilter(this);
+    }
+}
+
+void InputDispatcherFilter::registerPointer(MousePointer *pointer)
+{
+    // allow first registered pointer to be visible.
+    m_pointers.insert(pointer);
+}
+
+void InputDispatcherFilter::unregisterPointer(MousePointer *pointer)
+{
+    m_pointers.remove(pointer);
+}
+
+bool InputDispatcherFilter::eventFilter(QObject *o, QEvent *e)
+{
+    if (o != m_inputDispatcher) return false;
+
+    switch (e->type()) {
+        case QEvent::MouseMove:
+        case QEvent::MouseButtonPress:
+        case QEvent::MouseButtonRelease:
+        {
+            // if we don't have any pointers, filter all mouse events.
+            auto pointer = currentPointer();
+            if (!pointer) return true;
+
+            QMouseEvent* me = static_cast<QMouseEvent*>(e);
+
+            // Local position gives relative change of mouse pointer.
+            QPointF movement = me->localPos();
+
+            // Adjust the position
+            QPointF oldPos = pointer->window()->geometry().topLeft() + pointer->position();
+            QPointF newPos = adjustedPositionForMovement(oldPos, movement);
+
+            QScreen* currentScreen = screenAt(newPos);
+            if (currentScreen) {
+                QRect screenRect = currentScreen->geometry();
+                qreal newX = (oldPos + movement).x();
+                qreal newY = (oldPos + movement).y();
+
+                if (newX <= screenRect.left() && newY < screenRect.top() + pointer->topBoundaryOffset()) { // top left corner
+                    const auto distance = qSqrt(qPow(newX, 2) + qPow(newY- screenRect.top() - pointer->topBoundaryOffset(), 2));
+                    Q_EMIT pushedTopLeftCorner(currentScreen, qAbs(distance), me->buttons());
+                    m_pushing = true;
+                } else if (newX >= screenRect.right()-1 && newY < screenRect.top() + pointer->topBoundaryOffset()) { // top right corner
+                    const auto distance = qSqrt(qPow(newX-screenRect.right(), 2) + qPow(newY - screenRect.top() - pointer->topBoundaryOffset(), 2));
+                    Q_EMIT pushedTopRightCorner(currentScreen, qAbs(distance), me->buttons());
+                    m_pushing = true;
+                } else if (newX < 0 && newY >= screenRect.bottom()-1) { // bottom left corner
+                    const auto distance = qSqrt(qPow(newX, 2) + qPow(newY-screenRect.bottom(), 2));
+                    Q_EMIT pushedBottomLeftCorner(currentScreen, qAbs(distance), me->buttons());
+                    m_pushing = true;
+                } else if (newX >= screenRect.right()-1 && newY >= screenRect.bottom()-1) { // bottom right corner
+                    const auto distance = qSqrt(qPow(newX-screenRect.right(), 2) + qPow(newY-screenRect.bottom(), 2));
+                    Q_EMIT pushedBottomRightCorner(currentScreen, qAbs(distance), me->buttons());
+                    m_pushing = true;
+                } else if (newX <  screenRect.left()) { // left edge
+                    Q_EMIT pushedLeftBoundary(currentScreen, qAbs(newX), me->buttons());
+                    m_pushing = true;
+                } else if (newX >=  screenRect.right()) { // right edge
+                    Q_EMIT pushedRightBoundary(currentScreen, newX - (screenRect.right() - 1), me->buttons());
+                    m_pushing = true;
+                } else if (newY < screenRect.top() + pointer->topBoundaryOffset()) { // top edge
+                    Q_EMIT pushedTopBoundary(currentScreen, qAbs(newY - screenRect.top() - pointer->topBoundaryOffset()), me->buttons());
+                    m_pushing = true;
+                } else if (Q_LIKELY(newX > 0 && newX < screenRect.right()-1 && newY > 0 && newY < screenRect.bottom()-1)) { // normal pos, not pushing
+                    if (m_pushing) {
+                        Q_EMIT pushStopped(currentScreen);
+                        m_pushing = false;
+                    }
+                }
+            }
+
+            // Send the event
+            QMouseEvent eCopy(me->type(), me->localPos(), newPos, me->button(), me->buttons(), me->modifiers());
+            eCopy.setTimestamp(me->timestamp());
+            o->event(&eCopy);
+            return true;
+        }
+        default:
+            break;
+    }
+    return false;
+}
+
+QPointF InputDispatcherFilter::adjustedPositionForMovement(const QPointF &pt, const QPointF &movement) const
+{
+    QPointF adjusted = pt + movement;
+
+    auto screen = screenAt(adjusted); // first check if our move was to a screen with an enabled pointer.
+    if (screen) {
+        return adjusted;
+    } else if ((screen = screenAt(pt))) { // then check if our old position was valid
+        QRectF screenBounds = screen->geometry();
+        // bound the new position to the old screen geometry
+        adjusted.rx() = qMax(screenBounds.left(), qMin(adjusted.x(), screenBounds.right()-1));
+        adjusted.ry() = qMax(screenBounds.top(), qMin(adjusted.y(), screenBounds.bottom()-1));
+    } else {
+        auto screens = QGuiApplication::screens();
+
+        // center of first screen with a pointer.
+        Q_FOREACH(QScreen* screen, screens) {
+            Q_FOREACH(MousePointer* pointer, m_pointers) {
+                if (pointer->isEnabled() && pointer->screen() == screen) {
+                    return screen->geometry().center();
+                }
+            }
+        }
+    }
+    return adjusted;
+}
+
+QScreen *InputDispatcherFilter::screenAt(const QPointF &pt) const
+{
+    Q_FOREACH(MousePointer* pointer, m_pointers) {
+        if (!pointer->isEnabled()) continue;
+
+        QScreen* screen = pointer->screen();
+        if (screen && screen->geometry().contains(pt.toPoint()))
+            return screen;
+    }
+    return nullptr;
+}
+
+MousePointer *InputDispatcherFilter::currentPointer() const
+{
+    Q_FOREACH(MousePointer* pointer, m_pointers) {
+        if (!pointer->isEnabled()) continue;
+        return pointer;
+    }
+    return nullptr;
+}

plugins/Cursor/InputDispatcherFilter.h

@@ -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 Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INPUTDISPATCHERFILTER_H
+#define INPUTDISPATCHERFILTER_H
+
+#include <QObject>
+#include <QPointF>
+#include <QSet>
+
+class MousePointer;
+class QScreen;
+
+class InputDispatcherFilter : public QObject
+{
+    Q_OBJECT
+public:
+    static InputDispatcherFilter *instance();
+
+    void registerPointer(MousePointer* pointer);
+    void unregisterPointer(MousePointer* pointer);
+
+Q_SIGNALS:
+    void pushedLeftBoundary(QScreen* screen, qreal amount, Qt::MouseButtons buttons);
+    void pushedRightBoundary(QScreen* screen, qreal amount, Qt::MouseButtons buttons);
+    void pushedTopBoundary(QScreen* screen, qreal amount, Qt::MouseButtons buttons);
+    void pushedTopLeftCorner(QScreen* screen, qreal amount, Qt::MouseButtons buttons);
+    void pushedTopRightCorner(QScreen* screen, qreal amount, Qt::MouseButtons buttons);
+    void pushedBottomLeftCorner(QScreen* screen, qreal amount, Qt::MouseButtons buttons);
+    void pushedBottomRightCorner(QScreen* screen, qreal amount, Qt::MouseButtons buttons);
+    void pushStopped(QScreen* screen);
+
+protected:
+    InputDispatcherFilter(QObject* parent = nullptr);
+
+    bool eventFilter(QObject *o, QEvent *e) override;
+
+    QPointF adjustedPositionForMovement(const QPointF& pt, const QPointF& movement) const;
+    QScreen* screenAt(const QPointF& pt) const;
+
+    MousePointer* currentPointer() const;
+
+private:
+    QObject* m_inputDispatcher;
+    QSet<MousePointer*> m_pointers;
+    bool m_pushing;
+};
+
+#endif // INPUTDISPATCHERFILTER_H