Merge lp:~andreas-pokorny/mir/override-orientation into lp:mir/0.13

[Andreas Pokorny]

Overrides the configured orientation in mir for moving and displaying the cursor

Updated orientation override for mir-0.13

[lp:~andreas-pokorny/mir/override-orientation]

2291. By Andreas Pokorny on 2015-07-02

changelog entry

2292. By Andreas Pokorny on 2015-07-02

guessing a better version

Unmerged revisions

2292. By Andreas Pokorny on 2015-07-02

guessing a better version

2291. By Andreas Pokorny on 2015-07-02

changelog entry

2290. By Andreas Pokorny on 2015-07-02

switch to mir 0.13.0

2289. By Andreas Pokorny on 2015-07-02

add orientation override

2288. By Andreas Pokorny on 2015-07-02

merge mir-0.12 and pointer acceleration enablement

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/VelocityControl.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/VelocityControl.cpp	2015-03-31 02:35:42 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/VelocityControl.cpp	2015-07-02 11:48:27 +0000
@@ -70,7 +70,7 @@
 
         float vx, vy;
         float scale = mParameters.scale;
-        if (mVelocityTracker.getVelocity(0, &vx, &vy)) {
+        if (mVelocityTracker.getVelocity(1, &vx, &vy)) {
             float speed = hypotf(vx, vy) * scale;
             if (speed >= mParameters.highThreshold) {
                 // Apply full acceleration above the high speed threshold.

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/VelocityTracker.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/VelocityTracker.cpp	2015-03-31 02:35:42 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/VelocityTracker.cpp	2015-07-02 11:48:27 +0000
@@ -65,36 +65,31 @@
 
 #if DEBUG_STRATEGY || DEBUG_VELOCITY
 static String8 vectorToString(const float* a, uint32_t m) {
-    String8 str;
-    str.append("[");
+    std::stringstream str;
+    str << '[';
     while (m--) {
-        str.appendFormat(" %f", *(a++));
-        if (m) {
-            str.append(",");
-        }
+        str << *a++;
+        if (m)
+            str << ',';
     }
-    str.append(" ]");
-    return str;
+    str << ']';
+    return str.str();
 }
 
 static String8 matrixToString(const float* a, uint32_t m, uint32_t n, bool rowMajor) {
-    String8 str;
-    str.append("[");
+    std::stringstream str;
+    str << '[';
     for (size_t i = 0; i < m; i++) {
-        if (i) {
-            str.append(",");
-        }
-        str.append(" [");
+        if (i) str << ',';
+        str << " [";
         for (size_t j = 0; j < n; j++) {
-            if (j) {
-                str.append(",");
-            }
-            str.appendFormat(" %f", a[rowMajor ? i * n + j : j * m + i]);
+            if (j) str << ',';
+            str << ' ' << a[rowMajor ? i * n + j : j * m + i];
         }
-        str.append(" ]");
+        str << " ]";
     }
-    str.append(" ]");
-    return str;
+    str << " ]";
+    return str.str();
 }
 #endif
 
@@ -249,11 +244,11 @@
                 "estimator (degree=%d, xCoeff=%s, yCoeff=%s, confidence=%f)",
                 id, positions[index].x, positions[index].y,
                 int(estimator.degree),
-                vectorToString(estimator.xCoeff, estimator.degree + 1).string(),
-                vectorToString(estimator.yCoeff, estimator.degree + 1).string(),
+                vectorToString(estimator.xCoeff, estimator.degree + 1).c_str(),
+                vectorToString(estimator.yCoeff, estimator.degree + 1).c_str(),
                 estimator.confidence);
         ++index;
-    }
+    });
 #endif
 }
 
@@ -436,8 +431,8 @@
         const float* w, uint32_t m, uint32_t n, float* outB, float* outDet) {
 #if DEBUG_STRATEGY
     ALOGD("solveLeastSquares: m=%d, n=%d, x=%s, y=%s, w=%s", int(m), int(n),
-            vectorToString(x, m).string(), vectorToString(y, m).string(),
-            vectorToString(w, m).string());
+            vectorToString(x, m).c_str(), vectorToString(y, m).c_str(),
+            vectorToString(w, m).c_str());
 #endif
 
     // Expand the X vector to a matrix A, pre-multiplied by the weights.
@@ -449,7 +444,7 @@
         }
     }
 #if DEBUG_STRATEGY
-    ALOGD("  - a=%s", matrixToString(&a[0][0], m, n, false /*rowMajor*/).string());
+    ALOGD("  - a=%s", matrixToString(&a[0][0], m, n, false /*rowMajor*/).c_str());
 #endif
 
     // Apply the Gram-Schmidt process to A to obtain its QR decomposition.
@@ -484,8 +479,8 @@
         }
     }
 #if DEBUG_STRATEGY
-    ALOGD("  - q=%s", matrixToString(&q[0][0], m, n, false /*rowMajor*/).string());
-    ALOGD("  - r=%s", matrixToString(&r[0][0], n, n, true /*rowMajor*/).string());
+    ALOGD("  - q=%s", matrixToString(&q[0][0], m, n, false /*rowMajor*/).c_str());
+    ALOGD("  - r=%s", matrixToString(&r[0][0], n, n, true /*rowMajor*/).c_str());
 
     // calculate QR, if we factored A correctly then QR should equal A
     float qr[n][m];
@@ -497,7 +492,7 @@
             }
         }
     }
-    ALOGD("  - qr=%s", matrixToString(&qr[0][0], m, n, false /*rowMajor*/).string());
+    ALOGD("  - qr=%s", matrixToString(&qr[0][0], m, n, false /*rowMajor*/).c_str());
 #endif
 
     // Solve R B = Qt W Y to find B.  This is easy because R is upper triangular.
@@ -514,7 +509,7 @@
         outB[i] /= r[i][i];
     }
 #if DEBUG_STRATEGY
-    ALOGD("  - b=%s", vectorToString(outB, n).string());
+    ALOGD("  - b=%s", vectorToString(outB, n).c_str());
 #endif
 
     // Calculate the coefficient of determination as 1 - (SSerr / SStot) where
@@ -598,10 +593,10 @@
             outEstimator->degree = degree;
             outEstimator->confidence = xdet * ydet;
 #if DEBUG_STRATEGY
