Merge lp:~mir-team/mir/x11-multi-window into lp:mir

[Nick Dedekind]

Added support for multiple x11 windows

Unmerged revisions

4037. By Nick Dedekind on 2017-02-16

Multiple window support

=== modified file 'src/platforms/mesa/server/x11/graphics/display.cpp'
--- src/platforms/mesa/server/x11/graphics/display.cpp	2017-02-15 07:38:33 +0000
+++ src/platforms/mesa/server/x11/graphics/display.cpp	2017-02-16 10:45:38 +0000
@@ -18,12 +18,12 @@
 
 #include "mir/graphics/platform.h"
 #include "mir/graphics/display_report.h"
+#include "mir/graphics/display_configuration_policy.h"
 #include "mir/graphics/egl_error.h"
 #include "mir/graphics/virtual_output.h"
 #include "mir/renderer/gl/context.h"
 #include "mir/graphics/gl_config.h"
 #include "mir/graphics/atomic_frame.h"
-#include "display_configuration.h"
 #include "display.h"
 #include "display_buffer.h"
 
@@ -107,7 +107,7 @@
 
 mgx::X11Window::X11Window(::Display* x_dpy,
                           EGLDisplay egl_dpy,
-                          geom::Size const size,
+                          geom::Rectangle const& geometry,
                           EGLConfig const egl_cfg)
     : x_dpy{x_dpy}
 {
@@ -157,7 +157,7 @@
     auto mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
 
     win = XCreateWindow(x_dpy, root, 0, 0,
-                        size.width.as_int(), size.height.as_int(),
+                        geometry.size.width.as_int(), geometry.size.height.as_int(),
                         0, visInfo->depth, InputOutput,
                         visInfo->visual, mask, &attr);
 
@@ -170,12 +170,12 @@
         // TODO: Due to a bug, resize doesn't work after XGrabKeyboard under Unity.
         //       For now, make window unresizeable.
         //     http://stackoverflow.com/questions/14555703/x11-unable-to-move-window-after-xgrabkeyboard
-        sizehints.base_width = size.width.as_int();
-        sizehints.base_height = size.height.as_int();
-        sizehints.min_width = size.width.as_int();
-        sizehints.min_height = size.height.as_int();
-        sizehints.max_width = size.width.as_int();
-        sizehints.max_height = size.height.as_int();
+        sizehints.base_width = geometry.size.width.as_int();
+        sizehints.base_height = geometry.size.height.as_int();
+        sizehints.min_width = geometry.size.width.as_int();
+        sizehints.min_height = geometry.size.height.as_int();
+        sizehints.max_width = geometry.size.width.as_int();
+        sizehints.max_height = geometry.size.height.as_int();
         sizehints.flags = PSize | PMinSize | PMaxSize;
 
         XSetNormalHints(x_dpy, win, &sizehints);
@@ -198,12 +198,16 @@
 
         Atom wmDeleteMessage = XInternAtom(x_dpy, "WM_DELETE_WINDOW", False);
         XSetWMProtocols(x_dpy, win, &wmDeleteMessage, 1);
+
+        wmLogicalPosition = XInternAtom(x_dpy, "WM_LOGICAL_POSITION", False);
+        XPoint pt{(short)geometry.top_left.x.as_int(), (short)geometry.top_left.y.as_int()};
+        XChangeProperty(x_dpy, win, wmLogicalPosition, XA_POINT, 16, PropModeReplace, (unsigned char *) &pt, 2);
     }
 
     XMapWindow(x_dpy, win);
 
     XEvent xev;
-    do 
+    do
     {
         XNextEvent(x_dpy, &xev);
     }
@@ -225,8 +229,16 @@
     return r_mask;
 }
 
+void mgx::X11Window::set_geometry(mir::geometry::Rectangle const& geometry)
+{
+    XPoint pt{(short)geometry.top_left.x.as_int(), (short)geometry.top_left.y.as_int()};
+    XChangeProperty(x_dpy, win, wmLogicalPosition, XA_POINT, 16, PropModeReplace, (unsigned char *) &pt, 2);
+}
+
 mgx::Display::Display(::Display* x_dpy,
+                      uint requested_output_count,
                       geom::Size const requested_size,
+                      std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
                       std::shared_ptr<GLConfig> const& gl_config,
                       std::shared_ptr<DisplayReport> const& report)
     : shared_egl{*gl_config},
