Merge lp:~kdub/unity-system-compositor/unblock-silo0 into lp:~mir-team/unity-system-compositor/silo0

[Kevin DuBois]

upon Display changes, use information from WindowManager system to figure out the new dimensions. Also scan through the list of surfaces differently, as surface_after() will never return nullptr.

upon Display changes, use information from WindowManager system to figure out the new dimensions. Also scan through the list of surfaces differently, as surface_after() will never return nullptr.

Unmerged revisions

226. By Kevin DuBois on 2015-08-04

configure the display differently on screen changes

225. By Andreas Pokorny on 2015-07-31

fix changelog

224. By Andreas Pokorny on 2015-07-31

update to recent unity-system-compositor changes

223. By Gerry Boland on 2015-07-08

Merge fix-1461476-display-off-ubuntu

222. By Gerry Boland on 2015-07-07

Try a release

221. By Gerry Boland on 2015-07-06

WindowManager: attempt to resize surfaces to fil the smallest available display - deadlocks

220. By Gerry Boland on 2015-07-06

Update display rotation at runtime

219. By Gerry Boland on 2015-07-06

Attempt at rotating the non-primary display by default

218. By Gerry Boland on 2015-07-03

Update comment to reflect hardware cursor enabled by default

217. By Gerry Boland on 2015-07-03

Enable hardware cursor by default

