v0.1.4: reserve_margin + panelbaserad zon + reservationsdemo i docs

- Zonen mäts på synliga panelen (inte fönstret med skuggutrymme) —
  maximerade fönster kommer ~20px närmare docken direkt
- Ny inställning reserve_margin (även i settings → Layout): finjustera
  avståndet mellan panel och maximerade fönster; minus tillåtet
- README + wiki: före/efter-bild som demonstrerar reservationen

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Cargo.lock

@@ -1042,7 +1042,7 @@ checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
 name = "waydock"
-version = "0.1.0"
+version = "0.1.4"
 dependencies = [
  "async-channel",
  "gtk4",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "waydock"
-version = "0.1.0"
+version = "0.1.4"
 edition = "2021"
 description = "Modern, resurssnål dock för Wayfire — transparent, JSON-konfigurerad, per-skärm"
 license = "MIT"

README.md

@@ -6,6 +6,46 @@ Rust/GTK4 som **en enda binär**. Pinnade appar, körande fönster med
 gruppering, per-skärm-kontext, konfigurerbara menyer, settings-GUI och
 live-omladdning av JSON-configen.
 
+## Skärmbilder
+
+![waydock](assets/screenshots/dock-hero.png)
+
+| Dockan (pins, grupper, indikatorer) | Inställningar (per skärm, live) |
+|---|---|
+| ![dock](assets/screenshots/dock-closeup.png) | ![settings](assets/screenshots/settings.png) |
+
+Samma dock, sex olika configar — bara JSON-filen ändrades mellan bilderna:
+
+![galleri](assets/screenshots/gallery.png)
+
+## Vad kan konfigureras?
+
+- **Placering**: nere/uppe/vänster/höger; centrerad/vänster-/högerjusterad ö
+  eller expanderad över hela kanten; tre marginaler (från kanten + start/slut,
+  minusvärden ok) — med ritad illustration i settings som visar måtten
+- **Utseende**: panelfärg + transparens, accentfärg, hörnradie, kant, skugga,
+  ikonstorlek/-avstånd, hover-zoom, animationer, indikatorstil
+- **Beteende**: klick (fokus/minimera/växla), mittklick, skroll (växla fönster
+  eller starta stoppad app), gruppering, fönsterlista vid klick eller hover,
+  peek/fokus vid hover i listan, tooltips, urgency-puls
+- **Menyer**: välj exakt vilka val högerklicksmenyn ska ha
+  (minimera/maximera/flytta till skärm/pinna/stäng)
+- **Per skärm**: vilken inställning som helst kan överridas per skärm —
+  egna pins, position, färger, filter för bara-den-skärmens-fönster
+- **Reservera plats**: maximerade fönster stannar vid docklinjen i stället
+  för att täcka dockan — finjustera avståndet med `reserve_margin`
+  (0 = kant i kant, minus = ännu närmare). Fungerar ihop med autohide:
+
+  ![reservera plats](assets/screenshots/reserve-demo.png)
+
+- **Autohide**: dodge (göm vid fönsteröverlapp) eller göm alltid, med
+  sensor vid kanten och animation
+- **Hotspots**: hot corners/edges som kör kommandon eller Wayfire-IPC
+  (t.ex. scale-översikten)
+
+Allt via `~/.config/waydock/config.json` (live-omladdning) **eller**
+settings-GUI:t — högerklicka på tom dockyta → Inställningar…
+
 - Config: `~/.config/waydock/config.json` (skapas automatiskt första starten)
 - Djupare docs: [`doc/plan.md`](doc/plan.md),
   [`doc/architecture.md`](doc/architecture.md),

doc/plan.md

@@ -42,6 +42,8 @@ skriver samma fil. Schema dokumenteras i `doc/usage.md`.
 ## Milestones
 
 1. **M0 Scaffold** — repo, docs, CI, VS Code-tasks, release-flöde *(klar)*
+   (M1–M7 klara 2026-08-30 — v0.1.0 släppt: binär 1,6 MB, en-raders-install
+   verifierad, repot publikt. M8 klar — waydock är Wayfire-DE:s dock.)
 2. **M1 Panelskelett** — layer-shell-fönster per skärm; position
    (top/bottom/left/right), centrering, marginal, layer, exclusive zone;
    CSS-pipeline från config (bakgrund/opacity/radie/skugga/kant);
@@ -64,8 +66,8 @@ skriver samma fil. Schema dokumenteras i `doc/usage.md`.
    hot corners/edges med exec- eller IPC-actions
 8. **M7 Polish & släpp** — profilering (mål: 0 % CPU i vila, < 70 MB RAM),
    release v0.1.0, wiki-docs
-9. **M8 Wayfire-DE-integration** — ersätt `autostart/11-dock.sh`
-   (sfwbar) med waydock, pensionera sfwbar-configen
+9. **M8 Wayfire-DE-integration** *(klar 2026-08-30)* — `autostart/11-dock.sh`
+   kör waydock, sfwbar-configen pensionerad
 
 ## Roadmap / expansions (överenskomna)
 

doc/usage.md

@@ -7,6 +7,7 @@ waydock                      # normal start
 waydock --log debug          # pratigare logg till stderr
 waydock --log-file ~/.cache/waydock.log
 waydock --config /annan/väg.json
+waydock --settings              # öppna inställningsfönstret direkt
 ```
 
 Vid första start skapas `~/.config/waydock/config.json` med defaults.
@@ -44,6 +45,14 @@ inställningar; "Återställ skärmen till globalt" tar bort dem.
 
 ## Configreferens (`config.json`)
 
+I korthet kan du styra: **placering** (kant, justering, ö/expanderad,
+marginaler), **utseende** (färger, transparens, radie, skugga, ikoner,
+indikatorer, animationer), **beteende** (klick/mittklick/skroll,
+gruppering, fönsterlistans öppning och hover-effekt), **menyinnehåll**,
+**specialknappar**, **per-skärm-överridar**, **autohide/dodge**,
+**hotspots** och **loggning**. Exempelgalleri med färdiga teman finns i
+[wikin](https://gitea.brasse-pc.eu/brasse/waydock/wiki/Konfiguration).
+
 ```jsonc
 {
   "position": "bottom",        // bottom | top | left | right
@@ -55,7 +64,13 @@ inställningar; "Återställ skärmen till globalt" tar bort dem.
                                // skuggutrymme läggs aldrig på förankrade sidor,
                                // så 0 = verkligen kant i kant
   "layer": "top",              // top | overlay | bottom (always-on-top = overlay)
-  "avoid_windows": false,      // true = reservera plats (exclusive zone)
+  "reserve_margin": 0,         // extra px ovanpå reservationen: 0 = fönster ända
+                               // till panelkanten, minus = ännu närmare (in i
+                               // skuggan), plus = luft mellan panel och fönster
+  "avoid_windows": false,      // true = reservera plats: maximerade fönster
+                               // stannar vid dockan. Funkar IHOP med autohide —
+                               // då gömmer dodge bara för fönster du själv
+                               // drar in över dockan
 
   "appearance": {
     "background": "#222222",   // panelfärg

install.sh

@@ -13,9 +13,11 @@ command -v gtk4-launch >/dev/null 2>&1 || \
 
 mkdir -p "$DEST"
 echo "Hämtar waydock (latest)…"
-curl -fSL -o "$DEST/waydock" \
+# temp + mv: atomiskt byte som funkar även när waydock kör (ETXTBSY)
+curl -fSL -o "$DEST/waydock.new" \
   "$BASE/releases/download/latest/waydock-latest-linux-x64"
-chmod +x "$DEST/waydock"
+chmod +x "$DEST/waydock.new"
+mv -f "$DEST/waydock.new" "$DEST/waydock"
 
 # ikon + .desktop-fil
 mkdir -p "$HOME/.local/share/icons/hicolor/scalable/apps" "$HOME/.local/share/applications"

src/config.rs

@@ -312,6 +312,10 @@ pub struct Config {
     pub expand: bool,
     /// avstånd från kanten baren ligger mot (px)
     pub margin: i32,
+    /// extra marginal ovanpå det reserverade området (px). 0 = fönster
+    /// maximeras ända till panelens kant; minus låter dem gå närmare
+    /// (in i skuggan), plus ger luft mellan panel och fönster
+    pub reserve_margin: i32,
     /// marginal i början av kanten: vänster (topp/botten) resp. topp (vänster/höger)
     pub margin_start: i32,
     /// marginal i slutet av kanten: höger resp. botten
@@ -336,6 +340,7 @@ impl Default for Config {
             alignment: Alignment::Center,
             expand: false,
             margin: 8,
+            reserve_margin: 0,
             margin_start: 0,
             margin_end: 0,
             layer: Layer::Top,

src/dock.rs

@@ -53,15 +53,21 @@ pub struct Ctx {
 
 pub struct Dock {
     pub window: gtk::ApplicationWindow,
+    pub panel: gtk::Box,
     pub items_box: gtk::Box,
     pub revealer: gtk::Revealer,
     pub connector: String,
     /// pekaren är över dockan just nu
     pub hover: Cell<bool>,
+    /// pekaren är på väcknings-sensorn vid kanten
+    pub sensor_hover: Cell<bool>,
     /// dockan är undan-gömd av autohide
     pub hidden: Cell<bool>,
     /// något fönster överlappar dockans kantzon (dodge)
     pub dodge_overlap: Cell<bool>,
+    /// senaste synliga storlek längs huvudaxeln (px) — används för
+    /// exclusive zone och dodge-djup även när docken är gömd
+    pub main_size: Cell<i32>,
     /// generationsräknare för fördröjd göm-timer
     hide_generation: Cell<u64>,
     /// sensorremsan som väcker dockan när den är gömd
@@ -113,14 +119,17 @@ fn configure_layer(win: &gtk::ApplicationWindow, cfg: &Config, monitor: &gdk::Mo
     let (side_start, side_end) = side_edges(&cfg.position);
     win.set_anchor(edge, true);
     win.set_margin(edge, cfg.margin);
-    if cfg.expand {
-        // täck hela kanten; start/slut-marginalerna drar in baren
+    // exclusive zone honoreras bara för ytor som är förankrade i EN kant
+    // eller spänner kanten (spec + Wayfires tolkning) — så med reservera
+    // plats spänner ytan alltid kanten; ön ritas ändå som en ö via
+    // panelens alignment (flankerna är transparenta)
+    if cfg.expand || cfg.avoid_windows {
         win.set_anchor(side_start, true);
         win.set_anchor(side_end, true);
-        win.set_margin(side_start, cfg.margin_start);
-        win.set_margin(side_end, cfg.margin_end);
+        win.set_margin(side_start, cfg.margin_start.max(0));
+        win.set_margin(side_end, cfg.margin_end.max(0));
     } else {
-        // ö: förankra bara i vald ände (ingen sidoförankring = centrerad)
+        // ö utan reservation: förankra bara i vald ände
         match cfg.alignment {
             Alignment::Center => {}
             Alignment::Start => {
@@ -133,10 +142,38 @@ fn configure_layer(win: &gtk::ApplicationWindow, cfg: &Config, monitor: &gdk::Mo
             }
         }
     }
-    if cfg.avoid_windows && !cfg.autohide.enabled {
-        win.auto_exclusive_zone_enable();
+    // exclusive zone sätts explicit efter map (auto-zonen i
+    // gtk4-layer-shell fungerar bara för ytor som spänner hela kanten)
+    win.set_exclusive_zone(0);
+}
+
+/// Reservera plats: zon = dockans uppmätta storlek + marginal. Zonen
+/// ligger kvar även när docken är dodge-gömd (fönstret hålls mappat),
+/// så maximerade fönster alltid stannar vid docklinjen.
+pub fn update_exclusive_zone(ctx: &Rc<Ctx>, dock: &Rc<Dock>) {
+    let cfg = ctx.cfg.borrow().for_output(&dock.connector);
+    if !cfg.avoid_windows {
+        if !dock.hidden.get() {
+            dock.window.set_exclusive_zone(0);
+        }
+        return;
+    }
+    let horizontal = matches!(cfg.position, Position::Bottom | Position::Top);
+    // mät den SYNLIGA panelen — fönstret innehåller även skuggutrymmet,
+    // som inte ska räknas in i reservationen
+    let size = if horizontal {
+        dock.panel.height()
     } else {
-        win.set_exclusive_zone(0);
+        dock.panel.width()
+    };
+    if size > 1 && !dock.hidden.get() {
+        dock.main_size.set(size);
+    }
+    if dock.main_size.get() > 1 {
+        let zone =
+            (dock.main_size.get() + cfg.margin.max(0) + cfg.reserve_margin).max(1);
+        debug!("{}: exclusive zone {}px", dock.connector, zone);
+        dock.window.set_exclusive_zone(zone);
     }
 }
 
@@ -201,9 +238,17 @@ fn build_dock(ctx: &Rc<Ctx>, monitor: &gdk::Monitor, connector: String) -> Rc<Do
             items_box.set_vexpand(true);
             items_box.set_valign(items_align);
         }
-    } else {
-        panel.set_halign(gtk::Align::Center);
+    } else if orient == gtk::Orientation::Horizontal {
+        // ö: när ytan spänner kanten (reservera plats) placerar
+        // panel-alignmenten ön; expand krävs för att alignment ska
+        // verka i hela ytans bredd (annars packas panelen först)
+        panel.set_hexpand(true);
+        panel.set_halign(items_align);
         panel.set_valign(gtk::Align::Center);
+    } else {
+        panel.set_vexpand(true);
+        panel.set_halign(gtk::Align::Center);
+        panel.set_valign(items_align);
     }
     panel.append(&items_box);
 
@@ -272,12 +317,15 @@ fn build_dock(ctx: &Rc<Ctx>, monitor: &gdk::Monitor, connector: String) -> Rc<Do
 
     let dock = Rc::new(Dock {
         window: win.clone(),
+        panel: panel.clone(),
         items_box: items_box.clone(),
         revealer,
         connector,
         hover: Cell::new(false),
+        sensor_hover: Cell::new(false),
         hidden: Cell::new(false),
         dodge_overlap: Cell::new(false),
+        main_size: Cell::new(0),
         hide_generation: Cell::new(0),
         sensor: RefCell::new(None),
     });
@@ -287,13 +335,13 @@ fn build_dock(ctx: &Rc<Ctx>, monitor: &gdk::Monitor, connector: String) -> Rc<Do
     empty_click.set_button(3);
     {
         let ctx = ctx.clone();
-        let panel2 = panel.clone();
+        let outer2 = outer.clone();
         empty_click.connect_pressed(move |gesture, _, x, y| {
             gesture.set_state(gtk::EventSequenceState::Claimed);
-            menu::popup_panel_menu(&ctx, &panel2, x, y);
+            menu::popup_panel_menu(&ctx, &outer2, x, y);
         });
     }
-    panel.add_controller(empty_click);
+    outer.add_controller(empty_click);
 
     // hover-spårning för autohide
     let motion = gtk::EventControllerMotion::new();
@@ -355,39 +403,63 @@ fn build_sensor(ctx: &Rc<Ctx>, dock: &Rc<Dock>, monitor: &gdk::Monitor) {
         let ctx = ctx.clone();
         let dock2 = dock.clone();
         motion.connect_enter(move |_, _, _| {
+            dock2.sensor_hover.set(true);
+            dock2.hide_generation.set(dock2.hide_generation.get() + 1);
             if dock2.hidden.get() {
-                set_dock_hidden(&dock2, false);
-                // om pekaren aldrig når dockan: göm igen efter en stund
-                let ctx2 = ctx.clone();
-                let dock3 = dock2.clone();
-                glib::timeout_add_local_once(Duration::from_millis(1500), move || {
-                    if !dock3.hover.get() {
-                        update_autohide(&ctx2);
-                    }
-                });
+                set_dock_hidden(&ctx, &dock2, false);
             }
         });
     }
+    {
+        let ctx = ctx.clone();
+        let dock2 = dock.clone();
+        motion.connect_leave(move |_| {
+            dock2.sensor_hover.set(false);
+            // göm-fördröjningen börjar först NÄR man lämnar kantområdet
+            schedule_hide(&ctx, &dock2);
+        });
+    }
     strip.add_controller(motion);
 
     sensor.present();
     *dock.sensor.borrow_mut() = Some(sensor);
 }
 
-fn set_dock_hidden(dock: &Rc<Dock>, hidden: bool) {
+fn set_dock_hidden(ctx: &Ctx, dock: &Rc<Dock>, hidden: bool) {
     if dock.hidden.get() == hidden {
         return;
     }
+    let cfg = ctx.cfg.borrow().for_output(&dock.connector);
+    let horizontal = matches!(cfg.position, Position::Bottom | Position::Top);
+    // kom ihåg synlig storlek innan vi gömmer
+    if hidden {
+        let size = if horizontal { dock.panel.height() } else { dock.panel.width() };
+        if size > 1 {
+            dock.main_size.set(size);
+        }
+    }
     dock.hidden.set(hidden);
     if hidden {
-        let duration = dock.revealer.transition_duration();
         dock.revealer.set_reveal_child(false);
-        let dock2 = dock.clone();
-        glib::timeout_add_local_once(Duration::from_millis(duration as u64 + 30), move || {
-            if dock2.hidden.get() {
-                dock2.window.set_visible(false);
-            }
-        });
+        if cfg.avoid_windows {
+            // reservera plats även gömd: håll fönstret mappat (kollapsat)
+            // med frusen zon — maximerade fönster stannar vid docklinjen
+            dock.window.set_exclusive_zone(
+                (dock.main_size.get().max(1) + cfg.margin.max(0) + cfg.reserve_margin)
+                    .max(1),
+            );
+        } else {
+            let duration = dock.revealer.transition_duration();
+            let dock2 = dock.clone();
+            glib::timeout_add_local_once(
+                Duration::from_millis(duration as u64 + 30),
+                move || {
+                    if dock2.hidden.get() {
+                        dock2.window.set_visible(false);
+                    }
+                },
+            );
+        }
     } else {
         dock.window.set_visible(true);
         dock.revealer.set_reveal_child(true);
@@ -396,7 +468,7 @@ fn set_dock_hidden(dock: &Rc<Dock>, hidden: bool) {
 
 fn should_hide(ctx: &Ctx, dock: &Dock) -> bool {
     let cfg = ctx.cfg.borrow().for_output(&dock.connector);
-    if !cfg.autohide.enabled || dock.hover.get() {
+    if !cfg.autohide.enabled || dock.hover.get() || dock.sensor_hover.get() {
         return false;
     }
     match cfg.autohide.mode {
@@ -414,7 +486,7 @@ fn should_hide(ctx: &Ctx, dock: &Dock) -> bool {
 /// Applicera göm/visa-läget på alla dockor.
 pub fn update_autohide(ctx: &Rc<Ctx>) {
     for dock in ctx.docks.borrow().iter() {
-        set_dock_hidden(dock, should_hide(ctx, dock));
+        set_dock_hidden(ctx, dock, should_hide(ctx, dock));
     }
 }
 
@@ -426,7 +498,7 @@ fn schedule_hide(ctx: &Rc<Ctx>, dock: &Rc<Dock>) {
     let dock = dock.clone();
     glib::timeout_add_local_once(Duration::from_millis(delay as u64), move || {
         if dock.hide_generation.get() == generation && should_hide(&ctx, &dock) {
-            set_dock_hidden(&dock, true);
+            set_dock_hidden(&ctx, &dock, true);
         }
     });
 }
@@ -459,11 +531,19 @@ pub fn recompute_dodge(ctx: &Rc<Ctx>) {
         };
         let ow = output["geometry"]["width"].as_f64().unwrap_or(0.0);
         let oh = output["geometry"]["height"].as_f64().unwrap_or(0.0);
-        // zonen dockan upptar vid sin kant (fönstrets storlek + marginal)
-        let depth = match position {
-            Position::Bottom | Position::Top => dock.window.height().max(40) + margin,
-            _ => dock.window.width().max(40) + margin,
-        } as f64;
+        // zonen dockan upptar vid sin kant: senaste SYNLIGA storlek —
+        // den kollapsade storleken skulle få hidden/synlig att flappa
+        if !dock.hidden.get() {
+            let current = match position {
+                Position::Bottom | Position::Top => dock.panel.height(),
+                _ => dock.panel.width(),
+            };
+            if current > 1 {
+                dock.main_size.set(current);
+            }
+        }
+        let extra = if eff.avoid_windows { eff.reserve_margin } else { 0 };
+        let depth = (dock.main_size.get().max(24) + margin + extra).max(1) as f64;
 
         let overlap = views.iter().any(|v| {
             if v["role"].as_str() != Some("toplevel")
@@ -483,11 +563,14 @@ pub fn recompute_dodge(ctx: &Rc<Ctx>) {
             if x + w <= 0.0 || y + h <= 0.0 || x >= ow || y >= oh {
                 return false;
             }
+            // fönstret måste tränga IN i zonen — ett maximerat fönster
+            // som slutar exakt på docklinjen (reserverad plats) räknas
+            // inte som överlapp (0.5 px tolerans för avrundning)
             match position {
-                Position::Bottom => y + h >= oh - depth,
-                Position::Top => y <= depth,
-                Position::Left => x <= depth,
-                Position::Right => x + w >= ow - depth,
+                Position::Bottom => y + h > oh - depth + 0.5,
+                Position::Top => y < depth - 0.5,
+                Position::Left => x < depth - 0.5,
+                Position::Right => x + w > ow - depth + 0.5,
             }
         });
         dock.dodge_overlap.set(overlap);
@@ -576,6 +659,21 @@ pub fn refresh_items(ctx: &Rc<Ctx>) {
             let widget = build_item_widget(ctx, &dock.connector, Rc::new(item));
             dock.items_box.append(&widget);
         }
+        let ctx2 = ctx.clone();
+        let dock2 = dock.clone();
+        // första configure-rundan är asynkron — mät tills storleken finns
+        let mut attempts = 0;
+        glib::timeout_add_local(Duration::from_millis(120), move |
+| {
+            attempts += 1;
+            update_exclusive_zone(&ctx2, &dock2);
+            let done = dock2.main_size.get() > 1 || attempts > 20;
+            if done {
+                glib::ControlFlow::Break
+            } else {
+                glib::ControlFlow::Continue
+            }
+        });
     }
 }
 

src/main.rs

@@ -28,14 +28,16 @@ struct Cli {
     config: Option<PathBuf>,
     log: Option<String>,
     log_file: Option<String>,
+    open_settings: bool,
 }
 
 fn parse_cli() -> Cli {
-    let mut cli = Cli { config: None, log: None, log_file: None };
+    let mut cli = Cli { config: None, log: None, log_file: None, open_settings: false };
     let mut args = std::env::args().skip(1);
     while let Some(arg) = args.next() {
         match arg.as_str() {
             "--config" => cli.config = args.next().map(PathBuf::from),
+            "--settings" => cli.open_settings = true,
             "--log" => cli.log = args.next(),
             "--log-file" => cli.log_file = args.next(),
             "--version" | "-V" => {
@@ -49,6 +51,7 @@ fn parse_cli() -> Cli {
                      --config <fil>    annan configfil (default ~/.config/waydock/config.json)\n  \
                      --log <nivå>      error|warn|info|debug|trace (även env WAYDOCK_LOG)\n  \
                      --log-file <fil>  skriv logg till fil\n  \
+                     --settings        öppna inställningsfönstret vid start\n  \
                      --version         visa version"
                 );
                 std::process::exit(0);
@@ -128,20 +131,21 @@ fn main() -> glib::ExitCode {
     let started = Rc::new(Cell::new(false));
 
     let cfg_path2 = cfg_path.clone();
+    let open_settings = cli.open_settings;
     app.connect_activate(move |app| {
         if started.get() {
             info!("waydock kör redan — ignorerar andra instansen");
             return;
         }
         started.set(true);
-        activate(app, cfg_path2.clone());
+        activate(app, cfg_path2.clone(), open_settings);
     });
 
     // ge inte GTK våra egna flaggor
     app.run_with_args::<&str>(&[])
 }
 
-fn activate(app: &gtk::Application, cfg_path: PathBuf) {
+fn activate(app: &gtk::Application, cfg_path: PathBuf, open_settings: bool) {
     let cfg: config::SharedConfig = Rc::new(RefCell::new(config::load_or_create(&cfg_path)));
 
     let ctx = Rc::new(dock::Ctx {
@@ -224,6 +228,10 @@ fn activate(app: &gtk::Application, cfg_path: PathBuf) {
         );
     }
 
+    if open_settings {
+        settings::open(&ctx);
+    }
+
     // skärmar in/ut → bygg om (debouncat, skärmar kommer i klungor)
     {
         let ctx2 = ctx.clone();

src/settings.rs

@@ -467,7 +467,8 @@ fn build_layout_page(ctx: &Rc<Ctx>) -> gtk::ScrolledWindow {
             _ => Layer::Top,
         };
     }));
-    row(&list, "Reservera plats (undvik fönster)", &switch(ctx, cfg.avoid_windows, |c, v| c.avoid_windows = v));
+    row(&list, "Reservera plats (maximerade fönster stannar vid dockan)", &switch(ctx, cfg.avoid_windows, |c, v| c.avoid_windows = v));
+    row(&list, "Extra reservationsmarginal (px)", &spin(ctx, cfg.reserve_margin as f64, (-64.0, 128.0), 1.0, |c, v| c.reserve_margin = v as i32));
 
     heading(&list, "Marginaler");
     list.append(&margin_illustration(ctx));