Merge lp:~unity-team/unity-api/add-surfacemanager-and-item into lp:~unity-team/unity-api/qtMirCompositor

[Michael Zanetti]

Add support for Surfaces to Unity.Application api.

To be discussed...

[Michał Sawicz (saviq)]

On 01.05.2014 15:48, Michael Zanetti wrote:
> + enum State {
> + Unknown = mir_surface_state_unknown,
> + Restored = mir_surface_state_restored,
> + Minimized = mir_surface_state_minimized,
> + Maximized = mir_surface_state_maximized,
> + VertMaximized = mir_surface_state_vertmaximized,
> + /* SemiMaximized = mir_surface_state_semimaximized, // see mircommon/mir_toolbox/common.h*/
> + Fullscreen = mir_surface_state_fullscreen,
> + };

We've been playing with the idea of expressing "stage-ness" with those
(since we probably want to support sidestage on desktop). I understand
Mir probably doesn't want explicit MainStage, SideStage, but maybe
something could be discussed?

> + void surfaceCreated(SurfaceItemInterface* surface);
> + void surfaceDestroyed(SurfaceItemInterface* surface);

Wouldn't those be redundant to row additions/removals? What's the use
case here?

> +protected:
> + /// @cond
> + QHash<int, QByteArray> m_roleNames;

I know this is early, but didn't we decide that creating the hash
dynamically in roleNames() is better, since there's no use for this
member other than returning it from there (and only once in most cases)?

[Michael Zanetti (mzanetti)]

> On 01.05.2014 15:48, Michael Zanetti wrote:
> > + enum State {
> > + Unknown = mir_surface_state_unknown,
> > + Restored = mir_surface_state_restored,
> > + Minimized = mir_surface_state_minimized,
> > + Maximized = mir_surface_state_maximized,
> > + VertMaximized = mir_surface_state_vertmaximized,
> > + /* SemiMaximized = mir_surface_state_semimaximized, // see
> mircommon/mir_toolbox/common.h*/
> > + Fullscreen = mir_surface_state_fullscreen,
> > + };
>
> We've been playing with the idea of expressing "stage-ness" with those
> (since we probably want to support sidestage on desktop). I understand
> Mir probably doesn't want explicit MainStage, SideStage, but maybe
> something could be discussed?

I haven't been part of that so I might not know all details, but seems to me that Stage-ness is more related to the whole application instead of a single surface. Or do we want to allow a single Application to paint to the Main and Side stage at the same time?

>
> > + void surfaceCreated(SurfaceItemInterface* surface);
> > + void surfaceDestroyed(SurfaceItemInterface* surface);
>
> Wouldn't those be redundant to row additions/removals? What's the use
> case here?

I've added them in ApplicationManager because its really nasty to figure which one has been added/removed without having knowledge of the QModelIndex. So I thought they'd be useful here too. They'll probably change to "surfaceAdded(surfaceId)" and "surfaceRemoved(surfaceId)" as I'm pushing for allowing the QML context to create and destroy SurfaceItems as required and binding them to a surfaceId. That way we can have multiple SurfaceItems (App stack, alt+tab switcher, launcher preview etc) painting the same surface.

>
> > +protected:
> > + /// @cond
> > + QHash<int, QByteArray> m_roleNames;
>
> I know this is early, but didn't we decide that creating the hash
> dynamically in roleNames() is better, since there's no use for this
> member other than returning it from there (and only once in most cases)?

right... will change, thanks for the pointer.

[lp:~unity-team/unity-api/add-surfacemanager-and-item]

130. By Michael Zanetti on 2014-05-01

some more work on the new surface api

131. By Michael Zanetti on 2014-05-05

Split SurfaceItem into SurfaceItem and Surface.

132. By Michael Zanetti on 2014-05-05

some cleanup and commenting

133. By Michael Zanetti on 2014-05-05

make tests work

134. By Michael Zanetti on 2014-05-05

also make use of setting the surface property

[Gerry Boland (gerboland)]

+++ include/unity/shell/application/SurfaceInterface.h
+ Q_PROPERTY(QString appId READ appId CONSTANT)
Why not a pointer to the application?

