ignore Plasma panels in Latte heuristics

app/wm/abstractwindowinterface.cpp

@@ -55,6 +55,8 @@ AbstractWindowInterface::AbstractWindowInterface(QObject *parent)
         emit windowChanged(wid);
     });
 
+    connect(this, &AbstractWindowInterface::windowRemoved, this, &AbstractWindowInterface::windowRemovedSlot);
+
    // connect(this, &AbstractWindowInterface::windowChanged, this, [&](WindowId wid) {
    //     qDebug() << "WINDOW CHANGED ::: " << wid;
    // });
@@ -99,6 +101,52 @@ Tracker::Windows *AbstractWindowInterface::windowsTracker() const
     return m_windowsTracker;
 }
 
+bool AbstractWindowInterface::isIgnored(const WindowId &wid)
+{
+    return m_ignoredWindows.contains(wid);
+}
+
+bool AbstractWindowInterface::isPlasmaDesktop(const QRect &wGeometry) const
+{
+    if (wGeometry.isEmpty()) {
+        return false;
+    }
+
+    for (const auto scr : qGuiApp->screens()) {
+        if (wGeometry == scr->geometry()) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+bool AbstractWindowInterface::isPlasmaPanel(const QRect &wGeometry) const
+{
+    if (wGeometry.isEmpty()) {
+        return false;
+    }
+
+    for (const auto scr : qGuiApp->screens()) {
+        if (scr->geometry().contains(wGeometry.center())) {
+            if (wGeometry.y() == scr->geometry().y()
+                    || wGeometry.bottom() == scr->geometry().bottom()
+                    || wGeometry.left() == scr->geometry().left()
+                    || wGeometry.right() == scr->geometry().right()) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+bool AbstractWindowInterface::isRegisteredPlasmaPanel(const WindowId &wid)
+{
+    return m_plasmaPanels.contains(wid);
+}
+
+
 //! Register Latte Ignored Windows in order to NOT be tracked
 void AbstractWindowInterface::registerIgnoredWindow(WindowId wid)
 {
@@ -116,6 +164,27 @@ void AbstractWindowInterface::unregisterIgnoredWindow(WindowId wid)
     }
 }
 
+void AbstractWindowInterface::registerPlasmaPanel(WindowId wid)
+{
+    if (!wid.isNull() && !m_plasmaPanels.contains(wid)) {
+        m_plasmaPanels.append(wid);
+        emit windowChanged(wid);
+    }
+}
+
+void AbstractWindowInterface::unregisterPlasmaPanel(WindowId wid)
+{
+    if (m_plasmaPanels.contains(wid)) {
+        m_plasmaPanels.removeAll(wid);
+    }
+}
+
+void AbstractWindowInterface::windowRemovedSlot(WindowId wid)
+{
+    if (m_plasmaPanels.contains(wid)) {
+        unregisterPlasmaPanel(wid);
+    }
+}
 
 //! Activities switching
 void AbstractWindowInterface::switchToNextActivity()

app/wm/abstractwindowinterface.h

@@ -113,12 +113,18 @@ public:
     virtual WindowId winIdFor(QString appId, QRect geometry) const = 0;
     virtual AppData appDataFor(WindowId wid) const = 0;
 
+    bool isIgnored(const WindowId &wid);
+    bool isRegisteredPlasmaPanel(const WindowId &wid);
+
     QString currentDesktop() const;
     QString currentActivity() const;
 
     virtual void registerIgnoredWindow(WindowId wid);
     virtual void unregisterIgnoredWindow(WindowId wid);
 
+    void registerPlasmaPanel(WindowId wid);
+    void unregisterPlasmaPanel(WindowId wid);
+
     void switchToNextActivity();
     void switchToPreviousActivity();
 
@@ -146,6 +152,8 @@ protected:
     //! windows that must be ignored from tracking, a good example are Latte::Views and
     //! their Configuration windows
     QList<WindowId> m_ignoredWindows;
+    //! identified plasma panels
+    QList<WindowId> m_plasmaPanels;
 
     QPointer<KActivities::Consumer> m_activities;
 
@@ -160,6 +168,12 @@ protected:
 
     void considerWindowChanged(WindowId wid);
 
+    bool isPlasmaDesktop(const QRect &wGeometry) const;
+    bool isPlasmaPanel(const QRect &wGeometry) const;
+
+private slots:
+    void windowRemovedSlot(WindowId wid);
+
 private:
     Latte::Corona *m_corona;
     Tracker::Schemes *m_schemesTracker;

app/wm/tracker/windowstracker.cpp

@@ -873,7 +873,7 @@ void Windows::updateHints(Latte::View *view)
             existsFaultyWindow = true;
         }
 
-        if (winfo.isPlasmaDesktop() || !inCurrentDesktopActivity(winfo)) {
+        if (winfo.isPlasmaDesktop() || !inCurrentDesktopActivity(winfo) || m_wm->isRegisteredPlasmaPanel(winfo.wid())) {
             continue;
         }
 
@@ -930,7 +930,7 @@ void Windows::updateHints(Latte::View *view)
         WindowId mainWindowId = activeInfo.isChildWindow() ? activeInfo.parentId() : activeWinId;
 
         for (const auto &winfo : m_windows) {
-            if (winfo.isPlasmaDesktop() || !inCurrentDesktopActivity(winfo)) {
+            if (winfo.isPlasmaDesktop() || !inCurrentDesktopActivity(winfo) || m_wm->isRegisteredPlasmaPanel(winfo.wid())) {
                 continue;
             }
 
@@ -1015,7 +1015,7 @@ void Windows::updateHints(Latte::Layout::GenericLayout *layout) {
             existsFaultyWindow = true;
         }
 
-        if (winfo.isPlasmaDesktop() || !inCurrentDesktopActivity(winfo)) {
+        if (winfo.isPlasmaDesktop() || !inCurrentDesktopActivity(winfo) || m_wm->isRegisteredPlasmaPanel(winfo.wid())) {
             continue;
         }
 

app/wm/waylandinterface.cpp

@@ -630,16 +630,16 @@ bool WaylandInterface::isPlasmaDesktop(const KWayland::Client::PlasmaWindow *w)
         return false;
     }
 
-    bool hasScreenGeometry{false};
+    return AbstractWindowInterface::isPlasmaDesktop(w->geometry());
+}
 
-    for (const auto scr : qGuiApp->screens()) {
-        if (!w->geometry().isEmpty() && w->geometry() == scr->geometry()) {
-            hasScreenGeometry = true;
-            break;
-        }
+bool WaylandInterface::isPlasmaPanel(const KWayland::Client::PlasmaWindow *w) const
+{
+    if (!w || (w->appId() != QLatin1String("org.kde.plasmashell"))) {
+        return false;
     }
 
-    return hasScreenGeometry;
+    return AbstractWindowInterface::isPlasmaPanel(w->geometry());
 }
 
 bool WaylandInterface::isValidWindow(const KWayland::Client::PlasmaWindow *w) const
@@ -651,7 +651,7 @@ bool WaylandInterface::isValidWindow(const KWayland::Client::PlasmaWindow *w) co
     //! e.g. widgets explorer, Activities etc. that are not used to hide
     //! the dodge views appropriately
 
-    return w->isValid() && !isPlasmaDesktop(w) && !m_ignoredWindows.contains(w->internalId());
+    return w->isValid() && !isPlasmaDesktop(w) && !m_plasmaPanels.contains(w->internalId()) && !m_ignoredWindows.contains(w->internalId());
 }
 
 void WaylandInterface::windowCreatedProxy(KWayland::Client::PlasmaWindow *w)
@@ -697,10 +697,22 @@ void WaylandInterface::windowCreatedProxy(KWayland::Client::PlasmaWindow *w)
         PlasmaWindow *pW = qobject_cast<PlasmaWindow*>(w);
 
         if (pW && !m_ignoredWindows.contains(pW->internalId() && !isPlasmaDesktop(pW) )) {
+            if (pW->appId() == QLatin1String("org.kde.plasmashell")) {
+                if (isPlasmaDesktop(pW)) {
+                    return;
+                } else if (isPlasmaPanel(pW)) {
+                    registerIgnoredWindow(pW->internalId());
+                }
+            }
+
             considerWindowChanged(pW->internalId());
         }
     });
 
+    if (isPlasmaPanel(w)) {
+        registerPlasmaPanel(w->internalId());
+    }
+
     emit windowAdded(w->internalId());
 
     if (w->appId() == "latte-dock") {

app/wm/waylandinterface.h

@@ -110,6 +110,7 @@ private:
     void init();
     bool isValidWindow(const KWayland::Client::PlasmaWindow *w) const;
     bool isPlasmaDesktop(const KWayland::Client::PlasmaWindow *w) const;
+    bool isPlasmaPanel(const KWayland::Client::PlasmaWindow *w) const;
     void windowCreatedProxy(KWayland::Client::PlasmaWindow *w);
     KWayland::Client::PlasmaWindow *windowFor(WindowId wid) const;
     KWayland::Client::PlasmaShell *waylandCoronaInterface() const;

app/wm/xwindowinterface.cpp

@@ -62,6 +62,12 @@ XWindowInterface::XWindowInterface(QObject *parent)
             , static_cast<void (KWindowSystem::*)(WId, NET::Properties, NET::Properties2)>
             (&KWindowSystem::windowChanged)
             , this, &XWindowInterface::windowChangedProxy);
+
+
+    for(auto wid : KWindowSystem::self()->windows()) {
+        emit windowAdded(wid);
+        windowChangedProxy(wid,0,0);
+    }
 }
 
 XWindowInterface::~XWindowInterface()
@@ -313,9 +319,9 @@ WindowInfoWrap XWindowInterface::requestInfo(WindowId wid) const
 
     //! update desktop id
 
-    bool isPlasmaDesktop{false};
-    if (winfo.windowClassName() == "plasmashell" && hasScreenGeometry(winfo)) {
-        isPlasmaDesktop = true;
+    bool isDesktop{false};
+    if (winfo.windowClassName() == "plasmashell" && isPlasmaDesktop(winfo.geometry())) {
+        isDesktop = true;
         windowsTracker()->setPlasmaDesktop(wid);
     }
 
@@ -323,7 +329,7 @@ WindowInfoWrap XWindowInterface::requestInfo(WindowId wid) const
 
     if (!winfo.valid()) {
         winfoWrap.setIsValid(false);
-    } else if (isValidWindow(winfo) && !isPlasmaDesktop) {
+    } else if (isValidWindow(winfo) && !isDesktop) {
         winfoWrap.setIsValid(true);
         winfoWrap.setWid(wid);
         winfoWrap.setParentId(winfo.transientFor());
@@ -616,20 +622,6 @@ bool XWindowInterface::isValidWindow(const KWindowInfo &winfo) const
     return !(isMenu || isDock);
 }
 
-bool XWindowInterface::hasScreenGeometry(const KWindowInfo &winfo) const
-{
-    bool hasScreenGeometry{false};
-
-    for (const auto scr : qGuiApp->screens()) {
-        if (!winfo.geometry().isEmpty() && winfo.geometry() == scr->geometry()) {
-            hasScreenGeometry = true;
-            break;
-        }
-    }
-
-    return hasScreenGeometry;
-}
-
 void XWindowInterface::windowChangedProxy(WId wid, NET::Properties prop1, NET::Properties2 prop2)
 {
     const KWindowInfo info(wid, NET::WMGeometry, NET::WM2WindowClass);
@@ -641,12 +633,17 @@ void XWindowInterface::windowChangedProxy(WId wid, NET::Properties prop1, NET::P
         return;
     }
 
-    //! update desktop id
-    if (winClass == "plasmashell" && hasScreenGeometry(info)) {
-        m_desktopId = wid;
-        windowsTracker()->setPlasmaDesktop(wid);
-        considerWindowChanged(wid);
-        return;
+    if (winClass == "plasmashell") {
+        //! update desktop id
+        if (isPlasmaDesktop(info.geometry())) {
+            m_desktopId = wid;
+            windowsTracker()->setPlasmaDesktop(wid);
+            considerWindowChanged(wid);
+            return;
+        } else if (isPlasmaPanel(info.geometry())) {
+            registerPlasmaPanel(wid);
+            return;
+        }
     }
 
     //! accept only NET::Properties events,

app/wm/xwindowinterface.h

@@ -81,7 +81,6 @@ public:
     void switchToPreviousVirtualDesktop() const override;
 
 private:
-    bool hasScreenGeometry(const KWindowInfo &winfo) const;
     bool isValidWindow(WindowId wid) const;
     bool isValidWindow(const KWindowInfo &winfo) const;
     void windowChangedProxy(WId wid, NET::Properties prop1, NET::Properties2 prop2);