1 files changed, 135 insertions, 107 deletions

diff --git a/tests/auto/client/mockinput.cpp b/tests/auto/client/mockinput.cpp
index a5b46bf6e..ac2b666b4 100644
--- a/tests/auto/client/mockinput.cpp
+++ b/tests/auto/client/mockinput.cpp
@@ -40,164 +40,192 @@
 ****************************************************************************/
 
 #include "mockcompositor.h"
+#include "mockinput.h"
 #include "mocksurface.h"
 
 namespace Impl {
 
-void Compositor::destroyInputResource(wl_resource *resource)
+static Surface *resolveSurface(const QVariant &v)
 {
-    Compositor *compositor = static_cast<Compositor *>(resource->data);
-    wl_keyboard *keyboard = &compositor->m_keyboard;
-    wl_pointer *pointer = &compositor->m_pointer;
+    QSharedPointer<MockSurface> mockSurface = v.value<QSharedPointer<MockSurface> >();
+    return mockSurface ? mockSurface->handle() : 0;
+}
 
-    if (keyboard->focus_resource == resource)
-        keyboard->focus_resource = 0;
-    if (pointer->focus_resource == resource)
-        pointer->focus_resource = 0;
+void Compositor::setKeyboardFocus(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    compositor->m_keyboard->setFocus(resolveSurface(parameters.first()));
+}
 
-    wl_list_remove(&resource->link);
+void Compositor::sendMousePress(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+    if (!surface)
+        return;
 
-    free(resource);
+    QPoint pos = parameters.last().toPoint();
+    compositor->m_pointer->setFocus(surface, pos);
+    compositor->m_pointer->sendMotion(pos);
+    compositor->m_pointer->sendButton(0x110, 1);
 }
 
-static void destroyInputDevice(wl_resource *resource)
+void Compositor::sendMouseRelease(void *data, const QList<QVariant> &parameters)
 {
-    wl_list_remove(&resource->link);
-    free(resource);
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+    if (!surface)
+        return;
+
+    compositor->m_pointer->sendButton(0x110, 0);
 }
 
-void pointer_attach(wl_client *client,
-                    wl_resource *device_resource,
-                    uint32_t time,
-                    wl_resource *buffer_resource, int32_t x, int32_t y)
+void Compositor::sendKeyPress(void *data, const QList<QVariant> &parameters)
 {
-    Q_UNUSED(client);
-    Q_UNUSED(device_resource);
-    Q_UNUSED(time);
-    Q_UNUSED(buffer_resource);
-    Q_UNUSED(QPoint(x, y));
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+    if (!surface)
+        return;
+
+    compositor->m_keyboard->sendKey(parameters.last().toUInt() - 8, 1);
 }
 
-void Compositor::get_pointer(wl_client *client,
-                             wl_resource *resource,
-                             uint32_t id)
+void Compositor::sendKeyRelease(void *data, const QList<QVariant> &parameters)
 {
-    static const struct wl_pointer_interface pointer_interface = {
-        pointer_attach
-    };
-    Compositor *compositor = static_cast<Compositor *>(resource->data);
-    wl_pointer *pointer = &compositor->m_pointer;
-    wl_resource *clientResource = wl_client_add_object(client,
-                                                       &wl_pointer_interface,
-                                                       &pointer_interface,
-                                                       id,
-                                                       pointer);
-    wl_list_insert(&pointer->resource_list, &clientResource->link);
-    clientResource->destroy = destroyInputDevice;
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+    if (!surface)
+        return;
+
+    compositor->m_keyboard->sendKey(parameters.last().toUInt() - 8, 0);
 }
 
-void Compositor::get_keyboard(wl_client *client,
-                              wl_resource *resource,
-                              uint32_t id)
+Seat::Seat(Compositor *compositor, struct ::wl_display *display)
+    : wl_seat(display)
+    , m_compositor(compositor)
+    , m_keyboard(new Keyboard(compositor))
+    , m_pointer(new Pointer(compositor))
 {
-    Compositor *compositor = static_cast<Compositor *>(resource->data);
-    wl_keyboard *keyboard = &compositor->m_keyboard;
-    wl_resource *clientResource = wl_client_add_object(client,
-                                                       &wl_keyboard_interface,
-                                                       0,
-                                                       id,
-                                                       keyboard);
-    wl_list_insert(&keyboard->resource_list, &clientResource->link);
-    clientResource->destroy = destroyInputDevice;
 }
 
-void Compositor::get_touch(wl_client *client,
-                           wl_resource *resource,
-                           uint32_t id)
+Seat::~Seat()
 {
-    Q_UNUSED(client);
-    Q_UNUSED(resource);
-    Q_UNUSED(id);
 }
 
-void Compositor::bindSeat(wl_client *client, void *compositorData, uint32_t version, uint32_t id)
+void Seat::seat_bind_resource(Resource *resource)
 {
-    static const struct wl_seat_interface seatInterface = {
-        get_pointer,
-        get_keyboard,
-        get_touch
-    };
-
-    Q_UNUSED(version);
-    wl_resource *resource = wl_client_add_object(client, &wl_seat_interface, &seatInterface, id, compositorData);
-    resource->destroy = destroyInputResource;
+    send_capabilities(resource->handle, capability_keyboard | capability_pointer);
+}
 
-    Compositor *compositor = static_cast<Compositor *>(compositorData);
-    wl_list_insert(&compositor->m_seat.base_resource_list, &resource->link);
+void Seat::seat_get_keyboard(Resource *resource, uint32_t id)
+{
+    m_keyboard->add(resource->client(), id);
+}
 
-    wl_seat_send_capabilities(resource, WL_SEAT_CAPABILITY_POINTER | WL_SEAT_CAPABILITY_KEYBOARD);
+void Seat::seat_get_pointer(Resource *resource, uint32_t id)
+{
+    m_pointer->add(resource->client(), id);
 }
 
-static wl_surface *resolveSurface(const QVariant &v)
+Keyboard::Keyboard(Compositor *compositor)
+    : wl_keyboard()
+    , m_compositor(compositor)
 {
-    QSharedPointer<MockSurface> mockSurface = v.value<QSharedPointer<MockSurface> >();
-    Surface *surface = mockSurface ? mockSurface->handle() : 0;
-    return surface ? surface->base() : 0;
 }
 
-void Compositor::setKeyboardFocus(void *data, const QList<QVariant> &parameters)
+Keyboard::~Keyboard()
 {
-    Compositor *compositor = static_cast<Compositor *>(data);
-    wl_keyboard_set_focus(&compositor->m_keyboard, resolveSurface(parameters.first()));
 }
 
-void Compositor::sendMousePress(void *data, const QList<QVariant> &parameters)
+static wl_resource *resourceForSurface(wl_list *resourceList, Surface *surface)
 {
-    Compositor *compositor = static_cast<Compositor *>(data);
-    wl_surface *surface = resolveSurface(parameters.first());
     if (!surface)
-        return;
+        return 0;
 
-    QPoint pos = parameters.last().toPoint();
-    wl_pointer_set_focus(&compositor->m_pointer, surface,
-                         wl_fixed_from_int(pos.x()), wl_fixed_from_int(pos.y()));
-    wl_pointer_send_motion(compositor->m_pointer.focus_resource, compositor->time(),
-                           wl_fixed_from_double(pos.x()), wl_fixed_from_double(pos.y()));
-    wl_pointer_send_button(compositor->m_pointer.focus_resource,
-                           compositor->nextSerial(), compositor->time(), 0x110, 1);
+    wl_resource *r;
+    wl_client *surfaceClient = surface->resource()->client();
+
+    wl_list_for_each(r, resourceList, link) {
+        if (r->client == surfaceClient)
+            return r;
+    }
+
+    return 0;
 }
 
-void Compositor::sendMouseRelease(void *data, const QList<QVariant> &parameters)
+void Keyboard::setFocus(Surface *surface)
 {
-    Compositor *compositor = static_cast<Compositor *>(data);
-    wl_surface *surface = resolveSurface(parameters.first());
-    if (!surface)
-        return;
+    if (m_focusResource && m_focus != surface) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_leave(m_focusResource->handle, serial, m_focus->resource()->handle);
+    }
+
+    struct ::wl_resource *r = resourceForSurface(resourceList(), surface);
+    Resource *resource = r ? Resource::fromResource(r) : 0;
+
+    if (resource && (m_focus != surface || m_focusResource != resource)) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_modifiers(resource->handle, serial, 0, 0, 0, 0);
+        send_enter(resource->handle, serial, surface->resource()->handle, QByteArray());
+    }
+
+    m_focusResource = resource;
+    m_focus = surface;
+}
 