@@ -235,50 +247,63 @@
       gl_config{gl_config},
       pixel_width{get_pixel_width(x_dpy)},
       pixel_height{get_pixel_height(x_dpy)},
-      scale{1.0f},
       report{report},
-      orientation{mir_orientation_normal},
       last_frame{std::make_shared<AtomicFrame>()}
 {
     shared_egl.setup(x_dpy);
 
-    win = std::make_unique<X11Window>(x_dpy,
-                                      shared_egl.display(),
-                                      actual_size,
-                                      shared_egl.config());
-
-    auto red_mask = win->red_mask();
-    pf = (red_mask == 0xFF0000 ? mir_pixel_format_argb_8888
-                               : mir_pixel_format_abgr_8888);
-
-    display_buffer = std::make_unique<mgx::DisplayBuffer>(
-                         x_dpy,
-                         *win,
-                         actual_size,
-                         shared_egl.context(),
-                         last_frame,
-                         report,
-                         orientation,
-                         *gl_config);
-
+    for (uint i = 0; i < requested_output_count; i++) {
+        auto win = std::make_unique<X11Window>(x_dpy,
+                                 shared_egl.display(),
+                                 geom::Rectangle{{0,0}, actual_size},
+                                 shared_egl.config());
+
+        auto red_mask = win->red_mask();
+        pf = (red_mask == 0xFF0000 ? mir_pixel_format_argb_8888
+                                   : mir_pixel_format_abgr_8888);
+
+        auto output_id = display_configuration.add_output(pf,
+                                 actual_size,
+                                 geom::Size{actual_size.width * pixel_width, actual_size.height * pixel_height},
+                                 1.0f,
+                                 mir_orientation_normal);
+
+        auto display_buffer = std::make_unique<mgx::DisplayBuffer>(x_dpy,
+                                                     *win,
+                                                     geom::Rectangle{{0,0}, actual_size},
+                                                     shared_egl.context(),
+                                                     last_frame,
+                                                     report,
+                                                     mir_orientation_normal,
+                                                     output_id,
+                                                     *gl_config);
+
+        outputs.insert({ output_id, new OutputWindow{std::move(win), std::move(display_buffer)} });
+    }
     shared_egl.make_current();
 
+    initial_conf_policy->apply_to(display_configuration);
+    configure(display_configuration);
+
     report->report_successful_display_construction();
 }
 
 mgx::Display::~Display() noexcept
 {
+    for (auto output: outputs) {
+        delete output.second;
+    }
 }
 
 void mgx::Display::for_each_display_sync_group(std::function<void(mg::DisplaySyncGroup&)> const& f)
 {
-    f(*display_buffer);
+    for (const auto& output : outputs)
+        f(*(output.second->display_buffer));
 }
 
 std::unique_ptr<mg::DisplayConfiguration> mgx::Display::configuration() const
 {
-    return std::make_unique<mgx::DisplayConfiguration>(
-        pf, actual_size, geom::Size{actual_size.width * pixel_width, actual_size.height * pixel_height}, scale, orientation);
+    return display_configuration.clone();
 }
 
 void mgx::Display::configure(mg::DisplayConfiguration const& new_configuration)
@@ -289,18 +314,30 @@
             std::logic_error("Invalid or inconsistent display configuration"));
     }
 