Would be useful to be able to directly read Application info in QML with something like: "surface.application.stage" as opposed to searching for the application with that appId.

It will require care to ensure the Application isn't used if it is deleted though (since a SurfaceItem will have QML ownership, but Application C++ ownership).

I expect the Application has some properties that we easily want to monitor per-surface, examples that come to mind are stage, supportedStages, state, hasFrozen (if app not responding) and maybe focus.

Note every Surface must have an Application behind it, else we make our lives hard IMO.

+class UNITY_API SurfaceItemInterface: public QQuickItem
Design is exactly what I had in mind.

I'm wondering though if instead of accessing the surface properties like:
"mySurfaceItem.surface.name" it might be handy to add the relevant setters/getters to the SurfaceItem so that can just do "mySurfaceItem.name"
What do you think? It's syntactic sugar really...

+ * @brief Get a Surface item (using stack index).
Stack or list?

Nitpick:
+ while (!m_list.empty())
+ {
brace on same line.

Overall this API is plenty to get us moving.
One thing I note is that getting info on the application which generates a surface is easy, but getting the surfaces that an application generates is hard. I can't come up with a good reason why the latter is needed however, so for now let's leave it as it is.

review: Needs Fixing

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:134
https://unity8-jenkins.ubuntu.com/job/lp-unity-api-ci/48/
Executed test runs:
    FAILURE: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/1135/console

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

review: Needs Fixing (continuous-integration)

[Michał Sawicz (saviq)]

Text conflict in test/qmltest/mocks/plugins/Unity/Application/CMakeLists.txt
Text conflict in test/qmltest/unity/shell/CMakeLists.txt
2 conflicts encountered.

Unmerged revisions

134. By Michael Zanetti on 2014-05-05

also make use of setting the surface property

133. By Michael Zanetti on 2014-05-05

make tests work

132. By Michael Zanetti on 2014-05-05

some cleanup and commenting

131. By Michael Zanetti on 2014-05-05

Split SurfaceItem into SurfaceItem and Surface.

130. By Michael Zanetti on 2014-05-01

some more work on the new surface api

129. By Michael Zanetti on 2014-04-08

some cleanup

128. By Michael Zanetti on 2014-04-08

add very first draft of SurfaceManagerInterface and SurfaceItemInterface

=== modified file 'include/unity/shell/application/ApplicationManagerInterface.h'
--- include/unity/shell/application/ApplicationManagerInterface.h	2014-03-10 12:40:25 +0000
+++ include/unity/shell/application/ApplicationManagerInterface.h	2014-05-05 12:17:41 +0000
@@ -82,7 +82,6 @@
         connect(this, SIGNAL(rowsInserted(QModelIndex, int, int)), SIGNAL(countChanged()));
         connect(this, SIGNAL(rowsRemoved(QModelIndex, int, int)), SIGNAL(countChanged()));
         connect(this, SIGNAL(modelReset()), SIGNAL(countChanged()));
-        connect(this, SIGNAL(layoutChanged()), SIGNAL(countChanged()));
     }
     /// @endcond
 

