Merge lp:~andreas-pokorny/unity-system-compositor/override-orientation-dbus-api into lp:unity-system-compositor

[Andreas Pokorny]

Ugly hack to have a different orientation for cursors without changing the orientation

Ugly hack to have a different orientation for cursors without changing the orientation

Unmerged revisions

205. By Andreas Pokorny on 2015-02-06

add a dbus api to override orientation

204. By Andreas Pokorny on 2015-02-05

merge event-2.0 changes back in

*fingers-crossed*

203. By Andreas Pokorny on 2015-02-05

keep display on when mouse pointer moves

202. By Andreas Pokorny on 2015-02-04

merged mirevent-2.0

201. By Andreas Pokorny on 2015-02-03

further cleanup drops all references to cursor image again

200. By Andreas Pokorny on 2015-02-03

ok nearly

199. By Andreas Pokorny on 2015-02-03

merged msh changes

198. By Andreas Pokorny on 2015-02-03

merged event-2.0 changes

197. By Andreas Pokorny on 2015-02-03

add test and cleanup further

196. By Andreas Pokorny on 2015-02-03

Rework Cursor enablement inside Unity-System-Compositor

=== modified file 'debian/control'
--- debian/control	2015-01-07 23:33:32 +0000
+++ debian/control	2015-02-06 12:38:32 +0000
@@ -19,7 +19,7 @@
                libglib2.0-dev,
                libgles2-mesa-dev,
                libmirclient-dev (>= 0.6.0),
-               libmirserver-dev (>= 0.10.0),
+               libmirserver-dev (>= 0.11.0),
                libprotobuf-dev,
                pkg-config,
                python:any (>= 2.7),

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-11-06 12:18:08 +0000
+++ src/CMakeLists.txt	2015-02-06 12:38:32 +0000
@@ -16,15 +16,15 @@
 
 set(USC_SRCS
   asio_dm_connection.cpp
+  cursor_enabler.cpp
   dbus_screen.cpp
   external_spinner.cpp
   powerd_mediator.cpp
   powerkey_handler.cpp
   screen_state_handler.cpp
   server.cpp
-  session_coordinator.cpp
+  shell.cpp
   session_switcher.cpp
-  surface_coordinator.cpp
   system_compositor.cpp
   worker_thread.cpp
 )