-    MirOrientation o = mir_orientation_normal;
-    float new_scale = scale;
-
-    new_configuration.for_each_output([&](DisplayConfigurationOutput const& conf_output)
+    new_configuration.for_each_output([&](DisplayConfigurationOutput const& new_conf_output)
     {
-        o = conf_output.orientation;
-        new_scale = conf_output.scale;
+        display_configuration.for_each_output([&](UserDisplayConfigurationOutput& current_conf_output)
+        {
+            if (current_conf_output.id == new_conf_output.id) {
+
+                current_conf_output.scale = new_conf_output.scale;
+                current_conf_output.orientation = new_conf_output.orientation;
+                current_conf_output.top_left = new_conf_output.top_left;
+                current_conf_output.used = new_conf_output.used;
+                current_conf_output.power_mode = new_conf_output.power_mode;
+                current_conf_output.form_factor = new_conf_output.form_factor;
+                // TODO - current_mode_index for sizing.
+
+                auto search = outputs.find(new_conf_output.id);
+                if(search != outputs.end()) {
+                    auto output = search->second;
+                    output->display_buffer->set_orientation(new_conf_output.orientation);
+                    output->display_buffer->set_geometry(new_conf_output.extents());
+                    output->win->set_geometry(new_conf_output.extents());
+                }
+            }
+        });
     });
-
-    orientation = o;
-    display_buffer->set_orientation(orientation);
-    scale = new_scale;
 }
 
 void mgx::Display::register_configuration_change_handler(
 
=== modified file 'src/platforms/mesa/server/x11/graphics/display.h'
--- src/platforms/mesa/server/x11/graphics/display.h	2017-02-15 07:38:33 +0000
+++ src/platforms/mesa/server/x11/graphics/display.h	2017-02-16 10:45:38 +0000
@@ -24,12 +24,14 @@
 #include "mir/renderer/gl/context_source.h"
 #include "mir_toolkit/common.h"
 #include "egl_helper.h"
+#include "display_configuration.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <EGL/egl.h>
 
 #include <memory>
+#include <unordered_map>
 
 namespace mir
 {
@@ -39,6 +41,7 @@
 class AtomicFrame;
 class GLConfig;
 class DisplayReport;
+class DisplayConfigurationPolicy;
 
 namespace X
 {
@@ -50,15 +53,18 @@
 public:
     X11Window(::Display* const x_dpy,
               EGLDisplay egl_dpy,
-              geometry::Size const size,
+              mir::geometry::Rectangle const& geometry,
               EGLConfig const egl_cfg);
     ~X11Window();
 
     operator Window() const;
     unsigned long red_mask() const;
 
+    void set_geometry(mir::geometry::Rectangle const& geometry);
+
 private:
     ::Display* const x_dpy;
+    ::Atom wmLogicalPosition;
     Window win;
     unsigned long r_mask;
 };
@@ -69,7 +75,9 @@
 {
 public:
     explicit Display(::Display* x_dpy,
+                     uint requested_output_count,
                      geometry::Size const requested_size,
+                     std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
                      std::shared_ptr<GLConfig> const& gl_config,
                      std::shared_ptr<DisplayReport> const& report);
     ~Display() noexcept;
@@ -110,13 +118,15 @@
     std::shared_ptr<GLConfig> const gl_config;
     float pixel_width;
     float pixel_height;
-    float scale;
-    std::unique_ptr<X11Window> win;
     MirPixelFormat pf;
     std::shared_ptr<DisplayReport> const report;
-    MirOrientation orientation; //TODO: keep entire current display configuration
     std::shared_ptr<AtomicFrame> last_frame;
-    std::unique_ptr<DisplayBuffer> display_buffer;
+    struct OutputWindow {
+        std::unique_ptr<X11Window> win;
+        std::unique_ptr<DisplayBuffer> display_buffer;
+    };
+    std::unordered_map<DisplayConfigurationOutputId, OutputWindow*> outputs;
+    DisplayConfiguration display_configuration;
 };
 
 }
 
=== modified file 'src/platforms/mesa/server/x11/graphics/display_buffer.cpp'
--- src/platforms/mesa/server/x11/graphics/display_buffer.cpp	2017-01-30 06:36:29 +0000
+++ src/platforms/mesa/server/x11/graphics/display_buffer.cpp	2017-02-16 10:45:38 +0000
@@ -31,16 +31,18 @@
 
 mgx::DisplayBuffer::DisplayBuffer(::Display* const x_dpy,
                                   Window const win,
-                                  geom::Size const sz,
+                                  geometry::Rectangle const geo,
                                   EGLContext const shared_context,
                                   std::shared_ptr<AtomicFrame> const& f,
                                   std::shared_ptr<DisplayReport> const& r,
                                   MirOrientation const o,
+                                  DisplayConfigurationOutputId const output_id,
                                   GLConfig const& gl_config)
-                                  : size{sz},
+                                  : geometry{geo},
                                     report{r},
                                     orientation_{o},
                                     transform{mg::transformation(o)},
+                                    output_id_(output_id),
                                     egl{gl_config},
                                     last_frame{f},
                                     eglGetSyncValues{nullptr}
@@ -89,9 +91,9 @@
     {
     case mir_orientation_left:
     case mir_orientation_right:
-        return {{0,0}, {size.height.as_int(), size.width.as_int()}};
+        return {geometry.top_left, {geometry.size.height.as_int(), geometry.size.width.as_int()}};
     default:
-        return {{0,0}, size};
+        return geometry;
     }
 }
 
