yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
kwin/cursor.cpp
Martin Gräßlin 2c333417fa Support modifier only shortcuts on X11 
Summary:
With this change KWin/X11 reuses Wayland's modifier only shortcut
architecture. The XInput2 event filter also listens for
 * XI_RawKeyPress
 * XI_RawKeyRelease

Those events are also reported if another X11 client grabs keyboard
input. Thus KWin gets all key events, just like on Wayland.

All key events are then sent through the Xkb class which performs the
mapping from key codes to key syms and is able to detect whether the
modifier got pressed/released without another key being pressed.

This change will require a few follow up changes, which are required
also for Wayland:
 * ignore if another input device got interacted (e.g. mouse press,
   touch screen, scroll, etc)
 * use the layout from XServer instead of using our own (needed on
   Wayland in nested setup)

The biggest disadvantage of the change is that it triggers a wake
up of KWin on every key event. But as KWin already listens to all
pointer events that's not a big difference and normally a key event
will wake up the compositor any way.

Reviewers: #plasma

Subscribers: kwin

Tags: #kwin

Differential Revision: https://phabricator.kde.org/D2425
2016-08-16 12:56:06 +02:00

725 lines
24 KiB
C++
Raw Blame History

/********************************************************************
KWin - the KDE window manager
This file is part of the KDE project.
Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************/
#include "cursor.h"
// kwin
#include <kwinglobals.h>
#include "input.h"
#include "keyboard_input.h"
#include "main.h"
#include "utils.h"
#include "x11eventfilter.h"
#include "xcbutils.h"
// KDE
#include <KConfig>
#include <KConfigGroup>
#include <KSharedConfig>
// Qt
#include <QAbstractEventDispatcher>
#include <QDBusConnection>
#include <QScreen>
#include <QTimer>
// xcb
#include <xcb/xfixes.h>
#include <xcb/xcb_cursor.h>
// X11
#include <X11/Xlib.h>
#if HAVE_X11_XINPUT
#include <X11/extensions/XInput2.h>
#include <X11/extensions/XI2proto.h>
#else
#define XI_RawMotion 0
#endif
#include <fixx11h.h>
namespace KWin
{
Cursor *Cursor::s_self = nullptr;
Cursor *Cursor::create(QObject *parent)
{
Q_ASSERT(!s_self);
#ifndef KCMRULES
if (kwinApp()->operationMode() == Application::OperationModeX11) {
s_self = new X11Cursor(parent);
} else {
s_self = new InputRedirectionCursor(parent);
}
#else
s_self = new X11Cursor(parent);
#endif
return s_self;
}
Cursor::Cursor(QObject *parent)
: QObject(parent)
, m_mousePollingCounter(0)
, m_cursorTrackingCounter(0)
, m_themeName("default")
, m_themeSize(24)
{
loadThemeSettings();
QDBusConnection::sessionBus().connect(QString(), QStringLiteral("/KGlobalSettings"), QStringLiteral("org.kde.KGlobalSettings"),
QStringLiteral("notifyChange"), this, SLOT(slotKGlobalSettingsNotifyChange(int,int)));
}
Cursor::~Cursor()
{
s_self = NULL;
}
void Cursor::loadThemeSettings()
{
QString themeName = QString::fromUtf8(qgetenv("XCURSOR_THEME"));
bool ok = false;
// XCURSOR_SIZE might not be set (e.g. by startkde)
uint themeSize = 0;
if (qEnvironmentVariableIsSet("XCURSOR_SIZE")) {
themeSize = qgetenv("XCURSOR_SIZE").toUInt(&ok);
}
if (!ok) {
if (QScreen *s = QGuiApplication::primaryScreen()) {
themeSize = s->logicalDotsPerInchY() * 16 / 72;
ok = true;
}
}
if (!themeName.isEmpty() && ok) {
updateTheme(themeName, themeSize);
return;
}
// didn't get from environment variables, read from config file
loadThemeFromKConfig();
}
void Cursor::loadThemeFromKConfig()
{
KConfigGroup mousecfg(KSharedConfig::openConfig("kcminputrc", KConfig::NoGlobals), "Mouse");
const QString themeName = mousecfg.readEntry("cursorTheme", "default");
bool ok = false;
uint themeSize = mousecfg.readEntry("cursorSize", QString("24")).toUInt(&ok);
if (!ok) {
themeSize = 24;
}
updateTheme(themeName, themeSize);
}
void Cursor::updateTheme(const QString &name, int size)
{
if (m_themeName != name || m_themeSize != size) {
m_themeName = name;
m_themeSize = size;
emit themeChanged();
}
}
void Cursor::slotKGlobalSettingsNotifyChange(int type, int arg)
{
Q_UNUSED(arg)
if (type == 5 /*CursorChanged*/) {
loadThemeFromKConfig();
// sync to environment
qputenv("XCURSOR_THEME", m_themeName.toUtf8());
qputenv("XCURSOR_SIZE", QByteArray::number(m_themeSize));
}
}
QPoint Cursor::pos()
{
s_self->doGetPos();
return s_self->m_pos;
}
void Cursor::setPos(const QPoint &pos)
{
// first query the current pos to not warp to the already existing pos
if (pos == Cursor::pos()) {
return;
}
s_self->m_pos = pos;
s_self->doSetPos();
}
void Cursor::setPos(int x, int y)
{
Cursor::setPos(QPoint(x, y));
}
xcb_cursor_t Cursor::getX11Cursor(Qt::CursorShape shape)
{
Q_UNUSED(shape)
return XCB_CURSOR_NONE;
}
xcb_cursor_t Cursor::getX11Cursor(const QByteArray &name)
{
Q_UNUSED(name)
return XCB_CURSOR_NONE;
}
xcb_cursor_t Cursor::x11Cursor(Qt::CursorShape shape)
{
return s_self->getX11Cursor(shape);
}
xcb_cursor_t Cursor::x11Cursor(const QByteArray &name)
{
return s_self->getX11Cursor(name);
}
void Cursor::doSetPos()
{
emit posChanged(m_pos);
}
void Cursor::doGetPos()
{
}
void Cursor::updatePos(const QPoint &pos)
{
if (m_pos == pos) {
return;
}
m_pos = pos;
emit posChanged(m_pos);
}
void Cursor::startMousePolling()
{
++m_mousePollingCounter;
if (m_mousePollingCounter == 1) {
doStartMousePolling();
}
}
void Cursor::stopMousePolling()
{
Q_ASSERT(m_mousePollingCounter > 0);
--m_mousePollingCounter;
if (m_mousePollingCounter == 0) {
doStopMousePolling();
}
}
void Cursor::doStartMousePolling()
{
}
void Cursor::doStopMousePolling()
{
}
void Cursor::startCursorTracking()
{
++m_cursorTrackingCounter;
if (m_cursorTrackingCounter == 1) {
doStartCursorTracking();
}
}
void Cursor::stopCursorTracking()
{
Q_ASSERT(m_cursorTrackingCounter > 0);
--m_cursorTrackingCounter;
if (m_cursorTrackingCounter == 0) {
doStopCursorTracking();
}
}
void Cursor::doStartCursorTracking()
{
}
void Cursor::doStopCursorTracking()
{
}
void Cursor::notifyCursorChanged(uint32_t serial)
{
if (m_cursorTrackingCounter <= 0) {
// cursor change tracking is currently disabled, so don't emit signal
return;
}
emit cursorChanged(serial);
}
#ifndef KCMRULES
class XInputEventFilter : public X11EventFilter
{
public:
XInputEventFilter(X11Cursor *parent, int xi_opcode)
: X11EventFilter(XCB_GE_GENERIC, xi_opcode, QVector<int>{XI_RawMotion, XI_RawButtonPress, XI_RawButtonRelease, XI_RawKeyPress, XI_RawKeyRelease})
, m_x11Cursor(parent)
{}
virtual ~XInputEventFilter() = default;
bool event(xcb_generic_event_t *event) override {
xcb_ge_generic_event_t *ge = reinterpret_cast<xcb_ge_generic_event_t *>(event);
switch (ge->event_type) {
case XI_RawKeyPress:
input()->keyboard()->xkb()->updateKey(reinterpret_cast<xXIRawEvent*>(event)->detail - 8, InputRedirection::KeyboardKeyPressed);
break;
case XI_RawKeyRelease:
input()->keyboard()->xkb()->updateKey(reinterpret_cast<xXIRawEvent*>(event)->detail - 8, InputRedirection::KeyboardKeyReleased);
break;
default:
m_x11Cursor->schedulePoll();
break;
}
return false;
}
private:
X11Cursor *m_x11Cursor;
};
#endif
X11Cursor::X11Cursor(QObject *parent)
: Cursor(parent)
, m_timeStamp(XCB_TIME_CURRENT_TIME)
, m_buttonMask(0)
, m_resetTimeStampTimer(new QTimer(this))
, m_mousePollingTimer(new QTimer(this))
, m_hasXInput(false)
, m_xiOpcode(0)
, m_needsPoll(false)
{
initXInput();
m_resetTimeStampTimer->setSingleShot(true);
connect(m_resetTimeStampTimer, SIGNAL(timeout()), SLOT(resetTimeStamp()));
// TODO: How often do we really need to poll?
m_mousePollingTimer->setInterval(50);
connect(m_mousePollingTimer, SIGNAL(timeout()), SLOT(mousePolled()));
connect(this, &Cursor::themeChanged, this, [this] { m_cursors.clear(); });
}
X11Cursor::~X11Cursor()
{
}
void X11Cursor::initXInput()
{
#ifndef KCMRULES
#if HAVE_X11_XINPUT
if (qEnvironmentVariableIsSet("KWIN_NO_XI2")) {
return;
}
Display *dpy = display();
int xi_opcode, event, error;
// init XInput extension
if (!XQueryExtension(dpy, "XInputExtension", &xi_opcode, &event, &error)) {
return;
}
// verify that the XInput extension is at at least version 2.0
int major = 2, minor = 0;
int result = XIQueryVersion(dpy, &major, &minor);
if (result == BadImplementation) {
// Xinput 2.2 returns BadImplementation if checked against 2.0
major = 2;
minor = 2;
if (XIQueryVersion(dpy, &major, &minor) != Success) {
return;
}
} else if (result != Success) {
return;
}
m_hasXInput = true;
m_xiOpcode = xi_opcode;
input()->keyboard()->xkb()->reconfigure();
#endif
#endif
}
void X11Cursor::doSetPos()
{
const QPoint &pos = currentPos();
xcb_warp_pointer(connection(), XCB_WINDOW_NONE, rootWindow(), 0, 0, 0, 0, pos.x(), pos.y());
// call default implementation to emit signal
Cursor::doSetPos();
}
void X11Cursor::doGetPos()
{
if (m_timeStamp != XCB_TIME_CURRENT_TIME &&
m_timeStamp == xTime()) {
// time stamps did not change, no need to query again
return;
}
m_timeStamp = xTime();
Xcb::Pointer pointer(rootWindow());
if (pointer.isNull()) {
return;
}
m_buttonMask = pointer->mask;
updatePos(pointer->root_x, pointer->root_y);
m_resetTimeStampTimer->start(0);
}
void X11Cursor::resetTimeStamp()
{
m_timeStamp = XCB_TIME_CURRENT_TIME;
}
void X11Cursor::aboutToBlock()
{
if (m_needsPoll) {
mousePolled();
m_needsPoll = false;
}
}
void X11Cursor::doStartMousePolling()
{
if (m_hasXInput) {
#ifndef KCMRULES
#if HAVE_X11_XINPUT
m_xiEventFilter.reset(new XInputEventFilter(this, m_xiOpcode));
// this assumes KWin is the only one setting events on the root window
// given Qt's source code this seems to be true. If it breaks, we need to change
XIEventMask evmasks[1];
unsigned char mask1[XIMaskLen(XI_LASTEVENT)];
memset(mask1, 0, sizeof(mask1));
XISetMask(mask1, XI_RawMotion);
XISetMask(mask1, XI_RawButtonPress);
XISetMask(mask1, XI_RawButtonRelease);
XISetMask(mask1, XI_RawKeyPress);
XISetMask(mask1, XI_RawKeyRelease);
evmasks[0].deviceid = XIAllMasterDevices;
evmasks[0].mask_len = sizeof(mask1);
evmasks[0].mask = mask1;
XISelectEvents(display(), rootWindow(), evmasks, 1);
connect(qApp->eventDispatcher(), &QAbstractEventDispatcher::aboutToBlock, this, &X11Cursor::aboutToBlock);
#endif
#endif
} else {
m_mousePollingTimer->start();
}
}
void X11Cursor::doStopMousePolling()
{
if (m_hasXInput) {
#ifndef KCMRULES
#if HAVE_X11_XINPUT
m_xiEventFilter.reset();
XIEventMask evmasks[1];
unsigned char mask1[(XI_LASTEVENT + 7)/8];
memset(mask1, 0, sizeof(mask1));
evmasks[0].deviceid = XIAllMasterDevices;
evmasks[0].mask_len = sizeof(mask1);
evmasks[0].mask = mask1;
XISelectEvents(display(), rootWindow(), evmasks, 1);
disconnect(qApp->eventDispatcher(), &QAbstractEventDispatcher::aboutToBlock, this, &X11Cursor::aboutToBlock);
#endif
#endif
} else {
m_mousePollingTimer->stop();
}
}
void X11Cursor::doStartCursorTracking()
{
xcb_xfixes_select_cursor_input(connection(), rootWindow(), XCB_XFIXES_CURSOR_NOTIFY_MASK_DISPLAY_CURSOR);
}
void X11Cursor::doStopCursorTracking()
{
xcb_xfixes_select_cursor_input(connection(), rootWindow(), 0);
}
void X11Cursor::mousePolled()
{
static QPoint lastPos = currentPos();
static uint16_t lastMask = m_buttonMask;
doGetPos(); // Update if needed
if (lastPos != currentPos() || lastMask != m_buttonMask) {
emit mouseChanged(currentPos(), lastPos,
x11ToQtMouseButtons(m_buttonMask), x11ToQtMouseButtons(lastMask),
x11ToQtKeyboardModifiers(m_buttonMask), x11ToQtKeyboardModifiers(lastMask));
lastPos = currentPos();
lastMask = m_buttonMask;
}
}
xcb_cursor_t X11Cursor::getX11Cursor(Qt::CursorShape shape)
{
return getX11Cursor(cursorName(shape));
}
xcb_cursor_t X11Cursor::getX11Cursor(const QByteArray &name)
{
auto it = m_cursors.constFind(name);
if (it != m_cursors.constEnd()) {
return it.value();
}
return createCursor(name);
}
xcb_cursor_t X11Cursor::createCursor(const QByteArray &name)
{
if (name.isEmpty()) {
return XCB_CURSOR_NONE;
}
xcb_cursor_context_t *ctx;
if (xcb_cursor_context_new(connection(), defaultScreen(), &ctx) < 0) {
return XCB_CURSOR_NONE;
}
xcb_cursor_t cursor = xcb_cursor_load_cursor(ctx, name.constData());
if (cursor == XCB_CURSOR_NONE) {
const auto &names = cursorAlternativeNames(name);
for (auto cit = names.begin(); cit != names.end(); ++cit) {
cursor = xcb_cursor_load_cursor(ctx, (*cit).constData());
if (cursor != XCB_CURSOR_NONE) {
break;
}
}
}
if (cursor != XCB_CURSOR_NONE) {
m_cursors.insert(name, cursor);
}
xcb_cursor_context_free(ctx);
return cursor;
}
QVector<QByteArray> Cursor::cursorAlternativeNames(const QByteArray &name) const
{
static const QHash<QByteArray, QVector<QByteArray>> alternatives = {
{QByteArrayLiteral("left_ptr"), {QByteArrayLiteral("arrow"),
QByteArrayLiteral("dnd-none"),
QByteArrayLiteral("op_left_arrow")}},
{QByteArrayLiteral("cross"), {QByteArrayLiteral("crosshair"),
QByteArrayLiteral("diamond-cross"),
QByteArrayLiteral("cross-reverse")}},
{QByteArrayLiteral("up_arrow"), {QByteArrayLiteral("center_ptr"),
QByteArrayLiteral("sb_up_arrow"),
QByteArrayLiteral("centre_ptr")}},
{QByteArrayLiteral("wait"), {QByteArrayLiteral("watch"),
QByteArrayLiteral("progress")}},
{QByteArrayLiteral("ibeam"), {QByteArrayLiteral("xterm"),
QByteArrayLiteral("text")}},
{QByteArrayLiteral("size_all"), {QByteArrayLiteral("fleur")}},
{QByteArrayLiteral("pointing_hand"), {QByteArrayLiteral("hand2"),
QByteArrayLiteral("hand"),
QByteArrayLiteral("hand1"),
QByteArrayLiteral("pointer"),
QByteArrayLiteral("e29285e634086352946a0e7090d73106"),
QByteArrayLiteral("9d800788f1b08800ae810202380a0822")}},
{QByteArrayLiteral("size_ver"), {QByteArrayLiteral("00008160000006810000408080010102"),
QByteArrayLiteral("sb_v_double_arrow"),
QByteArrayLiteral("v_double_arrow"),
QByteArrayLiteral("n-resize"),
QByteArrayLiteral("s-resize"),
QByteArrayLiteral("col-resize"),
QByteArrayLiteral("top_side"),
QByteArrayLiteral("bottom_side"),
QByteArrayLiteral("base_arrow_up"),
QByteArrayLiteral("base_arrow_down"),
QByteArrayLiteral("based_arrow_down"),
QByteArrayLiteral("based_arrow_up")}},
{QByteArrayLiteral("size_hor"), {QByteArrayLiteral("028006030e0e7ebffc7f7070c0600140"),
QByteArrayLiteral("sb_h_double_arrow"),
QByteArrayLiteral("h_double_arrow"),
QByteArrayLiteral("e-resize"),
QByteArrayLiteral("w-resize"),
QByteArrayLiteral("row-resize"),
QByteArrayLiteral("right_side"),
QByteArrayLiteral("left_side")}},
{QByteArrayLiteral("size_bdiag"), {QByteArrayLiteral("fcf1c3c7cd4491d801f1e1c78f100000"),
QByteArrayLiteral("fd_double_arrow"),
QByteArrayLiteral("bottom_left_corner"),
QByteArrayLiteral("top_right_corner")}},
{QByteArrayLiteral("size_fdiag"), {QByteArrayLiteral("c7088f0f3e6c8088236ef8e1e3e70000"),
QByteArrayLiteral("bd_double_arrow"),
QByteArrayLiteral("bottom_right_corner"),
QByteArrayLiteral("top_left_corner")}},
{QByteArrayLiteral("whats_this"), {QByteArrayLiteral("d9ce0ab605698f320427677b458ad60b"),
QByteArrayLiteral("left_ptr_help"),
QByteArrayLiteral("help"),
QByteArrayLiteral("question_arrow"),
QByteArrayLiteral("dnd-ask"),
QByteArrayLiteral("5c6cd98b3f3ebcb1f9c7f1c204630408")}},
{QByteArrayLiteral("split_h"), {QByteArrayLiteral("14fef782d02440884392942c11205230"),
QByteArrayLiteral("size_hor")}},
{QByteArrayLiteral("split_v"), {QByteArrayLiteral("2870a09082c103050810ffdffffe0204"),
QByteArrayLiteral("size_ver")}},
{QByteArrayLiteral("forbidden"), {QByteArrayLiteral("03b6e0fcb3499374a867c041f52298f0"),
QByteArrayLiteral("circle"),
QByteArrayLiteral("dnd-no-drop"),
QByteArrayLiteral("not-allowed")}},
{QByteArrayLiteral("left_ptr_watch"), {QByteArrayLiteral("3ecb610c1bf2410f44200f48c40d3599"),
QByteArrayLiteral("00000000000000020006000e7e9ffc3f"),
QByteArrayLiteral("08e8e1c95fe2fc01f976f1e063a24ccd")}},
{QByteArrayLiteral("openhand"), {QByteArrayLiteral("9141b49c8149039304290b508d208c40"),
QByteArrayLiteral("all_scroll"),
QByteArrayLiteral("all-scroll")}},
{QByteArrayLiteral("closedhand"), {QByteArrayLiteral("05e88622050804100c20044008402080"),
QByteArrayLiteral("4498f0e0c1937ffe01fd06f973665830"),
QByteArrayLiteral("9081237383d90e509aa00f00170e968f"),
QByteArrayLiteral("fcf21c00b30f7e3f83fe0dfd12e71cff")}},
{QByteArrayLiteral("dnd-link"), {QByteArrayLiteral("link"),
QByteArrayLiteral("alias"),
QByteArrayLiteral("3085a0e285430894940527032f8b26df"),
QByteArrayLiteral("640fb0e74195791501fd1ed57b41487f"),
QByteArrayLiteral("a2a266d0498c3104214a47bd64ab0fc8")}},
{QByteArrayLiteral("dnd-copy"), {QByteArrayLiteral("copy"),
QByteArrayLiteral("1081e37283d90000800003c07f3ef6bf"),
QByteArrayLiteral("6407b0e94181790501fd1e167b474872"),
QByteArrayLiteral("b66166c04f8c3109214a4fbd64a50fc8")}},
{QByteArrayLiteral("dnd-move"), {QByteArrayLiteral("move")}}
};
auto it = alternatives.find(name);
if (it != alternatives.end()) {
return it.value();
}
return QVector<QByteArray>();
}
QByteArray Cursor::cursorName(Qt::CursorShape shape) const
{
switch (shape) {
case Qt::ArrowCursor:
return QByteArray("left_ptr");
case Qt::UpArrowCursor:
return QByteArray("up_arrow");
case Qt::CrossCursor:
return QByteArray("cross");
case Qt::WaitCursor:
return QByteArray("wait");
case Qt::IBeamCursor:
return QByteArray("ibeam");
case Qt::SizeVerCursor:
return QByteArray("size_ver");
case Qt::SizeHorCursor:
return QByteArray("size_hor");
case Qt::SizeBDiagCursor:
return QByteArray("size_bdiag");
case Qt::SizeFDiagCursor:
return QByteArray("size_fdiag");
case Qt::SizeAllCursor:
return QByteArray("size_all");
case Qt::SplitVCursor:
return QByteArray("split_v");
case Qt::SplitHCursor:
return QByteArray("split_h");
case Qt::PointingHandCursor:
return QByteArray("pointing_hand");
case Qt::ForbiddenCursor:
return QByteArray("forbidden");
case Qt::OpenHandCursor:
return QByteArray("openhand");
case Qt::ClosedHandCursor:
return QByteArray("closedhand");
case Qt::WhatsThisCursor:
return QByteArray("whats_this");
case Qt::BusyCursor:
return QByteArray("left_ptr_watch");
case Qt::DragMoveCursor:
return QByteArray("dnd-move");
case Qt::DragCopyCursor:
return QByteArray("dnd-copy");
case Qt::DragLinkCursor:
return QByteArray("dnd-link");
default:
return QByteArray();
}
}
InputRedirectionCursor::InputRedirectionCursor(QObject *parent)
: Cursor(parent)
, m_currentButtons(Qt::NoButton)
{
connect(input(), SIGNAL(globalPointerChanged(QPointF)), SLOT(slotPosChanged(QPointF)));
connect(input(), SIGNAL(pointerButtonStateChanged(uint32_t,InputRedirection::PointerButtonState)),
SLOT(slotPointerButtonChanged()));
#ifndef KCMRULES
connect(input(), &InputRedirection::keyboardModifiersChanged,
this, &InputRedirectionCursor::slotModifiersChanged);
connect(kwinApp(), &Application::x11ConnectionChanged, this,
[this] {
if (isCursorTracking()) {
doStartCursorTracking();
}
}, Qt::QueuedConnection
);
#endif
}
InputRedirectionCursor::~InputRedirectionCursor()
{
}
void InputRedirectionCursor::doSetPos()
{
if (input()->supportsPointerWarping()) {
input()->warpPointer(currentPos());
}
slotPosChanged(input()->globalPointer());
emit posChanged(currentPos());
}
void InputRedirectionCursor::slotPosChanged(const QPointF &pos)
{
const QPoint oldPos = currentPos();
updatePos(pos.toPoint());
emit mouseChanged(pos.toPoint(), oldPos, m_currentButtons, m_currentButtons,
input()->keyboardModifiers(), input()->keyboardModifiers());
}
void InputRedirectionCursor::slotModifiersChanged(Qt::KeyboardModifiers mods, Qt::KeyboardModifiers oldMods)
{
emit mouseChanged(currentPos(), currentPos(), m_currentButtons, m_currentButtons, mods, oldMods);
}
void InputRedirectionCursor::slotPointerButtonChanged()
{
const Qt::MouseButtons oldButtons = m_currentButtons;
m_currentButtons = input()->qtButtonStates();
const QPoint pos = currentPos();
emit mouseChanged(pos, pos, m_currentButtons, oldButtons, input()->keyboardModifiers(), input()->keyboardModifiers());
}
void InputRedirectionCursor::doStartCursorTracking()
{
if (!kwinApp()->x11Connection()) {
return;
}
xcb_xfixes_select_cursor_input(connection(), rootWindow(), XCB_XFIXES_CURSOR_NOTIFY_MASK_DISPLAY_CURSOR);
// TODO: also track the Wayland cursor
}
void InputRedirectionCursor::doStopCursorTracking()
{
if (!kwinApp()->x11Connection()) {
return;
}
xcb_xfixes_select_cursor_input(connection(), rootWindow(), 0);
// TODO: also track the Wayland cursor
}
} // namespace
Reference in a new issue View git blame Copy permalink