=== added file 'src/cursor_enabler.cpp'
--- src/cursor_enabler.cpp	1970-01-01 00:00:00 +0000
+++ src/cursor_enabler.cpp	2015-02-06 12:38:32 +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 = event.motion.event_time;
+    }
+    else if (remove_delay &&
+             mir_input_event_type_touch == mir_input_event_get_type(ev) &&
+             (event.motion.event_time - 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-02-06 12:38:32 +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/dbus_screen.cpp'
--- src/dbus_screen.cpp	2014-10-10 22:43:34 +0000
+++ src/dbus_screen.cpp	2015-02-06 12:38:32 +0000
@@ -20,6 +20,9 @@
 #include "power_state_change_reason.h"
 #include "worker_thread.h"
 
+#include "mir/input/input_region.h"
+#include "mir/graphics/cursor.h"
+
 #include <atomic>
 #include <memory>
 #include <thread>
@@ -53,12 +56,17 @@
 }
 
 
-DBusScreen::DBusScreen(DBusScreenObserver& observer, QObject *parent)
+DBusScreen::DBusScreen(DBusScreenObserver& observer,
+                       std::shared_ptr<mir::input::InputRegion> const& region,
+                       std::shared_ptr<mir::graphics::Cursor> const& cursor,
+                       QObject *parent)
     : QObject(parent),
       dbus_adaptor{new DBusScreenAdaptor(this)},
       service_watcher{new QDBusServiceWatcher()},
       observer{&observer},
-      worker_thread{new usc::WorkerThread("USC/DBusHandler")}
+      worker_thread{new usc::WorkerThread("USC/DBusHandler")},
+      region(region),
+      cursor(cursor)
 {
     QDBusConnection bus = QDBusConnection::systemBus();
     bus.registerObject("/com/canonical/Unity/Screen", this);
@@ -211,3 +219,9 @@
 {
     observer->set_touch_visualization_enabled(enabled);
 }
+
+void DBusScreen::overrideOrientation(unsigned int index, int orientation)
+{
+    region->override_orientation(index, static_cast<MirOrientation>(orientation));
+    cursor->override_orientation(index, static_cast<MirOrientation>(orientation));
+}

=== modified file 'src/dbus_screen.h'
--- src/dbus_screen.h	2014-09-22 17:19:52 +0000
+++ src/dbus_screen.h	2015-02-06 12:38:32 +0000
@@ -30,6 +30,8 @@
 
 namespace usc {class WorkerThread;}
 
+namespace mir { namespace graphics { class Cursor; } namespace input { class InputRegion; } }
+
 class DBusScreenAdaptor;
 class DBusScreenObserver;
 class QDBusInterface;
@@ -42,7 +44,7 @@
     Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity.Screen")
 
 public:
-    explicit DBusScreen(DBusScreenObserver& observer, QObject *parent = 0);
+    explicit DBusScreen(DBusScreenObserver& observer, std::shared_ptr<mir::input::InputRegion> const& region, std::shared_ptr<mir::graphics::Cursor> const& cursor, QObject *parent = 0);
     virtual ~DBusScreen();
 
     void emit_power_state_change(MirPowerMode mode, PowerStateChangeReason reason);
@@ -59,6 +61,7 @@
     void setInactivityTimeouts(int poweroff_timeout, int dimmer_timeout);
     
     void setTouchVisualizationEnabled(bool enabled);
+    void overrideOrientation(unsigned int index, int orientation);
 
 private Q_SLOTS:
     void remove_display_on_requestor(QString const& requestor);
@@ -72,6 +75,8 @@
     std::unordered_map<std::string, std::unordered_set<int>> display_requests;
     DBusScreenObserver* const observer;
     std::unique_ptr<usc::WorkerThread> worker_thread;
+    std::shared_ptr<mir::input::InputRegion> const region;
+    std::shared_ptr<mir::graphics::Cursor> const cursor;
 };
 
 #endif /* DBUS_SCREEN_H_ */

=== modified file 'src/powerkey_handler.cpp'
--- src/powerkey_handler.cpp	2014-07-21 21:33:35 +0000
+++ src/powerkey_handler.cpp	2015-02-06 12:38:32 +0000
@@ -44,15 +44,22 @@
 bool PowerKeyHandler::handle(MirEvent const& event)
 {
     static const int32_t POWER_KEY_CODE = 26;
-
-    if (event.type == mir_event_type_key &&
-        event.key.key_code == POWER_KEY_CODE)
-    {
-        if (event.key.action == mir_key_action_down)
-            power_key_down();
-        else if (event.key.action == mir_key_action_up)
-            power_key_up();
-    }
+    
+    if (mir_event_get_type(&event) != mir_event_type_input)
+        return false;
+    auto input_event = mir_event_get_input_event(&event);
+    if (mir_input_event_get_type(input_event) != mir_input_event_type_key)
+        return false;
+    auto kev = mir_input_event_get_key_input_event(input_event);
+    if (mir_key_input_event_get_key_code(kev) != POWER_KEY_CODE)
+        return false;
+
+    auto action = mir_key_input_event_get_action(kev);
+    if (action == mir_key_input_event_action_down)
+        power_key_down();
+    else if (action == mir_key_input_event_action_up)
+        power_key_up();
+
     return false;
 }
 

=== modified file 'src/screen_state_handler.cpp'
--- src/screen_state_handler.cpp	2015-01-26 22:59:20 +0000
+++ src/screen_state_handler.cpp	2015-02-06 12:38:32 +0000
@@ -47,7 +47,7 @@
               std::bind(&ScreenStateHandler::power_off_alarm_notification, this))},
       dimmer_alarm{server->the_main_loop()->create_alarm(
               std::bind(&ScreenStateHandler::dimmer_alarm_notification, this))},