=== added file 'include/unity/shell/application/SurfaceInterface.h'
--- include/unity/shell/application/SurfaceInterface.h	1970-01-01 00:00:00 +0000
+++ include/unity/shell/application/SurfaceInterface.h	2014-05-05 12:17:41 +0000
@@ -0,0 +1,136 @@
+/*
+ * Copyright (C) 2014 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 SURFACEINTERFACE_H
+#define SURFACEINTERFACE_H
+
+#include <unity/SymbolExport.h>
+
+#include <QObject>
+
+namespace unity
+{
+namespace shell
+{
+namespace application
+{
+
+class SurfaceManagerInterface;
+class ApplicationInfoInterface;
+
+/**
+ * @brief A class that holds information about an application's surface
+ *
+ * The items hold all the information required for the visual representation
+ * of a surface.
+ */
+
+class UNITY_API SurfaceInterface: public QObject
+{
+    Q_OBJECT
+    Q_ENUMS(Type)
+    Q_ENUMS(SurfaceState)
+
+    /**
+     * @brief The type of this surface.
+     *
+     * Gives information about the type of this surface. E.g. it is a normal window or a modal popup.
+     */
+    Q_PROPERTY(Type type READ type NOTIFY typeChanged)
+
+    /**
+     * @brief The state of this surface.
+     *
+     * Holds information about the state of this surface. E.g. it is shown normally or minimized.
+     */
+    Q_PROPERTY(SurfaceState surfaceState READ surfaceState NOTIFY surfaceStateChanged)
+
+    /**
+     * @brief The name of this surface.
+     *
+     * Holds the name of this surface. Can be used e.g. for the window title.
+     */
+    Q_PROPERTY(QString name READ name NOTIFY nameChanged)
+
+    /**
+     * @brief The application this surface belongs to.
+     *
+     * A 1:n connection between surfaces and applications. A surface always refers to one
+     * application, while an application might have many surfaces.
+     */
+    Q_PROPERTY(QString appId READ appId CONSTANT)
+
+public:
+    /**
+     * @brief The type of a surface.
+     *
+     * This enum defines all possible values for Surface types.
+     */
+    enum Type {
+        TypeNormal,
+        TypeUtility,
+        TypeDialog,
+        TypeOverlay,
+        TypeFreestyle,
+        TypePopover,
+        TypeInputMethod,
+    };
+
+    /**
+     * @brief The state of a surface.
+     *
+     * This enum defines all possible values for Surface states.
+     */
+    enum SurfaceState {
+        SurfaceStateUnknown,
+        SurfaceStateRestored,
+        SurfaceStateMinimized,
+        SurfaceStateMaximized,
+        SurfaceStateVertMaximized,
+        /* SurfaceStateSemiMaximized, // see mircommon/mir_toolbox/common.h*/
+        SurfaceStateFullscreen,
+    };
+
+    /**
+     * @brief Constructs a new Surface.
+     *
+     * Usually Surfaces are only created by the ApplicationManager and/or SurfaceManager.
+     */
+    explicit SurfaceInterface(QObject *parent = 0): QObject(parent) {}
+    virtual ~SurfaceInterface() {}
+
+    /// @cond
+    virtual QString appId() const = 0;
+    virtual Type type() const = 0;
+    virtual SurfaceState surfaceState() const = 0;
+    virtual QString name() const = 0;
+    /// @endcond
+
+Q_SIGNALS:
+    /// @cond
+    void typeChanged();
+    void surfaceStateChanged();
+    void nameChanged();
+    void appIdChanged();
+    void surfaceDestroyed();
+    /// @endcond
+};
+
+} // namespace application
+} // namespace shell
+} // namespace unity
+
+#endif // SURFACEINTERFACE_H

=== added file 'include/unity/shell/application/SurfaceItemInterface.h'
--- include/unity/shell/application/SurfaceItemInterface.h	1970-01-01 00:00:00 +0000
+++ include/unity/shell/application/SurfaceItemInterface.h	2014-05-05 12:17:41 +0000
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2014 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 UNITY_SHELL_APPLICATION_SURFACEITEMINTERFACE_H
+#define UNITY_SHELL_APPLICATION_SURFACEITEMINTERFACE_H
+
+#include <unity/SymbolExport.h>
+
+#include "SurfaceInterface.h"
+
+#include <QQuickItem>
+
+namespace unity
+{
+namespace shell
+{
+namespace application
+{
+
+class SurfaceManagerInterface;
+class Application;
+
+/**
+ * @brief A class that paints a SurfaceInterface in QML.
+ *
+ * This class doesn't hold any data on its own but is used to paint a SurfaceInterface
+ * in QML. SurfaceItems can be created and destroyed by the QML context as if they
+ * were plain Rectangles. By assigning a SurfaceInterface to it, application
+ * surfaces can be painted in the shell.
+ */
+
+class UNITY_API SurfaceItemInterface: public QQuickItem
+{
+    Q_OBJECT
+
+    /**
+     * @brief The surface that should be painted.
+     *
+     * Set this to the Surface you want to have painted by this SurfaceItem.
+     */
+    Q_PROPERTY(unity::shell::application::SurfaceInterface* surface MEMBER m_surface NOTIFY surfaceChanged)
+
+public:
+
+    /**
+     * @brief Constructs a SurfaceItem.
+     *
+     * Usually SurfaceItems are created within QML.
+     */
+    explicit SurfaceItemInterface(QQuickItem *parent = 0): QQuickItem(parent) {}
+    virtual ~SurfaceItemInterface() {}
+
+Q_SIGNALS:
+    /// @cond
+    void surfaceChanged();
+    /// @endcond
+
+private:
+    SurfaceInterface *m_surface;
+};
+
+} // namespace application
+} // namespace shell
+} // namespace unity
+
+#endif // UNITY_SHELL_APPLICATION_SURFACEITEMINTERFACE_H

