tablet_v2.h

Go to the documentation of this file.

/*
    SPDX-FileCopyrightText: 2019 Aleix Pol Gonzalez <aleixpol@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 <QList>
#include <QObject>
#include <memory>
 
struct wl_resource;
 
namespace KWin
{
class ClientConnection;
class Display;
class SeatInterface;
class SurfaceInterface;
class TabletSurfaceCursorV2;
class TabletSurfaceCursorV2Private;
class TabletManagerV2InterfacePrivate;
class TabletSeatV2Interface;
class TabletSeatV2InterfacePrivate;
class TabletToolV2InterfacePrivate;
class TabletV2Interface;
class TabletV2InterfacePrivate;
class TabletPadV2Interface;
class TabletPadV2InterfacePrivate;
class TabletPadRingV2Interface;
class TabletPadRingV2InterfacePrivate;
class TabletPadStripV2Interface;
class TabletPadStripV2InterfacePrivate;
class TabletPadGroupV2Interface;
class TabletPadGroupV2InterfacePrivate;
 
class KWIN_EXPORT TabletManagerV2Interface : public QObject
{
    Q_OBJECT
public:
    explicit TabletManagerV2Interface(Display *d, QObject *parent);
    virtual ~TabletManagerV2Interface();
 
    TabletSeatV2Interface *seat(SeatInterface *seat) const;
 
private:
    std::unique_ptr<TabletManagerV2InterfacePrivate> d;
};
 
class KWIN_EXPORT TabletSurfaceCursorV2 : public QObject
{
    Q_OBJECT
public:
    ~TabletSurfaceCursorV2() override;
    QPoint hotspot() const;
    quint32 enteredSerial() const;
    SurfaceInterface *surface() const;
 
Q_SIGNALS:
    void changed();
 
private:
    TabletSurfaceCursorV2();
    const std::unique_ptr<TabletSurfaceCursorV2Private> d;
    friend class TabletToolV2InterfacePrivate;
};
 
using TabletCursorSourceV2 = std::variant<TabletSurfaceCursorV2 *, QByteArray>;
 
class KWIN_EXPORT TabletToolV2Interface : public QObject
{
    Q_OBJECT
public:
    virtual ~TabletToolV2Interface();
 
    enum Type {
        Pen = 0x140, 
        Eraser = 0x141, 
        Brush = 0x142, 
        Pencil = 0x143, 
        Airbrush = 0x144, 
        Finger = 0x145, 
        Mouse = 0x146, 
        Lens = 0x147, 
        Totem
    };
    Q_ENUM(Type)
 
    enum Capability {
        Tilt = 1, 
        Pressure = 2, 
        Distance = 3, 
        Rotation = 4, 
        Slider = 5, 
        Wheel = 6, 
    };
    Q_ENUM(Capability)
 
    bool hasCapability(Capability capability) const;
 
    void setCurrentSurface(SurfaceInterface *surface);
    SurfaceInterface *currentSurface() const;
 
    bool isClientSupported() const;
 
    quint32 proximitySerial() const;
    std::optional<quint32> downSerial() const;
 
    void sendProximityIn(TabletV2Interface *tablet);
    void sendProximityOut();
    void sendUp();
    void sendDown();
    void sendPressure(quint32 pressure);
    void sendDistance(quint32 distance);
    void sendTilt(qreal degreesX, qreal degreesY);
    void sendRotation(qreal degrees);
    void sendSlider(qint32 position);
    void sendWheel(qint32 degrees, qint32 clicks);
    void sendButton(quint32 button, bool pressed);
    void sendFrame(quint32 time);
    void sendMotion(const QPointF &pos);
 
    static TabletToolV2Interface *get(wl_resource *resource);
 
Q_SIGNALS:
    void cursorChanged(const TabletCursorSourceV2 &cursor);
 
private:
    friend class TabletSeatV2InterfacePrivate;
    friend class TabletSeatV2Interface;
    explicit TabletToolV2Interface(Display *display,
                                   Type type,
                                   quint32 hsh,
                                   quint32 hsl,
                                   quint32 hih,
                                   quint32 hil,
                                   const QList<Capability> &capability);
    std::unique_ptr<TabletToolV2InterfacePrivate> d;
};
 
class KWIN_EXPORT TabletPadV2Interface : public QObject
{
    Q_OBJECT
public:
    virtual ~TabletPadV2Interface();
 
    TabletPadRingV2Interface *ring(uint at) const;
    TabletPadStripV2Interface *strip(uint at) const;
    void sendButton(std::chrono::microseconds time, quint32 button, bool pressed);
 
    void setCurrentSurface(SurfaceInterface *surface, TabletV2Interface *tablet);
    SurfaceInterface *currentSurface() const;
 
Q_SIGNALS:
    void feedback(KWin::ClientConnection *client, quint32 button, const QString &description, quint32 serial);
 
private:
    friend class TabletSeatV2Interface;
    friend class TabletSeatV2InterfacePrivate;
    explicit TabletPadV2Interface(const QString &path,
                                  quint32 buttons,
                                  quint32 rings,
                                  quint32 strips,
                                  quint32 modes,
                                  quint32 currentMode,
                                  Display *display,
                                  TabletSeatV2Interface *parent);
    std::unique_ptr<TabletPadV2InterfacePrivate> d;
};
 
class KWIN_EXPORT TabletPadRingV2Interface : public QObject
{
    Q_OBJECT
public:
    virtual ~TabletPadRingV2Interface();
 
    enum Source {
        SourceFinger = 1, // finger
    };
    Q_ENUM(Source)
 
    void sendSource(Source source);
    void sendAngle(qreal angle);
    void sendStop();
    void sendFrame(quint32 time);
 
private:
    friend class TabletPadGroupV2Interface;
    friend class TabletPadV2InterfacePrivate;
    friend class TabletSeatV2InterfacePrivate;
    explicit TabletPadRingV2Interface(TabletPadV2Interface *parent);
    std::unique_ptr<TabletPadRingV2InterfacePrivate> d;
};
 
class KWIN_EXPORT TabletPadStripV2Interface : public QObject
{
    Q_OBJECT
public:
    virtual ~TabletPadStripV2Interface();
 
    enum Source {
        SourceFinger = 1, // finger
    };
 
    void sendSource(Source source);
    void sendPosition(quint32 position);
    void sendFrame(quint32 time);
    void sendStop();
 
private:
    friend class TabletPadGroupV2Interface;
    friend class TabletPadV2InterfacePrivate;
    friend class TabletSeatV2InterfacePrivate;
    explicit TabletPadStripV2Interface(TabletPadV2Interface *parent);
    std::unique_ptr<TabletPadStripV2InterfacePrivate> d;
};
 
class KWIN_EXPORT TabletPadGroupV2Interface : public QObject
{
    Q_OBJECT
public:
    virtual ~TabletPadGroupV2Interface();
 
    void sendModeSwitch(quint32 time, quint32 serial, quint32 mode);
 
private:
    friend class TabletPadV2Interface;
    friend class TabletPadV2InterfacePrivate;
    friend class TabletSeatV2InterfacePrivate;
    explicit TabletPadGroupV2Interface(quint32 currentMode, TabletPadV2Interface *parent);
    std::unique_ptr<TabletPadGroupV2InterfacePrivate> d;
};
 
class KWIN_EXPORT TabletV2Interface : public QObject
{
    Q_OBJECT
public:
    virtual ~TabletV2Interface();
 
    bool isSurfaceSupported(SurfaceInterface *surface) const;
 
    TabletPadV2Interface *pad() const;
 
private:
    friend class TabletSeatV2Interface;
    friend class TabletSeatV2InterfacePrivate;
    friend class TabletPadV2Interface;
    friend class TabletToolV2Interface;
    explicit TabletV2Interface(quint32 vendorId, quint32 productId, const QString &name, const QStringList &paths, QObject *parent);
    std::unique_ptr<TabletV2InterfacePrivate> d;
};
 
class KWIN_EXPORT TabletSeatV2Interface : public QObject
{
    Q_OBJECT
public:
    virtual ~TabletSeatV2Interface();
 
    TabletV2Interface *addTablet(quint32 vendorId, quint32 productId, const QString &sysname, const QString &name, const QStringList &paths);
    TabletPadV2Interface *addTabletPad(const QString &sysname,
                                       const QString &name,
                                       const QStringList &paths,
                                       quint32 buttons,
                                       quint32 rings,
                                       quint32 strips,
                                       quint32 modes,
                                       quint32 currentMode,
                                       TabletV2Interface *tablet);
    TabletToolV2Interface *
    addTool(TabletToolV2Interface::Type type, quint64 hardwareSerial, quint64 hardwareId, const QList<TabletToolV2Interface::Capability> &capabilities, const QString &deviceSysName);
 
    TabletToolV2Interface *toolByHardwareId(quint64 hardwareId) const;
    TabletToolV2Interface *toolByHardwareSerial(quint64 hardwareSerial, TabletToolV2Interface::Type type) const;
    TabletPadV2Interface *padByName(const QString &sysname) const;
 
    void removeDevice(const QString &sysname);
 
    bool isClientSupported(ClientConnection *client) const;
 
    bool hasImplicitGrab(quint32 serial) const;
 
private:
    friend class TabletManagerV2InterfacePrivate;
    explicit TabletSeatV2Interface(Display *display, QObject *parent);
    std::unique_ptr<TabletSeatV2InterfacePrivate> d;
};
 
}
 
Q_DECLARE_METATYPE(KWin::TabletSeatV2Interface *)