Merge lp:~ricmm/unity-mir/sidestage-reenable into lp:unity-mir

[Ricardo Mendoza]

Re-enable Sidestage as it was under SF

[Gerry Boland (gerboland)]

+ Application* m_mainStageApplication;
+ Application* m_sideStageApplication;
+ Application* m_msApplicationToBeFocused; // placeholder store for async
focusing
+ Application* m_ssApplicationToBeFocused; // placeholder store for async focusing
Is there no way you can keep the idea of "stages" out of unity-mir? Stages are more a window management concept, so I was hoping to keep it out of unity-mir entirely.

You've moved panelHeight calculation into ApplicationManager - makes sense.

- m_mirServer->the_focus_controller()->set_focus_to(application->session());
+ if(application->session())
+ m_mirServer->the_focus_controller()->set_focus_to(application->session());
Wasn't expecting this to need the check, Application should only be attempted to be focused once it has a session associated. I mess up?

- if (app->state() == Application::Stopped || app->state() == Application::Starting) {
+ if (app->state() == Application::Stopped || app->state() == Application::Starting || app->state() == Application::Suspended) {
Actually hadn't checked this, but had expected that if app suspended, then it still has a Mir session and so has an output buffer that can be screenshotted.

- snapshot.size.height.as_int() - yOffset,
+ snapshot.size.height.as_int(),
I removed the yOffset to clip the area of the application under the panel. This not needed any more?

[Ricardo Mendoza (ricmm)]

> + Application* m_mainStageApplication;
> + Application* m_sideStageApplication;
> + Application* m_msApplicationToBeFocused; // placeholder store for async
> focusing
> + Application* m_ssApplicationToBeFocused; // placeholder store for async
> focusing
> Is there no way you can keep the idea of "stages" out of unity-mir? Stages are
> more a window management concept, so I was hoping to keep it out of unity-mir
> entirely.

I will give this some thought today.

> You've moved panelHeight calculation into ApplicationManager - makes sense.
>
> - m_mirServer->the_focus_controller()->set_focus_to(application->session());
> + if(application->session())
> + m_mirServer->the_focus_controller()->set_focus_to(application->session());
> Wasn't expecting this to need the check, Application should only be attempted
> to be focused once it has a session associated. I mess up?

The shell actually sometimes tries to focusApplication() a NULL session, for some reason. It has something to do with the gimmicks and tricks it does to maintain stage consistency in multi-stage scenarios.

Of course this goes bad when hitting the unity-mir focusApplication(0x0)

> - if (app->state() == Application::Stopped || app->state() ==
> Application::Starting) {
> + if (app->state() == Application::Stopped || app->state() ==
> Application::Starting || app->state() == Application::Suspended) {
> Actually hadn't checked this, but had expected that if app suspended, then it
> still has a Mir session and so has an output buffer that can be screenshotted.

Thats true, the buffer can still be screenshotted. I had added this for some other reason, but I will figure out if it can be removed. Stale code.

> - snapshot.size.height.as_int() - yOffset,
> + snapshot.size.height.as_int(),
> I removed the yOffset to clip the area of the application under the panel.
> This not needed any more?

Not needed anymore as currently surface buffers are created with the visible geometry provided to the application. Before all surfaces were full-geometry according to Mir (wrong creation params). Now they actually specify creation dimensions (platform-api branch).

[Gerry Boland (gerboland)]

> > You've moved panelHeight calculation into ApplicationManager - makes sense.
> >
> > - m_mirServer->the_focus_controller()->set_focus_to(application->session());
> > + if(application->session())
> > + m_mirServer->the_focus_controller()->set_focus_to(application->session());
> > Wasn't expecting this to need the check, Application should only be
> attempted
> > to be focused once it has a session associated. I mess up?
>
> The shell actually sometimes tries to focusApplication() a NULL session, for
> some reason. It has something to do with the gimmicks and tricks it does to
> maintain stage consistency in multi-stage scenarios.
>
> Of course this goes bad when hitting the unity-mir focusApplication(0x0)

set_focus_to(0x0) should tell Mir to unfocus all sessions, so that only the shell gets input. I can see yeah that breaks stuff when sidestage going. Must check that phone isn't relying on this behaviour.

> > - if (app->state() == Application::Stopped || app->state() ==
> > Application::Starting) {
> > + if (app->state() == Application::Stopped || app->state() ==
> > Application::Starting || app->state() == Application::Suspended) {
> > Actually hadn't checked this, but had expected that if app suspended, then
> it
> > still has a Mir session and so has an output buffer that can be
> screenshotted.
>
> Thats true, the buffer can still be screenshotted. I had added this for some
> other reason, but I will figure out if it can be removed. Stale code.

Ok

>
> > - snapshot.size.height.as_int() - yOffset,
> > + snapshot.size.height.as_int(),
> > I removed the yOffset to clip the area of the application under the panel.
> > This not needed any more?
>
> Not needed anymore as currently surface buffers are created with the visible
> geometry provided to the application. Before all surfaces were full-geometry
> according to Mir (wrong creation params). Now they actually specify creation
> dimensions (platform-api branch).

Aha cool, in that case m_panelHeight it totally unneeded in the screenshot provider.

[Michał Sawicz (saviq)]

Made "Needs review" to get packages out of CI.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:156
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/184/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/47
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/48
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/48/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/47

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/184/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:161
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/185/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/48
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/49
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/49/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/48

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/185/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:162
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/186/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/49
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/50
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/50/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/49

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/186/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:163
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/187/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/50
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/51
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/51/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/50

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/187/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:165
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/188/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/51
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/52
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/52/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/51

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/188/rebuild

review: Approve (continuous-integration)

[lp:~ricmm/unity-mir/sidestage-reenable]

160. By kevin gunn on 2014-01-08

bump debian version dependency for mir to 0.1.3 to force rebuild

161. By PS Jenkins bot on 2014-01-08

Releasing 0.2+14.04.20140108.1-0ubuntu1 (revision 160 from lp:unity-mir).

Approved by PS Jenkins bot.

[Gerry Boland (gerboland)]

+++ src/unity-mir/surfacefactory.h
+ void requestDepthForSession(mir::shell::Session const* session, mir::scene::DepthId &depth);

I don't see this being used anywhere. It's only usage is commented out:
+ //Q_EMIT requestDepthForSession(session, newParams.depth);

<pedantic>
+ if(application->session())
missing the space after the "if"
</pedantic>

Is pity that app man has to learn concept of main and side stage apps, but as it unblocks sidestage with mir, it will do. With revamp of window manager code, then this can go away again.

In conclusion, code looks good, functions correctly and with these small fixes am happy to approve.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:166
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/206/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/69
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/70
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/70/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/69

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/206/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:167
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/208/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/71
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/72
        deb: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/72/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/71

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/208/rebuild

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

I'm having problems with this and AP, not sure if it's my problem but here's the log output: http://pastebin.ubuntu.com/6727470/
Seems like the greeter isn't being swiped away - but I seldom see anything on screen!

Also want to do full test of all AP test suites before approving.

[lp:~ricmm/unity-mir/sidestage-reenable]

162. By Thomas Voß on 2014-01-10

Switch to cmake.

Approved by Gerry Boland, PS Jenkins bot, Albert Astals Cid, Jussi Pakkanen.

163. By Ricardo Mendoza on 2014-01-13

merge

164. By Ricardo Mendoza on 2014-01-14

Fix uninitialized var code path when using non-live application plugins

[Gerry Boland (gerboland)]

Working well, AP tests all pass on phone

review: Approve

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2013-11-23 06:11:07 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2014-01-14 06:02:15 +0000
@@ -25,6 +25,8 @@
 #include "shellserverconfiguration.h"
 #include "sessionlistener.h"
 #include "sessionauthorizer.h"
+#include "initialsurfaceplacementstrategy.h"
+#include "surfacefactory.h"
 #include "taskcontroller.h"
 #include "logging.h"
 
@@ -32,10 +34,16 @@
 #include <mir/shell/session.h>
 #include <mir/shell/focus_controller.h>
 #include <mir/shell/surface.h>
+#include <mir/graphics/display.h>
+#include <mir/graphics/display_buffer.h>
+#include <mircommon/mir/geometry/rectangles.h>
 
 // Qt
 #include <QCoreApplication>
 
+// Default element sizes
+#define SIDE_STAGE_WIDTH_GU 40
+
 namespace msh = mir::shell;
 
 using namespace unity::shell::application;
@@ -53,10 +61,15 @@
 ApplicationManager::ApplicationManager(QObject *parent)
 :   ApplicationManagerInterface(parent)
 ,   m_focusedApplication(nullptr)
-,   m_applicationToBeFocused(nullptr)
+,   m_mainStageApplication(nullptr)
+,   m_sideStageApplication(nullptr)
+,   m_msApplicationToBeFocused(nullptr)
+,   m_ssApplicationToBeFocused(nullptr)
 ,   m_lifecycleExceptions(QStringList() << "com.ubuntu.music")
 ,   m_taskController(TaskController::singleton())
+,   m_gridUnitPx(8)
 ,   m_fenceNext(false)
+,   m_panelHeight(54)
 {
     DLOG("ApplicationManager::ApplicationManager (this=%p)", this);
 
@@ -73,13 +86,15 @@
     QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionStopping,
                      this, &ApplicationManager::onSessionStopping);
     QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionFocused,
-                     this, &ApplicationManager::onSessionFocused);
+                     this, &ApplicationManager::onSessionFocused, Qt::QueuedConnection);
     QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionUnfocused,
                      this, &ApplicationManager::onSessionUnfocused);
     QObject::connect(m_mirServer->sessionListener(), &SessionListener::sessionCreatedSurface,
                      this, &ApplicationManager::onSessionCreatedSurface);
     QObject::connect(m_mirServer->sessionAuthorizer(), &SessionAuthorizer::requestAuthorizationForSession,
                      this, &ApplicationManager::authorizeSession, Qt::BlockingQueuedConnection);
+    QObject::connect(m_mirServer->placementStrategy(), &InitialSurfacePlacementStrategy::requestPlacementForSession,
+                     this, &ApplicationManager::placeSession, Qt::DirectConnection);
 
     QObject::connect(m_taskController.data(), &TaskController::processStartReport,
                      this, &ApplicationManager::onProcessStartReportReceived);
@@ -91,6 +106,35 @@
                      this, &ApplicationManager::onResumeRequested);
 
     m_dbusWindowStack = new DBusWindowStack(this);
+
+    std::shared_ptr<mir::graphics::Display> mirDisplay = m_mirServer->the_display();
+
+    // Obtain display size
+    mir::geometry::Rectangles view_area;
+    mirDisplay->for_each_display_buffer(
+        [&view_area](mir::graphics::DisplayBuffer const& db)
+        {
+            view_area.add(db.view_area());
+        });
+    
+    m_displaySize = QSize(
+        view_area.bounding_rectangle().size.width.as_uint32_t(),
+        view_area.bounding_rectangle().size.height.as_uint32_t()
+        );
+
+    // Setup panel height
+    QByteArray gridUnitString = qgetenv("GRID_UNIT_PX");
+    if (!gridUnitString.isEmpty()) {
+        bool ok;
+        int value = gridUnitString.toInt(&ok);
+        if (ok) {
+            m_gridUnitPx = value;
+        }
+    }
+
+    int densityPixelPx = qFloor( (float)m_gridUnitPx / 8 );
+
+    m_panelHeight = 3 * m_gridUnitPx + 2 * densityPixelPx;
 }
 
 ApplicationManager::~ApplicationManager()
@@ -98,6 +142,11 @@
     DLOG("ApplicationManager::~ApplicationManager");
 }
 