-      dbus_screen{new DBusScreen(*this)}
+      dbus_screen{new DBusScreen(*this, server->the_input_region(), server->the_cursor())}
 {
     /*
      * Make sure the compositor is running as certain conditions can
@@ -62,13 +62,22 @@
 
 bool ScreenStateHandler::handle(MirEvent const& event)
 {
-    if (event.type == mir_event_type_motion)
-    {
-        std::lock_guard<std::mutex> lock{guard};
-        reset_timers_l();
-        if (current_power_mode == MirPowerMode::mir_power_mode_on)
-            powerd_mediator->set_normal_backlight();
-    }
+    if (mir_event_get_type(&event) != mir_event_type_input)
+        return false;
+
+    auto input_event_type = mir_input_event_get_type(mir_event_get_input_event(&event));
+    // TODO: We should consider resetting the timer for key events too
+    // we have to make sure we wont introduce a bug where pressing the power
+    // key (to turn screen off) or just the volume keys will wake the screen though!
+    if (!(input_event_type == mir_input_event_type_touch
+          || input_event_type == mir_input_event_type_pointer))
+        return false;
+
+    std::lock_guard<std::mutex> lock{guard};
+    reset_timers_l();
+    if (current_power_mode == MirPowerMode::mir_power_mode_on)
+        powerd_mediator->set_normal_backlight();
+
     return false;
 }
 

=== modified file 'src/server.cpp'
--- src/server.cpp	2014-11-28 11:39:04 +0000
+++ src/server.cpp	2015-02-06 12:38:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014 Canonical Ltd.
+ * Copyright © 2014-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
@@ -18,8 +18,7 @@
 
 #include "server.h"
 #include "external_spinner.h"
-#include "session_coordinator.h"
-#include "surface_coordinator.h"
+#include "shell.h"
 #include "asio_dm_connection.h"
 #include "session_switcher.h"
 
@@ -103,44 +102,23 @@
     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("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("disable-inactivity-policy", "Disables handling user inactivity and power key",  mir::OptionType::boolean);
 
     set_command_line(argc, const_cast<char const **>(argv));
 
     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>
         {
             return std::make_shared<ServerStatusListener>(the_focus_controller());
         });
 
-    wrap_session_coordinator([this](std::shared_ptr<ms::SessionCoordinator> const& wrapped)
-        -> std::shared_ptr<ms::SessionCoordinator>
-        {
-            return std::make_shared<SessionCoordinator>(
-                wrapped,
-                the_session_switcher());
-        });
-
-    wrap_surface_coordinator([this](std::shared_ptr<ms::SurfaceCoordinator> const& wrapped)
-        -> std::shared_ptr<mir::scene::SurfaceCoordinator>
-        {
-            return std::make_shared<SurfaceCoordinator>(
-                wrapped,
-                the_session_switcher());
+    wrap_shell([this](std::shared_ptr<msh::Shell> const& wrapped)
+        -> std::shared_ptr<msh::Shell>
+        {
+            return std::make_shared<Shell>(wrapped, the_session_switcher());
         });
 
     set_config_filename("unity-system-compositor.conf");

=== modified file 'src/server.h'
--- src/server.h	2014-11-28 11:39:04 +0000
+++ src/server.h	2015-02-06 12:38:32 +0000
@@ -42,6 +42,8 @@
     using mir::Server::the_display;
     using mir::Server::the_compositor;
     using mir::Server::the_touch_visualizer;
+    using mir::Server::the_cursor;
+    using mir::Server::the_input_region;
 
     virtual std::shared_ptr<Spinner> the_spinner();
     virtual std::shared_ptr<DMMessageHandler> the_dm_message_handler();
@@ -72,6 +74,11 @@
        return the_options()->get("power-key-ignore-timeout", 2000);
     }
 
+    int remove_pointer_timeout()
+    {
+       return the_options()->get("remove-pointer-timeout", 0);
+    }
+
     bool enable_hardware_cursor()
     {
         return the_options()->get("enable-hardware-cursor", false);

=== renamed file 'src/session_coordinator.cpp' => 'src/shell.cpp'
--- src/session_coordinator.cpp	2014-08-01 21:58:43 +0000
+++ src/shell.cpp	2015-02-06 12:38:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014 Canonical Ltd.
+ * Copyright © 2014-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
@@ -16,10 +16,12 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#include "session_coordinator.h"
+#include "shell.h"
 #include "session_switcher.h"
 
+#include <mir/scene/null_surface_observer.h>
 #include <mir/scene/session.h>
+#include <mir/scene/surface.h>
 #include <mir/frontend/session.h>
 
 #include <iostream>
@@ -71,34 +73,59 @@
     msh::FocusController& focus_controller;
 };
 
+
+struct SessionReadyObserver : ms::NullSurfaceObserver,
+                              std::enable_shared_from_this<SessionReadyObserver>
+{
+    SessionReadyObserver(
+        std::shared_ptr<usc::SessionSwitcher> const& switcher,
+        std::shared_ptr<ms::Surface> const& surface,
+        ms::Session const* session)
+        : switcher{switcher},
+          surface{surface},
+          session{session}
+    {
+    }
+
+    void frame_posted(int) override
+    {
+        ++num_frames_posted;
+        if (num_frames_posted == num_frames_for_session_ready)
+        {
+            switcher->mark_ready(session);
+            surface->remove_observer(shared_from_this());
+        }
+    }
+
+    std::shared_ptr<usc::SessionSwitcher> const switcher;
+    std::shared_ptr<ms::Surface> const surface;
+    ms::Session const* const session;
+    // We need to wait for the second frame before marking the session
+    // as ready. The first frame posted from sessions is a blank frame.
+    // TODO: Solve this issue at its root and remove this workaround
+    int const num_frames_for_session_ready{2};
+    int num_frames_posted{0};
+};
+
 }
 
-usc::SessionCoordinator::SessionCoordinator(
-    std::shared_ptr<ms::SessionCoordinator> const& wrapped,
+usc::Shell::Shell(
+    std::shared_ptr<msh::Shell> const& wrapped,
     std::shared_ptr<SessionSwitcher> const& session_switcher)
-    : msh::SessionCoordinatorWrapper{wrapped},
+    : msh::ShellWrapper{wrapped},
       session_switcher{session_switcher}
 {
 }
 
-std::shared_ptr<mf::Session>
-usc::SessionCoordinator::open_session(
+std::shared_ptr<ms::Session>
+usc::Shell::open_session(
     pid_t client_pid,
     std::string const& name,
     std::shared_ptr<mf::EventSink> const& sink)
 {
     std::cerr << "Opening session " << name << std::endl;
 
-    // We need ms::Session objects because that is what the focus controller
-    // works with.  But the mf::SessionCoordinator interface deals with mf::Session objects.
-    // So we cast here since in practice, these objects are also ms::Sessions.
-    auto orig = std::dynamic_pointer_cast<ms::Session>(
-        msh::SessionCoordinatorWrapper::open_session(client_pid, name, sink));
-    if (!orig)
-    {
-        std::cerr << "Unexpected non-shell session" << std::endl;
-        return std::shared_ptr<mf::Session>();
-    }
+    auto orig = msh::ShellWrapper::open_session(client_pid, name, sink);
 
     auto const usc_session = std::make_shared<UscSession>(orig, *this);
 
@@ -107,12 +134,24 @@
     return orig;
 }
 
-void usc::SessionCoordinator::close_session(
-    std::shared_ptr<mf::Session> const& session)
+void usc::Shell::close_session(std::shared_ptr<ms::Session> const& session)
 {
     std::cerr << "Closing session " << session->name() << std::endl;
 
-    msh::SessionCoordinatorWrapper::close_session(session);
+    msh::ShellWrapper::close_session(session);
 
     session_switcher->remove(session);
 }
+
+mf::SurfaceId usc::Shell::create_surface(std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& params)
+{
+    auto const id = msh::ShellWrapper::create_surface(session, params);
+
+    auto const surface = session->surface(id);
+    auto const session_ready_observer = std::make_shared<SessionReadyObserver>(
+        session_switcher, surface, session.get());
+
+    surface->add_observer(session_ready_observer);
+
+    return id;
+}

=== renamed file 'src/session_coordinator.h' => 'src/shell.h'
--- src/session_coordinator.h	2014-07-09 06:58:05 +0000
+++ src/shell.h	2015-02-06 12:38:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014 Canonical Ltd.
+ * Copyright © 2014-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
@@ -16,35 +16,35 @@
  * Authored by: Alexandros Frantzis <[e-mail]>
  */
 
-#ifndef USC_SESSION_COORDINATOR_H_
-#define USC_SESSION_COORDINATOR_H_
+#ifndef USC_SHELL_H_
+#define USC_SHELL_H_
 
-#include <mir/shell/session_coordinator_wrapper.h>
+#include <mir/shell/shell_wrapper.h>
 
 #include <memory>
 
-namespace mir
-{
-namespace scene { class SurfaceCoordinator; }
-}
 
 namespace usc
 {
 class SessionSwitcher;
 
-class SessionCoordinator : public mir::shell::SessionCoordinatorWrapper
+class Shell : public mir::shell::ShellWrapper
 {
 public:
-    SessionCoordinator(
-        std::shared_ptr<mir::scene::SessionCoordinator> const& wrapped,
+    Shell(
+        std::shared_ptr<mir::shell::Shell> const& wrapped,
         std::shared_ptr<SessionSwitcher> const& session_switcher);
 
 private:
-    std::shared_ptr<mir::frontend::Session> open_session(
+    std::shared_ptr<mir::scene::Session> open_session(
         pid_t client_pid,
         std::string const& name,
         std::shared_ptr<mir::frontend::EventSink> const& sink) override;
-    void close_session(std::shared_ptr<mir::frontend::Session> const& session) override;
+    void close_session(std::shared_ptr<mir::scene::Session> const& session) override;
+
+    mir::frontend::SurfaceId create_surface(
+        std::shared_ptr<mir::scene::Session> const& session,
+        mir::scene::SurfaceCreationParameters const& params) override;
 
     std::shared_ptr<SessionSwitcher> const session_switcher;
 };

=== removed file 'src/surface_coordinator.cpp'
--- src/surface_coordinator.cpp	2014-08-01 21:58:43 +0000
+++ src/surface_coordinator.cpp	1970-01-01 00:00:00 +0000
@@ -1,87 +0,0 @@
-/*
- * Copyright © 2014 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: Alexandros Frantzis <[e-mail]>
- */
-
-#include "surface_coordinator.h"
-#include "session_switcher.h"
-
-#include <mir/scene/null_surface_observer.h>
-#include <mir/scene/surface.h>
-#include <mir/scene/session.h>
-
-namespace ms = mir::scene;
-namespace msh = mir::shell;
-
-namespace
-{
-
-struct SessionReadyObserver : ms::NullSurfaceObserver,
-                              std::enable_shared_from_this<SessionReadyObserver>
-{
-    SessionReadyObserver(
-        std::shared_ptr<usc::SessionSwitcher> const& switcher,
-        std::shared_ptr<ms::Surface> const& surface,
-        ms::Session const* session)
-        : switcher{switcher},
-          surface{surface},
-          session{session}
-    {
-    }
-
-    void frame_posted(int) override
-    {
-        ++num_frames_posted;
-        if (num_frames_posted == num_frames_for_session_ready)
-        {
-            switcher->mark_ready(session);
-            surface->remove_observer(shared_from_this());
-        }
-    }
-
-    std::shared_ptr<usc::SessionSwitcher> const switcher;
-    std::shared_ptr<ms::Surface> const surface;
-    ms::Session const* const session;
-    // We need to wait for the second frame before marking the session
-    // as ready. The first frame posted from sessions is a blank frame.
-    // TODO: Solve this issue at its root and remove this workaround
-    int const num_frames_for_session_ready{2};
-    int num_frames_posted{0};
-};
-
-}
-
-usc::SurfaceCoordinator::SurfaceCoordinator(
-    std::shared_ptr<ms::SurfaceCoordinator> const& wrapped,
-    std::shared_ptr<SessionSwitcher> const& session_switcher)
-    : msh::SurfaceCoordinatorWrapper{wrapped},
-      session_switcher{session_switcher}
-{
-}
-
-std::shared_ptr<ms::Surface> usc::SurfaceCoordinator::add_surface(
-    ms::SurfaceCreationParameters const& params,
-    ms::Session* session)
-{
-    auto const surface = msh::SurfaceCoordinatorWrapper::add_surface(params, session);
-
-    auto const session_ready_observer = std::make_shared<SessionReadyObserver>(
-        session_switcher, surface, session);
-
-    surface->add_observer(session_ready_observer);
-
-    return surface;
-}

=== removed file 'src/surface_coordinator.h'
--- src/surface_coordinator.h	2014-07-09 06:58:05 +0000
+++ src/surface_coordinator.h	1970-01-01 00:00:00 +0000
@@ -1,47 +0,0 @@
-/*
- * Copyright © 2014 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: Alexandros Frantzis <[e-mail]>
- */
-
-#ifndef USC_SURFACE_COORDINATOR_H_
-#define USC_SURFACE_COORDINATOR_H_
-
-#include <mir/shell/surface_coordinator_wrapper.h>
-
-#include <memory>
-
-namespace usc
-{
-class SessionSwitcher;
-
-class SurfaceCoordinator : public mir::shell::SurfaceCoordinatorWrapper
-{
-public:
-    SurfaceCoordinator(
-        std::shared_ptr<mir::scene::SurfaceCoordinator> const& wrapped,
-        std::shared_ptr<SessionSwitcher> const& session_switcher);
-
-private:
-    std::shared_ptr<mir::scene::Surface> add_surface(
-        mir::scene::SurfaceCreationParameters const& params,
-        mir::scene::Session* session) override;
-
-    std::shared_ptr<SessionSwitcher> const session_switcher;
-};
-
-}
-
-#endif

=== modified file 'src/system_compositor.cpp'
--- src/system_compositor.cpp	2015-01-05 22:38:04 +0000
+++ src/system_compositor.cpp	2015-02-06 12:38:32 +0000
@@ -24,6 +24,7 @@
 #include "spinner.h"
 #include "screen_state_handler.h"
 #include "powerkey_handler.h"
+#include "cursor_enabler.h"
 
 // Qt headers will introduce a #define of "signals"
 // but some mir headers use "signals" as a variable name in
@@ -152,6 +153,7 @@
         std::chrono::seconds inactivity_display_dim_timeout{server->inactivity_display_dim_timeout()};
         std::chrono::milliseconds power_key_ignore_timeout{server->power_key_ignore_timeout()};
         std::chrono::milliseconds shutdown_timeout{server->shutdown_timeout()};
+        std::chrono::milliseconds remove_pointer_timeout{server->remove_pointer_timeout()};
 
         screen_state_handler = std::make_shared<ScreenStateHandler>(server,
             std::chrono::duration_cast<std::chrono::milliseconds>(inactivity_display_off_timeout),
@@ -162,9 +164,15 @@
             shutdown_timeout,
             *screen_state_handler);
 
+        cursor_image_enabler = std::make_shared<CursorEnabler>(
+            server->the_cursor(),
+            remove_pointer_timeout);
+
         auto composite_filter = server->the_composite_event_filter();
         composite_filter->append(screen_state_handler);
         composite_filter->append(power_key_handler);
+        if (server->enable_hardware_cursor())
+            composite_filter->append(cursor_image_enabler);
     }
 
     app.exec();

=== modified file 'src/system_compositor.h'
--- src/system_compositor.h	2014-11-28 13:19:29 +0000
+++ src/system_compositor.h	2015-02-06 12:38:32 +0000
@@ -24,6 +24,7 @@
 
 class ScreenStateHandler;
 class PowerKeyHandler;
+class CursorEnabler;
 
 namespace usc
 {
@@ -46,6 +47,7 @@
     std::shared_ptr<Spinner> const spinner;
     std::shared_ptr<ScreenStateHandler> screen_state_handler;
     std::shared_ptr<PowerKeyHandler> power_key_handler;
+    std::shared_ptr<CursorEnabler> cursor_image_enabler;
 };
 
 }

=== modified file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	2014-07-09 06:58:05 +0000
+++ tests/unit-tests/CMakeLists.txt	2015-02-06 12:38:32 +0000
@@ -23,6 +23,7 @@
   usc_unit_tests
 
   test_session_switcher.cpp
+  test_cursor_enabler.cpp
 )
 
 target_link_libraries(

=== 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-02-06 12:38:32 +0000
@@ -0,0 +1,110 @@
+/*
+ * 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/graphics/cursor.h"
+#include "mir/graphics/cursor_image.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <memory>
+#include <vector>
+#include <tuple>
+#include <cstring>
+
+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};
+
+    MirEvent mouse_event;
+    MirEvent touch_event;
+    MirEvent key_event;
+    TestCursorEnabler()
+    {
+        std::memset(&mouse_event, 0, sizeof mouse_event);
+        std::memset(&touch_event, 0, sizeof touch_event);
+        std::memset(&key_event, 0, sizeof key_event);
+
+        mouse_event.type = mir_event_type_motion;
+        mouse_event.motion.source_id = 0x02002; // android constant for mouse | pointer
+        mouse_event.motion.pointer_count = 1;
+        mouse_event.motion.event_time = 0;
+        mouse_event.motion.pointer_coordinates[0].tool_type = mir_motion_tool_type_mouse;
+
+        touch_event.type = mir_event_type_motion;
+        touch_event.motion.source_id = 0x01002; // android constant for touchscreen | pointer
+        touch_event.motion.pointer_count = 1;
+        touch_event.motion.event_time = 6000;
+        touch_event.motion.pointer_coordinates[0].tool_type = mir_motion_tool_type_finger;
+
+        key_event.type = mir_event_type_key;
+        key_event.key.source_id = 0x0101; // android constant for keyboard | button
+        key_event.key.event_time = 6000;
+    }
+};
+}
+
+TEST_F(TestCursorEnabler, diables_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_session_switcher.cpp'
--- tests/unit-tests/test_session_switcher.cpp	2014-08-01 21:58:43 +0000
+++ tests/unit-tests/test_session_switcher.cpp	2015-02-06 12:38:32 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2014 Canonical Ltd.
+ * Copyright © 2014-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
@@ -96,13 +96,9 @@
         : name_{name}
     {}
 
-    mir::frontend::SurfaceId create_surface(mir::scene::SurfaceCreationParameters const&) override { return mir::frontend::SurfaceId{0}; }
-    void destroy_surface(mir::frontend::SurfaceId) override {}
     std::shared_ptr<mir::frontend::Surface> get_surface(mir::frontend::SurfaceId surface) const override { return nullptr; }
 
     std::string name() const override { return name_; }
-    void hide() override {}
-    void show() override {}
 
 private:
     std::string const name_;