flake.lock: update

fixes #9283

CMakeLists.txt

@@ -104,7 +104,7 @@ find_package(OpenGL REQUIRED COMPONENTS ${GLES_VERSION})
 pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine>=0.4.5)
 pkg_check_modules(hyprlang_dep REQUIRED IMPORTED_TARGET hyprlang>=0.3.2)
 pkg_check_modules(hyprcursor_dep REQUIRED IMPORTED_TARGET hyprcursor>=0.1.7)
-pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=0.4.0)
+pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=0.5.0)
 pkg_check_modules(hyprgraphics_dep REQUIRED IMPORTED_TARGET hyprgraphics>=0.1.1)
 
 add_compile_definitions(AQUAMARINE_VERSION="${aquamarine_dep_VERSION}")

VERSION

@@ -1 +1 @@
-0.47.1
+0.47.2

flake.lock

@@ -287,11 +287,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1737725508,
-        "narHash": "sha256-jGmcPc6y/prg/4A8KGYqJ27nSPaProCMiFadaxNAKvA=",
+        "lastModified": 1739891528,
+        "narHash": "sha256-h8HOCZ/rw2Buzku+GKF77VXxrGjCSOQkLhptiEKMYg0=",
         "owner": "hyprwm",
         "repo": "hyprutils",