=== added file 'include/unity/shell/application/SurfaceManagerInterface.h'
--- include/unity/shell/application/SurfaceManagerInterface.h	1970-01-01 00:00:00 +0000
+++ include/unity/shell/application/SurfaceManagerInterface.h	2014-05-05 12:17:41 +0000
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2014 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 UNITY_SHELL_APPLICATION_SURFACEMANGERINTERFACE_H
+#define UNITY_SHELL_APPLICATION_SURFACEMANGERINTERFACE_H
+
+#include <unity/SymbolExport.h>
+
+#include <QAbstractListModel>
+
+namespace unity
+{
+namespace shell
+{
+namespace application
+{
+
+class SurfaceInterface;
+
+/**
+ * @brief The SurfaceManager is a model which holds all the available surfaces.
+ *
+ * This is the main class to interact with surfaces.
+ */
+
+class UNITY_API SurfaceManagerInterface : public QAbstractListModel
+{
+    Q_OBJECT
+    Q_ENUMS(Roles)
+
+    /**
+     * @brief The count of the surfaces known to the manager.
+     *
+     * This is the same as rowCount, added in order to keep compatibility with QML ListModels.
+     */
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
+
+public:
+    /**
+     * @brief The Roles supported by the model
+     *
+     * See SurfaceInterface properties for details.
+     */
+    enum Roles {
+        RoleType,
+        RoleSurfaceState,
+        RoleName,
+        RoleApplicationId
+    };
+
+    virtual ~SurfaceManagerInterface() {}
+
+    /// @cond
+    virtual QHash<int, QByteArray> roleNames() const
+    {
+        QHash<int, QByteArray> roles;
+        roles.insert(RoleType, "type");
+        roles.insert(RoleSurfaceState, "surfaceState");
+        roles.insert(RoleName, "name");
+        roles.insert(RoleApplicationId, "appId");
+        return roles;
+    }
+
+    int count() const {
+        return rowCount();
+    }
+    /// @endcond
+
+    /**
+     * @brief Get a Surface item (using stack index).
+     *
+     * Note: QML requires the full namespace in the return value.
+     *
+     * @param index the index of the item to get
+     * @returns The item, or null if not found.
+     */
+    Q_INVOKABLE virtual unity::shell::application::SurfaceInterface *get(int index) const = 0;
+
+protected:
+    /// @cond
+    SurfaceManagerInterface(QObject *parent = 0):
+        QAbstractListModel(parent)
+    {
+        connect(this, &QAbstractListModel::rowsInserted, this, &SurfaceManagerInterface::countChanged);
+        connect(this, &QAbstractListModel::rowsRemoved, this, &SurfaceManagerInterface::countChanged);
+        connect(this, &QAbstractListModel::modelReset, this, &SurfaceManagerInterface::countChanged);
+    }
+    /// @endcond
+
+Q_SIGNALS:
+    /// @cond
+    void countChanged();
+    /// @endcond
+
+    /**
+     * @brief Indicates that a new surface has been created.
+     *
+     * This will be emitted when a new surface has been created and added
+     * to the model. It is the same as the rowsInserted() but more QML friendly.
+     */
+    void surfaceCreated(SurfaceInterface* surface);
+
+    /**
+     * @brief Indicates that a surface has been destroyed.
+     *
+     * This will be emitted when a surface has been destroyed and removed
+     * from the model. It is the same as the rowsRemoved() but more QML friendly.
+     */
+    void surfaceDestroyed(SurfaceInterface* surface);
+
+};
+
+} // namespace application
+} // namespace shell
+} // namespace unity
+
+#endif // UNITY_SHELL_APPLICATION_SURFACEMANGERINTERFACE_H

