Merge lp:~dandrader/unity-api/miral into lp:~unity-team/unity-api/miral

[Daniel d'Andrada]

unity::shel::application - changes for the miral way of doing things

Adds TopLevelWindowModelInterface and WindowInterface

=== modified file 'debian/changelog'
--- debian/changelog	2016-09-09 14:39:28 +0000
+++ debian/changelog	2016-11-01 19:35:04 +0000
@@ -1,3 +1,9 @@
+unity-api (7.120) UNRELEASED; urgency=medium
+
+  * unity::shel::application - changes for the miral way of doing things
+
+ -- Daniel d'Andrada <[e-mail]>  Tue, 01 Nov 2016 17:25:38 -0200
+
 unity-api (7.119+16.10.20160909-0ubuntu1) yakkety; urgency=medium
 
   [ Daniel d'Andrada ]

=== modified file 'include/unity/shell/application/CMakeLists.txt'
--- include/unity/shell/application/CMakeLists.txt	2016-09-05 13:21:24 +0000
+++ include/unity/shell/application/CMakeLists.txt	2016-11-01 19:35:04 +0000
@@ -7,7 +7,7 @@
 
 set(UNITY_API_LIB_HDRS ${UNITY_API_LIB_HDRS} ${headers} ${internal_headers} PARENT_SCOPE)
 
-set(VERSION 22)
+set(VERSION 23)
 set(PKGCONFIG_NAME "unity-shell-application")
 set(PKGCONFIG_DESCRIPTION "Unity shell Application APIs")
 set(PKGCONFIG_REQUIRES "Qt5Core")

=== added file 'include/unity/shell/application/TopLevelWindowModelInterface.h'
--- include/unity/shell/application/TopLevelWindowModelInterface.h	1970-01-01 00:00:00 +0000
+++ include/unity/shell/application/TopLevelWindowModelInterface.h	2016-11-01 19:35:04 +0000
@@ -0,0 +1,152 @@
+/*
+ * 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/>.
+ */
+
+#ifndef UNITY_SHELL_APPLICATION_TOPLEVELWINDOWMODELINTERFACE_H
+#define UNITY_SHELL_APPLICATION_TOPLEVELWINDOWMODELINTERFACE_H
+
+#include <QAbstractListModel>
+
+namespace unity
+{
+namespace shell
+{
+namespace application
+{
+
+class ApplicationInfoInterface;
+class MirSurfaceInterface;
+class WindowInterface;
+
+/**
+ * @brief A model of top-level surfaces
+ *
+ * It's an abstraction of top-level application windows.
+ *
+ * When an entry first appears, it normaly doesn't have a surface yet, meaning that the application is
+ * still starting up. A shell should then display a splash screen or saved screenshot of the application
+ * until its surface comes up.
+ *
+ * As applications can have multiple surfaces and you can also have entries without surfaces at all,
+ * the only way to unambiguously refer to an entry in this model is through its id.
+ */
+class TopLevelWindowModelInterface : public QAbstractListModel
+{
+    Q_OBJECT
+
+    /**
+     * @brief Number of top-level surfaces in this model
+     *
+     * This is the same as rowCount, added in order to keep compatibility with QML ListModels.
+     */
+    Q_PROPERTY(int count READ rowCount NOTIFY countChanged)
+
+    /**
+     * @brief The input method surface, if any
+     *
+     * The surface of a onscreen keyboard (akak "virtual keyboard") would be kept here and not in the model itself.
+     */
+    Q_PROPERTY(unity::shell::application::MirSurfaceInterface* inputMethodSurface READ inputMethodSurface NOTIFY inputMethodSurfaceChanged)
+
+    /**
+     * @brief The currently focused window, if any
+     */
+    Q_PROPERTY(unity::shell::application::WindowInterface* focusedWindow READ focusedWindow
+                                                                         NOTIFY focusedWindowChanged)
+public:
+    /**
+     * @brief The Roles supported by the model
+     *
+     * WindowRole - A WindowInterface. It will be null if the application is still starting up
+     * ApplicationRole - An ApplicationInfoInterface
+     */
+    enum Roles {
+        WindowRole = Qt::UserRole,
+        ApplicationRole = Qt::UserRole + 1,
+    };
+
+    virtual ~TopLevelWindowModelInterface() {}
+
+    QHash<int, QByteArray> roleNames() const override {
+        QHash<int, QByteArray> roleNames { {WindowRole, "window"},
+                                           {ApplicationRole, "application"} };
+        return roleNames;
+    }
+
+    /// @cond
+    virtual MirSurfaceInterface* inputMethodSurface() const = 0;
+    virtual WindowInterface* focusedWindow() const = 0;
+    /// @endcond
+
+public Q_SLOTS:
+    /**
+     * @brief Returns the surface at the given index
+     *
+     * It will be a nullptr if the application is still starting up and thus hasn't yet created
+     * and drawn into a surface.
+     *
+     * Same as windowAt(index).surface()
+     */
+    virtual MirSurfaceInterface *surfaceAt(int index) const = 0;
+
+    /**
+     * @brief Returns the window at the given index
+     *
+     * Will always be valid
+     */
+    virtual WindowInterface *windowAt(int index) const = 0;
+
+    /**
+     * @brief Returns the application at the given index
+     */
+    virtual ApplicationInfoInterface *applicationAt(int index) const = 0;
+
+    /**
+     * @brief Returns the unique id of the element at the given index
+     */
+    virtual int idAt(int index) const = 0;
+
+    /**
+     * @brief Returns the index where the row with the given id is located
+     *
+     * Returns -1 if there's no row with the given id.
+     */
+    virtual int indexForId(int id) const = 0;
+
+    /**
+     * @brief Raises the row with the given id to the top of the window stack (index == count-1)
+     */
+    virtual void raiseId(int id) = 0;
+
+Q_SIGNALS:
+    /// @cond
+    void countChanged();
+    void inputMethodSurfaceChanged(unity::shell::application::MirSurfaceInterface* inputMethodSurface);
+    void focusedWindowChanged(unity::shell::application::WindowInterface *focusedWindow);
+    /// @endcond
+
+    /**
+     * @brief Emitted when the list changes
+     *
+     * Emitted when model gains an element, loses an element or when elements exchange positions.
+     */
+    void listChanged();
+};
+
+} // namespace application
+} // namespace shell
+} // namespace unity
+
+#endif // UNITY_SHELL_APPLICATION_TOPLEVELWINDOWMODELINTERFACE_H

=== added file 'include/unity/shell/application/WindowInterface.h'
--- include/unity/shell/application/WindowInterface.h	1970-01-01 00:00:00 +0000
+++ include/unity/shell/application/WindowInterface.h	2016-11-01 19:35:04 +0000
@@ -0,0 +1,144 @@
+/*
+ * 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/>.
+ */
+
+#ifndef UNITY_SHELL_APPLICATION_WINDOW_H
+#define UNITY_SHELL_APPLICATION_WINDOW_H
+
+#include <QObject>
+#include <QPoint>
+
+#include "Mir.h"
+
+namespace unity
+{
+namespace shell
+{
+namespace application
+{
+
+class MirSurfaceInterface;
+
+/**
+   @brief A slightly higher concept than MirSurface
+
+   A Window exists before its MirSurface gets created (for splashscreen purposes)
+   and might also hang around after the backing surface is gone (In case the application
+   was killed to free up memory, as it should still remain in the window list since the user
+   did not explicitly close it).
+ */
+class WindowInterface : public QObject
+{
+    Q_OBJECT
+
+    /**
+     * @brief Position of the current surface buffer, in pixels.
+     */
+    Q_PROPERTY(QPoint position READ position NOTIFY positionChanged)
+
+    /**
+     * @brief Requested position of the current surface buffer, in pixels.
+     */
+    Q_PROPERTY(QPoint requestedPosition READ requestedPosition WRITE setRequestedPosition NOTIFY requestedPositionChanged)
+
+    /**
+     * @brief State of the surface
+     */
+    Q_PROPERTY(Mir::State state READ state NOTIFY stateChanged)
+
+    /**
+     * @brief Whether the surface is focused
+     *
+     * It will be true if this surface is MirFocusControllerInterface::focusedSurface
+     */
+    Q_PROPERTY(bool focused READ focused NOTIFY focusedChanged)
+
+    /**
+     * @brief Whether the surface wants to confine the mouse pointer within its boundaries
+     *
+     * If true, the surface doesn't want the mouse pointer to leave its boundaries while it's focused.
+     */
+    Q_PROPERTY(bool confinesMousePointer READ confinesMousePointer NOTIFY confinesMousePointerChanged)
+
+    /**
+     * @brief A unique identifier for this window.
+     * Useful for telling windows apart in a list model as they get moved around
+     */
+    Q_PROPERTY(int id READ id CONSTANT)
+
+    /**
+     * @brief Surface backing up this window
+     * It might be null if a surface hasn't been created yet (application is starting up) or if
+     * the corresponding application has been killed (but can still get restarted to continue from
+     * where it left)
+     */
+    Q_PROPERTY(unity::shell::application::MirSurfaceInterface* surface READ surface NOTIFY surfaceChanged)
+
+public:
+    /// @cond
+    WindowInterface(QObject *parent = nullptr) : QObject(parent) {}
+    virtual QPoint position() const = 0;
+    virtual QPoint requestedPosition() const = 0;
+    virtual void setRequestedPosition(const QPoint &) = 0;
+    virtual Mir::State state() const = 0;
+    virtual bool focused() const = 0;
+    virtual bool confinesMousePointer() const = 0;
+    virtual int id() const = 0;
+    virtual MirSurfaceInterface* surface() const = 0;
+    /// @endcond
+
+public Q_SLOTS:
+    /**
+     * @brief Requests a change to the specified state
+     */
+    virtual void requestState(Mir::State state) = 0;
+
+    /**
+     * @brief Requests focus for this surface
+     *
+     * Causes the emission of focusRequested()
+     */
+    virtual void requestFocus() = 0;
+
+    /**
+     * @brief Sends a close request
+     *
+     */
+    virtual void close() = 0;
+
+Q_SIGNALS:
+    /// @cond
+    void positionChanged(QPoint position);
+    void requestedPositionChanged(QPoint position);
+    void stateChanged(Mir::State value);
+    void focusedChanged(bool value);
+    void confinesMousePointerChanged(bool value);
+    void surfaceChanged(unity::shell::application::MirSurfaceInterface *surface);
+    /// @endcond
+
+    /**
+     * @brief Emitted in response to a requestFocus() call
+     */
+    void focusRequested();
+};
+
+
+} // namespace application
+} // namespace shell
+} // namespace unity
+
+Q_DECLARE_METATYPE(unity::shell::application::WindowInterface*)
+
+#endif // UNITY_SHELL_APPLICATION_WINDOw_H