=== modified file 'debian/changelog'
--- debian/changelog	2015-07-16 21:45:22 +0000
+++ debian/changelog	2015-08-04 17:52:54 +0000
@@ -1,8 +1,39 @@
-unity-system-compositor (0.0.5+15.10.20150506.2-0ubuntu1) UNRELEASED; urgency=medium
-
+unity-system-compositor (0.1.1) UNRELEASED; urgency=medium
+
+  * Demo USC with cursor override and special clone ability
+
+ -- Gerry Boland <[e-mail]>  Tue, 07 Jul 2015 10:50:27 +0100
+
+unity-system-compositor (0.1.0+15.10.20150728.1-0ubuntu1) wily; urgency=medium
+
+  [ Alexandros Frantzis ]
+  * Support different screen timeout values for notifications
+    (LP: #1426115)
+  * Enable and handle proximity events properly (LP: #1291455)
+  * Don't force gcc 4.9 when building the package (LP: #1478926)
+  * Introduce new versioning scheme
+
+  [ Alan Griffiths ]
+  * Port to mir SystemCompositorWindowManager
+  
+  [ Robert Ancell ]
+  * Depend on the new xmir package instead of the obsolete
+    xserver-xorg-xmir (LP: #1204505)
+
+  [ CI Train Bot ]
+  * New rebuild forced.
+
+ -- CI Train Bot <[e-mail]>  Tue, 28 Jul 2015 18:55:28 +0000
+
+unity-system-compositor (0.0.5+15.10.20150722-0ubuntu1) wily; urgency=medium
+
+  [ Kevin Gunn ]
   * Release in step with Mir 0.14 
 
- -- Kevin Gunn <[e-mail]>  Thu, 16 Jul 2015 15:14:22 -0500
+  [ CI Train Bot ]
+  * New rebuild forced.
+
+ -- CI Train Bot <[e-mail]>  Wed, 22 Jul 2015 14:49:58 +0000
 
 unity-system-compositor (0.0.5+15.04.20150713-0ubuntu1) vivid; urgency=medium
 

=== modified file 'debian/control'
--- debian/control	2015-07-27 10:29:16 +0000
+++ debian/control	2015-08-04 17:52:54 +0000
@@ -13,8 +13,8 @@
                libdbus-1-dev,
                libglib2.0-dev,
                libgles2-mesa-dev,
-               libmirclient-dev (>= 0.13.0),
-               libmirserver-dev (>= 0.13.0),
+               libmirclient-dev (>= 0.13.4),
+               libmirserver-dev (>= 0.13.4),
                libprotobuf-dev,
                pkg-config,
                python:any (>= 2.7),

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-08-04 17:05:31 +0000
+++ src/CMakeLists.txt	2015-08-04 17:52:54 +0000
@@ -16,7 +16,12 @@
 
 set(USC_SRCS
   asio_dm_connection.cpp
-  clone_display_configuration_policy.cpp
+<<<<<<< TREE
+  clone_display_configuration_policy.cpp
+=======
+  clone_display_configuration_policy.cpp
+  cursor_enabler.cpp
+>>>>>>> MERGE-SOURCE
   dbus_connection_handle.cpp
   dbus_event_loop.cpp
   dbus_message_handle.cpp

=== added file 'src/clone_display_configuration_policy.cpp'
--- src/clone_display_configuration_policy.cpp	1970-01-01 00:00:00 +0000
+++ src/clone_display_configuration_policy.cpp	2015-08-04 17:52:54 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2015 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 "clone_display_configuration_policy.h"
+
+#include <mir/graphics/display_configuration.h>
+#include <cstdio>
+namespace mg = mir::graphics;
+
+CloneDisplayConfigurationPolicy::CloneDisplayConfigurationPolicy(
+        const std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> &wrapped)
+   : wrapped{wrapped}
+{
+}
+
+void CloneDisplayConfigurationPolicy::apply_to(mir::graphics::DisplayConfiguration& conf)
+{
+    wrapped->apply_to(conf);
+
+    conf.for_each_output(
+                [&](mg::UserDisplayConfigurationOutput& displayConfigOutput) {
+        if (displayConfigOutput.id.as_value() > 0) { printf("Here\n");
+            displayConfigOutput.orientation = mir_orientation_left;
+        }
+    }
+    );
+
+    conf.for_each_output(
+                [&](const mg::DisplayConfigurationOutput displayConfigOutput) {
+        printf("Output %d: Orientation %d\n", displayConfigOutput.id.as_value(), displayConfigOutput.orientation);
+    }
+    );
+}

=== renamed file 'src/clone_display_configuration_policy.cpp' => 'src/clone_display_configuration_policy.cpp.moved'
=== added file 'src/clone_display_configuration_policy.h'
--- src/clone_display_configuration_policy.h	1970-01-01 00:00:00 +0000
+++ src/clone_display_configuration_policy.h	2015-08-04 17:52:54 +0000
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2015 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 CLONEDISPLAYCONFIGURATIONPOLICY_H
+#define CLONEDISPLAYCONFIGURATIONPOLICY_H
+
+#include <mir/graphics/display_configuration_policy.h>
+#include <memory>
+
+class CloneDisplayConfigurationPolicy : public mir::graphics::DisplayConfigurationPolicy
+{
+public:
+    CloneDisplayConfigurationPolicy(const std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> &wrapped);
+
+    void apply_to(mir::graphics::DisplayConfiguration& conf) override;
+
+private:
+    const std::shared_ptr<mir::graphics::DisplayConfigurationPolicy> wrapped;
+};
+
+#endif // CLONEDISPLAYCONFIGURATIONPOLICY_H

=== renamed file 'src/clone_display_configuration_policy.h' => 'src/clone_display_configuration_policy.h.moved'
=== modified file 'src/com.canonical.Unity.Screen.xml'
--- src/com.canonical.Unity.Screen.xml	2015-03-18 13:06:10 +0000
+++ src/com.canonical.Unity.Screen.xml	2015-08-04 17:52:54 +0000
@@ -25,5 +25,9 @@
     <method name='setTouchVisualizationEnabled'>
       <arg name='enabled' type='b' direction='in'/>
     </method>
+    <method name='overrideOrientation'>
+      <arg name='display_id' type='u' direction='in'/>
+      <arg name='orientation' type='i' direction='in'/>
+    </method>
   </interface>
 </node>

=== added file 'src/cursor_enabler.cpp'
--- src/cursor_enabler.cpp	1970-01-01 00:00:00 +0000
+++ src/cursor_enabler.cpp	2015-08-04 17:52:54 +0000
@@ -0,0 +1,72 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "cursor_enabler.h"
+
+#include "mir/graphics/cursor.h"
+#include "mir_toolkit/event.h"
+
+namespace mi = mir::input;
+
+CursorEnabler::CursorEnabler(
+    std::shared_ptr<mir::graphics::Cursor> const& cursor,
+    std::chrono::milliseconds remove_pointer_timeout)
+    : cursor_shown(false), remove_delay{static_cast<uint32_t>(remove_pointer_timeout.count())}, last_cursor_movement(0),
+    cursor(cursor)
+{
+    cursor->hide();
+}
+
+CursorEnabler::~CursorEnabler() = default;
+
+bool CursorEnabler::handle(MirEvent const& event)
+{
+    if (mir_event_get_type(&event) != mir_event_type_input)
+    {
+        return false;
+    }
+    auto const* ev = mir_event_get_input_event(&event);
+    if (mir_input_event_type_pointer == mir_input_event_get_type(ev))
+    {
+        enable_cursor();
+        last_cursor_movement = mir_input_event_get_event_time(ev);
+    }
+    else if (remove_delay &&
+             mir_input_event_type_touch == mir_input_event_get_type(ev) &&
+             (mir_input_event_get_event_time(ev) - last_cursor_movement > remove_delay))
+    {
+        disable_cursor();
+    }
+    return false;
+}
+
+void CursorEnabler::enable_cursor()
+{
+    if (!cursor_shown)
+    {
+        cursor->show();
+        cursor_shown = true;
+    }
+}
+
+void CursorEnabler::disable_cursor()
+{
+    if (cursor_shown)
+    {
+        cursor->hide();
+        cursor_shown = false;
+    }
+}

=== added file 'src/cursor_enabler.h'
--- src/cursor_enabler.h	1970-01-01 00:00:00 +0000
+++ src/cursor_enabler.h	2015-08-04 17:52:54 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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 USC_CURSOR_IMAGE_ENABLER_H_
+#define USC_CURSOR_IMAGE_ENABLER_H_
+
+#include "mir/input/event_filter.h"
+
+#include <memory>
+#include <chrono>
+
+namespace mir
+{
+namespace graphics
+{
+class Cursor;
+class CursorImage;
+}
+}
+
+/*
+ * Disables the cursor on construction and waits for the first mir pointer/cursor
+ * event to come by for enabling the cursor again.
+ */
+class CursorEnabler : public mir::input::EventFilter
+{
+public:
+    CursorEnabler(std::shared_ptr<mir::graphics::Cursor> const& cursor,
+                       std::chrono::milliseconds remove_pointer_timeout);
+
+    ~CursorEnabler();
+
+    bool handle(MirEvent const& event) override;
+
+private:
+    void enable_cursor();
+    void disable_cursor();
+
+    bool cursor_shown;
+    uint32_t remove_delay;
+    uint32_t last_cursor_movement;
+    std::shared_ptr<mir::graphics::Cursor> const cursor;
+};
+
+#endif

=== modified file 'src/mir_screen.cpp'
--- src/mir_screen.cpp	2015-07-27 17:01:28 +0000
+++ src/mir_screen.cpp	2015-08-04 17:52:54 +0000
@@ -23,6 +23,7 @@
 #include <mir/graphics/display.h>
 #include <mir/graphics/display_configuration.h>
 #include <mir/input/touch_visualizer.h>
+#include <mir/graphics/cursor.h>
 
 #include <cstdio>
 #include "screen_hardware.h"
@@ -39,6 +40,7 @@
     std::shared_ptr<mir::input::TouchVisualizer> const& touch_visualizer,
     std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
     std::shared_ptr<usc::Clock> const& clock,
+    std::shared_ptr<mir::graphics::Cursor> const& cursor,
     Timeouts inactivity_timeouts,
     Timeouts notification_timeouts)
     : screen_hardware{screen_hardware},
@@ -47,6 +49,7 @@
       touch_visualizer{touch_visualizer},
       alarm_factory{alarm_factory},
       clock{clock},
+      cursor{cursor},
       power_off_alarm{alarm_factory->create_alarm(
               std::bind(&usc::MirScreen::power_off_alarm_notification, this))},
       dimmer_alarm{alarm_factory->create_alarm(
@@ -328,3 +331,4 @@
 
     power_state_change_handler = handler;
 }
+

=== modified file 'src/mir_screen.h'
--- src/mir_screen.h	2015-07-17 12:43:46 +0000
+++ src/mir_screen.h	2015-08-04 17:52:54 +0000
@@ -29,7 +29,7 @@
 namespace mir
 {
 namespace compositor { class Compositor; }
-namespace graphics {class Display;}
+namespace graphics {class Display; class Cursor;}
 namespace input { class TouchVisualizer; }
 namespace time { class AlarmFactory; class Alarm; }
 }
@@ -55,6 +55,7 @@
               std::shared_ptr<mir::input::TouchVisualizer> const& touch_visualizer,
               std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
               std::shared_ptr<usc::Clock> const& clock,
+              std::shared_ptr<mir::graphics::Cursor> const& cursor,
               Timeouts inactivity_timeouts,
               Timeouts notification_timeouts);
     ~MirScreen();
@@ -94,6 +95,7 @@
     std::shared_ptr<mir::input::TouchVisualizer> const touch_visualizer;
     std::shared_ptr<mir::time::AlarmFactory> const alarm_factory;
     std::shared_ptr<usc::Clock> const clock;
+    std::shared_ptr<mir::graphics::Cursor> const cursor;
     std::unique_ptr<mir::time::Alarm> const power_off_alarm;
     std::unique_ptr<mir::time::Alarm> const dimmer_alarm;
 

=== modified file 'src/server.cpp'
--- src/server.cpp	2015-08-04 17:05:31 +0000
+++ src/server.cpp	2015-08-04 17:52:54 +0000
@@ -25,6 +25,7 @@
 #include "screen_event_handler.h"
 #include "powerd_mediator.h"
 #include "unity_screen_service.h"
+#include "clone_display_configuration_policy.h"
 #include "steady_clock.h"
 #include "clone_display_configuration_policy.h"
 
@@ -114,12 +115,13 @@
     add_configuration_option("version", "Show version of Unity System Compositor",  mir::OptionType::null);
     add_configuration_option("spinner", "Path to spinner executable",  mir::OptionType::string);
     add_configuration_option("public-socket", "Make the socket file publicly writable",  mir::OptionType::boolean);
-    add_configuration_option("enable-hardware-cursor", "Enable the hardware cursor (disabled by default)",  mir::OptionType::boolean);
+    add_configuration_option("enable-hardware-cursor", "Enable the hardware cursor (enabled by default)",  mir::OptionType::boolean);
     add_configuration_option("inactivity-display-off-timeout", "The time in seconds before the screen is turned off when there are no active sessions",  mir::OptionType::integer);
     add_configuration_option("inactivity-display-dim-timeout", "The time in seconds before the screen is dimmed when there are no active sessions",  mir::OptionType::integer);
     add_configuration_option("shutdown-timeout", "The time in milli-seconds the power key must be held to initiate a clean system shutdown",  mir::OptionType::integer);
     add_configuration_option("power-key-ignore-timeout", "The time in milli-seconds the power key must be held to ignore - must be less than shutdown-timeout",  mir::OptionType::integer);
     add_configuration_option("disable-inactivity-policy", "Disables handling user inactivity and power key",  mir::OptionType::boolean);
+    add_configuration_option("remove_pointer_timeout", "The time in milli-seconds the cursor image stays visible after touch screen is used again - by default the cursor image stays visible",  mir::OptionType::integer);
     add_configuration_option("notification-display-off-timeout", "The time in seconds before the screen is turned off after a notification arrives",  mir::OptionType::integer);
     add_configuration_option("notification-display-dim-timeout", "The time in seconds before the screen is dimmed after a notification arrives",  mir::OptionType::integer);
 
@@ -127,18 +129,6 @@
 
     set_command_line_handler(&ignore_unknown_arguments);
 
-    wrap_cursor_listener([this](std::shared_ptr<mir::input::CursorListener> const& default_)
-        -> std::shared_ptr<mir::input::CursorListener>
-        {
-            // This is a workaround for u8 desktop preview in 14.04 for the lack of client cursor API.
-            // We need to disable the cursor for XMir but leave it on for the desktop preview.
-            // Luckily as it stands they run inside seperate instances of USC. ~racarr
-            if (enable_hardware_cursor())
-                return default_;
-            else
-                return std::make_shared<NullCursorListener>();
-        });
-
     override_the_server_status_listener([this]()
         -> std::shared_ptr<mir::ServerStatusListener>
         {
@@ -154,6 +144,7 @@
              the_session_switcher());
        });
 
+<<<<<<< TREE
     wrap_display_configuration_policy(
     [](const std::shared_ptr<mg::DisplayConfigurationPolicy> &wrapped)
         -> std::shared_ptr<mg::DisplayConfigurationPolicy>
@@ -161,6 +152,16 @@
     	    return std::make_shared<CloneDisplayConfigurationPolicy>(wrapped);
     	});
 
+=======
+    wrap_display_configuration_policy(
+        [](const std::shared_ptr<mg::DisplayConfigurationPolicy> &wrapped)
+            -> std::shared_ptr<mg::DisplayConfigurationPolicy>
+        {
+            return std::make_shared<CloneDisplayConfigurationPolicy>(wrapped);
+        });
+
+
+>>>>>>> MERGE-SOURCE
     set_config_filename("unity-system-compositor.conf");
 
     apply_settings();
@@ -250,6 +251,7 @@
                 the_touch_visualizer(),
                 the_main_loop(),
                 the_clock(),
+                the_cursor(),
                 MirScreen::Timeouts{
                     inactivity_display_off_timeout(),
                     inactivity_display_dim_timeout()},

=== modified file 'src/server.h'
--- src/server.h	2015-07-15 13:48:31 +0000
+++ src/server.h	2015-08-04 17:52:54 +0000
@@ -51,6 +51,7 @@
 
     using mir::Server::add_init_callback;
     using mir::Server::run;
+    using mir::Server::the_cursor;
     using mir::Server::the_main_loop;
     using mir::Server::the_composite_event_filter;
     using mir::Server::the_display;
@@ -93,6 +94,16 @@
         return the_options()->get("file", "/tmp/mir_socket");
     }
 