-            ALOGD("estimate: degree=%d, xCoeff=%s, yCoeff=%s, confidence=%f",
+            ALOGD("estimate : degree=%d, xCoeff=%s, yCoeff=%s, confidence=%f",
                     int(outEstimator->degree),
-                    vectorToString(outEstimator->xCoeff, n).string(),
-                    vectorToString(outEstimator->yCoeff, n).string(),
+                    vectorToString(outEstimator->xCoeff, n).c_str(),
+                    vectorToString(outEstimator->yCoeff, n).c_str(),
                     outEstimator->confidence);
 #endif
             return true;

=== modified file 'debian/changelog'
--- debian/changelog	2015-06-17 20:02:15 +0000
+++ debian/changelog	2015-07-02 11:48:27 +0000
@@ -1,3 +1,14 @@
+mir (0.13.3+15.04.20150617-0ubuntu1) UNRELEASED; urgency=medium
+
+  * Orientation override and pointer acceleration
+    - Improvements:
+      . activates pointer acceleration path in android input stack
+    - Features:
+      . adds an interface to override the orienation of displays
+      . rotates the cursor according to the changed orientation
+
+ -- Andreas Pokorny <[e-mail]>  Thu, 02 Jul 2015 13:33:06 +0200
+
 mir (0.13.3+15.10.20150617-0ubuntu1) wily; urgency=medium
 
   [ Alberto Aguirre ]

=== added file 'include/common/mir/geometry/overrides.h'
--- include/common/mir/geometry/overrides.h	1970-01-01 00:00:00 +0000
+++ include/common/mir/geometry/overrides.h	2015-07-02 11:48:27 +0000
@@ -0,0 +1,92 @@
+/*
+ * Copyright © 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_GEOMETRY_OVERRIDES_H_
+#define MIR_GEOMETRY_OVERRIDES_H_
+
+#include "mir_toolkit/common.h"
+
+#include "mir/geometry/rectangle.h"
+
+#include <map>
+
+namespace mir
+{
+namespace geometry
+{
+struct Overrides
+{
+    inline MirOrientation get_orientation(uint32_t display_id, MirOrientation original)
+    {
+        if (end(overrides) == overrides.find(display_id))
+            return original;
+        return overrides[display_id];
+    }
+    inline Rectangle transform_rectangle(uint32_t display_id, Rectangle const& rect, MirOrientation original)
+    {
+        if (end(overrides) == overrides.find(display_id))
+            return rect;
+        if (original == overrides[display_id])
+            return rect;
+
+        switch(original)
+        {
+        case mir_orientation_left:
+        case mir_orientation_right:
+            switch(overrides[display_id])
+            {
+            case mir_orientation_left:
+            case mir_orientation_right:
+            default:
+                return rect;
+            case mir_orientation_inverted:
+            case mir_orientation_normal:
+                return swap_width_height(rect);
+            }
+        case mir_orientation_normal:
+        case mir_orientation_inverted:
+            switch(overrides[display_id])
+            {
+            case mir_orientation_left:
+            case mir_orientation_right:
+                return swap_width_height(rect);
+            case mir_orientation_inverted:
+            case mir_orientation_normal:
+            default:
+                return rect;
+            }
+        default:
+            return rect;
+        }
+    }
+
+    inline Rectangle swap_width_height(Rectangle rect)
+    {
+        return Rectangle{rect.top_left, Size{rect.size.height.as_int(), rect.size.width.as_int()}};
+    }
+
+    inline void add_override(uint32_t display, MirOrientation orientation)
+    {
+        overrides[display] = orientation;
+    }
+    std::map<uint32_t, MirOrientation> overrides;
+};
+}
+}
+
+#endif

=== modified file 'include/platform/mir/graphics/cursor.h'
--- include/platform/mir/graphics/cursor.h	2015-03-31 02:35:42 +0000
+++ include/platform/mir/graphics/cursor.h	2015-07-02 11:48:27 +0000
@@ -23,6 +23,7 @@
 #include "mir/geometry/size.h"
 #include "mir/geometry/point.h"
 
+#include "mir_toolkit/common.h"
 #include <memory>
 
 namespace mir
@@ -38,6 +39,7 @@
     virtual void hide() = 0;
 
     virtual void move_to(geometry::Point position) = 0;
+    virtual void override_orientation(uint32_t screen, MirOrientation orientation) = 0;
 
 protected:
     Cursor() = default;

=== renamed file 'src/include/server/mir/input/input_region.h' => 'include/server/mir/input/input_region.h'
--- src/include/server/mir/input/input_region.h	2015-01-21 07:34:50 +0000
+++ include/server/mir/input/input_region.h	2015-07-02 11:48:27 +0000
@@ -19,6 +19,9 @@
 #ifndef MIR_INPUT_INPUT_REGION_H_
 #define MIR_INPUT_INPUT_REGION_H_
 
+#include <mir_toolkit/common.h>
+#include <cstdint>
+
 namespace mir
 {
 namespace geometry
@@ -51,6 +54,9 @@
      */
     virtual void confine(geometry::Point& point) = 0;
 
+    virtual void override_orientation(uint32_t display_id, MirOrientation orientation) = 0;
+    virtual MirOrientation get_orientation(geometry::Point const& point) = 0;
+
 protected:
     InputRegion() = default;
     InputRegion(InputRegion const&) = delete;

=== modified file 'include/server/mir/server.h'
--- include/server/mir/server.h	2015-04-09 06:20:31 +0000
+++ include/server/mir/server.h	2015-07-02 11:48:27 +0000
@@ -31,7 +31,7 @@
 namespace compositor { class Compositor; class DisplayBufferCompositorFactory; }
 namespace frontend { class SessionAuthorizer; class Session; class SessionMediatorReport; }
 namespace graphics { class Cursor; class Platform; class Display; class GLConfig; class DisplayConfigurationPolicy; }
-namespace input { class CompositeEventFilter; class InputDispatcher; class CursorListener; class TouchVisualizer; class InputDeviceHub;}
+namespace input { class InputRegion; class CompositeEventFilter; class InputDispatcher; class CursorListener; class TouchVisualizer; class InputDeviceHub;}
 namespace logging { class Logger; }
 namespace options { class Option; }
 namespace shell
@@ -300,6 +300,9 @@
     /// \return the input targeter.
     auto the_input_targeter() const -> std::shared_ptr<shell::InputTargeter>;
 
+    /// Sets an override functor for creating the input region.
+    auto the_input_region() const -> std::shared_ptr<input::InputRegion>;
+
     /// \return the logger.
     auto the_logger() const -> std::shared_ptr<logging::Logger>;
 

=== modified file 'src/include/server/mir/display_changer.h'
--- src/include/server/mir/display_changer.h	2015-01-21 07:34:50 +0000
+++ src/include/server/mir/display_changer.h	2015-07-02 11:48:27 +0000
@@ -41,6 +41,7 @@
 
     virtual void pause_display_config_processing() = 0;
     virtual void resume_display_config_processing() = 0;
+    virtual void register_change_callback(std::function<void(graphics::DisplayConfiguration const&)> const& change_callback) = 0;
 
 protected:
     DisplayChanger() = default;

=== modified file 'src/platforms/mesa/server/cursor.cpp'
--- src/platforms/mesa/server/cursor.cpp	2015-04-30 11:36:36 +0000
+++ src/platforms/mesa/server/cursor.cpp	2015-07-02 11:48:27 +0000
@@ -262,11 +262,17 @@
     if (!visible)
         return;
 
+    uint32_t override_id = 0;
+
     for_each_used_output([&](KMSOutput& output, geom::Rectangle const& output_rect, MirOrientation orientation)
     {
         if (output_rect.contains(position))
         {
-            auto dp = transform(output_rect, position - output_rect.top_left, orientation);
+            MirOrientation overridden = orientation;
+            if (end(overrides) != overrides.find(override_id))
+                overridden = overrides[override_id];
+
+            auto dp = transform(output_rect, position - output_rect.top_left, overridden);
             
             // It's a little strange that we implement hotspot this way as there is
             // drmModeSetCursor2 with hotspot support. However it appears to not actually
@@ -285,5 +291,12 @@
                 output.clear_cursor();
             }
         }
+        ++override_id;
     });
 }
