winft · romangg · Feb 24, 2024 · Dec 2, 2023 · Dec 5, 2023 · Dec 4, 2023
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -6,9 +6,9 @@ cmake_minimum_required(VERSION 3.23 FATAL_ERROR)
 
 project("The Compositor Modules" VERSION 0.1.0)
 
-set(QT_MIN_VERSION "6.4.0")
-set(KF6_MIN_VERSION "5.240.0")
-set(KDE_PLASMA_VERSION "5.27")
+set(QT_MIN_VERSION "6.6.0")
+set(KF6_MIN_VERSION "6.0.0")
+set(KDE_PLASMA_VERSION "6.0.0")
 
 set(CMAKE_C_STANDARD 99)
 set(CMAKE_CXX_STANDARD 20)
@@ -138,7 +138,7 @@ set_package_properties(KScreenLocker PROPERTIES
     PURPOSE "For screenlocker integration in the Wayland session"
 )
 
-find_package(Breeze 5.9.0 CONFIG)
+find_package(Breeze 6.0.0 CONFIG)
 set_package_properties(Breeze PROPERTIES
     TYPE OPTIONAL
     PURPOSE "For setting the default window decoration plugin"

diff --git a/autotests/integration/global_shortcuts.cpp b/autotests/integration/global_shortcuts.cpp
@@ -257,6 +257,52 @@ TEST_CASE("global shortcuts", "[input]")
         QTRY_COMPARE(triggeredSpy.count(), 0);
     }
 