=== modified file 'test/qmltest/mocks/plugins/Unity/Application/CMakeLists.txt'
--- test/qmltest/mocks/plugins/Unity/Application/CMakeLists.txt	2013-08-29 12:54:56 +0000
+++ test/qmltest/mocks/plugins/Unity/Application/CMakeLists.txt	2014-05-05 12:17:41 +0000
@@ -13,13 +13,19 @@
 set(ApplicationMocks_SOURCES
     ${CMAKE_SOURCE_DIR}/include/unity/shell/application/ApplicationManagerInterface.h
     ${CMAKE_SOURCE_DIR}/include/unity/shell/application/ApplicationInfoInterface.h
+    ${CMAKE_SOURCE_DIR}/include/unity/shell/application/SurfaceManagerInterface.h
+    ${CMAKE_SOURCE_DIR}/include/unity/shell/application/SurfaceItemInterface.h
+    ${CMAKE_SOURCE_DIR}/include/unity/shell/application/SurfaceInterface.h
     Mocks/MockApplicationManager.cpp
     Mocks/MockApplicationInfo.cpp
+    Mocks/MockSurfaceManager.cpp
+    Mocks/MockSurfaceItem.cpp
+    Mocks/MockSurface.cpp
 )
 
 add_library(ApplicationMocks SHARED ${ApplicationMocks_SOURCES})
 