+
+void mgm::Cursor::override_orientation(uint32_t screen, MirOrientation orientation)
+{
+    // there is no cache invalidation in this hack
+    overrides[screen] = orientation;
+}

=== modified file 'src/platforms/mesa/server/cursor.h'
--- src/platforms/mesa/server/cursor.h	2015-03-31 02:35:42 +0000
+++ src/platforms/mesa/server/cursor.h	2015-07-02 11:48:27 +0000
@@ -28,6 +28,7 @@
 
 #include <gbm.h>
 
+#include <map>
 #include <memory>
 #include <mutex>
 
@@ -76,6 +77,7 @@
     void show() override;
     void show(CursorImage const& cursor_image) override;
     void hide() override;
+    void override_orientation(uint32_t screen, MirOrientation) override;
 
     void move_to(geometry::Point position) override;
 
@@ -113,6 +115,7 @@
     uint32_t buffer_height;
 
     std::shared_ptr<CurrentConfiguration> const current_configuration;
+    std::map<uint32_t, MirOrientation> overrides;
 };
 }
 }

=== modified file 'src/server/graphics/default_configuration.cpp'
--- src/server/graphics/default_configuration.cpp	2015-04-23 20:17:52 +0000
+++ src/server/graphics/default_configuration.cpp	2015-07-02 11:48:27 +0000
@@ -30,6 +30,7 @@
 #include "mir/graphics/gl_config.h"
 #include "mir/graphics/platform.h"
 #include "mir/graphics/cursor.h"
+#include "mir/graphics/display.h"
 #include "mir/graphics/platform_probe.h"
 #include "program_factory.h"
 
