xdgshell.h

/*
    SPDX-FileCopyrightText: 2016 Martin Gräßlin <[email protected]>

    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/
#ifndef KWAYLAND_CLIENT_XDG_SHELL_H
#define KWAYLAND_CLIENT_XDG_SHELL_H

#include <QObject>
#include <QSize>
#include <QRect>
#include <KWayland/Client/kwaylandclient_export.h>

//This is a mix of structs for both xdgshell unstable v5 AND xdg wm base stable
struct xdg_wm_base;
struct xdg_shell;
struct xdg_surface;
struct xdg_popup;
struct xdg_toplevel;

struct zxdg_shell_v6;
struct zxdg_toplevel_v6;
struct zxdg_surface_v6;
struct zxdg_popup_v6;
struct zxdg_position_v6;

namespace KWayland
{
namespace Client
{

class EventQueue;
class Output;
class Surface;
class Seat;
class XdgShellPopup;
class XdgShellSurface;

class KWAYLANDCLIENT_EXPORT XdgPositioner
{
public:
    /*
    * Flags describing how a popup should be reposition if constrained
    */
    enum class Constraint {
        /*
        * Slide the popup on the X axis until there is room
        */
        SlideX = 1 << 0,
        /*
        * Slide the popup on the Y axis until there is room
        */
        SlideY = 1 << 1,
        /*
        * Invert the anchor and gravity on the X axis
        */
        FlipX = 1 << 2,
        /*
        * Invert the anchor and gravity on the Y axis
        */
        FlipY = 1 << 3,
        /*
        * Resize the popup in the X axis
        */
        ResizeX = 1 << 4,
        /*
        * Resize the popup in the Y axis
        */
        ResizeY = 1 << 5
    };

    Q_DECLARE_FLAGS(Constraints, Constraint)

    XdgPositioner(const QSize &initialSize = QSize(), const QRect &anchor = QRect());
    XdgPositioner(const XdgPositioner &other);
    ~XdgPositioner();

    //KF6 TODO use a better data type (enum of 8 options) rather than flags which allow invalid values
    Qt::Edges anchorEdge() const;
    void setAnchorEdge(Qt::Edges edge);

    //KF6 TODO use a better data type (enum of 8 options) rather than flags which allow invalid values
    Qt::Edges gravity() const;
    void setGravity(Qt::Edges edge);

    QRect anchorRect() const;
    void setAnchorRect(const QRect &anchor);

    QSize initialSize() const;
    void setInitialSize(const QSize &size);

    Constraints constraints() const;
    void setConstraints(Constraints constraints);

    QPoint anchorOffset() const;
    void setAnchorOffset(const QPoint &offset);

private:
    class Private;
    QScopedPointer<Private> d;
};

Q_DECLARE_OPERATORS_FOR_FLAGS(XdgPositioner::Constraints)


class KWAYLANDCLIENT_EXPORT XdgShell : public QObject
{
    Q_OBJECT
public:
    virtual ~XdgShell();

    void setup(xdg_shell *xdgshellv5);

    void setup(zxdg_shell_v6 *xdgshellv6);

    void setup(xdg_wm_base *xdg_wm_base);
    bool isValid() const;
    void release();
    void destroy();

    void setEventQueue(EventQueue *queue);
    EventQueue *eventQueue();

    XdgShellSurface *createSurface(Surface *surface, QObject *parent = nullptr);

    XdgShellPopup *createPopup(Surface *surface, Surface *parentSurface, Seat *seat, quint32 serial, const QPoint &parentPos, QObject *parent = nullptr);

    XdgShellPopup *createPopup(Surface *surface, XdgShellSurface *parentSurface, const XdgPositioner &positioner, QObject *parent = nullptr);

    XdgShellPopup *createPopup(Surface *surface, XdgShellPopup *parentSurface, const XdgPositioner &positioner, QObject *parent = nullptr);

    operator xdg_wm_base*();
    operator xdg_wm_base*() const;
    operator xdg_shell*();
    operator xdg_shell*() const;
    operator zxdg_shell_v6*();
    operator zxdg_shell_v6*() const;

Q_SIGNALS:
    void removed();

protected:
    class Private;
    explicit XdgShell(Private *p, QObject *parent = nullptr);

private:
    QScopedPointer<Private> d;
};

