input.h

Go to the documentation of this file.

/*
    KWin - the KDE window manager
    This file is part of the KDE project.
 
    SPDX-FileCopyrightText: 2013 Martin Gräßlin <mgraesslin@kde.org>
    SPDX-FileCopyrightText: 2018 Roman Gilg <subdiff@gmail.com>
    SPDX-FileCopyrightText: 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
    SPDX-License-Identifier: GPL-2.0-or-later
*/
#pragma once
#include <config-kwin.h>
 
#include "effect/globals.h"
#include <QObject>
#include <QPoint>
#include <QPointer>
 
#include <KConfigWatcher>
#include <KSharedConfig>
#include <QSet>
 
#include "config-kwin.h"
#include <functional>
 
class KGlobalAccelInterface;
class QAction;
class QKeySequence;
class QMouseEvent;
class QKeyEvent;
class QWheelEvent;
 
namespace KWin
{
class IdleDetector;
class Window;
class GlobalShortcutsManager;
class InputEventFilter;
class InputEventSpy;
class KeyboardInputRedirection;
class PointerInputRedirection;
class TabletInputRedirection;
class TouchInputRedirection;
class WindowSelectorFilter;
class SwitchEvent;
class TabletEvent;
class TabletToolId;
class TabletPadId;
class MouseEvent;
class WheelEvent;
class KeyEvent;
 
namespace Decoration
{
class DecoratedClientImpl;
}
 
class InputBackend;
class InputDevice;
 
class KWIN_EXPORT InputRedirection : public QObject
{
    Q_OBJECT
public:
    enum PointerButtonState {
        PointerButtonReleased,
        PointerButtonPressed
    };
    enum PointerAxis {
        PointerAxisVertical,
        PointerAxisHorizontal
    };
    enum PointerAxisSource {
        PointerAxisSourceUnknown,
        PointerAxisSourceWheel,
        PointerAxisSourceFinger,
        PointerAxisSourceContinuous,
        PointerAxisSourceWheelTilt
    };
    enum KeyboardKeyState {
        KeyboardKeyReleased,
        KeyboardKeyPressed,
        KeyboardKeyAutoRepeat
    };
    enum TabletEventType {
        Axis,
        Proximity,
        Tip
    };
    enum TabletToolType {
        Pen,
        Eraser,
        Brush,
        Pencil,
        Airbrush,
        Finger,
        Mouse,
        Lens,
        Totem,
    };
    enum Capability {
        Tilt,
        Pressure,
        Distance,
        Rotation,
        Slider,
        Wheel,
    };
 
    ~InputRedirection() override;
    void init();
 
    QPointF globalPointer() const;
    Qt::MouseButtons qtButtonStates() const;
    Qt::KeyboardModifiers keyboardModifiers() const;
    Qt::KeyboardModifiers modifiersRelevantForGlobalShortcuts() const;
 
    void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action);
    void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action);
    void registerTouchpadSwipeShortcut(SwipeDirection direction, uint32_t fingerCount, QAction *onUp, std::function<void(qreal)> progressCallback = {});
    void registerTouchpadPinchShortcut(PinchDirection direction, uint32_t fingerCount, QAction *onUp, std::function<void(qreal)> progressCallback = {});
    void registerTouchscreenSwipeShortcut(SwipeDirection direction, uint32_t fingerCount, QAction *action, std::function<void(qreal)> progressCallback = {});
    void forceRegisterTouchscreenSwipeShortcut(SwipeDirection direction, uint32_t fingerCount, QAction *action, std::function<void(qreal)> progressCallback = {});
    void registerGlobalAccel(KGlobalAccelInterface *interface);
 
    bool supportsPointerWarping() const;
    void warpPointer(const QPointF &pos);
 
    void prependInputEventFilter(InputEventFilter *filter);
    void uninstallInputEventFilter(InputEventFilter *filter);
 
    void installInputEventSpy(InputEventSpy *spy);
 
    void uninstallInputEventSpy(InputEventSpy *spy);
 
    void simulateUserActivity();
 
    void addIdleDetector(IdleDetector *detector);
    void removeIdleDetector(IdleDetector *detector);
 
    QList<Window *> idleInhibitors() const;
    void addIdleInhibitor(Window *inhibitor);
    void removeIdleInhibitor(Window *inhibitor);
 
    Window *findToplevel(const QPointF &pos);
#if KWIN_BUILD_GLOBALSHORTCUTS
    GlobalShortcutsManager *shortcuts() const
    {
        return m_shortcuts;
    }