@@ -172,7 +173,6 @@
         {
             if (the_options()->is_set(options::host_socket_opt))
                 return std::make_shared<mgn::Cursor>(the_host_connection(), the_default_cursor_image());
-            
             // We try to create a hardware cursor, if this fails we use a software cursor
             auto hardware_cursor = the_display()->create_hardware_cursor(the_default_cursor_image());
             if (hardware_cursor)
@@ -185,6 +185,8 @@
                 mir::log_info("Using software cursor");
 
                 auto const cursor = std::make_shared<mg::SoftwareCursor>(
+                    *the_display()->configuration(), // hack
+                    the_display_changer(), // hack
                     the_buffer_allocator(),
                     the_input_scene());
 

=== modified file 'src/server/graphics/nested/cursor.cpp'
--- src/server/graphics/nested/cursor.cpp	2015-04-13 17:55:51 +0000
+++ src/server/graphics/nested/cursor.cpp	2015-07-02 11:48:27 +0000
@@ -50,3 +50,8 @@
 {
     connection->hide_cursor();
 }
+
+void mgn::Cursor::override_orientation(uint32_t, MirOrientation)
+{
+    // not going to be used.
+}

=== modified file 'src/server/graphics/nested/cursor.h'
--- src/server/graphics/nested/cursor.h	2015-04-13 17:43:08 +0000
+++ src/server/graphics/nested/cursor.h	2015-07-02 11:48:27 +0000
@@ -40,6 +40,7 @@
     void hide() override;
 
     void move_to(geometry::Point position) override;
+    void override_orientation(uint32_t screen, MirOrientation orientation) override;
 private:
     std::shared_ptr<HostConnection> const connection;
     std::shared_ptr<CursorImage> const default_image;

=== modified file 'src/server/graphics/software_cursor.cpp'
--- src/server/graphics/software_cursor.cpp	2015-04-30 11:36:36 +0000
+++ src/server/graphics/software_cursor.cpp	2015-07-02 11:48:27 +0000
@@ -21,10 +21,13 @@
 #include "mir/graphics/graphic_buffer_allocator.h"
 #include "mir/graphics/pixel_format_utils.h"
 #include "mir/graphics/renderable.h"
+#include "mir/display_changer.h"
+#include "mir/graphics/display_configuration.h"
 #include "mir/graphics/buffer_properties.h"
 #include "mir/input/scene.h"
 
 #include <mutex>
+#include <sstream>
 
 namespace mg = mir::graphics;
 namespace mi = mir::input;
@@ -32,6 +35,47 @@
 
 namespace
 {
+void update_rectangles(mg::DisplayConfiguration const& conf, geom::Rectangles& rectangles)
+{
+    conf.for_each_output(
+        [&rectangles](mg::DisplayConfigurationOutput const& output)
+        {
+            if (output.power_mode == mir_power_mode_on &&
+                output.current_mode_index < output.modes.size())
+                rectangles.add({output.top_left, output.modes[output.current_mode_index].size});
+        });
+}
+geom::Point transform(float scale,
+                      geom::Displacement const& vector,
+                      geom::Displacement const& hotspot,
+                      geom::Size const& buffer_size,
+                      MirOrientation orientation)
+{
+    auto center = geom::Displacement{buffer_size.width.as_int(), buffer_size.height.as_int()}*0.5f;
+    auto scaled_center = scale*center;
+    auto scaled_hotspot = scale*hotspot;
+
+    switch(orientation)
+    {
+    case mir_orientation_right:
+        scaled_hotspot = geom::Displacement{-scaled_hotspot.dy.as_int(), scaled_hotspot.dx.as_int()};
+        scaled_center = geom::Displacement{-scaled_center.dy.as_int(), scaled_center.dx.as_int()};
+        break;
+    case mir_orientation_left:
+        scaled_hotspot = geom::Displacement{scaled_hotspot.dy.as_int(), -scaled_hotspot.dx.as_int()};
+        scaled_center = geom::Displacement{scaled_center.dy.as_int(), -scaled_center.dx.as_int()};
+        break;
+    case mir_orientation_inverted:
+        scaled_center = -1.0f*scaled_center;
+        scaled_hotspot = -1.0f*scaled_hotspot;
+        break;
+    default:
+        break;
+    }
+
+    auto position = vector + scaled_center - scaled_hotspot - center;
+    return {position.dx.as_int(), position.dy.as_int()};
+}
 
 MirPixelFormat get_8888_format(std::vector<MirPixelFormat> const& formats)
 {
@@ -59,6 +103,14 @@
         : buffer_{buffer},
           position{position}
     {
+        auto const* env = getenv("GRID_UNIT_PX");
+        if (env)
+        {
+            std::stringstream gu_parse(std::string{env});
+            float value;
+            if (gu_parse >> value)
+                scale = value/8.0f; // guess to transform gu into a scale that turns 32x32 icon into a readable size
+        }
     }
 
     mg::Renderable::ID id() const override
@@ -82,9 +134,47 @@
         return 1.0;
     }
 
+
+    float get_scale()
+    {
+        return this->scale;
+    }
+    void set_scale(float scale)
+    {
+        this->scale = scale;
+    }
+
+    void set_orientation(MirOrientation orientation)
+    {
+        this->orientation = orientation;
+    }
+
     glm::mat4 transformation() const override
     {
-        return glm::mat4();
+        switch(orientation)
+        {
+        case  mir_orientation_left:
+            return glm::mat4( 0, -scale, 0, 0,
+                             scale, 0, 0, 0,
+                              0, 0, 1, 0,
+                              0, 0, 0, 1);
+        case  mir_orientation_inverted:
+            return glm::mat4(-scale, 0, 0, 0,
+                             0, -scale, 0, 0,
+                             0, 0, 1, 0,
+                             0, 0, 0, 1);
+        case  mir_orientation_right:
+            return glm::mat4( 0,scale, 0, 0,
+                              -scale, 0, 0, 0,
+                              0, 0, 1, 0,
+                              0, 0, 0, 1);
+        default:
+        case  mir_orientation_normal:
+            return glm::mat4(scale, 0, 0, 0,
+                             0, scale, 0, 0,
+                             0, 0, 1, 0,
+                             0, 0, 0, 1);
+        }
     }
 
     bool shaped() const override
@@ -102,9 +192,13 @@
     std::shared_ptr<mg::Buffer> const buffer_;
     mutable std::mutex position_mutex;
     geom::Point position;
+    float scale{1.0f};
+    MirOrientation orientation{mir_orientation_normal};
 };
 
 mg::SoftwareCursor::SoftwareCursor(
+    mg::DisplayConfiguration const& intial_configuration,
+    std::shared_ptr<mir::DisplayChanger> const& display_changer,
     std::shared_ptr<mg::GraphicBufferAllocator> const& allocator,
     std::shared_ptr<mi::Scene> const& scene)
     : allocator{allocator},
@@ -113,6 +207,13 @@
       visible(false),
       hotspot{0,0}
 {
+    update_rectangles(intial_configuration, bounding_rectangle);
+    display_changer->register_change_callback(
+        [this](mg::DisplayConfiguration const& conf)
+        {
+            std::unique_lock<std::mutex> lock(guard);
+            update_rectangles(conf, bounding_rectangle);
+        });
 }
 
 mg::SoftwareCursor::~SoftwareCursor()
@@ -129,7 +230,28 @@
             visible = needs_scene_change = true;
     }
     if (needs_scene_change && renderable)
+    {
+        update_visualization(renderable);
         scene->add_input_visualization(renderable);
+    }
+}
+
+void mg::SoftwareCursor::update_visualization(std::shared_ptr<detail::CursorRenderable> cursor)
+{
+    if (!cursor)
+        return;
+    uint32_t display_id = 0;
+    MirOrientation overridden = overrides.get_orientation(display_id, mir_orientation_normal);
+    geom::Rectangle area = bounding_rectangle.bounding_rectangle();
+
+    auto displacement = transform(cursor->get_scale(),
+                                  position - area.top_left,
+                                  hotspot,
+                                  cursor->buffer()->size(),
+                                  overridden);
+
+    cursor->move_to(displacement);
+    cursor->set_orientation(overridden);
 }
 
 void mg::SoftwareCursor::show(CursorImage const& cursor_image)
@@ -142,10 +264,10 @@
     {
         geom::Point position{0,0};
         std::lock_guard<std::mutex> lg{guard};
+        visible = true;
         if (renderable)
             position = renderable->screen_position().top_left;
         new_renderable = create_renderable_for(cursor_image, position);
-        visible = true;
     }
 
     // Add the new renderable first, then remove the old one to avoid
@@ -159,6 +281,7 @@
         renderable = new_renderable;
         hotspot = cursor_image.hotspot();
     }
+    update_visualization(new_renderable);
 
     if (old_renderable)
         scene->remove_input_visualization(old_renderable);
@@ -206,11 +329,20 @@
     {
         std::lock_guard<std::mutex> lg{guard};
 
+        this->position = position;
+
         if (!renderable)
             return;
 
-        renderable->move_to(position - hotspot);
+        update_visualization(renderable);
     }
 
     scene->emit_scene_changed();
 }
