yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

[wayland] Don't call into InputRedirection from AbstractBackend implementations

Browse source 
Instead the AbstractBackend provides methods which delegate into
InputRedirection.
This commit is contained in:
Martin Gräßlin 2015-05-05 10:44:46 +02:00
parent e283bda8e5
commit 8be38dc4f6
4 changed files with 192 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

113
abstract_backend.cpp
View file

@ -21,6 +21,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <config-kwin.h>
#include "composite.h"
#include "cursor.h"
#include "input.h"
#include "wayland_server.h"
#if HAVE_WAYLAND_CURSOR
#include "wayland_backend.h"
@ -179,4 +180,116 @@ void AbstractBackend::markCursorAsRendered()
m_cursor.lastRenderedPosition = Cursor::pos();
}
void AbstractBackend::keyboardKeyPressed(quint32 key, quint32 time)
{
if (!input()) {
return;
}
input()->processKeyboardKey(key, InputRedirection::KeyboardKeyPressed, time);
}
void AbstractBackend::keyboardKeyReleased(quint32 key, quint32 time)
{
if (!input()) {
return;
}
input()->processKeyboardKey(key, InputRedirection::KeyboardKeyReleased, time);
}
void AbstractBackend::keyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group)
{
if (!input()) {
return;
}
input()->processKeyboardModifiers(modsDepressed, modsLatched, modsLocked, group);
}
void AbstractBackend::keymapChange(int fd, uint32_t size)
{
if (!input()) {
return;
}
input()->processKeymapChange(fd, size);
}
void AbstractBackend::pointerAxisHorizontal(qreal delta, quint32 time)
{
if (!input()) {
return;
}
input()->processPointerAxis(InputRedirection::PointerAxisHorizontal, delta, time);
}
void AbstractBackend::pointerAxisVertical(qreal delta, quint32 time)
{
if (!input()) {
return;
}
input()->processPointerAxis(InputRedirection::PointerAxisVertical, delta, time);
}
void AbstractBackend::pointerButtonPressed(quint32 button, quint32 time)
{
if (!input()) {
return;
}
input()->processPointerButton(button, InputRedirection::PointerButtonPressed, time);
}
void AbstractBackend::pointerButtonReleased(quint32 button, quint32 time)
{
if (!input()) {
return;
}
input()->processPointerButton(button, InputRedirection::PointerButtonReleased, time);
}
void AbstractBackend::pointerMotion(const QPointF &position, quint32 time)
{
if (!input()) {
return;
}
input()->processPointerMotion(position, time);
}
void AbstractBackend::touchCancel()
{
if (!input()) {
return;
}
input()->cancelTouch();
}
void AbstractBackend::touchDown(qint32 id, const QPointF &pos, quint32 time)
{
if (!input()) {
return;
}
input()->processTouchDown(id, pos, time);
}
void AbstractBackend::touchFrame()
{
if (!input()) {
return;
}
input()->touchFrame();
}
void AbstractBackend::touchMotion(qint32 id, const QPointF &pos, quint32 time)
{
if (!input()) {
return;
}
input()->processTouchMotion(id, pos, time);
}
void AbstractBackend::touchUp(qint32 id, quint32 time)
{
if (!input()) {
return;
}
input()->processTouchUp(id, time);
}
}

15
abstract_backend.h
View file

@ -62,6 +62,21 @@ public:
return m_handlesOutputs;
}
void pointerMotion(const QPointF &position, quint32 time);
void pointerButtonPressed(quint32 button, quint32 time);
void pointerButtonReleased(quint32 button, quint32 time);
void pointerAxisHorizontal(qreal delta, quint32 time);
void pointerAxisVertical(qreal delta, quint32 time);
void keyboardKeyPressed(quint32 key, quint32 time);
void keyboardKeyReleased(quint32 key, quint32 time);
void keyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group);
void keymapChange(int fd, uint32_t size);
void touchDown(qint32 id, const QPointF &pos, quint32 time);
void touchUp(qint32 id, quint32 time);
void touchMotion(qint32 id, const QPointF &pos, quint32 time);
void touchCancel();
void touchFrame();
Q_SIGNALS:
void cursorChanged();

87
wayland_backend.cpp
View file