-qt5_use_modules(ApplicationMocks Core)
+qt5_use_modules(ApplicationMocks Core Quick)
 
 set(TestApplicationPlugin_SOURCES
     TestApplicationPlugin.cpp

=== added file 'test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurface.cpp'
--- test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurface.cpp	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurface.cpp	2014-05-05 12:17:41 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2014 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 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 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/>.
+ *
+ * Authors:
+ *      Michael Zanetti <[e-mail]>
+ */
+
+#include <Mocks/MockSurface.h>
+
+using namespace unity::shell::application;
+
+MockSurface::MockSurface(const QString &appId, const QString &name, QObject *parent):
+    SurfaceInterface(parent),
+    m_appId(appId),
+    m_name(name)
+{
+
+}
+
+QString MockSurface::appId() const
+{
+    return m_appId;
+}
+
+SurfaceInterface::Type MockSurface::type() const
+{
+    return SurfaceInterface::TypeNormal;
+}
+
+SurfaceInterface::SurfaceState MockSurface::surfaceState() const
+{
+    return SurfaceInterface::SurfaceStateRestored;
+}
+
+QString MockSurface::name() const
+{
+    return m_name;
+}

=== added file 'test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurface.h'
--- test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurface.h	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurface.h	2014-05-05 12:17:41 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2014 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 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 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/>.
+ *
+ * Authors:
+ *      Michael Zanetti <[e-mail]>
+ */
+
+#ifndef MOCKSURFACE_H
+#define MOCKSURFACE_H
+
+#include <SurfaceInterface.h>
+
+#include <QUrl>
+
+using namespace unity::shell::application;
+
+class UNITY_API MockSurface: public SurfaceInterface
+{
+    Q_OBJECT
+public:
+    MockSurface(const QString &appId, const QString &name, QObject* parent = 0);
+
+    QString appId() const override;
+    SurfaceInterface::Type type() const override;
+    SurfaceInterface::SurfaceState surfaceState() const override;
+    QString name() const override;
+
+private:
+    QString m_appId;
+    QString m_name;
+};
+
+#endif // MOCKSURFACE_H

=== added file 'test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceItem.cpp'
--- test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceItem.cpp	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceItem.cpp	2014-05-05 12:17:41 +0000
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2014 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 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 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/>.
+ *
+ * Authors:
+ *      Michael Zanetti <[e-mail]>
+ */
+
+#include <Mocks/MockSurfaceItem.h>
+
+using namespace unity::shell::application;
+
+MockSurfaceItem::MockSurfaceItem(QQuickItem *parent):
+    SurfaceItemInterface(parent)
+{
+
+}

=== added file 'test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceItem.h'
--- test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceItem.h	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceItem.h	2014-05-05 12:17:41 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2014 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 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 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/>.
+ *
+ * Authors:
+ *      Michael Zanetti <[e-mail]>
+ */
+
+#ifndef MOCKSURFACEITEM_H
+#define MOCKSURFACEITEM_H
+
+#include <SurfaceItemInterface.h>
+
+#include <QUrl>
+
+using namespace unity::shell::application;
+
+class UNITY_API MockSurfaceItem: public SurfaceItemInterface
+{
+    Q_OBJECT
+public:
+    MockSurfaceItem(QQuickItem* parent = 0);
+
+private:
+};
+
+#endif // MOCKSURFACEITEM_H

=== added file 'test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceManager.cpp'
--- test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceManager.cpp	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceManager.cpp	2014-05-05 12:17:41 +0000
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2014 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 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 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/>.
+ *
+ * Authors:
+ *      Michael Zanetti <[e-mail]>
+ */
+
+#include <Mocks/MockSurfaceManager.h>
+#include <Mocks/MockSurface.h>
+
+using namespace unity::shell::application;
+
+MockSurfaceManager::MockSurfaceManager(QObject* parent): SurfaceManagerInterface(parent)
+{
+    MockSurface *item = new MockSurface("dialer-app", "surface1", this);
+    m_list.append(item);
+}
+
+MockSurfaceManager::~MockSurfaceManager()
+{
+    while (!m_list.empty())
+    {
+        m_list.takeFirst()->deleteLater();
+    }
+}
+
+// cppcheck-suppress unusedFunction
+int MockSurfaceManager::rowCount(const QModelIndex& parent) const
+{
+    Q_UNUSED(parent)
+    return m_list.count();
+}
+
+QVariant MockSurfaceManager::data(const QModelIndex& index, int role) const
+{
+    switch (role) {
+    case RoleApplicationId:
+        return m_list.at(index.row())->appId();
+    case RoleName:
+        return m_list.at(index.row())->name();
+    case RoleType:
+        return m_list.at(index.row())->type();
+    case RoleSurfaceState:
+        return m_list.at(index.row())->surfaceState();
+    }
+
+    return QVariant();
+}
+
+SurfaceInterface *MockSurfaceManager::get(int index) const
+{
+    if (m_list.count() > index) {
+        return m_list.at(index);
+    }
+    return nullptr;
+}

=== added file 'test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceManager.h'
--- test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceManager.h	1970-01-01 00:00:00 +0000
+++ test/qmltest/mocks/plugins/Unity/Application/Mocks/MockSurfaceManager.h	2014-05-05 12:17:41 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2014 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 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 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/>.
+ *
+ * Authors:
+ *      Michael Zanetti <[e-mail]>
+ */
+
+#ifndef MOCKSURFACEMANAGER_H
+#define MOCKSURFACEMANAGER_H
+
+#include <SurfaceManagerInterface.h>
+
+using namespace unity::shell::application;
+
+class MockSurface;
+
+class UNITY_API MockSurfaceManager: public SurfaceManagerInterface
+{
+   Q_OBJECT
+
+public:
+    MockSurfaceManager(QObject* parent = 0);
+    ~MockSurfaceManager();
+
+    int rowCount(const QModelIndex& parent) const override;
+
+    QVariant data(const QModelIndex& index, int role) const override;
+
+    Q_INVOKABLE unity::shell::application::SurfaceInterface* get(int index) const override;
+
+private:
+    QList<MockSurface*> m_list;
+};
+
+#endif // MOCKSURFACEMANAGER_H

=== modified file 'test/qmltest/mocks/plugins/Unity/Application/TestApplicationPlugin.cpp'
--- test/qmltest/mocks/plugins/Unity/Application/TestApplicationPlugin.cpp	2013-08-29 12:54:56 +0000
+++ test/qmltest/mocks/plugins/Unity/Application/TestApplicationPlugin.cpp	2014-05-05 12:17:41 +0000
@@ -20,26 +20,45 @@
 #include <TestApplicationPlugin.h>
 #include <Mocks/MockApplicationManager.h>
 #include <Mocks/MockApplicationInfo.h>
+#include <Mocks/MockSurfaceManager.h>
+#include <Mocks/MockSurfaceItem.h>
+#include <Mocks/MockSurface.h>
 
 #include <ApplicationManagerInterface.h>
 #include <ApplicationInfoInterface.h>
+#include <SurfaceManagerInterface.h>
+#include <SurfaceItemInterface.h>
+#include <SurfaceInterface.h>
 
 #include <QtQml/qqml.h>
 
 using namespace unity::shell::application;
 
-static QObject* modelProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)
+static QObject* applicationManagerProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)
 {
     return new MockApplicationManager();
 }
 