+
+void mg::SoftwareCursor::override_orientation(uint32_t screen, MirOrientation orientation)
+{
+    // there is no cache invalidation in this hack
+    overrides.add_override(screen, orientation);
+    scene->emit_scene_changed();
+}

=== modified file 'src/server/graphics/software_cursor.h'
--- src/server/graphics/software_cursor.h	2015-04-30 11:36:36 +0000
+++ src/server/graphics/software_cursor.h	2015-07-02 11:48:27 +0000
@@ -22,13 +22,17 @@
 #include "mir/graphics/cursor.h"
 #include "mir_toolkit/client_types.h"
 #include "mir/geometry/displacement.h"
+#include "mir/geometry/overrides.h"
+#include "mir/geometry/rectangles.h"
 #include <mutex>
 
 namespace mir
 {
+class DisplayChanger;
 namespace input { class Scene; }
 namespace graphics
 {
+class DisplayConfiguration;
 class GraphicBufferAllocator;
 class Renderable;
 
@@ -41,6 +45,8 @@
 {
 public:
     SoftwareCursor(
+        mir::graphics::DisplayConfiguration const& inital_configuration,
+        std::shared_ptr<mir::DisplayChanger> const& display_changer,
         std::shared_ptr<GraphicBufferAllocator> const& allocator,
         std::shared_ptr<input::Scene> const& scene);
     ~SoftwareCursor();
@@ -49,10 +55,12 @@
     void show(CursorImage const& cursor_image) override;
     void hide() override;
     void move_to(geometry::Point position) override;
+    void override_orientation(uint32_t screen, MirOrientation) override;
 
 private:
     std::shared_ptr<detail::CursorRenderable> create_renderable_for(
         CursorImage const& cursor_image, geometry::Point position);
+    void update_visualization(std::shared_ptr<detail::CursorRenderable> renderable);
 
     std::shared_ptr<GraphicBufferAllocator> const allocator;
     std::shared_ptr<input::Scene> const scene;
@@ -60,7 +68,10 @@
     std::mutex guard;
     std::shared_ptr<detail::CursorRenderable> renderable;
     bool visible;
+    geometry::Point position;
     geometry::Displacement hotspot;
+    geometry::Overrides overrides;
+    geometry::Rectangles bounding_rectangle;
 };
 
 }

=== modified file 'src/server/input/android/android_input_reader_policy.cpp'
--- src/server/input/android/android_input_reader_policy.cpp	2015-01-21 07:34:50 +0000
+++ src/server/input/android/android_input_reader_policy.cpp	2015-07-02 11:48:27 +0000
@@ -22,6 +22,8 @@
 #include "mir/input/input_region.h"
 #include "mir/geometry/rectangle.h"
 
+#include <sstream>
+
 namespace mi = mir::input;
 namespace mia = mir::input::android;
 
@@ -50,8 +52,20 @@
         height,
         default_display_orientation);
 
-    out_config->pointerVelocityControlParameters.acceleration = 1.0;
-    
+    auto gu_scale = 16.0f;
+    auto gu_env = getenv("GRID_UNIT_PX");
+
+    if (gu_env)
+    {
+        std::istringstream in(gu_env);
+        in >> gu_scale;
+    }
+
+    out_config->pointerVelocityControlParameters.lowThreshold = 150.0f;
+    out_config->pointerVelocityControlParameters.highThreshold = 500.0f;
+    out_config->pointerVelocityControlParameters.acceleration = 3.0f + gu_scale/16.0f;
+    out_config->wheelVelocityControlParameters.acceleration = 4.0f + gu_scale/16.0f;
+
     // This only enables passing through the touch coordinates from the InputReader to the TouchVisualizer
     // the touch visualizer still decides whether or not to render anything.
     out_config->showTouches = true;

=== modified file 'src/server/input/android/android_pointer_controller.cpp'
--- src/server/input/android/android_pointer_controller.cpp	2015-01-21 07:34:50 +0000
+++ src/server/input/android/android_pointer_controller.cpp	2015-07-02 11:48:27 +0000
@@ -77,6 +77,25 @@
 {
     auto new_x = x + delta_x;
     auto new_y = y + delta_y;
+    auto old_orientation = input_region->get_orientation(geom::Point{x, y});
+    switch (old_orientation)
+    {
+    default:
+    case mir_orientation_normal:
+        break;
+    case mir_orientation_inverted:
+         new_x = x - delta_x;
+         new_y = y - delta_y;
+         break;
+    case mir_orientation_left:
+         new_x = x + delta_y;
+         new_y = y - delta_x;
+         break;
+    case mir_orientation_right:
+         new_x = x - delta_y;
+         new_y = y + delta_x;
+         break;
+    }
     setPosition(new_x, new_y);
 }
 void mia::PointerController::setButtonState(int32_t button_state)
@@ -103,6 +122,7 @@
     // to prevent the InputReader from getting ahead of rendering. This may need to be thought about later.
     notify_listener();
 }
+
 void mia::PointerController::getPosition(float *out_x, float *out_y) const
 {
     std::lock_guard<std::mutex> lg(guard);

=== modified file 'src/server/input/android/android_pointer_controller.h'
--- src/server/input/android/android_pointer_controller.h	2015-01-21 07:34:50 +0000
+++ src/server/input/android/android_pointer_controller.h	2015-07-02 11:48:27 +0000
@@ -54,6 +54,7 @@
 
   private:
     bool get_bounds_locked(float *out_min_x, float* out_min_y, float* out_max_x, float* out_max_y) const;
+    void update_positions(float& new_x, float& new_y);
     void notify_listener();
     // Could be a read/write mutex as this is a latency sensitive class.
     mutable std::mutex guard;

=== modified file 'src/server/input/default_configuration.cpp'
--- src/server/input/default_configuration.cpp	2015-04-28 12:28:05 +0000
+++ src/server/input/default_configuration.cpp	2015-07-02 11:48:27 +0000
@@ -48,6 +48,8 @@
 #include "mir/input/platform.h"
 #include "mir/options/configuration.h"
 #include "mir/options/option.h"
+#include "mir/graphics/display.h"
+#include "mir/graphics/display_configuration.h"
 #include "mir/dispatch/multiplexing_dispatchable.h"
 #include "mir/compositor/scene.h"
 #include "mir/emergency_cleanup.h"
@@ -75,7 +77,7 @@
     return input_region(
         [this]()
         {
-            return std::make_shared<mi::DisplayInputRegion>(the_display());
+            return std::make_shared<mi::DisplayInputRegion>(*the_display()->configuration(), the_display_changer());
         });
 }
 

