input: Various constraint handling fixes (#3381)

Fixes #3204

src/helpers/Monitor.hpp

@@ -59,6 +59,7 @@ class CMonitor {
     bool                scheduledRecalc = false;
     wl_output_transform transform       = WL_OUTPUT_TRANSFORM_NORMAL;
     bool                gammaChanged    = false;
+    float               xwaylandScale   = 1.f;
 
     bool                dpmsStatus    = true;
     bool                vrrActive     = false; // this can be TRUE even if VRR is not active in the case that this display does not support it.

src/helpers/Region.cpp

@@ -1,5 +1,6 @@
 #include "Region.hpp"
 #include <wlr/util/box.h>
+#include <wlr/util/region.h>
 
 CRegion::CRegion() {
     pixman_region32_init(&m_rRegion);
@@ -81,6 +82,11 @@ CRegion& CRegion::translate(const Vector2D& vec) {
     return *this;
 }
 
+CRegion& CRegion::scale(float scale) {
+    wlr_region_scale(&m_rRegion, &m_rRegion, scale);
+    return *this;
+}
+
 std::vector<pixman_box32_t> CRegion::getRects() const {
     std::vector<pixman_box32_t> result;
 
@@ -97,15 +103,15 @@ wlr_box CRegion::getExtents() {
     return {box->x1, box->y1, box->x2 - box->x1, box->y2 - box->y1};
 }
 
-bool CRegion::containsPoint(const Vector2D& vec) {
+bool CRegion::containsPoint(const Vector2D& vec) const {
     return pixman_region32_contains_point(&m_rRegion, vec.x, vec.y, nullptr);
 }
 
-bool CRegion::empty() {
+bool CRegion::empty() const {
     return !pixman_region32_not_empty(&m_rRegion);
 }
 
-Vector2D CRegion::closestPoint(const Vector2D& vec) {
+Vector2D CRegion::closestPoint(const Vector2D& vec) const {
     double   bestDist = __FLT_MAX__;
     Vector2D leader   = vec;
 

src/helpers/Region.hpp

@@ -42,15 +42,16 @@ class CRegion {
     CRegion&                    intersect(double x, double y, double w, double h);
     CRegion&                    translate(const Vector2D& vec);
     CRegion&                    invert(pixman_box32_t* box);
+    CRegion&                    scale(float scale);
     wlr_box                     getExtents();
-    bool                        containsPoint(const Vector2D& vec);
-    bool                        empty();
-    Vector2D                    closestPoint(const Vector2D& vec);
+    bool                        containsPoint(const Vector2D& vec) const;
+    bool                        empty() const;
+    Vector2D                    closestPoint(const Vector2D& vec) const;
 
     std::vector<pixman_box32_t> getRects() const;
 
     pixman_region32_t*          pixman() {
-        return &m_rRegion;
+                 return &m_rRegion;
     }
 
   private:

src/helpers/WLClasses.cpp

@@ -1,5 +1,6 @@
 #include "WLClasses.hpp"
 #include "../config/ConfigManager.hpp"
+#include "../Compositor.hpp"
 
 SLayerSurface::SLayerSurface() {
     alpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), nullptr, AVARDAMAGE_ENTIRE);
@@ -37,4 +38,80 @@ void SLayerSurface::applyRules() {
             } catch (...) {}
         }
     }
+}
+
+CRegion SConstraint::getLogicCoordsRegion() {
+    CRegion result;
+
+    if (!constraint)
+        return result;
+
+    const auto PWINDOWOWNER = g_pCompositor->getWindowFromSurface(constraint->surface);
+
+    if (!PWINDOWOWNER)
+        return result;
+
+    result.add(&constraint->region); // surface-local coords
+
+    if (!PWINDOWOWNER->m_bIsX11) {
+        result.translate(PWINDOWOWNER->m_vRealPosition.goalv());
+        return result;
+    }
+
+    const auto COORDS = PWINDOWOWNER->m_bIsMapped ? PWINDOWOWNER->m_vRealPosition.goalv() :
+                                                    g_pXWaylandManager->xwaylandToWaylandCoords({PWINDOWOWNER->m_uSurface.xwayland->x, PWINDOWOWNER->m_uSurface.xwayland->y});
+
+    const auto PMONITOR = PWINDOWOWNER->m_bIsMapped ? g_pCompositor->getMonitorFromID(PWINDOWOWNER->m_iMonitorID) : g_pCompositor->getMonitorFromVector(COORDS);
+
+    if (!PMONITOR)
+        return CRegion{};
+
+    result.scale(PMONITOR->xwaylandScale);
+
+    result.translate(COORDS);
+
+    return result;
+}
+
+Vector2D SConstraint::getLogicConstraintPos() {
+    if (!constraint)
+        return {};
+
+    const auto PWINDOWOWNER = g_pCompositor->getWindowFromSurface(constraint->surface);
+
+    if (!PWINDOWOWNER)
+        return {};
+
+    if (!PWINDOWOWNER->m_bIsX11)
+        return PWINDOWOWNER->m_vRealPosition.goalv();
+
+    const auto COORDS = PWINDOWOWNER->m_bIsMapped ? PWINDOWOWNER->m_vRealPosition.goalv() :
+                                                    g_pXWaylandManager->xwaylandToWaylandCoords({PWINDOWOWNER->m_uSurface.xwayland->x, PWINDOWOWNER->m_uSurface.xwayland->y});
+
+    return COORDS;
+}
+
+Vector2D SConstraint::getLogicConstraintSize() {
+    if (!constraint)
+        return {};
+
+    const auto PWINDOWOWNER = g_pCompositor->getWindowFromSurface(constraint->surface);
+
+    if (!PWINDOWOWNER)
+        return {};
+
+    if (!PWINDOWOWNER->m_bIsX11)
+        return PWINDOWOWNER->m_vRealSize.goalv();
+
+    const auto PMONITOR = PWINDOWOWNER->m_bIsMapped ?
+        g_pCompositor->getMonitorFromID(PWINDOWOWNER->m_iMonitorID) :
+        g_pCompositor->getMonitorFromVector(g_pXWaylandManager->xwaylandToWaylandCoords({PWINDOWOWNER->m_uSurface.xwayland->x, PWINDOWOWNER->m_uSurface.xwayland->y}));
+
+    if (!PMONITOR)
+        return {};
+
+    const auto SIZE = PWINDOWOWNER->m_bIsMapped ? PWINDOWOWNER->m_vRealSize.goalv() :
+                                                  Vector2D{PWINDOWOWNER->m_uSurface.xwayland->width, PWINDOWOWNER->m_uSurface.xwayland->height} * PMONITOR->xwaylandScale;
+
+    return SIZE;
 }

src/helpers/WLClasses.hpp

@@ -174,8 +174,12 @@ struct SConstraint {
     DYNLISTENER(setConstraintRegion);
     DYNLISTENER(destroyConstraint);
 
-    bool operator==(const SConstraint& b) const {
-        return constraint == b.constraint;
+    CRegion getLogicCoordsRegion();
+    Vector2D getLogicConstraintPos();
+    Vector2D getLogicConstraintSize();
+
+    bool    operator==(const SConstraint& b) const {
+           return constraint == b.constraint;
     }
 };