+    int remove_pointer_timeout()
+    {
+       return the_options()->get("remove-pointer-timeout", 0);
+    }
+
+    bool enable_hardware_cursor()
+    {
+        return the_options()->get("enable-hardware-cursor", true);
+    }
+
 private:
     inline auto the_options()
     -> decltype(mir::Server::get_options())
@@ -138,11 +149,6 @@
             the_options()->get("power-key-ignore-timeout", 2000)};
     }
 
-    bool enable_hardware_cursor()
-    {
-        return the_options()->get("enable-hardware-cursor", false);
-    }
-
     std::string spinner_executable()
     {
         // TODO: once our default spinner is ready for use everywhere, replace

=== modified file 'src/system_compositor.cpp'
--- src/system_compositor.cpp	2015-04-07 13:36:48 +0000
+++ src/system_compositor.cpp	2015-08-04 17:52:54 +0000
@@ -20,6 +20,7 @@
 #include "system_compositor.h"
 #include "server.h"
 #include "dm_connection.h"
+#include "cursor_enabler.h"
 
 #include <mir/input/composite_event_filter.h>
 #include <mir/abnormal_exit.h>
@@ -87,6 +88,8 @@
         return;
     }
 
+    std::chrono::milliseconds remove_pointer_timeout{server->remove_pointer_timeout()};
+
     server->add_init_callback([&]
         {
             auto vendor = (char *) glGetString(GL_VENDOR);
@@ -118,9 +121,16 @@
                 screen = server->the_screen();
                 screen_event_handler = server->the_screen_event_handler();
 
+                cursor_enabler = std::make_shared<CursorEnabler>(
+                    server->the_cursor(),
+                    remove_pointer_timeout);
+
                 auto composite_filter = server->the_composite_event_filter();
                 composite_filter->append(screen_event_handler);
 
+                if (server->enable_hardware_cursor())
+                    composite_filter->append(cursor_enabler);
+
                 unity_screen_service = server->the_unity_screen_service();
             }
         });

