From 8ea41bfe32de3b4dd4c15ec91c8925b1c6508c53 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B8rgen=20Lind?= Date: Thu, 30 Jul 2015 15:16:48 +0200 Subject: Public input apis Change-Id: I60ec2fd9f4afe54198d9c476b28f9f15a661e9ca --- .../qwindow-compositor/qwindowcompositor.cpp | 6 +- src/compositor/compositor_api/compositor_api.pri | 14 +- .../compositor_api/qwaylandcompositor.cpp | 45 ++-- src/compositor/compositor_api/qwaylandcompositor.h | 12 +- .../compositor_api/qwaylanddestroylistener.cpp | 72 ++++++ .../compositor_api/qwaylanddestroylistener.h | 64 +++++ .../compositor_api/qwaylanddestroylistener_p.h | 66 +++++ src/compositor/compositor_api/qwaylanddrag.cpp | 10 +- src/compositor/compositor_api/qwaylanddrag.h | 6 +- src/compositor/compositor_api/qwaylandinput.cpp | 88 +++---- src/compositor/compositor_api/qwaylandinput.h | 42 ++-- src/compositor/compositor_api/qwaylandkeyboard.cpp | 111 +++++++++ src/compositor/compositor_api/qwaylandkeyboard.h | 113 +++++++++ src/compositor/compositor_api/qwaylandoutput.cpp | 5 + src/compositor/compositor_api/qwaylandoutput.h | 2 + .../compositor_api/qwaylandoutputspace.cpp | 5 + .../compositor_api/qwaylandoutputspace.h | 3 +- src/compositor/compositor_api/qwaylandpointer.cpp | 257 +++++++++++++++++++ src/compositor/compositor_api/qwaylandpointer.h | 131 ++++++++++ src/compositor/compositor_api/qwaylandsurface.cpp | 22 +- src/compositor/compositor_api/qwaylandsurface.h | 4 + .../compositor_api/qwaylandsurfaceitem.cpp | 12 +- .../compositor_api/qwaylandsurfaceview.cpp | 7 + .../compositor_api/qwaylandsurfaceview.h | 2 + src/compositor/extensions/extensions.pri | 1 + .../extensions/qwaylandwindowmanagerextension.cpp | 60 ++--- .../extensions/qwaylandwindowmanagerextension.h | 30 +-- .../extensions/qwaylandwindowmanagerextension_p.h | 61 +++++ src/compositor/extensions/qwlshellsurface.cpp | 67 ++--- src/compositor/extensions/qwlshellsurface_p.h | 14 +- src/compositor/extensions/qwltextinput.cpp | 4 +- src/compositor/global/qwaylandextension.h | 2 +- src/compositor/wayland_wrapper/qwlcompositor.cpp | 32 +-- src/compositor/wayland_wrapper/qwlcompositor_p.h | 8 +- src/compositor/wayland_wrapper/qwldatadevice.cpp | 54 ++-- src/compositor/wayland_wrapper/qwldatadevice_p.h | 13 +- .../wayland_wrapper/qwldatadevicemanager.cpp | 10 +- src/compositor/wayland_wrapper/qwlinputdevice.cpp | 217 ++++++---------- src/compositor/wayland_wrapper/qwlinputdevice_p.h | 71 +++--- src/compositor/wayland_wrapper/qwlinputmethod.cpp | 10 +- src/compositor/wayland_wrapper/qwlinputmethod_p.h | 11 +- src/compositor/wayland_wrapper/qwlkeyboard.cpp | 103 ++++---- src/compositor/wayland_wrapper/qwlkeyboard_p.h | 71 ++---- src/compositor/wayland_wrapper/qwllistener.cpp | 65 ----- src/compositor/wayland_wrapper/qwllistener_p.h | 70 ------ src/compositor/wayland_wrapper/qwloutput_p.h | 1 + src/compositor/wayland_wrapper/qwlpointer.cpp | 273 +++++---------------- src/compositor/wayland_wrapper/qwlpointer_p.h | 105 ++++---- src/compositor/wayland_wrapper/qwlsurface.cpp | 3 +- src/compositor/wayland_wrapper/qwltouch.cpp | 136 +++++----- src/compositor/wayland_wrapper/qwltouch_p.h | 55 ++--- src/compositor/wayland_wrapper/wayland_wrapper.pri | 2 - 52 files changed, 1567 insertions(+), 1081 deletions(-) create mode 100644 src/compositor/compositor_api/qwaylanddestroylistener.cpp create mode 100644 src/compositor/compositor_api/qwaylanddestroylistener.h create mode 100644 src/compositor/compositor_api/qwaylanddestroylistener_p.h create mode 100644 src/compositor/compositor_api/qwaylandkeyboard.cpp create mode 100644 src/compositor/compositor_api/qwaylandkeyboard.h create mode 100644 src/compositor/compositor_api/qwaylandpointer.cpp create mode 100644 src/compositor/compositor_api/qwaylandpointer.h create mode 100644 src/compositor/extensions/qwaylandwindowmanagerextension_p.h delete mode 100644 src/compositor/wayland_wrapper/qwllistener.cpp delete mode 100644 src/compositor/wayland_wrapper/qwllistener_p.h diff --git a/examples/wayland/qwindow-compositor/qwindowcompositor.cpp b/examples/wayland/qwindow-compositor/qwindowcompositor.cpp index a4de89696..b42855fd3 100644 --- a/examples/wayland/qwindow-compositor/qwindowcompositor.cpp +++ b/examples/wayland/qwindow-compositor/qwindowcompositor.cpp @@ -396,7 +396,7 @@ bool QWindowCompositor::eventFilter(QObject *obj, QEvent *event) m_surfaces.append(target->surface()); m_renderScheduler.start(0); } - input->sendMousePressEvent(me->button(), local, me->localPos()); + input->sendMousePressEvent(me->button()); } return true; } @@ -410,7 +410,7 @@ bool QWindowCompositor::eventFilter(QObject *obj, QEvent *event) QPointF localPos; if (target) localPos = toView(target, me->localPos()); - input->sendMouseReleaseEvent(me->button(), localPos, me->localPos()); + input->sendMouseReleaseEvent(me->button()); } return true; } @@ -466,7 +466,7 @@ bool QWindowCompositor::eventFilter(QObject *obj, QEvent *event) target = viewAt(pointPos); } if (target && target != input->mouseFocus()) - input->setMouseFocus(target, pointPos, pointPos); + input->sendMouseMoveEvent(target, pointPos, pointPos); if (input->mouseFocus()) input->sendFullTouchEvent(te); break; diff --git a/src/compositor/compositor_api/compositor_api.pri b/src/compositor/compositor_api/compositor_api.pri index 0cb5392dc..2da46ae76 100644 --- a/src/compositor/compositor_api/compositor_api.pri +++ b/src/compositor/compositor_api/compositor_api.pri @@ -6,6 +6,9 @@ HEADERS += \ compositor_api/qwaylandsurface.h \ compositor_api/qwaylandsurface_p.h \ compositor_api/qwaylandinput.h \ + compositor_api/qwaylandkeyboard.h \ + compositor_api/qwaylandpointer.h \ + compositor_api/qwaylandtouch.h \ compositor_api/qwaylandinputpanel.h \ compositor_api/qwaylandoutput.h \ compositor_api/qwaylanddrag.h \ @@ -13,19 +16,26 @@ HEADERS += \ compositor_api/qwaylandsurfaceview.h \ compositor_api/qwaylandsurfaceview_p.h \ compositor_api/qwaylandoutputspace.h \ - compositor_api/qwaylandoutputspace_p.h + compositor_api/qwaylandoutputspace_p.h \ + compositor_api/qwaylanddestroylistener.h \ + compositor_api/qwaylanddestroylistener_p.h \ + SOURCES += \ compositor_api/qwaylandcompositor.cpp \ compositor_api/qwaylandclient.cpp \ compositor_api/qwaylandsurface.cpp \ compositor_api/qwaylandinput.cpp \ + compositor_api/qwaylandkeyboard.cpp \ + compositor_api/qwaylandpointer.cpp \ + compositor_api/qwaylandtouch.cpp \ compositor_api/qwaylandinputpanel.cpp \ compositor_api/qwaylandoutput.cpp \ compositor_api/qwaylanddrag.cpp \ compositor_api/qwaylandbufferref.cpp \ compositor_api/qwaylandsurfaceview.cpp \ - compositor_api/qwaylandoutputspace.cpp + compositor_api/qwaylandoutputspace.cpp \ + compositor_api/qwaylanddestroylistener.cpp \ QT += core-private diff --git a/src/compositor/compositor_api/qwaylandcompositor.cpp b/src/compositor/compositor_api/qwaylandcompositor.cpp index cc1826fc7..ff4a12ab4 100644 --- a/src/compositor/compositor_api/qwaylandcompositor.cpp +++ b/src/compositor/compositor_api/qwaylandcompositor.cpp @@ -42,6 +42,9 @@ #include "qwaylandoutput.h" #include "qwaylandsurfaceview.h" #include "qwaylandclient.h" +#include "qwaylandkeyboard.h" +#include "qwaylandpointer.h" +#include "qwaylandtouch.h" #include "wayland_wrapper/qwlcompositor_p.h" #include "wayland_wrapper/qwldatadevice_p.h" @@ -115,6 +118,11 @@ struct wl_display *QWaylandCompositor::waylandDisplay() const return m_compositor->wl_display(); } +uint32_t QWaylandCompositor::nextSerial() +{ + return wl_display_next_serial(waylandDisplay()); +} + void QWaylandCompositor::destroyClientForSurface(QWaylandSurface *surface) { destroyClient(surface->client()); @@ -170,6 +178,11 @@ void QWaylandCompositor::removeOutputSpace(QWaylandOutputSpace *outputSpace) m_compositor->removeOutputSpace(outputSpace); } +uint QWaylandCompositor::currentTimeMsecs() const +{ + return m_compositor->currentTimeMsecs(); +} + QWaylandOutput *QWaylandCompositor::createOutput(QWaylandOutputSpace *outputSpace, QWindow *window, const QString &manufacturer, @@ -193,15 +206,24 @@ QWaylandSurfaceView *QWaylandCompositor::createView() return new QWaylandSurfaceView(); } -/*! - Override this to handle QDesktopServices::openUrl() requests from the clients. +QWaylandInputDevice *QWaylandCompositor::createInputDevice() +{ + return new QWaylandInputDevice(this); +} - The default implementation simply forwards the request to QDesktopServices::openUrl(). -*/ -bool QWaylandCompositor::openUrl(QWaylandClient *client, const QUrl &url) +QWaylandPointer *QWaylandCompositor::createPointerDevice(QWaylandInputDevice *inputDevice) { - Q_UNUSED(client); - return QDesktopServices::openUrl(url); + return new QWaylandPointer(inputDevice); +} + +QWaylandKeyboard *QWaylandCompositor::createKeyboardDevice(QWaylandInputDevice *inputDevice) +{ + return new QWaylandKeyboard(inputDevice); +} + +QWaylandTouch *QWaylandCompositor::createTouchDevice(QWaylandInputDevice *inputDevice) +{ + return new QWaylandTouch(inputDevice); } QtWayland::Compositor * QWaylandCompositor::handle() const @@ -228,11 +250,6 @@ void QWaylandCompositor::overrideSelection(const QMimeData *data) m_compositor->overrideSelection(data); } -void QWaylandCompositor::setClientFullScreenHint(bool value) -{ - m_compositor->setClientFullScreenHint(value); -} - #if QT_DEPRECATED_SINCE(5, 5) /*! Set the screen orientation based on accelerometer data or similar. @@ -296,12 +313,12 @@ int QWaylandCompositor::outputRefreshRate() const QWaylandInputDevice *QWaylandCompositor::defaultInputDevice() const { - return m_compositor->defaultInputDevice()->handle(); + return m_compositor->defaultInputDevice(); } QWaylandDrag *QWaylandCompositor::drag() const { - return m_compositor->defaultInputDevice()->dragHandle(); + return m_compositor->defaultInputDevice()->drag(); } bool QWaylandCompositor::isDragging() const diff --git a/src/compositor/compositor_api/qwaylandcompositor.h b/src/compositor/compositor_api/qwaylandcompositor.h index 984624383..f22468239 100644 --- a/src/compositor/compositor_api/qwaylandcompositor.h +++ b/src/compositor/compositor_api/qwaylandcompositor.h @@ -61,6 +61,9 @@ class QWaylandGlobalInterface; class QWaylandSurfaceView; class QWaylandOutput; class QWaylandOutputSpace; +class QWaylandPointer; +class QWaylandKeyboard; +class QWaylandTouch; namespace QtWayland { @@ -104,6 +107,7 @@ public: ExtensionFlags extensionFlags() const; ::wl_display *waylandDisplay() const; + uint32_t nextSerial(); Q_INVOKABLE void destroyClientForSurface(QWaylandSurface *surface); Q_INVOKABLE void destroyClient(QWaylandClient *client); @@ -119,7 +123,7 @@ public: void addOutputSpace(QWaylandOutputSpace *outputSpace); void removeOutputSpace(QWaylandOutputSpace *outputSpace); - virtual bool openUrl(QWaylandClient *client, const QUrl &url); + uint currentTimeMsecs() const; QtWayland::Compositor *handle() const; @@ -127,8 +131,6 @@ public: bool retainedSelectionEnabled() const; void overrideSelection(const QMimeData *data); - void setClientFullScreenHint(bool value); - #if QT_DEPRECATED_SINCE(5, 5) void setScreenOrientation(Qt::ScreenOrientation orientation); @@ -176,6 +178,10 @@ protected: const QString &model); virtual QWaylandSurface *createSurface(QWaylandClient *client, quint32 id, int version); virtual QWaylandSurfaceView *createView(); + virtual QWaylandInputDevice *createInputDevice(); + virtual QWaylandPointer *createPointerDevice(QWaylandInputDevice *inputDevice); + virtual QWaylandKeyboard *createKeyboardDevice(QWaylandInputDevice *inputDevice); + virtual QWaylandTouch *createTouchDevice(QWaylandInputDevice *inputDevice); friend class QtWayland::Compositor; friend class QWaylandOutputSpacePrivate; diff --git a/src/compositor/compositor_api/qwaylanddestroylistener.cpp b/src/compositor/compositor_api/qwaylanddestroylistener.cpp new file mode 100644 index 000000000..13ec63849 --- /dev/null +++ b/src/compositor/compositor_api/qwaylanddestroylistener.cpp @@ -0,0 +1,72 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Jolla Ltd, author: +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the QtWaylandCompositor module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see http://www.qt.io/terms-conditions. For further +** information use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPLv3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qwaylanddestroylistener.h" +#include "qwaylanddestroylistener_p.h" + +QT_BEGIN_NAMESPACE + +QWaylandDestroyListenerPrivate::QWaylandDestroyListenerPrivate() +{ + listener.parent = this; + listener.listener.notify = handler; + wl_list_init(&listener.listener.link); +} + +QWaylandDestroyListener::QWaylandDestroyListener(QObject *parent) + : QObject(* new QWaylandDestroyListenerPrivate(), parent) +{ +} +void QWaylandDestroyListener::listenForDestruction(::wl_resource *resource) +{ + Q_D(QWaylandDestroyListener); + wl_resource_add_destroy_listener(resource, &d->listener.listener); +} + +void QWaylandDestroyListener::reset() +{ + Q_D(QWaylandDestroyListener); + wl_list_remove(&d->listener.listener.link); + wl_list_init(&d->listener.listener.link); +} + +void QWaylandDestroyListenerPrivate::handler(wl_listener *listener, void *data) +{ + QWaylandDestroyListenerPrivate *that = reinterpret_cast(listener)->parent; + emit that->q_func()->fired(data); +} + +QT_END_NAMESPACE diff --git a/src/compositor/compositor_api/qwaylanddestroylistener.h b/src/compositor/compositor_api/qwaylanddestroylistener.h new file mode 100644 index 000000000..6e141b828 --- /dev/null +++ b/src/compositor/compositor_api/qwaylanddestroylistener.h @@ -0,0 +1,64 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Jolla Ltd, author: +** Copyright (C) 2015 Digia Plc and/or its subsidi ary(-ies). +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the QtWaylandCompositor module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see http://www.qt.io/terms-conditions. For further +** information use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPLv3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QWAYLANDDESTROYLISTENER_H +#define QWAYLANDDESTROYLISTENER_H + +#include +#include + +QT_BEGIN_NAMESPACE + +class QWaylandDestroyListenerPrivate; + +class Q_COMPOSITOR_EXPORT QWaylandDestroyListener : public QObject +{ + Q_OBJECT + Q_DECLARE_PRIVATE(QWaylandDestroyListener) +public: + QWaylandDestroyListener(QObject *parent = 0); + void listenForDestruction(struct wl_resource *resource); + void reset(); + +Q_SIGNALS: + void fired(void *data); + +}; + +QT_END_NAMESPACE + +#endif /*QWAYLANDDESTROYLISTENER_H*/ diff --git a/src/compositor/compositor_api/qwaylanddestroylistener_p.h b/src/compositor/compositor_api/qwaylanddestroylistener_p.h new file mode 100644 index 000000000..7e9c43778 --- /dev/null +++ b/src/compositor/compositor_api/qwaylanddestroylistener_p.h @@ -0,0 +1,66 @@ +/**************************************************************************** +** +** Copyright (C) 2014 Jolla Ltd, author: +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the QtWaylandCompositor module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see http://www.qt.io/terms-conditions. For further +** information use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPLv3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QTWAYLAND_QWLLISTENER_H +#define QTWAYLAND_QWLLISTENER_H + +#include "qwaylanddestroylistener.h" + +#include + +#include + +QT_BEGIN_NAMESPACE + +class QWaylandDestroyListenerPrivate : public QObjectPrivate +{ +public: + Q_DECLARE_PUBLIC(QWaylandDestroyListener) + + QWaylandDestroyListenerPrivate(); + + static void handler(wl_listener *listener, void *data); + + struct Listener { + wl_listener listener; + QWaylandDestroyListenerPrivate *parent; + }; + Listener listener; +}; + +QT_END_NAMESPACE + +#endif diff --git a/src/compositor/compositor_api/qwaylanddrag.cpp b/src/compositor/compositor_api/qwaylanddrag.cpp index 281e64c2e..d3bae5a72 100644 --- a/src/compositor/compositor_api/qwaylanddrag.cpp +++ b/src/compositor/compositor_api/qwaylanddrag.cpp @@ -49,16 +49,16 @@ QT_BEGIN_NAMESPACE class QWaylandDragPrivate : public QObjectPrivate { public: - QWaylandDragPrivate(QtWayland::InputDevice *id) + QWaylandDragPrivate(QWaylandInputDevice *id) : inputDevice(id) { } - QtWayland::InputDevice *inputDevice; + QWaylandInputDevice *inputDevice; }; -QWaylandDrag::QWaylandDrag(QtWayland::InputDevice *inputDevice) +QWaylandDrag::QWaylandDrag(QWaylandInputDevice *inputDevice) : QObject(* new QWaylandDragPrivate(inputDevice)) { } @@ -67,7 +67,7 @@ QWaylandSurfaceView *QWaylandDrag::icon() const { Q_D(const QWaylandDrag); - const QtWayland::DataDevice *dataDevice = d->inputDevice->dataDevice(); + const QtWayland::DataDevice *dataDevice = QWaylandInputDevicePrivate::get(d->inputDevice)->dataDevice(); if (!dataDevice) return 0; @@ -78,7 +78,7 @@ bool QWaylandDrag::visible() const { Q_D(const QWaylandDrag); - const QtWayland::DataDevice *dataDevice = d->inputDevice->dataDevice(); + const QtWayland::DataDevice *dataDevice = QWaylandInputDevicePrivate::get(d->inputDevice)->dataDevice(); if (!dataDevice) return false; diff --git a/src/compositor/compositor_api/qwaylanddrag.h b/src/compositor/compositor_api/qwaylanddrag.h index 3fe34f48d..e4b7e8bfe 100644 --- a/src/compositor/compositor_api/qwaylanddrag.h +++ b/src/compositor/compositor_api/qwaylanddrag.h @@ -46,10 +46,8 @@ QT_BEGIN_NAMESPACE class QWaylandDragPrivate; class QWaylandSurface; class QWaylandSurfaceView; +class QWaylandInputDevice; -namespace QtWayland { -class InputDevice; -} class Q_COMPOSITOR_EXPORT QWaylandDrag : public QObject { Q_OBJECT @@ -59,7 +57,7 @@ class Q_COMPOSITOR_EXPORT QWaylandDrag : public QObject Q_PROPERTY(bool visible READ visible NOTIFY iconChanged) public: - explicit QWaylandDrag(QtWayland::InputDevice *inputDevice); + explicit QWaylandDrag(QWaylandInputDevice *inputDevice); QWaylandSurfaceView *icon() const; bool visible() const; diff --git a/src/compositor/compositor_api/qwaylandinput.cpp b/src/compositor/compositor_api/qwaylandinput.cpp index 34d4ac8ba..b2176c7f9 100644 --- a/src/compositor/compositor_api/qwaylandinput.cpp +++ b/src/compositor/compositor_api/qwaylandinput.cpp @@ -57,28 +57,24 @@ QWaylandKeymap::QWaylandKeymap(const QString &layout, const QString &variant, co QWaylandInputDevice::QWaylandInputDevice(QWaylandCompositor *compositor, CapabilityFlags caps) - : d(new QtWayland::InputDevice(this,compositor->handle(), caps)) + : QObject(*new QWaylandInputDevicePrivate(this,compositor, caps)) { } QWaylandInputDevice::~QWaylandInputDevice() { - delete d; } -void QWaylandInputDevice::sendMousePressEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos) +void QWaylandInputDevice::sendMousePressEvent(Qt::MouseButton button) { - d->sendMousePressEvent(button,localPos,globalPos); + Q_D(QWaylandInputDevice); + d->sendMousePressEvent(button); } -void QWaylandInputDevice::sendMouseReleaseEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos) +void QWaylandInputDevice::sendMouseReleaseEvent(Qt::MouseButton button) { - d->sendMouseReleaseEvent(button,localPos,globalPos); -} - -void QWaylandInputDevice::sendMouseMoveEvent(const QPointF &localPos, const QPointF &globalPos) -{ - d->sendMouseMoveEvent(localPos,globalPos); + Q_D(QWaylandInputDevice); + d->sendMouseReleaseEvent(button); } /** Convenience function that will set the mouse focus to the surface, then send the mouse move event. @@ -86,120 +82,130 @@ void QWaylandInputDevice::sendMouseMoveEvent(const QPointF &localPos, const QPoi **/ void QWaylandInputDevice::sendMouseMoveEvent(QWaylandSurfaceView *surface, const QPointF &localPos, const QPointF &globalPos) { + Q_D(QWaylandInputDevice); d->sendMouseMoveEvent(surface,localPos,globalPos); } void QWaylandInputDevice::sendMouseWheelEvent(Qt::Orientation orientation, int delta) { + Q_D(QWaylandInputDevice); d->sendMouseWheelEvent(orientation, delta); } -void QWaylandInputDevice::sendMouseEnterEvent(QWaylandSurfaceView *view, const QPointF &localPos) -{ - d->sendMouseEnterEvent(view,localPos); -} - -void QWaylandInputDevice::sendMouseLeaveEvent(QWaylandSurfaceView *view) +void QWaylandInputDevice::sendResetCurrentMouseView() { - d->sendMouseLeaveEvent(view); + Q_D(QWaylandInputDevice); + d->sendResetCurrentMouseView(); } void QWaylandInputDevice::sendKeyPressEvent(uint code) { - d->keyboardDevice()->sendKeyPressEvent(code); + keyboard()->sendKeyPressEvent(code); } void QWaylandInputDevice::sendKeyReleaseEvent(uint code) { - d->keyboardDevice()->sendKeyReleaseEvent(code); + keyboard()->sendKeyReleaseEvent(code); } -void QWaylandInputDevice::sendTouchPointEvent(int id, double x, double y, Qt::TouchPointState state) +void QWaylandInputDevice::sendTouchPointEvent(int id, const QPointF &point, Qt::TouchPointState state) { - d->sendTouchPointEvent(id,x,y,state); + Q_D(QWaylandInputDevice); + d->sendTouchPointEvent(id, point, state); } void QWaylandInputDevice::sendTouchFrameEvent() { + Q_D(QWaylandInputDevice); d->sendTouchFrameEvent(); } void QWaylandInputDevice::sendTouchCancelEvent() { + Q_D(QWaylandInputDevice); d->sendTouchCancelEvent(); } void QWaylandInputDevice::sendFullTouchEvent(QTouchEvent *event) { + Q_D(QWaylandInputDevice); d->sendFullTouchEvent(event); } void QWaylandInputDevice::sendFullKeyEvent(QKeyEvent *event) { + Q_D(QWaylandInputDevice); d->sendFullKeyEvent(event); } void QWaylandInputDevice::sendFullKeyEvent(QWaylandSurface *surface, QKeyEvent *event) { - d->sendFullKeyEvent(surface->handle(), event); + Q_D(QWaylandInputDevice); + d->sendFullKeyEvent(surface, event); +} + +QWaylandKeyboard *QWaylandInputDevice::keyboard() const +{ + Q_D(const QWaylandInputDevice); + return d->keyboardDevice(); } QWaylandSurface *QWaylandInputDevice::keyboardFocus() const { - QtWayland::Surface *wlsurface = d->keyboardFocus(); - if (wlsurface) - return wlsurface->waylandSurface(); - return 0; + Q_D(const QWaylandInputDevice); + QWaylandSurface *surface = d->keyboardFocus(); + return surface; } bool QWaylandInputDevice::setKeyboardFocus(QWaylandSurface *surface) { - QtWayland::Surface *wlsurface = surface?surface->handle():0; - return d->setKeyboardFocus(wlsurface); + Q_D(QWaylandInputDevice); + return d->setKeyboardFocus(surface); } void QWaylandInputDevice::setKeymap(const QWaylandKeymap &keymap) { - if (handle()->keyboardDevice()) - handle()->keyboardDevice()->setKeymap(keymap); + if (keyboard()) + keyboard()->setKeymap(keymap); } QWaylandSurfaceView *QWaylandInputDevice::mouseFocus() const { + Q_D(const QWaylandInputDevice); return d->mouseFocus(); } -void QWaylandInputDevice::setMouseFocus(QWaylandSurfaceView *surface, const QPointF &localPos, const QPointF &globalPos) -{ - d->setMouseFocus(surface,localPos,globalPos); -} - QWaylandOutputSpace *QWaylandInputDevice::outputSpace() const { + Q_D(const QWaylandInputDevice); return d->outputSpace(); } void QWaylandInputDevice::setOutputSpace(QWaylandOutputSpace *outputSpace) { + Q_D(QWaylandInputDevice); d->setOutputSpace(outputSpace); } QWaylandCompositor *QWaylandInputDevice::compositor() const { - return d->compositor()->waylandCompositor(); + Q_D(const QWaylandInputDevice); + return d->compositor(); } -QtWayland::InputDevice *QWaylandInputDevice::handle() const +QWaylandDrag *QWaylandInputDevice::drag() const { - return d; + Q_D(const QWaylandInputDevice); + return d->dragHandle(); } -QWaylandInputDevice::CapabilityFlags QWaylandInputDevice::capabilities() +QWaylandInputDevice::CapabilityFlags QWaylandInputDevice::capabilities() const { + Q_D(const QWaylandInputDevice); return d->capabilities(); } -bool QWaylandInputDevice::isOwner(QInputEvent *inputEvent) +bool QWaylandInputDevice::isOwner(QInputEvent *inputEvent) const { Q_UNUSED(inputEvent); return true; diff --git a/src/compositor/compositor_api/qwaylandinput.h b/src/compositor/compositor_api/qwaylandinput.h index 013f6d789..84a630f4a 100644 --- a/src/compositor/compositor_api/qwaylandinput.h +++ b/src/compositor/compositor_api/qwaylandinput.h @@ -42,6 +42,8 @@ #include #include +#include +#include QT_BEGIN_NAMESPACE @@ -52,6 +54,11 @@ class QTouchEvent; class QWaylandSurfaceView; class QInputEvent; class QWaylandOutputSpace; +class QWaylandInputDevicePrivate; +class QWaylandDrag; +class QWaylandKeyboard; +class QWaylandPointer; +class QWaylandTouch; namespace QtWayland { class InputDevice; @@ -77,8 +84,10 @@ private: QString m_model; }; -class Q_COMPOSITOR_EXPORT QWaylandInputDevice +class Q_COMPOSITOR_EXPORT QWaylandInputDevice : public QObject, public QWaylandExtensionContainer { + Q_OBJECT + Q_DECLARE_PRIVATE(QWaylandInputDevice) public: enum CapabilityFlag { // The order should match the enum WL_SEAT_CAPABILITY_* @@ -93,13 +102,11 @@ public: QWaylandInputDevice(QWaylandCompositor *compositor, CapabilityFlags caps = DefaultCapabilities); virtual ~QWaylandInputDevice(); - void sendMousePressEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos = QPointF()); - void sendMouseReleaseEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos = QPointF()); - void sendMouseMoveEvent(const QPointF &localPos, const QPointF &globalPos = QPointF()); + void sendMousePressEvent(Qt::MouseButton button); + void sendMouseReleaseEvent(Qt::MouseButton button); void sendMouseMoveEvent(QWaylandSurfaceView *surface , const QPointF &localPos, const QPointF &globalPos = QPointF()); void sendMouseWheelEvent(Qt::Orientation orientation, int delta); - void sendMouseEnterEvent(QWaylandSurfaceView *view, const QPointF &localPos); - void sendMouseLeaveEvent(QWaylandSurfaceView *view); + void sendResetCurrentMouseView(); void sendKeyPressEvent(uint code); void sendKeyReleaseEvent(uint code); @@ -107,32 +114,37 @@ public: void sendFullKeyEvent(QKeyEvent *event); void sendFullKeyEvent(QWaylandSurface *surface, QKeyEvent *event); - void sendTouchPointEvent(int id, double x, double y, Qt::TouchPointState state); + void sendTouchPointEvent(int id, const QPointF &point, Qt::TouchPointState state); void sendTouchFrameEvent(); void sendTouchCancelEvent(); void sendFullTouchEvent(QTouchEvent *event); + QWaylandPointer *pointer() const; + + QWaylandSurfaceView *mouseFocus() const; + void setMouseFocus(QWaylandSurfaceView *view); + + QWaylandKeyboard *keyboard() const; QWaylandSurface *keyboardFocus() const; bool setKeyboardFocus(QWaylandSurface *surface); void setKeymap(const QWaylandKeymap &keymap); - QWaylandSurfaceView *mouseFocus() const; - void setMouseFocus(QWaylandSurfaceView *surface, const QPointF &local_pos, const QPointF &global_pos = QPointF()); + QWaylandTouch *touch() const; QWaylandOutputSpace *outputSpace() const; void setOutputSpace(QWaylandOutputSpace *outputSpace); QWaylandCompositor *compositor() const; - QtWayland::InputDevice *handle() const; - QWaylandInputDevice::CapabilityFlags capabilities(); + QWaylandDrag *drag() const; - virtual bool isOwner(QInputEvent *inputEvent); + QWaylandInputDevice::CapabilityFlags capabilities() const; -private: - QtWayland::InputDevice *d; - Q_DISABLE_COPY(QWaylandInputDevice) + virtual bool isOwner(QInputEvent *inputEvent) const; + +Q_SIGNALS: + void mouseFocusChanged(); }; Q_DECLARE_OPERATORS_FOR_FLAGS(QWaylandInputDevice::CapabilityFlags) diff --git a/src/compositor/compositor_api/qwaylandkeyboard.cpp b/src/compositor/compositor_api/qwaylandkeyboard.cpp new file mode 100644 index 000000000..be828cd63 --- /dev/null +++ b/src/compositor/compositor_api/qwaylandkeyboard.cpp @@ -0,0 +1,111 @@ +/**************************************************************************** +** +** Copyright (C) 2015 Digia Plc and/or its subsidi ary(-ies). +** Copyright (C) 2013 Klarälvdalens Datakonsult AB (KDAB). +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the QtWaylandCompositor module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see http://www.qt.io/terms-conditions. For further +** information use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPLv3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qwaylandkeyboard.h" +#include "qwlkeyboard_p.h" +#include +#include + +QT_BEGIN_NAMESPACE + +QWaylandKeyboardGrabber::~QWaylandKeyboardGrabber() +{ +} + +QWaylandKeyboard::QWaylandKeyboard(QWaylandInputDevice *seat, QObject *parent) + : QObject(* new QWaylandKeyboardPrivate(seat), parent) +{ + Q_D(QWaylandKeyboard); + connect(&d->m_focusDestroyListener, &QWaylandDestroyListener::fired, this, &QWaylandKeyboard::focusDestroyed); +} + +void QWaylandKeyboard::focusDestroyed(void *data) +{ + Q_UNUSED(data); + Q_D(QWaylandKeyboard); + d->m_focusDestroyListener.reset(); + + d->m_focus = 0; + d->m_focusResource = 0; +} + +QWaylandClient *QWaylandKeyboard::focusClient() const +{ + Q_D(const QWaylandKeyboard); + if (!d->focusResource()) + return Q_NULLPTR; + return QWaylandClient::fromWlClient(d->focusResource()->client()); +} + +void QWaylandKeyboard::sendKeyModifiers(QWaylandClient *client, uint serial) +{ + Q_D(QWaylandKeyboard); + QtWaylandServer::wl_keyboard::Resource *resource = d->resourceMap().value(client->client()); + if (resource) + d->sendKeyModifiers(resource, serial); +} +void QWaylandKeyboard::sendKeyPressEvent(uint code) +{ + Q_D(QWaylandKeyboard); + d->sendKeyPressEvent(code); +} + +void QWaylandKeyboard::sendKeyReleaseEvent(uint code) +{ + Q_D(QWaylandKeyboard); + d->sendKeyReleaseEvent(code); +} + +QWaylandSurface *QWaylandKeyboard::focus() const +{ + Q_D(const QWaylandKeyboard); + return d->focus(); +} + +void QWaylandKeyboard::setFocus(QWaylandSurface *surface) +{ + Q_D(QWaylandKeyboard); + d->setFocus(surface); +} + +void QWaylandKeyboard::setKeymap(const QWaylandKeymap &keymap) +{ + Q_D(QWaylandKeyboard); + d->setKeymap(keymap); +} + +QT_END_NAMESPACE diff --git a/src/compositor/compositor_api/qwaylandkeyboard.h b/src/compositor/compositor_api/qwaylandkeyboard.h new file mode 100644 index 000000000..53e207379 --- /dev/null +++ b/src/compositor/compositor_api/qwaylandkeyboard.h @@ -0,0 +1,113 @@ +/**************************************************************************** +** +** Copyright (C) 2015 Digia Plc and/or its subsidi ary(-ies). +** Copyright (C) 2013 Klarälvdalens Datakonsult AB (KDAB). +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the QtWaylandCompositor module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see http://www.qt.io/terms-conditions. For further +** information use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPLv3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QWAYLANDKEYBOARD_H +#define QWAYLANDKEYBOARD_H + +#include + +#include +#include + +QT_BEGIN_NAMESPACE + +class QWaylandKeyboard; +class QWaylandKeyboardPrivate; +class QWaylandInputDevice; + +class Q_COMPOSITOR_EXPORT QWaylandKeyboardGrabber { +public: + virtual ~QWaylandKeyboardGrabber(); + virtual void focused(QWaylandSurface *surface) = 0; + virtual void key(uint32_t serial, uint32_t time, uint32_t key, uint32_t state) = 0; + virtual void modifiers(uint32_t serial, uint32_t mods_depressed, + uint32_t mods_latched, uint32_t mods_locked, uint32_t group) = 0; + + QWaylandKeyboard *m_keyboard; +}; + +class Q_COMPOSITOR_EXPORT QWaylandKeymap +{ +public: + QWaylandKeymap(const QString &layout = QLatin1String("us"), const QString &variant = QString(), const QString &options = QString(), + const QString &model = QLatin1String("pc105"), const QString &rules = QLatin1String("evdev")); + + inline QString layout() const { return m_layout; } + inline QString variant() const { return m_variant; } + inline QString options() const { return m_options; } + inline QString rules() const { return m_rules; } + inline QString model() const { return m_model; } + +private: + QString m_layout; + QString m_variant; + QString m_options; + QString m_rules; + QString m_model; +}; + +class Q_COMPOSITOR_EXPORT QWaylandKeyboard : public QObject, public QWaylandExtensionContainer +{ + Q_OBJECT + Q_DECLARE_PRIVATE(QWaylandKeyboard) + +public: + QWaylandKeyboard(QWaylandInputDevice *seat, QObject *parent = 0); + + void setFocus(QWaylandSurface *surface); + virtual void setKeymap(const QWaylandKeymap &keymap); + + virtual void sendKeyModifiers(QWaylandClient *client, uint32_t serial); + virtual void sendKeyPressEvent(uint code); + virtual void sendKeyReleaseEvent(uint code); + + QWaylandSurface *focus() const; + QWaylandClient *focusClient() const; + + void startGrab(QWaylandKeyboardGrabber *grab); + void endGrab(); + QWaylandKeyboardGrabber *currentGrab() const; + +Q_SIGNALS: + void focusChanged(QWaylandSurface *surface); +private: + void focusDestroyed(void *data); +}; + +QT_END_NAMESPACE + +#endif //QWAYLANDKEYBOARD_H diff --git a/src/compositor/compositor_api/qwaylandoutput.cpp b/src/compositor/compositor_api/qwaylandoutput.cpp index d94f38878..6cc7efbce 100644 --- a/src/compositor/compositor_api/qwaylandoutput.cpp +++ b/src/compositor/compositor_api/qwaylandoutput.cpp @@ -306,6 +306,11 @@ void QWaylandOutput::setHeight(int newHeight) d_ptr->setHeight(newHeight); } +QPointF QWaylandOutput::mapToOutputSpace(const QPointF &point) +{ + return point + d_ptr->topLeft(); +} + void QWaylandOutput::windowDestroyed() { delete this; diff --git a/src/compositor/compositor_api/qwaylandoutput.h b/src/compositor/compositor_api/qwaylandoutput.h index c602bf223..910507ab2 100644 --- a/src/compositor/compositor_api/qwaylandoutput.h +++ b/src/compositor/compositor_api/qwaylandoutput.h @@ -164,6 +164,8 @@ public: Q_INVOKABLE virtual QWaylandSurfaceView *pickView(const QPointF &outputPosition) const; Q_INVOKABLE virtual QPointF mapToView(QWaylandSurfaceView *view, const QPointF &surfacePosition) const; + Q_INVOKABLE QPointF mapToOutputSpace(const QPointF &point); + Q_SIGNALS: void positionChanged(); void geometryChanged(); diff --git a/src/compositor/compositor_api/qwaylandoutputspace.cpp b/src/compositor/compositor_api/qwaylandoutputspace.cpp index 3f78158d0..65497644d 100644 --- a/src/compositor/compositor_api/qwaylandoutputspace.cpp +++ b/src/compositor/compositor_api/qwaylandoutputspace.cpp @@ -188,4 +188,9 @@ QPointF QWaylandOutputSpace::mapToView(QWaylandSurfaceView *view, const QPointF return globalPosition - (view->requestedPosition() + view->output()->geometry().topLeft()); } +QPointF QWaylandOutputSpace::mapToSpace(QWaylandSurfaceView *view, const QPointF &local) const +{ + return local + view->requestedPosition() + view->output()->geometry().topLeft(); +} + QT_END_NAMESPACE diff --git a/src/compositor/compositor_api/qwaylandoutputspace.h b/src/compositor/compositor_api/qwaylandoutputspace.h index d8c40cf0c..c06ba3681 100644 --- a/src/compositor/compositor_api/qwaylandoutputspace.h +++ b/src/compositor/compositor_api/qwaylandoutputspace.h @@ -86,7 +86,8 @@ public: Q_INVOKABLE QListoutputs(const QPoint &point) const; Q_INVOKABLE QWaylandSurfaceView *pickView(const QPointF &globalPosition) const; - Q_INVOKABLE QPointF mapToView(QWaylandSurfaceView *view, const QPointF &surfacePosition) const; + Q_INVOKABLE QPointF mapToView(QWaylandSurfaceView *view, const QPointF &spacePoint) const; + Q_INVOKABLE QPointF mapToSpace(QWaylandSurfaceView *view, const QPointF &local) const; signals: void surfaceRequestedPositionChanged(QWaylandSurface *surface, const QPointF &point); diff --git a/src/compositor/compositor_api/qwaylandpointer.cpp b/src/compositor/compositor_api/qwaylandpointer.cpp new file mode 100644 index 000000000..07f327adf --- /dev/null +++ b/src/compositor/compositor_api/qwaylandpointer.cpp @@ -0,0 +1,257 @@ +/**************************************************************************** +** +** Copyright (C) 2015 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the QtWaylandCompositor module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see http://www.qt.io/terms-conditions. For further +** information use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPLv3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qwaylandpointer.h" +#include "qwlpointer_p.h" +#include +#include + +QT_BEGIN_NAMESPACE + +QWaylandPointerGrabber::~QWaylandPointerGrabber() +{ +} + +QWaylandPointer::QWaylandPointer(QWaylandInputDevice *seat, QObject *parent) + : QObject(* new QWaylandPointerPrivate(this, seat), parent) +{ + connect(&d_func()->m_focusDestroyListener, &QWaylandDestroyListener::fired, this, &QWaylandPointer::focusDestroyed); +} + +void QWaylandDefaultPointerGrabber::focus() +{ +// if (buttonPressed()) +// return; +// +// setFocus(m_currentPosition.view(), m_currentPosition.position()); +} + +void QWaylandDefaultPointerGrabber::motion(uint32_t time) +{ + struct wl_resource *focusResource = pointer->focusResource(); + if (focusResource) { + wl_fixed_t x = wl_fixed_from_double(pointer->currentLocalPosition().x()); + wl_fixed_t y = wl_fixed_from_double(pointer->currentLocalPosition().y()); + wl_pointer_send_motion(focusResource, time, x, y); + } +} + +void QWaylandDefaultPointerGrabber::button(uint32_t time, Qt::MouseButton button, uint32_t state) +{ + struct wl_resource *focusResource = pointer->focusResource(); + if (focusResource) { + pointer->sendButton(focusResource, time, button, state); + } +} + +QWaylandInputDevice *QWaylandPointer::inputDevice() const +{ + Q_D(const QWaylandPointer); + return d->seat(); +} + +QWaylandCompositor *QWaylandPointer::compositor() const +{ + Q_D(const QWaylandPointer); + return d->seat()->compositor(); +} + +QWaylandOutput *QWaylandPointer::output() const +{ + Q_D(const QWaylandPointer); + return d->output(); +} + +void QWaylandPointer::setOutput(QWaylandOutput *output) +{ + Q_D(QWaylandPointer); + d->setOutput(output); +} + +void QWaylandPointer::startGrab(QWaylandPointerGrabber *currentGrab) +{ + Q_D(QWaylandPointer); + d->startGrab(currentGrab); +} + +void QWaylandPointer::endGrab() +{ + Q_D(QWaylandPointer); + d->endGrab(); +} + +QWaylandPointerGrabber *QWaylandPointer::currentGrab() const +{ + Q_D(const QWaylandPointer); + return d->currentGrab(); +} + +Qt::MouseButton QWaylandPointer::grabButton() const +{ + Q_D(const QWaylandPointer); + return d->grabButton(); +} + +uint32_t QWaylandPointer::grabTime() const +{ + Q_D(const QWaylandPointer); + return d->grabTime(); + +} + +uint32_t QWaylandPointer::grabSerial() const +{ + Q_D(const QWaylandPointer); + return d->grabSerial(); +} + +void QWaylandPointer::sendMousePressEvent(Qt::MouseButton button) +{ + Q_D(QWaylandPointer); + d->sendMousePressEvent(button); +} +void QWaylandPointer::sendMouseReleaseEvent(Qt::MouseButton button) +{ + Q_D(QWaylandPointer); + d->sendMouseReleaseEvent(button); +} +void QWaylandPointer::sendMouseMoveEvent(QWaylandSurfaceView *view, const QPointF &localPos, const QPointF &outputSpacePos) +{ + Q_D(QWaylandPointer); + d->sendMouseMoveEvent(view, localPos, outputSpacePos); +} + +void QWaylandPointer::sendMouseWheelEvent(Qt::Orientation orientation, int delta) +{ + Q_D(QWaylandPointer); + d->sendMouseWheelEvent(orientation, delta); +} + +void QWaylandPointer::resetCurrentView() +{ + Q_D(QWaylandPointer); + d->resetCurrentState(); +} + +QWaylandSurfaceView *QWaylandPointer::currentView() const +{ + Q_D(const QWaylandPointer); + return d->focusView(); +} + +QPointF QWaylandPointer::currentLocalPosition() const +{ + Q_D(const QWaylandPointer); + return d->currentLocalPosition(); +} + +QPointF QWaylandPointer::currentSpacePosition() const +{ + Q_D(const QWaylandPointer); + return d->currentSpacePosition(); +} + +bool QWaylandPointer::isButtonPressed() const +{ + Q_D(const QWaylandPointer); + return d->buttonPressed(); +} + +void QWaylandPointer::addClient(QWaylandClient *client, uint32_t id) +{ + Q_D(QWaylandPointer); + d->add(client->client(), id, QtWaylandServer::wl_pointer::interfaceVersion()); +} + +struct wl_resource *QWaylandPointer::focusResource() const +{ + Q_D(const QWaylandPointer); + if (!d->focusResource()) + return Q_NULLPTR; + + return d->focusResource()->handle; +} + +void QWaylandPointer::sendButton(struct wl_resource *resource, uint32_t time, Qt::MouseButton button, uint32_t state) +{ + Q_D(QWaylandPointer); + uint32_t serial = compositor()->nextSerial(); + d->send_button(resource, serial, time, toWaylandButton(button), state); +} + +uint32_t QWaylandPointer::toWaylandButton(Qt::MouseButton button) +{ +#ifndef BTN_LEFT + uint32_t BTN_LEFT = 0x110; +#endif + // the range of valid buttons (evdev module) is from 0x110 + // through 0x11f. 0x120 is the first 'Joystick' button. + switch (button) { + case Qt::LeftButton: return BTN_LEFT; + case Qt::RightButton: return uint32_t(0x111); + case Qt::MiddleButton: return uint32_t(0x112); + case Qt::ExtraButton1: return uint32_t(0x113); // AKA Qt::BackButton, Qt::XButton1 + case Qt::ExtraButton2: return uint32_t(0x114); // AKA Qt::ForwardButton, Qt::XButton2 + case Qt::ExtraButton3: return uint32_t(0x115); + case Qt::ExtraButton4: return uint32_t(0x116); + case Qt::ExtraButton5: return uint32_t(0x117); + case Qt::ExtraButton6: return uint32_t(0x118); + case Qt::ExtraButton7: return uint32_t(0x119); + case Qt::ExtraButton8: return uint32_t(0x11a); + case Qt::ExtraButton9: return uint32_t(0x11b); + case Qt::ExtraButton10: return uint32_t(0x11c); + case Qt::ExtraButton11: return uint32_t(0x11d); + case Qt::ExtraButton12: return uint32_t(0x11e); + case Qt::ExtraButton13: return uint32_t(0x11f); + // default should not occur; but if it does, then return Wayland's highest possible button number. + default: return uint32_t(0x11f); + } +} + +void QWaylandPointer::focusDestroyed(void *data) +{ + Q_D(QWaylandPointer); + Q_UNUSED(data) + d->m_focusDestroyListener.reset(); + + d->m_currentPosition.reset(); + d->m_focusResource = 0; + d->m_buttonCount = 0; + endGrab(); +} + +QT_END_NAMESPACE + diff --git a/src/compositor/compositor_api/qwaylandpointer.h b/src/compositor/compositor_api/qwaylandpointer.h new file mode 100644 index 000000000..a11140733 --- /dev/null +++ b/src/compositor/compositor_api/qwaylandpointer.h @@ -0,0 +1,131 @@ +/**************************************************************************** +** +** Copyright (C) 2015 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the QtWaylandCompositor module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see http://www.qt.io/terms-conditions. For further +** information use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPLv3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QWAYLANDPOINTER_H +#define QWAYLANDPOINTER_H + +#include + +QT_BEGIN_NAMESPACE + +class QWaylandPointer; +class QWaylandPointerPrivate; +class QWaylandInputDevice; +class QWaylandSurfaceView; +class QWaylandOutput; +class QWaylandClient; + +class Q_COMPOSITOR_EXPORT QWaylandPointerGrabber +{ +public: + QWaylandPointerGrabber() + : pointer(Q_NULLPTR) + {} + virtual ~QWaylandPointerGrabber(); + + virtual void focus() = 0; + virtual void motion(uint32_t time) = 0; + virtual void button(uint32_t time, Qt::MouseButton button, uint32_t state) = 0; + + QWaylandPointer *pointer; +}; + +class Q_COMPOSITOR_EXPORT QWaylandDefaultPointerGrabber : public QWaylandPointerGrabber +{ +public: + QWaylandDefaultPointerGrabber() + : QWaylandPointerGrabber() + {} + QWaylandDefaultPointerGrabber(QWaylandPointer *pointer) + : QWaylandPointerGrabber() + { this->pointer = pointer; } + + void focus() Q_DECL_OVERRIDE; + void motion(uint32_t time) Q_DECL_OVERRIDE; + void button(uint32_t time, Qt::MouseButton button, uint32_t state) Q_DECL_OVERRIDE; +}; +class Q_COMPOSITOR_EXPORT QWaylandPointer : public QObject, public QWaylandExtensionContainer +{ + Q_OBJECT + Q_DECLARE_PRIVATE(QWaylandPointer) + Q_PROPERTY(bool isButtonPressed READ isButtonPressed NOTIFY buttonPressedChanged) +public: + QWaylandPointer(QWaylandInputDevice *seat, QObject *parent = 0); + + QWaylandInputDevice *inputDevice() const; + QWaylandCompositor *compositor() const; + + QWaylandOutput *output() const; + void setOutput(QWaylandOutput *output); + + void startGrab(QWaylandPointerGrabber *currentGrab); + void endGrab(); + QWaylandPointerGrabber *currentGrab() const; + Qt::MouseButton grabButton() const; + + uint32_t grabTime() const; + uint32_t grabSerial() const; + + virtual void sendMousePressEvent(Qt::MouseButton button); + virtual void sendMouseReleaseEvent(Qt::MouseButton button); + virtual void sendMouseMoveEvent(QWaylandSurfaceView *view, const QPointF &localPos, const QPointF &outputSpacePos); + virtual void sendMouseWheelEvent(Qt::Orientation orientation, int delta); + + void resetCurrentView(); + QWaylandSurfaceView *currentView() const; + QPointF currentLocalPosition() const; + QPointF currentSpacePosition() const; + + bool isButtonPressed() const; + + void addClient(QWaylandClient *client, uint32_t id); + + struct wl_resource *focusResource() const; + + static uint32_t toWaylandButton(Qt::MouseButton button); + void sendButton(struct wl_resource *resource, uint32_t time, Qt::MouseButton button, uint32_t state); +Q_SIGNALS: + void outputChanged(); + void buttonPressedChanged(); + +private: + void focusDestroyed(void *data); + void pointerFocusChanged(); +}; + +QT_END_NAMESPACE + +#endif /*QWAYLANDPOINTER_H*/ diff --git a/src/compositor/compositor_api/qwaylandsurface.cpp b/src/compositor/compositor_api/qwaylandsurface.cpp index cc463d08a..caf816353 100644 --- a/src/compositor/compositor_api/qwaylandsurface.cpp +++ b/src/compositor/compositor_api/qwaylandsurface.cpp @@ -300,6 +300,18 @@ void QWaylandSurface::leave(QWaylandOutput *output) d->send_leave(outputResource->handle); } +void QWaylandSurface::markAsCursorSurface(bool cursorSurface) +{ + Q_D(QWaylandSurface); + d->setCursorSurface(cursorSurface); +} + +bool QWaylandSurface::isCursorSurface() const +{ + Q_D(const QWaylandSurface); + return d->isCursorSurface(); +} + /*! Updates the surface with the compositor's retained clipboard selection. While this is done automatically when the surface receives keyboard focus, this function is @@ -308,9 +320,9 @@ void QWaylandSurface::leave(QWaylandOutput *output) void QWaylandSurface::updateSelection() { Q_D(QWaylandSurface); - const QtWayland::InputDevice *inputDevice = d->compositor()->defaultInputDevice(); + QWaylandInputDevice *inputDevice = d->compositor()->defaultInputDevice(); if (inputDevice) { - const QtWayland::DataDevice *dataDevice = inputDevice->dataDevice(); + const QtWayland::DataDevice *dataDevice = QWaylandInputDevicePrivate::get(inputDevice)->dataDevice(); if (dataDevice) { d->compositor()->dataDeviceManager()->offerRetainedSelection( dataDevice->resourceMap().value(d->resource()->client())->handle); @@ -351,6 +363,12 @@ QWaylandSurface *QWaylandSurface::fromResource(::wl_resource *res) return Q_NULLPTR; } +struct wl_resource *QWaylandSurface::resource() const +{ + Q_D(const QWaylandSurface); + return d->resource()->handle; +} + QWaylandSurfacePrivate *QWaylandSurfacePrivate::get(QWaylandSurface *surface) { return surface ? surface->d_func() : Q_NULLPTR; diff --git a/src/compositor/compositor_api/qwaylandsurface.h b/src/compositor/compositor_api/qwaylandsurface.h index 96be55f7d..c84aee05a 100644 --- a/src/compositor/compositor_api/qwaylandsurface.h +++ b/src/compositor/compositor_api/qwaylandsurface.h @@ -169,10 +169,14 @@ public: QList views() const; static QWaylandSurface *fromResource(::wl_resource *resource); + struct wl_resource *resource() const; void enter(QWaylandOutput *output); void leave(QWaylandOutput *output); + void markAsCursorSurface(bool cursorSurface); + bool isCursorSurface() const; + public Q_SLOTS: void updateSelection(); diff --git a/src/compositor/compositor_api/qwaylandsurfaceitem.cpp b/src/compositor/compositor_api/qwaylandsurfaceitem.cpp index 3b0ec3a3e..b174961d9 100644 --- a/src/compositor/compositor_api/qwaylandsurfaceitem.cpp +++ b/src/compositor/compositor_api/qwaylandsurfaceitem.cpp @@ -192,9 +192,7 @@ void QWaylandSurfaceItem::mousePressEvent(QMouseEvent *event) } QWaylandInputDevice *inputDevice = compositor()->inputDeviceFor(event); - if (inputDevice->mouseFocus() != this) - inputDevice->setMouseFocus(this, event->localPos(), event->windowPos()); - inputDevice->sendMousePressEvent(event->button(), event->localPos(), event->windowPos()); + inputDevice->sendMousePressEvent(event->button()); } void QWaylandSurfaceItem::mouseMoveEvent(QMouseEvent *event) @@ -211,7 +209,7 @@ void QWaylandSurfaceItem::mouseReleaseEvent(QMouseEvent *event) { if (shouldSendInputEvents()) { QWaylandInputDevice *inputDevice = compositor()->inputDeviceFor(event); - inputDevice->sendMouseReleaseEvent(event->button(), event->localPos(), event->windowPos()); + inputDevice->sendMouseReleaseEvent(event->button()); } else { event->ignore(); } @@ -226,7 +224,7 @@ void QWaylandSurfaceItem::hoverEnterEvent(QHoverEvent *event) } if (shouldSendInputEvents()) { QWaylandInputDevice *inputDevice = compositor()->inputDeviceFor(event); - inputDevice->sendMouseEnterEvent(this, event->pos()); + inputDevice->sendMouseMoveEvent(this, event->pos(), QPoint()); } else { event->ignore(); } @@ -251,7 +249,7 @@ void QWaylandSurfaceItem::hoverLeaveEvent(QHoverEvent *event) { if (shouldSendInputEvents()) { QWaylandInputDevice *inputDevice = compositor()->inputDeviceFor(event); - inputDevice->sendMouseLeaveEvent(this); + inputDevice->sendResetCurrentMouseView(); } else { event->ignore(); } @@ -315,7 +313,7 @@ void QWaylandSurfaceItem::touchEvent(QTouchEvent *event) event->accept(); if (inputDevice->mouseFocus() != this) { - inputDevice->setMouseFocus(this, pointPos, pointPos); + inputDevice->sendMouseMoveEvent(this, pointPos, QPointF()); } inputDevice->sendFullTouchEvent(event); } else { diff --git a/src/compositor/compositor_api/qwaylandsurfaceview.cpp b/src/compositor/compositor_api/qwaylandsurfaceview.cpp index cfb9aa2ea..545532590 100644 --- a/src/compositor/compositor_api/qwaylandsurfaceview.cpp +++ b/src/compositor/compositor_api/qwaylandsurfaceview.cpp @@ -185,6 +185,13 @@ void QWaylandSurfaceView::setBroadcastRequestedPositionChanged(bool broadcast) d->broadcastRequestedPositionChanged = broadcast; } +struct wl_resource *QWaylandSurfaceView::surfaceResource() const +{ + if (!d->surface) + return Q_NULLPTR; + return d->surface->resource(); +} + void QWaylandSurfaceView::waylandSurfaceChanged(QWaylandSurface *newSurface, QWaylandSurface *oldSurface) { if (d->output) diff --git a/src/compositor/compositor_api/qwaylandsurfaceview.h b/src/compositor/compositor_api/qwaylandsurfaceview.h index 07e8e661c..231244454 100644 --- a/src/compositor/compositor_api/qwaylandsurfaceview.h +++ b/src/compositor/compositor_api/qwaylandsurfaceview.h @@ -74,6 +74,8 @@ public: bool broadcastRequestedPositionChanged() const; void setBroadcastRequestedPositionChanged(bool broadcast); + + struct wl_resource *surfaceResource() const; protected: virtual void waylandSurfaceChanged(QWaylandSurface *newSurface, QWaylandSurface *oldSurface); virtual void waylandSurfaceDestroyed(); diff --git a/src/compositor/extensions/extensions.pri b/src/compositor/extensions/extensions.pri index 070c319c2..526ded510 100644 --- a/src/compositor/extensions/extensions.pri +++ b/src/compositor/extensions/extensions.pri @@ -13,6 +13,7 @@ HEADERS += \ extensions/qwlqtkey_p.h \ extensions/qwlshellsurface_p.h \ extensions/qwaylandwindowmanagerextension.h \ + extensions/qwaylandwindowmanagerextension_p.h \ extensions/qwltextinput_p.h \ extensions/qwltextinputmanager_p.h \ extensions/qwlinputpanel_p.h \ diff --git a/src/compositor/extensions/qwaylandwindowmanagerextension.cpp b/src/compositor/extensions/qwaylandwindowmanagerextension.cpp index 160fb690f..58abd661d 100644 --- a/src/compositor/extensions/qwaylandwindowmanagerextension.cpp +++ b/src/compositor/extensions/qwaylandwindowmanagerextension.cpp @@ -35,64 +35,64 @@ ****************************************************************************/ #include "qwaylandwindowmanagerextension.h" +#include "qwaylandwindowmanagerextension_p.h" -#include -#include +#include +#include -#include -#include - -#include - -#include +#include QT_BEGIN_NAMESPACE -WindowManagerServerIntegration::WindowManagerServerIntegration(QWaylandCompositor *compositor, QObject *parent) - : QWaylandExtension(compositor) - , QtWaylandServer::qt_windowmanager() - , m_showIsFullScreen(false) - , m_compositor(compositor) -{ -} - -WindowManagerServerIntegration::~WindowManagerServerIntegration() +QWaylandWindowManagerExtension::QWaylandWindowManagerExtension(QWaylandCompositor *compositor, QObject *parent) + : QWaylandExtensionTemplate(*new QWaylandWindowManagerExtensionPrivate(compositor), parent) { } -void WindowManagerServerIntegration::initialize(QtWayland::Display *waylandDisplay) +QWaylandWindowManagerExtensionPrivate::QWaylandWindowManagerExtensionPrivate(QWaylandCompositor *compositor) + : QWaylandExtensionTemplatePrivateImpl(compositor) + , m_showIsFullScreen(false) + , m_compositor(compositor) { - init(waylandDisplay->handle(), 1); + init(compositor->waylandDisplay(), 1); } -void WindowManagerServerIntegration::setShowIsFullScreen(bool value) +void QWaylandWindowManagerExtension::setShowIsFullScreen(bool value) { - m_showIsFullScreen = value; - Q_FOREACH (Resource *resource, resourceMap().values()) { - send_hints(resource->handle, static_cast(m_showIsFullScreen)); + Q_D(QWaylandWindowManagerExtension); + d->m_showIsFullScreen = value; + Q_FOREACH (QWaylandWindowManagerExtensionPrivate::Resource *resource, d->resourceMap().values()) { + d->send_hints(resource->handle, static_cast(d->m_showIsFullScreen)); } } -void WindowManagerServerIntegration::sendQuitMessage(wl_client *client) +void QWaylandWindowManagerExtension::sendQuitMessage(wl_client *client) { - Resource *resource = resourceMap().value(client); + Q_D(QWaylandWindowManagerExtension); + QWaylandWindowManagerExtensionPrivate::Resource *resource = d->resourceMap().value(client); if (resource) - send_quit(resource->handle); + d->send_quit(resource->handle); +} + +QWaylandWindowManagerExtension *QWaylandWindowManagerExtension::get(QWaylandExtensionContainer *container) +{ + return static_cast(container->extension(QtWaylandServer::qt_windowmanager::interface())); } -void WindowManagerServerIntegration::windowmanager_bind_resource(Resource *resource) +void QWaylandWindowManagerExtensionPrivate::windowmanager_bind_resource(Resource *resource) { send_hints(resource->handle, static_cast(m_showIsFullScreen)); } -void WindowManagerServerIntegration::windowmanager_destroy_resource(Resource *resource) +void QWaylandWindowManagerExtensionPrivate::windowmanager_destroy_resource(Resource *resource) { m_urls.remove(resource); } -void WindowManagerServerIntegration::windowmanager_open_url(Resource *resource, uint32_t remaining, const QString &newUrl) +void QWaylandWindowManagerExtensionPrivate::windowmanager_open_url(Resource *resource, uint32_t remaining, const QString &newUrl) { + Q_Q(QWaylandWindowManagerExtension); QString url = m_urls.value(resource, QString()); url.append(newUrl); @@ -101,7 +101,7 @@ void WindowManagerServerIntegration::windowmanager_open_url(Resource *resource, m_urls.insert(resource, url); else { m_urls.remove(resource); - m_compositor->openUrl(QWaylandClient::fromWlClient(resource->client()), QUrl(url)); + q->openUrl(QWaylandClient::fromWlClient(resource->client()), QUrl(url)); } } diff --git a/src/compositor/extensions/qwaylandwindowmanagerextension.h b/src/compositor/extensions/qwaylandwindowmanagerextension.h index 5cd64e06d..6c17c3961 100644 --- a/src/compositor/extensions/qwaylandwindowmanagerextension.h +++ b/src/compositor/extensions/qwaylandwindowmanagerextension.h @@ -37,11 +37,10 @@ #ifndef WAYLANDWINDOWMANAGERINTEGRATION_H #define WAYLANDWINDOWMANAGERINTEGRATION_H -#include -#include +#include +#include -#include -#include +#include QT_BEGIN_NAMESPACE @@ -51,28 +50,21 @@ namespace QtWayland { class QWaylandCompositor; -class Q_COMPOSITOR_EXPORT WindowManagerServerIntegration : public QWaylandExtension, public QtWaylandServer::qt_windowmanager +class QWaylandWindowManagerExtensionPrivate; + +class Q_COMPOSITOR_EXPORT QWaylandWindowManagerExtension : public QWaylandExtensionTemplate { Q_OBJECT + Q_DECLARE_PRIVATE(QWaylandWindowManagerExtension) public: - explicit WindowManagerServerIntegration(QWaylandCompositor *compositor, QObject *parent = 0); - ~WindowManagerServerIntegration(); - - void initialize(QtWayland::Display *waylandDisplay); + explicit QWaylandWindowManagerExtension(QWaylandCompositor *compositor, QObject *parent = 0); void setShowIsFullScreen(bool value); void sendQuitMessage(wl_client *client); - const wl_interface *interface() const Q_DECL_OVERRIDE { return QtWaylandServer::qt_windowmanager::interface(); } -protected: - void windowmanager_bind_resource(Resource *resource) Q_DECL_OVERRIDE; - void windowmanager_destroy_resource(Resource *resource) Q_DECL_OVERRIDE; - void windowmanager_open_url(Resource *resource, uint32_t remaining, const QString &url) Q_DECL_OVERRIDE; - -private: - bool m_showIsFullScreen; - QWaylandCompositor *m_compositor; - QMap m_urls; + static QWaylandWindowManagerExtension *get(QWaylandExtensionContainer *container); +signals: + void openUrl(QWaylandClient *client, const QUrl &url); }; QT_END_NAMESPACE diff --git a/src/compositor/extensions/qwaylandwindowmanagerextension_p.h b/src/compositor/extensions/qwaylandwindowmanagerextension_p.h new file mode 100644 index 000000000..94f389034 --- /dev/null +++ b/src/compositor/extensions/qwaylandwindowmanagerextension_p.h @@ -0,0 +1,61 @@ +/**************************************************************************** +** +** Copyright (C) 2015 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt.io/licensing/ +** +** This file is part of the QtWaylandCompositor module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL3$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and The Qt Company. For licensing terms +** and conditions see http://www.qt.io/terms-conditions. For further +** information use the contact form at http://www.qt.io/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 3 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPLv3 included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 3 requirements +** will be met: https://www.gnu.org/licenses/lgpl.html. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 2.0 or later as published by the Free +** Software Foundation and appearing in the file LICENSE.GPL included in +** the packaging of this file. Please review the following information to +** ensure the GNU General Public License version 2.0 requirements will be +** met: http://www.gnu.org/licenses/gpl-2.0.html. +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QWAYLANDWINDOWMANAGEREXTENSION_P_H +#define QWAYLANDWINDOWMANAGEREXTENSION_P_H + +#include + +#include + +#include + +class Q_COMPOSITOR_EXPORT QWaylandWindowManagerExtensionPrivate : public QWaylandExtensionTemplatePrivateImpl +{ + Q_DECLARE_PUBLIC(QWaylandWindowManagerExtension) +public: + QWaylandWindowManagerExtensionPrivate(QWaylandCompositor *compositor); + +protected: + void windowmanager_bind_resource(Resource *resource) Q_DECL_OVERRIDE; + void windowmanager_destroy_resource(Resource *resource) Q_DECL_OVERRIDE; + void windowmanager_open_url(Resource *resource, uint32_t remaining, const QString &url) Q_DECL_OVERRIDE; +private: + bool m_showIsFullScreen; + QWaylandCompositor *m_compositor; + QMap m_urls; +}; +#endif /*QWAYLANDWINDOWMANAGEREXTENSION_P_H*/ diff --git a/src/compositor/extensions/qwlshellsurface.cpp b/src/compositor/extensions/qwlshellsurface.cpp index de53f60eb..ad171aa0e 100644 --- a/src/compositor/extensions/qwlshellsurface.cpp +++ b/src/compositor/extensions/qwlshellsurface.cpp @@ -66,7 +66,7 @@ const wl_interface *Shell::interface() const return &wl_shell_interface; } -ShellSurfacePopupGrabber *Shell::getPopupGrabber(InputDevice *input) +ShellSurfacePopupGrabber *Shell::getPopupGrabber(QWaylandInputDevice *input) { if (!m_popupGrabber.contains(input)) m_popupGrabber.insert(input, new ShellSurfacePopupGrabber(input)); @@ -223,10 +223,10 @@ void ShellSurface::shell_surface_move(Resource *resource, return; } - InputDevice *input_device = InputDevice::fromSeatResource(input_device_super); - Pointer *pointer = input_device->pointerDevice(); + QWaylandInputDevicePrivate *input_device = QWaylandInputDevicePrivate::fromSeatResource(input_device_super); + QWaylandPointer *pointer = input_device->pointerDevice(); - m_moveGrabber = new ShellSurfaceMoveGrabber(this, pointer->position() - m_view->requestedPosition()); + m_moveGrabber = new ShellSurfaceMoveGrabber(this, pointer->currentSpacePosition() - m_view->requestedPosition()); pointer->startGrab(m_moveGrabber); } @@ -246,10 +246,10 @@ void ShellSurface::shell_surface_resize(Resource *resource, m_resizeGrabber = new ShellSurfaceResizeGrabber(this); - InputDevice *input_device = InputDevice::fromSeatResource(input_device_super); - Pointer *pointer = input_device->pointerDevice(); + QWaylandInputDevicePrivate *input_device = QWaylandInputDevicePrivate::fromSeatResource(input_device_super); + QWaylandPointer *pointer = input_device->pointerDevice(); - m_resizeGrabber->point = pointer->position(); + m_resizeGrabber->point = pointer->currentSpacePosition(); m_resizeGrabber->resize_edges = static_cast(edges); m_resizeGrabber->width = m_view->surface()->size().width(); m_resizeGrabber->height = m_view->surface()->size().height(); @@ -327,8 +327,8 @@ void ShellSurface::shell_surface_set_popup(Resource *resource, wl_resource *inpu Q_UNUSED(input_device); Q_UNUSED(flags); - InputDevice *input = InputDevice::fromSeatResource(input_device); - m_popupGrabber = m_shell->getPopupGrabber(input); + QWaylandInputDevicePrivate *input = QWaylandInputDevicePrivate::fromSeatResource(input_device); + m_popupGrabber = m_shell->getPopupGrabber(input->q_func()); m_popupSerial = serial; m_surface->setTransientParent(Surface::fromResource(parent)); @@ -394,7 +394,7 @@ void ShellSurface::shell_surface_set_class(Resource *resource, } ShellSurfaceGrabber::ShellSurfaceGrabber(ShellSurface *shellSurface) - : PointerGrabber() + : QWaylandPointerGrabber() , shell_surface(shellSurface) { } @@ -416,8 +416,8 @@ void ShellSurfaceResizeGrabber::motion(uint32_t time) { Q_UNUSED(time); - int width_delta = point.x() - m_pointer->position().x(); - int height_delta = point.y() - m_pointer->position().y(); + int width_delta = point.x() - pointer->currentSpacePosition().x(); + int height_delta = point.y() - pointer->currentSpacePosition().y(); int new_height = height; if (resize_edges & WL_SHELL_SURFACE_RESIZE_TOP) @@ -439,7 +439,7 @@ void ShellSurfaceResizeGrabber::button(uint32_t time, Qt::MouseButton button, ui Q_UNUSED(time) if (button == Qt::LeftButton && !state) { - m_pointer->endGrab(); + pointer->endGrab(); shell_surface->resetResizeGrabber(); delete this; } @@ -459,7 +459,7 @@ void ShellSurfaceMoveGrabber::motion(uint32_t time) { Q_UNUSED(time); - QPointF pos(m_pointer->position() - m_offset); + QPointF pos(pointer->currentSpacePosition() - m_offset); shell_surface->m_view->setRequestedPosition(pos); if (shell_surface->m_surface->transientParent()) { QWaylandSurfaceView *view = shell_surface->m_surface->transientParent()->waylandSurface()->views().first(); @@ -474,15 +474,15 @@ void ShellSurfaceMoveGrabber::button(uint32_t time, Qt::MouseButton button, uint Q_UNUSED(time) if (button == Qt::LeftButton && !state) { - m_pointer->setFocus(0, QPointF()); - m_pointer->endGrab(); + pointer->resetCurrentView(); + pointer->endGrab(); shell_surface->resetMoveGrabber(); delete this; } } -ShellSurfacePopupGrabber::ShellSurfacePopupGrabber(InputDevice *inputDevice) - : PointerGrabber() +ShellSurfacePopupGrabber::ShellSurfacePopupGrabber(QWaylandInputDevice *inputDevice) + : QWaylandDefaultPointerGrabber() , m_inputDevice(inputDevice) , m_client(0) , m_surfaces() @@ -492,7 +492,7 @@ ShellSurfacePopupGrabber::ShellSurfacePopupGrabber(InputDevice *inputDevice) uint32_t ShellSurfacePopupGrabber::grabSerial() const { - return m_inputDevice->pointerDevice()->grabSerial(); + return QWaylandInputDevicePrivate::get(m_inputDevice)->pointerDevice()->grabSerial(); } struct ::wl_client *ShellSurfacePopupGrabber::client() const @@ -510,11 +510,11 @@ void ShellSurfacePopupGrabber::addPopup(ShellSurface *surface) if (m_surfaces.isEmpty()) { m_client = surface->resource()->client(); - if (m_inputDevice->pointerDevice()->buttonPressed()) + if (QWaylandInputDevicePrivate::get(m_inputDevice)->pointerDevice()->isButtonPressed()) m_initialUp = false; m_surfaces.append(surface); - m_inputDevice->pointerDevice()->startGrab(this); + QWaylandInputDevicePrivate::get(m_inputDevice)->pointerDevice()->startGrab(this); } else { m_surfaces.append(surface); } @@ -527,30 +527,17 @@ void ShellSurfacePopupGrabber::removePopup(ShellSurface *surface) m_surfaces.removeOne(surface); if (m_surfaces.isEmpty()) - m_inputDevice->pointerDevice()->endGrab(); -} - -void ShellSurfacePopupGrabber::focus() -{ - if (m_pointer->current() && m_pointer->current()->surface()->handle()->resource()->client() == m_client) - m_pointer->setFocus(m_pointer->current(), m_pointer->currentPosition()); - else - m_pointer->setFocus(0, QPointF()); -} - -void ShellSurfacePopupGrabber::motion(uint32_t time) -{ - m_pointer->motion(time); + QWaylandInputDevicePrivate::get(m_inputDevice)->pointerDevice()->endGrab(); } void ShellSurfacePopupGrabber::button(uint32_t time, Qt::MouseButton button, uint32_t state) { - if (m_pointer->focusResource()) { - m_pointer->sendButton(time, button, state); + if (pointer->focusResource()) { + pointer->sendButton(pointer->focusResource(), time, button, state); } else if (state == QtWaylandServer::wl_pointer::button_state_pressed && - (m_initialUp || time - m_pointer->grabTime() > 500) && - m_pointer->currentGrab() == this) { - m_pointer->endGrab(); + (m_initialUp || time - pointer->grabTime() > 500) && + pointer->currentGrab() == this) { + pointer->endGrab(); Q_FOREACH (ShellSurface *surface, m_surfaces) { surface->send_popup_done(); } diff --git a/src/compositor/extensions/qwlshellsurface_p.h b/src/compositor/extensions/qwlshellsurface_p.h index 804ee2cff..ddb373d80 100644 --- a/src/compositor/extensions/qwlshellsurface_p.h +++ b/src/compositor/extensions/qwlshellsurface_p.h @@ -70,12 +70,12 @@ public: const wl_interface *interface() const Q_DECL_OVERRIDE; - ShellSurfacePopupGrabber* getPopupGrabber(InputDevice *input); + ShellSurfacePopupGrabber* getPopupGrabber(QWaylandInputDevice *input); private: void shell_get_shell_surface(Resource *resource, uint32_t id, struct ::wl_resource *surface) Q_DECL_OVERRIDE; - QHash m_popupGrabber; + QHash m_popupGrabber; }; class Q_COMPOSITOR_EXPORT ShellSurface : public QWaylandExtension, public QtWaylandServer::wl_shell_surface @@ -176,7 +176,7 @@ private: friend class ShellSurfaceMoveGrabber; }; -class ShellSurfaceGrabber : public PointerGrabber +class ShellSurfaceGrabber : public QWaylandPointerGrabber { public: ShellSurfaceGrabber(ShellSurface *shellSurface); @@ -213,10 +213,10 @@ private: QPointF m_offset; }; -class ShellSurfacePopupGrabber : public PointerGrabber +class ShellSurfacePopupGrabber : public QWaylandDefaultPointerGrabber { public: - ShellSurfacePopupGrabber(InputDevice *inputDevice); + ShellSurfacePopupGrabber(QWaylandInputDevice *inputDevice); uint32_t grabSerial() const; @@ -226,12 +226,10 @@ public: void addPopup(ShellSurface *surface); void removePopup(ShellSurface *surface); - void focus() Q_DECL_OVERRIDE; - void motion(uint32_t time) Q_DECL_OVERRIDE; void button(uint32_t time, Qt::MouseButton button, uint32_t state) Q_DECL_OVERRIDE; private: - InputDevice *m_inputDevice; + QWaylandInputDevice *m_inputDevice; struct ::wl_client *m_client; QList m_surfaces; bool m_initialUp; diff --git a/src/compositor/extensions/qwltextinput.cpp b/src/compositor/extensions/qwltextinput.cpp index af1b73cb6..5b5f8a6df 100644 --- a/src/compositor/extensions/qwltextinput.cpp +++ b/src/compositor/extensions/qwltextinput.cpp @@ -102,7 +102,7 @@ void TextInput::text_input_activate(Resource *, wl_resource *seat, wl_resource * bool wasEmpty = m_activeInputMethods.isEmpty(); - InputMethod *inputMethod = InputDevice::fromSeatResource(seat)->inputMethod(); + InputMethod *inputMethod = QWaylandInputDevicePrivate::fromSeatResource(seat)->inputMethod(); if (!m_activeInputMethods.contains(inputMethod)) { m_activeInputMethods.append(inputMethod); @@ -115,7 +115,7 @@ void TextInput::text_input_activate(Resource *, wl_resource *seat, wl_resource * void TextInput::text_input_deactivate(Resource *, wl_resource *seat) { - InputMethod *inputMethod = InputDevice::fromSeatResource(seat)->inputMethod(); + InputMethod *inputMethod = QWaylandInputDevicePrivate::fromSeatResource(seat)->inputMethod(); deactivate(inputMethod); } diff --git a/src/compositor/global/qwaylandextension.h b/src/compositor/global/qwaylandextension.h index c051e366f..e31c6398d 100644 --- a/src/compositor/global/qwaylandextension.h +++ b/src/compositor/global/qwaylandextension.h @@ -48,6 +48,7 @@ QT_BEGIN_NAMESPACE class QWaylandCompositor; class QWaylandExtensionContainer; class QWaylandExtensionPrivate; +class QWaylandExtensionTemplatePrivate; class Q_COMPOSITOR_EXPORT QWaylandExtension : public QObject { @@ -81,7 +82,6 @@ protected: QVector extension_vector; }; -class QWaylandExtensionTemplatePrivate; class Q_COMPOSITOR_EXPORT QWaylandExtensionTemplate : public QWaylandExtension { Q_OBJECT diff --git a/src/compositor/wayland_wrapper/qwlcompositor.cpp b/src/compositor/wayland_wrapper/qwlcompositor.cpp index 2de42fc2d..0aef63671 100644 --- a/src/compositor/wayland_wrapper/qwlcompositor.cpp +++ b/src/compositor/wayland_wrapper/qwlcompositor.cpp @@ -305,16 +305,6 @@ void Compositor::destroySurface(Surface *surface) m_destroyed_surfaces << surface->waylandSurface(); } -void Compositor::resetInputDevice(Surface *surface) -{ - foreach (QWaylandInputDevice *dev, m_inputDevices) { - if (dev->keyboardFocus() == surface->waylandSurface()) - dev->setKeyboardFocus(0); - if (dev->mouseFocus() && dev->mouseFocus()->surface() == surface->waylandSurface()) - dev->setMouseFocus(0, QPointF(), QPointF()); - } -} - void Compositor::unregisterSurface(QWaylandSurface *surface) { if (!m_all_surfaces.removeOne(surface)) @@ -403,18 +393,15 @@ void Compositor::initializeExtensions() new TextInputManager(this); new QWaylandInputPanel(waylandCompositor()); } - if (m_extensions & QWaylandCompositor::WindowManagerExtension) { - WindowManagerServerIntegration *wmint = new WindowManagerServerIntegration(m_qt_compositor, this); - wmint->initialize(m_display); - } - if (m_extensions & QWaylandCompositor::DefaultShellExtension) { + if (m_extensions & QWaylandCompositor::WindowManagerExtension) + new QWaylandWindowManagerExtension(waylandCompositor()); + if (m_extensions & QWaylandCompositor::DefaultShellExtension) new Shell(waylandCompositor()); - } } void Compositor::initializeDefaultInputDevice() { - m_default_wayland_input_device = new QWaylandInputDevice(m_qt_compositor); + m_default_wayland_input_device = m_qt_compositor->createInputDevice(); registerInputDevice(m_default_wayland_input_device); } @@ -423,22 +410,15 @@ QList Compositor::clients() const return m_clients; } -void Compositor::setClientFullScreenHint(bool value) -{ - WindowManagerServerIntegration *wmExtension = static_cast(waylandCompositor()->extension(QtWaylandServer::qt_windowmanager::name())); - if (wmExtension) - wmExtension->setShowIsFullScreen(value); -} - QWaylandCompositor::ExtensionFlags Compositor::extensions() const { return m_extensions; } -InputDevice* Compositor::defaultInputDevice() +QWaylandInputDevice *Compositor::defaultInputDevice() { // The list gets prepended so that default is the last element - return m_inputDevices.last()->handle(); + return m_inputDevices.last(); } DataDeviceManager *Compositor::dataDeviceManager() const diff --git a/src/compositor/wayland_wrapper/qwlcompositor_p.h b/src/compositor/wayland_wrapper/qwlcompositor_p.h index 0862477e4..750807449 100644 --- a/src/compositor/wayland_wrapper/qwlcompositor_p.h +++ b/src/compositor/wayland_wrapper/qwlcompositor_p.h @@ -89,9 +89,7 @@ public: void init(); - void sendFrameCallbacks(QList visibleSurfaces); - - InputDevice *defaultInputDevice(); + QWaylandInputDevice *defaultInputDevice(); void registerInputDevice(QWaylandInputDevice *device); QList inputDevices() const { return m_inputDevices; } @@ -128,8 +126,6 @@ public: QList clients() const; - void setClientFullScreenHint(bool value); - QWaylandCompositor::ExtensionFlags extensions() const; InputPanel *inputPanel() const; @@ -145,8 +141,6 @@ public: void overrideSelection(const QMimeData *data); void feedRetainedSelectionData(QMimeData *data); - void resetInputDevice(Surface *surface); - void unregisterSurface(QWaylandSurface *surface); public slots: diff --git a/src/compositor/wayland_wrapper/qwldatadevice.cpp b/src/compositor/wayland_wrapper/qwldatadevice.cpp index c3a059f74..fd5c6d3ca 100644 --- a/src/compositor/wayland_wrapper/qwldatadevice.cpp +++ b/src/compositor/wayland_wrapper/qwldatadevice.cpp @@ -48,6 +48,7 @@ #include "qwaylanddrag.h" #include "qwaylandsurfaceview.h" +#include #include @@ -55,7 +56,7 @@ QT_BEGIN_NAMESPACE namespace QtWayland { -DataDevice::DataDevice(InputDevice *inputDevice) +DataDevice::DataDevice(QWaylandInputDevice *inputDevice) : wl_data_device() , m_compositor(inputDevice->compositor()) , m_inputDevice(inputDevice) @@ -68,12 +69,12 @@ DataDevice::DataDevice(InputDevice *inputDevice) { } -void DataDevice::setFocus(QtWaylandServer::wl_keyboard::Resource *focusResource) +void DataDevice::setFocus(QWaylandClient *focusClient) { - if (!focusResource) + if (!focusClient) return; - Resource *resource = resourceMap().value(focusResource->client()); + Resource *resource = resourceMap().value(focusClient->client()); if (!resource) return; @@ -103,7 +104,7 @@ void DataDevice::setDragFocus(QWaylandSurfaceView *focus, const QPointF &localPo if (!resource) return; - uint32_t serial = wl_display_next_serial(m_compositor->wl_display()); + uint32_t serial = wl_display_next_serial(m_compositor->waylandDisplay()); DataOffer *offer = m_dragDataSource ? new DataOffer(m_dragDataSource, resource) : 0; @@ -131,20 +132,20 @@ void DataDevice::sourceDestroyed(DataSource *source) void DataDevice::focus() { - QWaylandSurfaceView *focus = outputSpace()->pickView(m_pointer->currentPosition()); - - if (focus != m_dragFocus) - setDragFocus(focus, outputSpace()->mapToView(focus, m_pointer->currentPosition())); + QWaylandSurfaceView *focus = pointer->currentView(); + if (focus != m_dragFocus) { + setDragFocus(focus, pointer->currentLocalPosition()); + } } void DataDevice::motion(uint32_t time) { if (m_dragIcon) { - m_dragIcon->setRequestedPosition(m_pointer->currentPosition()); + m_dragIcon->setRequestedPosition(pointer->currentSpacePosition()); } if (m_dragFocusResource && m_dragFocus) { - const QPointF &surfacePoint = outputSpace()->mapToView(m_dragFocus, m_pointer->currentPosition()); + const QPointF &surfacePoint = outputSpace()->mapToView(m_dragFocus, pointer->currentSpacePosition()); send_motion(m_dragFocusResource->handle, time, wl_fixed_from_double(surfacePoint.x()), wl_fixed_from_double(surfacePoint.y())); } @@ -155,37 +156,36 @@ void DataDevice::button(uint32_t time, Qt::MouseButton button, uint32_t state) Q_UNUSED(time); if (m_dragFocusResource && - m_pointer->grabButton() == button && - state == Pointer::button_state_released) + pointer->grabButton() == button && + state == QWaylandPointerPrivate::button_state_released) send_drop(m_dragFocusResource->handle); - if (!m_pointer->buttonPressed() && - state == Pointer::button_state_released) { + if (!pointer->isButtonPressed() && + state == QWaylandPointerPrivate::button_state_released) { if (m_dragIcon) { m_dragIcon = 0; - Q_EMIT m_inputDevice->dragHandle()->iconChanged(); + Q_EMIT QWaylandInputDevicePrivate::get(m_inputDevice)->dragHandle()->iconChanged(); } setDragFocus(0, QPointF()); - m_pointer->endGrab(); + pointer->endGrab(); } } void DataDevice::data_device_start_drag(Resource *resource, struct ::wl_resource *source, struct ::wl_resource *origin, struct ::wl_resource *icon, uint32_t serial) { - if (m_inputDevice->pointerDevice()->grabSerial() == serial) { - if (!m_inputDevice->pointerDevice()->buttonPressed() || - m_inputDevice->pointerDevice()->focusSurface()->surface()->handle() != Surface::fromResource(origin)) + if (QWaylandInputDevicePrivate::get(m_inputDevice)->pointerDevice()->grabSerial() == serial) { + if (!QWaylandInputDevicePrivate::get(m_inputDevice)->pointerDevice()->isButtonPressed() || + QWaylandInputDevicePrivate::get(m_inputDevice)->pointerDevice()->currentView()->surface()->handle() != Surface::fromResource(origin)) return; m_dragClient = resource->client(); m_dragDataSource = source != 0 ? DataSource::fromResource(source) : 0; - m_dragIcon = icon != 0 ? m_compositor->waylandCompositor()->createSurfaceView(Surface::fromResource(icon)->waylandSurface()) : 0; - Q_EMIT m_inputDevice->dragHandle()->iconChanged(); + m_dragIcon = icon != 0 ? m_compositor->createSurfaceView(Surface::fromResource(icon)->waylandSurface()) : 0; + Q_EMIT QWaylandInputDevicePrivate::get(m_inputDevice)->dragHandle()->iconChanged(); - m_inputDevice->pointerDevice()->setFocus(0, QPointF()); - m_inputDevice->pointerDevice()->startGrab(this); + QWaylandInputDevicePrivate::get(m_inputDevice)->pointerDevice()->startGrab(this); } } @@ -199,12 +199,12 @@ void DataDevice::data_device_set_selection(Resource *, struct ::wl_resource *sou m_selectionSource->cancel(); m_selectionSource = dataSource; - m_compositor->dataDeviceManager()->setCurrentSelectionSource(m_selectionSource); + m_compositor->handle()->dataDeviceManager()->setCurrentSelectionSource(m_selectionSource); if (m_selectionSource) m_selectionSource->setDevice(this); - QtWaylandServer::wl_keyboard::Resource *focusResource = m_inputDevice->keyboardDevice()->focusResource(); - Resource *resource = focusResource ? resourceMap().value(focusResource->client()) : 0; + QWaylandClient *focusClient = m_inputDevice->keyboard()->focusClient(); + Resource *resource = focusClient ? resourceMap().value(focusClient->client()) : 0; if (resource && m_selectionSource) { DataOffer *offer = new DataOffer(m_selectionSource, resource); diff --git a/src/compositor/wayland_wrapper/qwldatadevice_p.h b/src/compositor/wayland_wrapper/qwldatadevice_p.h index 59a9d2b27..a2facc111 100644 --- a/src/compositor/wayland_wrapper/qwldatadevice_p.h +++ b/src/compositor/wayland_wrapper/qwldatadevice_p.h @@ -39,6 +39,7 @@ #include #include +#include #include #include @@ -53,12 +54,12 @@ class DataSource; class InputDevice; class Surface; -class DataDevice : public QtWaylandServer::wl_data_device, public PointerGrabber +class DataDevice : public QtWaylandServer::wl_data_device, public QWaylandPointerGrabber { public: - DataDevice(InputDevice *inputDevice); + DataDevice(QWaylandInputDevice *inputDevice); - void setFocus(QtWaylandServer::wl_keyboard::Resource *focusResource); + void setFocus(QWaylandClient *client); void setDragFocus(QWaylandSurfaceView *focus, const QPointF &localPosition); @@ -74,9 +75,9 @@ protected: void data_device_set_selection(Resource *resource, struct ::wl_resource *source, uint32_t serial) Q_DECL_OVERRIDE; private: - QWaylandOutputSpace *outputSpace() const { return m_inputDevice->handle()->outputSpace(); } - Compositor *m_compositor; - InputDevice *m_inputDevice; + QWaylandOutputSpace *outputSpace() const { return m_inputDevice->outputSpace(); } + QWaylandCompositor *m_compositor; + QWaylandInputDevice *m_inputDevice; DataSource *m_selectionSource; diff --git a/src/compositor/wayland_wrapper/qwldatadevicemanager.cpp b/src/compositor/wayland_wrapper/qwldatadevicemanager.cpp index feb97e4af..35bbf59f4 100644 --- a/src/compositor/wayland_wrapper/qwldatadevicemanager.cpp +++ b/src/compositor/wayland_wrapper/qwldatadevicemanager.cpp @@ -44,6 +44,8 @@ #include "qwlsurface_p.h" #include "qwaylandmimehelper.h" +#include + #include #include #include @@ -198,11 +200,11 @@ void DataDeviceManager::overrideSelection(const QMimeData &mimeData) m_compositorOwnsSelection = true; - InputDevice *dev = m_compositor->defaultInputDevice(); - Surface *focusSurface = dev->keyboardFocus(); + QWaylandInputDevice *dev = m_compositor->defaultInputDevice(); + QWaylandSurface *focusSurface = QWaylandInputDevicePrivate::get(dev)->keyboardFocus(); if (focusSurface) offerFromCompositorToClient( - dev->dataDevice()->resourceMap().value(focusSurface->resource()->client())->handle); + QWaylandInputDevicePrivate::get(dev)->dataDevice()->resourceMap().value(QWaylandSurfacePrivate::get(focusSurface)->resource()->client())->handle); } bool DataDeviceManager::offerFromCompositorToClient(wl_resource *clientDataDeviceResource) @@ -242,7 +244,7 @@ void DataDeviceManager::data_device_manager_create_data_source(Resource *resourc void DataDeviceManager::data_device_manager_get_data_device(Resource *resource, uint32_t id, struct ::wl_resource *seat) { - InputDevice *input_device = InputDevice::fromSeatResource(seat); + QWaylandInputDevicePrivate *input_device = QWaylandInputDevicePrivate::fromSeatResource(seat); input_device->clientRequestedDataDevice(this, resource->client(), id); } diff --git a/src/compositor/wayland_wrapper/qwlinputdevice.cpp b/src/compositor/wayland_wrapper/qwlinputdevice.cpp index 2e1720a9f..768050435 100644 --- a/src/compositor/wayland_wrapper/qwlinputdevice.cpp +++ b/src/compositor/wayland_wrapper/qwlinputdevice.cpp @@ -48,93 +48,79 @@ #include "qwlkeyboard_p.h" #include "qwltouch_p.h" #include "qwaylandsurfaceview.h" +#include #include QT_BEGIN_NAMESPACE -namespace QtWayland { - -InputDevice::InputDevice(QWaylandInputDevice *handle, Compositor *compositor, QWaylandInputDevice::CapabilityFlags caps) - : QtWaylandServer::wl_seat(compositor->wl_display(), 3) - , m_handle(handle) - , m_dragHandle(new QWaylandDrag(this)) +QWaylandInputDevicePrivate::QWaylandInputDevicePrivate(QWaylandInputDevice *inputdevice, QWaylandCompositor *compositor, QWaylandInputDevice::CapabilityFlags caps) + : QObjectPrivate() + , QtWaylandServer::wl_seat(compositor->waylandDisplay(), 3) + , m_dragHandle(new QWaylandDrag(inputdevice)) , m_compositor(compositor) , m_outputSpace(compositor->primaryOutputSpace()) , m_capabilities(caps) - , m_pointer(m_capabilities & QWaylandInputDevice::Pointer ? new Pointer(m_compositor, this) : 0) - , m_keyboard(m_capabilities & QWaylandInputDevice::Keyboard ? new Keyboard(m_compositor, this) : 0) - , m_touch(m_capabilities & QWaylandInputDevice::Touch ? new Touch(m_compositor) : 0) - , m_inputMethod(m_compositor->extensions() & QWaylandCompositor::TextInputExtension ? new InputMethod(m_compositor, this) : 0) + , m_pointer(m_capabilities & QWaylandInputDevice::Pointer ? new QWaylandPointer(inputdevice) : 0) + , m_keyboard(m_capabilities & QWaylandInputDevice::Keyboard ? new QWaylandKeyboard(inputdevice) : 0) + , m_touch(m_capabilities & QWaylandInputDevice::Touch ? new QWaylandTouch(inputdevice) : 0) + , m_inputMethod(m_compositor->extensionFlags() & QWaylandCompositor::TextInputExtension ? new QtWayland::InputMethod(m_compositor, inputdevice) : 0) , m_data_device() { } -InputDevice::~InputDevice() +QWaylandInputDevicePrivate::~QWaylandInputDevicePrivate() { } -Pointer *InputDevice::pointerDevice() +QWaylandPointer *QWaylandInputDevicePrivate::pointerDevice() const { return m_pointer.data(); } -Keyboard *InputDevice::keyboardDevice() +QWaylandKeyboard *QWaylandInputDevicePrivate::keyboardDevice() const { return m_keyboard.data(); } -Touch *InputDevice::touchDevice() +QWaylandTouch *QWaylandInputDevicePrivate::touchDevice() const { return m_touch.data(); } -InputMethod *InputDevice::inputMethod() +QtWayland::InputMethod *QWaylandInputDevicePrivate::inputMethod() { return m_inputMethod.data(); } -const Pointer *InputDevice::pointerDevice() const -{ - return m_pointer.data(); -} -const Keyboard *InputDevice::keyboardDevice() const -{ - return m_keyboard.data(); -} - -const Touch *InputDevice::touchDevice() const -{ - return m_touch.data(); -} - -void InputDevice::seat_destroy_resource(wl_seat::Resource *) +void QWaylandInputDevicePrivate::seat_destroy_resource(wl_seat::Resource *) { // cleanupDataDeviceForClient(resource->client(), true); } -void InputDevice::seat_bind_resource(wl_seat::Resource *resource) +void QWaylandInputDevicePrivate::seat_bind_resource(wl_seat::Resource *resource) { // The order of m_capabilities matches the order defined in the wayland protocol wl_seat::send_capabilities(resource->handle, (uint32_t)m_capabilities); } -void InputDevice::setCapabilities(QWaylandInputDevice::CapabilityFlags caps) +void QWaylandInputDevicePrivate::setCapabilities(QWaylandInputDevice::CapabilityFlags caps) { + Q_Q(QWaylandInputDevice); if (m_capabilities != caps) { QWaylandInputDevice::CapabilityFlags changed = caps ^ m_capabilities; if (changed & QWaylandInputDevice::Pointer) { - m_pointer.reset(m_pointer.isNull() ? new Pointer(m_compositor, this) : 0); + m_pointer.reset(m_pointer.isNull() ? new QWaylandPointer(q) : 0); } if (changed & QWaylandInputDevice::Keyboard) { - m_keyboard.reset(m_keyboard.isNull() ? new Keyboard(m_compositor, this) : 0); + m_keyboard.reset(m_keyboard.isNull() ? new QWaylandKeyboard(q) : 0); } if (changed & QWaylandInputDevice::Touch) { - m_touch.reset(m_touch.isNull() ? new Touch(m_compositor) : 0); + m_touch.reset(m_touch.isNull() ? new QWaylandTouch(q) : 0); } m_capabilities = caps; @@ -145,110 +131,83 @@ void InputDevice::setCapabilities(QWaylandInputDevice::CapabilityFlags caps) } } -void InputDevice::seat_get_pointer(wl_seat::Resource *resource, uint32_t id) +void QWaylandInputDevicePrivate::seat_get_pointer(wl_seat::Resource *resource, uint32_t id) { if (!m_pointer.isNull()) { - m_pointer->add(resource->client(), id, resource->version()); + m_pointer->addClient(QWaylandClient::fromWlClient(resource->client()), id); } } -void InputDevice::seat_get_keyboard(wl_seat::Resource *resource, uint32_t id) +void QWaylandInputDevicePrivate::seat_get_keyboard(wl_seat::Resource *resource, uint32_t id) { if (!m_keyboard.isNull()) { - m_keyboard->add(resource->client(), id, resource->version()); + QWaylandKeyboardPrivate::get(m_keyboard.data())->add(resource->client(), id, resource->version()); } } -void InputDevice::seat_get_touch(wl_seat::Resource *resource, uint32_t id) +void QWaylandInputDevicePrivate::seat_get_touch(wl_seat::Resource *resource, uint32_t id) { if (!m_touch.isNull()) { - m_touch->add(resource->client(), id, resource->version()); + m_touch->addClient(QWaylandClient::fromWlClient(resource->client()), id); } } -void InputDevice::sendMousePressEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos) +void QWaylandInputDevicePrivate::sendMousePressEvent(Qt::MouseButton button) { - pointerDevice()->sendMousePressEvent(button, localPos, globalPos); + pointerDevice()->sendMousePressEvent(button); } -void InputDevice::sendMouseReleaseEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos) +void QWaylandInputDevicePrivate::sendMouseReleaseEvent(Qt::MouseButton button) { - pointerDevice()->sendMouseReleaseEvent(button, localPos, globalPos); + pointerDevice()->sendMouseReleaseEvent(button); } -void InputDevice::sendMouseMoveEvent(const QPointF &localPos, const QPointF &globalPos) +void QWaylandInputDevicePrivate::sendMouseMoveEvent(QWaylandSurfaceView *surface, const QPointF &localPos, const QPointF &globalPos) { - pointerDevice()->sendMouseMoveEvent(localPos, globalPos); + pointerDevice()->sendMouseMoveEvent(surface, localPos,globalPos); } -void InputDevice::sendMouseMoveEvent(QWaylandSurfaceView *surface, const QPointF &localPos, const QPointF &globalPos) -{ - setMouseFocus(surface,localPos,globalPos); - sendMouseMoveEvent(localPos,globalPos); -} - -void InputDevice::sendMouseWheelEvent(Qt::Orientation orientation, int delta) +void QWaylandInputDevicePrivate::sendMouseWheelEvent(Qt::Orientation orientation, int delta) { pointerDevice()->sendMouseWheelEvent(orientation, delta); } -void InputDevice::sendMouseEnterEvent(QWaylandSurfaceView *view, const QPointF &localPos) -{ - pointerDevice()->sendMouseEnterEvent(view, localPos); -} - -void InputDevice::sendMouseLeaveEvent(QWaylandSurfaceView *view) +void QWaylandInputDevicePrivate::sendResetCurrentMouseView() { - pointerDevice()->sendMouseLeaveEvent(view); + pointerDevice()->resetCurrentView(); } -void InputDevice::sendTouchPointEvent(int id, double x, double y, Qt::TouchPointState state) +void QWaylandInputDevicePrivate::sendTouchPointEvent(int id, const QPointF &point, Qt::TouchPointState state) { if (m_touch.isNull()) { return; } - - switch (state) { - case Qt::TouchPointPressed: - m_touch->sendDown(id, QPointF(x, y)); - break; - case Qt::TouchPointMoved: - m_touch->sendMotion(id, QPointF(x, y)); - break; - case Qt::TouchPointReleased: - m_touch->sendUp(id); - break; - case Qt::TouchPointStationary: - // stationary points are not sent through wayland, the client must cache them - break; - default: - break; - } + m_touch->sendTouchPointEvent(id, point,state); } -void InputDevice::sendTouchFrameEvent() +void QWaylandInputDevicePrivate::sendTouchFrameEvent() { if (!m_touch.isNull()) { - m_touch->sendFrame(); + m_touch->sendFrameEvent(); } } -void InputDevice::sendTouchCancelEvent() +void QWaylandInputDevicePrivate::sendTouchCancelEvent() { if (!m_touch.isNull()) { - m_touch->sendCancel(); + m_touch->sendCancelEvent(); } } -void InputDevice::sendFullKeyEvent(QKeyEvent *event) +void QWaylandInputDevicePrivate::sendFullKeyEvent(QKeyEvent *event) { if (!keyboardFocus()) { qWarning("Cannot send key event, no keyboard focus, fix the compositor"); return; } - QtKeyExtensionGlobal *ext = QtKeyExtensionGlobal::get(m_compositor->waylandCompositor()); - if (ext && ext->postQtKeyEvent(event, keyboardFocus())) + QtWayland::QtKeyExtensionGlobal *ext = QtWayland::QtKeyExtensionGlobal::get(m_compositor); + if (ext && ext->postQtKeyEvent(event, keyboardFocus()->handle())) return; if (!m_keyboard.isNull() && !event->isAutoRepeat()) { @@ -259,124 +218,92 @@ void InputDevice::sendFullKeyEvent(QKeyEvent *event) } } -void InputDevice::sendFullKeyEvent(Surface *surface, QKeyEvent *event) +void QWaylandInputDevicePrivate::sendFullKeyEvent(QWaylandSurface *surface, QKeyEvent *event) { - QtKeyExtensionGlobal *ext = QtKeyExtensionGlobal::get(m_compositor->waylandCompositor()); + QtWayland::QtKeyExtensionGlobal *ext = QtWayland::QtKeyExtensionGlobal::get(m_compositor); if (ext) - ext->postQtKeyEvent(event, surface); + ext->postQtKeyEvent(event, surface->handle()); } -void InputDevice::sendFullTouchEvent(QTouchEvent *event) +void QWaylandInputDevicePrivate::sendFullTouchEvent(QTouchEvent *event) { if (!mouseFocus()) { qWarning("Cannot send touch event, no pointer focus, fix the compositor"); return; } - if (event->type() == QEvent::TouchCancel) { - sendTouchCancelEvent(); + if (!m_touch) return; - } - TouchExtensionGlobal *ext = TouchExtensionGlobal::get(m_compositor->waylandCompositor()); - if (ext && ext->postTouchEvent(event, mouseFocus())) - return; - - const QList points = event->touchPoints(); - if (points.isEmpty()) - return; - - const int pointCount = points.count(); - QPointF pos = mouseFocus()->requestedPosition(); - for (int i = 0; i < pointCount; ++i) { - const QTouchEvent::TouchPoint &tp(points.at(i)); - // Convert the local pos in the compositor window to surface-relative. - QPointF p = tp.pos() - pos; - sendTouchPointEvent(tp.id(), p.x(), p.y(), tp.state()); - } - sendTouchFrameEvent(); + m_touch->sendFullTouchEvent(event); } -Surface *InputDevice::keyboardFocus() const +QWaylandSurface *QWaylandInputDevicePrivate::keyboardFocus() const { - return m_keyboard.isNull() ? 0 : m_keyboard->focus(); + if (m_keyboard.isNull() || !m_keyboard->focus()) + return Q_NULLPTR; + + return m_keyboard->focus(); } /*! * \return True if the keyboard focus is changed successfully. False for inactive transient surfaces. */ -bool InputDevice::setKeyboardFocus(Surface *surface) +bool QWaylandInputDevicePrivate::setKeyboardFocus(QWaylandSurface *surface) { - if (surface && (surface->transientInactive() || surface->isDestroyed())) + if (surface && (surface->transientInactive() || surface->handle()->isDestroyed())) return false; if (!m_keyboard.isNull()) { m_keyboard->setFocus(surface); if (m_data_device) - m_data_device->setFocus(m_keyboard->focusResource()); + m_data_device->setFocus(m_keyboard->focusClient()); return true; } return false; } -QWaylandSurfaceView *InputDevice::mouseFocus() const +QWaylandSurfaceView *QWaylandInputDevicePrivate::mouseFocus() const { - return m_pointer.isNull() ? 0 : m_pointer->focusSurface(); -} - -void InputDevice::setMouseFocus(QWaylandSurfaceView *view, const QPointF &localPos, const QPointF &globalPos) -{ - if (view && view->surface()->handle()->isDestroyed()) - return; - - if (!m_pointer.isNull()) { - m_pointer->setMouseFocus(view, localPos, globalPos); - } - - if (!m_touch.isNull()) { - // We have no separate touch focus management so make it match the pointer focus always. - // No wl_touch_set_focus() is available so set it manually. - m_touch->setFocus(view); - } + return m_pointer.isNull() ? 0 : m_pointer->currentView(); } -void InputDevice::clientRequestedDataDevice(DataDeviceManager *, struct wl_client *client, uint32_t id) +void QWaylandInputDevicePrivate::clientRequestedDataDevice(QtWayland::DataDeviceManager *, struct wl_client *client, uint32_t id) { + Q_Q(QWaylandInputDevice); if (!m_data_device) - m_data_device.reset(new DataDevice(this)); + m_data_device.reset(new QtWayland::DataDevice(q)); m_data_device->add(client, id, 1); } -Compositor *InputDevice::compositor() const +QWaylandCompositor *QWaylandInputDevicePrivate::compositor() const { return m_compositor; } -QWaylandInputDevice *InputDevice::handle() const -{ - return m_handle; -} - -QWaylandDrag *InputDevice::dragHandle() const +QWaylandDrag *QWaylandInputDevicePrivate::dragHandle() const { return m_dragHandle.data(); } -const DataDevice *InputDevice::dataDevice() const +const QtWayland::DataDevice *QWaylandInputDevicePrivate::dataDevice() const { return m_data_device.data(); } -QWaylandOutputSpace *InputDevice::outputSpace() const +QWaylandOutputSpace *QWaylandInputDevicePrivate::outputSpace() const { return m_outputSpace; } -void InputDevice::setOutputSpace(QWaylandOutputSpace *outputSpace) +void QWaylandInputDevicePrivate::setOutputSpace(QWaylandOutputSpace *outputSpace) { m_outputSpace = outputSpace; } +QWaylandInputDevicePrivate *QWaylandInputDevicePrivate::get(QWaylandInputDevice *device) +{ + return device->d_func(); } QT_END_NAMESPACE diff --git a/src/compositor/wayland_wrapper/qwlinputdevice_p.h b/src/compositor/wayland_wrapper/qwlinputdevice_p.h index da59dd208..dba63c05a 100644 --- a/src/compositor/wayland_wrapper/qwlinputdevice_p.h +++ b/src/compositor/wayland_wrapper/qwlinputdevice_p.h @@ -45,6 +45,7 @@ #include #include #include +#include #ifndef QT_NO_WAYLAND_XKB #include @@ -71,74 +72,70 @@ class Keyboard; class Touch; class InputMethod; -class Q_COMPOSITOR_EXPORT InputDevice : public QtWaylandServer::wl_seat +} + +class Q_COMPOSITOR_EXPORT QWaylandInputDevicePrivate : public QObjectPrivate, public QtWaylandServer::wl_seat { public: - InputDevice(QWaylandInputDevice *handle, Compositor *compositor, QWaylandInputDevice::CapabilityFlags caps); - ~InputDevice(); + Q_DECLARE_PUBLIC(QWaylandInputDevice) + + QWaylandInputDevicePrivate(QWaylandInputDevice *device, QWaylandCompositor *compositor, QWaylandInputDevice::CapabilityFlags caps); + ~QWaylandInputDevicePrivate(); - void sendMousePressEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos = QPointF()); - void sendMouseReleaseEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos = QPointF()); - void sendMouseMoveEvent(const QPointF &localPos, const QPointF &globalPos = QPointF()); - void sendMouseMoveEvent(QWaylandSurfaceView *surface, const QPointF &localPos, const QPointF &globalPos = QPointF()); + void sendMousePressEvent(Qt::MouseButton button); + void sendMouseReleaseEvent(Qt::MouseButton button); + void sendMouseMoveEvent(QWaylandSurfaceView *surface, const QPointF &localPos, const QPointF &spacePos = QPointF()); void sendMouseWheelEvent(Qt::Orientation orientation, int delta); - void sendMouseEnterEvent(QWaylandSurfaceView *view, const QPointF &localPos); - void sendMouseLeaveEvent(QWaylandSurfaceView *view); + void sendResetCurrentMouseView(); - void sendTouchPointEvent(int id, double x, double y, Qt::TouchPointState state); + void sendTouchPointEvent(int id, const QPointF &point, Qt::TouchPointState state); void sendTouchFrameEvent(); void sendTouchCancelEvent(); void sendFullKeyEvent(QKeyEvent *event); - void sendFullKeyEvent(Surface *surface, QKeyEvent *event); + void sendFullKeyEvent(QWaylandSurface *surface, QKeyEvent *event); void sendFullTouchEvent(QTouchEvent *event); - Surface *keyboardFocus() const; - bool setKeyboardFocus(Surface *surface); + QWaylandSurface *keyboardFocus() const; + bool setKeyboardFocus(QWaylandSurface *surface); QWaylandSurfaceView *mouseFocus() const; - void setMouseFocus(QWaylandSurfaceView *surface, const QPointF &localPos, const QPointF &globalPos); - void clientRequestedDataDevice(DataDeviceManager *dndSelection, struct wl_client *client, uint32_t id); - const DataDevice *dataDevice() const; + void clientRequestedDataDevice(QtWayland::DataDeviceManager *dndSelection, struct wl_client *client, uint32_t id); + const QtWayland::DataDevice *dataDevice() const; QWaylandOutputSpace *outputSpace() const; void setOutputSpace(QWaylandOutputSpace *outputSpace); - Compositor *compositor() const; - QWaylandInputDevice *handle() const; + QWaylandCompositor *compositor() const; QWaylandDrag *dragHandle() const; - Pointer *pointerDevice(); - Keyboard *keyboardDevice(); - Touch *touchDevice(); - InputMethod *inputMethod(); + QWaylandPointer *pointerDevice() const; + QWaylandKeyboard *keyboardDevice() const; + QWaylandTouch *touchDevice() const; + QtWayland::InputMethod *inputMethod(); - const Pointer *pointerDevice() const; - const Keyboard *keyboardDevice() const; - const Touch *touchDevice() const; - - static InputDevice *fromSeatResource(struct ::wl_resource *resource) + static QWaylandInputDevicePrivate *fromSeatResource(struct ::wl_resource *resource) { - return static_cast(wl_seat::Resource::fromResource(resource)->seat_object); + return static_cast(wl_seat::Resource::fromResource(resource)->seat_object); } - QWaylandInputDevice::CapabilityFlags capabilities() { return m_capabilities; } + QWaylandInputDevice::CapabilityFlags capabilities() const { return m_capabilities; } void setCapabilities(QWaylandInputDevice::CapabilityFlags caps); + static QWaylandInputDevicePrivate *get(QWaylandInputDevice *device); private: - QWaylandInputDevice *m_handle; QScopedPointer m_dragHandle; - Compositor *m_compositor; + QWaylandCompositor *m_compositor; QWaylandOutputSpace *m_outputSpace; QWaylandInputDevice::CapabilityFlags m_capabilities; - QScopedPointer m_pointer; - QScopedPointer m_keyboard; - QScopedPointer m_touch; - QScopedPointer m_inputMethod; - QScopedPointer m_data_device; + QScopedPointer m_pointer; + QScopedPointer m_keyboard; + QScopedPointer m_touch; + QScopedPointer m_inputMethod; + QScopedPointer m_data_device; void seat_bind_resource(wl_seat::Resource *resource) Q_DECL_OVERRIDE; @@ -152,8 +149,6 @@ private: void seat_destroy_resource(wl_seat::Resource *resource) Q_DECL_OVERRIDE; }; -} - QT_END_NAMESPACE #endif // WLINPUTDEVICE_H diff --git a/src/compositor/wayland_wrapper/qwlinputmethod.cpp b/src/compositor/wayland_wrapper/qwlinputmethod.cpp index 187c4e13d..a9ea4bbb3 100644 --- a/src/compositor/wayland_wrapper/qwlinputmethod.cpp +++ b/src/compositor/wayland_wrapper/qwlinputmethod.cpp @@ -47,15 +47,15 @@ QT_BEGIN_NAMESPACE namespace QtWayland { -InputMethod::InputMethod(Compositor *compositor, InputDevice *seat) - : QtWaylandServer::wl_input_method(seat->compositor()->wl_display(), 1) +InputMethod::InputMethod(QWaylandCompositor *compositor, QWaylandInputDevice *seat) + : QtWaylandServer::wl_input_method(seat->compositor()->waylandDisplay(), 1) , m_compositor(compositor) , m_seat(seat) , m_resource(0) , m_textInput() , m_context() { - connect(seat->keyboardDevice(), SIGNAL(focusChanged(Surface*)), this, SLOT(focusChanged(Surface*))); + connect(seat->keyboard(), SIGNAL(focusChanged(Surface*)), this, SLOT(focusChanged(Surface*))); } InputMethod::~InputMethod() @@ -78,7 +78,7 @@ void InputMethod::activate(TextInput *textInput) send_activate(m_resource->handle, m_context->resource()->handle); - QWaylandInputPanelPrivate *panel = QWaylandInputPanelPrivate::get(m_compositor->waylandCompositor()); + QWaylandInputPanelPrivate *panel = QWaylandInputPanelPrivate::get(m_compositor); if (panel) { panel->setFocus(textInput->focus()); panel->setCursorRectangle(textInput->cursorRectangle()); @@ -97,7 +97,7 @@ void InputMethod::deactivate() m_textInput = 0; m_context = 0; - QWaylandInputPanelPrivate *panel = QWaylandInputPanelPrivate::get(m_compositor->waylandCompositor()); + QWaylandInputPanelPrivate *panel = QWaylandInputPanelPrivate::get(m_compositor); if (panel) { panel->setFocus(0); panel->setCursorRectangle(QRect()); diff --git a/src/compositor/wayland_wrapper/qwlinputmethod_p.h b/src/compositor/wayland_wrapper/qwlinputmethod_p.h index 473810474..4d857c045 100644 --- a/src/compositor/wayland_wrapper/qwlinputmethod_p.h +++ b/src/compositor/wayland_wrapper/qwlinputmethod_p.h @@ -44,10 +44,11 @@ QT_BEGIN_NAMESPACE +class QWaylandInputDevice; +class QWaylandCompositor; + namespace QtWayland { -class Compositor; -class InputDevice; class InputMethodContext; class TextInput; class Surface; @@ -57,7 +58,7 @@ class InputMethod : public QObject, public QtWaylandServer::wl_input_method Q_OBJECT public: - explicit InputMethod(Compositor *compositor, InputDevice *seat); + explicit InputMethod(QWaylandCompositor *compositor, QWaylandInputDevice *seat); ~InputMethod(); void activate(TextInput *textInput); @@ -76,8 +77,8 @@ private slots: void focusChanged(Surface *surface); private: - Compositor *m_compositor; - InputDevice *m_seat; + QWaylandCompositor *m_compositor; + QWaylandInputDevice *m_seat; Resource *m_resource; TextInput *m_textInput; InputMethodContext *m_context; diff --git a/src/compositor/wayland_wrapper/qwlkeyboard.cpp b/src/compositor/wayland_wrapper/qwlkeyboard.cpp index 8a76cbb40..9811f918a 100644 --- a/src/compositor/wayland_wrapper/qwlkeyboard.cpp +++ b/src/compositor/wayland_wrapper/qwlkeyboard.cpp @@ -40,6 +40,8 @@ #include #include +#include + #include "qwlcompositor_p.h" #include "qwlsurface_p.h" @@ -52,11 +54,8 @@ QT_BEGIN_NAMESPACE -namespace QtWayland { - -Keyboard::Keyboard(Compositor *compositor, InputDevice *seat) +QWaylandKeyboardPrivate::QWaylandKeyboardPrivate(QWaylandInputDevice *seat) : QtWaylandServer::wl_keyboard() - , m_compositor(compositor) , m_seat(seat) , m_grab(this) , m_focus() @@ -74,10 +73,9 @@ Keyboard::Keyboard(Compositor *compositor, InputDevice *seat) #ifndef QT_NO_WAYLAND_XKB initXKB(); #endif - connect(&m_focusDestroyListener, &WlListener::fired, this, &Keyboard::focusDestroyed); } -Keyboard::~Keyboard() +QWaylandKeyboardPrivate::~QWaylandKeyboardPrivate() { #ifndef QT_NO_WAYLAND_XKB if (m_context) { @@ -90,55 +88,57 @@ Keyboard::~Keyboard() #endif } -KeyboardGrabber::~KeyboardGrabber() -{ -} - -void Keyboard::startGrab(KeyboardGrabber *grab) +void QWaylandKeyboardPrivate::startGrab(QWaylandKeyboardGrabber *grab) { + Q_Q(QWaylandKeyboard); m_grab = grab; - m_grab->m_keyboard = this; + m_grab->m_keyboard = q; m_grab->focused(m_focus); } -void Keyboard::endGrab() +void QWaylandKeyboardPrivate::endGrab() { m_grab = this; } -KeyboardGrabber *Keyboard::currentGrab() const +QWaylandKeyboardGrabber *QWaylandKeyboardPrivate::currentGrab() const { return m_grab; } -void Keyboard::focused(Surface *surface) +QWaylandKeyboardPrivate *QWaylandKeyboardPrivate::get(QWaylandKeyboard *keyboard) +{ + return keyboard->d_func(); +} + +void QWaylandKeyboardPrivate::focused(QWaylandSurface *surface) { if (m_focusResource && m_focus != surface) { - uint32_t serial = wl_display_next_serial(m_compositor->wl_display()); - send_leave(m_focusResource->handle, serial, m_focus->resource()->handle); + uint32_t serial = wl_display_next_serial(compositor()->waylandDisplay()); + send_leave(m_focusResource->handle, serial, m_focus->handle()->resource()->handle); m_focusDestroyListener.reset(); } - Resource *resource = surface ? resourceMap().value(surface->resource()->client()) : 0; + Resource *resource = surface ? resourceMap().value(surface->client()->client()) : 0; if (resource && (m_focus != surface || m_focusResource != resource)) { - uint32_t serial = wl_display_next_serial(m_compositor->wl_display()); + uint32_t serial = wl_display_next_serial(compositor()->waylandDisplay()); send_modifiers(resource->handle, serial, m_modsDepressed, m_modsLatched, m_modsLocked, m_group); - send_enter(resource->handle, serial, surface->resource()->handle, QByteArray::fromRawData((char *)m_keys.data(), m_keys.size() * sizeof(uint32_t))); - m_focusDestroyListener.listenForDestruction(surface->resource()->handle); + send_enter(resource->handle, serial, surface->resource(), QByteArray::fromRawData((char *)m_keys.data(), m_keys.size() * sizeof(uint32_t))); + m_focusDestroyListener.listenForDestruction(surface->resource()); } m_focusResource = resource; m_focus = surface; - Q_EMIT focusChanged(m_focus); + Q_EMIT q_func()->focusChanged(m_focus); } -void Keyboard::setFocus(Surface* surface) +void QWaylandKeyboardPrivate::setFocus(QWaylandSurface* surface) { m_grab->focused(surface); } -void Keyboard::setKeymap(const QWaylandKeymap &keymap) +void QWaylandKeyboardPrivate::setKeymap(const QWaylandKeymap &keymap) { m_keymap = keymap; @@ -152,41 +152,27 @@ void Keyboard::setKeymap(const QWaylandKeymap &keymap) } } -void Keyboard::focusDestroyed(void *data) -{ - Q_UNUSED(data) - m_focusDestroyListener.reset(); - - m_focus = 0; - m_focusResource = 0; -} - -void Keyboard::sendKeyModifiers(wl_keyboard::Resource *resource, uint32_t serial) +void QWaylandKeyboardPrivate::sendKeyModifiers(wl_keyboard::Resource *resource, uint32_t serial) { send_modifiers(resource->handle, serial, m_modsDepressed, m_modsLatched, m_modsLocked, m_group); } -void Keyboard::sendKeyPressEvent(uint code) +void QWaylandKeyboardPrivate::sendKeyPressEvent(uint code) { sendKeyEvent(code, WL_KEYBOARD_KEY_STATE_PRESSED); } -void Keyboard::sendKeyReleaseEvent(uint code) +void QWaylandKeyboardPrivate::sendKeyReleaseEvent(uint code) { sendKeyEvent(code, WL_KEYBOARD_KEY_STATE_RELEASED); } -Surface *Keyboard::focus() const +QWaylandSurface *QWaylandKeyboardPrivate::focus() const { return m_focus; } -QtWaylandServer::wl_keyboard::Resource *Keyboard::focusResource() const -{ - return m_focusResource; -} - -void Keyboard::keyboard_bind_resource(wl_keyboard::Resource *resource) +void QWaylandKeyboardPrivate::keyboard_bind_resource(wl_keyboard::Resource *resource) { #ifndef QT_NO_WAYLAND_XKB if (m_context) { @@ -201,26 +187,33 @@ void Keyboard::keyboard_bind_resource(wl_keyboard::Resource *resource) close(null_fd); } -void Keyboard::keyboard_destroy_resource(wl_keyboard::Resource *resource) +void QWaylandKeyboardPrivate::keyboard_destroy_resource(wl_keyboard::Resource *resource) { if (m_focusResource == resource) m_focusResource = 0; } -void Keyboard::keyboard_release(wl_keyboard::Resource *resource) +void QWaylandKeyboardPrivate::keyboard_release(wl_keyboard::Resource *resource) { wl_resource_destroy(resource->handle); } -void Keyboard::key(uint32_t serial, uint32_t time, uint32_t key, uint32_t state) +void QWaylandKeyboardPrivate::key(uint32_t serial, uint32_t time, uint32_t key, uint32_t state) { if (m_focusResource) { send_key(m_focusResource->handle, serial, time, key, state); } } -void Keyboard::keyEvent(uint code, uint32_t state) +void QWaylandKeyboardPrivate::sendKeyEvent(uint code, uint32_t state) { + // There must be no keys pressed when changing the keymap, + // see http://lists.freedesktop.org/archives/wayland-devel/2013-October/011395.html + if (m_pendingKeymap && m_keys.isEmpty()) + updateKeymap(); + + uint32_t time = compositor()->currentTimeMsecs(); + uint32_t serial = wl_display_next_serial(compositor()->waylandDisplay()); uint key = code - 8; if (state == WL_KEYBOARD_KEY_STATE_PRESSED) { m_keys << key; @@ -241,7 +234,7 @@ void Keyboard::sendKeyEvent(uint code, uint32_t state) m_grab->key(serial, time, key, state); } -void Keyboard::modifiers(uint32_t serial, uint32_t mods_depressed, +void QWaylandKeyboardPrivate::modifiers(uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group) { if (m_focusResource) { @@ -249,7 +242,7 @@ void Keyboard::modifiers(uint32_t serial, uint32_t mods_depressed, } } -void Keyboard::updateModifierState(uint code, uint32_t state) +void QWaylandKeyboardPrivate::updateModifierState(uint code, uint32_t state) { #ifndef QT_NO_WAYLAND_XKB if (!m_context) @@ -273,14 +266,14 @@ void Keyboard::updateModifierState(uint code, uint32_t state) m_modsLocked = modsLocked; m_group = group; - m_grab->modifiers(wl_display_next_serial(m_compositor->wl_display()), m_modsDepressed, m_modsLatched, m_modsLocked, m_group); + m_grab->modifiers(wl_display_next_serial(compositor()->waylandDisplay()), m_modsDepressed, m_modsLatched, m_modsLocked, m_group); #else Q_UNUSED(code); Q_UNUSED(state); #endif } -void Keyboard::updateKeymap() +void QWaylandKeyboardPrivate::updateKeymap() { // There must be no keys pressed when changing the keymap, // see http://lists.freedesktop.org/archives/wayland-devel/2013-October/011395.html @@ -299,7 +292,7 @@ void Keyboard::updateKeymap() xkb_state_update_mask(m_state, 0, m_modsLatched, m_modsLocked, 0, 0, 0); if (m_focusResource) - sendKeyModifiers(m_focusResource, wl_display_next_serial(m_compositor->wl_display())); + sendKeyModifiers(m_focusResource, wl_display_next_serial(compositor()->waylandDisplay())); #endif } @@ -334,7 +327,7 @@ static int createAnonymousFile(size_t size) return fd; } -void Keyboard::initXKB() +void QWaylandKeyboardPrivate::initXKB() { m_context = xkb_context_new(static_cast(0)); if (!m_context) { @@ -345,7 +338,7 @@ void Keyboard::initXKB() createXKBKeymap(); } -void Keyboard::createXKBKeymap() +void QWaylandKeyboardPrivate::createXKBKeymap() { if (!m_context) return; @@ -390,6 +383,4 @@ void Keyboard::createXKBKeymap() } #endif -} // namespace QtWayland - QT_END_NAMESPACE diff --git a/src/compositor/wayland_wrapper/qwlkeyboard_p.h b/src/compositor/wayland_wrapper/qwlkeyboard_p.h index 62fc157a2..2579c2da1 100644 --- a/src/compositor/wayland_wrapper/qwlkeyboard_p.h +++ b/src/compositor/wayland_wrapper/qwlkeyboard_p.h @@ -40,8 +40,10 @@ #include #include +#include +#include -#include +#include #include #include @@ -50,7 +52,6 @@ #include #endif -#include "qwllistener_p.h" QT_BEGIN_NAMESPACE @@ -61,55 +62,39 @@ class InputDevice; class Surface; class Keyboard; -class Q_COMPOSITOR_EXPORT KeyboardGrabber { - public: - virtual ~KeyboardGrabber(); - virtual void focused(Surface *surface) = 0; - virtual void key(uint32_t serial, uint32_t time, uint32_t key, uint32_t state) = 0; - virtual void modifiers(uint32_t serial, uint32_t mods_depressed, - uint32_t mods_latched, uint32_t mods_locked, uint32_t group) = 0; +} - Keyboard *m_keyboard; -}; - -class Q_COMPOSITOR_EXPORT Keyboard : public QObject, public QtWaylandServer::wl_keyboard, public KeyboardGrabber +class Q_COMPOSITOR_EXPORT QWaylandKeyboardPrivate : public QObjectPrivate + , public QtWaylandServer::wl_keyboard + , public QWaylandKeyboardGrabber { - Q_OBJECT - public: - Keyboard(Compositor *compositor, InputDevice *seat); - ~Keyboard(); + Q_DECLARE_PUBLIC(QWaylandKeyboard) + + QWaylandKeyboardPrivate(QWaylandInputDevice *seat); + ~QWaylandKeyboardPrivate(); - void setFocus(Surface *surface); + QWaylandCompositor *compositor() const { return m_seat->compositor(); } + void setFocus(QWaylandSurface *surface); void setKeymap(const QWaylandKeymap &keymap); void sendKeyModifiers(Resource *resource, uint32_t serial); void sendKeyPressEvent(uint code); void sendKeyReleaseEvent(uint code); - Surface *focus() const; - Resource *focusResource() const; + QWaylandSurface *focus() const; + Resource *focusResource() const { return m_focusResource; } - void focused(Surface* surface); + void focused(QWaylandSurface* surface); void key(uint32_t serial, uint32_t time, uint32_t key, uint32_t state); void modifiers(uint32_t serial, uint32_t mods_depressed, - uint32_t mods_latched, uint32_t mods_locked, uint32_t group); + uint32_t mods_latched, uint32_t mods_locked, uint32_t group); - void keyEvent(uint code, uint32_t state); - void updateModifierState(uint code, uint32_t state); - void updateKeymap(); + void startGrab(QWaylandKeyboardGrabber *grab); + void endGrab(); + QWaylandKeyboardGrabber *currentGrab() const; - void startGrab(KeyboardGrabber *grab); - void endGrab(); - KeyboardGrabber *currentGrab() const; - -#ifndef QT_NO_WAYLAND_XKB - struct xkb_state *xkbState() const { return m_state; } - uint32_t xkbModsMask() const { return m_modsDepressed | m_modsLatched | m_modsLocked; } -#endif - -Q_SIGNALS: - void focusChanged(Surface *surface); + static QWaylandKeyboardPrivate *get(QWaylandKeyboard *keyboard); protected: void keyboard_bind_resource(Resource *resource); @@ -118,20 +103,20 @@ protected: private: void sendKeyEvent(uint code, uint32_t state); - void focusDestroyed(void *data); + void updateModifierState(uint code, uint32_t state); + void updateKeymap(); #ifndef QT_NO_WAYLAND_XKB void initXKB(); void createXKBKeymap(); #endif - Compositor *m_compositor; - InputDevice *m_seat; + QWaylandInputDevice *m_seat; - KeyboardGrabber* m_grab; - Surface *m_focus; + QWaylandKeyboardGrabber* m_grab; + QWaylandSurface *m_focus; Resource *m_focusResource; - WlListener m_focusDestroyListener; + QWaylandDestroyListener m_focusDestroyListener; QVector m_keys; uint32_t m_modsDepressed; @@ -150,8 +135,6 @@ private: #endif }; -} // namespace QtWayland - QT_END_NAMESPACE #endif // QTWAYLAND_QWLKEYBOARD_P_H diff --git a/src/compositor/wayland_wrapper/qwllistener.cpp b/src/compositor/wayland_wrapper/qwllistener.cpp deleted file mode 100644 index 3099cc108..000000000 --- a/src/compositor/wayland_wrapper/qwllistener.cpp +++ /dev/null @@ -1,65 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2014 Jolla Ltd, author: -** Contact: http://www.qt.io/licensing/ -** -** This file is part of the QtWaylandCompositor module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL3$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see http://www.qt.io/terms-conditions. For further -** information use the contact form at http://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPLv3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or later as published by the Free -** Software Foundation and appearing in the file LICENSE.GPL included in -** the packaging of this file. Please review the following information to -** ensure the GNU General Public License version 2.0 requirements will be -** met: http://www.gnu.org/licenses/gpl-2.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#include "qwllistener_p.h" - -QT_BEGIN_NAMESPACE - -WlListener::WlListener() -{ - m_listener.parent = this; - m_listener.listener.notify = handler; - wl_list_init(&m_listener.listener.link); -} - -void WlListener::listenForDestruction(::wl_resource *resource) -{ - wl_resource_add_destroy_listener(resource, &m_listener.listener); -} - -void WlListener::reset() -{ - wl_list_remove(&m_listener.listener.link); - wl_list_init(&m_listener.listener.link); -} - -void WlListener::handler(wl_listener *listener, void *data) -{ - WlListener *that = reinterpret_cast(listener)->parent; - emit that->fired(data); -} - -QT_END_NAMESPACE diff --git a/src/compositor/wayland_wrapper/qwllistener_p.h b/src/compositor/wayland_wrapper/qwllistener_p.h deleted file mode 100644 index 8ecab6f7f..000000000 --- a/src/compositor/wayland_wrapper/qwllistener_p.h +++ /dev/null @@ -1,70 +0,0 @@ -/**************************************************************************** -** -** Copyright (C) 2014 Jolla Ltd, author: -** Contact: http://www.qt.io/licensing/ -** -** This file is part of the QtWaylandCompositor module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL3$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see http://www.qt.io/terms-conditions. For further -** information use the contact form at http://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPLv3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or later as published by the Free -** Software Foundation and appearing in the file LICENSE.GPL included in -** the packaging of this file. Please review the following information to -** ensure the GNU General Public License version 2.0 requirements will be -** met: http://www.gnu.org/licenses/gpl-2.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ - -#ifndef QTWAYLAND_QWLLISTENER_H -#define QTWAYLAND_QWLLISTENER_H - -#include - -#include - -QT_BEGIN_NAMESPACE - -class WlListener : public QObject -{ - Q_OBJECT -public: - WlListener(); - - void listenForDestruction(::wl_resource *resource); - void reset(); - -signals: - void fired(void *data); - -private: - static void handler(wl_listener *listener, void *data); - - struct Listener { - wl_listener listener; - WlListener *parent; - }; - Listener m_listener; -}; - -QT_END_NAMESPACE - -#endif diff --git a/src/compositor/wayland_wrapper/qwloutput_p.h b/src/compositor/wayland_wrapper/qwloutput_p.h index 974f5a789..1a261241b 100644 --- a/src/compositor/wayland_wrapper/qwloutput_p.h +++ b/src/compositor/wayland_wrapper/qwloutput_p.h @@ -95,6 +95,7 @@ public: void setGeometry(const QRect &geometry); void setWidth(int newWidth); void setHeight(int newHeight); + QPoint topLeft() const { return geometry().topLeft(); } bool sizeFollowsWindow() const; void setSizeFollowsWindow(bool follow); diff --git a/src/compositor/wayland_wrapper/qwlpointer.cpp b/src/compositor/wayland_wrapper/qwlpointer.cpp index 389964fa2..127003d36 100644 --- a/src/compositor/wayland_wrapper/qwlpointer.cpp +++ b/src/compositor/wayland_wrapper/qwlpointer.cpp @@ -46,196 +46,77 @@ QT_BEGIN_NAMESPACE -namespace QtWayland { - -using QtWaylandServer::wl_keyboard; - -static uint32_t toWaylandButton(Qt::MouseButton button) -{ -#ifndef BTN_LEFT - uint32_t BTN_LEFT = 0x110; -#endif - // the range of valid buttons (evdev module) is from 0x110 - // through 0x11f. 0x120 is the first 'Joystick' button. - switch (button) { - case Qt::LeftButton: return BTN_LEFT; - case Qt::RightButton: return uint32_t(0x111); - case Qt::MiddleButton: return uint32_t(0x112); - case Qt::ExtraButton1: return uint32_t(0x113); // AKA Qt::BackButton, Qt::XButton1 - case Qt::ExtraButton2: return uint32_t(0x114); // AKA Qt::ForwardButton, Qt::XButton2 - case Qt::ExtraButton3: return uint32_t(0x115); - case Qt::ExtraButton4: return uint32_t(0x116); - case Qt::ExtraButton5: return uint32_t(0x117); - case Qt::ExtraButton6: return uint32_t(0x118); - case Qt::ExtraButton7: return uint32_t(0x119); - case Qt::ExtraButton8: return uint32_t(0x11a); - case Qt::ExtraButton9: return uint32_t(0x11b); - case Qt::ExtraButton10: return uint32_t(0x11c); - case Qt::ExtraButton11: return uint32_t(0x11d); - case Qt::ExtraButton12: return uint32_t(0x11e); - case Qt::ExtraButton13: return uint32_t(0x11f); - // default should not occur; but if it does, then return Wayland's highest possible button number. - default: return uint32_t(0x11f); - } -} - -Pointer::Pointer(Compositor *compositor, InputDevice *seat) - : wl_pointer() - , PointerGrabber() - , m_compositor(compositor) +QWaylandPointerPrivate::QWaylandPointerPrivate(QWaylandPointer *pointer, QWaylandInputDevice *seat) + : QObjectPrivate() + , wl_pointer() , m_seat(seat) - , m_grab(this) + , m_output() + , m_defaultGrab(pointer) + , m_grab(&m_defaultGrab) , m_grabButton() , m_grabTime() , m_grabSerial() - , m_position(100, 100) - , m_focus() , m_focusResource() , m_buttonCount() { - connect(&m_focusDestroyListener, &WlListener::fired, this, &Pointer::focusDestroyed); -} - -void Pointer::setFocus(QWaylandSurfaceView *surface, const QPointF &position) -{ - if (m_focusResource && m_focus != surface) { - uint32_t serial = wl_display_next_serial(m_compositor->wl_display()); - send_leave(m_focusResource->handle, serial, m_focus->surface()->handle()->resource()->handle); - m_focusDestroyListener.reset(); - } - - Resource *resource = surface ? resourceMap().value(surface->surface()->handle()->resource()->client()) : 0; - - if (resource && (m_focus != surface || resource != m_focusResource)) { - uint32_t serial = wl_display_next_serial(m_compositor->wl_display()); - Keyboard *keyboard = m_seat->keyboardDevice(); - if (keyboard) { - wl_keyboard::Resource *kr = keyboard->resourceMap().value(surface->surface()->handle()->resource()->client()); - if (kr) - keyboard->sendKeyModifiers(kr, serial); - } - send_enter(resource->handle, serial, surface->surface()->handle()->resource()->handle, - wl_fixed_from_double(position.x()), wl_fixed_from_double(position.y())); - - m_focusDestroyListener.listenForDestruction(surface->surface()->handle()->resource()->handle); - } - - m_focusResource = resource; - m_focus = surface; -} - -void Pointer::focusDestroyed(void *data) -{ - Q_UNUSED(data) - m_focusDestroyListener.reset(); - - m_focus = 0; - m_focusResource = 0; - m_buttonCount = 0; - setMouseFocus(0, QPointF(), QPointF()); - endGrab(); } -void Pointer::startGrab(PointerGrabber *grab) +void QWaylandPointerPrivate::startGrab(QWaylandPointerGrabber *grab) { + Q_Q(QWaylandPointer); m_grab = grab; - grab->m_pointer = this; + grab->pointer = q; if (m_currentPosition.view()) grab->focus(); } -void Pointer::endGrab() +void QWaylandPointerPrivate::endGrab() { - m_grab = this; + m_grab = &m_defaultGrab; m_grab->focus(); } -void Pointer::setCurrent(QWaylandSurfaceView *surface, const QPointF &point) -{ - m_currentPosition.setCurrent(surface, point); -} - -bool Pointer::buttonPressed() const +bool QWaylandPointerPrivate::buttonPressed() const { return m_buttonCount > 0; } -PointerGrabber *Pointer::currentGrab() const +QWaylandPointerGrabber *QWaylandPointerPrivate::currentGrab() const { return m_grab; } -Qt::MouseButton Pointer::grabButton() const +Qt::MouseButton QWaylandPointerPrivate::grabButton() const { return m_grabButton; } -uint32_t Pointer::grabTime() const +uint32_t QWaylandPointerPrivate::grabTime() const { return m_grabTime; } -uint32_t Pointer::grabSerial() const +uint32_t QWaylandPointerPrivate::grabSerial() const { return m_grabSerial; } -QWaylandSurfaceView *Pointer::focusSurface() const -{ - return m_focus; -} - -QWaylandSurfaceView *Pointer::current() const -{ - return m_currentPosition.view(); -} - -QPointF Pointer::position() const -{ - return m_position; -} - -QPointF Pointer::currentPosition() const -{ - return m_currentPosition.position(); -} - -QtWaylandServer::wl_pointer::Resource *Pointer::focusResource() const -{ - return m_focusResource; -} - -void Pointer::pointer_destroy_resource(wl_pointer::Resource *resource) +void QWaylandPointerPrivate::pointer_destroy_resource(wl_pointer::Resource *resource) { if (m_focusResource == resource) m_focusResource = 0; } -void Pointer::pointer_release(wl_pointer::Resource *resource) +void QWaylandPointerPrivate::pointer_release(wl_pointer::Resource *resource) { wl_resource_destroy(resource->handle); } -void Pointer::setMouseFocus(QWaylandSurfaceView *surface, const QPointF &localPos, const QPointF &globalPos) +void QWaylandPointerPrivate::sendMousePressEvent(Qt::MouseButton button) { - m_position = globalPos; - - m_currentPosition.setCurrent(surface, localPos); - - m_grab->focus(); -} - -void Pointer::sendButton(uint32_t time, Qt::MouseButton button, uint32_t state) -{ - uint32_t serial = wl_display_next_serial(m_compositor->wl_display()); - send_button(m_focusResource->handle, serial, time, toWaylandButton(button), state); -} - -void Pointer::sendMousePressEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos) -{ - sendMouseMoveEvent(localPos, globalPos); - uint32_t time = m_compositor->currentTimeMsecs(); + Q_Q(QWaylandPointer); + uint32_t time = compositor()->currentTimeMsecs(); if (m_buttonCount == 0) { m_grabButton = button; m_grabTime = time; @@ -243,112 +124,86 @@ void Pointer::sendMousePressEvent(Qt::MouseButton button, const QPointF &localPo m_buttonCount++; m_grab->button(time, button, WL_POINTER_BUTTON_STATE_PRESSED); - if (m_buttonCount == 1) - m_grabSerial = wl_display_get_serial(m_compositor->wl_display()); + if (m_buttonCount == 1) { + m_grabSerial = wl_display_get_serial(compositor()->waylandDisplay()); + q->buttonPressedChanged(); + } } -void Pointer::sendMouseReleaseEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos) +void QWaylandPointerPrivate::sendMouseReleaseEvent(Qt::MouseButton button) { - sendMouseMoveEvent(localPos, globalPos); - uint32_t time = m_compositor->currentTimeMsecs(); + Q_Q(QWaylandPointer); + uint32_t time = compositor()->currentTimeMsecs(); m_buttonCount--; m_grab->button(time, button, WL_POINTER_BUTTON_STATE_RELEASED); if (m_buttonCount == 1) - m_grabSerial = wl_display_get_serial(m_compositor->wl_display()); + m_grabSerial = wl_display_get_serial(compositor()->waylandDisplay()); + if (m_buttonCount == 0) + q->buttonPressedChanged(); } -void Pointer::sendMouseMoveEvent(const QPointF &localPos, const QPointF &globalPos) +void QWaylandPointerPrivate::sendMouseMoveEvent(QWaylandSurfaceView *view, const QPointF &localPos, const QPointF &outputSpacePos) { - uint32_t time = m_compositor->currentTimeMsecs(); + Q_Q(QWaylandPointer); + if (m_focusResource && focusView() != view) { + uint32_t serial = wl_display_next_serial(compositor()->waylandDisplay()); + send_leave(m_focusResource->handle, serial, focusView()->surface()->handle()->resource()->handle); + m_focusDestroyListener.reset(); + } + + Resource *resource = view ? resourceMap().value(view->surface()->handle()->resource()->client()) : 0; + + if (resource && (focusView() != view || resource != m_focusResource)) { + uint32_t serial = wl_display_next_serial(compositor()->waylandDisplay()); + QWaylandKeyboard *keyboard = m_seat->keyboard(); + if (keyboard) { + keyboard->sendKeyModifiers(view->surface()->client(), serial); + } + send_enter(resource->handle, serial, view->surface()->handle()->resource()->handle, + wl_fixed_from_double(currentLocalPosition().x()), wl_fixed_from_double(currentLocalPosition().y())); - m_position = globalPos; + m_focusDestroyListener.listenForDestruction(view->surface()->handle()->resource()->handle); + } - m_currentPosition.updatePosition(localPos); + m_focusResource = resource; + m_currentPosition.updatePosition(view, localPos); + m_spacePosition = outputSpacePos; + if (view && view->output()) + q->setOutput(view->output()); - m_grab->motion(time); + m_grab->motion(compositor()->currentTimeMsecs()); } -void Pointer::sendMouseWheelEvent(Qt::Orientation orientation, int delta) +void QWaylandPointerPrivate::sendMouseWheelEvent(Qt::Orientation orientation, int delta) { if (!m_focusResource) return; - uint32_t time = m_compositor->currentTimeMsecs(); + uint32_t time = compositor()->currentTimeMsecs(); uint32_t axis = orientation == Qt::Horizontal ? WL_POINTER_AXIS_HORIZONTAL_SCROLL : WL_POINTER_AXIS_VERTICAL_SCROLL; send_axis(m_focusResource->handle, time, axis, wl_fixed_from_int(-delta / 12)); } -void Pointer::sendMouseEnterEvent(QWaylandSurfaceView *view, const QPointF &localPos) -{ - if (view == m_currentPosition.view()) { - qWarning("Possible input state error. Want to send enter event for the current input surface"); - } - - setMouseFocus(view, localPos, QPointF()); -} - -void Pointer::sendMouseLeaveEvent(QWaylandSurfaceView *view) -{ - if (view != m_currentPosition.view()) { - return; - } - - setMouseFocus(Q_NULLPTR, QPointF(), QPointF()); -} - -void Pointer::focus() -{ - if (buttonPressed()) - return; - - setFocus(m_currentPosition.view(), m_currentPosition.position()); -} - -void Pointer::motion(uint32_t time) -{ - if (m_focusResource) - send_motion(m_focusResource->handle, time, - wl_fixed_from_double(m_currentPosition.x()), - wl_fixed_from_double(m_currentPosition.y())); - -} - -void Pointer::button(uint32_t time, Qt::MouseButton button, uint32_t state) -{ - if (m_focusResource) { - sendButton(time, button, state); - } - - if (!buttonPressed() && state == WL_POINTER_BUTTON_STATE_RELEASED) - setFocus(m_currentPosition.view(), m_currentPosition.position()); -} - static void requestCursorSurface(QWaylandCompositor *compositor, QWaylandSurface *surface, int32_t hotspot_x, int hotspot_y) { compositor->currentCurserSurfaceRequest(surface, hotspot_x, hotspot_y); } -void Pointer::pointer_set_cursor(wl_pointer::Resource *resource, uint32_t serial, wl_resource *surface, int32_t hotspot_x, int32_t hotspot_y) +void QWaylandPointerPrivate::pointer_set_cursor(wl_pointer::Resource *resource, uint32_t serial, wl_resource *surface, int32_t hotspot_x, int32_t hotspot_y) { Q_UNUSED(resource); Q_UNUSED(serial); if (!surface) { - requestCursorSurface(m_compositor->waylandCompositor(), Q_NULLPTR, 0, 0); + requestCursorSurface(compositor(), Q_NULLPTR, 0, 0); return; } - Surface *s = Surface::fromResource(surface); - s->setCursorSurface(true); - requestCursorSurface(m_compositor->waylandCompositor(), s->waylandSurface(), hotspot_x, hotspot_y); + QWaylandSurface *s = QWaylandSurface::fromResource(surface); + s->markAsCursorSurface(true); + requestCursorSurface(compositor(), s, hotspot_x, hotspot_y); } -PointerGrabber::~PointerGrabber() -{ -} - -} // namespace QtWayland - QT_END_NAMESPACE diff --git a/src/compositor/wayland_wrapper/qwlpointer_p.h b/src/compositor/wayland_wrapper/qwlpointer_p.h index 5fe1fc99e..616464318 100644 --- a/src/compositor/wayland_wrapper/qwlpointer_p.h +++ b/src/compositor/wayland_wrapper/qwlpointer_p.h @@ -39,19 +39,21 @@ #define QTWAYLAND_QWLPOINTER_P_H #include +#include +#include #include #include #include +#include #include #include #include +#include #include -#include "qwllistener_p.h" - QT_BEGIN_NAMESPACE class QWaylandSurfaceView; @@ -59,21 +61,8 @@ class QWaylandSurfaceView; namespace QtWayland { class Compositor; -class InputDevice; -class Pointer; class Surface; -class Q_COMPOSITOR_EXPORT PointerGrabber { -public: - virtual ~PointerGrabber(); - - virtual void focus() = 0; - virtual void motion(uint32_t time) = 0; - virtual void button(uint32_t time, Qt::MouseButton button, uint32_t state) = 0; - - Pointer *m_pointer; -}; - class CurrentPosition { public: @@ -81,8 +70,15 @@ public: : m_view(Q_NULLPTR) {} - void updatePosition(const QPointF &position) + void reset() { + m_point = QPointF(); + m_view = Q_NULLPTR; + } + + void updatePosition(QWaylandSurfaceView *view, const QPointF &position) + { + m_view = view; m_point = position; //we adjust if the mouse position is on the edge //to work around Qt's event propogation @@ -102,59 +98,57 @@ public: qreal x() const { return m_point.x(); } qreal y() const { return m_point.y(); } - void setView(QWaylandSurfaceView *view) { m_view = view; } QWaylandSurfaceView *view() const { return m_view; } - void setCurrent(QWaylandSurfaceView *view, const QPointF &position) - { - QPointF toSet = view || position.isNull() ? position : QPointF(); - setView(view); - updatePosition(toSet); - } - private: QWaylandSurfaceView *m_view; QPointF m_point; }; -class Q_COMPOSITOR_EXPORT Pointer : public QObject, public QtWaylandServer::wl_pointer, public PointerGrabber + +} // namespace QtWayland + +class Q_COMPOSITOR_EXPORT QWaylandPointerPrivate : public QObjectPrivate + , public QtWaylandServer::wl_pointer { + Q_DECLARE_PUBLIC(QWaylandPointer) public: - Pointer(Compositor *compositor, InputDevice *seat); + QWaylandPointerPrivate(QWaylandPointer *pointer, QWaylandInputDevice *seat); + + QWaylandOutput *output() const { return m_output; } + void setOutput(QWaylandOutput *output) + { + if (m_output == output) return; + Q_Q(QWaylandPointer); + m_output = output; + q->outputChanged(); + } - void setFocus(QWaylandSurfaceView *surface, const QPointF &position); - void startGrab(PointerGrabber *currentGrab); + void startGrab(QWaylandPointerGrabber *currentGrab); void endGrab(); - PointerGrabber *currentGrab() const; + QWaylandPointerGrabber *currentGrab() const; Qt::MouseButton grabButton() const; uint32_t grabTime() const; uint32_t grabSerial() const; - void setCurrent(QWaylandSurfaceView *surface, const QPointF &point); - void setMouseFocus(QWaylandSurfaceView *surface, const QPointF &localPos, const QPointF &globalPos); - - void sendButton(uint32_t time, Qt::MouseButton button, uint32_t state); - - void sendMousePressEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos); - void sendMouseReleaseEvent(Qt::MouseButton button, const QPointF &localPos, const QPointF &globalPos); - void sendMouseMoveEvent(const QPointF &localPos, const QPointF &globalPos); + void sendMousePressEvent(Qt::MouseButton button); + void sendMouseReleaseEvent(Qt::MouseButton button); + void sendMouseMoveEvent(QWaylandSurfaceView *view, const QPointF &localPos, const QPointF &outputSpacePos); void sendMouseWheelEvent(Qt::Orientation orientation, int delta); - void sendMouseEnterEvent(QWaylandSurfaceView *view, const QPointF &localPos); - void sendMouseLeaveEvent(QWaylandSurfaceView *view); - QWaylandSurfaceView *focusSurface() const; - QWaylandSurfaceView *current() const; - QPointF position() const; - QPointF currentPosition() const; - Resource *focusResource() const; + Resource *focusResource() const { return m_focusResource; } + QWaylandSurfaceView *focusView() const { return m_currentPosition.view(); } bool buttonPressed() const; - void focus() Q_DECL_OVERRIDE; - void motion(uint32_t time) Q_DECL_OVERRIDE; - void button(uint32_t time, Qt::MouseButton button, uint32_t state) Q_DECL_OVERRIDE; + QWaylandInputDevice *seat() const { return m_seat; } + QWaylandCompositor *compositor() const { return m_seat->compositor(); } + void resetCurrentState() { m_currentPosition.reset(); } + QWaylandSurfaceView *currentView() const { return m_currentPosition.view(); } + QPointF currentSpacePosition() const { return m_spacePosition; } + QPointF currentLocalPosition() const { return m_currentPosition.position(); } protected: void pointer_set_cursor(Resource *resource, uint32_t serial, wl_resource *surface, int32_t hotspot_x, int32_t hotspot_y) Q_DECL_OVERRIDE; void pointer_release(Resource *resource) Q_DECL_OVERRIDE; @@ -163,28 +157,25 @@ protected: private: void focusDestroyed(void *data); - Compositor *m_compositor; - InputDevice *m_seat; + QWaylandInputDevice *m_seat; + QWaylandOutput *m_output; + QWaylandDefaultPointerGrabber m_defaultGrab; + QtWayland::CurrentPosition m_currentPosition; + QPointF m_spacePosition; - PointerGrabber *m_grab; + QWaylandPointerGrabber *m_grab; Qt::MouseButton m_grabButton; uint32_t m_grabTime; uint32_t m_grabSerial; - QPointF m_position; - - QWaylandSurfaceView *m_focus; Resource *m_focusResource; - CurrentPosition m_currentPosition; int m_buttonCount; - WlListener m_focusDestroyListener; + QWaylandDestroyListener m_focusDestroyListener; }; -} // namespace QtWayland - QT_END_NAMESPACE #endif // QTWAYLAND_QWLPOINTER_P_H diff --git a/src/compositor/wayland_wrapper/qwlsurface.cpp b/src/compositor/wayland_wrapper/qwlsurface.cpp index 498d9f23a..d5eed707a 100644 --- a/src/compositor/wayland_wrapper/qwlsurface.cpp +++ b/src/compositor/wayland_wrapper/qwlsurface.cpp @@ -292,9 +292,8 @@ void Surface::setBackBuffer(SurfaceBuffer *buffer, const QRegion &damage) m_damage = m_damage.intersected(QRect(QPoint(), m_size)); emit m_waylandSurface->damaged(m_damage); - } else { - m_compositor->resetInputDevice(this); } + m_damage = damage; QWaylandSurfacePrivate *priv = QWaylandSurfacePrivate::get(waylandSurface()); diff --git a/src/compositor/wayland_wrapper/qwltouch.cpp b/src/compositor/wayland_wrapper/qwltouch.cpp index b5a17c1a6..98daa20c9 100644 --- a/src/compositor/wayland_wrapper/qwltouch.cpp +++ b/src/compositor/wayland_wrapper/qwltouch.cpp @@ -40,44 +40,34 @@ #include "qwlcompositor_p.h" #include "qwlsurface_p.h" #include "qwaylandsurfaceview.h" +#include "qwlqttouch_p.h" QT_BEGIN_NAMESPACE -namespace QtWayland { - -Touch::Touch(Compositor *compositor) +QWaylandTouchPrivate::QWaylandTouchPrivate(QWaylandTouch *touch, QWaylandInputDevice *seat) : wl_touch() - , m_compositor(compositor) - , m_focus() + , m_seat(seat) , m_focusResource() - , m_grab(this) -{ - m_grab->setTouch(this); - connect(&m_focusDestroyListener, &WlListener::fired, this, &Touch::focusDestroyed); -} - -void Touch::setFocus(QWaylandSurfaceView *surface) + , m_defaultGrab() + , m_grab(&m_defaultGrab) { - m_focusDestroyListener.reset(); - if (surface) - m_focusDestroyListener.listenForDestruction(surface->surface()->handle()->resource()->handle); - - m_focus = surface; - m_focusResource = surface ? resourceMap().value(surface->surface()->handle()->resource()->client()) : 0; + m_grab->touch = touch; + connect(&m_focusDestroyListener, &QWaylandDestroyListener::fired, this, &QWaylandTouchPrivate::focusDestroyed); } -void Touch::startGrab(TouchGrabber *grab) +void QWaylandTouchPrivate::startGrab(QWaylandTouchGrabber *grab) { + Q_Q(QWaylandTouch); m_grab = grab; - grab->setTouch(this); + grab->touch = q; } -void Touch::endGrab() +void QWaylandTouchPrivate::endGrab() { - m_grab = this; + m_grab = &m_defaultGrab; } -void Touch::focusDestroyed(void *data) +void QWaylandTouchPrivate::focusDestroyed(void *data) { Q_UNUSED(data) m_focusDestroyListener.reset(); @@ -86,98 +76,88 @@ void Touch::focusDestroyed(void *data) m_focusResource = 0; } -void Touch::touch_destroy_resource(Resource *resource) +void QWaylandTouchPrivate::touch_destroy_resource(Resource *resource) { if (m_focusResource == resource) m_focusResource = 0; } -void Touch::touch_release(Resource *resource) +void QWaylandTouchPrivate::touch_release(Resource *resource) { wl_resource_destroy(resource->handle); } -void Touch::sendCancel() +void QWaylandTouchPrivate::sendCancel() { if (m_focusResource) send_cancel(m_focusResource->handle); } -void Touch::sendFrame() +void QWaylandTouchPrivate::sendFrame() { if (m_focusResource) send_frame(m_focusResource->handle); } -void Touch::sendDown(int touch_id, const QPointF &position) +void QWaylandTouchPrivate::sendTouchPoint(int id, const QPointF &point, Qt::TouchPointState state) { - m_grab->down(m_compositor->currentTimeMsecs(), touch_id, position); + switch (state) { + case Qt::TouchPointPressed: + sendDown(id, point); + break; + case Qt::TouchPointMoved: + sendMotion(id, point); + break; + case Qt::TouchPointReleased: + sendUp(id); + break; + case Qt::TouchPointStationary: + // stationary points are not sent through wayland, the client must cache them + break; + default: + break; + } } -void Touch::sendMotion(int touch_id, const QPointF &position) +void QWaylandTouchPrivate::sendDown(int touch_id, const QPointF &position) { - m_grab->motion(m_compositor->currentTimeMsecs(), touch_id, position); + m_grab->down(compositor()->currentTimeMsecs(), touch_id, position); } -void Touch::sendUp(int touch_id) +void QWaylandTouchPrivate::sendMotion(int touch_id, const QPointF &position) { - m_grab->up(m_compositor->currentTimeMsecs(), touch_id); + m_grab->motion(compositor()->currentTimeMsecs(), touch_id, position); } -void Touch::down(uint32_t time, int touch_id, const QPointF &position) +void QWaylandTouchPrivate::sendUp(int touch_id) { - if (!m_focusResource || !m_focus) - return; - - uint32_t serial = wl_display_next_serial(m_compositor->wl_display()); - - send_down(m_focusResource->handle, serial, time, m_focus->surface()->handle()->resource()->handle, touch_id, - wl_fixed_from_double(position.x()), wl_fixed_from_double(position.y())); + m_grab->up(compositor()->currentTimeMsecs(), touch_id); } -void Touch::up(uint32_t time, int touch_id) +void QWaylandTouchPrivate::sendFullTouchEvent(QTouchEvent *event) { - if (!m_focusResource) + if (event->type() == QEvent::TouchCancel) { + sendCancel(); return; + } - uint32_t serial = wl_display_next_serial(m_compositor->wl_display()); - - send_up(m_focusResource->handle, serial, time, touch_id); -} - -void Touch::motion(uint32_t time, int touch_id, const QPointF &position) -{ - if (!m_focusResource) + QtWayland::TouchExtensionGlobal *ext = qobject_cast(compositor()->extension(QtWaylandServer::qt_touch_extension::name())); + if (ext && ext->postTouchEvent(event, m_seat->mouseFocus())) return; - send_motion(m_focusResource->handle, time, touch_id, - wl_fixed_from_double(position.x()), wl_fixed_from_double(position.y())); -} - -TouchGrabber::TouchGrabber() - : m_touch(0) -{ -} - -TouchGrabber::~TouchGrabber() -{ -} - -const Touch *TouchGrabber::touch() const -{ - return m_touch; -} - -Touch *TouchGrabber::touch() -{ - return m_touch; -} + const QList points = event->touchPoints(); + if (points.isEmpty()) + return; -void TouchGrabber::setTouch(Touch *touch) -{ - m_touch = touch; + const int pointCount = points.count(); + QPointF pos = m_seat->mouseFocus()->requestedPosition(); + for (int i = 0; i < pointCount; ++i) { + const QTouchEvent::TouchPoint &tp(points.at(i)); + // Convert the local pos in the compositor window to surface-relative. + QPointF p = tp.pos() - pos; + sendTouchPoint(tp.id(), p, tp.state()); + } + sendFrame(); } -} // namespace QtWayland - QT_END_NAMESPACE diff --git a/src/compositor/wayland_wrapper/qwltouch_p.h b/src/compositor/wayland_wrapper/qwltouch_p.h index f3b7d5ee6..0ba8ba921 100644 --- a/src/compositor/wayland_wrapper/qwltouch_p.h +++ b/src/compositor/wayland_wrapper/qwltouch_p.h @@ -39,78 +39,57 @@ #define QTWAYLAND_QWLTOUCH_P_H #include +#include +#include +#include #include -#include +#include #include -#include "qwllistener_p.h" - QT_BEGIN_NAMESPACE class QWaylandSurfaceView; +class QWaylandCompositor; -namespace QtWayland { - -class Compositor; -class Surface; -class Touch; - -class Q_COMPOSITOR_EXPORT TouchGrabber { -public: - TouchGrabber(); - virtual ~TouchGrabber(); - - virtual void down(uint32_t time, int touch_id, const QPointF &position) = 0; - virtual void up(uint32_t time, int touch_id) = 0; - virtual void motion(uint32_t time, int touch_id, const QPointF &position) = 0; - - const Touch *touch() const; - Touch *touch(); - void setTouch(Touch *touch); - -private: - Touch *m_touch; -}; - -class Q_COMPOSITOR_EXPORT Touch : public QObject, public QtWaylandServer::wl_touch, public TouchGrabber +class Q_COMPOSITOR_EXPORT QWaylandTouchPrivate : public QObjectPrivate, public QtWaylandServer::wl_touch { + Q_DECLARE_PUBLIC(QWaylandTouch) public: - explicit Touch(Compositor *compositor); + explicit QWaylandTouchPrivate(QWaylandTouch *touch, QWaylandInputDevice *seat); - void setFocus(QWaylandSurfaceView *surface); + QWaylandCompositor *compositor() const { return m_seat->compositor(); } - void startGrab(TouchGrabber *grab); + void startGrab(QWaylandTouchGrabber *grab); void endGrab(); void sendCancel(); void sendFrame(); + void sendTouchPoint(int id, const QPointF &point, Qt::TouchPointState state); void sendDown(int touch_id, const QPointF &position); void sendMotion(int touch_id, const QPointF &position); void sendUp(int touch_id); - void down(uint32_t time, int touch_id, const QPointF &position); - void up(uint32_t time, int touch_id); - void motion(uint32_t time, int touch_id, const QPointF &position); + void sendFullTouchEvent(QTouchEvent *event); + Resource *focusResource() const { return m_focusResource; } private: void focusDestroyed(void *data); void touch_destroy_resource(Resource *resource) Q_DECL_OVERRIDE; void touch_release(Resource *resource) Q_DECL_OVERRIDE; - Compositor *m_compositor; + QWaylandInputDevice *m_seat; QWaylandSurfaceView *m_focus; Resource *m_focusResource; - WlListener m_focusDestroyListener; + QWaylandDestroyListener m_focusDestroyListener; - TouchGrabber *m_grab; + QWaylandDefaultTouchGrabber m_defaultGrab; + QWaylandTouchGrabber *m_grab; }; -} // namespace QtWayland - QT_END_NAMESPACE #endif // QTWAYLAND_QWLTOUCH_P_H diff --git a/src/compositor/wayland_wrapper/wayland_wrapper.pri b/src/compositor/wayland_wrapper/wayland_wrapper.pri index f7a630bd4..2bc732565 100644 --- a/src/compositor/wayland_wrapper/wayland_wrapper.pri +++ b/src/compositor/wayland_wrapper/wayland_wrapper.pri @@ -21,7 +21,6 @@ HEADERS += \ wayland_wrapper/qwlsurface_p.h \ wayland_wrapper/qwlsurfacebuffer_p.h \ wayland_wrapper/qwltouch_p.h \ - wayland_wrapper/qwllistener_p.h \ ../shared/qwaylandxkb.h \ SOURCES += \ @@ -41,7 +40,6 @@ SOURCES += \ wayland_wrapper/qwlsurface.cpp \ wayland_wrapper/qwlsurfacebuffer.cpp \ wayland_wrapper/qwltouch.cpp \ - wayland_wrapper/qwllistener.cpp \ ../shared/qwaylandxkb.cpp \ INCLUDEPATH += wayland_wrapper -- cgit v1.2.3