+int ApplicationManager::panelHeight()
+{
+    return m_panelHeight;
+}
+
 int ApplicationManager::rowCount(const QModelIndex &parent) const
 {
     return !parent.isValid() ? m_applications.size() : 0;
@@ -163,9 +212,17 @@
         DLOG("No such running application '%s'", qPrintable(appId));
         return false;
     }
-
-    m_applicationToBeFocused = application;
-
+   
+    if (application->stage() == Application::MainStage && m_sideStageApplication &&
+           (m_sideStageApplication->state() == Application::Running)) {
+        m_sideStageApplication->setState(Application::Suspended);
+    }
+    
+    if (application->stage() == Application::MainStage)
+        m_msApplicationToBeFocused = application;
+    else
+        m_ssApplicationToBeFocused = application;
+    
     if (application->state() == Application::Stopped) {
         // Respawning this app, move to end of application list so onSessionStarting works ok
         // FIXME: this happens pretty late, shell could request respawn earlier
@@ -173,7 +230,8 @@
         int from = m_applications.indexOf(application);
         move(from, m_applications.length()-1);
     } else {
-        m_mirServer->the_focus_controller()->set_focus_to(application->session());
+        if (application->session())
+            m_mirServer->the_focus_controller()->set_focus_to(application->session());
     }
 
     // FIXME(dandrader): lying here. The operation is async. So we will only know whether