=== modified file 'src/system_compositor.h'
--- src/system_compositor.h	2015-04-07 13:36:48 +0000
+++ src/system_compositor.h	2015-08-04 17:52:54 +0000
@@ -30,6 +30,8 @@
 }
 }
 
+class CursorEnabler;
+
 namespace usc
 {
 
@@ -53,6 +55,7 @@
     std::shared_ptr<Screen> screen;
     std::shared_ptr<mir::input::EventFilter> screen_event_handler;
     std::shared_ptr<UnityScreenService> unity_screen_service;
+    std::shared_ptr<CursorEnabler> cursor_enabler;
 };
 
 }

=== modified file 'src/window_manager.cpp'
--- src/window_manager.cpp	2015-06-11 16:55:36 +0000
+++ src/window_manager.cpp	2015-08-04 17:52:54 +0000
@@ -20,23 +20,23 @@
 
 #include "session_monitor.h"
 
+#include "mir/graphics/display.h"
+#include "mir/graphics/display_configuration.h"
 #include "mir/geometry/rectangle.h"
-#include "mir/shell/surface_ready_observer.h"
 #include "mir/scene/session.h"
-#include "mir/scene/session_coordinator.h"
 #include "mir/scene/surface.h"
-#include "mir/scene/surface_creation_parameters.h"
 #include "mir/shell/display_layout.h"
 #include "mir/shell/focus_controller.h"
