fix(effect): decouple zone selector from drag activation trigger gating (#175)

Disabling the zone selector popup broke drag-based zone activation because
the effect's D-Bus event gating used m_cachedZoneSelectorEnabled as a bypass
for trigger checking. When zone selector was enabled (default), drag events
always reached the daemon even if trigger deserialization failed. With it
disabled, the gate relied solely on detectActivationAndGrab() which could
fail if QDBusArgument types weren't handled.

Three-part fix:
- Handle QDBusArgument explicitly when deserializing trigger lists from D-Bus
  (Qt may deliver QVariantList<QVariantMap> as QDBusArgument instead of
  native types, causing silent toList()/toMap() failures)
- Add m_triggersLoaded flag with permissive default: before triggers load
  (or on failure), all three drag event gates stay open, matching pre-
  optimization behavior
- Add diagnostic logging: per-trigger debug dump, warning for all-zero
  triggers (deserialization failure indicator), warning on load failure

Co-Authored-By: claude-flow <ruv@ruv.net>

Author: fuddlesworth

kwin-effect/plasmazoneseffect.cpp

@@ -4,6 +4,7 @@
 #include "plasmazoneseffect.h"
 
 #include <QBuffer>
+#include <QDBusArgument>
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QDBusMessage>
@@ -217,7 +218,10 @@ PlasmaZonesEffect::PlasmaZonesEffect()
                 // Check if zones are needed right now. If so, send dragStarted
                 // immediately and grab keyboard. Otherwise defer until activation
                 // is detected mid-drag (or skip entirely if user never activates).
-                if (detectActivationAndGrab() || m_cachedZoneSelectorEnabled) {
+                //
+                // When triggers haven't loaded yet (!m_triggersLoaded), stay
+                // permissive — send immediately to avoid masking trigger issues (#175).
+                if (detectActivationAndGrab() || m_cachedZoneSelectorEnabled || !m_triggersLoaded) {
                     sendDeferredDragStarted();
                 }
             });
@@ -226,7 +230,9 @@ PlasmaZonesEffect::PlasmaZonesEffect()
                 // Gate D-Bus calls: if no activation trigger is held, toggle mode is off,
                 // and zone selector is disabled, skip the D-Bus call entirely. This
                 // eliminates 60Hz D-Bus traffic during non-zone drags.