@@ -146,7 +148,7 @@
      * but this is best-effort. And besides, we don't want Mir reporting all
      * real vsyncs because that would mean the compositor never sleeps.
      */
-    report->report_vsync(mgx::DisplayConfiguration::the_output_id.as_value(),
+    report->report_vsync(output_id_.as_value(),
                          last_frame->load());
 }
 
@@ -165,6 +167,12 @@
     transform = mg::transformation(orientation_);
 }
 
+void mgx::DisplayBuffer::set_geometry(geom::Rectangle const geo)
+{
+    // TODO - resize the window.
+    geometry.top_left = geo.top_left;
+}
+
 mg::NativeDisplayBuffer* mgx::DisplayBuffer::native_display_buffer()
 {
     return this;
 
=== modified file 'src/platforms/mesa/server/x11/graphics/display_buffer.h'
--- src/platforms/mesa/server/x11/graphics/display_buffer.h	2017-01-30 06:36:29 +0000
+++ src/platforms/mesa/server/x11/graphics/display_buffer.h	2017-02-16 10:45:38 +0000
@@ -22,6 +22,7 @@
 
 #include "mir/graphics/display_buffer.h"
 #include "mir/graphics/display.h"
+#include "mir/graphics/display_configuration.h"
 #include "mir/renderer/gl/render_target.h"
 #include "egl_helper.h"
 
@@ -49,11 +50,12 @@
     DisplayBuffer(
             ::Display* const x_dpy,
             Window const win,
-            geometry::Size const sz,
+            geometry::Rectangle const geometry,
             EGLContext const shared_context,
             std::shared_ptr<AtomicFrame> const& f,
             std::shared_ptr<DisplayReport> const& r,
             MirOrientation const o,
+            DisplayConfigurationOutputId const output_id,
             GLConfig const& gl_config);
 
     geometry::Rectangle view_area() const override;
@@ -63,6 +65,7 @@
     void bind() override;
     bool overlay(RenderableList const& renderlist) override;
     void set_orientation(MirOrientation const new_orientation);
+    void set_geometry(geometry::Rectangle const geometry);
 
     void for_each_display_buffer(
         std::function<void(graphics::DisplayBuffer&)> const& f) override;
@@ -73,10 +76,11 @@
     NativeDisplayBuffer* native_display_buffer() override;
 
 private:
-    geometry::Size const size;
+    geometry::Rectangle geometry;
     std::shared_ptr<DisplayReport> const report;
     MirOrientation orientation_;
     glm::mat2 transform;
+    DisplayConfigurationOutputId const output_id_;
     helpers::EGLHelper egl;
     std::shared_ptr<AtomicFrame> const last_frame;
 
 
=== modified file 'src/platforms/mesa/server/x11/graphics/display_configuration.cpp'
--- src/platforms/mesa/server/x11/graphics/display_configuration.cpp	2017-01-18 02:29:37 +0000
+++ src/platforms/mesa/server/x11/graphics/display_configuration.cpp	2017-02-16 10:45:38 +0000
@@ -24,11 +24,23 @@
 namespace mgx = mg::X;
 namespace geom = mir::geometry;
 
-mg::DisplayConfigurationOutputId const mgx::DisplayConfiguration::the_output_id{1};
-
-mgx::DisplayConfiguration::DisplayConfiguration(MirPixelFormat pf, geom::Size const pixels, geom::Size const size, const float scale, MirOrientation orientation) :
-    configuration{
-            the_output_id,
+mgx::DisplayConfiguration::DisplayConfiguration() :
+    card{mg::DisplayConfigurationCardId{0}, 1}
+{
+}
+
+mgx::DisplayConfiguration::DisplayConfiguration(DisplayConfiguration const& other)
+    : mg::DisplayConfiguration(),
+      outputs(other.outputs),
+      card(other.card)
+{
+}
+
+mg::DisplayConfigurationOutputId mgx::DisplayConfiguration::add_output(MirPixelFormat pf, geom::Size const pixels, geom::Size const size, const float scale, MirOrientation orientation)
+{
+    static int output_id = 1;
+    DisplayConfigurationOutput output{
+            mg::DisplayConfigurationOutputId(output_id++),
             mg::DisplayConfigurationCardId{0},
             mg::DisplayConfigurationOutputType::unknown,
             {pf},
@@ -48,16 +60,10 @@
             mir_subpixel_arrangement_unknown,
             {},
             mir_output_gamma_unsupported,
-            {}},
-    card{mg::DisplayConfigurationCardId{0}, 1}
-{
-}
+            {}};
+    outputs.push_back(output);
 
-mgx::DisplayConfiguration::DisplayConfiguration(DisplayConfiguration const& other)
-    : mg::DisplayConfiguration(),
-      configuration(other.configuration),
-      card(other.card)
-{
+    return output.id;
 }
 
 void mgx::DisplayConfiguration::for_each_card(std::function<void(mg::DisplayConfigurationCard const&)> f) const
@@ -67,13 +73,16 @@
 
 void mgx::DisplayConfiguration::for_each_output(std::function<void(mg::DisplayConfigurationOutput const&)> f) const
 {
-    f(configuration);
+    for (auto& output : outputs)
+        f(output);
 }
 
 void mgx::DisplayConfiguration::for_each_output(std::function<void(mg::UserDisplayConfigurationOutput&)> f)
 {
-    mg::UserDisplayConfigurationOutput user(configuration);
-    f(user);
+    for (auto& output : outputs) {
+        mg::UserDisplayConfigurationOutput user(output);
+        f(user);
+    }
 }
 
 std::unique_ptr<mg::DisplayConfiguration> mgx::DisplayConfiguration::clone() const
 
=== modified file 'src/platforms/mesa/server/x11/graphics/display_configuration.h'
--- src/platforms/mesa/server/x11/graphics/display_configuration.h	2017-01-18 02:29:37 +0000
+++ src/platforms/mesa/server/x11/graphics/display_configuration.h	2017-02-16 10:45:38 +0000
@@ -33,24 +33,24 @@
 class DisplayConfiguration : public graphics::DisplayConfiguration
 {
 public:
-    DisplayConfiguration(MirPixelFormat pf,
-                         mir::geometry::Size const pixels,
-                         mir::geometry::Size const size_mm,
-                         float const scale,
-                         MirOrientation orientation);
+    DisplayConfiguration();
     DisplayConfiguration(DisplayConfiguration const&);
 
     virtual ~DisplayConfiguration() = default;
 
+    DisplayConfigurationOutputId add_output(MirPixelFormat pf,
+                                            mir::geometry::Size const pixels,
+                                            mir::geometry::Size const size,
+                                            const float scale,
+                                            MirOrientation orientation);
+
     void for_each_card(std::function<void(DisplayConfigurationCard const&)> f) const override;
     void for_each_output(std::function<void(DisplayConfigurationOutput const&)> f) const override;
     void for_each_output(std::function<void(UserDisplayConfigurationOutput&)> f) override;
     std::unique_ptr<graphics::DisplayConfiguration> clone() const override;
 
-    static DisplayConfigurationOutputId const the_output_id;
-
 private:
-    DisplayConfigurationOutput configuration;
+    std::vector<DisplayConfigurationOutput> outputs;
     DisplayConfigurationCard card;
 };
 
 
=== modified file 'src/platforms/mesa/server/x11/graphics/graphics.cpp'
--- src/platforms/mesa/server/x11/graphics/graphics.cpp	2017-01-18 02:29:37 +0000
+++ src/platforms/mesa/server/x11/graphics/graphics.cpp	2017-02-16 10:45:38 +0000
@@ -38,6 +38,7 @@
 namespace
 {
 char const* x11_displays_option_name{"x11-displays"};
+char const* x11_output_count_option_name{"x11-output-count"};
 }
 
 mir::UniqueModulePtr<mg::Platform> create_host_platform(
@@ -55,8 +56,11 @@
     if (pos == std::string::npos)
         BOOST_THROW_EXCEPTION(std::runtime_error("Malformed display size option"));
 
+    auto output_count = options->get<uint>(x11_output_count_option_name);
+
     return mir::make_module_ptr<mgx::Platform>(
                x11_resources.get_conn(),
+               output_count,
                geom::Size{std::stoi(display_dims_str.substr(0, pos)),
                           std::stoi(display_dims_str.substr(pos+1, display_dims_str.find(':')))},
                report
@@ -78,6 +82,10 @@
         (x11_displays_option_name,
          boost::program_options::value<std::string>()->default_value("1280x1024"),
          "[mir-on-X specific] WIDTHxHEIGHT of \"display\" window.");
+    config.add_options()
+        (x11_output_count_option_name,
+         boost::program_options::value<uint>()->default_value(1),
+         "[mir-on-X specific] NUMBER of outputs.");
 }
 
 mg::PlatformPriority probe_graphics_platform(mo::ProgramOption const& /*options*/)
 
=== modified file 'src/platforms/mesa/server/x11/graphics/platform.cpp'
--- src/platforms/mesa/server/x11/graphics/platform.cpp	2017-01-18 02:29:37 +0000
+++ src/platforms/mesa/server/x11/graphics/platform.cpp	2017-02-16 10:45:38 +0000
@@ -27,12 +27,14 @@
 namespace geom = mir::geometry;
 
 mgx::Platform::Platform(std::shared_ptr<::Display> const& conn,
+                        uint output_count,
                         geom::Size const size,
                         std::shared_ptr<mg::DisplayReport> const& report)
     : x11_connection{conn},
       udev{std::make_shared<mir::udev::Context>()},
       drm{std::make_shared<mesa::helpers::DRMHelper>(mesa::helpers::DRMNodeToUse::render)},
       report{report},
+      output_count{output_count},
       size{size}
 {
     if (!x11_connection)
@@ -48,11 +50,10 @@
 }
 
 mir::UniqueModulePtr<mg::Display> mgx::Platform::create_display(
-    std::shared_ptr<DisplayConfigurationPolicy> const& /*initial_conf_policy*/,
+    std::shared_ptr<DisplayConfigurationPolicy> const& initial_conf_policy,
     std::shared_ptr<GLConfig> const& gl_config)
 {
-    return make_module_ptr<mgx::Display>(x11_connection.get(), size, gl_config,
-                                         report);
+    return make_module_ptr<mgx::Display>(x11_connection.get(), output_count, size, initial_conf_policy, gl_config, report);
 }
 
 mir::UniqueModulePtr<mg::PlatformIpcOperations> mgx::Platform::make_ipc_operations() const
 
=== modified file 'src/platforms/mesa/server/x11/graphics/platform.h'
--- src/platforms/mesa/server/x11/graphics/platform.h	2017-01-18 02:29:37 +0000
+++ src/platforms/mesa/server/x11/graphics/platform.h	2017-02-16 10:45:38 +0000
@@ -38,6 +38,7 @@
 {
 public:
     explicit Platform(std::shared_ptr<::Display> const& conn,
+                      uint output_count,
                       mir::geometry::Size const size,
                       std::shared_ptr<DisplayReport> const& report);
     ~Platform() = default;
@@ -57,6 +58,7 @@
     std::shared_ptr<mesa::helpers::DRMHelper> const drm;
     std::shared_ptr<DisplayReport> const report;
     mesa::helpers::GBMHelper gbm;
+    uint output_count;
     mir::geometry::Size const size;
 };
 
 
=== modified file 'src/platforms/mesa/server/x11/input/input_platform.cpp'
--- src/platforms/mesa/server/x11/input/input_platform.cpp	2017-02-15 07:38:33 +0000
+++ src/platforms/mesa/server/x11/input/input_platform.cpp	2017-02-16 10:45:38 +0000
@@ -28,6 +28,7 @@
 
 #include <X11/Xutil.h>
 #include <X11/Xlib.h>
+#include <X11/Xatom.h>
 #include <linux/input.h>
 #include <inttypes.h>
 #include <signal.h>
@@ -39,7 +40,7 @@
 
 // Due to a bug in Unity when keyboard is grabbed,
 // client cannot be resized. This helps in debugging.
-#define GRAB_KBD
+// #define GRAB_KBD
 
 namespace mi = mir::input;
 namespace geom = mir::geometry;
@@ -89,6 +90,41 @@
 {
 }
 
+XPoint get_logical_offset_for_window(::Display* display, Window window)
+{
+    XPoint pt{0,0};
+
+    static Atom atom = XInternAtom(display, "WM_LOGICAL_POSITION", False);
+    if (atom != None) {
+        int result;
+        Atom actual_type_return;
+        int actual_format_return;
+        unsigned long bytes_after_return;
+        unsigned char* prop_to_return;
+        unsigned long n_items;
+        result = XGetWindowProperty(display, window, atom,
+                       0, (~0L), False, XA_POINT,
+                       &actual_type_return,
+                       &actual_format_return,
+                       &n_items, &bytes_after_return, &prop_to_return);
+        if (result != Success) {
+            mir::log_error("X11 button event - failed to get window logicl position");
+        } else if (n_items*actual_format_return == sizeof(XPoint)*8) {
+            memcpy((unsigned char*)&pt, prop_to_return, sizeof(XPoint));
+        } else {
+            mir::log_error("X11 button event - logical position format error: type=%s format=%d bytes_remaiing=%d, n_items=%d",
+                            XGetAtomName(display, actual_type_return),
+                            actual_format_return,
+                            bytes_after_return,
+                            n_items);
+        }
+    } else {
+        mir::log_error("X11 button event - No atom WM_LOGICAL_POSITION");
+    }
+
+    return pt;
+}
+
 void mix::XInputPlatform::process_input_event()
 {
     while(XPending(x11_connection.get()))
@@ -217,11 +253,13 @@
                         std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::milliseconds{xbev.time});
                     core_pointer->update_button_state(xbev.state);
 
+                    XPoint logical_window_position = get_logical_offset_for_window(xbev.display, xbev.window);
+
                     if (xbev.button >= up && xbev.button <= right)
                     {  // scroll event
                         core_pointer->pointer_motion(
                             event_time,
-                            geom::Point{xbev.x, xbev.y},
+                            geom::Point{logical_window_position.x + xbev.x, logical_window_position.y + xbev.y},
                             geom::Displacement{xbev.button == right ? 1 : xbev.button == left ? -1 : 0,
                                                xbev.button == up ? 1 : xbev.button == down ? -1 : 0});
                     }
@@ -231,13 +269,13 @@
                             core_pointer->pointer_press(
                                 event_time,
                                 xbev.button,
-                                geom::Point{xbev.x, xbev.y},
+                                geom::Point{logical_window_position.x + xbev.x, logical_window_position.y + xbev.y},
                                 geom::Displacement{0, 0});
                         else
                             core_pointer->pointer_release(
                                 event_time,
                                 xbev.button,
-                                geom::Point{xbev.x, xbev.y},
+                                geom::Point{logical_window_position.x + xbev.x, logical_window_position.y + xbev.y},
                                 geom::Displacement{0, 0});
                     }
                     break;
@@ -257,9 +295,13 @@
                                   xmev.y_root, xmev.state, xmev.is_hint == NotifyNormal ? "no" : "yes", xmev.same_screen);
 #endif
 
+                    XPoint logical_window_position = get_logical_offset_for_window(xmev.display, xmev.window);
+
                     core_pointer->update_button_state(xmev.state);
                     core_pointer->pointer_motion(
-                        std::chrono::milliseconds{xmev.time}, geom::Point{xmev.x, xmev.y}, geom::Displacement{0, 0});
+                        std::chrono::milliseconds{xmev.time},
+                        geom::Point{logical_window_position.x + xmev.x, logical_window_position.y + xmev.y},
+                        geom::Displacement{0, 0});
 
                     break;
                 }