=== modified file 'src/server/input/display_input_region.cpp'
--- src/server/input/display_input_region.cpp	2015-03-31 02:35:42 +0000
+++ src/server/input/display_input_region.cpp	2015-07-02 11:48:27 +0000
@@ -17,50 +17,68 @@
  */
 
 #include "display_input_region.h"
-#include "mir/graphics/display.h"
-#include "mir/graphics/display_buffer.h"
+#include "mir/graphics/display_configuration.h"
+#include "mir/display_changer.h"
 
 #include "mir/geometry/rectangle.h"
 #include "mir/geometry/rectangles.h"
 
+#include <iostream>
+
 namespace mi = mir::input;
 namespace mg = mir::graphics;
 namespace geom = mir::geometry;
 
+namespace
+{
+void update_rectangles(mg::DisplayConfiguration const& conf, geom::Rectangles& rectangles)
+{
+    conf.for_each_output(
+        [&rectangles](mg::DisplayConfigurationOutput const& output)
+        {
+            if (output.power_mode == mir_power_mode_on &&
+                output.current_mode_index < output.modes.size())
+                rectangles.add({output.top_left, output.modes[output.current_mode_index].size});
+        });
+}
+}
+
 mi::DisplayInputRegion::DisplayInputRegion(
-    std::shared_ptr<mg::Display> const& display)
-    : display{display}
-{
+    mg::DisplayConfiguration const& initial_conf,
+    std::shared_ptr<mir::DisplayChanger> const& display_changer)
+{
+    update_rectangles(initial_conf, rectangles);
+    display_changer->register_change_callback(
+        [this](mg::DisplayConfiguration const& conf)
+        {
+            std::unique_lock<std::mutex> lock(rectangles_lock);
+            update_rectangles(conf, rectangles);
+        });
+}
+
+void mi::DisplayInputRegion::override_orientation(uint32_t display_id, MirOrientation orientation)
+{
+    std::unique_lock<std::mutex> lock(rectangles_lock);
+    overrides.add_override(display_id, orientation);
+}
+
+MirOrientation mi::DisplayInputRegion::get_orientation(geometry::Point const& /*point*/)
+{
+    std::unique_lock<std::mutex> lock(rectangles_lock);
+    uint32_t display_id = 0;
+    MirOrientation orientation = mir_orientation_normal;
+
+    return overrides.get_orientation(display_id, orientation);
 }
 
 geom::Rectangle mi::DisplayInputRegion::bounding_rectangle()
 {
-    geom::Rectangles rectangles;
-
-    display->for_each_display_sync_group([&rectangles](mg::DisplaySyncGroup& group)
-    {
-        group.for_each_display_buffer(
-            [&rectangles](mg::DisplayBuffer const& buffer)
-            {
-                rectangles.add(buffer.view_area());
-            });
-    });
-
+    std::unique_lock<std::mutex> lock(rectangles_lock);
     return rectangles.bounding_rectangle();
 }
 
 void mi::DisplayInputRegion::confine(geom::Point& point)
 {
-    geom::Rectangles rectangles;
-
-    display->for_each_display_sync_group([&rectangles](mg::DisplaySyncGroup& group)
-    {
-        group.for_each_display_buffer(
-            [&rectangles](mg::DisplayBuffer const& buffer)
-            {
-                rectangles.add(buffer.view_area());
-            });
-    });
-
+    std::unique_lock<std::mutex> lock(rectangles_lock);
     rectangles.confine(point);
 }

=== modified file 'src/server/input/display_input_region.h'
--- src/server/input/display_input_region.h	2014-03-06 06:05:17 +0000
+++ src/server/input/display_input_region.h	2015-07-02 11:48:27 +0000
@@ -20,14 +20,18 @@
 #define MIR_INPUT_DISPLAY_INPUT_REGION_H_
 
 #include "mir/input/input_region.h"
+#include "mir/geometry/overrides.h"
+#include "mir/geometry/rectangles.h"
 
 #include <memory>
+#include <mutex>
 
 namespace mir
 {
+class DisplayChanger;
 namespace graphics
 {
-class Display;
+class DisplayConfiguration;
 }
 namespace input
 {
@@ -35,13 +39,19 @@
 class DisplayInputRegion : public InputRegion
 {
 public:
-    DisplayInputRegion(std::shared_ptr<graphics::Display> const& display);
+    DisplayInputRegion(mir::graphics::DisplayConfiguration const& initial_conf,
+        std::shared_ptr<mir::DisplayChanger> const& display_changer);
 
+    void override_orientation(uint32_t display_id, MirOrientation orientation) override;
+    MirOrientation get_orientation(geometry::Point const& point) override;
     geometry::Rectangle bounding_rectangle();
     void confine(geometry::Point& point);
 
 private:
-    std::shared_ptr<graphics::Display> const display;
+    std::mutex rectangles_lock;
+    mir::geometry::Overrides overrides;
+    mir::geometry::Rectangles rectangles;
+
 };
 
 }

=== modified file 'src/server/scene/mediating_display_changer.cpp'
--- src/server/scene/mediating_display_changer.cpp	2015-01-21 07:34:50 +0000
+++ src/server/scene/mediating_display_changer.cpp	2015-07-02 11:48:27 +0000
@@ -160,9 +160,16 @@
 
             /* Send the new configuration to all the sessions */
             send_config_to_all_sessions(conf);
+
+            send_config_to_all_callbacks(conf);
         });
 }
 
+void ms::MediatingDisplayChanger::register_change_callback(std::function<void(mg::DisplayConfiguration const&)> const& callback)
+{
+    callbacks.push_back(callback);
+}
+
 void ms::MediatingDisplayChanger::pause_display_config_processing()
 {
     server_action_queue->pause_processing_for(this);
@@ -210,6 +217,16 @@
         });
 }
 