+static QObject* surfaceManagerProvider(QQmlEngine* /* engine */, QJSEngine* /* scriptEngine */)
+{
+    return new MockSurfaceManager();
+}
+
 // cppcheck-suppress unusedFunction
 void TestApplicationPlugin::registerTypes(const char* uri)
 {
     // @uri Unity.Application
     qmlRegisterUncreatableType<ApplicationManagerInterface>(uri, 0, 1, "ApplicationManagerInterface", "Interface for the ApplicationManager");
-    qmlRegisterUncreatableType<ApplicationInfoInterface>(uri, 0, 1, "ApplicationInfoInterface", "Interface for the ApplicationInfo");
+    qmlRegisterUncreatableType<ApplicationInfoInterface>(uri, 0, 1, "ApplicationInfoInterface", "Interface for ApplicationInfo");
 
-    qmlRegisterSingletonType<MockApplicationManager>(uri, 0, 1, "ApplicationManager", modelProvider);
+    qmlRegisterSingletonType<MockApplicationManager>(uri, 0, 1, "ApplicationManager", applicationManagerProvider);
     qmlRegisterUncreatableType<MockApplicationInfo>(uri, 0, 1, "ApplicationInfo", "Can't create ApplicationInfos in QML. Get them from the ApplicationManager");
+
+    qmlRegisterUncreatableType<SurfaceManagerInterface>(uri, 0, 1, "SurfaceManagerInterface", "Interface for the SurfaceManager");
+    qmlRegisterUncreatableType<SurfaceItemInterface>(uri, 0, 1, "SurfaceItemInterface", "Interface for SurfaceItem");
+    qmlRegisterUncreatableType<SurfaceInterface>(uri, 0, 1, "SurfaceInterface", "Interface for Surface");
+
+    qmlRegisterSingletonType<MockSurfaceManager>(uri, 0, 1, "SurfaceManager", surfaceManagerProvider);
+    qmlRegisterUncreatableType<MockSurface>(uri, 0, 1, "Surface", "Can't create Surfaces in QML. Get them from the SurfaceManager");
+    qmlRegisterType<MockSurfaceItem>(uri, 0, 1, "SurfaceItem");
 }

=== modified file 'test/qmltest/unity/shell/CMakeLists.txt'
--- test/qmltest/unity/shell/CMakeLists.txt	2013-08-29 11:33:59 +0000
+++ test/qmltest/unity/shell/CMakeLists.txt	2014-05-05 12:17:41 +0000
@@ -9,3 +9,4 @@
 add_qml_test(notifications Notifications)
 add_qml_test(launcher Launcher)
 add_qml_test(application Application)
+add_qml_test(application Surface)

