[feat] smartgaps: Hide gaps if showing a single window

Currently disabled by default but adds a toggle that will hide gaps if
only a single window is visible.

The feature is implemented both in the cpp and ts engines.

Author: defer

src/config/bismuth_config.kcfg

@@ -163,6 +163,11 @@
       <default>0</default>
     </entry>
 
+    <entry name="smartGaps" type="Bool">
+      <label>Hide gaps if showing a single window</label>
+      <default>false</default>
+    </entry>
+
     <entry name="limitTileWidth" type="Bool">
       <label>Limit the width of tiles</label>
       <default>false</default>

src/core/engine/engine.cpp

@@ -230,11 +230,11 @@ Surface Engine::activeSurface() const
 void Engine::arrangeWindowsOnSurface(const Surface &surface)
 {
     auto &layout = m_activeLayouts.layoutOnSurface(surface);
-    auto tilingArea = layout.tilingArea(workingArea(surface));
 
     auto visibleWindows = m_windows.visibleWindowsOn(surface);
     auto windowsThatCanBeTiled = visibleWindows; // TODO: Filter windows
 
+    auto tilingArea = layout.tilingArea(workingArea(surface), windowsThatCanBeTiled);
     layout.apply(tilingArea, windowsThatCanBeTiled);
 }
 

src/core/engine/layout/layout.cpp

@@ -10,8 +10,12 @@ Layout::Layout(const Bismuth::Config &config)
 {
 }
 
-QRect Layout::tilingArea(QRect workingArea) const
+QRect Layout::tilingArea(QRect workingArea, std::vector<Window> &windows) const
 {
+    if (windows.size() == 1 && m_config.smartGaps()) {
+        return workingArea;
+    }
+
     auto marginLeft = m_config.screenGapLeft();
     auto marginTop = m_config.screenGapTop();
     auto marginRight = m_config.screenGapRight();

src/core/engine/layout/layout.hpp

@@ -24,7 +24,7 @@ struct Layout {
     /**
      * Get the area on which tiled windows could be placed given the general @p workingArea
      */
-    virtual QRect tilingArea(QRect workingArea) const;
+    virtual QRect tilingArea(QRect workingArea, std::vector<Window> &windows) const;
 
 protected:
     const Bismuth::Config &m_config;

src/core/ts-proxy.cpp

@@ -75,6 +75,7 @@ QJSValue TSProxy::jsConfig()
     setProp("screenGapRight", m_config.screenGapRight());
     setProp("screenGapTop", m_config.screenGapTop());
     setProp("tileLayoutGap", m_config.tileLayoutGap());
+    setProp("smartGaps", m_config.smartGaps());
 
     setProp("newWindowAsMaster", m_config.newWindowAsMaster());
     setProp("layoutPerActivity", m_config.layoutPerActivity());

src/kcm/package/contents/ui/Appearance.qml

@@ -41,6 +41,11 @@ Kirigami.FormLayout {
         Kirigami.FormData.label: "Inner Gaps"
     }
 
+    BIC.ConfigCheckBox {
+        text: i18n("Hide gaps if showing a single window")
+        settingName: "smartGaps"
+    }
+
     BIC.PixelsConfigSpinBox {
         Kirigami.FormData.label: i18n("All:")
         settingName: "tileLayoutGap"

src/kwinscript/config.ts

@@ -26,6 +26,7 @@ export interface Config {
   screenGapRight: number;
   screenGapTop: number;
   tileLayoutGap: number;
+  smartGaps: boolean;
   //#endregion
 
   //#region Behavior

src/kwinscript/engine/index.ts

@@ -191,13 +191,16 @@ export class EngineImpl implements Engine {
     const srf = basis.surface;
     const layout = this.layouts.getCurrentLayout(srf);
     if (layout.adjust) {
-      const area = srf.workingArea.gap(
-        this.config.screenGapLeft,
-        this.config.screenGapRight,
-        this.config.screenGapTop,
-        this.config.screenGapBottom
-      );
       const tiles = this.windows.visibleTiledWindowsOn(srf);
+      const noGaps = tiles.length == 1 && this.config.smartGaps;
+      const area = noGaps
+        ? srf.workingArea
+        : srf.workingArea.gap(
+            this.config.screenGapLeft,
+            this.config.screenGapRight,
+            this.config.screenGapTop,
+            this.config.screenGapBottom
+          );
       layout.adjust(area, tiles, basis, basis.geometryDelta);
     }
   }
@@ -285,18 +288,17 @@ export class EngineImpl implements Engine {
 
     const layout = this.layouts.getCurrentLayout(srf);
     if (layout.adjust) {
-      const area = srf.workingArea.gap(
-        this.config.screenGapLeft,
-        this.config.screenGapRight,
-        this.config.screenGapTop,
-        this.config.screenGapBottom
-      );
-      layout.adjust(
-        area,
-        this.windows.visibleTileableWindowsOn(srf),
-        basis,
-        delta
-      );
+      const tiles = this.windows.visibleTiledWindowsOn(srf);
+      const noGaps = tiles.length == 1 && this.config.smartGaps;
+      const area = noGaps
+        ? srf.workingArea
+        : srf.workingArea.gap(
+            this.config.screenGapLeft,
+            this.config.screenGapRight,
+            this.config.screenGapTop,
+            this.config.screenGapBottom
+          );
+      layout.adjust(area, tiles, basis, delta);
     }
   }
 
@@ -330,9 +332,8 @@ export class EngineImpl implements Engine {
     const layout = this.layouts.getCurrentLayout(screenSurface);
 
     const workingArea = screenSurface.workingArea;
-    const tilingArea = this.getTilingArea(workingArea, layout);
-
     const visibleWindows = this.windows.visibleWindowsOn(screenSurface);
+    const tilingArea = this.getTilingArea(workingArea, layout, visibleWindows);
 
     // Set correct window state for new windows
     visibleWindows.forEach((win: EngineWindow) => {
@@ -740,9 +741,17 @@ export class EngineImpl implements Engine {
    *
    * @param workingArea area in which we are allowed to work. @see DriverSurface#workingArea
    * @param layout windows layout used
+   * @param visibleWindows the windows visible in the working area.
    */
-  private getTilingArea(workingArea: Rect, layout: WindowsLayout): Rect {
-    if (this.config.monocleMaximize && layout instanceof MonocleLayout) {
+  private getTilingArea(
+    workingArea: Rect,
+    layout: WindowsLayout,
+    visibleWindows: EngineWindow[]
+  ): Rect {
+    if (
+      (this.config.monocleMaximize && layout instanceof MonocleLayout) ||
+      (visibleWindows.length == 1 && this.config.smartGaps)
+    ) {
       return workingArea;
     } else {
       return workingArea.gap(