#endif
 
    template<class UnaryPredicate>
    void processFilters(UnaryPredicate function)
    {
        std::any_of(m_filters.constBegin(), m_filters.constEnd(), function);
    }
 
    template<class UnaryFunction>
    void processSpies(UnaryFunction function)
    {
        std::for_each(m_spies.constBegin(), m_spies.constEnd(), function);
    }
 
    KeyboardInputRedirection *keyboard() const
    {
        return m_keyboard;
    }
    PointerInputRedirection *pointer() const
    {
        return m_pointer;
    }
    TabletInputRedirection *tablet() const
    {
        return m_tablet;
    }
    TouchInputRedirection *touch() const
    {
        return m_touch;
    }
 
    void setLastInputHandler(QObject *device);
    QObject *lastInputHandler() const;
 
    QList<InputDevice *> devices() const;
 
    bool hasAlphaNumericKeyboard();
    bool hasPointer() const;
    bool hasTouch() const;
    bool hasTabletModeSwitch();
 
    void startInteractiveWindowSelection(std::function<void(KWin::Window *)> callback, const QByteArray &cursorName);
    void startInteractivePositionSelection(std::function<void(const QPoint &)> callback);
    bool isSelectingWindow() const;
 
    void toggleTouchpads();
    void enableTouchpads();
    void disableTouchpads();
 
Q_SIGNALS:
    void deviceAdded(InputDevice *device);
    void deviceRemoved(InputDevice *device);
    void globalPointerChanged(const QPointF &pos);
    void pointerButtonStateChanged(uint32_t button, InputRedirection::PointerButtonState state);
    void pointerAxisChanged(InputRedirection::PointerAxis axis, qreal delta);
    void keyboardModifiersChanged(Qt::KeyboardModifiers newMods, Qt::KeyboardModifiers oldMods);
    void keyStateChanged(quint32 keyCode, InputRedirection::KeyboardKeyState state);
 
    void hasKeyboardChanged(bool set);
    void hasAlphaNumericKeyboardChanged(bool set);
    void hasPointerChanged(bool set);
    void hasTouchChanged(bool set);
    void hasTabletModeSwitchChanged(bool set);
 
public Q_SLOTS:
    void addInputDevice(InputDevice *device);
    void removeInputDevice(InputDevice *device);
 
private Q_SLOTS:
    void handleInputConfigChanged(const KConfigGroup &group);
    void updateScreens();
 
private:
    void setupInputBackends();
    void setupTouchpadShortcuts();
    void setupWorkspace();
    void setupInputFilters();
    void installInputEventFilter(InputEventFilter *filter);
    void updateLeds(LEDs leds);
    void updateAvailableInputDevices();
    void addInputBackend(std::unique_ptr<InputBackend> &&inputBackend);
    KeyboardInputRedirection *m_keyboard;
    PointerInputRedirection *m_pointer;
    TabletInputRedirection *m_tablet;
    TouchInputRedirection *m_touch;
    QObject *m_lastInputDevice = nullptr;
 
#if KWIN_BUILD_GLOBALSHORTCUTS
    GlobalShortcutsManager *m_shortcuts;
#endif
 
    std::vector<std::unique_ptr<InputBackend>> m_inputBackends;
    QList<InputDevice *> m_inputDevices;
 
    QList<IdleDetector *> m_idleDetectors;
    QList<Window *> m_idleInhibitors;
    std::unique_ptr<WindowSelectorFilter> m_windowSelector;
 
    QList<InputEventFilter *> m_filters;
    QList<InputEventSpy *> m_spies;
    KConfigWatcher::Ptr m_inputConfigWatcher;
 
    std::unique_ptr<InputEventFilter> m_virtualTerminalFilter;
    std::unique_ptr<InputEventFilter> m_dragAndDropFilter;
    std::unique_ptr<InputEventFilter> m_lockscreenFilter;
    std::unique_ptr<InputEventFilter> m_screenEdgeFilter;
    std::unique_ptr<InputEventFilter> m_tabboxFilter;
    std::unique_ptr<InputEventFilter> m_globalShortcutFilter;
    std::unique_ptr<InputEventFilter> m_effectsFilter;
    std::unique_ptr<InputEventFilter> m_interactiveMoveResizeFilter;
    std::unique_ptr<InputEventFilter> m_popupFilter;
    std::unique_ptr<InputEventFilter> m_decorationFilter;
    std::unique_ptr<InputEventFilter> m_windowActionFilter;
    std::unique_ptr<InputEventFilter> m_internalWindowFilter;
    std::unique_ptr<InputEventFilter> m_inputKeyboardFilter;
    std::unique_ptr<InputEventFilter> m_forwardFilter;
    std::unique_ptr<InputEventFilter> m_tabletFilter;
 
    std::unique_ptr<InputEventSpy> m_hideCursorSpy;
    std::unique_ptr<InputEventSpy> m_userActivitySpy;
    std::unique_ptr<InputEventSpy> m_windowInteractedSpy;
 
    LEDs m_leds;
    bool m_hasKeyboard = false;
    bool m_hasPointer = false;
    bool m_hasTouch = false;
    bool m_hasTabletModeSwitch = false;
    bool m_touchpadsEnabled = true;
 
    KWIN_SINGLETON(InputRedirection)
    friend InputRedirection *input();
    friend class DecorationEventFilter;
    friend class InternalWindowEventFilter;
    friend class ForwardInputFilter;
};
 
