Update version number for 5.91.0

GIT_SILENT

.gitlab-ci.yml

@@ -2,6 +2,8 @@
 # SPDX-License-Identifier: CC0-1.0
 
 include:
-  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/reuse-lint.yml
-  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/linux-qt6.yml
-  - https://invent.kde.org/sysadmin/ci-utilities/raw/master/gitlab-templates/freebsd-qt6.yml
+  - project: sysadmin/ci-utilities
+    file:
+      - /gitlab-templates/reuse-lint.yml
+      - /gitlab-templates/linux-qt6.yml
+      - /gitlab-templates/freebsd-qt6.yml

CMakeLists.txt

@@ -4,12 +4,12 @@
 cmake_minimum_required(VERSION 3.16)
 
 project(layershellqt)
-set(PROJECT_VERSION "5.27.80")
-set(PROJECT_VERSION_MAJOR 5)
+set(PROJECT_VERSION "5.91.0")
+set(PROJECT_VERSION_MAJOR 6)
 
 set(CMAKE_C_STANDARD 99)
 
-set(QT_MIN_VERSION "6.5.0")
+set(QT_MIN_VERSION "6.6.0")
 set(KF6_MIN_VERSION "5.240.0")
 set(KDE_COMPILERSETTINGS_LEVEL "5.82")
 
@@ -47,7 +47,7 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu90")
 ecm_setup_version(${PROJECT_VERSION} VARIABLE_PREFIX LAYERSHELLQT
                         VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/layershellqt_version.h"
                         PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/LayerShellQtConfigVersion.cmake"
-                        SOVERSION 5)
+                        SOVERSION ${PROJECT_VERSION_MAJOR})
 
 file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES *.cpp *.h)
 kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES})

src/CMakeLists.txt

@@ -6,10 +6,11 @@ remove_definitions(-DQT_NO_SIGNALS_SLOTS_KEYWORDS)
 add_library(LayerShellQtInterface)
 qt6_generate_wayland_protocol_client_sources(LayerShellQtInterface FILES
     ${WaylandProtocols_DATADIR}/stable/xdg-shell/xdg-shell.xml
+    ${WaylandProtocols_DATADIR}/staging/xdg-activation/xdg-activation-v1.xml
     ${CMAKE_CURRENT_SOURCE_DIR}/wlr-layer-shell-unstable-v1.xml
 )
 