-#include "mir/shell/surface_specification.h"
 
 #include "mir_toolkit/client_types.h"
 
 #include <iostream>
+#include <algorithm>
 
 namespace mf = mir::frontend;
 namespace ms = mir::scene;
 namespace msh = mir::shell;
+namespace mg = mir::graphics;
 
 namespace
 {
@@ -93,9 +93,11 @@
         focus_controller,
         display_layout,
         session_coordinator},
-    session_monitor{session_monitor}
+    session_monitor{session_monitor},
+    display_layout{display_layout}
 {
 }
+
 void usc::WindowManager::on_session_added(std::shared_ptr<mir::scene::Session> const& session) const
 {
     std::cerr << "Opening session " << session->name() << std::endl;
@@ -103,6 +105,7 @@
     auto const usc_session = std::make_shared<UscSession>(session, *focus_controller);
 
     session_monitor->add(usc_session, session->process_id());
+    sessions.push_back(session);
 }
 
 void usc::WindowManager::on_session_removed(std::shared_ptr<mir::scene::Session> const& session) const
@@ -110,9 +113,59 @@
     std::cerr << "Closing session " << session->name() << std::endl;
 
     session_monitor->remove(session);
+
+    sessions.erase( std::remove(begin(sessions), end(sessions), session), end(sessions));
 }
 
 void usc::WindowManager::on_session_ready(std::shared_ptr<mir::scene::Session> const& session) const
 {
     session_monitor->mark_ready(session.get());
 }
