xdgshell.h

Go to the documentation of this file.

/*
    SPDX-FileCopyrightText: 2020 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 <QObject>
#include <QSharedDataPointer>
 
#include <chrono>
#include <memory>
 
struct wl_resource;
 
namespace KWin
{
class Display;
class OutputInterface;
class SeatInterface;
class SurfaceInterface;
class SurfaceRole;
class XdgShellInterfacePrivate;
class XdgSurfaceInterfacePrivate;
class XdgToplevelInterfacePrivate;
class XdgPopupInterfacePrivate;
class XdgPositionerData;
class XdgToplevelInterface;
class XdgPopupInterface;
class XdgSurfaceInterface;
 
class KWIN_EXPORT XdgShellInterface : public QObject
{
    Q_OBJECT
 
public:
    XdgShellInterface(Display *display, QObject *parent = nullptr);
    ~XdgShellInterface() override;
 
    Display *display() const;
 
    quint32 ping(XdgSurfaceInterface *surface);
 
    std::chrono::milliseconds pingTimeoutInterval() const;
 
    void setPingTimeoutInterval(std::chrono::milliseconds pingTimeout);
 
Q_SIGNALS:
    void toplevelCreated(XdgToplevelInterface *toplevel);
 
    void popupCreated(XdgPopupInterface *popup);
 
    void pongReceived(quint32 serial);
 
    void pingTimeout(quint32 serial);
 
    void pingDelayed(quint32 serial);
 
private:
    std::unique_ptr<XdgShellInterfacePrivate> d;
    friend class XdgShellInterfacePrivate;
};
 
class KWIN_EXPORT XdgSurfaceInterface : public QObject
{
    Q_OBJECT
 
public:
    XdgSurfaceInterface(XdgShellInterface *shell, SurfaceInterface *surface, ::wl_resource *resource);
    ~XdgSurfaceInterface() override;
 
    XdgToplevelInterface *toplevel() const;
 
    XdgPopupInterface *popup() const;
 
    XdgShellInterface *shell() const;
 
    SurfaceInterface *surface() const;
 
    bool isConfigured() const;
 
    QRect windowGeometry() const;
 
    static XdgSurfaceInterface *get(::wl_resource *resource);
 
Q_SIGNALS:
    void aboutToBeDestroyed();
 
    void configureAcknowledged(quint32 serial);
 
    void windowGeometryChanged(const QRect &rect);
 
    void resetOccurred();
 
private:
    std::unique_ptr<XdgSurfaceInterfacePrivate> d;
    friend class XdgSurfaceInterfacePrivate;
};
 
class KWIN_EXPORT XdgToplevelInterface : public QObject
{
    Q_OBJECT
 
public:
    enum State {
        MaximizedHorizontal = 0x1,
        MaximizedVertical = 0x2,
        FullScreen = 0x4,
        Resizing = 0x8,
        Activated = 0x10,
        TiledLeft = 0x20,
        TiledTop = 0x40,
        TiledRight = 0x80,
        TiledBottom = 0x100,
        Suspended = 0x200,
        Maximized = MaximizedHorizontal | MaximizedVertical,
    };
    Q_DECLARE_FLAGS(States, State)
 
    enum class ResizeAnchor {
        None = 0,
        Top = 1,
        Bottom = 2,
        Left = 4,
        TopLeft = 5,
        BottomLeft = 6,
        Right = 8,
        TopRight = 9,
        BottomRight = 10,
    };
    Q_ENUM(ResizeAnchor)
 
    enum class Capability {
        WindowMenu = 0x1,
        Maximize = 0x2,
        FullScreen = 0x4,
        Minimize = 0x8,
    };
    Q_DECLARE_FLAGS(Capabilities, Capability)
 
    
    XdgToplevelInterface(XdgSurfaceInterface *surface, ::wl_resource *resource);
    ~XdgToplevelInterface() override;
 
    static SurfaceRole *role();
 
    XdgShellInterface *shell() const;
 
    XdgSurfaceInterface *xdgSurface() const;
 
    SurfaceInterface *surface() const;
 
    XdgToplevelInterface *parentXdgToplevel() const;
 
    bool isConfigured() const;
 
    QString windowTitle() const;
 
    QString windowClass() const;
 
    QSize minimumSize() const;
 
    QSize maximumSize() const;
 
    quint32 sendConfigure(const QSize &size, const States &states);
 
    void sendClose();
 
    void sendConfigureBounds(const QSize &size);
 
    void sendWmCapabilities(Capabilities capabilities);
 
    static XdgToplevelInterface *get(::wl_resource *resource);
 
Q_SIGNALS:
    void aboutToBeDestroyed();
 
    void initializeRequested();
 
    void resetOccurred();
 
    void windowTitleChanged(const QString &windowTitle);
 
    void windowClassChanged(const QString &windowClass);
 
    void windowMenuRequested(KWin::SeatInterface *seat, const QPoint &pos, quint32 serial);
 
    void minimumSizeChanged(const QSize &size);
 
    void maximumSizeChanged(const QSize &size);
 
    void moveRequested(KWin::SeatInterface *seat, quint32 serial);
 
    void resizeRequested(KWin::SeatInterface *seat, KWin::XdgToplevelInterface::ResizeAnchor anchor, quint32 serial);
 
    void maximizeRequested();
 
    void unmaximizeRequested();
 
    void fullscreenRequested(KWin::OutputInterface *output);
 
    void unfullscreenRequested();
 
    void minimizeRequested();
 
    void parentXdgToplevelChanged();
 
private:
    std::unique_ptr<XdgToplevelInterfacePrivate> d;
    friend class XdgToplevelInterfacePrivate;
};
 
class KWIN_EXPORT XdgPositioner
{
public:
    XdgPositioner();
    XdgPositioner(const XdgPositioner &other);
    ~XdgPositioner();
 
    XdgPositioner &operator=(const XdgPositioner &other);
 
    bool isComplete() const;
 
    QSize size() const;
 
    bool isReactive() const;
 
    QRectF placement(const QRectF &bounds) const;
 
    static XdgPositioner get(::wl_resource *resource);
 
private:
    XdgPositioner(const QSharedDataPointer<XdgPositionerData> &data);
    QSharedDataPointer<XdgPositionerData> d;
};
 
class KWIN_EXPORT XdgPopupInterface : public QObject
{
    Q_OBJECT
 
public:
    XdgPopupInterface(XdgSurfaceInterface *surface, SurfaceInterface *parentSurface, const XdgPositioner &positioner, ::wl_resource *resource);
    ~XdgPopupInterface() override;
 
    static SurfaceRole *role();
 
    XdgShellInterface *shell() const;
 
    SurfaceInterface *parentSurface() const;
 
    XdgSurfaceInterface *xdgSurface() const;
 
    SurfaceInterface *surface() const;
 
    XdgPositioner positioner() const;
 
    bool isConfigured() const;
 
    quint32 sendConfigure(const QRect &rect);
 
    void sendPopupDone();
 
    void sendRepositioned(quint32 token);
 
    static XdgPopupInterface *get(::wl_resource *resource);
 
Q_SIGNALS:
    void aboutToBeDestroyed();
 
    void initializeRequested();
    void grabRequested(SeatInterface *seat, quint32 serial);
    void repositionRequested(quint32 token);
 
private:
    std::unique_ptr<XdgPopupInterfacePrivate> d;
    friend class XdgPopupInterfacePrivate;
};
 
} // namespace KWin
 
Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::XdgToplevelInterface::States)
Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::XdgToplevelInterface::Capabilities)
Q_DECLARE_METATYPE(KWin::XdgToplevelInterface::State)
Q_DECLARE_METATYPE(KWin::XdgToplevelInterface::States)