@@ -186,7 +244,15 @@
 {
     DLOG("ApplicationManager::unfocusCurrentApplication (this=%p)", this);
 
-    m_applicationToBeFocused = nullptr;
+    if (m_sideStageApplication)
+        m_sideStageApplication->setState(Application::Suspended);
+
+    if (m_mainStageApplication)
+        m_mainStageApplication->setState(Application::Suspended);
+
+    // Clear both stages
+    m_msApplicationToBeFocused = nullptr;
+    m_ssApplicationToBeFocused = nullptr;
     m_mirServer->the_focus_controller()->set_focus_to(NULL); //FIXME(greyback)
 }
 
@@ -260,6 +326,11 @@
         Q_EMIT focusedApplicationIdChanged();
     }
 
+    if (application == m_mainStageApplication)
+        m_mainStageApplication = nullptr;
+    if (application == m_sideStageApplication)
+        m_sideStageApplication = nullptr;
+    
     remove(application);
     m_dbusWindowStack->WindowDestroyed(0, application->appId());
 
@@ -419,7 +490,7 @@
 
     // if stage supplied in CLI, fetch that
     Application::Stage stage = Application::MainStage;
-    pattern = QRegularExpression::escape("--stage=") + "(\\S+)";
+    pattern = QRegularExpression::escape("--stage_hint=") + "(\\S+)";
     regExp.setPattern(pattern);
     regExpMatch = regExp.match(command);
 