+    SECTION("keypad")
+    {
+        auto zero_action = std::make_unique<QAction>();
+        zero_action->setProperty("componentName", QStringLiteral("kwin"));
+        zero_action->setObjectName(QStringLiteral("globalshortcuts-test-keypad-0"));
+
+        QSignalSpy zero_action_spy(zero_action.get(), &QAction::triggered);
+        KGlobalAccel::self()->setShortcut(
+            zero_action.get(),
+            QList<QKeySequence>{Qt::MetaModifier | Qt::KeypadModifier | Qt::Key_0},
+            KGlobalAccel::NoAutoloading);
+
+        auto insert_action = std::make_unique<QAction>();
+        insert_action->setProperty("componentName", QStringLiteral("kwin"));
+        insert_action->setObjectName(QStringLiteral("globalshortcuts-test-keypad-ins"));
+
+        QSignalSpy insert_action_spy(insert_action.get(), &QAction::triggered);
+        KGlobalAccel::self()->setShortcut(
+            insert_action.get(),
+            QList<QKeySequence>{Qt::MetaModifier | Qt::KeypadModifier | Qt::Key_Insert},
+            KGlobalAccel::NoAutoloading);
+
+        // Turn on numlock
+        quint32 timestamp = 0;
+        keyboard_key_pressed(KEY_NUMLOCK, timestamp++);
+        keyboard_key_released(KEY_NUMLOCK, timestamp++);
+
+        keyboard_key_pressed(KEY_LEFTMETA, timestamp++);
+        keyboard_key_pressed(KEY_KP0, timestamp++);
+        keyboard_key_released(KEY_KP0, timestamp++);
+        keyboard_key_released(KEY_LEFTMETA, timestamp++);
+        TRY_REQUIRE(zero_action_spy.size() == 1);
+        REQUIRE(insert_action_spy.empty());
+
+        // Turn off numlock
+        keyboard_key_pressed(KEY_NUMLOCK, timestamp++);
+        keyboard_key_released(KEY_NUMLOCK, timestamp++);
+
+        keyboard_key_pressed(KEY_LEFTMETA, timestamp++);
+        keyboard_key_pressed(KEY_KP0, timestamp++);
+        keyboard_key_released(KEY_KP0, timestamp++);
+        keyboard_key_released(KEY_LEFTMETA, timestamp++);
+        TRY_REQUIRE(insert_action_spy.size() == 1);
+        REQUIRE(zero_action_spy.size() == 1);
+    }
+
     SECTION("x11 window shortcut")
     {
         auto c = xcb_connection_create();

diff --git a/autotests/integration/lib/setup.cpp b/autotests/integration/lib/setup.cpp
@@ -65,6 +65,11 @@ setup::setup(std::string const& test_name,
     qunsetenv("XKB_DEFAULT_VARIANT");
     qunsetenv("XKB_DEFAULT_OPTIONS");
 
+    auto breezerc = KSharedConfig::openConfig(QStringLiteral("breezerc"));
+    breezerc->group(QStringLiteral("Common"))
+        .writeEntry(QStringLiteral("OutlineIntensity"), QStringLiteral("OutlineOff"));
+    breezerc->sync();
+
     base = std::make_unique<base_t>(base::wayland::platform_arguments{
         .config = base::config(KConfig::OpenFlag::SimpleConfig, ""),
         .socket_name = socket_name,

diff --git a/autotests/integration/modifier_only_shortcut.cpp b/autotests/integration/modifier_only_shortcut.cpp
@@ -270,15 +270,14 @@ TEST_CASE("modifier only shortcut", "[input]")
         keyboard_key_pressed(KEY_CAPSLOCK, timestamp++);
         keyboard_key_released(KEY_CAPSLOCK, timestamp++);
         QTRY_COMPARE(input::xkb::get_active_keyboard_modifiers(*setup.base->mod.input),
-                     Qt::ShiftModifier);
+                     Qt::NoModifier);
         QTRY_COMPARE(triggeredSpy.count(), 1);
 
         // currently caps lock is on
-        // shift still triggers
         keyboard_key_pressed(modifier, timestamp++);
         keyboard_key_released(modifier, timestamp++);
         QTRY_COMPARE(input::xkb::get_active_keyboard_modifiers(*setup.base->mod.input),
-                     Qt::ShiftModifier);
+                     Qt::NoModifier);
         QTRY_COMPARE(triggeredSpy.count(), 2);
 
         // meta should also trigger

diff --git a/autotests/integration/move_resize_window.cpp b/autotests/integration/move_resize_window.cpp
@@ -679,7 +679,8 @@ TEST_CASE("move resize window", "[win]")
 
         // use NETRootInfo to trigger a move request
         win::x11::net::root_info root(c.get(), win::x11::net::Properties());
-        root.moveResizeRequest(w, origGeo.center().x(), origGeo.center().y(), win::x11::net::Move);
+        root.moveResizeRequest(
+            w, origGeo.center().x(), origGeo.center().y(), win::x11::net::Move, XCB_BUTTON_INDEX_1);
         xcb_flush(c.get());
 
         QVERIFY(moveStartSpy.wait());
@@ -697,7 +698,8 @@ TEST_CASE("move resize window", "[win]")
         root.moveResizeRequest(w,
                                client->geo.frame.center().x(),
                                client->geo.frame.center().y(),
-                               win::x11::net::MoveResizeCancel);
+                               win::x11::net::MoveResizeCancel,
+                               XCB_BUTTON_INDEX_1);
         xcb_flush(c.get());
         QVERIFY(moveEndSpy.wait());
 

diff --git a/autotests/integration/tabbox.cpp b/autotests/integration/tabbox.cpp
@@ -213,13 +213,12 @@ TEST_CASE("tabbox", "[win]")
         quint32 timestamp = 0;
         keyboard_key_pressed(KEY_CAPSLOCK, timestamp++);
         keyboard_key_released(KEY_CAPSLOCK, timestamp++);
-        QCOMPARE(input::xkb::get_active_keyboard_modifiers(*setup.base->mod.input),
-                 Qt::ShiftModifier);
+        QCOMPARE(input::xkb::get_active_keyboard_modifiers(*setup.base->mod.input), Qt::NoModifier);
 
         // press alt+tab
         keyboard_key_pressed(KEY_LEFTALT, timestamp++);
         REQUIRE(input::xkb::get_active_keyboard_modifiers(*setup.base->mod.input)
-                == (Qt::ShiftModifier | Qt::AltModifier));
+                == Qt::AltModifier);
         keyboard_key_pressed(KEY_TAB, timestamp++);
         keyboard_key_released(KEY_TAB, timestamp++);
 