@ -21,7 +21,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "wayland_backend.h"
// KWin
#include "cursor.h"
#include "input.h"
#include "main.h"
#include "scene_qpainter.h"
#include "screens_wayland.h"
@ -87,26 +86,26 @@ WaylandSeat::WaylandSeat(wl_seat *seat, WaylandBackend *backend)
m_keyboard = m_seat->createKeyboard(this);
connect(m_keyboard, &Keyboard::keyChanged, this,
[this](quint32 key, Keyboard::KeyState state, quint32 time) {
auto toState = [state] {
switch (state) {
case Keyboard::KeyState::Pressed:
return InputRedirection::KeyboardKeyPressed;
case Keyboard::KeyState::Released:
return InputRedirection::KeyboardKeyReleased;
}
abort();
};
input()->processKeyboardKey(key, toState(), time);
switch (state) {
case Keyboard::KeyState::Pressed:
m_backend->keyboardKeyPressed(key, time);
break;
case Keyboard::KeyState::Released:
m_backend->keyboardKeyReleased(key, time);
break;
default:
Q_UNREACHABLE();
}
}
);
connect(m_keyboard, &Keyboard::modifiersChanged, this,
[this](quint32 depressed, quint32 latched, quint32 locked, quint32 group) {
input()->processKeyboardModifiers(depressed, latched, locked, group);
m_backend->keyboardModifiers(depressed, latched, locked, group);
}
);
connect(m_keyboard, &Keyboard::keymapChanged, this,
[this](int fd, quint32 size) {
input()->processKeymapChange(fd, size);
m_backend->keymapChange(fd, size);
}
);
} else {
@ -129,36 +128,36 @@ WaylandSeat::WaylandSeat(wl_seat *seat, WaylandBackend *backend)
);
connect(m_pointer, &Pointer::motion, this,
[this](const QPointF &relativeToSurface, quint32 time) {
input()->processPointerMotion(relativeToSurface.toPoint(), time);
m_backend->pointerMotion(relativeToSurface, time);
}
);
connect(m_pointer, &Pointer::buttonStateChanged, this,
[this](quint32 serial, quint32 time, quint32 button, Pointer::ButtonState state) {
Q_UNUSED(serial)
auto toState = [state] {
switch (state) {
case Pointer::ButtonState::Pressed:
return InputRedirection::PointerButtonPressed;
case Pointer::ButtonState::Released:
return InputRedirection::PointerButtonReleased;
}
abort();
};
input()->processPointerButton(button, toState(), time);
switch (state) {
case Pointer::ButtonState::Pressed:
m_backend->pointerButtonPressed(button, time);
break;
case Pointer::ButtonState::Released:
m_backend->pointerButtonReleased(button, time);
break;
default:
Q_UNREACHABLE();
}
}
);
connect(m_pointer, &Pointer::axisChanged, this,
[this](quint32 time, Pointer::Axis axis, qreal delta) {
auto toAxis = [axis] {
switch (axis) {
case Pointer::Axis::Horizontal:
return InputRedirection::PointerAxisHorizontal;
case Pointer::Axis::Vertical:
return InputRedirection::PointerAxisVertical;
}
abort();
};
input()->processPointerAxis(toAxis(), delta, time);
switch (axis) {
case Pointer::Axis::Horizontal:
m_backend->pointerAxisHorizontal(delta, time);
break;
case Pointer::Axis::Vertical:
m_backend->pointerAxisVertical(delta, time);
break;
default:
Q_UNREACHABLE();
}
}
);
} else {
@ -170,26 +169,26 @@ WaylandSeat::WaylandSeat(wl_seat *seat, WaylandBackend *backend)
[this] (bool hasTouch) {
if (hasTouch && !m_touch) {
m_touch = m_seat->createTouch(this);
connect(m_touch, &Touch::sequenceCanceled, input(), &InputRedirection::cancelTouch);
connect(m_touch, &Touch::frameEnded, input(), &InputRedirection::touchFrame);
connect(m_touch, &Touch::sequenceCanceled, m_backend, &AbstractBackend::touchCancel);
connect(m_touch, &Touch::frameEnded, m_backend, &AbstractBackend::touchFrame);
connect(m_touch, &Touch::sequenceStarted, this,
[] (TouchPoint *tp) {
input()->processTouchDown(tp->id(), tp->position(), tp->time());
[this] (TouchPoint *tp) {
m_backend->touchDown(tp->id(), tp->position(), tp->time());
}
);
connect(m_touch, &Touch::pointAdded, this,
[] (TouchPoint *tp) {
input()->processTouchDown(tp->id(), tp->position(), tp->time());
[this] (TouchPoint *tp) {
m_backend->touchDown(tp->id(), tp->position(), tp->time());
}
);
connect(m_touch, &Touch::pointRemoved, this,
[] (TouchPoint *tp) {
input()->processTouchUp(tp->id(), tp->time());
[this] (TouchPoint *tp) {
m_backend->touchUp(tp->id(), tp->time());
}
);
connect(m_touch, &Touch::pointMoved, this,
[] (TouchPoint *tp) {
input()->processTouchMotion(tp->id(), tp->position(), tp->time());
[this] (TouchPoint *tp) {
m_backend->touchMotion(tp->id(), tp->position(), tp->time());
}
);
} else {

35
x11windowed_backend.cpp
View file

@ -19,7 +19,6 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "x11windowed_backend.h"
#include "composite.h"
#include "input.h"
#include "scene_qpainter.h"
#include "screens_x11windowed.h"
#include "utils.h"
@ -150,26 +149,27 @@ void X11WindowedBackend::handleEvent(xcb_generic_event_t *e)
case XCB_BUTTON_RELEASE:
handleButtonPress(reinterpret_cast<xcb_button_press_event_t*>(e));
break;
case XCB_MOTION_NOTIFY:
if (input()) {
case XCB_MOTION_NOTIFY: {
auto event = reinterpret_cast<xcb_motion_notify_event_t*>(e);
input()->processPointerMotion(QPointF(event->event_x, event->event_y), event->time);
pointerMotion(QPointF(event->event_x, event->event_y), event->time);
}
break;
case XCB_KEY_PRESS:
case XCB_KEY_RELEASE:
if (input()) {
case XCB_KEY_RELEASE: {
auto event = reinterpret_cast<xcb_key_press_event_t*>(e);
input()->processKeyboardKey(event->detail - 8, eventType == XCB_KEY_PRESS ? InputRedirection::KeyboardKeyPressed : InputRedirection::KeyboardKeyReleased, event->time);
if (eventType == XCB_KEY_PRESS) {
keyboardKeyPressed(event->detail - 8, event->time);
} else {
keyboardKeyReleased(event->detail - 8, event->time);
}
}
break;
case XCB_CONFIGURE_NOTIFY:
updateSize(reinterpret_cast<xcb_configure_notify_event_t*>(e));
break;
case XCB_ENTER_NOTIFY:
if (input()) {
case XCB_ENTER_NOTIFY: {
auto event = reinterpret_cast<xcb_enter_notify_event_t*>(e);
input()->processPointerMotion(QPointF(event->event_x, event->event_y), event->time);
pointerMotion(QPointF(event->event_x, event->event_y), event->time);
}
break;
case XCB_CLIENT_MESSAGE:
@ -208,9 +208,12 @@ void X11WindowedBackend::handleButtonPress(xcb_button_press_event_t *event)
return;
}
const int delta = (event->detail == XCB_BUTTON_INDEX_4 || event->detail == 6) ? -1 : 1;
InputRedirection::PointerAxis axis = (event->detail > 5) ? InputRedirection::PointerAxisHorizontal : InputRedirection::PointerAxisVertical;
static const qreal s_defaultAxisStepDistance = 10.0;
input()->processPointerAxis(axis, delta * s_defaultAxisStepDistance, event->time);
if (event->detail > 5) {
pointerAxisHorizontal(delta * s_defaultAxisStepDistance, event->time);
} else {
pointerAxisVertical(delta * s_defaultAxisStepDistance, event->time);
}
return;
}
uint32_t button = 0;
@ -228,8 +231,12 @@ void X11WindowedBackend::handleButtonPress(xcb_button_press_event_t *event)
button = event->detail + BTN_LEFT - 1;
return;
}
input()->processPointerMotion(QPointF(event->event_x, event->event_y), event->time);
input()->processPointerButton(button, pressed ? InputRedirection::PointerButtonPressed : InputRedirection::PointerButtonReleased, event->time);
pointerMotion(QPointF(event->event_x, event->event_y), event->time);
if (pressed) {
pointerButtonPressed(button, event->time);
} else {
pointerButtonReleased(button, event->time);
}
}
void X11WindowedBackend::handleExpose(xcb_expose_event_t *event)