Add a new setExclusiveEdge call in the protocol

This can be used to disambiguate the exclusive edge when the anchors are on a corner (so there would be 2 candidates)

CMakeLists.txt

@@ -4,13 +4,13 @@
 cmake_minimum_required(VERSION 3.16)
 
 project(layershellqt)
-set(PROJECT_VERSION "6.0.5")
+set(PROJECT_VERSION "5.91.90")
 set(PROJECT_VERSION_MAJOR 6)
 
 set(CMAKE_C_STANDARD 99)
 
 set(QT_MIN_VERSION "6.6.0")
-set(KF6_MIN_VERSION "6.0.0")
+set(KF6_MIN_VERSION "5.240.0")
 set(KDE_COMPILERSETTINGS_LEVEL "5.82")
 
 set(CMAKE_CXX_STANDARD 20)

src/interfaces/window.cpp

@@ -27,7 +27,7 @@ public:
     QWindow *parentWindow;
     QString scope = QStringLiteral("window");
     Window::Anchors anchors = {Window::AnchorTop | Window::AnchorBottom | Window::AnchorLeft | Window::AnchorRight};
-    int32_t exclusionZone = 0;
+    QSize exclusionZone;
     Window::Anchor exclusiveEdge = Window::AnchorNone;
     Window::KeyboardInteractivity keyboardInteractivity = Window::KeyboardInteractivityOnDemand;
     Window::Layer layer = Window::LayerTop;
@@ -56,7 +56,7 @@ Window::Anchors Window::anchors() const
     return d->anchors;
 }
 
-void Window::setExclusiveZone(int32_t zone)
+void Window::setExclusiveZone(const QSize &zone)
 {
     if (d->exclusionZone != zone) {
         d->exclusionZone = zone;
@@ -64,26 +64,11 @@ void Window::setExclusiveZone(int32_t zone)
     }
 }
 
-int32_t Window::exclusionZone() const
+QSize Window::exclusionZone() const
 {
     return d->exclusionZone;
 }
 