@@ -239,9 +238,9 @@ TEST_CASE("tabbox", "[win]")
         QCOMPARE(setup.base->mod.space->tabbox->is_grabbed(), false);
 
         // Has walked backwards to the previously lowest client in the stacking order.
-        QCOMPARE(get_wayland_window(setup.base->mod.space->stacking.active), c1);
+        QCOMPARE(get_wayland_window(setup.base->mod.space->stacking.active), c2);
         QCOMPARE(setup.base->mod.space->stacking.order.stack,
-                 (std::deque<space::window_t>{c2, c3, c1}));
+                 (std::deque<space::window_t>{c1, c3, c2}));
 
         surface3.reset();
         QVERIFY(wait_for_destroyed(c3));

diff --git a/autotests/integration/xdg-shell_rules.cpp b/autotests/integration/xdg-shell_rules.cpp
@@ -4025,6 +4025,98 @@ TEST_CASE("xdg-shell rules", "[win]")
         QVERIFY(wait_for_destroyed(client));
     }
 
+    SECTION("closeable dont affect")
+    {
+        // Initialize RuleBook with the test rule.
+        auto [config, group] = get_config();
+        group.writeEntry("closeable", false);
+        group.writeEntry("closeablerule", enum_index(win::rules::action::dont_affect));
+        group.writeEntry("wmclass", "org.kde.foo");
+        group.writeEntry("wmclasscomplete", false);
+        group.writeEntry("wmclassmatch", enum_index(win::rules::name_match::exact));
+        group.sync();
+        setup.base->mod.space->rule_book->config = config;
+        win::space_reconfigure(*setup.base->mod.space);
+
+        // Create the test client.
+        wayland_window* client;
+        std::unique_ptr<Surface> surface;
+        std::unique_ptr<XdgShellToplevel> shellSurface;
+        std::tie(client, surface, shellSurface) = createWindow("org.kde.foo");
+        QVERIFY(client);
+        QVERIFY(client->control->active);
+        REQUIRE(client->isCloseable());
+
+        // Destroy the client.
+        shellSurface.reset();
+        surface.reset();
+        QVERIFY(wait_for_destroyed(client));
+    }
+
+    SECTION("closeable force")
+    {
+        // Initialize RuleBook with the test rule.
+        auto [config, group] = get_config();
+        group.writeEntry("closeable", false);
+        group.writeEntry("closeablerule", enum_index(win::rules::action::force));
+        group.writeEntry("wmclass", "org.kde.foo");
+        group.writeEntry("wmclasscomplete", false);
+        group.writeEntry("wmclassmatch", enum_index(win::rules::name_match::exact));
+        group.sync();
+        setup.base->mod.space->rule_book->config = config;
+        win::space_reconfigure(*setup.base->mod.space);
+
+        // Create the test client.
+        wayland_window* client;
+        std::unique_ptr<Surface> surface;
+        std::unique_ptr<XdgShellToplevel> shellSurface;
+        std::tie(client, surface, shellSurface) = createWindow("org.kde.foo");
+        QVERIFY(client);
+        QVERIFY(client->control->active);
+        REQUIRE(!client->isCloseable());
+
+        // Destroy the client.
+        shellSurface.reset();
+        surface.reset();
+        QVERIFY(wait_for_destroyed(client));
+    }
+
+    SECTION("closeable force temporarily")
+    {
+        // Initialize RuleBook with the test rule.
+        auto [config, group] = get_config();
+        group.writeEntry("closeable", false);
+        group.writeEntry("closeablerule", enum_index(win::rules::action::force_temporarily));
+        group.writeEntry("wmclass", "org.kde.foo");
+        group.writeEntry("wmclasscomplete", false);
+        group.writeEntry("wmclassmatch", enum_index(win::rules::name_match::exact));
+        group.sync();
+        setup.base->mod.space->rule_book->config = config;
+        win::space_reconfigure(*setup.base->mod.space);
+
+        // Create the test client.
+        wayland_window* client;
+        std::unique_ptr<Surface> surface;
+        std::unique_ptr<XdgShellToplevel> shellSurface;
+        std::tie(client, surface, shellSurface) = createWindow("org.kde.foo");
+        QVERIFY(client);
+        QVERIFY(client->control->active);
+        REQUIRE(!client->isCloseable());
+
+        // The rule should be discarded when the client is closed.
+        shellSurface.reset();
+        surface.reset();
+        QVERIFY(wait_for_destroyed(client));
+        std::tie(client, surface, shellSurface) = createWindow("org.kde.foo");
+        QVERIFY(client);
+        REQUIRE(client->isCloseable());
+
+        // Destroy the client.
+        shellSurface.reset();
+        surface.reset();
+        QVERIFY(wait_for_destroyed(client));
+    }
+
     SECTION("match after name change")
     {
         auto [config, group] = get_config();

diff --git a/como-config.cmake.in b/como-config.cmake.in
@@ -4,6 +4,7 @@ include(CMakeFindDependencyMacro)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/modules/")
 
 find_dependency(Wrapland)
+find_dependency(epoxy)
 find_dependency(Pixman)
 find_dependency(wlroots @WLROOTS_MIN_VERSION@)
 find_dependency(Qt6Gui @QT_MIN_VERSION@)

diff --git a/como/data/update_default_rules.cpp b/como/data/update_default_rules.cpp
@@ -6,9 +6,11 @@ SPDX-License-Identifier: GPL-2.0-or-later
 
 // read additional window rules and add them to kwinrulesrc
 
+#include <QCoreApplication>
+#include <QDBusConnection>
+#include <QDBusMessage>
 #include <QDebug>
 #include <QStandardPaths>
-#include <QtDBus>
 #include <kconfig.h>
 #include <kconfiggroup.h>
 

diff --git a/como/desktop/kde/dbus/KWinDBusInterfaceConfig.cmake.in b/como/desktop/kde/dbus/KWinDBusInterfaceConfig.cmake.in
@@ -8,7 +8,7 @@ set(KWIN_INTERFACE "@PACKAGE_KDE_INSTALL_DBUSINTERFACEDIR@/org.kde.KWin.xml")
 set(KWIN_COMPOSITING_INTERFACE "@PACKAGE_KDE_INSTALL_DBUSINTERFACEDIR@/org.kde.kwin.Compositing.xml")
 set(KWIN_EFFECTS_INTERFACE "@PACKAGE_KDE_INSTALL_DBUSINTERFACEDIR@/org.kde.kwin.Effects.xml")
 set(KWIN_INPUTDEVICE_INTERFACE "@PACKAGE_KDE_INSTALL_DBUSINTERFACEDIR@/org.kde.kwin.InputDevice.xml")
-set(KWIN_COLORCORRECT_INTERFACE "@PACKAGE_KDE_INSTALL_DBUSINTERFACEDIR@/org.kde.kwin.ColorCorrect.xml")
+set(KWIN_NIGHTLIGHT_INTERFACE "@PACKAGE_KDE_INSTALL_DBUSINTERFACEDIR@/org.kde.KWin.NightLight.xml")
 set(KWIN_WAYLAND_BIN_PATH "@CMAKE_INSTALL_FULL_BINDIR@/kwin_wayland")
 
 # Still needs to be set as plasma-workspace expects it at compile time.

diff --git a/como/desktop/kde/dbus/kwin.h b/como/desktop/kde/dbus/kwin.h
@@ -14,8 +14,10 @@
 #include <como/win/space_qobject.h>
 #include <como/win/subspaces_set.h>
 
+#include <QDBusConnection>
+#include <QDBusContext>
+#include <QDBusMessage>
 #include <QObject>
-#include <QtDBus>
 
 namespace como
 {

diff --git a/como/input/filters/internal_window.h b/como/input/filters/internal_window.h
@@ -18,6 +18,7 @@
 #include <QWindow>
 #include <Wrapland/Server/seat.h>
 #include <Wrapland/Server/touch_pool.h>
+#include <qpa/qwindowsysteminterface.h>
 
 namespace como::input
 {
@@ -51,15 +52,14 @@ class internal_window_filter : public event_filter<Redirect>
         }
 
         auto qt_event = button_to_qt_event(*this->redirect.pointer, event);
-        auto adapted_qt_event = QMouseEvent(qt_event.type(),
-                                            qt_event.pos() - internal->position(),
-                                            qt_event.pos(),
-                                            qt_event.button(),
-                                            qt_event.buttons(),
-                                            qt_event.modifiers());
-        adapted_qt_event.setAccepted(false);
-        QCoreApplication::sendEvent(internal, &adapted_qt_event);
-        return adapted_qt_event.isAccepted();
+        return QWindowSystemInterface::handleMouseEvent<
+            QWindowSystemInterface::SynchronousDelivery>(internal,
+                                                         qt_event.position() - internal->position(),
+                                                         qt_event.globalPosition(),
+                                                         qt_event.buttons(),
+                                                         qt_event.button(),
+                                                         qt_event.type(),
+                                                         qt_event.modifiers());
     }
 
     bool motion(motion_event const& event) override

diff --git a/como/input/wayland/kglobalaccel/runtime/global_accel_d.cpp b/como/input/wayland/kglobalaccel/runtime/global_accel_d.cpp
@@ -14,6 +14,7 @@
 #include <como/input/logging.h>
 
 #include <KGlobalAccel>
+#include <QDBusConnection>
 #include <QDBusMetaType>
 #include <QDBusObjectPath>
 #include <QMetaMethod>

diff --git a/como/input/wayland/kglobalaccel/runtime/global_accel_d.h b/como/input/wayland/kglobalaccel/runtime/global_accel_d.h
@@ -7,9 +7,9 @@
 
 #include <KGlobalAccel>
 #include <KGlobalShortcutInfo>
+#include <QDBusContext>
 #include <QList>
 #include <QStringList>
-#include <QtDBus>
 
 struct KGlobalAccelDPrivate;
 

diff --git a/como/input/xkb/keyboard.cpp b/como/input/xkb/keyboard.cpp
@@ -148,8 +148,7 @@ void keyboard::update_modifiers()
     constexpr auto is_active = xkb_state_mod_index_is_active;
     auto mods = Qt::KeyboardModifiers();
 
-    if (is_active(state, modifiers_indices.shift, XKB_STATE_MODS_EFFECTIVE) == 1
-        || is_active(state, modifiers_indices.caps, XKB_STATE_MODS_EFFECTIVE) == 1) {
+    if (is_active(state, modifiers_indices.shift, XKB_STATE_MODS_EFFECTIVE) == 1) {
         mods |= Qt::ShiftModifier;
     }
     if (is_active(state, modifiers_indices.alt, XKB_STATE_MODS_EFFECTIVE) == 1) {
@@ -268,6 +267,9 @@ Qt::KeyboardModifiers keyboard::modifiers_relevant_for_global_shortcuts(uint32_t
     if (is_active(state, modifiers_indices.meta, XKB_STATE_MODS_EFFECTIVE) == 1) {
         mods |= Qt::MetaModifier;
     }
+    if (keysym >= XKB_KEY_KP_Space && keysym <= XKB_KEY_KP_9) {
+        mods |= Qt::KeypadModifier;
+    }
 
     auto consumed_mods = qt_modifiers_consumed;
     if ((mods & Qt::ShiftModifier) && (consumed_mods == Qt::ShiftModifier)) {

diff --git a/como/render/CMakeLists.txt b/como/render/CMakeLists.txt
@@ -156,7 +156,7 @@ qt6_add_dbus_adaptor(render_dbus_SRCS
   como::render::dbus::compositing_qobject
 )
 qt6_add_dbus_adaptor(render_dbus_SRCS
-  dbus/org.kde.kwin.ColorCorrect.xml
+  dbus/org.kde.KWin.NightLight.xml
   post/color_correct_dbus_interface.h
   como::render::post::color_correct_dbus_interface
 )
@@ -300,7 +300,7 @@ install(
 )
 install(
   FILES
-    dbus/org.kde.kwin.ColorCorrect.xml
+    dbus/org.kde.KWin.NightLight.xml
     dbus/org.kde.kwin.Compositing.xml
     effect/interface/org.kde.kwin.Effects.xml
   DESTINATION