+
+void usc::WindowManager::add_display(mir::geometry::Rectangle const& area)
+{
+    rects.push_back(area);
+    resize_scene_to_cloned_display_intersection();
+}
+
+void usc::WindowManager::remove_display(mir::geometry::Rectangle const& area)
+{
+    for(auto it = rects.begin(); it != rects.end();)
+    {
+        if (*it == area)
+            it = rects.erase(it);
+        else
+            it++;
+    }
+
+    resize_scene_to_cloned_display_intersection();
+}
+
+void usc::WindowManager::resize_scene_to_cloned_display_intersection()
+{
+    using namespace mir::geometry;
+    // Determine display intersection geometry - they should already be cloned and have
+    // orientation (i.e. both landscape)
+
+    if (rects.empty())
+        return;
+
+    auto intersection = rects.front();
+    for (auto const& rect : rects)
+        intersection = intersection.intersection_with(rect);
+
+    std::cout << "Intersection: " << intersection << std::endl;
+
+    // Now resize all surfaces in scene to this value
+    for (auto &session : sessions)
+    {
+        auto first = session->default_surface();
+        first->resize(intersection.size);
+        auto next = session->surface_after(first);
+        while (next != first)
+        {
+            next->resize(intersection.size);
+            next = session->surface_after(next);
+        }
+    }
+}

=== modified file 'src/window_manager.h'
--- src/window_manager.h	2015-06-11 16:51:42 +0000
+++ src/window_manager.h	2015-08-04 17:52:54 +0000
@@ -20,11 +20,15 @@
 #define USC_WINDOW_MANAGER_H_
 
 #include <mir/shell/system_compositor_window_manager.h>
+#include "mir/geometry/rectangle.h"
 #include "session_monitor.h"
+#include <vector>
+#include <set>
 
 namespace mir
 {
-namespace scene { class PlacementStrategy; class SessionCoordinator; }
+namespace graphics { class Display; }
+namespace scene { class SessionCoordinator; }
 namespace shell { class FocusController; class DisplayLayout; }
 }
 