-void Window::setExclusiveEdge(Window::Anchor edge)
-{
-    if (d->exclusiveEdge == edge) {
-        return;
-    }
-
-    d->exclusiveEdge = edge;
-    Q_EMIT exclusiveEdgeChanged();
-}
-
-Window::Anchor Window::exclusiveEdge() const
-{
-    return d->exclusiveEdge;
-}
-
 void Window::setMargins(const QMargins &margins)
 {
     if (d->margins != margins) {

src/interfaces/window.h

@@ -24,7 +24,7 @@ class LAYERSHELLQT_EXPORT Window : public QObject
     Q_PROPERTY(Anchors anchors READ anchors WRITE setAnchors NOTIFY anchorsChanged)
     Q_PROPERTY(QString scope READ scope WRITE setScope)
     Q_PROPERTY(QMargins margins READ margins WRITE setMargins NOTIFY marginsChanged)
-    Q_PROPERTY(qint32 exclusionZone READ exclusionZone WRITE setExclusiveZone NOTIFY exclusionZoneChanged)
+    Q_PROPERTY(QSize exclusionZone READ exclusionZone WRITE setExclusiveZone NOTIFY exclusionZoneChanged)
     Q_PROPERTY(Layer layer READ layer WRITE setLayer NOTIFY layerChanged)
     Q_PROPERTY(KeyboardInteractivity keyboardInteractivity READ keyboardInteractivity WRITE setKeyboardInteractivity NOTIFY keyboardInteractivityChanged)
     Q_PROPERTY(ScreenConfiguration screenConfiguration READ screenConfiguration WRITE setScreenConfiguration)
@@ -77,11 +77,8 @@ public:
     void setAnchors(Anchors anchor);
     Anchors anchors() const;
 
-    void setExclusiveZone(int32_t zone);
-    int32_t exclusionZone() const;
-
-    void setExclusiveEdge(Window::Anchor edge);
-    Window::Anchor exclusiveEdge() const;
+    void setExclusiveZone(const QSize &zone);
+    QSize exclusionZone() const;
 
     void setMargins(const QMargins &margins);
     QMargins margins() const;

src/qwaylandlayershellintegration.cpp

@@ -15,7 +15,7 @@
 namespace LayerShellQt
 {
 QWaylandLayerShellIntegration::QWaylandLayerShellIntegration()
-    : QWaylandShellIntegrationTemplate<QWaylandLayerShellIntegration>(5)
+    : QWaylandShellIntegrationTemplate<QWaylandLayerShellIntegration>(4)
     , m_xdgActivation(new QWaylandXdgActivationV1)
 {
 }

src/qwaylandlayersurface.cpp

@@ -23,7 +23,6 @@ QWaylandLayerSurface::QWaylandLayerSurface(QWaylandLayerShellIntegration *shell,
     , QtWayland::zwlr_layer_surface_v1()
     , m_shell(shell)
     , m_interface(Window::get(window->window()))
-    , m_window(window)
 {
     wl_output *output = nullptr;
     if (m_interface->screenConfiguration() == Window::ScreenFromQWindow) {
@@ -41,20 +40,14 @@ QWaylandLayerSurface::QWaylandLayerSurface(QWaylandLayerShellIntegration *shell,
         setLayer(m_interface->layer());
     });
 
-    setAnchor(m_interface->anchors());
+    set_anchor(m_interface->anchors());
     connect(m_interface, &Window::anchorsChanged, this, [this]() {
-        setAnchor(m_interface->anchors());
-        setDesiredSize(m_window->windowContentGeometry().size());
+        set_anchor(m_interface->anchors());
     });
-
     setExclusiveZone(m_interface->exclusionZone());
     connect(m_interface, &Window::exclusionZoneChanged, this, [this]() {
         setExclusiveZone(m_interface->exclusionZone());
     });
-    setExclusiveEdge(m_interface->exclusiveEdge());
-    connect(m_interface, &Window::exclusiveEdgeChanged, this, [this]() {
-        setExclusiveEdge(m_interface->exclusiveEdge());
-    });
 
     setMargins(m_interface->margins());
     connect(m_interface, &Window::marginsChanged, this, [this]() {
@@ -66,14 +59,21 @@ QWaylandLayerSurface::QWaylandLayerSurface(QWaylandLayerShellIntegration *shell,
         setKeyboardInteractivity(m_interface->keyboardInteractivity());
     });
 
-    setDesiredSize(window->windowContentGeometry().size());
+    QSize size = window->surfaceSize();
+    const Window::Anchors anchors = m_interface->anchors();
+    if ((anchors & Window::AnchorLeft) && (anchors & Window::AnchorRight)) {
+        size.setWidth(0);
+    }
+    if ((anchors & Window::AnchorTop) && (anchors & Window::AnchorBottom)) {
+        size.setHeight(0);
+    }
+    if (size.isValid() && size != QSize(0, 0)) {
+        set_size(size.width(), size.height());
+    }
 }
 
 QWaylandLayerSurface::~QWaylandLayerSurface()
 {
-    if (m_waitForSyncCallback) {
-        wl_callback_destroy(m_waitForSyncCallback);
-    }
     destroy();
 }
 
@@ -91,8 +91,8 @@ void QWaylandLayerSurface::zwlr_layer_surface_v1_configure(uint32_t serial, uint
 
     if (!m_configured) {
         m_configured = true;
-        applyConfigure();
-        sendExpose();
+        window()->resizeFromApplyConfigure(m_pendingSize);
+        window()->handleExpose(QRect(QPoint(), m_pendingSize));
     } else {
         // Later configures are resizes, so we have to queue them up for a time when we
         // are not painting to the window.
@@ -113,41 +113,18 @@ void QWaylandLayerSurface::attachPopup(QtWaylandClient::QWaylandShellSurface *po
 
 void QWaylandLayerSurface::applyConfigure()
 {
-    m_configuring = true;
     window()->resizeFromApplyConfigure(m_pendingSize);
-    m_configuring = false;
-}
-
-void QWaylandLayerSurface::setDesiredSize(const QSize &size)
-{
-    const bool horizontallyConstrained = m_interface->anchors().testFlags({Window::AnchorLeft, Window::AnchorRight});
-    const bool verticallyConstrained = m_interface->anchors().testFlags({Window::AnchorTop, Window::AnchorBottom});
-
-    QSize effectiveSize = size;
-    if (horizontallyConstrained) {
-        effectiveSize.setWidth(0);
-    }
-    if (verticallyConstrained) {
-        effectiveSize.setHeight(0);
-    }
-    set_size(effectiveSize.width(), effectiveSize.height());
 }
 
 void QWaylandLayerSurface::setAnchor(uint anchor)
 {
     set_anchor(anchor);
+    setWindowGeometry(window()->windowContentGeometry());
 }
 
-void QWaylandLayerSurface::setExclusiveZone(int32_t zone)
+void QWaylandLayerSurface::setExclusiveZone(const QSize &zone)
 {
-    set_exclusive_zone(zone);
-}
-
-void QWaylandLayerSurface::setExclusiveEdge(uint32_t edge)
-{
-    if (zwlr_layer_surface_v1_get_version(object()) >= ZWLR_LAYER_SURFACE_V1_SET_EXCLUSIVE_EDGE_SINCE_VERSION) {
-        set_exclusive_edge(edge);
-    }
+    set_exclusive_zone(zone.width(), zone.height());
 }
 
 void QWaylandLayerSurface::setMargins(const QMargins &margins)
@@ -168,12 +145,17 @@ void QWaylandLayerSurface::setLayer(uint32_t layer)
 
 void QWaylandLayerSurface::setWindowGeometry(const QRect &geometry)
 {
-    if (m_configuring) {
-        return;
-    }
+    const bool horizontallyConstrained = m_interface->anchors().testFlags({Window::AnchorLeft, Window::AnchorRight});
+    const bool verticallyConstrained = m_interface->anchors().testFlags({Window::AnchorTop, Window::AnchorBottom});
 
-    setDesiredSize(geometry.size());
-    requestWaylandSync();
+    QSize size = geometry.size();
+    if (horizontallyConstrained) {
+        size.setWidth(0);
+    }
+    if (verticallyConstrained) {
+        size.setHeight(0);
+    }
+    set_size(size.width(), size.height());
 }
 
 bool QWaylandLayerSurface::requestActivate()
@@ -222,43 +204,7 @@ void QWaylandLayerSurface::requestXdgActivationToken(quint32 serial)
                 Q_EMIT window()->xdgActivationTokenCreated(token);
             });
     connect(tokenProvider, &QWaylandXdgActivationTokenV1::done, tokenProvider, &QObject::deleteLater);
-}
 
-const wl_callback_listener QWaylandLayerSurface::syncCallbackListener = {
-    .done = [](void *data, struct wl_callback *callback, uint32_t time){
-        Q_UNUSED(time);
-        wl_callback_destroy(callback);
-        QWaylandLayerSurface *layerSurface = static_cast<QWaylandLayerSurface *>(data);
-        layerSurface->m_waitForSyncCallback = nullptr;
-        layerSurface->sendExpose();
-    }
-};
-
-void QWaylandLayerSurface::requestWaylandSync()
-{
-    if (m_waitForSyncCallback) {
-        return;
-    }
-
-    m_waitForSyncCallback = wl_display_sync(m_window->display()->wl_display());
-    wl_callback_add_listener(m_waitForSyncCallback, &syncCallbackListener, this);
-}
-
-void QWaylandLayerSurface::handleWaylandSyncDone()
-{
-    if (!window()->isExposed()) {
-        return;
-    }
-    sendExpose();
-}
-
-void QWaylandLayerSurface::sendExpose()
-{
-#if QT_VERSION < QT_VERSION_CHECK(6, 7, 0)
-    window()->handleExpose(QRect(QPoint(), m_pendingSize));
-#else
-    window()->sendRecursiveExposeEvent();
-#endif
 }
 
 }

src/qwaylandlayersurface_p.h

@@ -30,14 +30,12 @@ public:
 
     bool isExposed() const override
     {
-        return m_configured && !m_waitForSyncCallback;
+        return m_configured;
     }
     void attachPopup(QtWaylandClient::QWaylandShellSurface *popup) override;
 
-    void setDesiredSize(const QSize &size);
     void setAnchor(uint32_t anchor);
-    void setExclusiveZone(int32_t zone);
-    void setExclusiveEdge(uint32_t edge);
+    void setExclusiveZone(const QSize &zone);
     void setMargins(const QMargins &margins);
     void setKeyboardInteractivity(uint32_t interactivity);
     void setLayer(uint32_t layer);
@@ -50,23 +48,14 @@ public:
     void requestXdgActivationToken(quint32 serial) override;
 
 private:
-    void requestWaylandSync();
-    void handleWaylandSyncDone();
-    void sendExpose();
     void zwlr_layer_surface_v1_configure(uint32_t serial, uint32_t width, uint32_t height) override;
     void zwlr_layer_surface_v1_closed() override;
 
     QWaylandLayerShellIntegration *m_shell;
     LayerShellQt::Window *m_interface;
-    QtWaylandClient::QWaylandWindow *m_window;
     QSize m_pendingSize;
     QString m_activationToken;
-
     bool m_configured = false;
-    bool m_configuring = false;
-
-    static const wl_callback_listener syncCallbackListener;
-    struct wl_callback *m_waitForSyncCallback = nullptr;
 };
 
 }

src/wlr-layer-shell-unstable-v1.xml

@@ -184,7 +184,8 @@
 
         Exclusive zone is double-buffered, see wl_surface.commit.
       </description>
-      <arg name="zone" type="int"/>
+      <arg name="horizontal_zone" type="int"/>
+      <arg name="vertical_zone" type="int"/>
     </request>
 
     <request name="set_margin">
@@ -367,7 +368,6 @@
       <entry name="invalid_size" value="1" summary="size is invalid"/>
       <entry name="invalid_anchor" value="2" summary="anchor bitfield is invalid"/>
       <entry name="invalid_keyboard_interactivity" value="3" summary="keyboard interactivity is invalid"/>
-      <entry name="invalid_exclusive_edge" value="4" summary="exclusive edge is invalid given the surface anchors"/>
     </enum>
 
     <enum name="anchor" bitfield="true">
@@ -388,20 +388,5 @@
       <arg name="layer" type="uint" enum="zwlr_layer_shell_v1.layer" summary="layer to move this surface to"/>
     </request>
 
-    <!-- Version 5 additions -->
-
-    <request name="set_exclusive_edge" since="5">
-      <description summary="set the edge the exclusive zone will be applied to">
-        Requests an edge for the exclusive zone to apply. The exclusive
-        edge will be automatically deduced from anchor points when possible,
-        but when the surface is anchored to a corner, it will be necessary
-        to set it explicitly to disambiguate, as it is not possible to deduce
-        which one of the two corner edges should be used.
-
-        The edge must be one the surface is anchored to, otherwise the
-        invalid_exclusive_edge protocol error will be raised.
-      </description>
-      <arg name="edge" type="uint"/>
-    </request>
   </interface>
 </protocol>