-                if (!detectActivationAndGrab() && !m_cachedZoneSelectorEnabled) {
+                //
+                // When triggers haven't loaded yet, stay permissive (#175).
+                if (!detectActivationAndGrab() && !m_cachedZoneSelectorEnabled && m_triggersLoaded) {
                     return;
                 }
                 // Ensure dragStarted was sent before any dragMoved
@@ -572,7 +578,8 @@ void PlasmaZonesEffect::slotMouseChanged(const QPointF& pos, const QPointF& oldp
             //
             // Gating: same logic as poll-based dragMoved — skip if no activation
             // detected and no reason to send (avoids D-Bus traffic for non-zone drags).
-            if (detectActivationAndGrab() || m_cachedZoneSelectorEnabled) {
+            // When triggers haven't loaded yet, stay permissive (#175).
+            if (detectActivationAndGrab() || m_cachedZoneSelectorEnabled || !m_triggersLoaded) {
                 sendDeferredDragStarted();
                 callDragMoved(m_dragTracker->draggedWindowId(), pos, m_currentModifiers, static_cast<int>(m_currentMouseButtons));
             }
@@ -1057,6 +1064,7 @@ void PlasmaZonesEffect::loadCachedSettings()
     m_minimumWindowWidth = 200;
     m_minimumWindowHeight = 150;
     m_snapAssistEnabled = false;
+    m_triggersLoaded = false; // Permissive until new triggers arrive (#175)
 
     // Use QDBusMessage + QDBusConnection::asyncCall instead of QDBusInterface to avoid
     // synchronous D-Bus introspection that blocks the compositor thread.
@@ -1141,19 +1149,72 @@ void PlasmaZonesEffect::loadCachedSettings()
         w->deleteLater();
         QDBusPendingReply<QVariant> reply = *w;
         if (reply.isValid()) {
-            m_cachedDragActivationTriggers = extractVariant(reply).toList();
+            QVariant triggerVariant = extractVariant(reply);
+
+            // D-Bus may deliver QVariantList-of-QVariantMap as a QDBusArgument
+            // instead of a native QVariantList. Extract manually if needed (#175).
+            // D-Bus wire format is typically `av` (array of variants), so we
+            // extract QVariants first, then handle inner maps per-element below.
+            QVariantList triggerList;
+            if (triggerVariant.canConvert<QDBusArgument>()) {
+                const QDBusArgument arg = triggerVariant.value<QDBusArgument>();
+                arg.beginArray();
+                while (!arg.atEnd()) {
+                    QVariant element;
+                    arg >> element;
+                    triggerList.append(element);
+                }
+                arg.endArray();
+            } else {
+                triggerList = triggerVariant.toList();
+            }
+            m_cachedDragActivationTriggers = triggerList;
+
             // Pre-parse to POD structs so anyLocalTriggerHeld() avoids QVariant
             // unboxing on every call (~30x/sec during drag).
             m_parsedTriggers.clear();
-            m_parsedTriggers.reserve(m_cachedDragActivationTriggers.size());
-            for (const auto& t : std::as_const(m_cachedDragActivationTriggers)) {
-                const auto map = t.toMap();
+            m_parsedTriggers.reserve(triggerList.size());
+            for (const auto& t : std::as_const(triggerList)) {
+                // Each trigger element may also arrive as QDBusArgument
+                QVariantMap map;
+                if (t.canConvert<QDBusArgument>()) {
+                    const QDBusArgument elemArg = t.value<QDBusArgument>();
+                    elemArg >> map;
+                } else {
+                    map = t.toMap();
+                }
                 ParsedTrigger pt;
                 pt.modifier = map.value(QStringLiteral("modifier"), 0).toInt();
                 pt.mouseButton = map.value(QStringLiteral("mouseButton"), 0).toInt();
                 m_parsedTriggers.append(pt);
             }
+
             qCDebug(lcEffect) << "Loaded dragActivationTriggers:" << m_parsedTriggers.size() << "triggers";
+            for (int i = 0; i < m_parsedTriggers.size(); ++i) {
+                qCDebug(lcEffect) << "  trigger" << i << "modifier:" << m_parsedTriggers[i].modifier
+                                  << "mouseButton:" << m_parsedTriggers[i].mouseButton;
+            }
+
+            // Safety: if triggers loaded but are all empty (modifier=0, mouseButton=0),
+            // the gating would block ALL drag events when zoneSelectorEnabled=false.
+            // Log a warning so this misconfiguration is visible in debug output.
+            bool anyValidTrigger = false;
+            for (const auto& pt : std::as_const(m_parsedTriggers)) {
+                if (pt.modifier != 0 || pt.mouseButton != 0) {
+                    anyValidTrigger = true;
+                    break;
+                }
+            }
+            if (!m_parsedTriggers.isEmpty() && !anyValidTrigger) {
+                qCWarning(lcEffect) << "All loaded triggers have modifier=0 mouseButton=0"
+                                    << "— possible D-Bus deserialization issue;"
+                                    << "zone activation may not work when zone selector is disabled";
+            }
+            m_triggersLoaded = true;
+        } else {
+            qCWarning(lcEffect) << "Failed to load dragActivationTriggers from daemon"
+                                << "— trigger gating will remain permissive";
+            // Leave m_triggersLoaded = false so gating stays permissive
         }
     });
 

kwin-effect/plasmazoneseffect.h

@@ -381,6 +381,7 @@ public Q_SLOTS:
     // Once real settings arrive, they override these conservative defaults.
     QVariantList m_cachedDragActivationTriggers; // raw D-Bus data, kept for reload
     QVector<ParsedTrigger> m_parsedTriggers; // pre-parsed from QVariantList at load time (avoids QVariant unboxing in hot path)
+    bool m_triggersLoaded = false; // false until D-Bus reply arrives — permissive default bypasses trigger gating (#175)
     bool m_cachedToggleActivation = false;
     bool m_cachedZoneSelectorEnabled = true; // true until proven false — ensures dragMoved passes through at startup