-        "rev": "fb0c2d1de3d1ef7396d19c18ac09e12bd956929e",
+        "rev": "61a5382f4b1ab578064d470b1b3d3f0df396b8ba",
         "type": "github"
       },
       "original": {

src/config/ConfigWatcher.cpp

@@ -4,6 +4,7 @@
 #include <ranges>
 #include <fcntl.h>
 #include <unistd.h>
+#include <filesystem>
 
 CConfigWatcher::CConfigWatcher() : m_inotifyFd(inotify_init()) {
     if (m_inotifyFd < 0) {
@@ -46,9 +47,19 @@ void CConfigWatcher::setWatchList(const std::vector<std::string>& paths) {
     // add new paths
     for (const auto& path : paths) {
         m_watches.emplace_back(SInotifyWatch{
-            .wd   = inotify_add_watch(m_inotifyFd, path.c_str(), IN_MODIFY),
+            .wd   = inotify_add_watch(m_inotifyFd, path.c_str(), IN_MODIFY | IN_DONT_FOLLOW),
             .file = path,
         });
+
+        std::error_code ec, ec2;
+        const auto      CANONICAL  = std::filesystem::canonical(path, ec);
+        const auto      IS_SYMLINK = std::filesystem::is_symlink(path, ec2);
+        if (!ec && !ec2 && IS_SYMLINK) {
+            m_watches.emplace_back(SInotifyWatch{
+                .wd   = inotify_add_watch(m_inotifyFd, CANONICAL.c_str(), IN_MODIFY),
+                .file = path,
+            });
+        }
     }
 }
 

src/desktop/LayerSurface.cpp

@@ -31,10 +31,9 @@ PHLLS CLayerSurface::create(SP<CLayerShellResource> resource) {
 
     pLS->szNamespace = resource->layerNamespace;
 
-    pLS->layer              = resource->current.layer;
-    pLS->popupHead          = makeUnique<CPopup>(pLS);
-    pLS->popupHead->m_pSelf = pLS->popupHead;
-    pLS->monitor            = pMonitor;
+    pLS->layer     = resource->current.layer;
+    pLS->popupHead = CPopup::create(pLS);
+    pLS->monitor   = pMonitor;
     pMonitor->m_aLayerSurfaceLayers[resource->current.layer].emplace_back(pLS);
 
     pLS->forceBlur = g_pConfigManager->shouldBlurLS(pLS->szNamespace);
@@ -98,7 +97,8 @@ void CLayerSurface::onDestroy() {
             onUnmap();
         } else {
             Debug::log(LOG, "Removing LayerSurface that wasn't mapped.");
-            alpha->setValueAndWarp(0.f);
+            if (alpha)
+                alpha->setValueAndWarp(0.f);
             fadingOut = true;
             g_pCompositor->addToFadingOutSafe(self.lock());
         }

src/desktop/Popup.cpp

@@ -12,23 +12,37 @@
 #include "../render/OpenGL.hpp"
 #include <ranges>
 
-CPopup::CPopup(PHLWINDOW pOwner) : m_pWindowOwner(pOwner) {
-    initAllSignals();
+UP<CPopup> CPopup::create(PHLWINDOW pOwner) {
+    auto popup            = UP<CPopup>(new CPopup());
+    popup->m_pWindowOwner = pOwner;
+    popup->m_pSelf        = popup;
+    popup->initAllSignals();
+    return popup;
 }
 
-CPopup::CPopup(PHLLS pOwner) : m_pLayerOwner(pOwner) {
-    initAllSignals();
+UP<CPopup> CPopup::create(PHLLS pOwner) {
+    auto popup           = UP<CPopup>(new CPopup());
+    popup->m_pLayerOwner = pOwner;
+    popup->m_pSelf       = popup;
+    popup->initAllSignals();
+    return popup;
 }
 
-CPopup::CPopup(SP<CXDGPopupResource> popup, WP<CPopup> pOwner) :
-    m_pWindowOwner(pOwner->m_pWindowOwner), m_pLayerOwner(pOwner->m_pLayerOwner), m_pParent(pOwner), m_pResource(popup) {
-    m_pWLSurface = CWLSurface::create();
-    m_pWLSurface->assign(popup->surface->surface.lock(), this);
+UP<CPopup> CPopup::create(SP<CXDGPopupResource> resource, WP<CPopup> pOwner) {
+    auto popup            = UP<CPopup>(new CPopup());
+    popup->m_pResource    = resource;
+    popup->m_pWindowOwner = pOwner->m_pWindowOwner;
+    popup->m_pLayerOwner  = pOwner->m_pLayerOwner;
+    popup->m_pParent      = pOwner;
+    popup->m_pSelf        = popup;
+    popup->m_pWLSurface   = CWLSurface::create();
+    popup->m_pWLSurface->assign(resource->surface->surface.lock(), popup.get());
 
-    m_vLastSize = popup->surface->current.geometry.size();
-    reposition();
+    popup->m_vLastSize = resource->surface->current.geometry.size();
+    popup->reposition();
 
-    initAllSignals();
+    popup->initAllSignals();
+    return popup;
 }
 
 CPopup::~CPopup() {
@@ -59,7 +73,7 @@ void CPopup::initAllSignals() {
 }
 
 void CPopup::onNewPopup(SP<CXDGPopupResource> popup) {
-    const auto& POPUP = m_vChildren.emplace_back(makeShared<CPopup>(popup, m_pSelf));
+    const auto& POPUP = m_vChildren.emplace_back(CPopup::create(popup, m_pSelf));
     POPUP->m_pSelf    = POPUP;
     Debug::log(LOG, "New popup at {:x}", (uintptr_t)POPUP);
 }
@@ -91,8 +105,7 @@ void CPopup::onMap() {
 
     g_pInputManager->simulateMouseMovement();
 
-    m_pSubsurfaceHead          = makeUnique<CSubsurface>(m_pSelf);
-    m_pSubsurfaceHead->m_pSelf = m_pSubsurfaceHead;
+    m_pSubsurfaceHead = CSubsurface::create(m_pSelf);
 
     //unconstrain();
     sendScale();
@@ -269,7 +282,8 @@ void CPopup::recheckTree() {
 }
 
 void CPopup::recheckChildrenRecursive() {
-    auto cpy = m_vChildren;
+    std::vector<WP<CPopup>> cpy;
+    std::ranges::for_each(m_vChildren, [&cpy](const auto& el) { cpy.emplace_back(el); });
     for (auto const& c : cpy) {
         c->onCommit(true);
         c->recheckChildrenRecursive();
@@ -326,22 +340,24 @@ void CPopup::breadthfirst(std::function<void(WP<CPopup>, void*)> fn, void* data)
 
 WP<CPopup> CPopup::at(const Vector2D& globalCoords, bool allowsInput) {
     std::vector<WP<CPopup>> popups;
-    breadthfirst([](WP<CPopup> popup, void* data) { ((std::vector<WP<CPopup>>*)data)->push_back(popup); }, &popups);
+    breadthfirst([&popups](WP<CPopup> popup, void* data) { popups.push_back(popup); }, &popups);
 
     for (auto const& p : popups | std::views::reverse) {
         if (!p->m_pResource || !p->m_bMapped)
             continue;
 
         if (!allowsInput) {
-            const Vector2D offset = p->m_pResource ? (p->size() - p->m_pResource->geometry.size()) / 2.F : Vector2D{};
-            const Vector2D size   = p->m_pResource ? p->m_pResource->geometry.size() : p->size();
+            const Vector2D offset =
+                p->m_pResource && p->m_pResource->surface ? (p->size() - p->m_pResource->geometry.size()) / 2.F - p->m_pResource->surface->current.geometry.pos() : Vector2D{};
+            const Vector2D size = p->m_pResource ? p->m_pResource->geometry.size() : p->size();
 
             const auto     BOX = CBox{p->coordsGlobal() + offset, size};
             if (BOX.containsPoint(globalCoords))
                 return p;
         } else {
-            const Vector2D offset = p->m_pResource ? (p->size() - p->m_pResource->geometry.size()) / 2.F : Vector2D{};
-            const auto     REGION =
+            const Vector2D offset =
+                p->m_pResource && p->m_pResource->surface ? (p->size() - p->m_pResource->geometry.size()) / 2.F - p->m_pResource->surface->current.geometry.pos() : Vector2D{};
+            const auto REGION =
                 CRegion{p->m_pWLSurface->resource()->current.input}.intersect(CBox{{}, p->m_pWLSurface->resource()->current.size}).translate(p->coordsGlobal() + offset);
             if (REGION.containsPoint(globalCoords))
                 return p;

src/desktop/Popup.hpp

@@ -10,11 +10,11 @@ class CXDGPopupResource;
 class CPopup {
   public:
     // dummy head nodes
-    CPopup(PHLWINDOW pOwner);
-    CPopup(PHLLS pOwner);
+    static UP<CPopup> create(PHLWINDOW pOwner);
+    static UP<CPopup> create(PHLLS pOwner);
 
     // real nodes
-    CPopup(SP<CXDGPopupResource> popup, WP<CPopup> pOwner);
+    static UP<CPopup> create(SP<CXDGPopupResource> popup, WP<CPopup> pOwner);
 
     ~CPopup();
 
@@ -45,6 +45,8 @@ class CPopup {
     bool           m_bMapped = false;
 
   private:
+    CPopup() = default;
+
     // T1 owners, each popup has to have one of these
     PHLWINDOWREF m_pWindowOwner;
     PHLLSREF     m_pLayerOwner;
@@ -62,7 +64,7 @@ class CPopup {
     bool                  m_bInert = false;
 
     //
-    std::vector<SP<CPopup>> m_vChildren;
+    std::vector<UP<CPopup>> m_vChildren;
     UP<CSubsurface>         m_pSubsurfaceHead;
 
     struct {

src/desktop/Subsurface.cpp

@@ -7,28 +7,47 @@
 #include "../render/Renderer.hpp"
 #include "../managers/input/InputManager.hpp"
 
-CSubsurface::CSubsurface(PHLWINDOW pOwner) : m_pWindowParent(pOwner) {
-    initSignals();
-    initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
+UP<CSubsurface> CSubsurface::create(PHLWINDOW pOwner) {
+    auto subsurface             = UP<CSubsurface>(new CSubsurface());
+    subsurface->m_pWindowParent = pOwner;
+    subsurface->m_pSelf         = subsurface;
+
+    subsurface->initSignals();
+    subsurface->initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
+    return subsurface;
 }
 
-CSubsurface::CSubsurface(WP<CPopup> pOwner) : m_pPopupParent(pOwner) {
-    initSignals();
-    initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
+UP<CSubsurface> CSubsurface::create(WP<CPopup> pOwner) {
+    auto subsurface            = UP<CSubsurface>(new CSubsurface());
+    subsurface->m_pPopupParent = pOwner;
+    subsurface->m_pSelf        = subsurface;
+    subsurface->initSignals();
+    subsurface->initExistingSubsurfaces(pOwner->m_pWLSurface->resource());
+    return subsurface;
 }
 
-CSubsurface::CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, PHLWINDOW pOwner) : m_pSubsurface(pSubsurface), m_pWindowParent(pOwner) {
-    m_pWLSurface = CWLSurface::create();
-    m_pWLSurface->assign(pSubsurface->surface.lock(), this);
-    initSignals();
-    initExistingSubsurfaces(pSubsurface->surface.lock());
+UP<CSubsurface> CSubsurface::create(SP<CWLSubsurfaceResource> pSubsurface, PHLWINDOW pOwner) {
+    auto subsurface             = UP<CSubsurface>(new CSubsurface());
+    subsurface->m_pWindowParent = pOwner;
+    subsurface->m_pSubsurface   = pSubsurface;
+    subsurface->m_pSelf         = subsurface;
+    subsurface->m_pWLSurface    = CWLSurface::create();
+    subsurface->m_pWLSurface->assign(pSubsurface->surface.lock(), subsurface.get());
+    subsurface->initSignals();
+    subsurface->initExistingSubsurfaces(pSubsurface->surface.lock());
+    return subsurface;
 }
 
-CSubsurface::CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, WP<CPopup> pOwner) : m_pSubsurface(pSubsurface), m_pPopupParent(pOwner) {
-    m_pWLSurface = CWLSurface::create();
-    m_pWLSurface->assign(pSubsurface->surface.lock(), this);
-    initSignals();
-    initExistingSubsurfaces(pSubsurface->surface.lock());
+UP<CSubsurface> CSubsurface::create(SP<CWLSubsurfaceResource> pSubsurface, WP<CPopup> pOwner) {
+    auto subsurface            = UP<CSubsurface>(new CSubsurface());
+    subsurface->m_pPopupParent = pOwner;
+    subsurface->m_pSubsurface  = pSubsurface;
+    subsurface->m_pSelf        = subsurface;
+    subsurface->m_pWLSurface   = CWLSurface::create();
+    subsurface->m_pWLSurface->assign(pSubsurface->surface.lock(), subsurface.get());
+    subsurface->initSignals();
+    subsurface->initExistingSubsurfaces(pSubsurface->surface.lock());
+    return subsurface;
 }
 
 CSubsurface::~CSubsurface() {
@@ -135,9 +154,9 @@ void CSubsurface::onNewSubsurface(SP<CWLSubsurfaceResource> pSubsurface) {
     WP<CSubsurface> PSUBSURFACE;
 
     if (!m_pWindowParent.expired())
-        PSUBSURFACE = m_vChildren.emplace_back(makeUnique<CSubsurface>(pSubsurface, m_pWindowParent.lock()));
+        PSUBSURFACE = m_vChildren.emplace_back(CSubsurface::create(pSubsurface, m_pWindowParent.lock()));
     else if (m_pPopupParent)
-        PSUBSURFACE = m_vChildren.emplace_back(makeUnique<CSubsurface>(pSubsurface, m_pPopupParent));
+        PSUBSURFACE = m_vChildren.emplace_back(CSubsurface::create(pSubsurface, m_pPopupParent));
 
     PSUBSURFACE->m_pSelf = PSUBSURFACE;
 

src/desktop/Subsurface.hpp

@@ -10,12 +10,12 @@ class CWLSubsurfaceResource;
 class CSubsurface {
   public:
     // root dummy nodes
-    CSubsurface(PHLWINDOW pOwner);
-    CSubsurface(WP<CPopup> pOwner);
+    static UP<CSubsurface> create(PHLWINDOW pOwner);
+    static UP<CSubsurface> create(WP<CPopup> pOwner);
 
     // real nodes
-    CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, PHLWINDOW pOwner);
-    CSubsurface(SP<CWLSubsurfaceResource> pSubsurface, WP<CPopup> pOwner);
+    static UP<CSubsurface> create(SP<CWLSubsurfaceResource> pSubsurface, PHLWINDOW pOwner);
+    static UP<CSubsurface> create(SP<CWLSubsurfaceResource> pSubsurface, WP<CPopup> pOwner);
 
     ~CSubsurface();
 
@@ -37,6 +37,8 @@ class CSubsurface {
     WP<CSubsurface> m_pSelf;
 
   private:
+    CSubsurface() = default;
+
     struct {
         CHyprSignalListener destroySubsurface;
         CHyprSignalListener commitSubsurface;

src/desktop/Window.cpp

@@ -571,10 +571,8 @@ void CWindow::onMap() {
     if (m_bIsX11)
         return;
 
-    m_pSubsurfaceHead          = makeUnique<CSubsurface>(m_pSelf.lock());
-    m_pSubsurfaceHead->m_pSelf = m_pSubsurfaceHead;
-    m_pPopupHead               = makeUnique<CPopup>(m_pSelf.lock());
-    m_pPopupHead->m_pSelf      = m_pPopupHead;
+    m_pSubsurfaceHead = CSubsurface::create(m_pSelf.lock());
+    m_pPopupHead      = CPopup::create(m_pSelf.lock());
 }
 
 void CWindow::onBorderAngleAnimEnd(WP<CBaseAnimatedVariable> pav) {
@@ -1697,18 +1695,18 @@ Vector2D CWindow::requestedMaxSize() {
 
 void CWindow::sendWindowSize(Vector2D size, bool force, std::optional<Vector2D> overridePos) {
     static auto PXWLFORCESCALEZERO = CConfigValue<Hyprlang::INT>("xwayland:force_zero_scaling");
+    const auto  PMONITOR           = m_pMonitor.lock();
 
-    const auto  PMONITOR = m_pMonitor.lock();
-
-    size = size.clamp(Vector2D{0, 0}, Vector2D{std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()});
+    size = size.clamp(Vector2D{1, 1}, Vector2D{std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity()});
 
     // calculate pos
     // TODO: this should be decoupled from setWindowSize IMO
     Vector2D windowPos = overridePos.value_or(m_vRealPosition->goal());
 
-    if (m_bIsX11) {
-        if (const auto XWAYLANDPOS = g_pXWaylandManager->waylandToXWaylandCoords(windowPos); XWAYLANDPOS != Vector2D{})
-            windowPos = XWAYLANDPOS;
+    if (m_bIsX11 && PMONITOR) {
+        windowPos = g_pXWaylandManager->waylandToXWaylandCoords(windowPos);
+        if (*PXWLFORCESCALEZERO)
+            size *= PMONITOR->scale;
     }
 
     if (!force && m_vPendingReportedSize == size && (windowPos == m_vReportedPosition || !m_bIsX11))
@@ -1716,13 +1714,10 @@ void CWindow::sendWindowSize(Vector2D size, bool force, std::optional<Vector2D>
 
     m_vReportedPosition    = windowPos;
     m_vPendingReportedSize = size;
+    m_fX11SurfaceScaledBy  = 1.0f;
 
-    m_fX11SurfaceScaledBy = 1.0f;
-
-    if (*PXWLFORCESCALEZERO && m_bIsX11 && PMONITOR) {
-        size *= PMONITOR->scale;
+    if (*PXWLFORCESCALEZERO && m_bIsX11 && PMONITOR)
         m_fX11SurfaceScaledBy = PMONITOR->scale;
-    }
 
     if (m_bIsX11 && m_pXWaylandSurface)
         m_pXWaylandSurface->configure({windowPos, size});

src/helpers/Monitor.cpp

@@ -434,7 +434,7 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
 
     // accumulate requested modes in reverse order (cause inesrting at front is inefficient)
     std::vector<SP<Aquamarine::SOutputMode>> requestedModes;
-    std::string                              requestedStr = "preferred";
+    std::string                              requestedStr = "unknown";
 
     // use sortFunc, add best 3 to requestedModes in reverse, since we test in reverse
     auto addBest3Modes = [&](auto const& sortFunc) {
@@ -445,13 +445,24 @@ bool CMonitor::applyMonitorRule(SMonitorRule* pMonitorRule, bool force) {
         requestedModes.insert(requestedModes.end(), sortedModes.rbegin(), sortedModes.rend());
     };
 
-    // last fallback is preferred mode, btw this covers resolution == Vector2D()
+    // last fallback is always preferred mode
     if (!output->preferredMode())
         Debug::log(ERR, "Monitor {} has NO PREFERRED MODE", output->name);
     else
         requestedModes.push_back(output->preferredMode());
 
-    if (RULE->resolution == Vector2D(-1, -1)) {
+    if (RULE->resolution == Vector2D()) {
+        requestedStr = "preferred";
+
+        // fallback to first 3 modes if preferred fails/doesn't exist
+        requestedModes = output->modes;
+        if (requestedModes.size() > 3)
+            requestedModes.erase(requestedModes.begin() + 3, requestedModes.end());
+        std::ranges::reverse(requestedModes.begin(), requestedModes.end());
+
+        if (output->preferredMode())
+            requestedModes.push_back(output->preferredMode());
+    } else if (RULE->resolution == Vector2D(-1, -1)) {
         requestedStr = "highrr";
 
         // sort prioritizing refresh rate 1st and resolution 2nd, then add best 3

src/managers/AnimationManager.cpp

@@ -43,7 +43,7 @@ CHyprAnimationManager::CHyprAnimationManager() {
 template <Animable VarType>
 static void updateVariable(CAnimatedVariable<VarType>& av, const float POINTY, bool warp = false) {
     if (warp || av.value() == av.goal()) {
-        av.warp();
+        av.warp(true, false);
         return;
     }
 
@@ -53,7 +53,7 @@ static void updateVariable(CAnimatedVariable<VarType>& av, const float POINTY, b
 
 static void updateColorVariable(CAnimatedVariable<CHyprColor>& av, const float POINTY, bool warp) {
     if (warp || av.value() == av.goal()) {
-        av.warp();
+        av.warp(true, false);
         return;
     }
 

src/protocols/core/Compositor.cpp

@@ -308,9 +308,7 @@ void CWLSurfaceResource::breadthfirst(std::function<void(SP<CWLSurfaceResource>,
 
 std::pair<SP<CWLSurfaceResource>, Vector2D> CWLSurfaceResource::at(const Vector2D& localCoords, bool allowsInput) {
     std::vector<std::pair<SP<CWLSurfaceResource>, Vector2D>> surfs;
-    breadthfirst([](SP<CWLSurfaceResource> surf, const Vector2D& offset,
-                    void* data) { ((std::vector<std::pair<SP<CWLSurfaceResource>, Vector2D>>*)data)->emplace_back(std::make_pair<>(surf, offset)); },
-                 &surfs);
+    breadthfirst([&surfs](SP<CWLSurfaceResource> surf, const Vector2D& offset, void* data) { surfs.emplace_back(std::make_pair<>(surf, offset)); }, &surfs);
 
     for (auto const& [surf, pos] : surfs | std::views::reverse) {
         if (!allowsInput) {