class KWAYLANDCLIENT_EXPORT XdgShellSurface : public QObject
{
    Q_OBJECT
public:
    virtual ~XdgShellSurface();
    enum class State {
        Maximized  = 1 << 0,
        Fullscreen = 1 << 1,
        Resizing   = 1 << 2,
        Activated  = 1 << 3
    };
    Q_DECLARE_FLAGS(States, State)

    
    void setup(xdg_surface *xdgsurfacev5);

    void setup(zxdg_surface_v6 *xdgsurfacev6, zxdg_toplevel_v6 *toplevel);

    void setup(xdg_surface *xdgsurface, xdg_toplevel *toplevel);

    bool isValid() const;
    void release();
    void destroy();
    void setEventQueue(EventQueue *queue);
    EventQueue *eventQueue();

    QSize size() const;

    void setSize(const QSize &size);

    void setTransientFor(XdgShellSurface *parent);

    void setTitle(const QString &title);

    void setAppId(const QByteArray &appId);

    void requestShowWindowMenu(Seat *seat, quint32 serial, const QPoint &pos);

    void requestMove(Seat *seat, quint32 serial);

    void requestResize(Seat *seat, quint32 serial, Qt::Edges edges);

    void ackConfigure(quint32 serial);

    void setMaximized(bool set);

    void setFullscreen(bool set, Output *output = nullptr);

    void requestMinimize();

    void setMaxSize(const QSize &size);

    void setMinSize(const QSize &size);

    void setWindowGeometry(const QRect &windowGeometry);

    operator xdg_surface*();
    operator xdg_surface*() const;
    operator xdg_toplevel*();
    operator xdg_toplevel*() const;
    operator zxdg_surface_v6*();
    operator zxdg_surface_v6*() const;
    operator zxdg_toplevel_v6*();
    operator zxdg_toplevel_v6*() const;

Q_SIGNALS:
    void closeRequested();
    void configureRequested(const QSize &size, KWayland::Client::XdgShellSurface::States states, quint32 serial);

    void sizeChanged(const QSize &);

protected:
    class Private;
    explicit XdgShellSurface(Private *p, QObject *parent = nullptr);

private:
    QScopedPointer<Private> d;
};

Q_DECLARE_OPERATORS_FOR_FLAGS(XdgShellSurface::States)


class KWAYLANDCLIENT_EXPORT XdgShellPopup : public QObject
{
    Q_OBJECT
public:
    virtual ~XdgShellPopup();

    KWAYLANDCLIENT_DEPRECATED_VERSION(5, 49, "Use XDGShell version >5")
    void setup(xdg_popup *xdgpopupv5);

    void setup(zxdg_surface_v6 *xdgsurfacev6, zxdg_popup_v6 *xdgpopup6);

    void setup(xdg_surface *xdgsurface, xdg_popup *xdgpopup);

    bool isValid() const;
    void release();
    void destroy();
    void setEventQueue(EventQueue *queue);
    EventQueue *eventQueue();

    void requestGrab(Seat *seat, quint32 serial);

    void ackConfigure(quint32 serial);

    void setWindowGeometry(const QRect &windowGeometry);

    operator xdg_surface*();
    operator xdg_surface*() const;
    operator xdg_popup*();
    operator xdg_popup*() const;
    operator zxdg_surface_v6*();
    operator zxdg_surface_v6*() const;
    operator zxdg_popup_v6*();
    operator zxdg_popup_v6*() const;


Q_SIGNALS:
    void popupDone();

    void configureRequested(const QRect &relativePosition, quint32 serial);


protected:
    class Private;
    explicit XdgShellPopup(Private *p, QObject *parent = nullptr);

private:
    QScopedPointer<Private> d;
};

}
}

Q_DECLARE_METATYPE(KWayland::Client::XdgPositioner)
Q_DECLARE_METATYPE(KWayland::Client::XdgShellSurface::State)
Q_DECLARE_METATYPE(KWayland::Client::XdgShellSurface::States)
Q_DECLARE_METATYPE(KWayland::Client::XdgPositioner::Constraint)
Q_DECLARE_METATYPE(KWayland::Client::XdgPositioner::Constraints)


#endif