[plasma/kwin] src/plugins/private: Move ExpoLayout to KWin namespace

Git commit 5cbbf646f8611c989eb6b23fed6b9dbe622f1065 by Vlad Zahorodnii.
Committed on 23/07/2026 at 06:04.
Pushed by vladz into branch 'master'.

Move ExpoLayout to KWin namespace

This allows to get rid of the KWin:: prefix when accessing RectF.

M  +33   -28   src/plugins/private/expolayout.cpp
M  +15   -10   src/plugins/private/expolayout.h
M  +2    -2    src/plugins/private/plugin.cpp

https://invent.kde.org/plasma/kwin/-/commit/5cbbf646f8611c989eb6b23fed6b9dbe622f1065

diff --git a/src/plugins/private/expolayout.cpp b/src/plugins/private/expolayout.cpp
index c07db4cda3b..80584954dad 100644
--- a/src/plugins/private/expolayout.cpp
+++ b/src/plugins/private/expolayout.cpp
@@ -12,6 +12,9 @@
 #include <deque>
 #include <tuple>
 
+namespace KWin
+{
+
 ExpoCell::ExpoCell(QQuickItem *parent)
     : QQuickItem(parent)
 {
@@ -231,9 +234,9 @@ void ExpoCell::setNaturalHeight(qreal height)
     }
 }
 
-KWin::RectF ExpoCell::naturalRect() const
+RectF ExpoCell::naturalRect() const
 {
-    return KWin::RectF(m_naturalX, m_naturalY, m_naturalWidth, m_naturalHeight);
+    return RectF(m_naturalX, m_naturalY, m_naturalWidth, m_naturalHeight);
 }
 
 QMarginsF ExpoCell::margins() const
@@ -281,7 +284,7 @@ void ExpoCell::updateContentItemGeometry()
         return;
     }
 
