1 files changed, 134 insertions, 0 deletions
diff --git a/config/quickshell/qs-hyprview-trixie/layouts/SmartGridLayout.qml b/config/quickshell/qs-hyprview-trixie/layouts/SmartGridLayout.qml
new file mode 100644
index 00000000..6207d19c
--- /dev/null
+++ b/config/quickshell/qs-hyprview-trixie/layouts/SmartGridLayout.qml
@@ -0,0 +1,134 @@
+pragma Singleton
+import Quickshell
+
+Singleton {
+    id: root
+
+    function doLayout(windowList, outerWidth, outerHeight) {
+        var N = windowList.length
+        if (N === 0) return []
+        if (outerWidth <= 0 || outerHeight <= 0) return []
+
+        var gap = Math.min(outerWidth * 0.03, outerHeight * 0.03)
+
+        // --- 0. DEFINIZIONE AREA SICURA (SCALATA) ---
+        // Riduciamo l'area di calcolo al 90% per lasciare spazio alle animazioni hover
+        var contentScale = 0.9
+        var usableW = outerWidth * contentScale
+        var usableH = outerHeight * contentScale
+
+        // --- 1. TROVARE LA SCALA OTTIMALE ---
+        // Usiamo usableW/H per decidere la dimensione delle finestre
+        var TARGET_ASPECT = 16.0 / 9.0
+        var bestCols = 1
+        var bestRows = 1
+        var bestScale = 0
+
+        for (var cols = 1; cols <= N; cols++) {
+            var rows = Math.ceil(N / cols)
+
+            // Calcoliamo lo spazio basandoci sull'area ridotta
+            var availW = usableW - gap * (cols - 1)
+            var availH = usableH - gap * (rows - 1)
+
+            if (availW <= 0 || availH <= 0) continue
+
+            var cellW = availW / cols
+            var cellH = availH / rows
+
+            var scaleW = cellW / TARGET_ASPECT
+            var scaleH = cellH / 1.0
+            var currentScale = Math.min(scaleW, scaleH)
+
+            if (currentScale > bestScale) {
+                bestScale = currentScale
+                bestCols = cols
+                bestRows = rows
+            }
+        }
+
+        // --- 2. CALCOLO DIMENSIONI REALI ---
+
+        // Ricalcoliamo i limiti cella basati sull'area ridotta
+        var finalAvailW = usableW - gap * (bestCols - 1)
+        var finalAvailH = usableH - gap * (bestRows - 1)
+        var maxCellW = finalAvailW / bestCols
+        var maxCellH = finalAvailH / bestRows
+
+        // --- 3. POSIZIONAMENTO (CENTRATO NELL'AREA TOTALE) ---
+
+        // Calcoliamo l'altezza totale del blocco di contenuto
+        var totalGridContentH = bestRows * maxCellH + (bestRows - 1) * gap
+
+        // Per centrare verticalmente, usiamo l'outerHeight REALE (al 100%)
+        // In questo modo il blocco ridotto (90%) finisce esattamente al centro dello schermo fisico
+        var startOffsetY = (outerHeight - totalGridContentH) / 2
+
+        var result = []
+
+        // Iteriamo per RIGA
+        for (var r = 0; r < bestRows; r++) {
+            var rowItems = []
+            var startIndex = r * bestCols
+            var endIndex = Math.min(startIndex + bestCols, N)
+
+            if (startIndex >= N) break
+
+            var totalRowContentWidth = 0
+
+            // Fase 3a: Calcolo dimensioni miniature (Packed)
+            for (var i = startIndex; i < endIndex; i++) {
+                var item = windowList[i]
+                var w0 = (item.width && item.width > 0) ? item.width : 100
+                var h0 = (item.height && item.height > 0) ? item.height : 100
+
+                // Scala calcolata sui limiti "sicuri" (90%)
+                var scale = Math.min(maxCellW / w0, maxCellH / h0)
+
+                var thumbW = w0 * scale
+                var thumbH = h0 * scale
+
+                rowItems.push({
+                    originalItem: item,
+                    width: thumbW,
+                    height: thumbH,
+                    index: i,
+                    col: i - startIndex
+                })
+
+                totalRowContentWidth += thumbW
+            }
+
+            // Aggiungiamo i gap totali della riga
+            if (rowItems.length > 1) {
+                totalRowContentWidth += (rowItems.length - 1) * gap
+            }
+
+            // Fase 3b: Posizionamento X
+            // Anche qui, usiamo outerWidth REALE per centrare il blocco riga nello schermo intero
+            var currentX = (outerWidth - totalRowContentWidth) / 2
+            var cellAbsY = startOffsetY + r * (maxCellH + gap)
+
+            for (var k = 0; k < rowItems.length; k++) {
+                var rItem = rowItems[k]
+
+                // Centratura verticale nella fascia
+                var currentY = cellAbsY + (maxCellH - rItem.height) / 2
+
+                result.push({
+                    win: rItem.originalItem.win,
+                    x: currentX,
+                    y: currentY,
+                    width: rItem.width,
+                    height: rItem.height,
+                    rowIndex: r,
+                    colIndex: rItem.col
+                })
+
+                currentX += rItem.width + gap
+            }
+        }
+
+        return result
+    }
+}