+
+void ms::MediatingDisplayChanger::send_config_to_all_callbacks(
+    std::shared_ptr<mg::DisplayConfiguration> const& conf)
+{
+    for (auto const& callback : callbacks)
+    {
+        callback(*conf);
+    }
+}
+
 void ms::MediatingDisplayChanger::focus_change_handler(
     std::shared_ptr<ms::Session> const& session)
 {

=== modified file 'src/server/scene/mediating_display_changer.h'
--- src/server/scene/mediating_display_changer.h	2015-01-21 07:34:50 +0000
+++ src/server/scene/mediating_display_changer.h	2015-07-02 11:48:27 +0000
@@ -24,6 +24,7 @@
 
 #include <mutex>
 #include <map>
+#include <vector>
 
 namespace mir
 {
@@ -65,6 +66,7 @@
 
     void pause_display_config_processing() override;
     void resume_display_config_processing() override;
+    void register_change_callback(std::function<void(graphics::DisplayConfiguration const&)> const& change_callback) override;
 
 private:
     void focus_change_handler(std::shared_ptr<Session> const& session);
@@ -76,6 +78,8 @@
     void apply_base_config(SystemStateHandling pause_resume_system);
     void send_config_to_all_sessions(
         std::shared_ptr<graphics::DisplayConfiguration> const& conf);
+    void send_config_to_all_callbacks(
+        std::shared_ptr<graphics::DisplayConfiguration> const& conf);
 
     std::shared_ptr<graphics::Display> const display;
     std::shared_ptr<compositor::Compositor> const compositor;
@@ -90,6 +94,7 @@
     std::weak_ptr<frontend::Session> focused_session;
     std::shared_ptr<graphics::DisplayConfiguration> base_configuration;
     bool base_configuration_applied;
+    std::vector<std::function<void(graphics::DisplayConfiguration const&)>> callbacks;
 };
 
 }

=== modified file 'src/server/server.cpp'
--- src/server/server.cpp	2015-04-09 06:20:31 +0000
+++ src/server/server.cpp	2015-07-02 11:48:27 +0000
@@ -67,6 +67,7 @@
     MACRO(the_cursor_listener)\
     MACRO(the_cursor)\
     MACRO(the_display)\
+    MACRO(the_input_region)\
     MACRO(the_focus_controller)\
     MACRO(the_gl_config)\
     MACRO(the_graphics_platform)\

=== modified file 'src/server/symbols.map'
--- src/server/symbols.map	2015-05-01 13:49:42 +0000
+++ src/server/symbols.map	2015-07-02 11:48:27 +0000
@@ -182,6 +182,7 @@
     mir::Server::the_graphics_platform*;
     mir::Server::the_input_device_hub*;
     mir::Server::the_input_targeter*;
+    mir::Server::the_input_region*;
     mir::Server::the_logger*;
     mir::Server::the_main_loop*;
     mir::Server::the_prompt_session_listener*;
@@ -424,6 +425,7 @@
     vtable?for?mir::input::InputDeviceObserver;
     vtable?for?mir::input::InputDispatcher;
     vtable?for?mir::input::InputManager;
+    vtable?for?mir::input::InputRegion;
     vtable?for?mir::input::Surface;
     vtable?for?mir::input::TouchVisualizer;
     vtable?for?mir::input::TouchVisualizer::Spot;

=== modified file 'tests/acceptance-tests/throwback/test_client_cursor_api.cpp'
--- tests/acceptance-tests/throwback/test_client_cursor_api.cpp	2015-04-23 20:17:52 +0000
+++ tests/acceptance-tests/throwback/test_client_cursor_api.cpp	2015-07-02 11:48:27 +0000
@@ -55,6 +55,7 @@
 {
     MOCK_METHOD0(show, void());
     MOCK_METHOD1(show, void(mg::CursorImage const&));
+    MOCK_METHOD2(override_orientation, void(uint32_t, MirOrientation));
     MOCK_METHOD0(hide, void());
 
     // We are not interested in mocking the motion in these tests as we

=== modified file 'tests/include/mir_test_doubles/mock_input_region.h'
--- tests/include/mir_test_doubles/mock_input_region.h	2013-07-19 14:12:57 +0000
+++ tests/include/mir_test_doubles/mock_input_region.h	2015-07-02 11:48:27 +0000
@@ -35,6 +35,8 @@
 class MockInputRegion : public input::InputRegion
 {
 public:
+    MOCK_METHOD2(override_orientation, void(uint32_t, MirOrientation));
+    MOCK_METHOD1(get_orientation, MirOrientation(mir::geometry::Point const&));
     MOCK_METHOD0(bounding_rectangle, geometry::Rectangle());
     MOCK_METHOD1(confine, void(geometry::Point&));
 };

=== modified file 'tests/include/mir_test_doubles/stub_cursor.h'
--- tests/include/mir_test_doubles/stub_cursor.h	2015-04-01 22:06:05 +0000
+++ tests/include/mir_test_doubles/stub_cursor.h	2015-07-02 11:48:27 +0000
@@ -34,6 +34,7 @@
     void show(graphics::CursorImage const&) override {}
     void hide() override {}
     void move_to(geometry::Point) override {}
+    void override_orientation(uint32_t, MirOrientation) override {}
 };
 
 }

