windows on top of fullscreen, lastmonitor fixes

src/Window.hpp

@@ -45,6 +45,9 @@ public:
 
     bool            m_bIsMapped = false;
 
+    // This is for fullscreen apps
+    bool            m_bCreatedOverFullscreen = false;
+
     // XWayland stuff
     bool            m_bIsX11 = false;
     bool            m_bMappedX11 = false;

src/events/Windows.cpp

@@ -24,7 +24,8 @@ void addViewCoords(void* pWindow, int* x, int* y) {
 void Events::listener_mapWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
-    const auto PMONITOR = g_pCompositor->m_pLastMonitor;
+    const auto PMONITOR = g_pCompositor->getMonitorFromCursor();
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
     PWINDOW->m_iMonitorID = PMONITOR->ID;
     PWINDOW->m_bMappedX11 = true;
     PWINDOW->m_iWorkspaceID = PMONITOR->activeWorkspace;
@@ -43,6 +44,12 @@ void Events::listener_mapWindow(void* owner, void* data) {
     if (g_pXWaylandManager->shouldBeFloated(PWINDOW))
         PWINDOW->m_bIsFloating = true;
 
+    if (PWORKSPACE->hasFullscreenWindow && !PWINDOW->m_bIsFloating) {
+        const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->ID);
+        g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PFULLWINDOW);
+        g_pXWaylandManager->setWindowFullscreen(PFULLWINDOW, PFULLWINDOW->m_bIsFullscreen);
+    }
+
     // window rules
     const auto WINDOWRULES = g_pConfigManager->getMatchingRules(PWINDOW);
 
@@ -71,6 +78,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
     if (PWINDOW->m_bIsFloating) {
         g_pLayoutManager->getCurrentLayout()->onWindowCreatedFloating(PWINDOW);
+        PWINDOW->m_bCreatedOverFullscreen = true;
 
         // size and move rules
         for (auto& r : WINDOWRULES) {

src/layout/DwindleLayout.cpp

@@ -359,7 +359,7 @@ void CHyprDwindleLayout::onWindowCreatedFloating(CWindow* pWindow) {
         Vector2D middlePoint = Vector2D(desiredGeometry.x, desiredGeometry.y) + Vector2D(desiredGeometry.width, desiredGeometry.height) / 2.f;
 
                                                                                             // TODO: detect a popup in a more consistent way.
-        if (g_pCompositor->getMonitorFromVector(middlePoint)->ID != pWindow->m_iMonitorID || (desiredGeometry.x == 0 && desiredGeometry.y == 0)) {
+        if ((g_pCompositor->getMonitorFromVector(middlePoint) && g_pCompositor->getMonitorFromVector(middlePoint)->ID != pWindow->m_iMonitorID) || (desiredGeometry.x == 0 && desiredGeometry.y == 0)) {
             // if it's not, fall back to the center placement
             pWindow->m_vEffectivePosition = PMONITOR->vecPosition + Vector2D((PMONITOR->vecSize.x - desiredGeometry.width) / 2.f, (PMONITOR->vecSize.y - desiredGeometry.height) / 2.f);
         } else {

src/managers/InputManager.cpp

@@ -23,8 +23,10 @@ void CInputManager::mouseMoveUnified(uint32_t time) {
     wlr_surface* foundSurface = nullptr;
     Vector2D mouseCoords = getMouseCoordsInternal();
     const auto PMONITOR = g_pCompositor->getMonitorFromCursor();
+    if (PMONITOR)
+        g_pCompositor->m_pLastMonitor = PMONITOR;
     Vector2D surfaceCoords;
-    Vector2D surfacePos;
+    Vector2D surfacePos = Vector2D(-1337, -1337);
 
     // first, we check if the workspace doesnt have a fullscreen window
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
@@ -36,6 +38,16 @@ void CInputManager::mouseMoveUnified(uint32_t time) {
             foundSurface = g_pXWaylandManager->getWindowSurface(PFULLSCREENWINDOW);
             if (foundSurface)
                 surfacePos = PFULLSCREENWINDOW->m_vRealPosition;
+
+            for (auto& w : g_pCompositor->m_lWindows) {
+                wlr_box box = {w.m_vRealPosition.x, w.m_vRealPosition.y, w.m_vRealSize.x, w.m_vRealSize.y};
+                if (w.m_iWorkspaceID == PFULLSCREENWINDOW->m_iWorkspaceID && w.m_bIsMapped && w.m_bCreatedOverFullscreen && wlr_box_contains_point(&box, mouseCoords.x, mouseCoords.y)) {
+                    foundSurface = g_pXWaylandManager->getWindowSurface(&w);
+                    if (foundSurface)
+                        surfacePos = w.m_vRealPosition;
+                    break;
+                }
+            }
         } 
     }
 
@@ -73,14 +85,13 @@ void CInputManager::mouseMoveUnified(uint32_t time) {
     if (time)
         wlr_idle_notify_activity(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat);
 
-    Vector2D surfaceLocal = surfacePos == Vector2D() ? surfaceCoords : Vector2D(g_pCompositor->m_sWLRCursor->x, g_pCompositor->m_sWLRCursor->y) - surfacePos;
+    Vector2D surfaceLocal = surfacePos == Vector2D(-1337, -1337) ? surfaceCoords : Vector2D(g_pCompositor->m_sWLRCursor->x, g_pCompositor->m_sWLRCursor->y) - surfacePos;
 
     wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, foundSurface, surfaceLocal.x, surfaceLocal.y);
     wlr_seat_pointer_notify_motion(g_pCompositor->m_sSeat.seat, time, surfaceLocal.x, surfaceLocal.y);
 
     g_pCompositor->focusSurface(foundSurface);
 
-    g_pCompositor->m_pLastMonitor = PMONITOR;
     g_pLayoutManager->getCurrentLayout()->onMouseMove(getMouseCoordsInternal());
 }
 

src/managers/KeybindManager.cpp

@@ -178,6 +178,12 @@ void CKeybindManager::fullscreenActive(std::string args) {
     g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(PWINDOW);
 
     g_pXWaylandManager->setWindowFullscreen(PWINDOW, PWINDOW->m_bIsFullscreen);
+
+    // make all windows on the same workspace under the fullscreen window
+    for (auto& w : g_pCompositor->m_lWindows) {
+        if (w.m_iWorkspaceID == PWINDOW->m_iWorkspaceID)
+            w.m_bCreatedOverFullscreen = false;
+    }
 }
 
 void CKeybindManager::moveActiveToWorkspace(std::string args) {

src/render/Renderer.cpp

@@ -59,12 +59,24 @@ bool shouldRenderWindow(CWindow* pWindow, SMonitor* pMonitor) {
 }
 
 void CHyprRenderer::renderWorkspaceWithFullscreenWindow(SMonitor* pMonitor, SWorkspace* pWorkspace, timespec* time) {
+    CWindow* pWorkspaceWindow = nullptr;
+
     for (auto& w : g_pCompositor->m_lWindows) {
         if (w.m_iWorkspaceID != pWorkspace->ID || !w.m_bIsFullscreen)
             continue;
 
         // found it!
         renderWindow(&w, pMonitor, time, false);
+
+        pWorkspaceWindow = &w;
+    }
+
+    // then render windows over fullscreen
+    for (auto& w : g_pCompositor->m_lWindows) {
+        if (w.m_iWorkspaceID != pWorkspaceWindow->m_iWorkspaceID || !w.m_bCreatedOverFullscreen || !w.m_bIsMapped)
+            continue;
+
+        renderWindow(&w, pMonitor, time, true);
     }
 }