-ecm_qt_declare_logging_category(LAYER_SHELL_SOURCES
+ecm_qt_declare_logging_category(LayerShellQtInterface
     HEADER
         layershellqt_logging.h
     IDENTIFIER
@@ -18,7 +19,14 @@ ecm_qt_declare_logging_category(LAYER_SHELL_SOURCES
         layershellqt
 )
 
-target_sources(LayerShellQtInterface PRIVATE qwaylandlayersurface.cpp interfaces/window.cpp interfaces/shell.cpp qwaylandlayershellintegration.cpp ${LAYER_SHELL_SOURCES})
+target_sources(LayerShellQtInterface PRIVATE
+    qwaylandxdgactivationv1.cpp
+    qwaylandlayersurface.cpp
+    qwaylandlayershellintegration.cpp
+    interfaces/window.cpp
+    interfaces/shell.cpp
+)
+
 target_link_libraries(LayerShellQtInterface PUBLIC Qt::Gui)
 target_link_libraries(LayerShellQtInterface PRIVATE Qt::WaylandClientPrivate Wayland::Client PkgConfig::XKBCOMMON)
 if (TARGET Qt::XkbCommonSupportPrivate)

src/interfaces/window.cpp

@@ -6,9 +6,6 @@
 
 #include "window.h"
 #include "../qwaylandlayershellintegration_p.h"
-#if QT_VERSION < QT_VERSION_CHECK(6, 6, 0)
-#include "../qwaylandlayersurface_p.h"
-#endif
 
 #include <layershellqt_logging.h>
 
@@ -31,7 +28,7 @@ public:
     QString scope = QStringLiteral("window");
     Window::Anchors anchors = {Window::AnchorTop | Window::AnchorBottom | Window::AnchorLeft | Window::AnchorRight};
     int32_t exclusionZone = 0;
-    Window::KeyboardInteractivity keyboardInteractivity = Window::KeyboardInteractivityNone;
+    Window::KeyboardInteractivity keyboardInteractivity = Window::KeyboardInteractivityOnDemand;
     Window::Layer layer = Window::LayerTop;
     QMargins margins;
     Window::ScreenConfiguration screenConfiguration = Window::ScreenFromQWindow;
@@ -141,21 +138,6 @@ void Window::setCloseOnDismissed(bool close)
     d->closeOnDismissed = close;
 }
 
-#if QT_VERSION < QT_VERSION_CHECK(6, 6, 0)
-void Window::attachPopup(QWindow *window, xdg_popup *popup)
-{
-    auto waylandWindow = dynamic_cast<QtWaylandClient::QWaylandWindow *>(window->handle());
-    if (!waylandWindow) {
-        return;
-    }
-
-    auto shellSurface = dynamic_cast<QWaylandLayerSurface *>(waylandWindow->shellSurface());
-    if (shellSurface) {
-        shellSurface->get_popup(popup);
-    }
-}
-#endif
-
 Window::Window(QWindow *window)
     : QObject(window)
     , d(new WindowPrivate(window))

src/interfaces/window.h

@@ -14,10 +14,6 @@
 
 #include "layershellqt_export.h"
 
-#if QT_VERSION < QT_VERSION_CHECK(6, 6, 0)
-struct xdg_popup;
-#endif
-
 namespace LayerShellQt
 {
 class WindowPrivate;
@@ -120,10 +116,6 @@ public:
      */
     static Window *get(QWindow *window);
 
-#if QT_VERSION < QT_VERSION_CHECK(6, 6, 0)
-    static void attachPopup(QWindow *window, xdg_popup *popup);
-#endif
-
     static Window *qmlAttachedProperties(QObject *object);
 
 Q_SIGNALS:

src/qwaylandlayershellintegration.cpp

@@ -7,6 +7,7 @@
 
 #include "qwaylandlayershellintegration_p.h"
 #include "qwaylandlayersurface_p.h"
+#include "qwaylandxdgactivationv1_p.h"
 
 #include <QtWaylandClient/private/qwaylanddisplay_p.h>
 #include <QtWaylandClient/private/qwaylandwindow_p.h>
@@ -15,6 +16,7 @@ namespace LayerShellQt
 {
 QWaylandLayerShellIntegration::QWaylandLayerShellIntegration()
     : QWaylandShellIntegrationTemplate<QWaylandLayerShellIntegration>(4)
+    , m_xdgActivation(new QWaylandXdgActivationV1)
 {
 }
 

src/qwaylandlayershellintegration_p.h

@@ -13,6 +13,8 @@
 #include <QtWaylandClient/private/qwaylandshellintegration_p.h>
 #include <qwayland-wlr-layer-shell-unstable-v1.h>
 
+class QWaylandXdgActivationV1;
+
 namespace LayerShellQt
 {
 
@@ -22,7 +24,10 @@ public:
     QWaylandLayerShellIntegration();
     ~QWaylandLayerShellIntegration() override;
 
+    QWaylandXdgActivationV1 *activation() const { return m_xdgActivation.data(); }
     QtWaylandClient::QWaylandShellSurface *createShellSurface(QtWaylandClient::QWaylandWindow *window) override;
+private:
+    QScopedPointer<QWaylandXdgActivationV1> m_xdgActivation;
 };
 
 }

src/qwaylandlayersurface.cpp

@@ -8,16 +8,20 @@
 #include "interfaces/window.h"
 #include "layershellqt_logging.h"
 #include "qwaylandlayersurface_p.h"
+#include "qwaylandxdgactivationv1_p.h"
 
 #include <QtWaylandClient/private/qwaylandscreen_p.h>
 #include <QtWaylandClient/private/qwaylandsurface_p.h>
 #include <QtWaylandClient/private/qwaylandwindow_p.h>
 
+#include <QGuiApplication>
+
 namespace LayerShellQt
 {
-QWaylandLayerSurface::QWaylandLayerSurface(QtWayland::zwlr_layer_shell_v1 *shell, QtWaylandClient::QWaylandWindow *window)
+QWaylandLayerSurface::QWaylandLayerSurface(QWaylandLayerShellIntegration *shell, QtWaylandClient::QWaylandWindow *window)
     : QtWaylandClient::QWaylandShellSurface(window)
     , QtWayland::zwlr_layer_surface_v1()
+    , m_shell(shell)
     , m_interface(Window::get(window->window()))
 {
     wl_output *output = nullptr;
@@ -96,7 +100,6 @@ void QWaylandLayerSurface::zwlr_layer_surface_v1_configure(uint32_t serial, uint
     }
 }
 
-#if QT_VERSION >= QT_VERSION_CHECK(6, 6, 0)
 void QWaylandLayerSurface::attachPopup(QtWaylandClient::QWaylandShellSurface *popup)
 {
     std::any anyRole = popup->surfaceRole();
@@ -107,7 +110,6 @@ void QWaylandLayerSurface::attachPopup(QtWaylandClient::QWaylandShellSurface *po
         qCWarning(LAYERSHELLQT) << "Cannot attach popup of unknown type";
     }
 }
-#endif
 
 void QWaylandLayerSurface::applyConfigure()
 {
@@ -136,7 +138,6 @@ void QWaylandLayerSurface::setKeyboardInteractivity(uint32_t interactivity)
 
 void QWaylandLayerSurface::setLayer(uint32_t layer)
 {
-    qDebug() << "wtfffffff" << layer << zwlr_layer_surface_v1_get_version(object()) << ZWLR_LAYER_SURFACE_V1_SET_LAYER_SINCE_VERSION;
     if (zwlr_layer_surface_v1_get_version(object()) >= ZWLR_LAYER_SURFACE_V1_SET_LAYER_SINCE_VERSION)
         set_layer(layer);
 }
@@ -156,4 +157,54 @@ void QWaylandLayerSurface::setWindowGeometry(const QRect &geometry)
     set_size(size.width(), size.height());
 }
 
+bool QWaylandLayerSurface::requestActivate()
+{
+    QWaylandXdgActivationV1 *activation = m_shell->activation();
+    if (!activation->isActive()) {
+        return false;
+    }
+    if (!m_activationToken.isEmpty()) {
+        activation->activate(m_activationToken, window()->wlSurface());
+        m_activationToken = {};
+        return true;
+    } else {
+        const auto focusWindow = QGuiApplication::focusWindow();
+        const auto wlWindow = focusWindow ? static_cast<QtWaylandClient::QWaylandWindow*>(focusWindow->handle()) : window();
+        if (const auto seat = wlWindow->display()->lastInputDevice()) {
+            const auto tokenProvider = activation->requestXdgActivationToken(
+                wlWindow->display(), wlWindow->wlSurface(), 0, QString());
+            connect(tokenProvider, &QWaylandXdgActivationTokenV1::done, this,
+                    [this](const QString &token) {
+                        m_shell->activation()->activate(token, window()->wlSurface());
+                    });
+            connect(tokenProvider, &QWaylandXdgActivationTokenV1::done, tokenProvider, &QObject::deleteLater);
+            return true;
+        }
+    }
+    return false;
 }
+
+void QWaylandLayerSurface::setXdgActivationToken(const QString &token)
+{
+    m_activationToken = token;
+}
+
+void QWaylandLayerSurface::requestXdgActivationToken(quint32 serial)
+{
+    QWaylandXdgActivationV1 *activation = m_shell->activation();
+    if (!activation->isActive()) {
+        return;
+    }
+    auto tokenProvider = activation->requestXdgActivationToken(
+        window()->display(), window()->wlSurface(), serial, QString());
+
+    connect(tokenProvider, &QWaylandXdgActivationTokenV1::done, this,
+            [this](const QString &token) {
+                Q_EMIT window()->xdgActivationTokenCreated(token);
+            });
+    connect(tokenProvider, &QWaylandXdgActivationTokenV1::done, tokenProvider, &QObject::deleteLater);
+
+}
+
+}
+

src/qwaylandlayersurface_p.h

@@ -10,6 +10,8 @@
 
 #include <wayland-client.h>
 
+#include "qwaylandlayershellintegration_p.h"
+
 #include "layershellqt_export.h"
 #include <QtWaylandClient/private/qwaylandshellsurface_p.h>
 #include <qwayland-wlr-layer-shell-unstable-v1.h>
@@ -23,16 +25,14 @@ class LAYERSHELLQT_EXPORT QWaylandLayerSurface : public QtWaylandClient::QWaylan
 {
     Q_OBJECT
 public:
-    QWaylandLayerSurface(QtWayland::zwlr_layer_shell_v1 *shell, QtWaylandClient::QWaylandWindow *window);
+    QWaylandLayerSurface(QWaylandLayerShellIntegration *shell, QtWaylandClient::QWaylandWindow *window);
     ~QWaylandLayerSurface() override;
 
     bool isExposed() const override
     {
         return m_configured;
     }
-#if QT_VERSION >= QT_VERSION_CHECK(6, 6, 0)
     void attachPopup(QtWaylandClient::QWaylandShellSurface *popup) override;
-#endif
 
     void setAnchor(uint32_t anchor);
     void setExclusiveZone(int32_t zone);
@@ -43,12 +43,18 @@ public:
     void applyConfigure() override;
     void setWindowGeometry(const QRect &geometry) override;
 
+    bool requestActivate() override;
+    void setXdgActivationToken(const QString &token) override;
+    void requestXdgActivationToken(quint32 serial) override;
+
 private:
     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;
     QSize m_pendingSize;
+    QString m_activationToken;
     bool m_configured = false;
 };
 

src/qwaylandxdgactivationv1.cpp

@@ -0,0 +1,44 @@
+/** Copyright (C) 2020 Aleix Pol Gonzalez <aleixpol@kde.org>
+ *   SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+#include "qwaylandxdgactivationv1_p.h"
+#include <QtWaylandClient/private/qwaylanddisplay_p.h>
+#include <QtWaylandClient/private/qwaylandinputdevice_p.h>
+
+QWaylandXdgActivationV1::QWaylandXdgActivationV1()
+    : QWaylandClientExtensionTemplate<QWaylandXdgActivationV1>(1)
+{
+    initialize();
+}
+
+QWaylandXdgActivationV1::~QWaylandXdgActivationV1()
+{
+    if (isActive()) {
+        destroy();
+    }
+}
+
+QWaylandXdgActivationTokenV1 *QWaylandXdgActivationV1::requestXdgActivationToken(QtWaylandClient::QWaylandDisplay *display,
+                                                                                 struct ::wl_surface *surface,
+                                                                                 std::optional<uint32_t> serial,
+                                                                                 const QString &app_id)
+{
+    auto wl = get_activation_token();
+    auto provider = new QWaylandXdgActivationTokenV1;
+    provider->init(wl);
+
+    if (surface) {
+        provider->set_surface(surface);
+    }
+    if (!app_id.isEmpty()) {
+        provider->set_app_id(app_id);
+    }
+    if (serial && display->lastInputDevice()) {
+        provider->set_serial(*serial, display->lastInputDevice()->wl_seat());
+    }
+    provider->commit();
+    return provider;
+}
+
+#include "moc_qwaylandxdgactivationv1_p.cpp"

src/qwaylandxdgactivationv1_p.h

@@ -0,0 +1,48 @@
+/** Copyright (C) 2020 Aleix Pol Gonzalez <aleixpol@kde.org>
+ *  SPDX-License-Identifier: LGPL-3.0-or-later
+ */
+
+#ifndef QWAYLANDXDGACTIVATIONV1_P_H
+#define QWAYLANDXDGACTIVATIONV1_P_H
+
+#include "qwayland-xdg-activation-v1.h"
+#include <QObject>
+
+#include <QtWaylandClient/QWaylandClientExtension>
+
+namespace QtWaylandClient
+{
+class QWaylandDisplay;
+class QWaylandSurface;
+}
+
+class QWaylandXdgActivationTokenV1 : public QObject, public QtWayland::xdg_activation_token_v1
+{
+    Q_OBJECT
+public:
+    ~QWaylandXdgActivationTokenV1() override
+    {
+        destroy();
+    }
+
+protected:
+    void xdg_activation_token_v1_done(const QString &token) override
+    {
+        Q_EMIT done(token);
+    }
+
+Q_SIGNALS:
+    void done(const QString &token);
+};
+
+class QWaylandXdgActivationV1 : public QWaylandClientExtensionTemplate<QWaylandXdgActivationV1>, public QtWayland::xdg_activation_v1
+{
+public:
+    QWaylandXdgActivationV1();
+    ~QWaylandXdgActivationV1() override;
+
+    QWaylandXdgActivationTokenV1 *
+    requestXdgActivationToken(QtWaylandClient::QWaylandDisplay *display, struct ::wl_surface *surface, std::optional<uint32_t> serial, const QString &app_id);
+};
+
+#endif // QWAYLANDXDGACTIVATIONV1_P_H

tests/main.cpp

@@ -32,7 +32,7 @@ template<typename T>
 T stringToEnum(QMetaEnum metaEnum, const QString &str)
 {
     T ret = {};
-    const auto splitted = str.split(QLatin1Char('|'));
+    const auto splitted = str.split(QLatin1Char('|'), Qt::SkipEmptyParts);
     for (const auto &value : splitted) {
         ret |= T(metaEnum.keyToValue(qPrintable(value)));
     }