=== added file 'tests/include/mir_test_doubles/stub_display_changer.h'
--- tests/include/mir_test_doubles/stub_display_changer.h	1970-01-01 00:00:00 +0000
+++ tests/include/mir_test_doubles/stub_display_changer.h	2015-07-02 11:48:27 +0000
@@ -0,0 +1,52 @@
+/*
+ * 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]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_DISPLAY_CHANGER_H_
+#define MIR_TEST_DOUBLES_STUB_DISPLAY_CHANGER_H_
+
+#include "mir/display_changer.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubDisplayChanger : public mir::DisplayChanger
+{
+    void configure_for_hardware_change(
+        std::shared_ptr<graphics::DisplayConfiguration> const& ,
+        SystemStateHandling) override
+    {}
+
+    void pause_display_config_processing() override
+    {}
+
+    void resume_display_config_processing() override
+    {}
+    void register_change_callback(std::function<void(graphics::DisplayConfiguration const&)> const&) override
+    {}
+
+};
+
+}
+}
+}
+
+#endif

=== modified file 'tests/mir_test_doubles/fake_event_hub.cpp'
--- tests/mir_test_doubles/fake_event_hub.cpp	2015-04-16 08:42:38 +0000
+++ tests/mir_test_doubles/fake_event_hub.cpp	2015-07-02 11:48:27 +0000
@@ -558,7 +558,9 @@
 void FakeEventHub::synthesize_event(const mis::MotionParameters &parameters)
 {
     RawEvent event;
-    event.when = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch());
+    static auto time = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch());
+    time += std::chrono::seconds(1);
+    event.when = time;
     event.type = EV_REL;
     if (parameters.device_id)
         event.deviceId = parameters.device_id;

=== modified file 'tests/mir_test_framework/stubbed_server_configuration.cpp'
--- tests/mir_test_framework/stubbed_server_configuration.cpp	2015-04-23 20:17:52 +0000
+++ tests/mir_test_framework/stubbed_server_configuration.cpp	2015-07-02 11:48:27 +0000
@@ -47,6 +47,7 @@
 
 namespace
 {
+
 class StubRendererFactory : public mc::RendererFactory
 {
 public:

=== modified file 'tests/unit-tests/graphics/test_software_cursor.cpp'
--- tests/unit-tests/graphics/test_software_cursor.cpp	2015-04-30 11:36:36 +0000
+++ tests/unit-tests/graphics/test_software_cursor.cpp	2015-07-02 11:48:27 +0000
@@ -22,6 +22,8 @@
 
 #include "mir_test_doubles/stub_buffer_allocator.h"
 #include "mir_test_doubles/stub_input_scene.h"
+#include "mir_test_doubles/stub_display.h"
+#include "mir_test_doubles/stub_display_changer.h"
 
 #include "mir_test/fake_shared.h"
 
@@ -80,12 +82,21 @@
 
 struct SoftwareCursor : testing::Test
 {
+    std::vector<mir::geometry::Rectangle> regs{
+        mir::geometry::Rectangle{
+            mir::geometry::Point{0,0},
+            mir::geometry::Size{1024,768}
+        }};
+    mtd::StubDisplay stub_display{regs};
+    mtd::StubDisplayChanger stub_display_changer;
     StubCursorImage stub_cursor_image{{3,4}};
     StubCursorImage another_stub_cursor_image{{10,9}};
     mtd::StubBufferAllocator stub_buffer_allocator;
     testing::NiceMock<MockInputScene> mock_input_scene;
 
     mg::SoftwareCursor cursor{
+        *stub_display.configuration(),
+        mt::fake_shared(stub_display_changer),
         mt::fake_shared(stub_buffer_allocator),
         mt::fake_shared(mock_input_scene)};
 };
@@ -307,6 +318,8 @@
         .Times(3)
         .WillRepeatedly(testing::Return(std::make_shared<mtd::StubBuffer>()));;
     mg::SoftwareCursor cursor{
+        *stub_display.configuration(),
+        mt::fake_shared(stub_display_changer),
         mt::fake_shared(mock_allocator),
         mt::fake_shared(mock_input_scene)};
     cursor.show(another_stub_cursor_image);

=== modified file 'tests/unit-tests/input/android/test_android_pointer_controller.cpp'
--- tests/unit-tests/input/android/test_android_pointer_controller.cpp	2015-01-21 07:34:50 +0000
+++ tests/unit-tests/input/android/test_android_pointer_controller.cpp	2015-07-02 11:48:27 +0000
@@ -48,9 +48,11 @@
     {
         controller = std::make_shared<mia::PointerController>(mt::fake_shared(input_region), std::shared_ptr<mi::CursorListener>(),
                                                               std::make_shared<mtd::StubTouchVisualizer>());
+        using namespace ::testing;
+        ON_CALL(input_region,get_orientation(_)).WillByDefault(Return(mir_orientation_normal));
     }
 protected:
-    mtd::MockInputRegion input_region;
+    ::testing::NiceMock<mtd::MockInputRegion> input_region;
     std::shared_ptr<mia::PointerController> controller;
 };
 

=== modified file 'tests/unit-tests/input/test_cursor_controller.cpp'
--- tests/unit-tests/input/test_cursor_controller.cpp	2015-03-31 02:35:42 +0000
+++ tests/unit-tests/input/test_cursor_controller.cpp	2015-07-02 11:48:27 +0000
@@ -86,6 +86,7 @@
 
 struct MockCursor : public mg::Cursor
 {
+    MOCK_METHOD2(override_orientation, void(uint32_t, MirOrientation));
     MOCK_METHOD0(show, void());
     MOCK_METHOD1(show, void(mg::CursorImage const&));
     MOCK_METHOD0(hide, void());

=== modified file 'tests/unit-tests/input/test_display_input_region.cpp'
--- tests/unit-tests/input/test_display_input_region.cpp	2015-03-31 02:35:42 +0000
+++ tests/unit-tests/input/test_display_input_region.cpp	2015-07-02 11:48:27 +0000
@@ -20,6 +20,7 @@
 
 #include "mir_test_doubles/null_display.h"
 #include "mir_test_doubles/stub_display.h"
+#include "mir_test_doubles/stub_display_changer.h"
 
 #include <vector>
 #include <tuple>
@@ -44,8 +45,9 @@
 {
     geom::Rectangle const expected_bounding_rect{geom::Point{0,0}, geom::Size{900,700}};
     auto stub_display = std::make_shared<mtd::StubDisplay>(rects);
+    auto stub_display_changer = std::make_shared<mtd::StubDisplayChanger>();
 
-    mi::DisplayInputRegion input_region{stub_display};
+    mi::DisplayInputRegion input_region{*stub_display->configuration(), stub_display_changer};
 
     auto rect = input_region.bounding_rectangle();
     EXPECT_EQ(expected_bounding_rect, rect);
@@ -54,8 +56,9 @@
 TEST(DisplayInputRegionTest, confines_point_to_closest_valid_position)
 {
     auto stub_display = std::make_shared<mtd::StubDisplay>(rects);
+    auto stub_display_changer = std::make_shared<mtd::StubDisplayChanger>();
 
-    mi::DisplayInputRegion input_region{stub_display};
+    mi::DisplayInputRegion input_region{*stub_display->configuration(), stub_display_changer};
 
     std::vector<std::tuple<geom::Point,geom::Point>> point_tuples{
         std::make_tuple(geom::Point{0,0}, geom::Point{0,0}),