From 40cb4f5cd625cce1399fe01a62f6a2aa2a479792 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Gr=C3=A4=C3=9Flin?= Date: Mon, 20 May 2013 10:49:28 +0200 Subject: [PATCH] Map cursors from X11 to Wayland Tracking cursor changes in X11. Whenever the cursor image changes, the image is read and a wl_buffer is created with the content of the X11 cursor. This buffer is attached to a surface used as a cursor image. As a memory pool for the cursor buffers a temporary file is created and mmapped. All created cursors are cached but not yet removed from the cache. Some cleanup code would be useful also to ensure that our shared memory pool doesn't overflow. --- egl_wayland_backend.cpp | 190 +++++++++++++++++++++++++++++++++++++++- egl_wayland_backend.h | 105 +++++++++++++++++++++- 2 files changed, 291 insertions(+), 4 deletions(-) diff --git a/egl_wayland_backend.cpp b/egl_wayland_backend.cpp index 401b6b06f3..67ed4fe2c3 100644 --- a/egl_wayland_backend.cpp +++ b/egl_wayland_backend.cpp @@ -20,16 +20,23 @@ along with this program. If not, see . #define WL_EGL_PLATFORM 1 #include "egl_wayland_backend.h" // kwin +#include "cursor.h" #include "options.h" // kwin libs #include // KDE #include +#include // xcb #include +// Wayland +#include // system #include +#include +#include #include +#include namespace KWin { @@ -52,6 +59,8 @@ static void registryHandleGlobal(void *data, struct wl_registry *registry, d->setShell(reinterpret_cast(wl_registry_bind(registry, name, &wl_shell_interface, 1))); } else if (strcmp(interface, "wl_seat") == 0) { d->createSeat(name); + } else if (strcmp(interface, "wl_shm") == 0) { + d->createShm(name); } kDebug(1212) << "Wayland Interface: " << interface; } @@ -111,10 +120,11 @@ static void pointerHandleEnter(void *data, wl_pointer *pointer, uint32_t serial, { Q_UNUSED(data) Q_UNUSED(pointer) - Q_UNUSED(serial) Q_UNUSED(surface) Q_UNUSED(sx) Q_UNUSED(sy) + WaylandSeat *seat = reinterpret_cast(data); + seat->pointerEntered(serial); } static void pointerHandleLeave(void *data, wl_pointer *pointer, uint32_t serial, wl_surface *surface) @@ -279,10 +289,165 @@ static const struct wl_seat_listener s_seatListener = { seatHandleCapabilities }; -WaylandSeat::WaylandSeat(wl_seat *seat) +CursorData::CursorData(ShmPool *pool) + : m_cursor(NULL) + , m_valid(init(pool)) +{ +} + +CursorData::~CursorData() +{ +} + +bool CursorData::init(ShmPool *pool) +{ + QScopedPointer cursor( + xcb_xfixes_get_cursor_image_reply(connection(), + xcb_xfixes_get_cursor_image_unchecked(connection()), + NULL)); + if (cursor.isNull()) { + return false; + } + + QImage cursorImage((uchar *) xcb_xfixes_get_cursor_image_cursor_image(cursor.data()), cursor->width, cursor->height, + QImage::Format_ARGB32_Premultiplied); + if (cursorImage.isNull()) { + return false; + } + m_size = QSize(cursor->width, cursor->height); + + m_cursor = pool->createBuffer(cursorImage); + if (!m_cursor) { + kDebug(1212) << "Creating cursor buffer failed"; + return false; + } + + m_hotSpot = QPoint(cursor->xhot, cursor->yhot); + return true; +} + +X11CursorTracker::X11CursorTracker(wl_pointer *pointer, WaylandBackend *backend, QObject* parent) + : QObject(parent) + , m_pointer(pointer) + , m_backend(backend) + , m_cursor(wl_compositor_create_surface(backend->compositor())) + , m_enteredSerial(0) + , m_lastX11Cursor(0) +{ + Cursor::self()->startCursorTracking(); + connect(Cursor::self(), SIGNAL(cursorChanged(uint32_t)), SLOT(cursorChanged(uint32_t))); +} + +X11CursorTracker::~X11CursorTracker() +{ + Cursor::self()->stopCursorTracking(); + if (m_cursor) { + wl_surface_destroy(m_cursor); + } +} + +void X11CursorTracker::cursorChanged(uint32_t serial) +{ + if (m_lastX11Cursor == serial) { + // not changed; + return; + } + m_lastX11Cursor = serial; + QHash::iterator it = m_cursors.find(serial); + if (it != m_cursors.end()) { + installCursor(it.value()); + return; + } + ShmPool *pool = m_backend->shmPool(); + if (!pool) { + return; + } + CursorData cursor(pool); + if (cursor.isValid()) { + // TODO: discard unused cursors after some time? + m_cursors.insert(serial, cursor); + } + installCursor(cursor); +} + +void X11CursorTracker::installCursor(const CursorData& cursor) +{ + wl_pointer_set_cursor(m_pointer, m_enteredSerial, m_cursor, cursor.hotSpot().x(), cursor.hotSpot().y()); + wl_surface_attach(m_cursor, cursor.cursor(), 0, 0); + wl_surface_damage(m_cursor, 0, 0, cursor.size().width(), cursor.size().height()); + wl_surface_commit(m_cursor); +} + +void X11CursorTracker::setEnteredSerial(uint32_t serial) +{ + m_enteredSerial = serial; +} + +ShmPool::ShmPool(wl_shm *shm) + : m_shm(shm) + , m_pool(NULL) + , m_poolData(NULL) + , m_size(1024 * 1024) // TODO: useful size? + , m_tmpFile(new KTemporaryFile()) + , m_valid(createPool()) +{ +} + +ShmPool::~ShmPool() +{ + if (m_poolData) { + munmap(m_poolData, m_size); + } + if (m_pool) { + wl_shm_pool_destroy(m_pool); + } + if (m_shm) { + wl_shm_destroy(m_shm); + } +} + +bool ShmPool::createPool() +{ + if (!m_tmpFile->open()) { + kDebug(1212) << "Could not open temporary file for Shm pool"; + return false; + } + if (ftruncate(m_tmpFile->handle(), m_size) < 0) { + kDebug(1212) << "Could not set size for Shm pool file"; + return false; + } + m_poolData = mmap(NULL, m_size, PROT_READ | PROT_WRITE, MAP_SHARED, m_tmpFile->handle(), 0); + m_pool = wl_shm_create_pool(m_shm, m_tmpFile->handle(), m_size); + + if (!m_poolData || !m_pool) { + kDebug(1212) << "Creating Shm pool failed"; + return false; + } + m_tmpFile->close(); + return true; +} + +wl_buffer *ShmPool::createBuffer(const QImage& image) +{ + if (image.isNull() || !m_valid) { + return NULL; + } + // TODO: test whether buffer needs resizing + wl_buffer *buffer = wl_shm_pool_create_buffer(m_pool, m_offset, image.width(), image.height(), + image.bytesPerLine(), WL_SHM_FORMAT_ARGB8888); + if (buffer) { + memcpy((char *)m_poolData + m_offset, image.bits(), image.byteCount()); + m_offset += image.byteCount(); + } + return buffer; +} + +WaylandSeat::WaylandSeat(wl_seat *seat, WaylandBackend *backend) : m_seat(seat) , m_pointer(NULL) , m_keyboard(NULL) + , m_cursorTracker() + , m_backend(backend) { if (m_seat) { wl_seat_add_listener(m_seat, &s_seatListener, this); @@ -303,6 +468,7 @@ void WaylandSeat::destroyPointer() if (m_pointer) { wl_pointer_destroy(m_pointer); m_pointer = NULL; + m_cursorTracker.reset(); } } @@ -319,6 +485,7 @@ void WaylandSeat::changed(uint32_t capabilities) if ((capabilities & WL_SEAT_CAPABILITY_POINTER) && !m_pointer) { m_pointer = wl_seat_get_pointer(m_seat); wl_pointer_add_listener(m_pointer, &s_pointerListener, this); + m_cursorTracker.reset(new X11CursorTracker(m_pointer, m_backend)); } else if (!(capabilities & WL_SEAT_CAPABILITY_POINTER)) { destroyPointer(); } @@ -330,6 +497,14 @@ void WaylandSeat::changed(uint32_t capabilities) } } +void WaylandSeat::pointerEntered(uint32_t serial) +{ + if (m_cursorTracker.isNull()) { + return; + } + m_cursorTracker->setEnteredSerial(serial); +} + WaylandBackend::WaylandBackend() : m_display(wl_display_connect(NULL)) , m_registry(wl_display_get_registry(m_display)) @@ -339,6 +514,7 @@ WaylandBackend::WaylandBackend() , m_overlay(NULL) , m_shellSurface(NULL) , m_seat() + , m_shm() { kDebug(1212) << "Created Wayland display"; // setup the registry @@ -376,7 +552,7 @@ WaylandBackend::~WaylandBackend() void WaylandBackend::createSeat(uint32_t name) { wl_seat *seat = reinterpret_cast(wl_registry_bind(m_registry, name, &wl_seat_interface, 1)); - m_seat.reset(new WaylandSeat(seat)); + m_seat.reset(new WaylandSeat(seat, this)); } bool WaylandBackend::createSurface() @@ -407,6 +583,14 @@ bool WaylandBackend::createSurface() return true; } +void WaylandBackend::createShm(uint32_t name) +{ + m_shm.reset(new ShmPool(reinterpret_cast(wl_registry_bind(m_registry, name, &wl_shm_interface, 1)))); + if (!m_shm->isValid()) { + m_shm.reset(); + } +} + } EglWaylandBackend::EglWaylandBackend() diff --git a/egl_wayland_backend.h b/egl_wayland_backend.h index b0c23a8e2a..451fe4531c 100644 --- a/egl_wayland_backend.h +++ b/egl_wayland_backend.h @@ -26,26 +26,90 @@ along with this program. If not, see . // xcb #include +class KTemporaryFile; +struct wl_buffer; +struct wl_shm; + namespace KWin { namespace Wayland { +class ShmPool; +class WaylandBackend; + +class CursorData +{ +public: + CursorData(ShmPool *pool); + ~CursorData(); + bool isValid() const; + const QPoint &hotSpot() const; + const QSize &size() const; + wl_buffer *cursor() const; +private: + bool init(ShmPool *pool); + wl_buffer *m_cursor; + QPoint m_hotSpot; + QSize m_size; + bool m_valid; +}; + +class X11CursorTracker : public QObject +{ + Q_OBJECT +public: + explicit X11CursorTracker(wl_pointer *pointer, WaylandBackend *backend, QObject* parent = 0); + virtual ~X11CursorTracker(); + void setEnteredSerial(uint32_t serial); +private Q_SLOTS: + void cursorChanged(uint32_t serial); +private: + void installCursor(const CursorData &cursor); + wl_pointer *m_pointer; + QHash m_cursors; + WaylandBackend *m_backend; + wl_surface *m_cursor; + uint32_t m_enteredSerial; + uint32_t m_installedCursor; + uint32_t m_lastX11Cursor; +}; + +class ShmPool +{ +public: + ShmPool(wl_shm *shm); + ~ShmPool(); + bool isValid() const; + wl_buffer *createBuffer(const QImage &image); +private: + bool createPool(); + wl_shm *m_shm; + wl_shm_pool *m_pool; + void *m_poolData; + size_t m_size; + QScopedPointer m_tmpFile; + bool m_valid; + int m_offset; +}; class WaylandSeat { public: - WaylandSeat(wl_seat *seat); + WaylandSeat(wl_seat *seat, WaylandBackend *backend); virtual ~WaylandSeat(); void changed(uint32_t capabilities); wl_seat *seat(); + void pointerEntered(uint32_t serial); private: void destroyPointer(); void destroyKeyboard(); wl_seat *m_seat; wl_pointer *m_pointer; wl_keyboard *m_keyboard; + QScopedPointer m_cursorTracker; + WaylandBackend *m_backend; }; /** @@ -66,7 +130,9 @@ public: void setShell(wl_shell *s); wl_shell *shell(); wl_egl_window *overlay(); + ShmPool *shmPool(); void createSeat(uint32_t name); + void createShm(uint32_t name); bool createSurface(); private: @@ -78,14 +144,45 @@ private: wl_egl_window *m_overlay; wl_shell_surface *m_shellSurface; QScopedPointer m_seat; + QScopedPointer m_shm; }; +inline +bool CursorData::isValid() const +{ + return m_valid; +} + +inline +const QPoint& CursorData::hotSpot() const +{ + return m_hotSpot; +} + +inline +wl_buffer* CursorData::cursor() const +{ + return m_cursor; +} + +inline +const QSize& CursorData::size() const +{ + return m_size; +} + inline wl_seat *WaylandSeat::seat() { return m_seat; } +inline +bool ShmPool::isValid() const +{ + return m_valid; +} + inline wl_display *WaylandBackend::display() { @@ -128,6 +225,12 @@ wl_shell *WaylandBackend::shell() return m_shell; } +inline +ShmPool* WaylandBackend::shmPool() +{ + return m_shm.data(); +} + } // namespace Wayland class Shm;