@@ -438,6 +509,33 @@
     authorized = true;
 }
 
+void ApplicationManager::placeSession(msh::Session const* session, uint32_t &x, uint32_t &y)
+{
+    DLOG("ApplicationManager::placeSession (this=%p, session=%p)", this, session);
+    
+    Application* application = findApplicationWithSession(session);
+
+    // Application defaults 
+    x = 0;
+    y = m_panelHeight;
+
+    // Shell client override
+    if (!session) {
+        y = 0;
+        return;
+    }
+
+    // Fullscreen applications override
+    if (application && application->fullscreen())
+        y = 0;
+
+    // SideStage override
+    if (application && application->stage() == Application::SideStage)
+        x = m_displaySize.width() - (SIDE_STAGE_WIDTH_GU * m_gridUnitPx);
+    
+    DLOG("ApplicationManager::placeSession (x=%d, y=%d)", x, y);
+}
+
 void ApplicationManager::onSessionStarting(std::shared_ptr<msh::Session> const& session)
 {
     DLOG("ApplicationManager::onSessionStarting (this=%p, application=%s)", this, session->name().c_str());
@@ -452,7 +550,10 @@
     Application* application = findLastExecutedApplication();
     if (application && application->state() != Application::Running) {
         application->setSession(session);
-        m_applicationToBeFocused = application;
+        if (application->stage() == Application::MainStage)
+            m_msApplicationToBeFocused = application;
+        else
+            m_ssApplicationToBeFocused = application;
     } else {
         DLOG("ApplicationManager::onSessionStarting - unauthorized application!!");
     }
@@ -469,6 +570,12 @@
         application->setSession(nullptr);
         m_dbusWindowStack->WindowDestroyed(0, application->appId());
 
+        if (m_mainStageApplication == application)
+            m_mainStageApplication = nullptr;
+        
+        if (m_sideStageApplication == application)
+            m_sideStageApplication = nullptr;
+
         if (application == m_focusedApplication) {
             // TODO(greyback) What to do?? Focus next app, or unfocus everything??
             m_focusedApplication = NULL;
@@ -481,12 +588,14 @@
 
 void ApplicationManager::onSessionFocused(std::shared_ptr<msh::Session> const& session)
 {
-    DLOG("ApplicationManager::onSessionFocused (this=%p, application=%s)", this, session->name().c_str());
+    DLOG("ApplicationManager::onSessionFocused (this=%p, session=%p)", this, session.get());
     Application* application = findApplicationWithSession(session);
 
     // Don't give application focus until it has created it's surface, when it is set as state "Running"
     // and only notify shell of focus changes that it actually expects
-    if (application && application->state() != Application::Starting && application == m_applicationToBeFocused
+    if (application && application->state() != Application::Starting && 
+        (application == m_msApplicationToBeFocused ||
+         application == m_ssApplicationToBeFocused)
             && application != m_focusedApplication) {
         setFocused(application);
         QModelIndex appIndex = findIndex(application);
@@ -546,9 +655,16 @@
 
     // set state of previously focused app to suspended
     if (m_focusedApplication && m_lifecycleExceptions.filter(m_focusedApplication->appId().section('_',0,0)).empty()) {
-        m_focusedApplication->setState(Application::Suspended);
+        Application *lastApplication = applicationForStage(application->stage());
+        if (lastApplication && lastApplication->state() == Application::Running)
+            lastApplication->setState(Application::Suspended);
     }
 
+    if (application->stage() == Application::MainStage)
+        m_mainStageApplication = application;
+    else
+        m_sideStageApplication = application;
+
     m_focusedApplication = application;
     m_focusedApplication->setFocused(true);
     m_focusedApplication->setState(Application::Running);
@@ -593,6 +709,16 @@
     }
 }
 
+Application* ApplicationManager::applicationForStage(Application::Stage stage)
+{
+    DLOG("ApplicationManager::focusedApplicationForStage(this=%p)", this);
+
+    if (stage == Application::MainStage)
+        return m_mainStageApplication;
+    else
+        return m_sideStageApplication;
+}
+
 void ApplicationManager::add(Application* application)
 {
     DASSERT(application != NULL);

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2013-11-20 14:39:50 +0000
+++ src/modules/Unity/Application/application_manager.h	2014-01-14 06:02:15 +0000
@@ -30,12 +30,17 @@
 // local
 #include "application.h"
 
+#include <mir/scene/depth_id.h>
+
 class ShellServerConfiguration;
 class DBusWindowStack;
 class MirSurfaceManager;
 class TaskController;
 
 namespace mir {
+    namespace geometry {
+        class Size;
+    }
     namespace shell {
         class Session;
         class Surface;
@@ -80,9 +85,14 @@
     const QList<Application*> &list() const { return m_applications; }
     Application* findApplicationWithPid(const qint64 pid);
 
+    // Internal helpers
+    int panelHeight();
+    QSize displaySize() const { return m_displaySize; }
+
 public Q_SLOTS:
     void authorizeSession(const quint64 pid, bool &authorized);
-
+    void placeSession(mir::shell::Session const*, uint32_t &x, uint32_t &y);
+    
     void onSessionStarting(std::shared_ptr<mir::shell::Session> const& session);
     void onSessionStopping(std::shared_ptr<mir::shell::Session> const& session);
     void onSessionFocused(std::shared_ptr<mir::shell::Session> const& session);
@@ -105,17 +115,24 @@
     Application* findApplicationWithSession(const std::shared_ptr<mir::shell::Session> &session);
     Application* findApplicationWithSession(const mir::shell::Session *session);
     Application* findLastExecutedApplication();
+    Application* applicationForStage(Application::Stage stage);
     QModelIndex findIndex(Application* application);
 
     QList<Application*> m_applications;
     Application* m_focusedApplication; // remove as Mir has API for this
-    Application* m_applicationToBeFocused; // a basic form of focus stealing prevention
+    Application* m_mainStageApplication;
+    Application* m_sideStageApplication;
+    Application* m_msApplicationToBeFocused; // placeholder store for async focusing
+    Application* m_ssApplicationToBeFocused; // placeholder store for async focusing
     QStringList m_lifecycleExceptions;
     ShellServerConfiguration* m_mirServer;
     DBusWindowStack* m_dbusWindowStack;
     QScopedPointer<TaskController> m_taskController;
     static ApplicationManager* the_application_manager;
+    int m_gridUnitPx;
     bool m_fenceNext;
+    QSize m_displaySize;
+    int m_panelHeight;
 
     friend class DBusWindowStack;
     friend class MirSurfaceManager;

=== modified file 'src/modules/Unity/Application/applicationscreenshotprovider.cpp'
--- src/modules/Unity/Application/applicationscreenshotprovider.cpp	2013-11-26 10:32:56 +0000
+++ src/modules/Unity/Application/applicationscreenshotprovider.cpp	2014-01-14 06:02:15 +0000
@@ -25,29 +25,11 @@
 // mir
 #include "mirserver/mir/shell/session.h"
 
-// fallback grid unit used if GRID_UNIT_PX is not in the environment.
-const int defaultGridUnitPx = 8;
-
 ApplicationScreenshotProvider::ApplicationScreenshotProvider(ApplicationManager *appManager)
     : QQuickImageProvider(QQuickImageProvider::Image)
     , m_appManager(appManager)
-    , m_panelHeight(54)
+    , m_panelHeight(m_appManager->panelHeight())
 {
-    // See below to explain why this is needed for now.
-    int gridUnitPx = defaultGridUnitPx;
-
-    QByteArray gridUnitString = qgetenv("GRID_UNIT_PX");
-    if (!gridUnitString.isEmpty()) {
-        bool ok;
-        int value = gridUnitString.toInt(&ok);
-        if (ok) {
-            gridUnitPx = value;
-        }
-    }
-
-    int densityPixelPx = qFloor( (float)gridUnitPx / defaultGridUnitPx );
-
-    m_panelHeight = 3 * gridUnitPx + 2 * densityPixelPx;
 }
 
 QQmlImageProviderBase::Flags ApplicationScreenshotProvider::flags() const
@@ -79,15 +61,6 @@
         return QImage();
     }
 
-    /* Workaround for bug https://bugs.launchpad.net/qtubuntu/+bug/1209216 - currently all qtubuntu
-     * based applications are allocated a fullscreen Mir surface, but draw in a geometry excluding
-     * the panel's rectangle. Mir snapshots thus have a white rectangle which the panel hides.
-     * So need to clip this rectangle from the snapshot. */
-    int yOffset = 0;
-    if (!app->fullscreen()) {
-        yOffset = m_panelHeight;
-    }
-
     QMutex mutex;
     QWaitCondition wait;
     mutex.lock();
@@ -102,7 +75,7 @@
 
             image = QImage( (const uchar*)snapshot.pixels, // since we mirror, no need to offset starting position
                             snapshot.size.width.as_int(),
-                            snapshot.size.height.as_int() - yOffset,
+                            snapshot.size.height.as_int(),
                             QImage::Format_ARGB32_Premultiplied).mirrored();
             wait.wakeOne();
         });

=== modified file 'src/modules/Unity/Application/mirsurface.cpp'
--- src/modules/Unity/Application/mirsurface.cpp	2013-10-23 16:00:09 +0000
+++ src/modules/Unity/Application/mirsurface.cpp	2014-01-14 06:02:15 +0000
@@ -101,7 +101,7 @@
     Size size = m_surface->size();
     if (size.width.as_int() != (int) widthValue) {
         size.width = Width{widthValue};
-//        m_surface->set_size(size); //MISSING FROM API
+        m_surface->resize(size);
         Q_EMIT widthChanged();
     }
 }
@@ -113,7 +113,7 @@
     Size size = m_surface->size();
     if (size.height.as_int() != (int) heightValue) {
         size.height = Height{heightValue};
-//        m_surface->set_size(size); //MISSING FROM API
+        m_surface->resize(size);
         Q_EMIT heightChanged();
     }
 }

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2013-11-15 17:57:20 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2014-01-14 06:02:15 +0000
@@ -148,7 +148,16 @@
         it.value()->setAttribute(attribute, value);
         if (attribute == mir_surface_attrib_state &&
                 value == mir_surface_state_fullscreen) {
-            it.value()->application()->setFullscreen(static_cast<bool>(value));
+            // Only screen-wide applications are allowed to go fullscreen
+            if (it.value()->application()->stage() == Application::MainStage) {
+                it.value()->application()->setFullscreen(static_cast<bool>(value));
+                ApplicationManager* appMgr = static_cast<ApplicationManager*>(ApplicationManager::singleton());
+                QSize displaySize = appMgr->displaySize();
+                it.value()->setWidth(displaySize.width());
+                it.value()->setHeight(displaySize.height());
+                it.value()->setX(0);
+                it.value()->setY(0);
+            }
         }
     }
 }