@@ -39,14 +43,24 @@
         mir::shell::FocusController* focus_controller,
         std::shared_ptr<mir::shell::DisplayLayout> const& display_layout,
         std::shared_ptr<mir::scene::SessionCoordinator> const& session_coordinator,
-        std::shared_ptr<SessionMonitor> const& session_switcher);
+        std::shared_ptr<SessionMonitor> const& session_monitor);
 
 private:
+    void resize_scene_to_cloned_display_intersection();
     std::shared_ptr<SessionMonitor> const session_monitor;
 
+    std::shared_ptr<mir::graphics::Display> display;
+    std::shared_ptr<mir::shell::DisplayLayout> const display_layout;
+    mutable std::vector<std::shared_ptr<mir::scene::Session>> sessions;
+
+    void add_display(mir::geometry::Rectangle const& area);
+    void remove_display(mir::geometry::Rectangle const& area);
     virtual void on_session_added(std::shared_ptr<mir::scene::Session> const& session) const;
     virtual void on_session_removed(std::shared_ptr<mir::scene::Session> const& session) const;
     virtual void on_session_ready(std::shared_ptr<mir::scene::Session> const& session) const;
+    std::vector<mir::geometry::Rectangle> rects;
+    mir::geometry::Size surface_size;
+    std::vector<std::shared_ptr<mir::scene::Surface>> mutable surfaces;
 };
 }
 

=== modified file 'tests/integration-tests/test_unity_screen_service.cpp'
--- tests/integration-tests/test_unity_screen_service.cpp	2015-07-16 06:14:32 +0000
+++ tests/integration-tests/test_unity_screen_service.cpp	2015-08-04 17:52:54 +0000
@@ -50,6 +50,7 @@
     MOCK_METHOD2(set_inactivity_timeouts, void(int power_off_timeout, int dimmer_timeout));
 
     MOCK_METHOD1(set_touch_visualization_enabled, void(bool enabled));
+    MOCK_METHOD2(override_orientation, void(unsigned int, int));
 
     void register_power_state_change_handler(
         usc::PowerStateChangeHandler const& handler)