-    KWin::RectF rect = mapRectToItem(m_contentItem->parentItem(), boundingRect());
+    RectF rect = mapRectToItem(m_contentItem->parentItem(), boundingRect());
 
     rect = {
         rect.x() * m_partialActivationFactor + (m_naturalX + m_offsetX) * (1.0 - m_partialActivationFactor),
@@ -360,7 +363,7 @@ void ExpoLayout::geometryChange(const QRectF &newGeometry, const QRectF &oldGeom
 }
 
 // Move and scale rect to fit inside area
-static void moveToFit(KWin::RectF &rect, const KWin::RectF &area)
+static void moveToFit(RectF &rect, const RectF &area)
 {
     qreal scale = std::min(area.width() / rect.width(), area.height() / rect.height());
     rect.setWidth(rect.width() * scale);
@@ -375,7 +378,7 @@ void ExpoLayout::updatePolish()
         return;
     }
 
-    KWin::RectF area = KWin::RectF(0, 0, width(), height());
+    RectF area = RectF(0, 0, width(), height());
 
     std::sort(m_cells.begin(), m_cells.end(), [](const ExpoCell *a, const ExpoCell *b) {
         return a->persistentKey() < b->persistentKey();
@@ -390,7 +393,7 @@ void ExpoLayout::updatePolish()
     qreal scale = std::sqrt(availableArea / totalArea) * 0.7; // conservative estimate
     scale = std::clamp(scale, 0.1, 10.0); // don't go crazy
 
-    QList<KWin::RectF> windowSizes;
+    QList<RectF> windowSizes;
     for (ExpoCell *cell : std::as_const(m_cells)) {
         const QMarginsF &margins = cell->margins();
         const QMarginsF scaledMargins(margins.left() / scale, margins.top() / scale, margins.right() / scale, margins.bottom() / scale);
@@ -399,14 +402,14 @@ void ExpoLayout::updatePolish()
     auto windowLayouts = ExpoLayout::layout(area, windowSizes);
     for (int i = 0; i < windowLayouts.size(); ++i) {
         ExpoCell *cell = m_cells[i];
-        KWin::RectF target = windowLayouts[i];
+        RectF target = windowLayouts[i];
 
-        KWin::RectF adjustedTarget = target.marginsRemoved(cell->margins());
+        RectF adjustedTarget = target.marginsRemoved(cell->margins());
         if (adjustedTarget.isValid()) {
             target = adjustedTarget; // Borders
         }
 
-        KWin::RectF rect = cell->naturalRect();
+        RectF rect = cell->naturalRect();
         moveToFit(rect, target);
         if (m_ready) {
             // Use setProperty so the QML side can animate with Behavior
@@ -424,7 +427,7 @@ void ExpoLayout::updatePolish()
     setReady();
 }
 
-Layer::Layer(qreal maxWidth, const QList<KWin::RectF> &windowSizes, const QList<size_t> &windowIds, size_t startPos, size_t endPos)
+ExpoLayer::ExpoLayer(qreal maxWidth, const QList<RectF> &windowSizes, const QList<size_t> &windowIds, size_t startPos, size_t endPos)
     : maxWidth(maxWidth)
     , maxHeight(windowSizes[windowIds[endPos - 1]].height())
     , ids(windowIds.begin() + startPos, windowIds.begin() + endPos)
@@ -435,12 +438,12 @@ Layer::Layer(qreal maxWidth, const QList<KWin::RectF> &windowSizes, const QList<
     }
 }
 
-qreal Layer::width() const
+qreal ExpoLayer::width() const
 {
     return maxWidth - remainingWidth;
 }
 
-LayeredPacking::LayeredPacking(qreal maxWidth, const QList<KWin::RectF> &windowSizes, const QList<size_t> &ids, const QList<size_t> &layerStartPos)
+LayeredPacking::LayeredPacking(qreal maxWidth, const QList<RectF> &windowSizes, const QList<size_t> &ids, const QList<size_t> &layerStartPos)
     : maxWidth(maxWidth)
     , width(0)
     , height(0)
@@ -650,9 +653,9 @@ static QMarginsF reflect(const QMarginsF &margins)
 {
     return QMarginsF(margins.top(), margins.right(), margins.bottom(), margins.left());
 }
-static KWin::RectF reflect(const KWin::RectF &rect)
+static RectF reflect(const RectF &rect)
 {
-    return KWin::RectF(rect.y(), rect.x(), rect.height(), rect.width());
+    return RectF(rect.y(), rect.x(), rect.height(), rect.width());
 }
 static QPointF reflect(const QPointF &point)
 {
@@ -669,7 +672,7 @@ static QList<T> reflect(const QList<T> &v)
     return result;
 }
 
-QList<KWin::RectF> ExpoLayout::layout(const KWin::RectF &area, const QList<KWin::RectF> &windowSizes)
+QList<RectF> ExpoLayout::layout(const RectF &area, const QList<RectF> &windowSizes)
 {
     const qreal shortSide = std::min(area.width(), area.height());
     const QMarginsF margins(shortSide * m_relativeMarginLeft,
@@ -677,21 +680,21 @@ QList<KWin::RectF> ExpoLayout::layout(const KWin::RectF &area, const QList<KWin:
                             shortSide * m_relativeMarginRight,
                             shortSide * m_relativeMarginBottom);
     const qreal minLength = m_relativeMinLength * shortSide;
-    const KWin::RectF minSize = KWin::RectF(0, 0, minLength, minLength);
+    const RectF minSize = RectF(0, 0, minLength, minLength);
 
     QList<QPointF> centers;
-    for (const KWin::RectF &windowSize : windowSizes) {
+    for (const RectF &windowSize : windowSizes) {
         centers.push_back(windowSize.center());
     }
 
     // windows bigger than 4x the area are considered ill-behaved and their sizes are clipped
-    const auto adjustedSizes = adjustSizes(minSize, KWin::RectF(0, 0, 4 * area.width(), 4 * area.height()), margins, windowSizes);
+    const auto adjustedSizes = adjustSizes(minSize, RectF(0, 0, 4 * area.width(), 4 * area.height()), margins, windowSizes);
 
     if (placementMode() == PlacementMode::Rows) {
         LayeredPacking bestPacking = findGoodPacking(area, adjustedSizes, centers, m_idealWidthRatio, m_searchTolerance);
         return refineAndApplyPacking(area, margins, bestPacking, adjustedSizes, centers);
     } else {
-        QList<KWin::RectF> adjustedSizesReflected(reflect(adjustedSizes));
+        QList<RectF> adjustedSizesReflected(reflect(adjustedSizes));
         QList<QPointF> centersReflected(reflect(centers));
 
         LayeredPacking bestPacking = findGoodPacking(area.transposed(), adjustedSizesReflected, centersReflected, m_idealWidthRatio, m_searchTolerance);
@@ -699,10 +702,10 @@ QList<KWin::RectF> ExpoLayout::layout(const KWin::RectF &area, const QList<KWin:
     }
 }
 
-QList<KWin::RectF> ExpoLayout::adjustSizes(const KWin::RectF &minSize, const KWin::RectF &maxSize, const QMarginsF &margins, const QList<KWin::RectF> &windowSizes)
+QList<RectF> ExpoLayout::adjustSizes(const RectF &minSize, const RectF &maxSize, const QMarginsF &margins, const QList<RectF> &windowSizes)
 {
-    QList<KWin::RectF> adjustedSizes;
-    for (KWin::RectF windowSize : windowSizes) {
+    QList<RectF> adjustedSizes;
+    for (RectF windowSize : windowSizes) {
         windowSize.setWidth(std::clamp(windowSize.width(), minSize.width(), maxSize.width()));
         windowSize.setHeight(std::clamp(windowSize.height(), minSize.height(), maxSize.height()));
         windowSize += margins;
@@ -712,9 +715,9 @@ QList<KWin::RectF> ExpoLayout::adjustSizes(const KWin::RectF &minSize, const KWi
 }
 
 LayeredPacking
-ExpoLayout::findGoodPacking(const KWin::RectF &area, const QList<KWin::RectF> &windowSizes, const QList<QPointF> &centers, qreal idealWidthRatio, qreal tol)
+ExpoLayout::findGoodPacking(const RectF &area, const QList<RectF> &windowSizes, const QList<QPointF> &centers, qreal idealWidthRatio, qreal tol)
 {
-    QList<std::tuple<size_t, KWin::RectF, QPointF>> windowSizesWithIds;
+    QList<std::tuple<size_t, RectF, QPointF>> windowSizesWithIds;
 
     for (int i = 0; i < windowSizes.size(); ++i) {
         windowSizesWithIds.emplace_back(i, windowSizes[i], centers[i]);
@@ -803,7 +806,7 @@ ExpoLayout::findGoodPacking(const KWin::RectF &area, const QList<KWin::RectF> &w
     }
 }
 
-QList<KWin::RectF> ExpoLayout::refineAndApplyPacking(const KWin::RectF &area, const QMarginsF &margins, const LayeredPacking &packing, const QList<KWin::RectF> &windowSizes, const QList<QPointF> &centers)
+QList<RectF> ExpoLayout::refineAndApplyPacking(const RectF &area, const QMarginsF &margins, const LayeredPacking &packing, const QList<RectF> &windowSizes, const QList<QPointF> &centers)
 {
     // Scale packing to fit area
     qreal scale = std::min(area.width() / packing.width, area.height() / packing.height);
@@ -821,7 +824,7 @@ QList<KWin::RectF> ExpoLayout::refineAndApplyPacking(const KWin::RectF &area, co
     qreal gapY = std::min(maxGapY, extraY / (packing.layers.size() + 1));
     qreal y = area.y() + (extraY - gapY * (packing.layers.size() - 1)) / 2;
 
-    QList<KWin::RectF> finalWindowLayouts(windowSizes);
+    QList<RectF> finalWindowLayouts(windowSizes);
     // smaller windows "float" to the top
     for (const auto &layer : packing.layers) {
         qreal extraX = area.width() - layer.width() * scale;
@@ -833,9 +836,9 @@ QList<KWin::RectF> ExpoLayout::refineAndApplyPacking(const KWin::RectF &area, co
             return centers[a].x() < centers[b].x(); // minimize horizontal movement
         });
         for (auto id : std::as_const(ids)) {
-            KWin::RectF &windowLayout = finalWindowLayouts[id];
+            RectF &windowLayout = finalWindowLayouts[id];
             qreal newY = y + (layer.maxHeight - windowLayout.height()) * scale / 2; // center align y
-            windowLayout = KWin::RectF(x, newY, windowLayout.width() * scale, windowLayout.height() * scale);
+            windowLayout = RectF(x, newY, windowLayout.width() * scale, windowLayout.height() * scale);
             x += windowLayout.width() + gapX;
             windowLayout -= scaledMargins;
         }
@@ -844,4 +847,6 @@ QList<KWin::RectF> ExpoLayout::refineAndApplyPacking(const KWin::RectF &area, co
     return finalWindowLayouts;
 }
 
+}
+
 #include "moc_expolayout.cpp"
diff --git a/src/plugins/private/expolayout.h b/src/plugins/private/expolayout.h
index 69db73ae8ab..b6230d7e872 100644
--- a/src/plugins/private/expolayout.h
+++ b/src/plugins/private/expolayout.h
@@ -13,8 +13,11 @@
 #include <QObject>
 #include <QQuickItem>
 
+namespace KWin
+{
+
 class ExpoCell;
-struct Layer;
+struct ExpoLayer;
 struct LayeredPacking;
 
 /**
@@ -115,14 +118,14 @@ protected:
      *
      * This is the main entry point for the layout algorithm.
      */
-    QList<KWin::RectF> layout(const KWin::RectF &area, const QList<KWin::RectF> &windowSizes);
+    QList<RectF> layout(const RectF &area, const QList<RectF> &windowSizes);
 
     /**
      * @brief First clip @param windowSizes to be between @param minSize and
      * @param maxSize. Then add @param margins to each window size, and @return
      * the adjusted window sizes.
      */
-    QList<KWin::RectF> adjustSizes(const KWin::RectF &minSize, const KWin::RectF &maxSize, const QMarginsF &margins, const QList<KWin::RectF> &windowSizes);
+    QList<RectF> adjustSizes(const RectF &minSize, const RectF &maxSize, const QMarginsF &margins, const QList<RectF> &windowSizes);
 
     /**
      * @brief Use binary search to find a good packing of the @param windowSizes
@@ -144,7 +147,7 @@ protected:
      * Since we clip the window size, this is just O(n log n log log n)
      */
     LayeredPacking
-    findGoodPacking(const KWin::RectF &area, const QList<KWin::RectF> &windowSizes, const QList<QPointF> &centers, qreal idealWidthRatio, qreal tol);
+    findGoodPacking(const RectF &area, const QList<RectF> &windowSizes, const QList<QPointF> &centers, qreal idealWidthRatio, qreal tol);
 
     /**
      * @brief LogicalOutput the final window layouts from the packing.
@@ -154,7 +157,7 @@ protected:
      * and @return the final layout.
      * In each layer, sort the windows by x coordinates of the @param centers.
      */
-    QList<KWin::RectF> refineAndApplyPacking(const KWin::RectF &area, const QMarginsF &margins, const LayeredPacking &packing, const QList<KWin::RectF> &windowSizes, const QList<QPointF> &centers);
+    QList<RectF> refineAndApplyPacking(const RectF &area, const QMarginsF &margins, const LayeredPacking &packing, const QList<RectF> &windowSizes, const QList<QPointF> &centers);
 
 Q_SIGNALS:
     void placementModeChanged();
@@ -237,7 +240,7 @@ public:
     qreal naturalHeight() const;
     void setNaturalHeight(qreal height);
 
-    KWin::RectF naturalRect() const;
+    RectF naturalRect() const;
     QMarginsF margins() const;
 
     QString persistentKey() const;
@@ -287,7 +290,7 @@ private:
  * @brief Each Layer is a horizontal strip of windows with a maximum width and
  * height.
  */
-struct Layer
+struct ExpoLayer
 {
     qreal maxWidth;
     qreal maxHeight;
@@ -313,7 +316,7 @@ struct Layer
      * @param startPos windowIds[startPos] is the first window in this layer.
      * @param endPos windowIds[endPos-1] is the last window in this layer.
      */
-    Layer(qreal maxWidth, const QList<KWin::RectF> &windowSizes, const QList<size_t> &windowIds, size_t startPos, size_t endPos);
+    ExpoLayer(qreal maxWidth, const QList<RectF> &windowSizes, const QList<size_t> &windowIds, size_t startPos, size_t endPos);
 
     /**
      * @brief The total width of all the windows in this layer.
@@ -331,7 +334,7 @@ struct LayeredPacking
     qreal maxWidth;
     qreal width;
     qreal height;
-    QList<Layer> layers;
+    QList<ExpoLayer> layers;
 
     /**
      * @brief Construct a new LayeredPacking object from a list of windows
@@ -343,5 +346,7 @@ struct LayeredPacking
      * @param layerStartPos Array of indices into ids that indicate the start
      * of a new layer. Must start with 0 and end with ids.size().
      */
-    LayeredPacking(qreal maxWidth, const QList<KWin::RectF> &windowSizes, const QList<size_t> &ids, const QList<size_t> &layerStartPos);
+    LayeredPacking(qreal maxWidth, const QList<RectF> &windowSizes, const QList<size_t> &ids, const QList<size_t> &layerStartPos);
 };
+
+}
diff --git a/src/plugins/private/plugin.cpp b/src/plugins/private/plugin.cpp
index 014954363be..9e4ec16ee58 100644
--- a/src/plugins/private/plugin.cpp
+++ b/src/plugins/private/plugin.cpp
@@ -11,8 +11,8 @@
 void EffectKitExtensionPlugin::registerTypes(const char *uri)
 {
     qmlRegisterType<KWin::ExpoArea>(uri, 1, 0, "ExpoArea");
-    qmlRegisterType<ExpoLayout>(uri, 1, 0, "ExpoLayout");
-    qmlRegisterType<ExpoCell>(uri, 1, 0, "ExpoCell");
+    qmlRegisterType<KWin::ExpoLayout>(uri, 1, 0, "ExpoLayout");
+    qmlRegisterType<KWin::ExpoCell>(uri, 1, 0, "ExpoCell");
 }
 
 #include "moc_plugin.cpp"