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

445 lines
16 KiB
C++
Raw Normal View History

Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
/********************************************************************
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>
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
#include "input.h"
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-12 13:14:49 +00:00
#include "keyboard_input.h"
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
#include "main.h"
Implement cursor shape tracking on Wayland Summary: So far the tracking for cursor shape was done incorrectly on Wayland by only listening to X11 cursor changes. That's from a time when KWin/Wayland was still run on top of an X server. Nowadays the Platform tracks cursor shape changes and emits changes to it. Xwayland cursor changes go through the normal Wayland way so it's just one way to get it on Wayland. This change adds the required connect and changes the signal signature in Cursor by dropping the serial argument. No user of the signal uses the argument and on Wayland we don't have a serial for the cursor. So it can be dropped. Test Plan: Zoom effect updates cursor shape correctly on Wayland Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3095
2016-10-18 07:45:49 +00:00
#include "platform.h"
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
#include "utils.h"
Port XQueryPointer usage to XCB Introduces new XCB::Pointer wrapper and is used in Client::leaveNotifyEvent and in Cursor and KillWindow to simplify the usage. CCBUG: 333836
2014-04-25 09:18:49 +00:00
#include "xcbutils.h"
Track used cursor theme and size in Cursor Reads the settings from kcminputrc. Unfortunately there is no update when the settings change. This needs fixing in the cursors KCM first.
2013-06-27 07:06:16 +00:00
// KDE
[kwin] Fix includes of kde4support headers * drop unused headers * use QExplicitlySharedDataPointer instead of KSharedPointer * drop KDE/ from includes
2014-03-18 13:34:36 +00:00
#include <KConfig>
#include <KConfigGroup>
#include <KSharedConfig>
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
// Qt
Use XInput for "polling" the mouse positing Replaces the timer based polling approach. If XInput is available we listen for the RawMotion event on the root window and use this to trigger a mouse pointer position. BUG: 357692 FIXED-IN: 5.6.0 REVIEW: 126733
2016-01-13 14:40:02 +00:00
#include <QAbstractEventDispatcher>
Update cursor theme when it changes at runtime Connecting to the DBus signal emitted on KGlobalAccels by the cursor kcm and forcing a reload of all cursors. For runtime config change we need to take the config value and need to ignore the now outdated environment variables. REVIEW: 121928 BUG: 325763 FIXED-IN: 5.2.0
2015-01-08 16:03:25 +00:00
#include <QDBusConnection>
Handle case that XCURSOR_SIZE environment variable is not set In a default startup startkde does not set XCURSOR_SIZE environment variable. Only XCURSOR_THEME is set. The size should be DPI dependent. With this patch Cursor is able to handle this situation and does not fall back to loading the config from file. Logic is taken from KHintsSettings in frameworkintegration which in turn is from KApplication. REVIEW: 122139
2015-01-19 08:24:54 +00:00
#include <QScreen>
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
#include <QTimer>
Support for cursor change tracking in KWin::Cursor KWin::Cursor can track changes to the cursor image. It supports a start/stop tracking to not handle these events if nobody is interested in them. When enabled and the cursor image changes a signal is emitted with the serial number of the new cursor image. To track cursor image changes xcb_xfixes_select_cursor_input is used (see XFixes Version 5.0 protocol, section 7). This could be useful for the zoom effect when it replaces the cursor. REVIEW: 110519
2013-05-19 07:32:27 +00:00
// xcb
#include <xcb/xfixes.h>
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
namespace KWin
{
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
Cursor *Cursor::s_self = nullptr;
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
Cursor::Cursor(QObject *parent)
: QObject(parent)
, m_mousePollingCounter(0)
Support for cursor change tracking in KWin::Cursor KWin::Cursor can track changes to the cursor image. It supports a start/stop tracking to not handle these events if nobody is interested in them. When enabled and the cursor image changes a signal is emitted with the serial number of the new cursor image. To track cursor image changes xcb_xfixes_select_cursor_input is used (see XFixes Version 5.0 protocol, section 7). This could be useful for the zoom effect when it replaces the cursor. REVIEW: 110519
2013-05-19 07:32:27 +00:00
, m_cursorTrackingCounter(0)
Track used cursor theme and size in Cursor Reads the settings from kcminputrc. Unfortunately there is no update when the settings change. This needs fixing in the cursors KCM first.
2013-06-27 07:06:16 +00:00
, m_themeName("default")
, m_themeSize(24)
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
{
Create Cursor instance through Platform By default the InputRedirectionCursor is created and only the X11 standalone platform creates the X11 specific cursor. This is a preparation step for moving the X11 specific cursor implementation into the x11standalone platform plugin.
2016-08-15 10:00:03 +00:00
s_self = this;
Track used cursor theme and size in Cursor Reads the settings from kcminputrc. Unfortunately there is no update when the settings change. This needs fixing in the cursors KCM first.
2013-06-27 07:06:16 +00:00
loadThemeSettings();
Update cursor theme when it changes at runtime Connecting to the DBus signal emitted on KGlobalAccels by the cursor kcm and forcing a reload of all cursors. For runtime config change we need to take the config value and need to ignore the now outdated environment variables. REVIEW: 121928 BUG: 325763 FIXED-IN: 5.2.0
2015-01-08 16:03:25 +00:00
QDBusConnection::sessionBus().connect(QString(), QStringLiteral("/KGlobalSettings"), QStringLiteral("org.kde.KGlobalSettings"),
QStringLiteral("notifyChange"), this, SLOT(slotKGlobalSettingsNotifyChange(int,int)));
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
}
Cursor::~Cursor()
{
s_self = NULL;
}
Track used cursor theme and size in Cursor Reads the settings from kcminputrc. Unfortunately there is no update when the settings change. This needs fixing in the cursors KCM first.
2013-06-27 07:06:16 +00:00
void Cursor::loadThemeSettings()
{
First try getting cursor theme from environment variable If XCURSOR_THEME and XCURSOR_SIZE are set they are preferred over reading the values from kcminputrc. REVIEW: 121923 BUG: 334954 FIXED-IN: 5.2.0
2015-01-08 14:09:23 +00:00
QString themeName = QString::fromUtf8(qgetenv("XCURSOR_THEME"));
Track used cursor theme and size in Cursor Reads the settings from kcminputrc. Unfortunately there is no update when the settings change. This needs fixing in the cursors KCM first.
2013-06-27 07:06:16 +00:00
bool ok = false;
Handle case that XCURSOR_SIZE environment variable is not set In a default startup startkde does not set XCURSOR_SIZE environment variable. Only XCURSOR_THEME is set. The size should be DPI dependent. With this patch Cursor is able to handle this situation and does not fall back to loading the config from file. Logic is taken from KHintsSettings in frameworkintegration which in turn is from KApplication. REVIEW: 122139
2015-01-19 08:24:54 +00:00
// 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;
}
}
First try getting cursor theme from environment variable If XCURSOR_THEME and XCURSOR_SIZE are set they are preferred over reading the values from kcminputrc. REVIEW: 121923 BUG: 334954 FIXED-IN: 5.2.0
2015-01-08 14:09:23 +00:00
if (!themeName.isEmpty() && ok) {
updateTheme(themeName, themeSize);
return;
}
// didn't get from environment variables, read from config file
Update cursor theme when it changes at runtime Connecting to the DBus signal emitted on KGlobalAccels by the cursor kcm and forcing a reload of all cursors. For runtime config change we need to take the config value and need to ignore the now outdated environment variables. REVIEW: 121928 BUG: 325763 FIXED-IN: 5.2.0
2015-01-08 16:03:25 +00:00
loadThemeFromKConfig();
}
void Cursor::loadThemeFromKConfig()
{
First try getting cursor theme from environment variable If XCURSOR_THEME and XCURSOR_SIZE are set they are preferred over reading the values from kcminputrc. REVIEW: 121923 BUG: 334954 FIXED-IN: 5.2.0
2015-01-08 14:09:23 +00:00
KConfigGroup mousecfg(KSharedConfig::openConfig("kcminputrc", KConfig::NoGlobals), "Mouse");
Update cursor theme when it changes at runtime Connecting to the DBus signal emitted on KGlobalAccels by the cursor kcm and forcing a reload of all cursors. For runtime config change we need to take the config value and need to ignore the now outdated environment variables. REVIEW: 121928 BUG: 325763 FIXED-IN: 5.2.0
2015-01-08 16:03:25 +00:00
const QString themeName = mousecfg.readEntry("cursorTheme", "default");
bool ok = false;
uint themeSize = mousecfg.readEntry("cursorSize", QString("24")).toUInt(&ok);
Track used cursor theme and size in Cursor Reads the settings from kcminputrc. Unfortunately there is no update when the settings change. This needs fixing in the cursors KCM first.
2013-06-27 07:06:16 +00:00
if (!ok) {
First try getting cursor theme from environment variable If XCURSOR_THEME and XCURSOR_SIZE are set they are preferred over reading the values from kcminputrc. REVIEW: 121923 BUG: 334954 FIXED-IN: 5.2.0
2015-01-08 14:09:23 +00:00
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();
Track used cursor theme and size in Cursor Reads the settings from kcminputrc. Unfortunately there is no update when the settings change. This needs fixing in the cursors KCM first.
2013-06-27 07:06:16 +00:00
}
}
Update cursor theme when it changes at runtime Connecting to the DBus signal emitted on KGlobalAccels by the cursor kcm and forcing a reload of all cursors. For runtime config change we need to take the config value and need to ignore the now outdated environment variables. REVIEW: 121928 BUG: 325763 FIXED-IN: 5.2.0
2015-01-08 16:03:25 +00:00
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));
}
}
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
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;
}
Support getting XCursor by name So far all cursors were only resolved through Qt::CursorShape, but Qt::CursorShape is not a complete mapping of all cursors used inside KWin. E.g. killwindow uses the "pirate" cursor. This change keeps the cursors by name instead of Qt::CursorShape and thus allows us to use Cursor for resolving XCursors everywhere.
2015-01-28 09:14:56 +00:00
xcb_cursor_t Cursor::getX11Cursor(const QByteArray &name)
{
Q_UNUSED(name)
return XCB_CURSOR_NONE;
}
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
xcb_cursor_t Cursor::x11Cursor(Qt::CursorShape shape)
{
return s_self->getX11Cursor(shape);
}
Support getting XCursor by name So far all cursors were only resolved through Qt::CursorShape, but Qt::CursorShape is not a complete mapping of all cursors used inside KWin. E.g. killwindow uses the "pirate" cursor. This change keeps the cursors by name instead of Qt::CursorShape and thus allows us to use Cursor for resolving XCursors everywhere.
2015-01-28 09:14:56 +00:00
xcb_cursor_t Cursor::x11Cursor(const QByteArray &name)
{
return s_self->getX11Cursor(name);
}
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
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()
{
}
Support for cursor change tracking in KWin::Cursor KWin::Cursor can track changes to the cursor image. It supports a start/stop tracking to not handle these events if nobody is interested in them. When enabled and the cursor image changes a signal is emitted with the serial number of the new cursor image. To track cursor image changes xcb_xfixes_select_cursor_input is used (see XFixes Version 5.0 protocol, section 7). This could be useful for the zoom effect when it replaces the cursor. REVIEW: 110519
2013-05-19 07:32:27 +00:00
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)
{
Implement cursor shape tracking on Wayland Summary: So far the tracking for cursor shape was done incorrectly on Wayland by only listening to X11 cursor changes. That's from a time when KWin/Wayland was still run on top of an X server. Nowadays the Platform tracks cursor shape changes and emits changes to it. Xwayland cursor changes go through the normal Wayland way so it's just one way to get it on Wayland. This change adds the required connect and changes the signal signature in Cursor by dropping the serial argument. No user of the signal uses the argument and on Wayland we don't have a serial for the cursor. So it can be dropped. Test Plan: Zoom effect updates cursor shape correctly on Wayland Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3095
2016-10-18 07:45:49 +00:00
Q_UNUSED(serial)
Support for cursor change tracking in KWin::Cursor KWin::Cursor can track changes to the cursor image. It supports a start/stop tracking to not handle these events if nobody is interested in them. When enabled and the cursor image changes a signal is emitted with the serial number of the new cursor image. To track cursor image changes xcb_xfixes_select_cursor_input is used (see XFixes Version 5.0 protocol, section 7). This could be useful for the zoom effect when it replaces the cursor. REVIEW: 110519
2013-05-19 07:32:27 +00:00
if (m_cursorTrackingCounter <= 0) {
// cursor change tracking is currently disabled, so don't emit signal
return;
}
Implement cursor shape tracking on Wayland Summary: So far the tracking for cursor shape was done incorrectly on Wayland by only listening to X11 cursor changes. That's from a time when KWin/Wayland was still run on top of an X server. Nowadays the Platform tracks cursor shape changes and emits changes to it. Xwayland cursor changes go through the normal Wayland way so it's just one way to get it on Wayland. This change adds the required connect and changes the signal signature in Cursor by dropping the serial argument. No user of the signal uses the argument and on Wayland we don't have a serial for the cursor. So it can be dropped. Test Plan: Zoom effect updates cursor shape correctly on Wayland Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3095
2016-10-18 07:45:49 +00:00
emit cursorChanged();
Support for cursor change tracking in KWin::Cursor KWin::Cursor can track changes to the cursor image. It supports a start/stop tracking to not handle these events if nobody is interested in them. When enabled and the cursor image changes a signal is emitted with the serial number of the new cursor image. To track cursor image changes xcb_xfixes_select_cursor_input is used (see XFixes Version 5.0 protocol, section 7). This could be useful for the zoom effect when it replaces the cursor. REVIEW: 110519
2013-05-19 07:32:27 +00:00
}
Add Cursor::cursorAlternativeNames Make the internal hash of cursor names available.
2016-02-22 12:18:18 +00:00
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>();
}
Make mapping between Qt::CursorShape and theme name public It's of general interest as Wayland cursor uses the same theme name.
2013-06-27 07:45:58 +00:00
QByteArray Cursor::cursorName(Qt::CursorShape shape) const
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
{
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();
}
}
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
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()));
InputRedirection emits a signal when the modifiers change Used by Cursor to properly emit the mouseChanged signal which for historic reasons includes the keyboard modifiers. Again some fiddling around with the autotests and kcmrules needed to make it compile. This needs improvement!
2013-07-02 10:16:03 +00:00
#ifndef KCMRULES
connect(input(), &InputRedirection::keyboardModifiersChanged,
this, &InputRedirectionCursor::slotModifiersChanged);
#endif
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
}
InputRedirectionCursor::~InputRedirectionCursor()
{
}
void InputRedirectionCursor::doSetPos()
{
[wayland] Add support for pointer warping in InputRedirectionCursor With libinput we do can support warping pointers, let's do it.
2015-06-05 04:43:12 +00:00
if (input()->supportsPointerWarping()) {
input()->warpPointer(currentPos());
}
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
slotPosChanged(input()->globalPointer());
[wayland] Add support for pointer warping in InputRedirectionCursor With libinput we do can support warping pointers, let's do it.
2015-06-05 04:43:12 +00:00
emit posChanged(currentPos());
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
}
void InputRedirectionCursor::slotPosChanged(const QPointF &pos)
{
const QPoint oldPos = currentPos();
updatePos(pos.toPoint());
Fix mouseChanged signal arguments in InputRedirectionCursor The button state was not represented correctly which was very visible when using the MouseClickEffect. Now MouseClickEffect on Wayland works as expected.
2015-10-28 08:18:26 +00:00
emit mouseChanged(pos.toPoint(), oldPos, m_currentButtons, m_currentButtons,
InputRedirection emits a signal when the modifiers change Used by Cursor to properly emit the mouseChanged signal which for historic reasons includes the keyboard modifiers. Again some fiddling around with the autotests and kcmrules needed to make it compile. This needs improvement!
2013-07-02 10:16:03 +00:00
input()->keyboardModifiers(), input()->keyboardModifiers());
}
void InputRedirectionCursor::slotModifiersChanged(Qt::KeyboardModifiers mods, Qt::KeyboardModifiers oldMods)
{
emit mouseChanged(currentPos(), currentPos(), m_currentButtons, m_currentButtons, mods, oldMods);
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
}
void InputRedirectionCursor::slotPointerButtonChanged()
{
Fix mouseChanged signal arguments in InputRedirectionCursor The button state was not represented correctly which was very visible when using the MouseClickEffect. Now MouseClickEffect on Wayland works as expected.
2015-10-28 08:18:26 +00:00
const Qt::MouseButtons oldButtons = m_currentButtons;
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
m_currentButtons = input()->qtButtonStates();
Fix mouseChanged signal arguments in InputRedirectionCursor The button state was not represented correctly which was very visible when using the MouseClickEffect. Now MouseClickEffect on Wayland works as expected.
2015-10-28 08:18:26 +00:00
const QPoint pos = currentPos();
emit mouseChanged(pos, pos, m_currentButtons, oldButtons, input()->keyboardModifiers(), input()->keyboardModifiers());
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
}
void InputRedirectionCursor::doStartCursorTracking()
{
Implement cursor shape tracking on Wayland Summary: So far the tracking for cursor shape was done incorrectly on Wayland by only listening to X11 cursor changes. That's from a time when KWin/Wayland was still run on top of an X server. Nowadays the Platform tracks cursor shape changes and emits changes to it. Xwayland cursor changes go through the normal Wayland way so it's just one way to get it on Wayland. This change adds the required connect and changes the signal signature in Cursor by dropping the serial argument. No user of the signal uses the argument and on Wayland we don't have a serial for the cursor. So it can be dropped. Test Plan: Zoom effect updates cursor shape correctly on Wayland Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3095
2016-10-18 07:45:49 +00:00
#ifndef KCMRULES
connect(kwinApp()->platform(), &Platform::cursorChanged, this, &Cursor::cursorChanged);
#endif
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
}
void InputRedirectionCursor::doStopCursorTracking()
{
Implement cursor shape tracking on Wayland Summary: So far the tracking for cursor shape was done incorrectly on Wayland by only listening to X11 cursor changes. That's from a time when KWin/Wayland was still run on top of an X server. Nowadays the Platform tracks cursor shape changes and emits changes to it. Xwayland cursor changes go through the normal Wayland way so it's just one way to get it on Wayland. This change adds the required connect and changes the signal signature in Cursor by dropping the serial argument. No user of the signal uses the argument and on Wayland we don't have a serial for the cursor. So it can be dropped. Test Plan: Zoom effect updates cursor shape correctly on Wayland Reviewers: #kwin, #plasma_on_wayland Subscribers: plasma-devel, kwin Tags: #plasma_on_wayland, #kwin Differential Revision: https://phabricator.kde.org/D3095
2016-10-18 07:45:49 +00:00
#ifndef KCMRULES
disconnect(kwinApp()->platform(), &Platform::cursorChanged, this, &Cursor::cursorChanged);
#endif
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
}
Replacement class for QCursor With Qt5 QCursor does no longer provide ::handle() which was used to set a cursor on a native XWindow for which we do not have a QWidget. Also KWin has had for quite some time an optimized version to get the cursor position without doing XQueryPointer each time ::pos() is called. These two features are merged into a new class Cursor providing more or less the same API as QCursor. In addition the new class provides a facility to perform mouse polling replacing the implementations in Compositor and ScreenEdges. For more information about the new class see the documentation for the new class in cursor.h.
2013-02-19 10:25:46 +00:00
} // namespace
Reference in a new issue Copy permalink