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

230 lines
6.6 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/>.
*********************************************************************/
#ifndef KWIN_INPUT_H
#define KWIN_INPUT_H
#include <kwinglobals.h>
#include <QHash>
#include <QObject>
#include <QPoint>
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 <QEvent>
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 <QWeakPointer>
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 <config-kwin.h>
#if HAVE_XKB
#include <xkbcommon/xkbcommon.h>
#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
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
class QAction;
class QKeySequence;
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
{
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
class GlobalShortcutsManager;
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
class Toplevel;
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
class Xkb;
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
/**
* @brief This class is responsible for redirecting incoming input to the surface which currently
* has input or send enter/leave events.
*
* In addition input is intercepted before passed to the surfaces to have KWin internal areas
* getting input first (e.g. screen edges) and filter the input event out if we currently have
* a full input grab.
*
*/
class InputRedirection : public QObject
{
Q_OBJECT
public:
enum PointerButtonState {
PointerButtonReleased,
PointerButtonPressed
};
enum PointerAxis {
PointerAxisVertical,
PointerAxisHorizontal
};
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
enum KeyboardKeyState {
KeyboardKeyReleased,
KeyboardKeyPressed
};
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
virtual ~InputRedirection();
/**
* @return const QPointF& The current global pointer position
*/
const QPointF &globalPointer() const;
/**
* @brief The last known state of the @p button. If @p button is still unknown the state is
* @c PointerButtonReleased.
*
* @param button The button for which the last known state should be queried.
* @return KWin::InputRedirection::PointerButtonState
*/
PointerButtonState pointerButtonState(uint32_t button) const;
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
Qt::MouseButtons qtButtonStates() const;
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 keyboardModifiers() const;
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
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 registerShortcut(const QKeySequence &shortcut, QAction *action);
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 registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action);
Support for global pointer axis activation Just as pointer buttons...
2013-07-15 09:26:56 +00:00
void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *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
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
/**
* @internal
*/
void processPointerMotion(const QPointF &pos, uint32_t time);
/**
* @internal
*/
void processPointerButton(uint32_t button, PointerButtonState state, uint32_t time);
/**
* @internal
*/
void processPointerAxis(PointerAxis axis, qreal delta, uint32_t time);
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
/**
* @internal
*/
void processKeyboardKey(uint32_t key, KeyboardKeyState state, uint32_t time);
/**
* @internal
*/
void processKeyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group);
/**
* @internal
**/
void processKeymapChange(int fd, uint32_t size);
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
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
static uint8_t toXPointerButton(uint32_t button);
static uint8_t toXPointerButton(PointerAxis axis, qreal delta);
public Q_SLOTS:
void updatePointerWindow();
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
Q_SIGNALS:
/**
* @brief Emitted when the global pointer position changed
*
* @param pos The new global pointer position.
*/
void globalPointerChanged(const QPointF &pos);
/**
* @brief Emitted when the state of a pointer button changed.
*
* @param button The button which changed
* @param state The new button state
*/
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
void pointerButtonStateChanged(uint32_t button, InputRedirection::PointerButtonState state);
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
/**
* @brief Emitted when a pointer axis changed
*
* @param axis The axis on which the even occurred
* @param delta The delta of the event.
*/
Integrate KWin::Cursor with InputRedirection New inheriting class which uses the InputRedirection to track the cursor position. It doesn't support warping of cursor. This introduces a slight dependency loop in the startup. Cursor needs to be created after the WaylandBackend to ensure that the operation mode is set correctly. But the WaylandBackend itself is accessing Cursor. It should be safe as inside the WaylandBackend it's only accessed after callbacks.
2013-06-26 12:32:03 +00:00
void pointerAxisChanged(InputRedirection::PointerAxis axis, qreal delta);
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
/**
* @brief Emitted when the modifiers changes.
*
* Only emitted for the mask which is provided by Qt::KeyboardModifiers, if other modifiers
* change signal is not emitted
*
* @param newMods The new modifiers state
* @param oldMods The previous modifiers state
*/
void keyboardModifiersChanged(Qt::KeyboardModifiers newMods, Qt::KeyboardModifiers oldMods);
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
private:
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
static QEvent::Type buttonStateToEvent(PointerButtonState state);
static Qt::MouseButton buttonToQtMouseButton(uint32_t button);
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 *findToplevel(const QPoint &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
QPointF m_globalPointer;
QHash<uint32_t, PointerButtonState> m_pointerButtons;
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
QScopedPointer<Xkb> m_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
/**
* @brief The Toplevel which currently receives pointer events
*/
QWeakPointer<Toplevel> m_pointerWindow;
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
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
GlobalShortcutsManager *m_shortcuts;
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(InputRedirection)
friend InputRedirection *input();
};
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
class Xkb
{
public:
Xkb();
~Xkb();
void installKeymap(int fd, uint32_t size);
void updateModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group);
void updateKey(uint32_t key, InputRedirection::KeyboardKeyState state);
xkb_keysym_t toKeysym(uint32_t key);
QString toString(xkb_keysym_t keysym);
Qt::Key toQtKey(xkb_keysym_t keysym);
Qt::KeyboardModifiers modifiers() const;
private:
xkb_context *m_context;
xkb_keymap *m_keymap;
xkb_state *m_state;
xkb_mod_index_t m_shiftModifier;
xkb_mod_index_t m_controlModifier;
xkb_mod_index_t m_altModifier;
xkb_mod_index_t m_metaModifier;
Qt::KeyboardModifiers m_modifiers;
};
#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
inline
InputRedirection *input()
{
return InputRedirection::s_self;
}
inline
const QPointF &InputRedirection::globalPointer() const
{
return m_globalPointer;
}
inline
InputRedirection::PointerButtonState InputRedirection::pointerButtonState(uint32_t button) const
{
auto it = m_pointerButtons.constFind(button);
if (it != m_pointerButtons.constEnd()) {
return it.value();
} else {
return KWin::InputRedirection::PointerButtonReleased;
}
}
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
inline
Qt::KeyboardModifiers Xkb::modifiers() const
{
return m_modifiers;
}
#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
} // namespace KWin
#endif // KWIN_INPUT_H
Reference in a new issue Copy permalink