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

888 lines
26 KiB
C++
Raw Normal View History

Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +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 "input.h"
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
#include "client.h"
Pass pointer events through the effect system InputRedirection forwards pointer events (currently motion, press and release) through the EffectsHandlerImpl for the case that an effect has intercepted pointer events. If the KWin operation mode is not X11 only, the window for intercepting the mouse events is no longer created.
2013-06-26 09:40:30 +00:00
#include "effects.h"
Beginning of global shortcut handling inside KWin A new GlobalShortcutsManager is introduced which is responsible for holding the registered shortcuts and triggering the matching action. The InputRedirection checks with the GlobalShortcutManager whether a key press event triggers a global shortcut and stops processing the event in that case. At the moment the GlobalShortcutsManager only supports the very basics for KWin internal usage. External applications can not yet make usage of the global shortcut system inside KWin.
2013-07-10 09:41:16 +00:00
#include "globalshortcuts.h"
Use Logind to open/close devices needed by libinput With libinput we have the problem that we need to have privileges to open the device files. In order to not need wrappers or suid bits, we use logind. This means that kwin_wayland has to be the session controler. A LogindIntegration is added to connect to logind and wrap the dbus calls. This is based on the logind integration done for ksld in ksmserver. The LogindIntegration is started by Workspace and the InputRedirection tries to become the session controller and starts the libinput integration only after this succeeded.
2014-08-15 07:30:08 +00:00
#include "logind.h"
#include "main.h"
Properly support key events in TabBox over InputRedirection Forward all key press events to the TabBox if it is currently grabbed and connect the TabBox to the modifiers changed signal for checking if TabBox should be ended.
2013-07-10 11:20:43 +00:00
#ifdef KWIN_BUILD_TABBOX
#include "tabbox/tabbox.h"
#endif
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
#include "unmanaged.h"
Fix build if there is no libinput
2014-10-20 13:01:12 +00:00
#include "screens.h"
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
#include "workspace.h"
Initial support for libinput Libinput is an optional dependency for getting low level input events. As opening the input devices requires root privs this is rather pointless in the current state. But there is a small added test app which can be executed with root privs to demonstrate the functionality. To properly get input events we need a wrapper like it's used in weston. So far the following is setup: * opening devices found by udev * forwarding keyboard events to InputRedirection * forwarding pointer button events to InputRedirection * forwarding pointer axis events to InputRedirection * signals emitted for pointer motion events Pointer motion events need some further work as they are provided as delta events. We need to track that and map them properly. Also missing are touch events due to me not having a touch screen. It should be fairly simple to setup the touch events, though. Also hotplugging of devices is not yet implemented.
2014-08-14 12:43:57 +00:00
#if HAVE_INPUT
#include "libinput/connection.h"
#endif
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#if HAVE_WAYLAND
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
#include "abstract_backend.h"
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#include "wayland_server.h"
[input] Add support for VT switch shortcuts If we have a VirtualTerminal and get a XKB_KEY_XF86Switch_VT_* keysym we trigger a VT switch.
2015-03-31 07:33:05 +00:00
#include "virtual_terminal.h"
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#include <KWayland/Server/seat_interface.h>
#endif
Drop dependency on kdecoration.h
2014-12-02 12:50:26 +00:00
// Qt
#include <QKeyEvent>
#include <QMouseEvent>
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
// KDE
#include <kkeyserver.h>
Don't include xkbcommon/xkbcommon.h in input.h, forward-declare instead Some systems (e.g. openSuSE) don't install the xkbcommon header into /usr/include/xkbcommon/xkbcommon.h (which is always in the include path), but instead into a subdirectory, which is in the openSuSE case /usr/include/pkg/libxkbcommon/xkbcommon/xkbcommon.h. This means that e.g. kcm_kwinrules will not compile there since it includes input.h REVIEW: 117069
2014-03-28 08:41:48 +00:00
#if HAVE_XKB
#include <xkbcommon/xkbcommon.h>
[input] Add support for VT switch shortcuts If we have a VirtualTerminal and get a XKB_KEY_XF86Switch_VT_* keysym we trigger a VT switch.
2015-03-31 07:33:05 +00:00
#include <xkbcommon/xkbcommon-keysyms.h>
Don't include xkbcommon/xkbcommon.h in input.h, forward-declare instead Some systems (e.g. openSuSE) don't install the xkbcommon header into /usr/include/xkbcommon/xkbcommon.h (which is always in the include path), but instead into a subdirectory, which is in the openSuSE case /usr/include/pkg/libxkbcommon/xkbcommon/xkbcommon.h. This means that e.g. kcm_kwinrules will not compile there since it includes input.h REVIEW: 117069
2014-03-28 08:41:48 +00:00
#endif
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
// system
#include <linux/input.h>
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
#include <sys/mman.h>
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
namespace KWin
{
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
#if HAVE_XKB
Xkb::Xkb()
: m_context(xkb_context_new(static_cast<xkb_context_flags>(0)))
, m_keymap(NULL)
, m_state(NULL)
, m_shiftModifier(0)
, m_controlModifier(0)
, m_altModifier(0)
, m_metaModifier(0)
, m_modifiers(Qt::NoModifier)
{
if (!m_context) {
Introduce categorized logging for kwin core Done by Daniel Pastushchak for KDE during GCI-2014.
2014-12-05 10:42:15 +00:00
qCDebug(KWIN_CORE) << "Could not create xkb context";
[input] Set a default xkb modifier map
2015-03-27 13:12:41 +00:00
} else {
// load default keymap
xkb_keymap *keymap = xkb_keymap_new_from_names(m_context, nullptr, XKB_KEYMAP_COMPILE_NO_FLAGS);
if (keymap) {
updateKeymap(keymap);
} else {
qCDebug(KWIN_CORE) << "Could not create default xkb keymap";
}
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
}
}
Xkb::~Xkb()
{
xkb_state_unref(m_state);
xkb_keymap_unref(m_keymap);
xkb_context_unref(m_context);
}
void Xkb::installKeymap(int fd, uint32_t size)
{
if (!m_context) {
return;
}
char *map = reinterpret_cast<char*>(mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0));
if (map == MAP_FAILED) {
return;
}
xkb_keymap *keymap = xkb_keymap_new_from_string(m_context, map, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_MAP_COMPILE_PLACEHOLDER);
munmap(map, size);
if (!keymap) {
Introduce categorized logging for kwin core Done by Daniel Pastushchak for KDE during GCI-2014.
2014-12-05 10:42:15 +00:00
qCDebug(KWIN_CORE) << "Could not map keymap from file";
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
return;
}
[input] Set a default xkb modifier map
2015-03-27 13:12:41 +00:00
updateKeymap(keymap);
}
void Xkb::updateKeymap(xkb_keymap *keymap)
{
Q_ASSERT(keymap);
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
xkb_state *state = xkb_state_new(keymap);
if (!state) {
Introduce categorized logging for kwin core Done by Daniel Pastushchak for KDE during GCI-2014.
2014-12-05 10:42:15 +00:00
qCDebug(KWIN_CORE) << "Could not create XKB state";
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
xkb_keymap_unref(keymap);
return;
}
// now release the old ones
xkb_state_unref(m_state);
xkb_keymap_unref(m_keymap);
m_keymap = keymap;
m_state = state;
m_shiftModifier = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_SHIFT);
m_controlModifier = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_CTRL);
m_altModifier = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_ALT);
m_metaModifier = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_LOGO);
}
void Xkb::updateModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group)
{
if (!m_keymap || !m_state) {
return;
}
xkb_state_update_mask(m_state, modsDepressed, modsLatched, modsLocked, 0, 0, group);
[input] Try updating the modifiers after each key press TODO: send new modifier information to wayland server.
2015-03-27 13:15:25 +00:00
updateModifiers();
}
void Xkb::updateKey(uint32_t key, InputRedirection::KeyboardKeyState state)
{
if (!m_keymap || !m_state) {
return;
}
xkb_state_update_key(m_state, key + 8, static_cast<xkb_key_direction>(state));
updateModifiers();
}
void Xkb::updateModifiers()
{
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
Qt::KeyboardModifiers mods = Qt::NoModifier;
if (xkb_state_mod_index_is_active(m_state, m_shiftModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
mods |= Qt::ShiftModifier;
}
if (xkb_state_mod_index_is_active(m_state, m_altModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
mods |= Qt::AltModifier;
}
if (xkb_state_mod_index_is_active(m_state, m_controlModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
mods |= Qt::ControlModifier;
}
if (xkb_state_mod_index_is_active(m_state, m_metaModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
mods |= Qt::MetaModifier;
}
m_modifiers = mods;
}
xkb_keysym_t Xkb::toKeysym(uint32_t key)
{
if (!m_state) {
return XKB_KEY_NoSymbol;
}
return xkb_state_key_get_one_sym(m_state, key + 8);
}
QString Xkb::toString(xkb_keysym_t keysym)
{
if (!m_state || keysym == XKB_KEY_NoSymbol) {
return QString();
}
QByteArray byteArray(7, 0);
int ok = xkb_keysym_to_utf8(keysym, byteArray.data(), byteArray.size());
if (ok == -1 || ok == 0) {
return QString();
}
return QString::fromUtf8(byteArray.constData());
}
Qt::Key Xkb::toQtKey(xkb_keysym_t keysym)
{
int key = Qt::Key_unknown;
KKeyServer::symXToKeyQt(keysym, &key);
return static_cast<Qt::Key>(key);
}
#endif
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
KWIN_SINGLETON_FACTORY(InputRedirection)
InputRedirection::InputRedirection(QObject *parent)
: QObject(parent)
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
#if HAVE_XKB
, m_xkb(new Xkb())
#endif
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
, m_pointerWindow()
Beginning of global shortcut handling inside KWin A new GlobalShortcutsManager is introduced which is responsible for holding the registered shortcuts and triggering the matching action. The InputRedirection checks with the GlobalShortcutManager whether a key press event triggers a global shortcut and stops processing the event in that case. At the moment the GlobalShortcutsManager only supports the very basics for KWin internal usage. External applications can not yet make usage of the global shortcut system inside KWin.
2013-07-10 09:41:16 +00:00
, m_shortcuts(new GlobalShortcutsManager(this))
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
{
Use Logind to open/close devices needed by libinput With libinput we have the problem that we need to have privileges to open the device files. In order to not need wrappers or suid bits, we use logind. This means that kwin_wayland has to be the session controler. A LogindIntegration is added to connect to logind and wrap the dbus calls. This is based on the logind integration done for ksld in ksmserver. The LogindIntegration is started by Workspace and the InputRedirection tries to become the session controller and starts the libinput integration only after this succeeded.
2014-08-15 07:30:08 +00:00
#if HAVE_INPUT
Add command line option to enable libinput support kwin_wayland gains a new command line option to enable libinput support. This is needed as logind blanks the VT when the session controller releases the control. So a nested compositor can seriously affect the primary session. Thus it needs a dedicated command line switch to enable it. By default libinput support is disabled for kwin_x11 and can be enabled for kwin_wayland in case KWin is compiled with libinput support.
2014-08-15 12:03:52 +00:00
if (Application::usesLibinput()) {
[libinput] Bind libinput support to VirtualTerminal This change is motivated by the fact that we need to suspend libinput before switching the virtual terminal. Also we don't want to take over libinput if we do not have a VirtualTerminal created - in windowed mode we don't want libinput to be started. So binding it to the backends which create the VirtualTerminal makes sense. The KWin::Application gains a new signal virtualTerminalCreated which is emitted from VirtualTerminal once it's properly setup. This is used by Input to create Libinput integration instead of binding it to logind. Furthermore Libinput gets suspended when the VirtualTerminal reports that it is no longer active. For re-activation we still just use logind's session active property.
2015-04-15 15:47:56 +00:00
if (VirtualTerminal::self()) {
setupLibInput();
Use Logind to open/close devices needed by libinput With libinput we have the problem that we need to have privileges to open the device files. In order to not need wrappers or suid bits, we use logind. This means that kwin_wayland has to be the session controler. A LogindIntegration is added to connect to logind and wrap the dbus calls. This is based on the logind integration done for ksld in ksmserver. The LogindIntegration is started by Workspace and the InputRedirection tries to become the session controller and starts the libinput integration only after this succeeded.
2014-08-15 07:30:08 +00:00
} else {
[libinput] Bind libinput support to VirtualTerminal This change is motivated by the fact that we need to suspend libinput before switching the virtual terminal. Also we don't want to take over libinput if we do not have a VirtualTerminal created - in windowed mode we don't want libinput to be started. So binding it to the backends which create the VirtualTerminal makes sense. The KWin::Application gains a new signal virtualTerminalCreated which is emitted from VirtualTerminal once it's properly setup. This is used by Input to create Libinput integration instead of binding it to logind. Furthermore Libinput gets suspended when the VirtualTerminal reports that it is no longer active. For re-activation we still just use logind's session active property.
2015-04-15 15:47:56 +00:00
connect(kwinApp(), &Application::virtualTerminalCreated, this, &InputRedirection::setupLibInput);
Use Logind to open/close devices needed by libinput With libinput we have the problem that we need to have privileges to open the device files. In order to not need wrappers or suid bits, we use logind. This means that kwin_wayland has to be the session controler. A LogindIntegration is added to connect to logind and wrap the dbus calls. This is based on the logind integration done for ksld in ksmserver. The LogindIntegration is started by Workspace and the InputRedirection tries to become the session controller and starts the libinput integration only after this succeeded.
2014-08-15 07:30:08 +00:00
}
}
#endif
}
InputRedirection::~InputRedirection()
{
s_self = NULL;
}
[libinput] Pass device capabilities to Wayland::Server::SeatInterface We handle device added/remove to monitor whether we have keyboard, pointer and touch devices and emit signals. Those are used to update the SeatInferface from InputRedirection.
2015-03-26 15:19:26 +00:00
#if HAVE_WAYLAND
static KWayland::Server::SeatInterface *findSeat()
{
auto server = waylandServer();
if (!server) {
return nullptr;
}
return server->seat();
}
#endif
Use Logind to open/close devices needed by libinput With libinput we have the problem that we need to have privileges to open the device files. In order to not need wrappers or suid bits, we use logind. This means that kwin_wayland has to be the session controler. A LogindIntegration is added to connect to logind and wrap the dbus calls. This is based on the logind integration done for ksld in ksmserver. The LogindIntegration is started by Workspace and the InputRedirection tries to become the session controller and starts the libinput integration only after this succeeded.
2014-08-15 07:30:08 +00:00
void InputRedirection::setupLibInput()
{
Initial support for libinput Libinput is an optional dependency for getting low level input events. As opening the input devices requires root privs this is rather pointless in the current state. But there is a small added test app which can be executed with root privs to demonstrate the functionality. To properly get input events we need a wrapper like it's used in weston. So far the following is setup: * opening devices found by udev * forwarding keyboard events to InputRedirection * forwarding pointer button events to InputRedirection * forwarding pointer axis events to InputRedirection * signals emitted for pointer motion events Pointer motion events need some further work as they are provided as delta events. We need to track that and map them properly. Also missing are touch events due to me not having a touch screen. It should be fairly simple to setup the touch events, though. Also hotplugging of devices is not yet implemented.
2014-08-14 12:43:57 +00:00
#if HAVE_INPUT
Add command line option to enable libinput support kwin_wayland gains a new command line option to enable libinput support. This is needed as logind blanks the VT when the session controller releases the control. So a nested compositor can seriously affect the primary session. Thus it needs a dedicated command line switch to enable it. By default libinput support is disabled for kwin_x11 and can be enabled for kwin_wayland in case KWin is compiled with libinput support.
2014-08-15 12:03:52 +00:00
if (!Application::usesLibinput()) {
return;
}
Ensure screens are created before fully setting up libinput Parts rely on screens being available but input might be created before screens are available. Thus connect to signal and delay.
2015-03-30 06:55:41 +00:00
if (m_libInput) {
return;
}
Initial support for libinput Libinput is an optional dependency for getting low level input events. As opening the input devices requires root privs this is rather pointless in the current state. But there is a small added test app which can be executed with root privs to demonstrate the functionality. To properly get input events we need a wrapper like it's used in weston. So far the following is setup: * opening devices found by udev * forwarding keyboard events to InputRedirection * forwarding pointer button events to InputRedirection * forwarding pointer axis events to InputRedirection * signals emitted for pointer motion events Pointer motion events need some further work as they are provided as delta events. We need to track that and map them properly. Also missing are touch events due to me not having a touch screen. It should be fairly simple to setup the touch events, though. Also hotplugging of devices is not yet implemented.
2014-08-14 12:43:57 +00:00
LibInput::Connection *conn = LibInput::Connection::create(this);
Ensure screens are created before fully setting up libinput Parts rely on screens being available but input might be created before screens are available. Thus connect to signal and delay.
2015-03-30 06:55:41 +00:00
m_libInput = conn;
Initial support for libinput Libinput is an optional dependency for getting low level input events. As opening the input devices requires root privs this is rather pointless in the current state. But there is a small added test app which can be executed with root privs to demonstrate the functionality. To properly get input events we need a wrapper like it's used in weston. So far the following is setup: * opening devices found by udev * forwarding keyboard events to InputRedirection * forwarding pointer button events to InputRedirection * forwarding pointer axis events to InputRedirection * signals emitted for pointer motion events Pointer motion events need some further work as they are provided as delta events. We need to track that and map them properly. Also missing are touch events due to me not having a touch screen. It should be fairly simple to setup the touch events, though. Also hotplugging of devices is not yet implemented.
2014-08-14 12:43:57 +00:00
if (conn) {
conn->setup();
connect(conn, &LibInput::Connection::pointerButtonChanged, this, &InputRedirection::processPointerButton);
connect(conn, &LibInput::Connection::pointerAxisChanged, this, &InputRedirection::processPointerAxis);
connect(conn, &LibInput::Connection::keyChanged, this, &InputRedirection::processKeyboardKey);
Connect pointer events from libinput
2014-10-17 07:21:38 +00:00
connect(conn, &LibInput::Connection::pointerMotion, this,
[this] (QPointF delta, uint32_t time) {
processPointerMotion(m_globalPointer + delta, time);
}
);
connect(conn, &LibInput::Connection::pointerMotionAbsolute, this,
[this] (QPointF orig, QPointF screen, uint32_t time) {
Q_UNUSED(orig)
processPointerMotion(screen, time);
}
);
Touch support in libinput
2015-03-25 15:30:47 +00:00
connect(conn, &LibInput::Connection::touchDown, this, &InputRedirection::processTouchDown);
connect(conn, &LibInput::Connection::touchUp, this, &InputRedirection::processTouchUp);
connect(conn, &LibInput::Connection::touchMotion, this, &InputRedirection::processTouchMotion);
connect(conn, &LibInput::Connection::touchCanceled, this, &InputRedirection::cancelTouch);
connect(conn, &LibInput::Connection::touchFrame, this, &InputRedirection::touchFrame);
Center initial pointer position on screen in libinput mode
2014-10-17 09:57:14 +00:00
if (screens()) {
Ensure screens are created before fully setting up libinput Parts rely on screens being available but input might be created before screens are available. Thus connect to signal and delay.
2015-03-30 06:55:41 +00:00
setupLibInputWithScreens();
} else {
connect(kwinApp(), &Application::screensCreated, this, &InputRedirection::setupLibInputWithScreens);
Center initial pointer position on screen in libinput mode
2014-10-17 09:57:14 +00:00
}
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#if HAVE_WAYLAND
[libinput] Pass device capabilities to Wayland::Server::SeatInterface We handle device added/remove to monitor whether we have keyboard, pointer and touch devices and emit signals. Those are used to update the SeatInferface from InputRedirection.
2015-03-26 15:19:26 +00:00
if (auto s = findSeat()) {
s->setHasKeyboard(conn->hasKeyboard());
s->setHasPointer(conn->hasPointer());
s->setHasTouch(conn->hasTouch());
[input] Only update seat state if session is active When our session gets inactive libinput loses all devices, thus our Seat would not have neither keyboard, pointer nor touch. To not confuse all connected clients we block updates while libinput is suspended. After resume we check whether something actually changed and emit the corresponding signals to ensure everything is up to date.
2015-03-31 07:16:16 +00:00
connect(conn, &LibInput::Connection::hasKeyboardChanged, this,
[this, s] (bool set) {
if (m_libInput->isSuspended()) {
return;
}
s->setHasKeyboard(set);
}
);
connect(conn, &LibInput::Connection::hasPointerChanged, this,
[this, s] (bool set) {
if (m_libInput->isSuspended()) {
return;
}
s->setHasPointer(set);
}
);
connect(conn, &LibInput::Connection::hasTouchChanged, this,
[this, s] (bool set) {
if (m_libInput->isSuspended()) {
return;
}
s->setHasTouch(set);
}
);
[libinput] Pass device capabilities to Wayland::Server::SeatInterface We handle device added/remove to monitor whether we have keyboard, pointer and touch devices and emit signals. Those are used to update the SeatInferface from InputRedirection.
2015-03-26 15:19:26 +00:00
}
[libinput] Bind libinput support to VirtualTerminal This change is motivated by the fact that we need to suspend libinput before switching the virtual terminal. Also we don't want to take over libinput if we do not have a VirtualTerminal created - in windowed mode we don't want libinput to be started. So binding it to the backends which create the VirtualTerminal makes sense. The KWin::Application gains a new signal virtualTerminalCreated which is emitted from VirtualTerminal once it's properly setup. This is used by Input to create Libinput integration instead of binding it to logind. Furthermore Libinput gets suspended when the VirtualTerminal reports that it is no longer active. For re-activation we still just use logind's session active property.
2015-04-15 15:47:56 +00:00
connect(VirtualTerminal::self(), &VirtualTerminal::activeChanged, m_libInput,
[this] (bool active) {
if (!active) {
m_libInput->deactivate();
}
}
);
[libinput] Pass device capabilities to Wayland::Server::SeatInterface We handle device added/remove to monitor whether we have keyboard, pointer and touch devices and emit signals. Those are used to update the SeatInferface from InputRedirection.
2015-03-26 15:19:26 +00:00
#endif
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
}
#endif
[libinput] Pass device capabilities to Wayland::Server::SeatInterface We handle device added/remove to monitor whether we have keyboard, pointer and touch devices and emit signals. Those are used to update the SeatInferface from InputRedirection.
2015-03-26 15:19:26 +00:00
}
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
Ensure screens are created before fully setting up libinput Parts rely on screens being available but input might be created before screens are available. Thus connect to signal and delay.
2015-03-30 06:55:41 +00:00
void InputRedirection::setupLibInputWithScreens()
{
#if HAVE_INPUT
if (!screens() || !m_libInput) {
return;
}
m_libInput->setScreenSize(screens()->size());
connect(screens(), &Screens::sizeChanged, this,
[this] {
m_libInput->setScreenSize(screens()->size());
}
);
// set pos to center of all screens
connect(screens(), &Screens::changed, this, &InputRedirection::updatePointerAfterScreenChange);
m_globalPointer = screens()->geometry().center();
emit globalPointerChanged(m_globalPointer);
// sanitize
updatePointerAfterScreenChange();
#endif
}
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
void InputRedirection::updatePointerWindow()
{
// TODO: handle pointer grab aka popups
Toplevel *t = findToplevel(m_globalPointer.toPoint());
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
auto oldWindow = m_pointerWindow;
if (!oldWindow.isNull() && t == m_pointerWindow.data()) {
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
return;
}
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#if HAVE_WAYLAND
if (auto seat = findSeat()) {
// disconnect old surface
if (oldWindow) {
disconnect(oldWindow.data(), &Toplevel::geometryChanged, this, &InputRedirection::updateFocusedPointerPosition);
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
if (AbstractBackend *b = waylandServer()->backend()) {
[input] Add safety checks before accessing Cursor of focused pointer There might be no focused pointer and there might be no cursor.
2015-03-04 07:04:46 +00:00
if (auto p = seat->focusedPointer()) {
if (auto c = p->cursor()) {
disconnect(c, &KWayland::Server::Cursor::changed, b, &AbstractBackend::installCursorFromServer);
}
}
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
}
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
}
if (t && t->surface()) {
seat->setFocusedPointerSurface(t->surface(), t->pos());
connect(t, &Toplevel::geometryChanged, this, &InputRedirection::updateFocusedPointerPosition);
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
if (AbstractBackend *b = waylandServer()->backend()) {
b->installCursorFromServer();
[input] Add safety checks before accessing Cursor of focused pointer There might be no focused pointer and there might be no cursor.
2015-03-04 07:04:46 +00:00
if (auto p = seat->focusedPointer()) {
if (auto c = p->cursor()) {
connect(c, &KWayland::Server::Cursor::changed, b, &AbstractBackend::installCursorFromServer);
}
}
Introduce AbstractBackend as base class for Wayland and X11Windowed backend The AbstractBackend registers itself in the WaylandServer allowing external users to easily get to the backend and not needing to test manually which backend is used.
2015-03-20 13:41:03 +00:00
}
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
} else {
seat->setFocusedPointerSurface(nullptr);
t = nullptr;
}
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
}
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#endif
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
if (!t) {
m_pointerWindow.clear();
return;
}
m_pointerWindow = QWeakPointer<Toplevel>(t);
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
}
void InputRedirection::updateFocusedPointerPosition()
{
#if HAVE_WAYLAND
if (m_pointerWindow.isNull()) {
return;
}
if (workspace()->getMovingClient()) {
// don't update while moving
return;
}
if (auto seat = findSeat()) {
if (m_pointerWindow.data()->surface() != seat->focusedPointerSurface()) {
return;
}
seat->setFocusedPointerSurfacePosition(m_pointerWindow.data()->pos());
}
#endif
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
}
[wayland] Add support for processing touch events InputRedirection gains basic support for processing touch events which are delegated to KWayland::Server. WaylandBackend accepts touch events from KWayland::Client and delegates them to the InputRedirection.
2015-03-25 13:50:14 +00:00
void InputRedirection::updateFocusedTouchPosition()
{
#if HAVE_WAYLAND
if (m_touchWindow.isNull()) {
return;
}
if (auto seat = findSeat()) {
if (m_touchWindow.data()->surface() != seat->focusedTouchSurface()) {
return;
}
seat->setFocusedTouchSurfacePosition(m_touchWindow.data()->pos());
}
#endif
}
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
void InputRedirection::processPointerMotion(const QPointF &pos, uint32_t time)
{
// first update to new mouse position
// const QPointF oldPos = m_globalPointer;
Add sanity checks before updating pointer position and on screen changes We don't want the cursor to leave the visible area, so better check that the cursor doesn't leave it. And when the screens changes better check that the cursor is still on a visible screen. If not: put it back to the center of the closest screen.
2014-10-17 13:44:12 +00:00
updatePointerPosition(pos);
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
// TODO: check which part of KWin would like to intercept the event
Pass pointer events through the effect system InputRedirection forwards pointer events (currently motion, press and release) through the EffectsHandlerImpl for the case that an effect has intercepted pointer events. If the KWin operation mode is not X11 only, the window for intercepting the mouse events is no longer created.
2013-06-26 09:40:30 +00:00
QMouseEvent event(QEvent::MouseMove, m_globalPointer.toPoint(), m_globalPointer.toPoint(),
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
Qt::NoButton, qtButtonStates(), keyboardModifiers());
Pass pointer events through the effect system InputRedirection forwards pointer events (currently motion, press and release) through the EffectsHandlerImpl for the case that an effect has intercepted pointer events. If the KWin operation mode is not X11 only, the window for intercepting the mouse events is no longer created.
2013-06-26 09:40:30 +00:00
// check whether an effect has a mouse grab
if (effects && static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent(&event)) {
// an effect grabbed the pointer, we do not forward the event to surfaces
return;
}
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
QWeakPointer<Toplevel> old = m_pointerWindow;
updatePointerWindow();
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#if HAVE_WAYLAND
if (auto seat = findSeat()) {
seat->setTimestamp(time);
seat->setPointerPos(pos);
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
}
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#endif
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
}
void InputRedirection::processPointerButton(uint32_t button, InputRedirection::PointerButtonState state, uint32_t time)
{
m_pointerButtons[button] = state;
emit pointerButtonStateChanged(button, state);
Pass pointer events through the effect system InputRedirection forwards pointer events (currently motion, press and release) through the EffectsHandlerImpl for the case that an effect has intercepted pointer events. If the KWin operation mode is not X11 only, the window for intercepting the mouse events is no longer created.
2013-06-26 09:40:30 +00:00
QMouseEvent event(buttonStateToEvent(state), m_globalPointer.toPoint(), m_globalPointer.toPoint(),
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
buttonToQtMouseButton(button), qtButtonStates(), keyboardModifiers());
Pass pointer events through the effect system InputRedirection forwards pointer events (currently motion, press and release) through the EffectsHandlerImpl for the case that an effect has intercepted pointer events. If the KWin operation mode is not X11 only, the window for intercepting the mouse events is no longer created.
2013-06-26 09:40:30 +00:00
// check whether an effect has a mouse grab
if (effects && static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent(&event)) {
// an effect grabbed the pointer, we do not forward the event to surfaces
return;
}
Support for global pointer shortcut activation Sharing most of the code with keyboard shortcuts allowing to trigger a QAction with holding modifiers and clicking a mouse button.
2013-07-14 20:52:58 +00:00
#if HAVE_XKB
if (state == KWin::InputRedirection::PointerButtonPressed) {
if (m_shortcuts->processPointerPressed(m_xkb->modifiers(), qtButtonStates())) {
return;
}
}
#endif
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
// TODO: check which part of KWin would like to intercept the event
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#if HAVE_WAYLAND
if (auto seat = findSeat()) {
seat->setTimestamp(time);
state == PointerButtonPressed ? seat->pointerButtonPressed(button) : seat->pointerButtonReleased(button);
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
}
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#endif
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
}
void InputRedirection::processPointerAxis(InputRedirection::PointerAxis axis, qreal delta, uint32_t time)
{
if (delta == 0) {
return;
}
emit pointerAxisChanged(axis, delta);
Support for global pointer axis activation Just as pointer buttons...
2013-07-15 09:26:56 +00:00
#if HAVE_XKB
if (m_xkb->modifiers() != Qt::NoModifier) {
PointerAxisDirection direction = PointerAxisUp;
if (axis == PointerAxisHorizontal) {
if (delta > 0) {
direction = PointerAxisUp;
} else {
direction = PointerAxisDown;
}
} else {
if (delta > 0) {
direction = PointerAxisLeft;
} else {
direction = PointerAxisRight;
}
}
if (m_shortcuts->processAxis(m_xkb->modifiers(), direction)) {
return;
}
}
#endif
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
// TODO: check which part of KWin would like to intercept the event
Pass pointer events through the effect system InputRedirection forwards pointer events (currently motion, press and release) through the EffectsHandlerImpl for the case that an effect has intercepted pointer events. If the KWin operation mode is not X11 only, the window for intercepting the mouse events is no longer created.
2013-06-26 09:40:30 +00:00
// TODO: Axis support for effect redirection
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#if HAVE_WAYLAND
if (auto seat = findSeat()) {
seat->setTimestamp(time);
seat->pointerAxis(axis == InputRedirection::PointerAxisHorizontal ? Qt::Horizontal : Qt::Vertical, delta);
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
}
[wayland] Pass pointer input events to SeatInterface Pointer events are no longer sent through the methods on Toplevel, but properly sent through the SeatInterface. This has the advantage that SeatInterface properly tracks which is the focused pointer surface and does not need to use the xtest extension.
2015-02-26 14:32:44 +00:00
#endif
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
}
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
void InputRedirection::processKeyboardKey(uint32_t key, InputRedirection::KeyboardKeyState state, uint32_t time)
{
#if HAVE_XKB
[input] Try updating the modifiers after each key press TODO: send new modifier information to wayland server.
2015-03-27 13:15:25 +00:00
const Qt::KeyboardModifiers oldMods = keyboardModifiers();
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
m_xkb->updateKey(key, state);
[input] Try updating the modifiers after each key press TODO: send new modifier information to wayland server.
2015-03-27 13:15:25 +00:00
if (oldMods != keyboardModifiers()) {
emit keyboardModifiersChanged(keyboardModifiers(), oldMods);
}
[input] Add support for VT switch shortcuts If we have a VirtualTerminal and get a XKB_KEY_XF86Switch_VT_* keysym we trigger a VT switch.
2015-03-31 07:33:05 +00:00
#if HAVE_WAYLAND
// check for vt-switch
if (VirtualTerminal::self()) {
const xkb_keysym_t keysym = m_xkb->toKeysym(key);
if (state == KWin::InputRedirection::KeyboardKeyPressed &&
(keysym >= XKB_KEY_XF86Switch_VT_1 && keysym <= XKB_KEY_XF86Switch_VT_12)) {
VirtualTerminal::self()->activate(keysym - XKB_KEY_XF86Switch_VT_1 + 1);
return;
}
}
#endif
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
// TODO: pass to internal parts of KWin
Properly support key events in TabBox over InputRedirection Forward all key press events to the TabBox if it is currently grabbed and connect the TabBox to the modifiers changed signal for checking if TabBox should be ended.
2013-07-10 11:20:43 +00:00
#ifdef KWIN_BUILD_TABBOX
[input] Include more safety checks nullptr checks as input events might be processed prior to KWin having been fully started.
2015-03-27 13:40:57 +00:00
if (TabBox::TabBox::self() && TabBox::TabBox::self()->isGrabbed()) {
Properly support key events in TabBox over InputRedirection Forward all key press events to the TabBox if it is currently grabbed and connect the TabBox to the modifiers changed signal for checking if TabBox should be ended.
2013-07-10 11:20:43 +00:00
if (state == KWin::InputRedirection::KeyboardKeyPressed) {
TabBox::TabBox::self()->keyPress(m_xkb->modifiers() | m_xkb->toQtKey(m_xkb->toKeysym(key)));
}
return;
}
#endif
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
if (effects && static_cast< EffectsHandlerImpl* >(effects)->hasKeyboardGrab()) {
const xkb_keysym_t keysym = m_xkb->toKeysym(key);
// TODO: start auto-repeat
// TODO: add modifiers to the event
const QEvent::Type type = (state == KeyboardKeyPressed) ? QEvent::KeyPress : QEvent::KeyRelease;
QKeyEvent event(type, m_xkb->toQtKey(keysym), m_xkb->modifiers(), m_xkb->toString(keysym));
static_cast< EffectsHandlerImpl* >(effects)->grabbedKeyboardEvent(&event);
return;
}
[input] Include more safety checks nullptr checks as input events might be processed prior to KWin having been fully started.
2015-03-27 13:40:57 +00:00
if (workspace()) {
Workspace::movingClient changed to AbstractClient In events.cpp it's casted to Client as it's X11 specific. In InputRedirections it's kind of broken, but window movement is anyway broken.
2015-03-06 11:38:07 +00:00
if (Client *c = dynamic_cast<Client*>(workspace()->getMovingClient())) {
[input] Include more safety checks nullptr checks as input events might be processed prior to KWin having been fully started.
2015-03-27 13:40:57 +00:00
// TODO: this does not yet fully support moving of the Client
// cursor events change the cursor and on Wayland pointer warping is not possible
c->keyPressEvent(m_xkb->toQtKey(m_xkb->toKeysym(key)));
return;
}
Handle keyboard events during move/resize When moving/resizing a window we don't want the keyboard events being passed to the Clients. Instead we want to do the normal processing. Unfortunately moving the window through the keyboard relies on warping the pointer which is not (yet) available on Wayland. This means that this is not yet working, but ending through enter/escape etc. is working as expected.
2013-07-02 12:00:08 +00:00
}
Beginning of global shortcut handling inside KWin A new GlobalShortcutsManager is introduced which is responsible for holding the registered shortcuts and triggering the matching action. The InputRedirection checks with the GlobalShortcutManager whether a key press event triggers a global shortcut and stops processing the event in that case. At the moment the GlobalShortcutsManager only supports the very basics for KWin internal usage. External applications can not yet make usage of the global shortcut system inside KWin.
2013-07-10 09:41:16 +00:00
// process global shortcuts
if (state == KeyboardKeyPressed) {
if (m_shortcuts->processKey(m_xkb->modifiers(), m_xkb->toKeysym(key))) {
return;
}
}
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
#endif
[wayland] Pass keyboard key press/released events to SeatInterface Improves handling by no longer sending events with xtest.
2015-02-26 15:06:48 +00:00
#if HAVE_WAYLAND
if (auto seat = findSeat()) {
seat->setTimestamp(time);
// TODO: this needs better integration
// check unmanaged
Toplevel *t = nullptr;
if (!workspace()->unmanagedList().isEmpty()) {
// TODO: better check whether this unmanaged should get the key event
t = workspace()->unmanagedList().first();
}
if (!t) {
t = workspace()->activeClient();
}
if (t && t->surface()) {
if (t->surface() != seat->focusedKeyboardSurface()) {
seat->setFocusedKeyboardSurface(t->surface());
}
state == InputRedirection::KeyboardKeyPressed ? seat->keyPressed(key) : seat->keyReleased(key);
}
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
}
[wayland] Pass keyboard key press/released events to SeatInterface Improves handling by no longer sending events with xtest.
2015-02-26 15:06:48 +00:00
#endif
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
}
void InputRedirection::processKeyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group)
{
// TODO: send to proper Client and also send when active Client changes
#if HAVE_XKB
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
Qt::KeyboardModifiers oldMods = keyboardModifiers();
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
m_xkb->updateModifiers(modsDepressed, modsLatched, modsLocked, group);
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
if (oldMods != keyboardModifiers()) {
emit keyboardModifiersChanged(keyboardModifiers(), oldMods);
}
Fix unused variable warnings for compilation without xkbcommon Sorry, my fault that this generated warnings in the first place.
2014-04-28 14:57:35 +00:00
#else
Q_UNUSED(modsDepressed)
Q_UNUSED(modsLatched)
Q_UNUSED(modsLocked)
Q_UNUSED(group)
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
#endif
}
void InputRedirection::processKeymapChange(int fd, uint32_t size)
{
// TODO: should we pass the keymap to our Clients? Or only to the currently active one and update
#if HAVE_XKB
m_xkb->installKeymap(fd, size);
Fix unused variable warnings for compilation without xkbcommon Sorry, my fault that this generated warnings in the first place.
2014-04-28 14:57:35 +00:00
#else
Q_UNUSED(fd)
Q_UNUSED(size)
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
#endif
}
[wayland] Add support for processing touch events InputRedirection gains basic support for processing touch events which are delegated to KWayland::Server. WaylandBackend accepts touch events from KWayland::Client and delegates them to the InputRedirection.
2015-03-25 13:50:14 +00:00
void InputRedirection::processTouchDown(qint32 id, const QPointF &pos, quint32 time)
{
// TODO: internal handling?
#if HAVE_WAYLAND
if (auto seat = findSeat()) {
seat->setTimestamp(time);
if (!seat->isTouchSequence()) {
updateTouchWindow(pos);
}
m_touchIdMapper.insert(id, seat->touchDown(pos));
}
#else
Q_UNUSED(id)
Q_UNUSED(pos)
Q_UNUSED(time)
#endif
}
void InputRedirection::updateTouchWindow(const QPointF &pos)
{
// TODO: handle pointer grab aka popups
Toplevel *t = findToplevel(pos.toPoint());
auto oldWindow = m_touchWindow;
if (!oldWindow.isNull() && t == oldWindow.data()) {
return;
}
#if HAVE_WAYLAND
if (auto seat = findSeat()) {
// disconnect old surface
if (oldWindow) {
disconnect(oldWindow.data(), &Toplevel::geometryChanged, this, &InputRedirection::updateFocusedTouchPosition);
}
if (t && t->surface()) {
seat->setFocusedTouchSurface(t->surface(), t->pos());
connect(t, &Toplevel::geometryChanged, this, &InputRedirection::updateFocusedTouchPosition);
} else {
seat->setFocusedTouchSurface(nullptr);
t = nullptr;
}
}
#endif
if (!t) {
m_touchWindow.clear();
return;
}
m_touchWindow = QWeakPointer<Toplevel>(t);
}
void InputRedirection::processTouchUp(qint32 id, quint32 time)
{
// TODO: internal handling?
#if HAVE_WAYLAND
if (auto seat = findSeat()) {
auto it = m_touchIdMapper.constFind(id);
if (it != m_touchIdMapper.constEnd()) {
seat->setTimestamp(time);
seat->touchUp(it.value());
}
}
#else
Q_UNUSED(id)
Q_UNUSED(time)
#endif
}
void InputRedirection::processTouchMotion(qint32 id, const QPointF &pos, quint32 time)
{
// TODO: internal handling?
#if HAVE_WAYLAND
if (auto seat = findSeat()) {
seat->setTimestamp(time);
auto it = m_touchIdMapper.constFind(id);
if (it != m_touchIdMapper.constEnd()) {
seat->setTimestamp(time);
seat->touchMove(it.value(), pos);
}
}
#else
Q_UNUSED(id)
Q_UNUSED(pos)
Q_UNUSED(time)
#endif
}
void InputRedirection::cancelTouch()
{
#if HAVE_WAYLAND
if (auto seat = findSeat()) {
seat->cancelTouchSequence();
}
#endif
}
void InputRedirection::touchFrame()
{
#if HAVE_WAYLAND
if (auto seat = findSeat()) {
seat->touchFrame();
}
#endif
}
Pass pointer events through the effect system InputRedirection forwards pointer events (currently motion, press and release) through the EffectsHandlerImpl for the case that an effect has intercepted pointer events. If the KWin operation mode is not X11 only, the window for intercepting the mouse events is no longer created.
2013-06-26 09:40:30 +00:00
QEvent::Type InputRedirection::buttonStateToEvent(InputRedirection::PointerButtonState state)
{
switch (state) {
case KWin::InputRedirection::PointerButtonReleased:
return QEvent::MouseButtonRelease;
case KWin::InputRedirection::PointerButtonPressed:
return QEvent::MouseButtonPress;
}
return QEvent::None;
}
Qt::MouseButton InputRedirection::buttonToQtMouseButton(uint32_t button)
{
switch (button) {
case BTN_LEFT:
return Qt::LeftButton;
case BTN_MIDDLE:
return Qt::MiddleButton;
case BTN_RIGHT:
return Qt::RightButton;
case BTN_BACK:
return Qt::XButton1;
case BTN_FORWARD:
return Qt::XButton2;
}
return Qt::NoButton;
}
Qt::MouseButtons InputRedirection::qtButtonStates() const
{
Qt::MouseButtons buttons;
for (auto it = m_pointerButtons.constBegin(); it != m_pointerButtons.constEnd(); ++it) {
if (it.value() == KWin::InputRedirection::PointerButtonReleased) {
continue;
}
Qt::MouseButton button = buttonToQtMouseButton(it.key());
if (button != Qt::NoButton) {
buttons |= button;
}
}
return buttons;
}
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
Toplevel *InputRedirection::findToplevel(const QPoint &pos)
{
Add safety check to InputRedirection::findToplevel InputRedirection might be invoked to process input events prior to Workspace being started.
2015-03-20 13:43:47 +00:00
if (!Workspace::self()) {
return nullptr;
}
Redirect pointer events to the Toplevel InputRedirection keeps track of the Toplevel which is currently the one which should get pointer events. This is determined by checking whether there is an Unmanaged or a Client at the pointer position. At the moment this is still slightly incorrect, e.g. pointer grabs are ignored, unmanaged are not checked whether they are output only and input shapes are not yet tracked. The pointer events are delivered to the Toplevel as: * enter * leave * move * button press * axis event Nevertheless move events are still generated in InputRedirection through xcb test for simplicity. They are still send to the root window, so all windows get mouse move. Button press and axis are generated only in the implementations of the event handlers and delivered directly to the window, so other windows won't see it.
2013-07-01 06:37:59 +00:00
// TODO: check whether the unmanaged wants input events at all
const UnmanagedList &unmanaged = Workspace::self()->unmanagedList();
foreach (Unmanaged *u, unmanaged) {
if (u->geometry().contains(pos)) {
return u;
}
}
const ToplevelList &stacking = Workspace::self()->stackingOrder();
if (stacking.isEmpty()) {
return NULL;
}
auto it = stacking.end();
do {
--it;
Toplevel *t = (*it);
if (t->isDeleted()) {
// a deleted window doesn't get mouse events
continue;
}
if (t->isClient()) {
Client *c = static_cast<Client*>(t);
if (!c->isOnCurrentActivity() || !c->isOnCurrentDesktop() || c->isMinimized() || !c->isCurrentTab()) {
continue;
}
}
if (t->geometry().contains(pos)) {
return t;
}
} while (it != stacking.begin());
return NULL;
}
uint8_t InputRedirection::toXPointerButton(uint32_t button)
{
switch (button) {
case BTN_LEFT:
return XCB_BUTTON_INDEX_1;
case BTN_RIGHT:
return XCB_BUTTON_INDEX_3;
case BTN_MIDDLE:
return XCB_BUTTON_INDEX_2;
default:
// TODO: add more buttons
return XCB_BUTTON_INDEX_ANY;
}
}
uint8_t InputRedirection::toXPointerButton(InputRedirection::PointerAxis axis, qreal delta)
{
switch (axis) {
case PointerAxisVertical:
if (delta < 0) {
return 4;
} else {
return 5;
}
case PointerAxisHorizontal:
if (delta < 0) {
return 6;
} else {
return 7;
}
}
return XCB_BUTTON_INDEX_ANY;
}
Pass pointer events through the effect system InputRedirection forwards pointer events (currently motion, press and release) through the EffectsHandlerImpl for the case that an effect has intercepted pointer events. If the KWin operation mode is not X11 only, the window for intercepting the mouse events is no longer created.
2013-06-26 09:40:30 +00:00
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
Qt::KeyboardModifiers InputRedirection::keyboardModifiers() const
{
#if HAVE_XKB
return m_xkb->modifiers();
#else
return Qt::NoModifier;
#endif
}
Beginning of global shortcut handling inside KWin A new GlobalShortcutsManager is introduced which is responsible for holding the registered shortcuts and triggering the matching action. The InputRedirection checks with the GlobalShortcutManager whether a key press event triggers a global shortcut and stops processing the event in that case. At the moment the GlobalShortcutsManager only supports the very basics for KWin internal usage. External applications can not yet make usage of the global shortcut system inside KWin.
2013-07-10 09:41:16 +00:00
void InputRedirection::registerShortcut(const QKeySequence &shortcut, QAction *action)
{
m_shortcuts->registerShortcut(action, shortcut);
Update x11Time when a global shortcut is pressed KGlobalAccel sets the timestamp as a property and we need to set our x11Time to it otherwise following keyboard grabs might fail. Requires 61e2a156678eef033b2629f7c72530dc78d7c3ac in kglobalaccel.
2015-02-19 09:38:49 +00:00
registerShortcutForGlobalAccelTimestamp(action);
Beginning of global shortcut handling inside KWin A new GlobalShortcutsManager is introduced which is responsible for holding the registered shortcuts and triggering the matching action. The InputRedirection checks with the GlobalShortcutManager whether a key press event triggers a global shortcut and stops processing the event in that case. At the moment the GlobalShortcutsManager only supports the very basics for KWin internal usage. External applications can not yet make usage of the global shortcut system inside KWin.
2013-07-10 09:41:16 +00:00
}
InputRedirection for keyboard events Major new functionality is xkbcommon support. InputRedirection holds an instance to a small wrapper class which has the xkb context, keymap and state. The keymap is initialied from the file descriptor we get from the Wayland backend. InputRedirection uses this to translate the keycodes into keysymbols and to QString and to track the modifiers as provided by the Qt::KeybordModifiers flags. This provides us enough information for internal usage (e.g. pass through effects if they have "grabbed" the keyboard). If KWin doesn't filter out the key events, it passes them on to the currently active Client respectively an unmanaged on top of the stack. This needs still some improvement (not each unmanaged should get the event). The Client/Unmnaged still uses xtest extension to send the key events to the window. So keylogging is still possible.
2013-07-02 09:44:18 +00:00
Support for global pointer shortcut activation Sharing most of the code with keyboard shortcuts allowing to trigger a QAction with holding modifiers and clicking a mouse button.
2013-07-14 20:52:58 +00:00
void InputRedirection::registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action)
{
m_shortcuts->registerPointerShortcut(action, modifiers, pointerButtons);
}
Support for global pointer axis activation Just as pointer buttons...
2013-07-15 09:26:56 +00:00
void InputRedirection::registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action)
{
m_shortcuts->registerAxisShortcut(action, modifiers, axis);
}
Update x11Time when a global shortcut is pressed KGlobalAccel sets the timestamp as a property and we need to set our x11Time to it otherwise following keyboard grabs might fail. Requires 61e2a156678eef033b2629f7c72530dc78d7c3ac in kglobalaccel.
2015-02-19 09:38:49 +00:00
void InputRedirection::registerShortcutForGlobalAccelTimestamp(QAction *action)
{
connect(action, &QAction::triggered, kwinApp(), [action] {
QVariant timestamp = action->property("org.kde.kglobalaccel.activationTimestamp");
bool ok = false;
const quint32 t = timestamp.toULongLong(&ok);
if (ok) {
kwinApp()->setX11Time(t);
}
});
}
Add sanity checks before updating pointer position and on screen changes We don't want the cursor to leave the visible area, so better check that the cursor doesn't leave it. And when the screens changes better check that the cursor is still on a visible screen. If not: put it back to the center of the closest screen.
2014-10-17 13:44:12 +00:00
static bool screenContainsPos(const QPointF &pos)
{
for (int i = 0; i < screens()->count(); ++i) {
if (screens()->geometry(i).contains(pos.toPoint())) {
return true;
}
}
return false;
}
void InputRedirection::updatePointerPosition(const QPointF &pos)
{
// verify that at least one screen contains the pointer position
if (!screenContainsPos(pos)) {
return;
}
m_globalPointer = pos;
emit globalPointerChanged(m_globalPointer);
}
void InputRedirection::updatePointerAfterScreenChange()
{
if (screenContainsPos(m_globalPointer)) {
// pointer still on a screen
return;
}
// pointer no longer on a screen, reposition to closes screen
m_globalPointer = screens()->geometry(screens()->number(m_globalPointer.toPoint())).center();
emit globalPointerChanged(m_globalPointer);
}
Introduce the beginning of an InputRedirection class So far this new class is not yet doing much. The WaylandBackend forwards the received pointer events to this InputRedirection class. From there signals are emitted to inform internal areas about the changes first. The events are currently forwarded to X through the xtest extension. This will be removed in future. Input will be forwarded directly to the surface which wants it (no matter whether X11 or Wayland).
2013-06-26 08:15:20 +00:00
} // namespace
Reference in a new issue Copy permalink