=== added file 'test/qmltest/unity/shell/application/tst_Surface.qml'
--- test/qmltest/unity/shell/application/tst_Surface.qml	1970-01-01 00:00:00 +0000
+++ test/qmltest/unity/shell/application/tst_Surface.qml	2014-05-05 12:17:41 +0000
@@ -0,0 +1,168 @@
+/*
+ * Copyright 2014 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 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 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/>.
+ *
+ * Authors:
+ *      Michael Zanetti <[e-mail]>
+ */
+
+import QtQuick 2.0
+import QtTest 1.0
+import TestUtil 0.1
+import Unity.Application 0.1
+
+Item {
+
+    SignalSpy {
+        id: signalSpy
+    }
+
+    Verifier {
+        id: checkModelVerifier
+
+        property var model: SurfaceManager
+
+        function test_model_data() {
+            return [
+                { tag: "SurfaceManager[object]", type: "object" },
+                { tag: "SurfaceManager[SurfaceManagerInterface]", type: "unity::shell::application::SurfaceManagerInterface" },
+            ];
+        }
+
+        function test_model(data) {
+            object = model;
+            name = "SurfaceManager"
+
+            verifyData(data);
+        }
+    }
+
+    Verifier {
+        when: checkModelVerifier.completed
+
+        Repeater {
+            id: repeater
+            model: SurfaceManager
+            delegate: Item {
+                property var roles: model
+            }
+        }
+
+        SurfaceItem {
+            id: surfaceItem
+            surface: SurfaceManager.get(0)
+        }
+
+        /* make sure all the required roles are exposed on SurfaceManager */
+        function test_model_roles_enum_data() {
+            return [
+                        { enum: "RoleType" },
+                        { enum: "RoleSurfaceState" },
+                        { enum: "RoleName" },
+                        { enum: "RoleApplicationId" },
+                    ];
+        }
+
+        function test_model_roles_enum(data) {
+            name = "SurfaceManager"
+            object = SurfaceManager
+
+            verifyData(data);
+        }
+
+        function test_model_roles_data() {
+            return [
+                        { tag: "SurfaceManager.roles[appId]", role: "appId", type: "string" },
+                        { tag: "SurfaceManager.roles[name]", role: "name", type: "string" },
+                        { tag: "SurfaceManager.roles[type]", role: "type", type: "number" },
+                        { tag: "SurfaceManager.roles[surfaceState]", role: "surfaceState", type: "number" },
+                    ];
+        }
+
+        function test_model_roles(data) {
+            name = "SurfaceManager"
+            try {
+                object = repeater.itemAt(0).roles;
+            } catch(err) {
+                object = undefined;
+            }
+
+            verifyData(data);
+        }
+
+        function test_model_methods_data() {
+            return [
+                { tag: "SurfaceManager.methods[surfaceCreated]", method: "surfaceCreated" },
+                { tag: "SurfaceManager.methods[surfaceDestroyed]", method: "surfaceDestroyed" },
+            ];
+        }
+
+        function test_model_methods(data) {
+            name = "SurfaceManager";
+            object = SurfaceManager;
+            verifyData(data);
+        }
+
+        function test_model_properties_data() {
+            return [
+                { tag: "SurfaceManager.count", property: "count", type: "number" },
+            ];
+        }
+
+        function test_model_properties(data) {
+            name = "SurfaceManager";
+            object = SurfaceManager;
+            verifyData(data);
+        }
+
+        function test_surface_properties_data() {
+            return [
+                { tag: "Surface.properties[type]", constant: "type", type: "number" },
+                { tag: "Surface.properties[surfaceState]", property: "surfaceState", type: "number" },
+                { tag: "Surface.properties[name]", property: "name", type: "string" },
+                { tag: "Surface.properties[appId]", property: "appId", type: "string" },
+            ];
+        }
+
+        function test_surface_properties(data) {
+            name = "Surface"
+            try {
+                object = SurfaceManager.get(0)
+            } catch(err) {
+                object = undefined;
+                print(err)
+            }
+
+            verifyData(data)
+        }
+
+        function test_surfaceitem_properties_data() {
+            return [
+                { tag: "SurfaceItem.properties[surface]", property: "surface", type: "object" },
+            ];
+        }
+
+        function test_surfaceitem_properties(data) {
+            name = "SurfaceItem"
+            try {
+                object = surfaceItem;
+            } catch(err) {
+                object = undefined;
+                print(err)
+            }
+
+            verifyData(data)
+        }
+    }
+}