=== modified file 'src/unity-mir/focussetter.cpp'
--- src/unity-mir/focussetter.cpp	2013-10-07 21:52:28 +0000
+++ src/unity-mir/focussetter.cpp	2014-01-14 06:02:15 +0000
@@ -34,6 +34,7 @@
 
 void FocusSetter::set_focus_to(std::shared_ptr<msh::Session> const& session)
 {
+    DLOG("FocusSetter::set_focus_to(session=%p):%d", session.get(), __LINE__);
     // Ensure we always call the underlying setter to dispatch focus/unfocus notifications.
     underlying_setter->set_focus_to(session);
     if (session == nullptr)

=== modified file 'src/unity-mir/initialsurfaceplacementstrategy.cpp'
--- src/unity-mir/initialsurfaceplacementstrategy.cpp	2013-08-26 23:45:40 +0000
+++ src/unity-mir/initialsurfaceplacementstrategy.cpp	2014-01-14 06:02:15 +0000
@@ -16,6 +16,7 @@
 
 // local
 #include "initialsurfaceplacementstrategy.h"
+#include "logging.h"
 
 // mir
 #include "mir/shell/surface_creation_parameters.h"
@@ -23,23 +24,27 @@
 
 namespace msh = mir::shell;
 
-InitialSurfacePlacementStrategy::InitialSurfacePlacementStrategy(std::shared_ptr<msh::DisplayLayout> const& displayLayout)
-  : m_displayLayout(displayLayout)
+InitialSurfacePlacementStrategy::InitialSurfacePlacementStrategy(std::shared_ptr<msh::DisplayLayout> const& displayLayout, QObject *parent)
+  : QObject(parent),
+    m_displayLayout(displayLayout)
+{
+}
+
+InitialSurfacePlacementStrategy::~InitialSurfacePlacementStrategy()
 {
 }
 
 msh::SurfaceCreationParameters
-InitialSurfacePlacementStrategy::place(msh::Session const& /*session*/, msh::SurfaceCreationParameters const& requestParameters)
+InitialSurfacePlacementStrategy::place(msh::Session const& session, msh::SurfaceCreationParameters const& requestParameters)
 {
     using namespace mir::geometry;
     auto placedParameters = requestParameters;
-
-    Rectangle rect{placedParameters.top_left, placedParameters.size};
-    m_displayLayout->size_to_output(rect);
-    placedParameters.size = rect.size;
-
-    // position surface initially off-screen, until ready to be animated in
-//    placedParameters.top_left = Point{ X{rect.size.width.as_int()}, Y{0}};
+    uint32_t x = 0;
+    uint32_t y = 0;
+
+    Q_EMIT requestPlacementForSession(&session, x, y);
+
+    placedParameters.top_left = Point{ X{x}, Y{y} };
 
     return placedParameters;
 }

=== modified file 'src/unity-mir/initialsurfaceplacementstrategy.h'
--- src/unity-mir/initialsurfaceplacementstrategy.h	2013-08-26 23:45:40 +0000
+++ src/unity-mir/initialsurfaceplacementstrategy.h	2014-01-14 06:02:15 +0000
@@ -21,15 +21,26 @@
 
 #include "mirserver/mir/shell/placement_strategy.h"
 #include "mirserver/mir/shell/display_layout.h"
-
-class InitialSurfacePlacementStrategy : public mir::shell::PlacementStrategy
+#include "mir/shell/session.h"
+#include "mir/scene/depth_id.h"
+
+#include <QObject>
+
+class InitialSurfacePlacementStrategy : public QObject, public mir::shell::PlacementStrategy
 {
+    Q_OBJECT
+
 public:
-    InitialSurfacePlacementStrategy(std::shared_ptr<mir::shell::DisplayLayout> const& displayLayout);
+    InitialSurfacePlacementStrategy(std::shared_ptr<mir::shell::DisplayLayout> const& displayLayout,
+                                    QObject *parent = 0);
+    ~InitialSurfacePlacementStrategy();
 
     mir::shell::SurfaceCreationParameters place(mir::shell::Session const& session,
                                                 mir::shell::SurfaceCreationParameters const& requestParameters) override;
 
+Q_SIGNALS:
+    void requestPlacementForSession(mir::shell::Session const* session, uint32_t &x, uint32_t &y);
+        
 private:
     std::shared_ptr<mir::shell::DisplayLayout> const m_displayLayout;
 };

=== modified file 'src/unity-mir/shellserverconfiguration.cpp'
--- src/unity-mir/shellserverconfiguration.cpp	2013-11-27 10:45:09 +0000
+++ src/unity-mir/shellserverconfiguration.cpp	2014-01-14 06:02:15 +0000
@@ -125,6 +125,14 @@
 // scope the unique pointer will be destroyed so we return 0
 //
 
+InitialSurfacePlacementStrategy *ShellServerConfiguration::placementStrategy()
+{
+    auto sharedPtr = the_shell_placement_strategy();
+    if (sharedPtr.unique()) return 0;
+
+    return static_cast<InitialSurfacePlacementStrategy*>(sharedPtr.get());
+}
+
 SessionAuthorizer *ShellServerConfiguration::sessionAuthorizer()
 {
     auto sharedPtr = the_session_authorizer();

=== modified file 'src/unity-mir/shellserverconfiguration.h'
--- src/unity-mir/shellserverconfiguration.h	2013-11-18 16:05:56 +0000
+++ src/unity-mir/shellserverconfiguration.h	2014-01-14 06:02:15 +0000
@@ -26,6 +26,7 @@
 class SessionAuthorizer;
 class SurfaceFactory;
 class SurfaceConfigurator;
+class InitialSurfacePlacementStrategy;
 
 class ShellServerConfiguration : public QObject, public mir::DefaultServerConfiguration
 {
@@ -51,6 +52,7 @@
 
     /* qt specific */
     // getters
+    InitialSurfacePlacementStrategy *placementStrategy();
     SessionAuthorizer *sessionAuthorizer();
     SessionListener *sessionListener();
     SurfaceConfigurator *surfaceConfigurator();