-    wl_pointer_send_button(compositor->m_pointer.focus_resource,
-                           compositor->nextSerial(), compositor->time(), 0x110, 0);
+void Keyboard::sendKey(uint32_t key, uint32_t state)
+{
+    if (m_focusResource) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_key(m_focusResource->handle, serial, m_compositor->time(), key, state);
+    }
 }
 
-void Compositor::sendKeyPress(void *data, const QList<QVariant> &parameters)
+Pointer::Pointer(Compositor *compositor)
+    : wl_pointer()
+    , m_compositor(compositor)
+{
+}
+
+Pointer::~Pointer()
 {
-    Compositor *compositor = static_cast<Compositor *>(data);
-    wl_surface *surface = resolveSurface(parameters.first());
-    if (!surface)
-        return;
 
-    wl_keyboard_send_key(compositor->m_keyboard.focus_resource,
-                         compositor->nextSerial(), compositor->time(), parameters.last().toUInt() - 8, 1);
 }
 
-void Compositor::sendKeyRelease(void *data, const QList<QVariant> &parameters)
+void Pointer::setFocus(Surface *surface, const QPoint &pos)
 {
-    Compositor *compositor = static_cast<Compositor *>(data);
-    wl_surface *surface = resolveSurface(parameters.first());
-    if (!surface)
-        return;
+    if (m_focusResource && m_focus != surface) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_leave(m_focusResource->handle, serial, m_focus->resource()->handle);
+    }
+
+    struct ::wl_resource *r = resourceForSurface(resourceList(), surface);
+    Resource *resource = r ? Resource::fromResource(r) : 0;
+
+    if (resource && (m_focus != surface || resource != m_focusResource)) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_enter(resource->handle, serial, surface->resource()->handle,
+                   wl_fixed_from_int(pos.x()), wl_fixed_from_int(pos.y()));
+    }
+
+    m_focusResource = resource;
+    m_focus = surface;
+}
 
-    wl_keyboard_send_key(compositor->m_keyboard.focus_resource,
-                         compositor->nextSerial(), compositor->time(), parameters.last().toUInt() - 8, 0);
+void Pointer::sendMotion(const QPoint &pos)
+{
+    if (m_focusResource)
+        send_motion(m_focusResource->handle, m_compositor->time(),
+                    wl_fixed_from_int(pos.x()), wl_fixed_from_int(pos.y()));
+}
+
+void Pointer::sendButton(uint32_t button, uint32_t state)
+{
+    if (m_focusResource) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_button(m_focusResource->handle, serial, m_compositor->time(),
+                    button, state);
+    }
 }
 
 }