class KWIN_EXPORT InputEventFilter
{
public:
    InputEventFilter();
    virtual ~InputEventFilter();
 
    virtual bool pointerEvent(MouseEvent *event, quint32 nativeButton);
    virtual bool pointerFrame();
    virtual bool wheelEvent(WheelEvent *event);
    virtual bool keyEvent(KeyEvent *event);
    virtual bool touchDown(qint32 id, const QPointF &pos, std::chrono::microseconds time);
    virtual bool touchMotion(qint32 id, const QPointF &pos, std::chrono::microseconds time);
    virtual bool touchUp(qint32 id, std::chrono::microseconds time);
    virtual bool touchCancel();
    virtual bool touchFrame();
 
    virtual bool pinchGestureBegin(int fingerCount, std::chrono::microseconds time);
    virtual bool pinchGestureUpdate(qreal scale, qreal angleDelta, const QPointF &delta, std::chrono::microseconds time);
    virtual bool pinchGestureEnd(std::chrono::microseconds time);
    virtual bool pinchGestureCancelled(std::chrono::microseconds time);
 
    virtual bool swipeGestureBegin(int fingerCount, std::chrono::microseconds time);
    virtual bool swipeGestureUpdate(const QPointF &delta, std::chrono::microseconds time);
    virtual bool swipeGestureEnd(std::chrono::microseconds time);
    virtual bool swipeGestureCancelled(std::chrono::microseconds time);
 
    virtual bool holdGestureBegin(int fingerCount, std::chrono::microseconds time);
    virtual bool holdGestureEnd(std::chrono::microseconds time);
    virtual bool holdGestureCancelled(std::chrono::microseconds time);
 
    virtual bool switchEvent(SwitchEvent *event);
 
    virtual bool tabletToolEvent(TabletEvent *event);
    virtual bool tabletToolButtonEvent(uint button, bool pressed, const TabletToolId &tabletToolId, std::chrono::microseconds time);
    virtual bool tabletPadButtonEvent(uint button, bool pressed, const TabletPadId &tabletPadId, std::chrono::microseconds time);
    virtual bool tabletPadStripEvent(int number, int position, bool isFinger, const TabletPadId &tabletPadId, std::chrono::microseconds time);
    virtual bool tabletPadRingEvent(int number, int position, bool isFinger, const TabletPadId &tabletPadId, std::chrono::microseconds time);
 
protected:
    void passToWaylandServer(QKeyEvent *event);
    bool passToInputMethod(QKeyEvent *event);
};
 
class KWIN_EXPORT InputDeviceHandler : public QObject
{
    Q_OBJECT
public:
    ~InputDeviceHandler() override;
    virtual void init();
 
    void update();
 
    Window *hover() const;
    Window *focus() const;
 
    Decoration::DecoratedClientImpl *decoration() const;
 
    virtual QPointF position() const = 0;
 
    void setFocus(Window *window);
    void setDecoration(Decoration::DecoratedClientImpl *decoration);
 
Q_SIGNALS:
    void decorationChanged();
 
protected:
    explicit InputDeviceHandler(InputRedirection *parent);
 
    virtual void cleanupDecoration(Decoration::DecoratedClientImpl *old, Decoration::DecoratedClientImpl *now) = 0;
 
    virtual void focusUpdate(Window *old, Window *now) = 0;
 
    virtual bool positionValid() const
    {
        return true;
    }
    virtual bool focusUpdatesBlocked()
    {
        return false;
    }
 
    inline bool inited() const
    {
        return m_inited;
    }
    inline void setInited(bool set)
    {
        m_inited = set;
    }
 
private:
    bool setHover(Window *window);
    void updateFocus();
    void updateDecoration();
 
    struct
    {
        QPointer<Window> window;
        QMetaObject::Connection surfaceCreatedConnection;
    } m_hover;
 
    struct
    {
        QPointer<Window> window;
        QPointer<Decoration::DecoratedClientImpl> decoration;
    } m_focus;
 
    bool m_inited = false;
};
 
inline InputRedirection *input()
{
    return InputRedirection::s_self;
}
 
inline QList<InputDevice *> InputRedirection::devices() const
{
    return m_inputDevices;
}
 
} // namespace KWin
 
Q_DECLARE_METATYPE(KWin::InputRedirection::KeyboardKeyState)
Q_DECLARE_METATYPE(KWin::InputRedirection::PointerButtonState)
Q_DECLARE_METATYPE(KWin::InputRedirection::PointerAxis)
Q_DECLARE_METATYPE(KWin::InputRedirection::PointerAxisSource)