seat.h

Go to the documentation of this file.

/*
    SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
    SPDX-FileCopyrightText: 2021 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/
#pragma once
 
#include "kwin_export.h"
 
#include <QMatrix4x4>
#include <QObject>
#include <QPoint>
 
struct wl_client;
struct wl_resource;
 
namespace KWin
{
class AbstractDataSource;
class AbstractDropHandler;
class DragAndDropIcon;
class DataDeviceInterface;
class Display;
class KeyboardInterface;
class PointerInterface;
class SeatInterfacePrivate;
class SurfaceInterface;
class TextInputV1Interface;
class TextInputV2Interface;
class TextInputV3Interface;
class TouchInterface;
class XdgToplevelDragV1Interface;
 
enum class PointerAxisSource {
    Unknown,
    Wheel,
    Finger,
    Continuous,
    WheelTilt,
};
 
enum class PointerAxisRelativeDirection {
    Normal,
    Inverted
};
 
enum class PointerButtonState : quint32 {
    Released = 0,
    Pressed = 1,
};
 
enum class KeyboardKeyState : quint32 {
    Released = 0,
    Pressed = 1,
};
 
class KWIN_EXPORT SeatInterface : public QObject
{
    Q_OBJECT
public:
    explicit SeatInterface(Display *display, QObject *parent = nullptr);
    virtual ~SeatInterface();
 
    Display *display() const;
    QString name() const;
    bool hasPointer() const;
    bool hasKeyboard() const;
    bool hasTouch() const;
 
    void setName(const QString &name);
    void setHasPointer(bool has);
    void setHasKeyboard(bool has);
    void setHasTouch(bool has);
 
    void setTimestamp(std::chrono::microseconds time);
    std::chrono::milliseconds timestamp() const;
 
 
    bool isDrag() const;
    bool isDragPointer() const;
    bool isDragTouch() const;
    QMatrix4x4 dragSurfaceTransformation() const;
    SurfaceInterface *dragSurface() const;
    AbstractDataSource *dragSource() const;
    XdgToplevelDragV1Interface *xdgTopleveldrag() const;
 
    void setDragTarget(AbstractDropHandler *dropTarget, SurfaceInterface *surface, const QPointF &globalPosition, const QMatrix4x4 &inputTransformation);
    void setDragTarget(AbstractDropHandler *dropTarget, SurfaceInterface *surface, const QMatrix4x4 &inputTransformation = QMatrix4x4());
 
    AbstractDropHandler *dropHandlerForSurface(SurfaceInterface *surface) const;
 
    void cancelDrag();
 
 
    void notifyPointerMotion(const QPointF &pos);
    QPointF pointerPos() const;
    void notifyPointerEnter(SurfaceInterface *surface, const QPointF &position, const QPointF &surfacePosition = QPointF());
    void notifyPointerEnter(SurfaceInterface *surface, const QPointF &position, const QMatrix4x4 &transformation);
    void notifyPointerLeave();
    SurfaceInterface *focusedPointerSurface() const;
    PointerInterface *pointer() const;
    void setFocusedPointerSurfacePosition(const QPointF &surfacePosition);
    QPointF focusedPointerSurfacePosition() const;
    void setFocusedPointerSurfaceTransformation(const QMatrix4x4 &transformation);
    QMatrix4x4 focusedPointerSurfaceTransformation() const;
    void notifyPointerButton(quint32 button, PointerButtonState state);
    void notifyPointerButton(Qt::MouseButton button, PointerButtonState state);
    void notifyPointerFrame();
    bool isPointerButtonPressed(quint32 button) const;
    bool isPointerButtonPressed(Qt::MouseButton button) const;
    quint32 pointerButtonSerial(quint32 button) const;
    quint32 pointerButtonSerial(Qt::MouseButton button) const;
    void notifyPointerAxis(Qt::Orientation orientation, qreal delta, qint32 deltaV120, PointerAxisSource source, PointerAxisRelativeDirection direction = PointerAxisRelativeDirection::Normal);
    bool hasImplicitPointerGrab(quint32 serial) const;
 
    void relativePointerMotion(const QPointF &delta, const QPointF &deltaNonAccelerated, std::chrono::microseconds timestamp);
 
    void startPointerSwipeGesture(quint32 fingerCount);
 
    void updatePointerSwipeGesture(const QPointF &delta);
 
    void endPointerSwipeGesture();
 
    void cancelPointerSwipeGesture();
 
    void startPointerPinchGesture(quint32 fingerCount);
 
    void updatePointerPinchGesture(const QPointF &delta, qreal scale, qreal rotation);
 
    void endPointerPinchGesture();
 
    void cancelPointerPinchGesture();
 
    void startPointerHoldGesture(quint32 fingerCount);
 
    void endPointerHoldGesture();
 
    void cancelPointerHoldGesture();
 
    void setFocusedKeyboardSurface(SurfaceInterface *surface);
    SurfaceInterface *focusedKeyboardSurface() const;
    KeyboardInterface *keyboard() const;
    void notifyKeyboardKey(quint32 keyCode, KeyboardKeyState state);
    void notifyKeyboardModifiers(quint32 depressed, quint32 latched, quint32 locked, quint32 group);
 
    void setFocusedTouchSurface(SurfaceInterface *surface, const QPointF &surfacePosition = QPointF());
    SurfaceInterface *focusedTouchSurface() const;
    TouchInterface *touch() const;
    void setFocusedTouchSurfacePosition(const QPointF &surfacePosition);
    QPointF focusedTouchSurfacePosition() const;
    void notifyTouchDown(qint32 id, const QPointF &globalPosition);
    void notifyTouchUp(qint32 id);
    void notifyTouchMotion(qint32 id, const QPointF &globalPosition);
    void notifyTouchFrame();
    void notifyTouchCancel();
    bool isTouchSequence() const;
    QPointF firstTouchPointPosition() const;
    bool hasImplicitTouchGrab(quint32 serial) const;
 
 
    void setFocusedTextInputSurface(SurfaceInterface *surface);
    SurfaceInterface *focusedTextInputSurface() const;
 
    TextInputV1Interface *textInputV1() const;
 
    TextInputV2Interface *textInputV2() const;
 
    TextInputV3Interface *textInputV3() const;
 
    AbstractDataSource *selection() const;
 
    void setSelection(AbstractDataSource *selection);
 
    AbstractDataSource *primarySelection() const;
    void setPrimarySelection(AbstractDataSource *selection);
 
    void startDrag(AbstractDataSource *source, SurfaceInterface *sourceSurface, int dragSerial = -1, DragAndDropIcon *dragIcon = nullptr);
 
    DragAndDropIcon *dragIcon() const;
 
    static SeatInterface *get(wl_resource *native);
 
Q_SIGNALS:
    void nameChanged(const QString &);
    void hasPointerChanged(bool);
    void hasKeyboardChanged(bool);
    void hasTouchChanged(bool);
    void pointerPosChanged(const QPointF &pos);
    void touchMoved(qint32 id, quint32 serial, const QPointF &globalPosition);
    void timestampChanged();
 
    void selectionChanged(KWin::AbstractDataSource *);
 
    void primarySelectionChanged(KWin::AbstractDataSource *);
 
    void dragStarted();
    void dragEnded();
    void dragSurfaceChanged();
 
    void dragDropped();
    void focusedTextInputSurfaceChanged();
    void focusedKeyboardSurfaceAboutToChange(SurfaceInterface *nextSurface);
 
private:
    std::unique_ptr<SeatInterfacePrivate> d;
    friend class SeatInterfacePrivate;
};
 
}
 
Q_DECLARE_METATYPE(KWin::SeatInterface *)