=== modified file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	2015-02-18 14:40:29 +0000
+++ tests/unit-tests/CMakeLists.txt	2015-08-04 17:52:54 +0000
@@ -22,6 +22,7 @@
 add_executable(
   usc_unit_tests
 
+  test_cursor_enabler.cpp
   test_session_switcher.cpp
   test_screen_event_handler.cpp
   test_mir_screen.cpp

=== added file 'tests/unit-tests/test_cursor_enabler.cpp'
--- tests/unit-tests/test_cursor_enabler.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/test_cursor_enabler.cpp	2015-08-04 17:52:54 +0000
@@ -0,0 +1,97 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU 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 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/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
+
+#include "src/cursor_enabler.h"
+
+#include "mir_toolkit/event.h"
+#include "mir/events/event_builders.h"
+#include "mir/graphics/cursor.h"
+#include "mir/graphics/cursor_image.h"
+#include "mir_toolkit/events/input/input_event.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <memory>
+#include <vector>
+#include <tuple>
+#include <cstring>
+#include <chrono>
+
+namespace mev = mir::events;
+
+namespace
+{
+struct MockCursor : mir::graphics::Cursor
+{
+    MOCK_METHOD0(show, void());
+    MOCK_METHOD1(show, void(mir::graphics::CursorImage const&));
+    MOCK_METHOD0(hide, void());
+    MOCK_METHOD1(move_to, void(mir::geometry::Point));
+    MOCK_METHOD2(override_orientation, void(uint32_t, MirOrientation));
+};
+
+struct TestCursorEnabler : ::testing::Test
+{
+    std::shared_ptr<::testing::NiceMock<MockCursor>> mock_cursor = std::make_shared<::testing::NiceMock<MockCursor>>();
+    std::chrono::milliseconds never_remove_pointer{0};
+    std::chrono::milliseconds remove_after_five_seconds_of_non_pointing_events{5000};
+
+    mir::EventUPtr mouse_event{ mev::make_event(MirInputDeviceId{1}, std::chrono::nanoseconds(10), mir_input_event_modifier_none, mir_pointer_action_motion, 0, 1.0f, 1.0f, 0.0f, 0.0f) };
+    mir::EventUPtr touch_event{ mev::make_event(MirInputDeviceId{2}, std::chrono::nanoseconds(6000), mir_input_event_modifier_none) };
+    mir::EventUPtr key_event{ mev::make_event(MirInputDeviceId{3}, std::chrono::nanoseconds(6000), mir_keyboard_action_up, 0, 0, mir_input_event_modifier_none) };
+    TestCursorEnabler()
+    {
+        mev::add_touch(*touch_event, 0, mir_touch_action_change, mir_touch_tooltype_unknown, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
+    }
+};
+}
+
+TEST_F(TestCursorEnabler, disables_cursor_on_start)
+{
+    using namespace testing;
+    EXPECT_CALL(*mock_cursor, hide());
+
+    CursorEnabler enabler(mock_cursor, never_remove_pointer);
+}
+
+TEST_F(TestCursorEnabler, enable_cursor_on_mouse_event)
+{
+    using namespace testing;
+    EXPECT_CALL(*mock_cursor, hide());
+    EXPECT_CALL(*mock_cursor, show());
+
+    CursorEnabler enabler(mock_cursor, never_remove_pointer);
+    enabler.handle(*mouse_event);
+}
+
+TEST_F(TestCursorEnabler, disable_cursor_on_touch_event)
+{
+    using namespace testing;
+    InSequence seq;
+    EXPECT_CALL(*mock_cursor, hide());
+    EXPECT_CALL(*mock_cursor, show());
+    EXPECT_CALL(*mock_cursor, hide());
+
+    CursorEnabler enabler(mock_cursor, remove_after_five_seconds_of_non_pointing_events);
+    enabler.handle(*mouse_event);
+    enabler.handle(*touch_event);
+}
+

=== modified file 'tests/unit-tests/test_mir_screen.cpp'
--- tests/unit-tests/test_mir_screen.cpp	2015-07-27 17:01:28 +0000
+++ tests/unit-tests/test_mir_screen.cpp	2015-08-04 17:52:54 +0000
@@ -26,6 +26,7 @@
 #include <mir/graphics/display_configuration.h>
 #include <mir/graphics/gl_context.h>
 #include <mir/input/touch_visualizer.h>
+#include <mir/graphics/cursor.h>
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -146,6 +147,15 @@
     void visualize_touches(std::vector<Spot> const& touches) override {}
 };
 
+struct MockCursor : mir::graphics::Cursor
+{
+    void show() {}
+    void show(mg::CursorImage const& ) {}
+    void hide() {}
+    void move_to(mir::geometry::Point) {}
+    void override_orientation(uint32_t, MirOrientation) {}
+};
+
 struct AMirScreen : testing::Test
 {
     AMirScreen()
@@ -272,6 +282,8 @@
         std::make_shared<testing::NiceMock<MockTouchVisualizer>>()};
     std::shared_ptr<AdvanceableTimer> timer{
         std::make_shared<AdvanceableTimer>()};
+    std::shared_ptr<MockCursor> cursor{
+        std::make_shared<testing::NiceMock<MockCursor>>()};
 
     usc::MirScreen mir_screen{
         screen_hardware,
@@ -280,6 +292,7 @@
         touch_visualizer,
         timer,
         timer,
+        cursor,
         {power_off_timeout, dimmer_timeout},
         {notification_power_off_timeout, notification_dimmer_timeout}};
 };

=== modified file 'tests/unit-tests/test_screen_event_handler.cpp'
--- tests/unit-tests/test_screen_event_handler.cpp	2015-07-13 12:35:41 +0000
+++ tests/unit-tests/test_screen_event_handler.cpp	2015-08-04 17:52:54 +0000
@@ -46,6 +46,7 @@
     MOCK_METHOD2(set_inactivity_timeouts, void(int power_off_timeout, int dimmer_timeout));
 
     MOCK_METHOD1(set_touch_visualization_enabled, void(bool enabled));
+    MOCK_METHOD2(override_orientation, void(unsigned int, int));
     MOCK_METHOD1(register_power_state_change_handler, void(
                  usc::PowerStateChangeHandler const& handler));