Update README.md

1.1.5
2026-11-09 18:14:33 +01:00 · 2026-11-09 17:57:31 +01:00 · 2026-11-09 17:32:50 +01:00 · 2026-11-09 17:06:35 +01:00 · 2026-11-09 17:00:58 +01:00 · 2026-11-09 16:36:28 +01:00
57 changed files with 4395 additions and 219 deletions
@@ -0,0 +1,51 @@
+---
+name: Gebogen lijnen
+overview: Lijnen en pijlen krijgen buigpunten waardoor een vloeiende kromme door alle punten loopt. Bij een geselecteerde lijn staat tussen elk paar punten een spook-greep; slepen daarvan maakt een nieuw buigpunt, dubbelklikken op een buigpunt verwijdert het.
+todos:
+  - id: model
+    content: "LineAnnotation: Bends-lijst, Catmull-Rom-naar-Bezier helper, Render/Bounds/HitTest/Move/Clone aanpassen, pijlpunt langs raaklijn"
+    status: completed
+  - id: handles
+    content: "Grepen: buigpunten + spook-grepen, BeginHandleDrag voegt buigpunt in, RemoveHandle; IsGhostHandle/RemoveHandle in Annotation"
+    status: completed
+  - id: surface
+    content: "AnnotationSurface: spook-grepen anders tekenen, echte grepen voorrang bij HitHandle"
+    status: completed
+  - id: editor
+    content: "EditorWindow: dubbelklik op buigpunt verwijdert het (met undo), hint-tekst bijwerken"
+    status: completed
+isProject: false
+---
+
+# Gebogen lijnen en pijlen
+
+## Gedrag
+- Selecteer een lijn of pijl: je ziet de begin- en eindgreep, de buigpunten en, halverwege elk stuk van de kromme, een kleine halfdoorzichtige spook-greep.
+- Sleep je een spook-greep, dan wordt die een echt buigpunt en volgt de lijn de muis (zoals in je screenshot).
+- Dubbelklik op een buigpunt verwijdert het. Beide acties kun je ongedaan maken.
+- De kromme loopt precies door alle punten (Catmull-Rom, omgezet naar kubische Beziers). De pijlpunt volgt de richting van het laatste stuk.
+
+## Wijzigingen
+
+**[src/Kniip/Editor/Annotations/LineAnnotation.cs](src/Kniip/Editor/Annotations/LineAnnotation.cs)**
+- Nieuw: `List<Point> Bends`, met `Start + Bends + End` als doorlooppunten.
+- Een helper bouwt de Bezier-segmenten. Voor `Bounds`, `HitTest` en de posities van de spook-grepen gebruikt hij bemonsterde punten (ongeveer 16 per segment). Zonder buigpunten blijft alles gelijk aan nu.
+- `Render`: een `StreamGeometry` met `BezierTo`. Bij een pijl wordt de richting bepaald door `End` min het laatste controlepunt. Het laatste segment eindigt op het basispunt van de pijlpunt.
+- Grepen: index 0 is `Start` en 1 is `End`, zodat bestaande code blijft werken. Daarna volgen de buigpunten en dan de spook-grepen (het Bezier-punt bij t=0,5 van elk segment).
+- `BeginHandleDrag`: bij een spook-greep wordt een buigpunt op de juiste plek in `Bends` ingevoegd en het actieve buigpunt onthouden. `MoveHandle` verplaatst daarna dat punt.
+- Met Shift blijft `SnapAngle` werken voor begin en eind, maar dan ten opzichte van het naastliggende punt.
+- `Move` verschuift ook alle buigpunten. `Clone` maakt een diepe kopie van `Bends`, nodig voor ongedaan maken (zelfde patroon als in `HighlightAnnotation`).
+
+**[src/Kniip/Editor/Annotations/Annotation.cs](src/Kniip/Editor/Annotations/Annotation.cs)**
+- `public virtual bool IsGhostHandle(int index) => false;`
+- `public virtual bool RemoveHandle(int index) => false;` (LineAnnotation verwijdert hiermee een buigpunt)
+
+**[src/Kniip/Editor/AnnotationSurface.cs](src/Kniip/Editor/AnnotationSurface.cs)**
+- `DrawSelection` tekent spook-grepen als kleinere, halfdoorzichtige cirkels. `HitHandle` controleert eerst de echte grepen en daarna pas de spook-grepen, zodat een echte greep voorrang krijgt als ze overlappen.
+
+**[src/Kniip/Editor/EditorWindow.xaml.cs](src/Kniip/Editor/EditorWindow.xaml.cs)** (rond regel 452)
+- In `Surface_MouseLeftButtonDown`: als op een greep geklikt wordt met `e.ClickCount == 2` en `_selected.RemoveHandle(handle)` slaagt, dan volgen `Commit(_pending)` en `InvalidateVisual`, en stopt de verwerking daar. Anders start het bestaande sleepgedrag.
+- Optioneel: in `UpdateHint` een korte tip toevoegen voor lijnen ("Sleep het middenpunt om te buigen, dubbelklik om een punt te verwijderen").
+
+## Niet nodig
+Exporteren gaat via `Render` in [src/Kniip/Editor/DocumentRenderer.cs](src/Kniip/Editor/DocumentRenderer.cs) en werkt dus automatisch. Ook het aanmaken van lijnen (`UpdateCreating`) blijft ongewijzigd: nieuwe lijnen zijn recht.
@@ -0,0 +1,64 @@
+---
+name: Naamsjabloon opslaan
+overview: In de tab Opslaan komt per soort (knipsels en screencasts) een eigen naamsjabloon met %J, %M, %D, %V, %Rn en %Nn. Mappen worden automatisch aangemaakt en kniip plakt zelf de extensie (.png, .mp4 of .gif) erachter.
+todos:
+  - id: template
+    content: FileNameTemplate.cs maken (tokens, submappen, opschonen, %N per map, fallback)
+    status: completed
+  - id: settings
+    content: SnipFileNameTemplate en VideoFileNameTemplate toevoegen aan AppSettings
+    status: completed
+  - id: windowname
+    content: Programmanaam van het venster bepalen in SnapshotWindows en doorgeven via RegionCaptureWindow, App, RecordingController
+    status: completed
+  - id: save
+    content: EditorWindow.Save/SaveAs en ScreencastWindow.FixedTarget/DefaultFileName op het sjabloon laten draaien
+    status: completed
+  - id: ui
+    content: Naamvelden met live voorbeeld en tokenuitleg toevoegen in de tab Opslaan
+    status: completed
+  - id: build
+    content: Bouwen en testen met het voorbeeld %J/%M-%D/%V_%N3
+    status: completed
+isProject: false
+---
+
+# Naamsjabloon voor opslaan
+
+## Gedrag
+
+- In de tab **Opslaan** komt onder elke map (Knipsels en Screencasts) een veld **Naam**, met een live voorbeeld eronder. Bijvoorbeeld: `%J/%M-%D/%V_%N3` wordt `2026/11-08/Cursor_001.png`.
+- Tokens:
+  - `%J` is het jaar (2026).
+  - `%M` is de maand en `%D` de dag, allebei met twee cijfers (11, 08), zodat de mappen goed sorteren.
+  - `%V` is de programmanaam van het venster, bijvoorbeeld `Cursor` of `chrome`.
+  - `%Rn` zijn n willekeurige letters en cijfers.
+  - `%Nn` is het eerste vrije nummer in de doelmap, met n cijfers (001, 002, ...). In een nieuwe map begint de teller weer bij 001.
+- Met `/` of `\` maak je submappen. Die maakt kniip zelf aan, onder de ingestelde map.
+- kniip plakt de extensie er zelf achter: `.png` voor knipsels, `.mp4` of `.gif` voor screencasts.
+- Is het veld leeg, dan blijft de huidige naam staan (`Knipsel 2026-11-08 234500`), zodat bestaande instellingen gewoon blijven werken.
+- Ongeldige tekens zoals `: * ? " < > |` worden `_`. Zit er geen `%N` in en bestaat het bestand al, dan valt kniip terug op de bestaande `(2)`-nummering uit `SaveLocation.UniquePath`.
+- Tokens beginnen altijd met `%`. In jouw voorbeeld moet `_N3` dus `_%N3` zijn. Het live voorbeeld laat meteen zien of het klopt.
+
+## Waar komt %V vandaan
+
+```mermaid
+flowchart LR
+    WinSnip["Alt+PrintScreen: aangeklikt venster"] --> Name[Programmanaam]
+    RegionSnip["Rechthoekknipsel: venster onder het midden van de selectie"] --> Name
+    Screencast["Screencast: venster onder het midden van het opnamegebied"] --> Name
+    Other["Knipprogramma, klembord, Openen met"] --> Fallback["'Knipsel' of 'Screencast'"]
+```
+
+Het venster wordt bepaald uit de vensterlijst die al vóór de overlay wordt vastgelegd (`PhysicalWindow.SnapshotWindows`). Zo staat kniip's eigen overlay er nooit tussen.
+
+## Wijzigingen
+
+- **Nieuw** [src/Kniip/Settings/FileNameTemplate.cs](src/Kniip/Settings/FileNameTemplate.cs): `Resolve(folder, template, windowName, extension)` geeft het volledige pad terug, inclusief submappen, opschoning en `%N`-telling. Daarnaast `Preview(...)` voor het voorbeeld in de instellingen.
+- [src/Kniip/Settings/AppSettings.cs](src/Kniip/Settings/AppSettings.cs): twee nieuwe instellingen, `SnipFileNameTemplate` en `VideoFileNameTemplate`. Leeg betekent de huidige standaardnaam.
+- [src/Kniip/Recording/PhysicalWindow.cs](src/Kniip/Recording/PhysicalWindow.cs): `SnapshotWindows` geeft naast de rechthoek ook de handle van elk venster terug. Een nieuwe helper zoekt via `GetWindowThreadProcessId` en `Process.ProcessName` de programmanaam op.
+- [src/Kniip/Capture/RegionCaptureWindow.xaml.cs](src/Kniip/Capture/RegionCaptureWindow.xaml.cs) en [src/Kniip/App.xaml.cs](src/Kniip/App.xaml.cs): `Finished` levert naast de afbeelding ook de vensternaam. `OpenEditor(image, windowName)` geeft die door aan `EditorWindow`.
+- [src/Kniip/Recording/RecordingController.cs](src/Kniip/Recording/RecordingController.cs): bij het kiezen van het gebied wordt de vensternaam onthouden. Die gaat via `RecordingFinished` naar `ScreencastWindow`.
+- [src/Kniip/Editor/EditorWindow.xaml.cs](src/Kniip/Editor/EditorWindow.xaml.cs): `Save()` gebruikt `FileNameTemplate.Resolve` in plaats van de vaste `Knipsel {DateTime.Now:...}.png`. `SaveAs()` stelt de gegenereerde bestandsnaam voor.
+- [src/Kniip/Recording/ScreencastWindow.xaml.cs](src/Kniip/Recording/ScreencastWindow.xaml.cs): `FixedTarget()` en `DefaultFileName` gaan via het sjabloon, met `.gif` of `.mp4` afhankelijk van het formaat.
+- [src/Kniip/Settings/SettingsWindow.xaml](src/Kniip/Settings/SettingsWindow.xaml) en [.xaml.cs](src/Kniip/Settings/SettingsWindow.xaml.cs): per soort een `TextBox` **Naam** met een voorbeeldregel, een uitleg van de tokens als hint, en opslaan en herstellen samen met de mapinstellingen. De bestaande hint over "datum en tijd in de naam" wordt aangepast.
@@ -0,0 +1,72 @@
+---
+name: Schermafdruk vertraging
+overview: "Tray-submenu \"Schermafdruk vertraging: Xs\" (0-60 s, slider plus getalveld) dat rechthoek- en vensterknipsels uitstelt, met een klein aftelvenster bij de muis dat met Esc te annuleren is."
+todos:
+  - id: setting
+    content: CaptureDelaySeconds toevoegen aan AppSettings (0-60, standaard 0)
+    status: completed
+  - id: tray
+    content: Tray-submenu met TrackBar + NumericUpDown, SetCaptureDelay en CaptureDelayChanged in TrayIcon
+    status: completed
+  - id: countdown
+    content: CountdownWindow (niet-activerend, volgt muis, Elapsed/Cancelled) maken
+    status: completed
+  - id: app
+    content: BeginDelayedSnip in App.xaml.cs, Esc-binding tijdelijk, StartNewSnip onvertraagd, instelling opslaan
+    status: completed
+  - id: changelog
+    content: CHANGELOG.md bijwerken
+    status: completed
+  - id: release
+    content: CHANGELOG 1.1.5-item, build.ps1 draaien, commit/tag 1.1.5 en pushen
+    status: completed
+isProject: false
+---
+
+# Schermafdruk vertraging (0-60 s)
+
+## Gedrag
+- In het tray-menu komt direct onder "Venster knippen" een item `Schermafdruk vertraging: 0s` met een submenu.
+- In het submenu staan een slider (0-60) en een getalveld (`NumericUpDown`, 0-60) die met elkaar meelopen. De tekst van het hoofditem werkt meteen bij, bijvoorbeeld `Schermafdruk vertraging: 5s`.
+- 0 betekent uit: dan werkt alles zoals nu.
+- De vertraging geldt voor "Rechthoek knippen" en "Venster knippen", via de tray en via de sneltoetsen. Screencasts en "Nieuw knipsel" na het sluiten van de editor (`StartNewSnip`) gaan zonder vertraging.
+- Tijdens het aftellen staat een klein, altijd-bovenop, niet-focusstelend venstertje bij de muis met de resterende seconden. Het scherm wordt pas vastgelegd nadat dat venster weg is, zodat het niet in de schermafdruk komt. Met Esc (of een klik op het venster) annuleer je.
+
+```mermaid
+flowchart LR
+    trigger["Tray of sneltoets"] --> check{"Delay groter dan 0?"}
+    check -->|nee| snip["BeginSnip: scherm bevriezen"]
+    check -->|ja| countdown["CountdownWindow bij muis"]
+    countdown -->|"Esc of klik"| cancel[Geannuleerd]
+    countdown -->|"tijd om"| closeWin["Venster sluiten, korte pauze"] --> snip
+```
+
+## Wijzigingen
+
+**[src/Kniip/Settings/AppSettings.cs](src/Kniip/Settings/AppSettings.cs)**
+- Nieuwe instelling `public int CaptureDelaySeconds { get; set; }` (standaard 0), met een doc-comment in dezelfde stijl. Bij het lezen begrenzen tot 0-60.
+
+**[src/Kniip/Infrastructure/TrayIcon.cs](src/Kniip/Infrastructure/TrayIcon.cs)**
+- `_delayItem` (een `ToolStripMenuItem`) met in de `DropDownItems` een `ToolStripControlHost` om een klein `Panel`: daarin een `TrackBar` (0-60, `TickFrequency` 5) en een `NumericUpDown` met het label "seconden".
+- `public void SetCaptureDelay(int seconds)` zet de besturingselementen en de menutekst.
+- `public event Action<int>? CaptureDelayChanged`: wordt afgevuurd als de waarde wijzigt. Opslaan gebeurt pas bij `DropDownClosed`, zodat niet elke stap van de slider een schrijfactie wordt.
+- Toetsen in het getalveld mogen het menu niet sluiten. Als dat in de praktijk toch gebeurt, krijgt het hostpaneel focus en geven we Enter/Esc expliciet door.
+
+**[src/Kniip/App.xaml.cs](src/Kniip/App.xaml.cs)**
+- Bij het opstarten: `_tray.SetCaptureDelay(Settings.CaptureDelaySeconds)` en `CaptureDelayChanged` koppelen. De koppeling zet `Settings.CaptureDelaySeconds` en roept `SettingsStore.Save` aan.
+- `BeginRegionSnip`/`BeginWindowSnip` gaan via een nieuwe `BeginDelayedSnip(bool pickWindow)`:
+  - Als de vertraging 0 is, of er al een knipsel loopt, of er al wordt afgeteld, gaat het direct naar `BeginSnip`. Een tweede sneltoets tijdens het aftellen wordt genegeerd.
+  - Anders wordt een `CountdownWindow` gestart. Na afloop sluit dat venster en volgt een `DispatcherTimer` van circa 150 ms (zelfde idee als `StartNewSnip`), daarna `BeginSnip(pickWindow)`.
+  - Esc tijdens het aftellen: tijdelijk een `Escape`-binding toevoegen aan `HotkeyHook.Bindings` die het aftellen annuleert, en daarna via `ApplyHotkeys()` herstellen. `HotkeyHook.Capture` gebruiken we niet, want dat slokt alle toetsen op, en de gebruiker moet tijdens het aftellen juist zijn scherm kunnen klaarzetten.
+- `StartNewSnip` blijft `BeginRegionSnip` direct aanroepen, maar dan via de onvertraagde route (`BeginSnip(false)`).
+
+**Nieuw: `src/Kniip/Capture/CountdownWindow.xaml(.cs)`**
+- Een klein, rond-hoekig WPF-venster zonder rand: `Topmost`, `ShowActivated=False`, `ShowInTaskbar=False`, met `WS_EX_NOACTIVATE`/`WS_EX_TOOLWINDOW` zodat de focus bij het actieve programma blijft. De opmaak is vergelijkbaar met [`SnipToast.xaml`](src/Kniip/Notifications/SnipToast.xaml).
+- Toont een groot getal en de tekst "Esc om te annuleren". Er loopt een `DispatcherTimer` van 1 s. Het venster schuift mee met de muis (positie bijwerken op dezelfde tick of op een snellere tick van circa 50 ms).
+- Events `Elapsed` en `Cancelled`. Een muisklik op het venster telt als annuleren.
+
+## Release 1.1.5
+De versienummers in [build.ps1](build.ps1), [installer/Kniip.iss](installer/Kniip.iss), [src/Kniip/Kniip.csproj](src/Kniip/Kniip.csproj) en [README.md](README.md) staan al op 1.1.5. Tag `1.1.5` bestaat nog niet. Deze functie gaat dus mee in dezelfde release als de ShareX-indeling, het vergrootglas en de geschiedenis.
+- [CHANGELOG.md](CHANGELOG.md): in de bestaande sectie `## 1.1.5 - 2026-11-09` onder **Nieuw** een item toevoegen in dezelfde stijl, bijvoorbeeld: **Schermafdruk vertraging.** In het systeemvakmenu staat **Schermafdruk vertraging: 0s**. Stel daar met de schuifbalk of het getalveld 0 tot 60 seconden in. Daarna wachten **Rechthoek knippen** en **Venster knippen** (ook via de sneltoets) zo lang voordat het scherm bevriest. Bij de muis telt een venstertje af, en met Esc annuleer je. 0 betekent geen vertraging; screencasts wachten niet.
+- `.\build.ps1` draaien en controleren dat de build en de installer slagen.
+- Commit "1.1.5" met alle openstaande 1.1.5-wijzigingen, waaronder de nieuwe History- en Magnifier-bestanden. Daarna tag `1.1.5` en pushen, net als bij 1.1.4. De release op git.hibbit.net maak je zelf aan; ik lever de changelogtekst aan.
@@ -0,0 +1,74 @@
+---
+name: ShareX-indeling editor
+overview: "Een tweede editor-indeling toevoegen in de stijl van ShareX: bovenaan de bewerkgereedschappen met daaronder de eigenschappenbalk, onderaan een aparte balk met zoom en de opslag-, upload- en kopieerknoppen. De indeling is te kiezen in Instellingen (tab Editor) en via het rechtsklikmenu van de werkbalk. Uitbrengen als versie 1.1.5."
+todos:
+  - id: settings
+    content: EditorLayout-enum, EditorLayout- en SplitToolbarOrder-instelling toevoegen aan AppSettings
+    status: completed
+  - id: xaml
+    content: ActionBar met ActionItems (ToolbarPanel) toevoegen aan EditorWindow.xaml
+    status: completed
+  - id: code
+    content: "Werkbalkcode ombouwen: items verdelen over twee panelen, labels/vergrendelen/verbergen/volgorde/omwisselen per paneel, menu Indeling, bijsnijden, OnActivated"
+    status: completed
+  - id: settingsui
+    content: Radioknoppen voor de indeling in de Editor-tab van Instellingen plus herstellen naar standaard
+    status: completed
+  - id: version
+    content: Versie 1.1.5 in csproj, build.ps1 en Kniip.iss en een CHANGELOG-regel
+    status: completed
+  - id: verify
+    content: Bouwen en beide indelingen handmatig testen
+    status: completed
+isProject: false
+---
+
+# ShareX-achtige editor-indeling (versie 1.1.5)
+
+## Indeling
+
+- **Eén werkbalk** (standaard, zoals nu): alles in `ToolbarItems`, positie Boven/Onder/Links/Rechts blijft werken.
+- **Gesplitst (zoals ShareX)**:
+  - Boven, gecentreerd: Selecteren, Rechthoek ... Vervagen, Bijsnijden, met daarnaast Wissen, Ongedaan maken, Opnieuw en Verwijderen. Direct daaronder de bestaande eigenschappenbalk `PropsBar` (die al gecentreerd is).
+  - Onder, boven de statusbalk: links Nieuw en Screencast, in het midden Uitzoomen / 100% / Inzoomen, rechts Instellingen, Opslaan, Uploaden en Kopiëren (met tekstlabels, want daar is ruimte).
+
+```mermaid
+flowchart TB
+    topBar["Boven: gereedschappen + ongedaan maken"]
+    props["Eigenschappenbalk: kleur, dikte, lijnstijl"]
+    canvas["Canvas"]
+    bottomBar["Onder: Nieuw, Screencast | Zoom | Instellingen, Opslaan, Uploaden, Kopiëren"]
+    status["Statusbalk"]
+    topBar --> props --> canvas --> bottomBar --> status
+```
+
+## Wijzigingen
+
+**[src/Kniip/Settings/AppSettings.cs](src/Kniip/Settings/AppSettings.cs)**
+- Nieuwe enum `EditorLayout { Single, Split }` en `public EditorLayout EditorLayout { get; set; } = EditorLayout.Single;`
+- Aparte `List<string> SplitToolbarOrder`, zodat versleepte volgordes van beide indelingen elkaar niet overschrijven. `ToolbarHidden` blijft gedeeld.
+
+**[src/Kniip/Editor/EditorWindow.xaml](src/Kniip/Editor/EditorWindow.xaml)**
+- Een tweede `Border x:Name="ActionBar" DockPanel.Dock="Bottom"` (na de statusbalk gedeclareerd, dus erboven) met `local:ToolbarPanel x:Name="ActionItems"`, dezelfde `ContextMenuOpening`- en `OrderChanged`-handlers en standaard `Collapsed`.
+- De knoppen zelf blijven op één plek in de XAML staan; de code verdeelt ze over de panelen.
+
+**[src/Kniip/Editor/EditorWindow.xaml.cs](src/Kniip/Editor/EditorWindow.xaml.cs)** (rond regels 141-362 voor de werkbalk)
+- In `InitializeToolbar` alle items één keer in een dictionary `_toolbarItems` (id naar element) vastleggen, plus een vaste set id's die in de gesplitste indeling onderaan komen: `New, Screencast, Spacer, ZoomOut, Zoom, ZoomIn, Spacer2, Settings, Save, Upload, Copy` (plus de bijbehorende scheidingslijnen).
+- `ApplyToolbarOrder` ombouwen tot `ApplyToolbarLayout()`: beide panelen leegmaken en de items volgens de opgeslagen volgorde (`ToolbarOrder` of `SplitToolbarOrder`) verdelen over `ToolbarItems` en `ActionItems`. De logica voor nieuwe items die na hun standaardvoorganger komen, blijft hetzelfde. In de gesplitste indeling krijgt het bovenste paneel `HorizontalAlignment=Center`, `Toolbar` vast `Dock.Top` en wordt `ActionBar` getoond.
+- Alle plekken die nu `ToolbarItems.Items` gebruiken, laten werken op beide panelen: `SelectTool` (regel 368), "Knoppen tonen", `ResetToolbar`, de vergrendeling (`IsLocked` op beide panelen, achtergrondkleur op beide balken) en `OrderChanged` (de volgorde van boven + onder samen opslaan in `SplitToolbarOrder`).
+- `UpdateToolbarLayout` en `SetActionLabelsVisible` per paneel laten rekenen, zodat de labels op de onderbalk zichtbaar blijven, ook als de bovenbalk vol is. De lus op regel 236 stopt bij het `ToolbarPanel` waarin het label staat, in plaats van alleen bij `ToolbarItems`.
+- `SwapToolbarGroups` werkt op het paneel waarop is rechtsgeklikt.
+- Rechtsklikmenu: een nieuw submenu "Indeling" met "Eén werkbalk" en "Gesplitst (zoals ShareX)". "Positie" alleen tonen bij Eén werkbalk.
+- Op regel 935, waar `Toolbar` tijdens bijsnijden wordt verborgen, ook `ActionBar` verbergen (alleen als de gesplitste indeling aanstaat).
+- In `OnActivated` (regel 1508) `ApplyToolbarLayout()` aanroepen als de indeling is veranderd, zodat een wijziging in Instellingen meteen zichtbaar is in een open editor (zoals dat nu ook gebeurt met `ApplySaveButton`).
+
+**[src/Kniip/Settings/SettingsWindow.xaml](src/Kniip/Settings/SettingsWindow.xaml) en [.xaml.cs](src/Kniip/Settings/SettingsWindow.xaml.cs)**
+- In de tab Editor (regel 252) een kopje "Werkbalk" met twee radioknoppen `LayoutSingleRadio` / `LayoutSplitRadio` en een korte uitleg, op dezelfde manier geladen en opgeslagen als `SaveOnlyRadio` / `SaveAndCopyRadio`.
+- Bij het herstellen van de standaardinstellingen (regel 466) ook `EditorLayout` en `SplitToolbarOrder` meenemen.
+
+**Versie 1.1.5**
+- `<Version>1.1.5</Version>` in [src/Kniip/Kniip.csproj](src/Kniip/Kniip.csproj), de standaardwaarde in [build.ps1](build.ps1) (regel 16) en `#define AppVersion` in [installer/Kniip.iss](installer/Kniip.iss).
+- In [CHANGELOG.md](CHANGELOG.md) bovenaan `## 1.1.5 - 2026-11-09`, onder `### Nieuw`: **Werkbalkindeling zoals ShareX.**
+
+## Controle
+- Bouwen met `build.ps1`, daarna beide indelingen uitproberen: wisselen via Instellingen en via het rechtsklikmenu, knoppen verslepen en verbergen, bijsnijden, een smal venster (de balken moeten netjes doorlopen naar een nieuwe regel) en "Standaard herstellen".
@@ -0,0 +1,93 @@
+---
+name: Update-melding blauwe stip
+overview: kniip controleert op de achtergrond (bij het starten en daarna elke 24 uur, uit te zetten in Instellingen) op een nieuwe versie. Als die er is, krijgen de knop Instellingen in de editor-werkbalk en de tab Update in Instellingen een blauwe stip.
+todos:
+  - id: setting
+    content: CheckForUpdates toevoegen aan AppSettings
+    status: completed
+  - id: notifier
+    content: UpdateNotifier maken (controle na het starten en elke 24 uur, AvailabilityChanged-event, Report)
+    status: completed
+  - id: app
+    content: "UpdateNotifier koppelen in App: aanroepen bij het opstarten en in SaveSettings"
+    status: completed
+  - id: editor-badge
+    content: Blauwe stip op de knop Instellingen in EditorWindow
+    status: completed
+  - id: settings-tab
+    content: Blauwe stip op de tab Update, vinkje voor automatische controle, Report na handmatige controle
+    status: completed
+  - id: changelog-readme
+    content: CHANGELOG.md sectie 1.1.4 toevoegen en README bijwerken (achtergrondcontrole, versietabel, build-commentaar)
+    status: completed
+  - id: bump-version
+    content: Versie naar 1.1.4 in build.ps1, installer/Kniip.iss en src/Kniip/Kniip.csproj
+    status: completed
+  - id: build-release
+    content: build.ps1 draaien, commit "1.1.4", tag 1.1.4 en pushen; installer klaarzetten voor de release op git.hibbit.net
+    status: completed
+isProject: false
+---
+
+# Blauwe update-melding bij Instellingen en de tab Update
+
+## Huidige situatie
+- [src/Kniip/Update/UpdateChecker.cs](src/Kniip/Update/UpdateChecker.cs) haalt releases op met `GetReleasesAsync`, maar dat gebeurt nu alleen in [src/Kniip/Settings/SettingsWindow.xaml.cs](src/Kniip/Settings/SettingsWindow.xaml.cs) zodra de tab Update geopend wordt (`Tabs_SelectionChanged` gevolgd door `CheckForUpdatesAsync`).
+- De knop Instellingen staat in [src/Kniip/Editor/EditorWindow.xaml](src/Kniip/Editor/EditorWindow.xaml) (regel 318–321, glyph `&#xE713;`).
+- `AccentBrush` is `#0067C0` (blauw) in [src/Kniip/App.xaml](src/Kniip/App.xaml), en die gebruiken we voor de stip.
+
+```mermaid
+flowchart LR
+    AppStart[App start] --> Notifier[UpdateNotifier]
+    Timer["Timer 24 uur"] --> Notifier
+    Notifier -->|GetReleasesAsync| Checker[UpdateChecker]
+    Notifier -->|AvailabilityChanged| EditorBadge[Stip op knop Instellingen]
+    Notifier -->|AvailabilityChanged| TabBadge[Stip op tab Update]
+    SettingsCheck[Handmatige controle in tab Update] -->|Report| Notifier
+```
+
+## Stappen
+
+1. **Nieuwe instelling** in [src/Kniip/Settings/AppSettings.cs](src/Kniip/Settings/AppSettings.cs):
+   `public bool CheckForUpdates { get; set; } = true;`
+
+2. **Nieuwe klasse `UpdateNotifier`** in `src/Kniip/Update/UpdateNotifier.cs`:
+   - Houdt `ReleaseInfo? Available` bij en `bool IsUpdateAvailable`, met een event `AvailabilityChanged` dat op de UI-thread wordt afgevuurd.
+   - `Apply(bool enabled)`: als de controle aanstaat, wordt die kort na het starten uitgevoerd (ongeveer 10 seconden vertraging, zodat het opstarten niet trager wordt) en daarna via een `DispatcherTimer` elke 24 uur. Als de controle uitstaat, stopt de timer en verdwijnt de stip.
+   - `CheckAsync()` roept `UpdateChecker.GetReleasesAsync` aan en vangt `UpdateException` stil af, zodat een achtergrondcontrole nooit een foutmelding toont.
+   - `Report(ReleaseInfo? newest)` wordt gebruikt door de handmatige controle in de tab Update, zodat de stip ook daarmee gelijkloopt.
+   - "Nieuwer" betekent hetzelfde als in `ShowReleases`: `r.Version > UpdateChecker.CurrentVersion`.
+
+3. **App** ([src/Kniip/App.xaml.cs](src/Kniip/App.xaml.cs)):
+   - Een property `public UpdateNotifier Updates { get; } = new();`
+   - Bij het opstarten (na `ApplyHotkeys`) wordt `Updates.Apply(Settings.CheckForUpdates)` aangeroepen.
+   - In `SaveSettings()` gebeurt dat opnieuw, zodat het aan- of uitzetten van de controle direct effect heeft.
+
+4. **Stip op de knop Instellingen** ([src/Kniip/Editor/EditorWindow.xaml](src/Kniip/Editor/EditorWindow.xaml) en `.xaml.cs`):
+   - De inhoud van de knop wordt een `Grid` met de bestaande glyph plus `<Ellipse x:Name="SettingsBadge" Width="8" Height="8" Fill="{StaticResource AccentBrush}" Stroke="White" StrokeThickness="1" HorizontalAlignment="Right" VerticalAlignment="Top" Margin="0,-2,-3,0" Visibility="Collapsed" />`.
+   - In de code-behind abonneert de editor zich op `App.Instance.Updates.AvailabilityChanged`. Bij een wijziging worden `SettingsBadge.Visibility` en de tooltip bijgewerkt (de tooltip wordt "Instellingen - nieuwe versie beschikbaar"). Bij `Closed` wordt het abonnement weer opgezegd.
+
+5. **Stip op de tab Update en een vinkje voor de achtergrondcontrole** ([src/Kniip/Settings/SettingsWindow.xaml](src/Kniip/Settings/SettingsWindow.xaml) en `.xaml.cs`):
+   - De `Header` van `UpdateTab` wordt een horizontale `StackPanel` met de tekst "Update" en daarachter een blauwe `Ellipse x:Name="UpdateTabBadge"` van dezelfde stijl, met een margin links van 6.
+   - In de tab Update, onder `CurrentVersionText`, komt `<CheckBox x:Name="AutoUpdateCheckBox" Content="Automatisch controleren op nieuwe versies (bij starten en dagelijks)" />`. Die wordt gevuld in `LoadFrom`, bewaard in `Save_Click` en meegenomen bij Standaardinstellingen.
+   - Het venster abonneert zich op `AvailabilityChanged` om de zichtbaarheid van de stip te zetten, en zegt dat abonnement op bij `Closed`.
+   - Na een handmatige controle roept `ShowReleases` `App.Instance.Updates.Report(newer.FirstOrDefault())` aan.
+
+## Gedrag
+- De stip blijft zichtbaar zolang er een nieuwere versie is. Na het updaten start kniip met de nieuwe versie, en dan is er geen nieuwere versie meer, dus verdwijnt de stip vanzelf.
+- Er komen geen extra meldingen in het systeemvak, zoals afgesproken.
+
+## Changelog en release 1.1.4 (na de codewijzigingen)
+
+6. **[CHANGELOG.md](CHANGELOG.md)**: bovenaan een nieuwe sectie `## 1.1.4 - 2026-11-09` in dezelfde stijl als de eerdere versies, bijvoorbeeld:
+   - Onder `### Nieuw`: **Melding bij een nieuwe versie.** kniip kijkt bij het starten en daarna elke dag of er een nieuwere versie is. Als die er is, staat er een blauwe stip op de knop **Instellingen** in de editor en op de tab **Update**. Je zet dit uit in de tab **Update** met **Automatisch controleren op nieuwe versies**.
+   - Onder `### Gewijzigd`: kniip zoekt nu standaard zelf op de achtergrond naar updates. Tot nu toe gebeurde dat alleen als je de tab **Update** opende, zoals vermeld bij 1.1.0.
+7. **[README.md](README.md)**:
+   - In de versietabel 1.1.3 vervangen door 1.1.4, met de link `.../releases/download/1.1.4/Kniip-Setup-1.1.4.exe`.
+   - Het commentaar `# versie 1.1.3` bij het bouwen wordt `# versie 1.1.4`.
+   - Bij "Updaten vanuit kniip" komt een zin over de automatische controle en de blauwe stip.
+8. **Versienummer** van 1.1.3 naar 1.1.4 in [build.ps1](build.ps1) (`$Version`), [installer/Kniip.iss](installer/Kniip.iss) (`#define AppVersion`) en [src/Kniip/Kniip.csproj](src/Kniip/Kniip.csproj) (`<Version>`).
+9. **Bouwen en uitbrengen**, op dezelfde manier als bij 1.1.2 en 1.1.3:
+   - `.\build.ps1` draaien. Dat levert `artifacts\Kniip-1.1.4.exe` en `artifacts\Kniip-Setup-1.1.4.exe` op.
+   - Daarna `git add -A`, `git commit -m "1.1.4"`, `git tag 1.1.4` (zonder `v`, net als de vorige tags) en `git push origin HEAD` plus `git push origin 1.1.4`.
+   - De release op git.hibbit.net maak je, net als eerder, zelf aan. Je hangt daar `artifacts\Kniip-Setup-1.1.4.exe` aan als bijlage en plakt de 1.1.4-tekst uit de changelog in de beschrijving. Ik lever die tekst kant-en-klaar aan.
@@ -0,0 +1,86 @@
+---
+name: Update-tab met changelog
+overview: Add an "Update" tab to the settings that reads releases from git.hibbit.net (public Gitea/Forgejo API), shows the changelog rendered as Markdown, and on "Updaten" downloads the installer, runs it silently and restarts kniip.
+todos:
+  - id: checker
+    content: "UpdateChecker: releases ophalen via Gitea-API, versies vergelijken"
+    status: completed
+  - id: markdown
+    content: Markdig-referentie + MarkdownRenderer naar FlowDocument
+    status: completed
+  - id: installer-dl
+    content: "UpdateInstaller: download met voortgang en stille start"
+    status: completed
+  - id: tab-ui
+    content: Update-tab in SettingsWindow (xaml + code-behind)
+    status: completed
+  - id: app-exit
+    content: "App: TryCloseAllWindows en --updated-argument"
+    status: completed
+  - id: iss
+    content: "Kniip.iss: herstart na stille installatie"
+    status: completed
+  - id: readme
+    content: "README: releasenotes en publiek-vereiste documenteren"
+    status: completed
+isProject: false
+---
+
+# Update-tab met changelog
+
+## Uitgangspunten
+- git.hibbit.net heeft een Gitea/Forgejo-API (`/api/v1/version` geeft `28.3.0`). Releases: `GET https://git.hibbit.net/api/v1/repos/rogier/kniip/releases?limit=20`. De repo moet **publiek** worden; nu geeft die URL 404.
+- Per release gebruiken we deze velden: `tag_name` (`v1.2.0`), `name`, `body` (markdown-changelog), `published_at`, `draft`, `prerelease`, `html_url` en `assets[]`. Uit `assets[]` zoeken we `name` = `Kniip-Setup-*.exe` en de bijbehorende `browser_download_url` op.
+- Alleen handmatig controleren: bij het openen van de tab en met de knop "Opnieuw controleren". Er komt geen achtergrondcontrole.
+- Huidige versie: `Assembly.GetEntryAssembly().GetName().Version`, gezet via `-p:Version` in [build.ps1](build.ps1). Niet `InformationalVersion`, want daar zet de .NET 8 SDK een `+commithash` achter.
+
+```mermaid
+flowchart LR
+    Tab[Update-tab geopend] --> Api["GET releases API"]
+    Api --> Compare{"Nieuwere versie?"}
+    Compare -->|ja| Show["Changelog van alle nieuwere versies + knop Updaten"]
+    Compare -->|nee| Current["'Je hebt de nieuwste versie' + changelog huidige versie"]
+    Show --> Download["Installer downloaden naar TEMP met voortgang"]
+    Download --> Exit["Vensters sluiten, installer /VERYSILENT starten, kniip afsluiten"]
+    Exit --> Restart["Installer start kniip --updated"]
+```
+
+## Nieuwe bestanden
+- `src/Kniip/Update/UpdateChecker.cs`
+  - Record `ReleaseInfo(Version Version, string Tag, string Title, DateTimeOffset? Date, string Body, string HtmlUrl, string? InstallerUrl, long InstallerSize)`.
+  - `Task<IReadOnlyList<ReleaseInfo>> GetReleasesAsync(CancellationToken)`: haalt de releases op via één statische `HttpClient` (zoals in [ZiplineUploader.cs](src/Kniip/Upload/ZiplineUploader.cs)) met User-Agent `kniip/<versie>`. Drafts, prereleases en tags die niet als versie te lezen zijn vallen af. Gesorteerd van nieuw naar oud.
+  - `static Version CurrentVersion`, genormaliseerd naar 3 delen voor de vergelijking.
+- `src/Kniip/Update/UpdateInstaller.cs`
+  - `Task<string> DownloadAsync(ReleaseInfo, IProgress<double>, CancellationToken)` downloadt naar `%TEMP%\kniip-update\Kniip-Setup-<versie>.exe`. Daarna controleren we of de bestandsgrootte gelijk is aan `size` van de asset.
+  - `Start(string path)` start de installer met `/VERYSILENT /SUPPRESSMSGBOXES /NORESTART /CLOSEAPPLICATIONS`. `UsePreviousTasks` behoudt de eerder gekozen integraties.
+- `src/Kniip/Update/MarkdownRenderer.cs`: zet markdown om naar een WPF `FlowDocument` via **Markdig** (nieuwe NuGet-referentie in [Kniip.csproj](src/Kniip/Kniip.csproj)). Een eigen walker over de AST ondersteunt:
+  - koppen, alinea's, opsommingen (ook genummerd en genest) en citaten
+  - codeblokken en inline code (Consolas, grijze achtergrond), vet, cursief en doorhalen
+  - links: `Hyperlink` die de browser opent, met `Process.Start` zoals `OpenUrl` in `SettingsWindow`
+  - horizontale lijnen
+  - kleuren en lettertypen uit de bestaande resources (`AccentBrush`, `SubtleTextBrush`, Segoe UI)
+
+## Wijzigingen
+- [src/Kniip/Settings/SettingsWindow.xaml](src/Kniip/Settings/SettingsWindow.xaml): nieuwe `TabItem Header="Update"` na "Editor", met:
+  - `CardTitle` "Update", met daaronder "Geïnstalleerde versie: 1.0.0" en een statusregel (`Hint`).
+  - Knoppen `AccentButton` "Updaten naar x.y.z" (verborgen als er geen update is), `SecondaryButton` "Opnieuw controleren" en `FlatButton` "Releasepagina".
+  - `ProgressBar` (verborgen) voor de download.
+  - Changelog in een `FlowDocumentScrollViewer` met vaste hoogte (~300) en een rand. De tab staat al in een `ScrollViewer`, dus de viewer heeft een vaste hoogte nodig.
+- [src/Kniip/Settings/SettingsWindow.xaml.cs](src/Kniip/Settings/SettingsWindow.xaml.cs):
+  - In `Tabs_SelectionChanged` start de eerste keer dat de Update-tab wordt gekozen de controle (`CheckForUpdatesAsync`). Het resultaat blijft bewaard zolang het venster open is.
+  - Changelog: per nieuwere release een kop "Versie x.y.z, d MMMM yyyy" met de body eronder. Is er geen update, dan tonen we de notes van de huidige versie. Is er een fout of offline, dan tonen we een melding in de statusregel.
+  - `Update_Click`:
+    1. Bevestigen met "kniip wordt afgesloten en bijgewerkt".
+    2. Downloaden met voortgang. Tijdens het downloaden zijn de knoppen uitgeschakeld en annuleert sluiten van het venster de download.
+    3. `App.Instance.TryExitForUpdate()`. Lukt dat, dan `UpdateInstaller.Start` en `Shutdown`.
+- [src/Kniip/App.xaml.cs](src/Kniip/App.xaml.cs):
+  - Splits `ExitApplication` op in `bool TryCloseAllWindows()`. Die stopt als er een screencast loopt of als een editor het sluiten tegenhoudt, zodat we de installer pas starten als kniip echt kan stoppen.
+  - Nieuw argument `--updated` in `HandleArguments`: toont de ballon "kniip is bijgewerkt naar versie x.y.z" en gedraagt zich verder als `--tray`.
+- [installer/Kniip.iss](installer/Kniip.iss): extra `[Run]`-regel die kniip opnieuw start na een stille installatie:
+  `Filename: "{app}\{#AppExe}"; Parameters: "--updated"; Flags: nowait; Check: WizardSilent`
+- [README.md](README.md), sectie "Een nieuwe versie publiceren": de releasebeschrijving (markdown) wordt de changelog in kniip, de installerbijlage moet `Kniip-Setup-<versie>.exe` heten, en de repo moet publiek zijn voor de updatecontrole.
+
+## Randgevallen
+- Draai je kniip als losse exe (niet geïnstalleerd), dan installeert de update in `%LOCALAPPDATA%\Programs\Kniip`. Dat is acceptabel; het staat in de bevestiging.
+- Een release zonder installerbijlage: geen knop Updaten, wel een link naar de releasepagina.
+- Een oude download in `%TEMP%\kniip-update` wordt overschreven.
@@ -0,0 +1,66 @@
+---
+name: Vergrootglas bij selectie
+overview: Add a magnifier (circular zoom with crosshair and X/Y coordinates near the cursor) to the snip overlay and the screencast region selector, with a settings checkbox that is on by default. Release as 1.1.5.
+todos:
+  - id: setting
+    content: ShowMagnifier (default true) toevoegen aan AppSettings
+    status: completed
+  - id: control
+    content: "MagnifierControl maken: ronde zoom, raster, kruisdraad, X/Y-badge, plaatsing bij cursor met randcorrectie"
+    status: completed
+  - id: snip
+    content: Vergrootglas in RegionCaptureWindow + doorgeven vanuit App.BeginSnip
+    status: completed
+  - id: screencast
+    content: Vergrootglas in RegionSelectorWindow met vooraf vastgelegd beeld vanuit RecordingController.BeginSelection
+    status: completed
+  - id: settings-ui
+    content: Checkbox in SettingsWindow (tab Sneltoetsen) laden en opslaan
+    status: completed
+  - id: release
+    content: CHANGELOG 1.1.5, README, versienummers, build.ps1 draaien, commit/tag 1.1.5 en pushen
+    status: completed
+isProject: false
+---
+
+# Vergrootglas bij het kiezen van een gebied (1.1.5)
+
+## Starting point
+- kniip has no magnifier yet. The snip overlay [src/Kniip/Capture/RegionCaptureWindow.xaml](src/Kniip/Capture/RegionCaptureWindow.xaml) shows a frozen screenshot (`Frozen`), a dim layer, the selection and a `W × H` badge.
+- The screencast selector [src/Kniip/Recording/RegionSelectorWindow.xaml](src/Kniip/Recording/RegionSelectorWindow.xaml) is a transparent overlay over the live screen. It has no image to zoom into.
+
+## Approach
+
+```mermaid
+flowchart LR
+    Settings["AppSettings.ShowMagnifier"] --> App["App.BeginSnip"]
+    Settings --> Rec["RecordingController.BeginSelection"]
+    App -->|"frozen image + flag"| Snip[RegionCaptureWindow]
+    Rec -->|"capture per screen + flag"| Sel[RegionSelectorWindow]
+    Snip --> Mag[MagnifierControl]
+    Sel --> Mag
+```
+
+1. **Setting**: in [src/Kniip/Settings/AppSettings.cs](src/Kniip/Settings/AppSettings.cs) add
+   `public bool ShowMagnifier { get; set; } = true;` with a Dutch doc comment.
+2. **Shared control**: new `src/Kniip/Capture/MagnifierControl.xaml(.cs)` (UserControl, `IsHitTestVisible="False"`), styled like the screenshot:
+   - A round clipped area (about 130 DIP) showing an `Image` of the frozen bitmap with `NearestNeighbor` scaling. A `CroppedBitmap` of about 15x15 physical pixels around the cursor is enlarged around 8x.
+   - A pixel grid, a blue crosshair through the center pixel and a small square on the center pixel. The crosshair uses `AccentBrush`, the ring is white with a shadow.
+   - Below the circle, a badge in the same style as `SizeBadge` with `X: … Y: …` in physical screen coordinates.
+   - Method `Update(BitmapSource frozen, System.Drawing.Point physicalRelative, System.Drawing.Point screenPoint)`. Pixels outside the image are left black.
+   - Placement: bottom-right of the cursor at about 20 DIP offset. It flips left and/or up near the screen edge.
+3. **Snip overlay** [src/Kniip/Capture/RegionCaptureWindow.xaml.cs](src/Kniip/Capture/RegionCaptureWindow.xaml.cs):
+   - Add a constructor parameter `bool showMagnifier` and add `<local:MagnifierControl x:Name="Magnifier" Visibility="Collapsed"/>` to the Grid.
+   - In `OnMouseMove`, update and show the magnifier while it is on (before and during dragging). Not in window-pick mode (`PicksWindow`), because exact pixels don't matter there. Hide it on `MouseLeave`.
+   - [src/Kniip/App.xaml.cs](src/Kniip/App.xaml.cs) `BeginSnip` passes `Settings.ShowMagnifier`.
+4. **Screencast selector** [src/Kniip/Recording/RegionSelectorWindow.xaml.cs](src/Kniip/Recording/RegionSelectorWindow.xaml.cs):
+   - Add an optional `BitmapSource? frozen` constructor parameter. When it is set, the same magnifier runs in `OnMouseMove` (also while hovering over windows, because you can drag from there).
+   - [src/Kniip/Recording/RecordingController.cs](src/Kniip/Recording/RecordingController.cs) `BeginSelection`: if `_settings.ShowMagnifier` is on, call `ScreenGrabber.Capture(screen.Bounds)` per screen *before* the selectors are shown, so the overlay is not in the image. Otherwise pass `null`.
+5. **Settings screen** [src/Kniip/Settings/SettingsWindow.xaml](src/Kniip/Settings/SettingsWindow.xaml) tab **Sneltoetsen**: below the hotkeys, add a card title "Gebied kiezen" with
+   `<CheckBox x:Name="MagnifierBox" Content="Vergrootglas tonen bij het kiezen van een gebied (knipsel en screencast)" />`.
+   In [SettingsWindow.xaml.cs](src/Kniip/Settings/SettingsWindow.xaml.cs), add a line to `LoadFrom` (around line 100) and to the save step (around line 444).
+6. **Release 1.1.5**:
+   - [CHANGELOG.md](CHANGELOG.md) gets a new section `## 1.1.5 - 2026-11-09` with a **Nieuw** entry for the magnifier (round zoom with crosshair and X/Y, for both snips and screencasts) and how to turn it off.
+   - [README.md](README.md): the version table and build comment go to 1.1.5.
+   - Version 1.1.4 becomes 1.1.5 in [build.ps1](build.ps1), [installer/Kniip.iss](installer/Kniip.iss) and [src/Kniip/Kniip.csproj](src/Kniip/Kniip.csproj).
+   - Run `.\build.ps1`, then commit "1.1.5", tag `1.1.5` and push, the same way as 1.1.4. You create the release on git.hibbit.net yourself; I'll supply the changelog text.
@@ -0,0 +1,109 @@
+# Changelog
+
+Alle noemenswaardige wijzigingen in kniip staan in dit bestand. De nieuwste versie staat bovenaan.
+
+## 1.1.5 - 2026-11-09
+
+### Nieuw
+
+- **Split-weergave.** De editor kan nu ook twee werkbalken tonen. Bovenaan staan de gereedschappen in het midden, met **Instellingen** rechts en daaronder de eigenschappen (kleur, dikte, lijnstijl). Onderaan staan **Nieuw** en **Screencast** links, **Opslaan**, **Uploaden** en **Kopiëren** in het midden en de zoomknoppen rechts. Kies de indeling in de instellingen onder **Editor** > **Werkbalk**, of klik met rechts op een werkbalk en kies **Indeling**.
+  - In beide werkbalken kun je knoppen verslepen (na ontgrendelen) en verbergen, net als bij één werkbalk. Beide indelingen onthouden hun eigen volgorde.
+  - Split-weergave is de nieuwe standaard. Wil je de vertrouwde indeling terug, kies dan **Eén werkbalk**.
+- **Vergrootglas bij het kiezen van een gebied.** Bij het knippen van een rechthoek en bij het kiezen van een opnamegebied voor een screencast loopt naast de muisaanwijzer een rond vergrootglas mee. Je ziet de pixels rond de aanwijzer vergroot met een raster en een blauwe kruisdraad, en daaronder de schermcoördinaten (X en Y). Zo zet je een hoek precies op de goede pixel. Bij **Venster knippen** verschijnt het vergrootglas niet.
+  - Het vergrootglas staat standaard aan. Wil je het niet, zet dan in de instellingen onder **Sneltoetsen** > **Gebied kiezen** het vinkje **Vergrootglas tonen bij het kiezen van een gebied** uit.
+- **Schermafdruk vertraging.** In het systeemvakmenu staat **Schermafdruk vertraging: 0s**. Stel daar met de schuifbalk of het getalveld 0 tot 60 seconden in. **Rechthoek knippen** en **Venster knippen** wachten dan zo lang voordat het scherm bevriest, ook via de sneltoets. Zo kun je eerst een menu openklappen of een tooltip laten verschijnen.
+  - Bij de muis telt een klein venster af. Dat venster komt zelf niet in het knipsel. Druk op Esc of klik op het venster om te annuleren.
+  - Bij 0 seconden knip je direct, zoals voorheen. Screencasts en de knop **Nieuw** in de editor wachten niet.
+- **Geschiedenis.** kniip houdt nu bij wat je opslaat en uploadt: knipsels en screencasts, met het bestand en de link. Knipsels die je alleen kopieert of niet bewaart, komen er niet in. Het systeemvakmenu heeft vier nieuwe items:
+  - **Map openen**, met de map Schermafbeeldingen, je knipselmap en je screencastmap.
+  - **Geschiedenis...** opent een lijst met datum, soort, naam, map en link. Je kunt zoeken op naam of link.
+  - **Afbeeldingsgeschiedenis...** opent hetzelfde venster met miniaturen. Ook een knipsel dat je alleen hebt geüpload heeft een miniatuur.
+  - **Recente items** toont de laatste tien. Klik op een item om het te openen, of ga naar het submenu voor **Openen in de editor**, **Link kopiëren**, **Afbeelding kopiëren**, **Pad kopiëren** en **Tonen in map**.
+
+  Dubbelklik in het geschiedenisvenster om een item te openen. Klik met rechts voor dezelfde acties en voor **Uit geschiedenis verwijderen**. Met **Geschiedenis wissen** maak je de lijst leeg. Je bestanden en uploads blijven dan gewoon bestaan. kniip bewaart de laatste 500 items.
+
+## 1.1.4 - 2026-11-09
+
+### Nieuw
+
+- **Melding bij een nieuwe versie.** kniip kijkt bij het starten en daarna elke dag of er een nieuwere versie is. Is die er, dan staat er een blauwe stip op de knop **Instellingen** in de editor en op de tab **Update** in de instellingen. Wil je dat niet, zet dan in de tab **Update** het vinkje **Automatisch controleren op nieuwe versies** uit.
+- **Uitgebreid rechtermuisknopmenu in de editor.** Klik met rechts op het canvas, ook op een leeg stuk, voor een menu met iconen en sneltoetsen. Wat op dat moment niet kan, staat grijs.
+  - **Ongedaan maken** en **Opnieuw**.
+  - **Verwijder**, **Verwijder alles** (Shift+Delete, de afbeelding blijft staan) en **Samenvoegen** (Ctrl+Shift+F). Samenvoegen maakt de annotaties deel van de afbeelding en kun je ongedaan maken.
+  - **Knip** (Ctrl+X), **Kopieer** (Ctrl+Shift+C), **Plak** (Ctrl+V) en **Dupliceren** (Ctrl+D). Plak via het menu zet de annotatie op de plek waar je rechts klikte. Kopiëren en plakken werkt ook tussen twee editorvensters.
+  - **Naar voorgrond** (Home), **Naar voren** (PageUp), **Naar achteren** (PageDown) en **Naar achtergrond** (End).
+  - **Werkbalken verbergen** (Ctrl+H). Via hetzelfde menu of Ctrl+H haal je ze terug. Bij een nieuwe start zijn ze er altijd weer.
+- **Lijnen en pijlen buigen.** Selecteer een lijn of pijl. Midden op elk stuk staat dan een klein rondje. Sleep dat rondje en het wordt een buigpunt. De lijn loopt daarna als vloeiende kromme door alle punten. Zo kun je zoveel buigpunten toevoegen als je wilt.
+  - Dubbelklik op een buigpunt om het weer te verwijderen.
+  - Bij een pijl draait de punt mee met de richting van het laatste stuk.
+  - Met Shift springen begin- en eindpunt in stappen van 45°, gemeten vanaf het buigpunt ernaast.
+  - Toevoegen, verschuiven en verwijderen van buigpunten kun je ongedaan maken.
+
+### Gewijzigd
+
+- kniip zoekt nu standaard zelf op de achtergrond naar updates. Tot nu toe gebeurde dat alleen als je de tab **Update** opende of op **Opnieuw controleren** klikte. Een mislukte controle, bijvoorbeeld zonder internet, geeft geen foutmelding.
+- **Ctrl+V** plakt nu eerst een gekopieerde annotatie. Heb je daarna iets anders gekopieerd, dan opent Ctrl+V zoals voorheen de afbeelding van het klembord.
+- Het rechtermuisknopmenu van de werkbalk heeft dezelfde nieuwe stijl gekregen.
+- **Testversie naast kniip.** `build.ps1` maakt nu ook `KniipTest-<versie>.exe`. Die testversie heeft eigen instellingen en registervermeldingen, zodat hij naast de geïnstalleerde kniip kan draaien zonder die te raken. De testversie werkt zichzelf niet bij. Met `-SkipTest` sla je hem over.
+
+## 1.1.3 - 2026-11-09
+
+### Nieuw
+
+- **Sneltoets voor het klembord.** In de tab **Sneltoetsen** kun je een combinatie zetten op **Vanaf klembord**. Die opent de afbeelding op het klembord in de editor. Standaard is er geen sneltoets. De gekozen combinatie staat ook bij **Bewerken vanaf klembord** in het systeemvakmenu.
+- **Afbeelding naar de editor slepen.** Sleep een afbeeldingsbestand, of een afbeelding uit een ander programma, naar het kniip-venster. kniip vraagt daarna of je die afbeelding wilt openen, zodat een lopende bewerking niet zomaar verdwijnt.
+
+## 1.1.2 - 2026-11-09
+
+### Opgelost
+
+- **Link kopiëren na uploaden.** Na het uploaden kon kniip de link soms niet op het klembord zetten en meldde dan dat het klembord bezet was. Dat gebeurde vooral als de klembordgeschiedenis van Windows (Win+V) of een ander klembordprogramma actief is. kniip zet de link nu op een directere manier op het klembord en probeert het langer opnieuw. Dit geldt ook voor het uploaden van screencasts en de test-upload in de instellingen.
+
+## 1.1.1 - 2026-11-09
+
+### Gewijzigd
+
+- **Instellingen zonder scrollbalk.** Het instellingenvenster is iets hoger geworden, zodat elke tab, ook **Opslaan** met de nieuwe naamvelden, in één keer past. De changelog in de tab **Update** heeft daardoor ook meer ruimte.
+
+### Opgelost
+
+- De downloadlinks in de handleiding (README) wezen naar een verkeerde tag en gaven een foutmelding.
+
+## 1.1.0 - 2026-11-09
+
+### Nieuw
+
+- **Updaten vanuit kniip.** In de instellingen staat een nieuwe tab **Update**. kniip kijkt op git.hibbit.net of er een nieuwere versie is en toont de wijzigingen van alle nieuwere versies, netjes opgemaakt. Met **Updaten** downloadt kniip de installer, sluit zichzelf af, installeert de nieuwe versie op de achtergrond en start daarna opnieuw. Je eerder gekozen instellingen, zoals starten met Windows en 'Openen met', blijven staan.
+  - Na een update meldt kniip in het systeemvak naar welke versie het is bijgewerkt.
+  - Er wordt alleen gecontroleerd als je de tab opent of op **Opnieuw controleren** klikt; kniip zoekt niet zelf op de achtergrond naar updates.
+  - Loopt er nog een screencast, of wil je een open knipsel eerst opslaan, dan wacht de update tot dat klaar is.
+- **Naamsjabloon voor opslaan.** In de tab **Opslaan** stel je per soort (knipsels en screencasts) zelf in hoe bestanden heten. Je kunt deze codes gebruiken:
+  - `%J` jaar, `%M` maand en `%D` dag (bijvoorbeeld `2026`, `11`, `09`)
+  - `%V` de naam van het programma waarvan je een knipsel of opname maakt, bijvoorbeeld `chrome`
+  - `%R6` zes willekeurige letters en cijfers
+  - `%N3` een oplopend nummer met drie cijfers (`001`, `002`, ...), per map opnieuw geteld
+  - `/` maakt een submap; kniip maakt die mappen zelf aan.
+
+  Zo wordt `%J/%M-%D/%V_%N3` bijvoorbeeld `2026/11-09/chrome_001.png`. Onder het veld zie je meteen een voorbeeld. De extensie (`.png`, `.mp4` of `.gif`) zet kniip er zelf achter. Laat je het veld leeg, dan blijft de vertrouwde naam staan: `Knipsel` of `Screencast` met datum en tijd.
+- **Autostart-vermelding opruimen.** Heb je kniip ooit als losse exe gestart, dan kan er een vermelding in **Instellingen > Apps > Opstarten** achterblijven. Met `tools\remove-autostart.cmd` haal je die weg. Beheerdersrechten zijn daarvoor niet nodig.
+
+### Gewijzigd
+
+- Het versienummer staat nu ook in de naam van de losse exe (`Kniip-1.1.0.exe`), naast de installer (`Kniip-Setup-1.1.0.exe`).
+- De handleiding (README) beschrijft nu het downloaden, installeren, verwijderen en publiceren van nieuwe versies, en heeft een schermafbeelding van de editor.
+
+### Let op
+
+- Vanaf 1.0.0 moet je deze versie nog één keer zelf installeren met `Kniip-Setup-1.1.0.exe`. Daarna kun je volgende versies bijwerken via **Instellingen > Update**.
+
+## 1.0.0 - 2026-11-07
+
+Eerste stabiele versie.
+
+- **Annotatie-editor** naast het Windows Knipprogramma: voeg pijlen, lijnen, rechthoeken en andere vormen, tekst, markeringen, genummerde stappen, emoji, muisaanwijzers en vervaging toe aan een knipsel. Met ongedaan maken en opnieuw doen, en een werkbalk die je zelf kunt indelen.
+- **Knipsels oppikken**: kniip ziet nieuwe afbeeldingen van het Knipprogramma op het klembord of in de map Schermafbeeldingen, en toont dan een melding of opent meteen de editor.
+- **Eigen sneltoetsen** voor een rechthoek of een venster knippen, ook met Print Screen.
+- **Screencasts** van een gekozen gebied, met systeemgeluid, microfoon, muisaanwijzer en gemarkeerde muisklikken. Daarna knippen en exporteren als MP4-video of GIF.
+- **Opslaan, kopiëren en uploaden**: opslaan in een vaste map of elke keer kiezen, desgewenst ook naar het klembord, en uploaden naar een eigen Zipline-server. Na het uploaden staat de link op het klembord.
+- **Windows-integratie**: draait op de achtergrond in het systeemvak, kan starten met Windows en staat in 'Openen met' voor afbeeldingen.
+- **Installer** per gebruiker, zonder beheerdersrechten en zonder losse .NET-installatie.
@@ -5,23 +5,38 @@
 <h1 align="center">kniip</h1>

 <p align="center">
-  Annotatie-editor naast het Windows Knipprogramma
+  <b>kniip</b> is een uitgebreide annotatie-editor voor Windows. Leg iets op je scherm vast, maak het duidelijk met annotaties en deel het als afbeelding, video, GIF of link.
 </p>

 <p align="center">
-  <a href="https://git.hibbit.net/rogier/kniip/releases"><strong>Download de installer</strong></a>
+  <a href="https://git.hibbit.net/rogier/kniip/releases"><strong>Download: kniip</strong></a>
 </p>

 ---

 kniip is een annotatie-editor die naast het Windows Knipprogramma werkt. Maak een schermafbeelding, voeg pijlen, tekst, markeringen, stappen, emoji of vervaging toe en sla het resultaat op, kopieer het of upload het. kniip kan ook schermopnames maken en die exporteren als video of GIF.

+<p align="center">
+  <a href="screenshot/kniip.png"><img src="screenshot/kniip.png" alt="Screenshot van de kniip-editor" width="720"></a>
+</p>
+
+## Wat kan kniip?
+
+- **Knippen tot op de pixel.** Rechthoek of venster, met een vergrootglas voor precieze hoeken en een instelbare vertraging om eerst een menu of tooltip te openen.
+- **Aantekenen.** Pijlen en lijnen die je kunt buigen, tekst, vormen, genummerde stappen, markeerstift, emoji en vervaging.
+- **Screencasts.** Neem een deel van je scherm op en exporteer als video of GIF.
+- **Delen.** Opslaan, kopiëren naar het klembord of uploaden en de link meteen delen.
+- **Geschiedenis.** Vind eerdere knipsels en uploads terug, met miniaturen en zoeken.
+- **Jouw werkbalk.** Kies een of twee werkbalken, versleep knoppen en verberg wat je niet gebruikt.
+- **Altijd bij.** kniip meldt zelf wanneer er een nieuwe versie is en werkt zichzelf bij met een klik.
+
 ## Downloaden

 | Versie | Installer |
 | ------ | --------- |
-| Nieuwste versie | [Alle releases](https://git.hibbit.net/rogier/kniip/releases) |
-| 1.0.0 | [Kniip-Setup-1.0.0.exe](https://git.hibbit.net/rogier/kniip/releases/download/v1.0.0/Kniip-Setup-1.0.0.exe) |
+| 1.1.5 | [Kniip-Setup-1.1.5.exe](https://git.hibbit.net/rogier/kniip/releases/download/1.1.5/Kniip-Setup-1.1.5.exe) |
+
+Oudere versies vind je bij [alle releases](https://git.hibbit.net/rogier/kniip/releases).

 ## Installeren

@@ -45,6 +60,16 @@ Een losse .NET-installatie is niet nodig; de installer bevat alles wat kniip nod

 Verwijder kniip via **Instellingen > Apps > Geïnstalleerde apps**. Autostart en de 'Openen met'-registratie worden daarbij ook opgeruimd.

+Heb je alleen `Kniip.exe` gestart en geen installer gebruikt, dan staat kniip mogelijk nog bij **Instellingen > Apps > Opstarten**. Die regel wijst naar de map waar de exe toen stond. De schakelaar daar uitzetten verbergt kniip niet: Windows bewaart de regel en zet hem alleen op uit.
+
+`tools\remove-autostart.cmd` haalt de regel weg. Dubbelklik het bestand, of voer uit:
+
+```powershell
+powershell -NoProfile -ExecutionPolicy Bypass -File .\tools\remove-autostart.ps1
+```
+
+Het script geldt voor de aangemelde gebruiker. Het pad van de exe maakt niet uit en het bestand hoeft er niet meer te staan. Beheerdersrechten zijn niet nodig. Elke Windows-account heeft een eigen opstartlijst, dus draai het in de account waarin kniip een keer is gestart. Blijft de vermelding daarna zichtbaar, log dan een keer uit en weer in.
+
 ## Zelf bouwen

 Vereisten:
@@ -55,17 +80,45 @@ Vereisten:
 Bouwen:

 ```powershell
-.\build.ps1                  # versie 1.0.0
+.\build.ps1                  # versie 1.1.5
 .\build.ps1 -Version 1.2.0   # andere versie
 ```

 Het script levert op:

 - `artifacts\publish\Kniip.exe`: zelfstandige exe, draait zonder installatie
+- `artifacts\Kniip-<versie>.exe`: dezelfde exe, met het versienummer in de naam
 - `artifacts\Kniip-Setup-<versie>.exe`: de installer (alleen als Inno Setup 6 gevonden is)
+- `artifacts\KniipTest-<versie>.exe`: testversie (overslaan met `-SkipTest`)
+
+### Testversie
+
+De testversie draait naast de geïnstalleerde kniip en raakt die niet aan. Hij gebruikt overal `KniipTest` in plaats van `Kniip`: de autostartregel, de 'Openen met'-registratie (`KniipTest.Image`), de instellingenmap `%APPDATA%\KniipTest` en de single-instance-mutex. Bij de eerste start kopieert hij de instellingen van de gewone kniip. Zichzelf bijwerken doet hij niet, want de installer zou de gewone kniip overschrijven.
+
+Opruimen hoeft alleen als je in de testversie autostart of 'Openen met' hebt aangezet:
+
+```powershell
+.\artifacts\KniipTest-<versie>.exe --unregister
+Remove-Item "$env:APPDATA\KniipTest" -Recurse   # optioneel: instellingen van de testversie
+```
+
+Draaien beide versies tegelijk, dan reageren ze allebei op dezelfde sneltoetsen en knipsels. Sluit de gewone kniip tijdens het testen, of kies in de testversie andere sneltoetsen.

 ## Een nieuwe versie publiceren

 1. Bouw met `.\build.ps1 -Version <versie>`.
 2. Maak op [git.hibbit.net](https://git.hibbit.net/rogier/kniip/releases) een release met tag `v<versie>` en voeg `artifacts\Kniip-Setup-<versie>.exe` toe als bijlage.
-3. Voeg de nieuwe versie toe aan de tabel onder [Downloaden](#downloaden).
+3. Schrijf de wijzigingen in markdown in de beschrijving van de release. kniip toont die als changelog onder **Instellingen > Update**.
+4. Vervang de versie en de link in de tabel onder [Downloaden](#downloaden) door de nieuwe versie.
+
+### Updaten vanuit kniip
+
+Onder **Instellingen > Update** controleert kniip via de API van git.hibbit.net of er een nieuwere release is en toont de changelog van alle nieuwere versies. **Updaten** downloadt de installer, sluit kniip, installeert stil en start kniip opnieuw. De eerder gekozen integraties blijven behouden.
+
+kniip controleert ook zelf bij het starten en daarna elke 24 uur. Is er een nieuwere versie, dan staat er een blauwe stip op de knop **Instellingen** in de editor en op de tab **Update**. Dit zet je uit met **Automatisch controleren op nieuwe versies** in die tab.
+
+Voorwaarden:
+
+- De repository `rogier/kniip` is publiek; kniip gebruikt geen token.
+- De tag is een versienummer (`v1.2.0`); concepten en voorversies worden overgeslagen.
+- De bijlage heet `Kniip-Setup-<versie>.exe`. Zonder bijlage toont kniip alleen de changelog en een link naar de releasepagina.
@@ -1,19 +1,27 @@
-# Publiceert kniip als zelfstandige single-file exe (geen .NET-installatie nodig op de doel-pc)
+# Publiceert kniip als zelfstandige single-file exe (geen .NET-installatie nodig op de doel-pc)
 # en bouwt de installer als Inno Setup 6 aanwezig is.
 # ScreenRecorderLib (screencasts) is een C++/CLI-assembly die niet uit de bundel geladen kan worden;
 # IncludeAllContentForSelfExtract pakt daarom bij de eerste start alles uit naar %TEMP%\.net.
 #
-#   .\build.ps1                 -> artifacts\publish\Kniip.exe (+ installer indien mogelijk)
+#
+# Elke build levert ook artifacts\KniipTest-<versie>.exe: een testversie met eigen register-, instellingen-
+# en mutexnamen (KniipTest), die naast de geïnstalleerde kniip draait zonder diens registratie te raken.
+#
+#   .\build.ps1                 -> artifacts\publish\Kniip.exe (+ installer indien mogelijk) + testexe
 #   .\build.ps1 -Version 1.2.0
+#   .\build.ps1 -SkipTest       -> zonder testexe

 param(
-    [string]$Version = "1.0.0",
-    [string]$Runtime = "win-x64"
+    [string]$Version = "1.1.5",
+    [string]$Runtime = "win-x64",
+    [switch]$SkipTest
 )

 $ErrorActionPreference = "Stop"
 $root = $PSScriptRoot
+$project = Join-Path $root "src\Kniip\Kniip.csproj"
 $publishDir = Join-Path $root "artifacts\publish"
+$testPublishDir = Join-Path $root "artifacts\publish-test"

 # Gebruik een SDK in het gebruikersprofiel als er geen systeembrede SDK is.
 $localDotnet = Join-Path $env:LOCALAPPDATA "Microsoft\dotnet"
@@ -22,21 +30,31 @@ if (-not (dotnet --list-sdks 2>$null) -and (Test-Path (Join-Path $localDotnet "d
    $env:PATH = "$localDotnet;$env:PATH"
 }

-if (Test-Path $publishDir) { Remove-Item $publishDir -Recurse -Force }
+function Publish-Kniip([string]$outputDir, [bool]$test) {
+    if (Test-Path $outputDir) { Remove-Item $outputDir -Recurse -Force }

-dotnet publish (Join-Path $root "src\Kniip\Kniip.csproj") `
-    -c Release -r $Runtime --self-contained true `
-    -p:PublishSingleFile=true `
-    -p:IncludeNativeLibrariesForSelfExtract=true `
-    -p:IncludeAllContentForSelfExtract=true `
-    -p:EnableCompressionInSingleFile=true `
-    -p:DebugType=none `
-    -p:Version=$Version `
-    -o $publishDir
-if ($LASTEXITCODE -ne 0) { throw "dotnet publish is mislukt." }
+    dotnet publish $project `
+        -c Release -r $Runtime --self-contained true `
+        -p:PublishSingleFile=true `
+        -p:IncludeNativeLibrariesForSelfExtract=true `
+        -p:IncludeAllContentForSelfExtract=true `
+        -p:EnableCompressionInSingleFile=true `
+        -p:DebugType=none `
+        -p:Version=$Version `
+        -p:KniipTest=$($test.ToString().ToLowerInvariant()) `
+        -o $outputDir
+    if ($LASTEXITCODE -ne 0) { throw "dotnet publish is mislukt." }
+}
+
+Publish-Kniip $publishDir $false

 Write-Host "Gepubliceerd: $publishDir\Kniip.exe" -ForegroundColor Green

+# Losse exe met versienummer; de installer blijft Kniip.exe uit de publish-map gebruiken.
+$portableExe = Join-Path $root "artifacts\Kniip-$Version.exe"
+Copy-Item (Join-Path $publishDir "Kniip.exe") $portableExe -Force
+Write-Host "Losse exe: $portableExe" -ForegroundColor Green
+
 $iscc = @(
    "${env:ProgramFiles(x86)}\Inno Setup 6\ISCC.exe",
    "$env:ProgramFiles\Inno Setup 6\ISCC.exe",
@@ -50,3 +68,10 @@ if ($iscc) {
 } else {
    Write-Host "Inno Setup 6 niet gevonden; installer overgeslagen (winget install JRSoftware.InnoSetup)." -ForegroundColor Yellow
 }
+
+if (-not $SkipTest) {
+    Publish-Kniip $testPublishDir $true
+    $testExe = Join-Path $root "artifacts\KniipTest-$Version.exe"
+    Copy-Item (Join-Path $testPublishDir "Kniip.exe") $testExe -Force
+    Write-Host "Testversie: $testExe" -ForegroundColor Green
+}
@@ -5,7 +5,7 @@
 #define AppName "kniip"
 #define AppExe "Kniip.exe"
 #ifndef AppVersion
-  #define AppVersion "1.0.0"
+  #define AppVersion "1.1.5"
 #endif
 #ifndef PublishDir
  #define PublishDir "..\artifacts\publish"
@@ -75,6 +75,8 @@ Root: HKCU; Subkey: "Software\Classes\.gif\OpenWithProgids"; ValueType: none; Va

 [Run]
 Filename: "{app}\{#AppExe}"; Description: "kniip nu starten"; Flags: nowait postinstall skipifsilent
+; Stille installatie = update vanuit kniip zelf; daarna opnieuw starten.
+Filename: "{app}\{#AppExe}"; Parameters: "--updated"; Flags: nowait; Check: WizardSilent

 [UninstallRun]
 Filename: "{cmd}"; Parameters: "/C taskkill /IM {#AppExe} /F"; Flags: runhidden; RunOnceId: "StopKniip"
@@ -293,6 +293,92 @@
            </Setter>
        </Style>

+        <!-- Contextmenu's: icoon, tekst, sneltoets en eventueel een submenu -->
+        <Style TargetType="ContextMenu">
+            <Setter Property="FontFamily" Value="Segoe UI" />
+            <Setter Property="FontSize" Value="13" />
+            <Setter Property="Foreground" Value="{StaticResource InkBrush}" />
+            <Setter Property="HasDropShadow" Value="False" />
+            <Setter Property="Grid.IsSharedSizeScope" Value="True" />
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="ContextMenu">
+                        <Border Background="{StaticResource ToolbarBrush}" BorderBrush="#D6D6D6" BorderThickness="1" CornerRadius="8"
+                                Padding="4" Margin="0,0,10,10" MinWidth="220">
+                            <Border.Effect>
+                                <DropShadowEffect BlurRadius="12" ShadowDepth="2" Opacity="0.18" />
+                            </Border.Effect>
+                            <ItemsPresenter KeyboardNavigation.DirectionalNavigation="Cycle" />
+                        </Border>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <Style x:Key="{x:Static MenuItem.SeparatorStyleKey}" TargetType="Separator">
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="Separator">
+                        <Border Height="1" Margin="6,4" Background="{StaticResource DividerBrush}" />
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
+        <Style TargetType="MenuItem">
+            <Setter Property="Foreground" Value="{StaticResource InkBrush}" />
+            <Setter Property="FocusVisualStyle" Value="{x:Null}" />
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="MenuItem">
+                        <Border x:Name="Bd" Background="Transparent" CornerRadius="4" Padding="8,6" SnapsToDevicePixels="True">
+                            <Grid>
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="28" />
+                                    <ColumnDefinition Width="*" SharedSizeGroup="MenuHeader" />
+                                    <ColumnDefinition Width="Auto" SharedSizeGroup="MenuGesture" />
+                                    <ColumnDefinition Width="16" />
+                                </Grid.ColumnDefinitions>
+                                <ContentPresenter x:Name="IconHost" ContentSource="Icon" VerticalAlignment="Center" HorizontalAlignment="Left" />
+                                <TextBlock x:Name="Check" Text="&#xE73E;" FontFamily="{StaticResource IconFont}" FontSize="12"
+                                           VerticalAlignment="Center" HorizontalAlignment="Left" Visibility="Collapsed" />
+                                <ContentPresenter Grid.Column="1" ContentSource="Header" RecognizesAccessKey="True" VerticalAlignment="Center" />
+                                <TextBlock Grid.Column="2" Text="{TemplateBinding InputGestureText}" Margin="24,0,0,0"
+                                           Foreground="{StaticResource SubtleTextBrush}" VerticalAlignment="Center" HorizontalAlignment="Right" />
+                                <TextBlock x:Name="Arrow" Grid.Column="3" Text="&#xE76C;" FontFamily="{StaticResource IconFont}" FontSize="10"
+                                           VerticalAlignment="Center" HorizontalAlignment="Right" Visibility="Collapsed" />
+                                <Popup x:Name="PART_Popup" Placement="Right" HorizontalOffset="6" VerticalOffset="-6" AllowsTransparency="True"
+                                       Focusable="False" PopupAnimation="Fade" IsOpen="{Binding IsSubmenuOpen, RelativeSource={RelativeSource TemplatedParent}}">
+                                    <Border Background="{StaticResource ToolbarBrush}" BorderBrush="#D6D6D6" BorderThickness="1" CornerRadius="8"
+                                            Padding="4" Margin="0,0,10,10" MinWidth="180" Grid.IsSharedSizeScope="True">
+                                        <Border.Effect>
+                                            <DropShadowEffect BlurRadius="12" ShadowDepth="2" Opacity="0.18" />
+                                        </Border.Effect>
+                                        <ItemsPresenter KeyboardNavigation.DirectionalNavigation="Cycle" />
+                                    </Border>
+                                </Popup>
+                            </Grid>
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsChecked" Value="True">
+                                <Setter TargetName="Check" Property="Visibility" Value="Visible" />
+                                <Setter TargetName="IconHost" Property="Visibility" Value="Collapsed" />
+                            </Trigger>
+                            <Trigger Property="HasItems" Value="True">
+                                <Setter TargetName="Arrow" Property="Visibility" Value="Visible" />
+                            </Trigger>
+                            <Trigger Property="IsHighlighted" Value="True">
+                                <Setter TargetName="Bd" Property="Background" Value="{StaticResource HoverBrush}" />
+                            </Trigger>
+                            <Trigger Property="IsEnabled" Value="False">
+                                <Setter Property="Opacity" Value="0.4" />
+                            </Trigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+
        <Style x:Key="PropCombo" TargetType="ComboBox">
            <Setter Property="MinWidth" Value="80" />
            <Setter Property="Height" Value="28" />
@@ -7,11 +7,13 @@ using System.Windows.Media.Imaging;
 using System.Windows.Threading;
 using Kniip.Capture;
 using Kniip.Editor;
+using Kniip.History;
 using Kniip.Infrastructure;
 using Kniip.Interop;
 using Kniip.Notifications;
 using Kniip.Recording;
 using Kniip.Settings;
+using Kniip.Update;
 using Microsoft.Win32;
 using Screen = System.Windows.Forms.Screen;

@@ -22,7 +24,10 @@ public partial class App : Application
    private SingleInstance? _singleInstance;
    private TrayIcon? _tray;
    private SettingsWindow? _settingsWindow;
+    private HistoryWindow? _historyWindow;
    private readonly List<RegionCaptureWindow> _snipWindows = new();
+    private List<SnappedWindow> _snipSnapshot = new();
+    private CountdownWindow? _snipCountdown;
    private uint? _ignoredClipboardSequence;

    public static App Instance => (App)Current;
@@ -36,6 +41,9 @@ public partial class App : Application
    /// <summary>Toetsenbordhaak voor alle sneltoetsen (knipsels en screencasts).</summary>
    internal GlobalHotkeyHook? HotkeyHook { get; private set; }

+    /// <summary>Achtergrondcontrole op nieuwe versies; stuurt de blauwe stip bij Instellingen.</summary>
+    public UpdateNotifier Updates { get; } = new();
+
    protected override void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);
@@ -85,6 +93,12 @@ public partial class App : Application
        _tray.OpenFileRequested += OpenFileWithDialog;
        _tray.SnipRequested += BeginRegionSnip;
        _tray.WindowSnipRequested += BeginWindowSnip;
+        _tray.SetCaptureDelay(Settings.CaptureDelaySeconds);
+        _tray.CaptureDelayChanged += seconds =>
+        {
+            Settings.CaptureDelaySeconds = seconds;
+            SettingsStore.Save(Settings);
+        };
        _tray.RecordRequested += () =>
        {
            if (Recorder.Stage == RecordingStage.Idle)
@@ -98,11 +112,14 @@ public partial class App : Application
        };
        _tray.GifRequested += () => Recorder.Toggle(ScreencastFormat.Gif);
        _tray.SettingsRequested += ShowSettings;
+        _tray.HistoryRequested += ShowHistory;
+        _tray.FoldersProvider = TrayFolders;
        _tray.ExitRequested += ExitApplication;
        _tray.PauseChanged += _ => UpdateCapturePaused();

        HotkeyHook = new GlobalHotkeyHook(Dispatcher);
        ApplyHotkeys();
+        Updates.Apply(Settings.CheckForUpdates);

        _singleInstance.StartServer(received => Dispatcher.BeginInvoke(() => HandleArguments(received, false)));
        HandleArguments(args, true);
@@ -134,6 +151,12 @@ public partial class App : Application
            OpenFile(file);
        }

+        if (args.Contains("--updated", StringComparer.OrdinalIgnoreCase))
+        {
+            _tray?.ShowBalloon("kniip is bijgewerkt", $"Je gebruikt nu versie {UpdateChecker.CurrentVersion}.");
+            return;
+        }
+
        if (files.Length > 0 || args.Contains("--tray", StringComparer.OrdinalIgnoreCase))
        {
            return;
@@ -142,7 +165,7 @@ public partial class App : Application
        if (isFirstStart)
        {
            string? hotkey = HotkeyDisplay(Settings.SnipHotkey);
-            _tray?.ShowBalloon("kniip is actief", hotkey == null
+            _tray?.ShowBalloon($"{AppIdentity.DisplayName} is actief", hotkey == null
                ? "Maak een knipsel met Win + Shift + S. kniip biedt het daarna aan om te bewerken."
                : $"Druk op {hotkey} en sleep een rechthoek om te knippen en te bewerken.");
        }
@@ -163,9 +186,10 @@ public partial class App : Application
        }
    }

-    public void OpenEditor(BitmapSource image)
+    /// <param name="windowName">Programmanaam van het geknipte venster, voor %V in het naamsjabloon.</param>
+    public void OpenEditor(BitmapSource image, string? windowName = null)
    {
-        var editor = new EditorWindow(image, Settings);
+        var editor = new EditorWindow(image, Settings, windowName: windowName);
        editor.Show();
        BringToFront(editor);
    }
@@ -178,20 +202,59 @@ public partial class App : Application
        timer.Tick += (_, _) =>
        {
            timer.Stop();
-            BeginRegionSnip();
+            BeginSnip(pickWindow: false);
        };
        timer.Start();
    }

-    /// <summary>Bevriest alle schermen en laat een rechthoek slepen; het resultaat opent in de editor.</summary>
-    public void BeginRegionSnip() => BeginSnip(pickWindow: false);
+    /// <summary>Bevriest alle schermen (na de ingestelde vertraging) en laat een rechthoek slepen; het resultaat opent in de editor.</summary>
+    public void BeginRegionSnip() => BeginDelayedSnip(pickWindow: false);

-    /// <summary>Bevriest alle schermen en laat een venster aanklikken; het resultaat opent in de editor.</summary>
-    public void BeginWindowSnip() => BeginSnip(pickWindow: true);
+    /// <summary>Bevriest alle schermen (na de ingestelde vertraging) en laat een venster aanklikken; het resultaat opent in de editor.</summary>
+    public void BeginWindowSnip() => BeginDelayedSnip(pickWindow: true);
+
+    private void BeginDelayedSnip(bool pickWindow)
+    {
+        if (_snipCountdown != null)
+        {
+            return;
+        }
+
+        int seconds = Settings.CaptureDelaySeconds;
+        if (seconds <= 0 || _snipWindows.Count > 0)
+        {
+            BeginSnip(pickWindow);
+            return;
+        }
+
+        var countdown = new CountdownWindow(seconds);
+        countdown.Elapsed += () =>
+        {
+            EndCountdown();
+            // Even wachten tot het aftelvenster echt van het scherm is.
+            var timer = new DispatcherTimer { Interval = TimeSpan.FromMilliseconds(150) };
+            timer.Tick += (_, _) =>
+            {
+                timer.Stop();
+                BeginSnip(pickWindow);
+            };
+            timer.Start();
+        };
+        countdown.Cancelled += EndCountdown;
+        _snipCountdown = countdown;
+        ApplyHotkeys();
+        countdown.Start();
+    }
+
+    private void EndCountdown()
+    {
+        _snipCountdown = null;
+        ApplyHotkeys();
+    }

    private void BeginSnip(bool pickWindow)
    {
-        if (_snipWindows.Count > 0 || Recorder.Stage == RecordingStage.Selecting)
+        if (_snipWindows.Count > 0 || _snipCountdown != null || Recorder.Stage == RecordingStage.Selecting)
        {
            return;
        }
@@ -200,11 +263,12 @@ public partial class App : Application
        var cursorPoint = new System.Drawing.Point(cursor.X, cursor.Y);

        // Eerst alle schermen vastleggen, dan pas vensters tonen, anders staat de overlay in het beeld.
-        List<System.Drawing.Rectangle>? windows = pickWindow ? PhysicalWindow.SnapshotWindows(includeOwn: true) : null;
+        _snipSnapshot = PhysicalWindow.Snapshot(includeOwn: true);
+        List<System.Drawing.Rectangle>? windows = pickWindow ? _snipSnapshot.Select(w => w.Bounds).ToList() : null;
        var frozen = Screen.AllScreens.Select(screen => (screen, ScreenGrabber.Capture(screen.Bounds))).ToList();
        foreach ((Screen screen, BitmapSource image) in frozen)
        {
-            var window = new RegionCaptureWindow(screen, image, windows);
+            var window = new RegionCaptureWindow(screen, image, windows, Settings.ShowMagnifier);
            window.Finished += OnRegionSnipFinished;
            _snipWindows.Add(window);
            window.Show();
@@ -249,6 +313,7 @@ public partial class App : Application
            HotkeyHook.Capture = null;
        }

+        System.Drawing.Rectangle? area = _snipWindows.Select(w => w.SelectedArea).FirstOrDefault(a => a != null);
        foreach (RegionCaptureWindow window in _snipWindows)
        {
            window.Finished -= OnRegionSnipFinished;
@@ -256,9 +321,12 @@ public partial class App : Application
        }

        _snipWindows.Clear();
+        List<SnappedWindow> snapshot = _snipSnapshot;
+        _snipSnapshot = new();
        if (image != null)
        {
-            OpenEditor(image);
+            string? windowName = area is { } a ? PhysicalWindow.ProgramNameAt(snapshot, a) : null;
+            OpenEditor(image, windowName);
        }
    }

@@ -284,11 +352,18 @@ public partial class App : Application
            Bind(Settings.WindowHotkey, BeginWindowSnip);
            Bind(Settings.RecordHotkey, () => Recorder.Toggle(ScreencastFormat.Mp4));
            Bind(Settings.GifHotkey, () => Recorder.Toggle(ScreencastFormat.Gif));
+            Bind(Settings.ClipboardHotkey, OpenFromClipboard);
+            if (_snipCountdown is { } countdown)
+            {
+                // Alleen tijdens het aftellen; daarna moet Esc gewoon naar het actieve programma.
+                bindings[new HotkeyGesture(System.Windows.Input.ModifierKeys.None, System.Windows.Input.Key.Escape)] = countdown.Cancel;
+            }
+
            HotkeyHook.Bindings = bindings;
        }

        _tray?.SetHotkeys(HotkeyDisplay(Settings.SnipHotkey), HotkeyDisplay(Settings.WindowHotkey),
-            HotkeyDisplay(Settings.RecordHotkey), HotkeyDisplay(Settings.GifHotkey));
+            HotkeyDisplay(Settings.RecordHotkey), HotkeyDisplay(Settings.GifHotkey), HotkeyDisplay(Settings.ClipboardHotkey));
    }

    /// <summary>Start een screencast: eerst het gebied kiezen, daarna de knoppenbalk.</summary>
@@ -325,9 +400,9 @@ public partial class App : Application
    private void UpdateCapturePaused() =>
        Capture.Paused = (_tray?.IsPaused ?? false) || Recorder.Stage != RecordingStage.Idle;

-    private void OpenScreencast(string path, ScreencastFormat? format)
+    private void OpenScreencast(string path, ScreencastFormat? format, string? windowName)
    {
-        var window = new ScreencastWindow(path, Settings, format);
+        var window = new ScreencastWindow(path, Settings, format, windowName);
        window.Show();
        BringToFront(window);
    }
@@ -418,6 +493,37 @@ public partial class App : Application
        BringToFront(_settingsWindow);
    }

+    public void ShowHistory(bool images)
+    {
+        if (_historyWindow == null)
+        {
+            _historyWindow = new HistoryWindow(images);
+            _historyWindow.Closed += (_, _) => _historyWindow = null;
+            _historyWindow.Show();
+        }
+        else
+        {
+            _historyWindow.ShowImages(images);
+        }
+
+        BringToFront(_historyWindow);
+    }
+
+    private IReadOnlyList<(string Label, string? Path)> TrayFolders()
+    {
+        static string? Existing(params string?[] folders) =>
+            folders.FirstOrDefault(folder => folder is { Length: > 0 } && Directory.Exists(folder));
+
+        return new (string, string?)[]
+        {
+            ("Schermafbeeldingen", Existing(CaptureCoordinator.ScreenshotsFolder)),
+            ("Knipsels", Existing(Settings.SnipSaveFolder, Settings.LastSaveFolder,
+                Environment.GetFolderPath(Environment.SpecialFolder.MyPictures))),
+            ("Screencasts", Existing(Settings.VideoSaveFolder, Settings.LastVideoFolder,
+                Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyVideos), "kniip")))
+        };
+    }
+
    public void ShowBalloon(string title, string text) => _tray?.ShowBalloon(title, text);

    public void SaveSettings()
@@ -425,6 +531,7 @@ public partial class App : Application
        SettingsStore.Save(Settings);
        Capture.ApplySettings(Settings);
        ApplyHotkeys();
+        Updates.Apply(Settings.CheckForUpdates);
    }

    private static void BringToFront(Window window)
@@ -441,12 +548,21 @@ public partial class App : Application
    }

    private void ExitApplication()
+    {
+        if (TryCloseAllWindows())
+        {
+            Shutdown();
+        }
+    }
+
+    /// <summary>Sluit alle vensters; false als een screencast loopt of een editor open blijft.</summary>
+    private bool TryCloseAllWindows()
    {
        if (Recorder.Stage != RecordingStage.Idle)
        {
            MessageBox.Show("Er loopt nog een screencast. Stop of annuleer die eerst.", "kniip",
                MessageBoxButton.OK, MessageBoxImage.Information);
-            return;
+            return false;
        }

        foreach (Window window in Windows.Cast<Window>().ToList())
@@ -454,11 +570,28 @@ public partial class App : Application
            window.Close();
        }

-        if (Windows.OfType<EditorWindow>().Any())
+        return !Windows.OfType<EditorWindow>().Any();
+    }
+
+    /// <summary>Start de gedownloade installer en sluit kniip; de installer start kniip daarna opnieuw.</summary>
+    public void InstallUpdate(string installerPath)
+    {
+        if (!TryCloseAllWindows())
        {
            return;
        }

+        try
+        {
+            UpdateInstaller.Start(installerPath);
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show($"De installer kon niet worden gestart.\n\n{ex.Message}", "kniip",
+                MessageBoxButton.OK, MessageBoxImage.Warning);
+            return;
+        }
+
        Shutdown();
    }

@@ -41,33 +41,14 @@ internal static class ClipboardImageReader
                return null;
            }

-            if (includeFiles && TryReadFile(data) is { } fromFile)
+            if (ReadData(data, includeFiles) is { } image)
            {
-                return fromFile;
+                return image;
            }

-            if (data.GetDataPresent("PNG") && data.GetData("PNG") is MemoryStream png)
+            if (Clipboard.ContainsImage() && Clipboard.GetImage() is { } bitmap)
            {
-                return PixelUtil.Decode(png);
-            }
-
-            if (data.GetDataPresent(DataFormats.Dib) && data.GetData(DataFormats.Dib) is MemoryStream dib)
-            {
-                BitmapSource? fromDib = FromDib(dib.ToArray());
-                if (fromDib != null)
-                {
-                    return fromDib;
-                }
-            }
-
-            if (Clipboard.ContainsImage())
-            {
-                BitmapSource? image = Clipboard.GetImage();
-                if (image != null)
-                {
-                    var copy = PixelUtil.CreateBitmap(PixelUtil.ToOpaqueBgra(image), image.PixelWidth, image.PixelHeight);
-                    return copy;
-                }
+                return OpaqueCopy(bitmap);
            }
        }
        catch (Exception ex) when (ex is COMException or ExternalException or NotSupportedException or FileFormatException)
@@ -78,6 +59,64 @@ internal static class ClipboardImageReader
        return null;
    }

+    /// <summary>Snelle controle tijdens het slepen, zonder te decoderen.</summary>
+    public static bool CanDrop(IDataObject data)
+    {
+        try
+        {
+            return data.GetDataPresent("PNG") || data.GetDataPresent(DataFormats.Dib) || data.GetDataPresent(DataFormats.Bitmap)
+                || (data.GetData(DataFormats.FileDrop) is string[] files && Array.Exists(files, IsImageFile));
+        }
+        catch (Exception ex) when (ex is COMException or ExternalException)
+        {
+            return false;
+        }
+    }
+
+    /// <summary>Afbeelding uit iets dat in kniip is neergezet: een afbeeldingsbestand of afbeeldingsdata.</summary>
+    public static BitmapSource? FromDrop(IDataObject data)
+    {
+        try
+        {
+            if (ReadData(data, includeFiles: true) is { } image)
+            {
+                return image;
+            }
+
+            return data.GetData(DataFormats.Bitmap) is BitmapSource bitmap ? OpaqueCopy(bitmap) : null;
+        }
+        catch (Exception ex) when (ex is COMException or ExternalException or NotSupportedException or FileFormatException)
+        {
+            return null;
+        }
+    }
+
+    private static BitmapSource? ReadData(IDataObject data, bool includeFiles)
+    {
+        if (includeFiles && TryReadFile(data) is { } fromFile)
+        {
+            return fromFile;
+        }
+
+        if (data.GetDataPresent("PNG") && data.GetData("PNG") is MemoryStream png)
+        {
+            return PixelUtil.Decode(png);
+        }
+
+        if (data.GetDataPresent(DataFormats.Dib) && data.GetData(DataFormats.Dib) is MemoryStream dib)
+        {
+            return FromDib(dib.ToArray());
+        }
+
+        return null;
+    }
+
+    private static BitmapSource OpaqueCopy(BitmapSource image) =>
+        PixelUtil.CreateBitmap(PixelUtil.ToOpaqueBgra(image), image.PixelWidth, image.PixelHeight);
+
+    private static bool IsImageFile(string file) =>
+        Array.IndexOf(ImageExtensions, Path.GetExtension(file).ToLowerInvariant()) >= 0;
+
    private static BitmapSource? TryReadFile(IDataObject data)
    {
        if (!data.GetDataPresent(DataFormats.FileDrop) || data.GetData(DataFormats.FileDrop) is not string[] files)
@@ -87,7 +126,7 @@ internal static class ClipboardImageReader

        foreach (string file in files)
        {
-            if (!File.Exists(file) || Array.IndexOf(ImageExtensions, Path.GetExtension(file).ToLowerInvariant()) < 0)
+            if (!File.Exists(file) || !IsImageFile(file))
            {
                continue;
            }
@@ -0,0 +1,21 @@
+<Window x:Class="Kniip.Capture.CountdownWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="kniip" WindowStyle="None" AllowsTransparency="True" Background="Transparent"
+        Topmost="True" ShowInTaskbar="False" ShowActivated="False" ResizeMode="NoResize"
+        SizeToContent="WidthAndHeight" FontFamily="Segoe UI" UseLayoutRounding="True">
+    <Border Margin="10" Background="#FCFCFC" CornerRadius="8" BorderBrush="#DADADA" BorderThickness="1"
+            Cursor="Hand" MouseLeftButtonUp="Border_Click" ToolTip="Klik om te annuleren">
+        <Border.Effect>
+            <DropShadowEffect BlurRadius="14" ShadowDepth="2" Opacity="0.22" />
+        </Border.Effect>
+        <StackPanel Orientation="Horizontal" Margin="12,8,14,8">
+            <TextBlock x:Name="SecondsText" FontSize="28" FontWeight="SemiBold" Foreground="#0067C0"
+                       MinWidth="34" TextAlignment="Center" VerticalAlignment="Center" />
+            <StackPanel Margin="10,0,0,0" VerticalAlignment="Center">
+                <TextBlock Text="Knipsel over" FontSize="12" FontWeight="SemiBold" />
+                <TextBlock Text="Esc om te annuleren" FontSize="11" Foreground="#5C5C5C" />
+            </StackPanel>
+        </StackPanel>
+    </Border>
+</Window>
@@ -0,0 +1,116 @@
+using System;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Threading;
+using Kniip.Interop;
+using Kniip.Recording;
+using Rectangle = System.Drawing.Rectangle;
+using Screen = System.Windows.Forms.Screen;
+
+namespace Kniip.Capture;
+
+/// <summary>Klein venster bij de muis dat aftelt tot een vertraagd knipsel; neemt nooit de focus over.</summary>
+public partial class CountdownWindow : Window
+{
+    private const int CursorOffset = 20;
+
+    private readonly DispatcherTimer _follow = new() { Interval = TimeSpan.FromMilliseconds(40) };
+    private readonly DateTime _end;
+    private bool _finished;
+
+    /// <summary>De tijd is om; het venster is dan al gesloten.</summary>
+    public event Action? Elapsed;
+
+    /// <summary>Geannuleerd met Esc of een klik; het venster is dan al gesloten.</summary>
+    public event Action? Cancelled;
+
+    public CountdownWindow(int seconds)
+    {
+        InitializeComponent();
+        Left = Top = -32000;
+        _end = DateTime.UtcNow.AddSeconds(seconds);
+        SecondsText.Text = seconds.ToString();
+        _follow.Tick += (_, _) => Tick();
+        SourceInitialized += (_, _) =>
+        {
+            NativeMethods.AddExtendedStyle(PhysicalWindow.Handle(this),
+                NativeMethods.WS_EX_TOOLWINDOW | NativeMethods.WS_EX_NOACTIVATE);
+            PhysicalWindow.ExcludeFromCapture(this);
+        };
+        ContentRendered += (_, _) => FollowCursor();
+        Closed += (_, _) =>
+        {
+            _follow.Stop();
+            if (!_finished)
+            {
+                _finished = true;
+                Cancelled?.Invoke();
+            }
+        };
+    }
+
+    public void Start()
+    {
+        Show();
+        FollowCursor();
+        _follow.Start();
+    }
+
+    public void Cancel() => Finish(Cancelled);
+
+    private void Tick()
+    {
+        TimeSpan left = _end - DateTime.UtcNow;
+        if (left <= TimeSpan.Zero)
+        {
+            Finish(Elapsed);
+            return;
+        }
+
+        SecondsText.Text = ((int)Math.Ceiling(left.TotalSeconds)).ToString();
+        FollowCursor();
+    }
+
+    private void FollowCursor()
+    {
+        if (!IsVisible)
+        {
+            return;
+        }
+
+        NativeMethods.GetCursorPos(out NativeMethods.POINT cursor);
+        Rectangle area = Screen.FromPoint(new System.Drawing.Point(cursor.X, cursor.Y)).WorkingArea;
+        Rectangle size = PhysicalWindow.GetBounds(this);
+        int x = cursor.X + CursorOffset, y = cursor.Y + CursorOffset;
+        if (x + size.Width > area.Right)
+        {
+            x = cursor.X - CursorOffset - size.Width;
+        }
+
+        if (y + size.Height > area.Bottom)
+        {
+            y = cursor.Y - CursorOffset - size.Height;
+        }
+
+        x = Math.Max(area.Left, x);
+        y = Math.Max(area.Top, y);
+        if (x != size.X || y != size.Y)
+        {
+            PhysicalWindow.Place(this, new Rectangle(x, y, size.Width, size.Height), resize: false);
+        }
+    }
+
+    private void Finish(Action? handler)
+    {
+        if (_finished)
+        {
+            return;
+        }
+
+        _finished = true;
+        Close();
+        handler?.Invoke();
+    }
+
+    private void Border_Click(object sender, MouseButtonEventArgs e) => Cancel();
+}
@@ -0,0 +1,44 @@
+<UserControl x:Class="Kniip.Capture.MagnifierControl"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             HorizontalAlignment="Left" VerticalAlignment="Top" IsHitTestVisible="False">
+    <StackPanel>
+        <Grid Width="120" Height="120">
+            <Grid.Effect>
+                <DropShadowEffect BlurRadius="10" ShadowDepth="2" Opacity="0.35" />
+            </Grid.Effect>
+            <Grid>
+                <Grid.Clip>
+                    <EllipseGeometry Center="60,60" RadiusX="60" RadiusY="60" />
+                </Grid.Clip>
+                <Image x:Name="Zoom" Stretch="Fill" RenderOptions.BitmapScalingMode="NearestNeighbor" />
+                <Rectangle>
+                    <Rectangle.Fill>
+                        <DrawingBrush Viewport="0,0,8,8" ViewportUnits="Absolute" TileMode="Tile">
+                            <DrawingBrush.Drawing>
+                                <GeometryDrawing>
+                                    <GeometryDrawing.Pen>
+                                        <Pen Brush="#40000000" Thickness="0.5" />
+                                    </GeometryDrawing.Pen>
+                                    <GeometryDrawing.Geometry>
+                                        <RectangleGeometry Rect="0,0,8,8" />
+                                    </GeometryDrawing.Geometry>
+                                </GeometryDrawing>
+                            </DrawingBrush.Drawing>
+                        </DrawingBrush>
+                    </Rectangle.Fill>
+                </Rectangle>
+                <Rectangle Height="8" VerticalAlignment="Top" Margin="0,56,0,0" Fill="{StaticResource AccentBrush}" Opacity="0.55" />
+                <Rectangle Width="8" HorizontalAlignment="Left" Margin="56,0,0,0" Fill="{StaticResource AccentBrush}" Opacity="0.55" />
+                <Rectangle Width="10" Height="10" HorizontalAlignment="Left" VerticalAlignment="Top" Margin="55,55,0,0"
+                           Stroke="White" StrokeThickness="1" />
+                <Rectangle Width="8" Height="8" HorizontalAlignment="Left" VerticalAlignment="Top" Margin="56,56,0,0"
+                           Stroke="#202020" StrokeThickness="1" />
+            </Grid>
+            <Ellipse Stroke="White" StrokeThickness="2" />
+        </Grid>
+        <Border HorizontalAlignment="Center" Margin="0,6,0,0" Background="#E6202020" CornerRadius="4" Padding="6,2">
+            <TextBlock x:Name="CoordinateText" Foreground="White" FontSize="12" />
+        </Border>
+    </StackPanel>
+</UserControl>
@@ -0,0 +1,102 @@
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+
+namespace Kniip.Capture;
+
+/// <summary>Rond vergrootglas met kruisdraad en coördinaten dat naast de muisaanwijzer meeloopt.</summary>
+public partial class MagnifierControl : UserControl
+{
+    private const int Pixels = 15;
+    private const double CursorOffset = 20;
+
+    private static MagnifierControl? _visible;
+
+    private readonly WriteableBitmap _zoom = new(Pixels, Pixels, 96, 96, PixelFormats.Bgra32, null);
+    private readonly byte[] _buffer = new byte[Pixels * Pixels * 4];
+    private readonly TranslateTransform _offset = new();
+
+    public MagnifierControl()
+    {
+        InitializeComponent();
+        Zoom.Source = _zoom;
+        RenderTransform = _offset;
+        Visibility = Visibility.Collapsed;
+        Unloaded += (_, _) => Hide();
+    }
+
+    /// <param name="frozen">Vastgelegd beeld van het scherm.</param>
+    /// <param name="relative">Muispositie in pixels van <paramref name="frozen"/>.</param>
+    /// <param name="screen">Muispositie in fysieke bureaubladcoördinaten, voor de tekst.</param>
+    /// <param name="cursor">Muispositie in het venster (DIP).</param>
+    /// <param name="area">Grootte van het venster (DIP).</param>
+    public void Show(BitmapSource frozen, System.Drawing.Point relative, System.Drawing.Point screen, Point cursor, Size area)
+    {
+        // Elk scherm heeft een eigen overlay; een overlay krijgt soms muisbewegingen terwijl de aanwijzer op een ander scherm staat.
+        if (relative.X < 0 || relative.Y < 0 || relative.X >= frozen.PixelWidth || relative.Y >= frozen.PixelHeight)
+        {
+            Hide();
+            return;
+        }
+
+        if (_visible != this)
+        {
+            _visible?.Hide();
+            _visible = this;
+        }
+
+        CopyPixels(frozen, relative);
+        CoordinateText.Text = $"X: {screen.X} Y: {screen.Y}";
+        Visibility = Visibility.Visible;
+
+        Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
+        Size size = DesiredSize;
+        double left = cursor.X + CursorOffset;
+        if (left + size.Width > area.Width)
+        {
+            left = cursor.X - CursorOffset - size.Width;
+        }
+
+        double top = cursor.Y + CursorOffset;
+        if (top + size.Height > area.Height)
+        {
+            top = cursor.Y - CursorOffset - size.Height;
+        }
+
+        _offset.X = Math.Max(0, left);
+        _offset.Y = Math.Max(0, top);
+    }
+
+    public void Hide()
+    {
+        Visibility = Visibility.Collapsed;
+        if (_visible == this)
+        {
+            _visible = null;
+        }
+    }
+
+    private void CopyPixels(BitmapSource frozen, System.Drawing.Point center)
+    {
+        Array.Clear(_buffer);
+        for (int i = 3; i < _buffer.Length; i += 4)
+        {
+            _buffer[i] = 255;
+        }
+
+        int half = Pixels / 2;
+        int x0 = Math.Max(0, center.X - half);
+        int y0 = Math.Max(0, center.Y - half);
+        int x1 = Math.Min(frozen.PixelWidth, center.X + half + 1);
+        int y1 = Math.Min(frozen.PixelHeight, center.Y + half + 1);
+        if (x1 > x0 && y1 > y0)
+        {
+            int offset = ((y0 - (center.Y - half)) * Pixels + (x0 - (center.X - half))) * 4;
+            frozen.CopyPixels(new Int32Rect(x0, y0, x1 - x0, y1 - y0), _buffer, Pixels * 4, offset);
+        }
+
+        _zoom.WritePixels(new Int32Rect(0, 0, Pixels, Pixels), _buffer, Pixels * 4, 0);
+    }
+}
@@ -1,6 +1,7 @@
 <Window x:Class="Kniip.Capture.RegionCaptureWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:local="clr-namespace:Kniip.Capture"
        Title="kniip rechthoek knippen" WindowStyle="None" ResizeMode="NoResize"
        ShowInTaskbar="False" Topmost="True" Cursor="Cross" FontFamily="Segoe UI" FontSize="13"
        Background="Black">
@@ -13,6 +14,7 @@
                CornerRadius="4" Padding="6,2" Visibility="Collapsed" IsHitTestVisible="False">
            <TextBlock x:Name="SizeText" Foreground="White" FontSize="12" />
        </Border>
+        <local:MagnifierControl x:Name="Magnifier" />
        <Border x:Name="Hint" HorizontalAlignment="Center" VerticalAlignment="Top" Margin="0,28,0,0" Background="#F2FFFFFF"
                CornerRadius="6" Padding="16,9" IsHitTestVisible="False">
            <Border.Effect>
@@ -22,6 +22,7 @@ public partial class RegionCaptureWindow : Window
    private readonly Screen _screen;
    private readonly BitmapSource _frozen;
    private readonly IReadOnlyList<Rectangle>? _windows;
+    private readonly bool _showMagnifier;
    private Point? _dragStart;
    private bool _dragging;
    private Rectangle? _hover;
@@ -29,14 +30,20 @@ public partial class RegionCaptureWindow : Window
    /// <summary>Het knipsel, of null bij annuleren.</summary>
    internal event Action<BitmapSource?>? Finished;

+    /// <summary>Geknipt gebied in fysieke schermcoördinaten, gezet vlak voor Finished.</summary>
+    internal Rectangle? SelectedArea { get; private set; }
+
    /// <param name="windows">Vensterrechthoeken van boven naar onder; gezet = venster aanklikken in plaats van slepen.</param>
-    internal RegionCaptureWindow(Screen screen, BitmapSource frozen, IReadOnlyList<Rectangle>? windows = null)
+    /// <param name="showMagnifier">Vergrootglas bij de muisaanwijzer tonen; niet bij venster aanklikken.</param>
+    internal RegionCaptureWindow(Screen screen, BitmapSource frozen, IReadOnlyList<Rectangle>? windows = null, bool showMagnifier = false)
    {
        InitializeComponent();
        _screen = screen;
        _frozen = frozen;
        _windows = windows;
+        _showMagnifier = showMagnifier && windows == null;
        Frozen.Source = frozen;
+        MouseLeave += (_, _) => Magnifier.Hide();
        if (windows != null)
        {
            Cursor = Cursors.Hand;
@@ -75,12 +82,19 @@ public partial class RegionCaptureWindow : Window
            return;
        }

+        Point position = e.GetPosition(this);
+        if (_showMagnifier)
+        {
+            System.Drawing.Point physical = ToPhysical(position);
+            var relative = new System.Drawing.Point(physical.X - _screen.Bounds.X, physical.Y - _screen.Bounds.Y);
+            Magnifier.Show(_frozen, relative, physical, position, new Size(ActualWidth, ActualHeight));
+        }
+
        if (_dragStart is not Point start || e.LeftButton != MouseButtonState.Pressed)
        {
            return;
        }

-        Point position = e.GetPosition(this);
        if (!_dragging && (position - start).Length >= DragThreshold)
        {
            _dragging = true;
@@ -164,6 +178,7 @@ public partial class RegionCaptureWindow : Window
        }

        var relative = new Int32Rect(clipped.X - _screen.Bounds.X, clipped.Y - _screen.Bounds.Y, clipped.Width, clipped.Height);
+        SelectedArea = clipped;
        Finished?.Invoke(ScreenGrabber.Crop(_frozen, relative));
    }

@@ -0,0 +1,49 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Windows;
+using Kniip.Editor.Annotations;
+
+namespace Kniip.Editor;
+
+/// <summary>
+/// Gekopieerde annotatie, gedeeld tussen editorvensters. Op het Windows-klembord staat alleen een markering,
+/// zodat iets wat daarna in een ander programma wordt gekopieerd bij plakken voorgaat.
+/// </summary>
+internal static class AnnotationClipboard
+{
+    private const string MarkerFormat = "Kniip.Annotation";
+
+    private static Annotation? _item;
+    private static string? _token;
+
+    public static bool Set(Annotation item)
+    {
+        string token = Guid.NewGuid().ToString("N");
+        if (!ClipboardWriter.SetMarker(MarkerFormat, token))
+        {
+            return false;
+        }
+
+        _item = item.Clone();
+        _token = token;
+        return true;
+    }
+
+    /// <summary>Een kopie van de annotatie, of null als het klembord inmiddels iets anders bevat.</summary>
+    public static Annotation? Get()
+    {
+        if (_item == null)
+        {
+            return null;
+        }
+
+        try
+        {
+            return Clipboard.GetData(MarkerFormat) as string == _token ? _item.Clone() : null;
+        }
+        catch (ExternalException)
+        {
+            return null;
+        }
+    }
+}
@@ -12,6 +12,7 @@ namespace Kniip.Editor;
 public sealed class AnnotationSurface : FrameworkElement
 {
    private static readonly Brush AccentBrush = RenderHelpers.Freeze(new SolidColorBrush(Palette.Accent));
+    private static readonly Brush GhostHandleBrush = RenderHelpers.Freeze(new SolidColorBrush(Color.FromArgb(170, 255, 255, 255)));
    private static readonly Brush CropShadeBrush = RenderHelpers.Freeze(new SolidColorBrush(Color.FromArgb(120, 0, 0, 0)));

    public EditorDocument? Document { get; set; }
@@ -74,8 +75,16 @@ public sealed class AnnotationSurface : FrameworkElement

        double size = HandleSize;
        var pen = new Pen(AccentBrush, 1.2 / ViewScale);
-        foreach (Point h in handles)
+        for (int i = 0; i < handles.Count; i++)
        {
+            Point h = handles[i];
+            if (item.IsGhostHandle(i))
+            {
+                double radius = size * 0.35;
+                dc.DrawEllipse(GhostHandleBrush, pen, h, radius, radius);
+                continue;
+            }
+
            dc.DrawRoundedRectangle(Brushes.White, pen, new Rect(h.X - size / 2, h.Y - size / 2, size, size),
                1.5 / ViewScale, 1.5 / ViewScale);
        }
@@ -90,14 +99,20 @@ public sealed class AnnotationSurface : FrameworkElement
    {
        IReadOnlyList<Point> handles = item.GetHandles();
        double tolerance = HandleSize / 2 + 2 / ViewScale;
+        int ghost = -1;
        for (int i = handles.Count - 1; i >= 0; i--)
        {
            if (System.Math.Abs(handles[i].X - p.X) <= tolerance && System.Math.Abs(handles[i].Y - p.Y) <= tolerance)
            {
-                return i;
+                if (!item.IsGhostHandle(i))
+                {
+                    return i;
+                }
+
+                ghost = i;
            }
        }

-        return -1;
+        return ghost;
    }
 }
@@ -33,6 +33,9 @@ public abstract class Annotation

    public virtual IReadOnlyList<Point> GetHandles() => Array.Empty<Point>();

+    /// <summary>Een greep die pas iets wordt als je hem sleept, zoals het middenpunt om een lijn te buigen.</summary>
+    public virtual bool IsGhostHandle(int index) => false;
+
    public virtual void BeginHandleDrag(int index)
    {
    }
@@ -41,6 +44,8 @@ public abstract class Annotation
    {
    }

+    public virtual bool RemoveHandle(int index) => false;
+
    /// <summary>Te klein om te bewaren na het tekenen (bijv. een losse klik met het rechthoek-gereedschap).</summary>
    public virtual bool IsDegenerate => false;

@@ -5,8 +5,16 @@ using System.Windows.Media;

 namespace Kniip.Editor.Annotations;

+/// <summary>
+/// Lijn of pijl. Met buigpunten wordt het een vloeiende kromme die door alle punten loopt.
+/// </summary>
 public sealed class LineAnnotation : Annotation
 {
+    private const int SamplesPerSegment = 16;
+
+    private int _dragBend = -1;
+    private int _pendingGhost = -1;
+
    public LineAnnotation(bool isArrow)
    {
        IsArrow = isArrow;
@@ -18,27 +26,124 @@ public sealed class LineAnnotation : Annotation

    public Point End { get; set; }

+    /// <summary>Tussenpunten waar de kromme doorheen loopt, in volgorde van begin naar eind.</summary>
+    public List<Point> Bends { get; set; } = new();
+
    public override ToolKind Kind => IsArrow ? ToolKind.Arrow : ToolKind.Line;

    public override Rect Bounds
    {
        get
        {
-            var r = new Rect(Start, End);
+            List<Point> points = Flatten();
+            var r = new Rect(points[0], points[0]);
+            foreach (Point p in points)
+            {
+                r.Union(p);
+            }
+
            double pad = Style.Thickness / 2 + (IsArrow ? HeadLength / 2 : 0);
            r.Inflate(pad, pad);
            return r;
        }
    }

-    public override bool IsDegenerate => (End - Start).Length < 4;
+    public override bool IsDegenerate => Bends.Count == 0 && (End - Start).Length < 4;

    private double HeadLength => Math.Max(12, Style.Thickness * 4);

+    private readonly record struct Segment(Point A, Point C1, Point C2, Point B)
+    {
+        public Point At(double t)
+        {
+            double u = 1 - t;
+            double a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
+            return new Point(
+                a * A.X + b * C1.X + c * C2.X + d * B.X,
+                a * A.Y + b * C1.Y + c * C2.Y + d * B.Y);
+        }
+    }
+
+    private List<Point> ThroughPoints()
+    {
+        var points = new List<Point>(Bends.Count + 2) { Start };
+        points.AddRange(Bends);
+        points.Add(End);
+        return points;
+    }
+
+    /// <summary>Catmull-Rom door alle punten, omgezet naar kubische Bezier-segmenten.</summary>
+    private List<Segment> Segments()
+    {
+        List<Point> p = ThroughPoints();
+        int last = p.Count - 1;
+        var segments = new List<Segment>(last);
+        for (int i = 0; i < last; i++)
+        {
+            Point prev = p[Math.Max(i - 1, 0)];
+            Point next = p[Math.Min(i + 2, last)];
+            segments.Add(new Segment(p[i], p[i] + (p[i + 1] - prev) / 6, p[i + 1] - (next - p[i]) / 6, p[i + 1]));
+        }
+
+        return segments;
+    }
+
+    private List<Point> Flatten()
+    {
+        if (Bends.Count == 0)
+        {
+            return new List<Point> { Start, End };
+        }
+
+        var points = new List<Point> { Start };
+        foreach (Segment s in Segments())
+        {
+            for (int k = 1; k <= SamplesPerSegment; k++)
+            {
+                points.Add(s.At(k / (double)SamplesPerSegment));
+            }
+        }
+
+        return points;
+    }
+
+    private static double PathLength(List<Point> points)
+    {
+        double length = 0;
+        for (int i = 1; i < points.Count; i++)
+        {
+            length += (points[i] - points[i - 1]).Length;
+        }
+
+        return length;
+    }
+
+    private Geometry BuildGeometry(List<Segment> segments)
+    {
+        var geometry = new StreamGeometry();
+        using (StreamGeometryContext ctx = geometry.Open())
+        {
+            ctx.BeginFigure(segments[0].A, false, false);
+            foreach (Segment s in segments)
+            {
+                if (Bends.Count == 0)
+                {
+                    ctx.LineTo(s.B, true, true);
+                }
+                else
+                {
+                    ctx.BezierTo(s.C1, s.C2, s.B, true, true);
+                }
+            }
+        }
+
+        geometry.Freeze();
+        return geometry;
+    }
+
    public override void Render(DrawingContext dc, EditorDocument document)
    {
-        Vector v = End - Start;
-        double length = v.Length;
+        double length = PathLength(Flatten());
        if (length < 1)
        {
            return;
@@ -50,18 +155,26 @@ public sealed class LineAnnotation : Annotation
            return;
        }

-        var geometry = new GeometryGroup { FillRule = FillRule.Nonzero };
-        Brush? headFill = null;
+        List<Segment> segments = Segments();

        if (IsArrow)
        {
+            Segment lastSegment = segments[^1];
+            Vector v = lastSegment.B - lastSegment.C2;
+            if (v.Length < 1e-6)
+            {
+                v = lastSegment.B - lastSegment.A;
+            }
+
            v.Normalize();
            double headLength = Math.Min(HeadLength, length);
            double halfWidth = headLength * 0.45;
            Point basePoint = End - v * headLength;
            var normal = new Vector(-v.Y, v.X);

-            geometry.Children.Add(new LineGeometry(Start, basePoint + v * Math.Min(2, headLength / 4)));
+            Point lineEnd = basePoint + v * Math.Min(2, headLength / 4);
+            Vector shift = lineEnd - End;
+            segments[^1] = lastSegment with { C2 = lastSegment.C2 + shift, B = lineEnd };

            var head = new StreamGeometry();
            using (StreamGeometryContext ctx = head.Open())
@@ -72,39 +185,105 @@ public sealed class LineAnnotation : Annotation
            }

            head.Freeze();
-            headFill = RenderHelpers.BrushOrNull(Style.Stroke);
+            Brush? headFill = RenderHelpers.BrushOrNull(Style.Stroke);

            // Lijn en punt apart tekenen zodat de punt gevuld en niet gestippeld wordt.
-            RenderHelpers.DrawWithShadow(dc, geometry, null, pen, Style.Shadow);
+            RenderHelpers.DrawWithShadow(dc, BuildGeometry(segments), null, pen, Style.Shadow);
            var headPen = RenderHelpers.CreatePen(Style.Stroke, Math.Max(1, Style.Thickness / 3), LineDash.Solid);
            RenderHelpers.DrawWithShadow(dc, head, headFill, headPen, Style.Shadow);
            return;
        }

-        geometry.Children.Add(new LineGeometry(Start, End));
-        RenderHelpers.DrawWithShadow(dc, geometry, null, pen, Style.Shadow);
+        RenderHelpers.DrawWithShadow(dc, BuildGeometry(segments), null, pen, Style.Shadow);
    }

-    public override bool HitTest(Point point, double tolerance) =>
-        RenderHelpers.DistanceToSegment(point, Start, End) <= tolerance + Style.Thickness / 2 + (IsArrow ? 4 : 0);
+    public override bool HitTest(Point point, double tolerance)
+    {
+        double limit = tolerance + Style.Thickness / 2 + (IsArrow ? 4 : 0);
+        List<Point> points = Flatten();
+        for (int i = 1; i < points.Count; i++)
+        {
+            if (RenderHelpers.DistanceToSegment(point, points[i - 1], points[i]) <= limit)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }

    public override void Move(Vector delta)
    {
        Start += delta;
        End += delta;
+        for (int i = 0; i < Bends.Count; i++)
+        {
+            Bends[i] += delta;
+        }
    }

-    public override IReadOnlyList<Point> GetHandles() => new[] { Start, End };
+    /// <summary>Volgorde: begin, eind, buigpunten, en daarna één spook-greep midden op elk segment.</summary>
+    public override IReadOnlyList<Point> GetHandles()
+    {
+        var handles = new List<Point> { Start, End };
+        handles.AddRange(Bends);
+        foreach (Segment s in Segments())
+        {
+            handles.Add(s.At(0.5));
+        }
+
+        return handles;
+    }
+
+    public override bool IsGhostHandle(int index) => index >= 2 + Bends.Count;
+
+    public override void BeginHandleDrag(int index)
+    {
+        _pendingGhost = IsGhostHandle(index) ? index - 2 - Bends.Count : -1;
+        _dragBend = index >= 2 && _pendingGhost < 0 ? index - 2 : -1;
+    }

    public override void MoveHandle(int index, Point point, bool constrain)
    {
-        if (index == 0)
+        // Het buigpunt pas bij de eerste beweging invoegen, zodat een losse klik de lijn niet verandert.
+        if (_pendingGhost >= 0)
        {
-            Start = constrain ? RenderHelpers.SnapAngle(End, point) : point;
+            Bends.Insert(_pendingGhost, point);
+            _dragBend = _pendingGhost;
+            _pendingGhost = -1;
+            return;
        }
-        else
+
+        if (_dragBend >= 0)
        {
-            End = constrain ? RenderHelpers.SnapAngle(Start, point) : point;
+            Bends[_dragBend] = point;
+        }
+        else if (index == 0)
+        {
+            Start = constrain ? RenderHelpers.SnapAngle(Bends.Count > 0 ? Bends[0] : End, point) : point;
+        }
+        else if (index == 1)
+        {
+            End = constrain ? RenderHelpers.SnapAngle(Bends.Count > 0 ? Bends[^1] : Start, point) : point;
        }
    }
+
+    public override bool RemoveHandle(int index)
+    {
+        int bend = index - 2;
+        if (bend < 0 || bend >= Bends.Count)
+        {
+            return false;
+        }
+
+        Bends.RemoveAt(bend);
+        return true;
+    }
+
+    public override Annotation Clone()
+    {
+        var clone = (LineAnnotation)base.Clone();
+        clone.Bends = new List<Point>(Bends);
+        return clone;
+    }
 }
@@ -59,6 +59,13 @@ public sealed class EditorDocument
        }
    }

+    /// <summary>Vervangt het knipsel door de platgemaakte versie; de annotaties zitten daarna in de pixels.</summary>
+    public void Flatten(BitmapSource rendered)
+    {
+        SetPixels(PixelUtil.ToOpaqueBgra(rendered), rendered.PixelWidth, rendered.PixelHeight);
+        Items = new List<Annotation>();
+    }
+
    public string GetStepLabel(StepAnnotation step)
    {
        int ordinal = 0;
@@ -5,7 +5,8 @@
        Title="kniip" Width="1180" Height="780" MinWidth="760" MinHeight="420"
        WindowStartupLocation="CenterScreen" Background="{StaticResource WindowBrush}"
        FontFamily="Segoe UI" FontSize="13" UseLayoutRounding="True"
-        Icon="pack://application:,,,/AppIcon.ico">
+        Icon="pack://application:,,,/AppIcon.ico"
+        AllowDrop="True" PreviewDragEnter="Window_PreviewDragOver" PreviewDragOver="Window_PreviewDragOver" PreviewDrop="Window_PreviewDrop">
    <Window.Resources>
        <local:CornerPreviewConverter x:Key="CornerPreview" />
        <local:CursorIconConverter x:Key="CursorIcon" />
@@ -187,6 +188,16 @@
            </DockPanel>
        </Border>

+        <!-- Onderste werkbalk in de gesplitste indeling; de code verplaatst de acties hierheen -->
+        <Border x:Name="ActionBar" DockPanel.Dock="Bottom" Background="{StaticResource ToolbarBrush}" BorderBrush="{StaticResource DividerBrush}"
+                BorderThickness="0,1,0,0" Padding="8,6" Visibility="Collapsed"
+                SizeChanged="Toolbar_SizeChanged" ContextMenuOpening="Toolbar_ContextMenuOpening">
+            <Border.ContextMenu>
+                <ContextMenu x:Name="ActionBarMenu" />
+            </Border.ContextMenu>
+            <local:ToolbarPanel x:Name="ActionItems" OrderChanged="ToolbarItems_OrderChanged" />
+        </Border>
+
        <!-- Gereedschappen en acties; rechtsklik voor vergrendelen, positie en zichtbare knoppen -->
        <Border x:Name="Toolbar" DockPanel.Dock="Top" Background="{StaticResource ToolbarBrush}" BorderBrush="{StaticResource DividerBrush}"
                BorderThickness="0,0,0,1" Padding="8,6" SizeChanged="Toolbar_SizeChanged" ContextMenuOpening="Toolbar_ContextMenuOpening">
@@ -314,9 +325,14 @@
                    <TextBlock Text="&#xE8A3;" Style="{StaticResource IconText}" />
                </Button>
                <local:ToolbarSeparator local:ToolbarPanel.ItemId="Sep5" />
-                <Button local:ToolbarPanel.ItemId="Settings" local:ToolbarPanel.Title="Instellingen"
+                <Button x:Name="SettingsButton" local:ToolbarPanel.ItemId="Settings" local:ToolbarPanel.Title="Instellingen"
                        Style="{StaticResource FlatButton}" ToolTip="Instellingen" Click="Settings_Click">
-                    <TextBlock Text="&#xE713;" Style="{StaticResource IconText}" />
+                    <Grid>
+                        <TextBlock Text="&#xE713;" Style="{StaticResource IconText}" />
+                        <Ellipse x:Name="SettingsBadge" Width="8" Height="8" Fill="{StaticResource AccentBrush}" Stroke="White"
+                                 StrokeThickness="1" HorizontalAlignment="Right" VerticalAlignment="Top" Margin="0,-2,-3,0"
+                                 IsHitTestVisible="False" Visibility="Collapsed" />
+                    </Grid>
                </Button>
                <Button x:Name="SaveButton" local:ToolbarPanel.ItemId="Save" local:ToolbarPanel.Title="Opslaan"
                        Style="{StaticResource SecondaryButton}" ToolTip="Opslaan (Ctrl+S); Shift+klik of Ctrl+Shift+S = opslaan als" Click="Save_Click">
@@ -339,11 +355,15 @@
                        <TextBlock x:Name="CopyLabel" Text="Kopiëren" Margin="6,0,0,0" />
                    </StackPanel>
                </Button>
+
+                <!-- Alleen in de gesplitste indeling: gereedschappen in het midden, Instellingen rechts -->
+                <local:ToolbarSpacer local:ToolbarPanel.ItemId="SplitSpacer1" />
+                <local:ToolbarSpacer local:ToolbarPanel.ItemId="SplitSpacer2" />
            </local:ToolbarPanel>
        </Border>

        <!-- Eigenschappen van het actieve gereedschap of het geselecteerde object -->
-        <Border DockPanel.Dock="Top" Background="White" BorderBrush="{StaticResource DividerBrush}" BorderThickness="0,0,0,1"
+        <Border x:Name="PropsBar" DockPanel.Dock="Top" Background="White" BorderBrush="{StaticResource DividerBrush}" BorderThickness="0,0,0,1"
                Padding="12,4" MinHeight="42">
            <WrapPanel x:Name="PropsPanel" VerticalAlignment="Center" HorizontalAlignment="Center">
                <StackPanel x:Name="StrokeGroup" Style="{StaticResource PropGroup}">
@@ -22,6 +22,8 @@ public partial class EditorWindow : Window
 {
    private enum DragMode { None, Creating, Moving, Handle, Cropping }

+    private enum ZOrder { Front, Forward, Backward, Back }
+
    private static readonly double[] ThicknessValues = { 0, 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32 };
    private static readonly double[] FontSizeValues = { 10, 12, 14, 16, 18, 20, 24, 28, 32, 40, 48, 64 };
    private static readonly double[] SizeValues = { 16, 20, 24, 28, 32, 40, 48, 56, 64, 80 };
@@ -33,11 +35,31 @@ public partial class EditorWindow : Window
    private static readonly CursorKind[] CursorKindValues = { CursorKind.Arrow, CursorKind.Click, CursorKind.Hand };
    private static readonly BlurMode[] BlurModeValues = { BlurMode.Pixelate, BlurMode.Blur };

+    /// <summary>Standaardvolgorde in de gesplitste indeling: eerst de bovenste werkbalk, dan de onderste.</summary>
+    private static readonly string[] DefaultSplitOrder =
+    {
+        "SplitSpacer1", "Select", "Sep1", "Rectangle", "Ellipse", "Line", "Arrow", "Text", "Step", "Cursor", "Emoji", "Highlight", "Blur",
+        "Sep2", "Crop", "Sep3", "Undo", "Redo", "Delete", "Sep4", "Clear", "SplitSpacer2", "Settings",
+        "New", "Screencast", "Spacer", "Save", "Upload", "Copy", "Sep5", "Spacer2", "ZoomOut", "Zoom", "ZoomIn"
+    };
+
+    /// <summary>Items die in de gesplitste indeling op de onderste werkbalk staan.</summary>
+    private static readonly HashSet<string> SplitBottomIds = new()
+    {
+        "New", "Screencast", "Spacer", "Save", "Upload", "Copy", "Sep5", "Spacer2", "ZoomOut", "Zoom", "ZoomIn"
+    };
+
+    /// <summary>Items die alleen in de gesplitste indeling op een werkbalk staan.</summary>
+    private static readonly HashSet<string> SplitOnlyIds = new() { "SplitSpacer1", "SplitSpacer2" };
+
    private readonly EditorDocument _doc;
    private readonly UndoStack _undo = new();
    private readonly AppSettings _settings;
    private readonly DispatcherTimer _hintResetTimer = new() { Interval = TimeSpan.FromSeconds(3) };
    private readonly List<string> _defaultToolbarOrder = new();
+    private readonly List<string> _defaultSplitOrder = new();
+    private readonly Dictionary<string, UIElement> _toolbarItems = new();
+    private EditorLayout _appliedLayout;

    private ToolKind _tool;
    private Annotation? _selected;
@@ -68,11 +90,15 @@ public partial class EditorWindow : Window
    private bool _dirty;
    private bool _discarding;
    private bool _exported;
+    private bool _toolbarsHidden;
+    private readonly string? _windowName;

-    public EditorWindow(BitmapSource image, AppSettings settings, bool isBlank = false)
+    /// <param name="windowName">Programmanaam van het geknipte venster, voor %V in het naamsjabloon.</param>
+    public EditorWindow(BitmapSource image, AppSettings settings, bool isBlank = false, string? windowName = null)
    {
        InitializeComponent();
        _settings = settings;
+        _windowName = windowName;
        _doc = new EditorDocument(image);

        Surface.Document = _doc;
@@ -114,6 +140,10 @@ public partial class EditorWindow : Window
        DpiChanged += (_, _) => ApplyZoom();
        PreviewKeyDown += OnPreviewKeyDown;

+        App.Instance.Updates.AvailabilityChanged += OnUpdateAvailabilityChanged;
+        Closed += (_, _) => App.Instance.Updates.AvailabilityChanged -= OnUpdateAvailabilityChanged;
+        ShowUpdateBadge();
+
        InitializeToolbar();
        ApplySaveButton();
        _suppressStyleEvents = false;
@@ -130,45 +160,73 @@ public partial class EditorWindow : Window

    private void InitializeToolbar()
    {
-        _defaultToolbarOrder.AddRange(ToolbarItems.Items.Select(ItemId));
-        ApplyToolbarOrder(_settings.ToolbarOrder);
        foreach (UIElement item in ToolbarItems.Items)
+        {
+            _toolbarItems[ItemId(item)] = item;
+            if (!SplitOnlyIds.Contains(ItemId(item)))
+            {
+                _defaultToolbarOrder.Add(ItemId(item));
+            }
+        }
+
+        _defaultSplitOrder.AddRange(DefaultSplitOrder.Where(_toolbarItems.ContainsKey));
+        _defaultSplitOrder.AddRange(_defaultToolbarOrder.Except(_defaultSplitOrder));
+        ApplyToolbarLayout();
+        foreach (UIElement item in _toolbarItems.Values)
        {
            item.Visibility = _settings.ToolbarHidden.Contains(ItemId(item)) ? Visibility.Collapsed : Visibility.Visible;
        }

        ApplyUploadButton();
-        ApplyToolbarPosition();
        ApplyToolbarLock();
    }

    private static string ItemId(UIElement item) => ToolbarPanel.GetItemId(item) ?? string.Empty;

-    private void ApplyToolbarOrder(IReadOnlyList<string> saved)
+    private bool IsSplitLayout => _settings.EditorLayout == EditorLayout.Split;
+
+    private IEnumerable<UIElement> AllToolbarItems => ToolbarItems.Items.Concat(ActionItems.Items);
+
+    /// <summary>Items volgens de opgeslagen volgorde van de huidige indeling over de bovenste en onderste werkbalk verdelen.</summary>
+    private void ApplyToolbarLayout()
    {
-        Dictionary<string, UIElement> byId = ToolbarItems.Items.ToDictionary(ItemId);
-        List<string> order = saved.Where(byId.ContainsKey).Distinct().ToList();
+        bool split = IsSplitLayout;
+        _appliedLayout = _settings.EditorLayout;
+        List<string> order = split
+            ? MergeToolbarOrder(_settings.SplitToolbarOrder, _defaultSplitOrder)
+            : MergeToolbarOrder(_settings.ToolbarOrder, _defaultToolbarOrder);
+
+        ToolbarItems.Children.Clear();
+        ActionItems.Children.Clear();
+        foreach (string id in order.Where(id => split || !SplitOnlyIds.Contains(id)))
+        {
+            (split && SplitBottomIds.Contains(id) ? ActionItems : ToolbarItems).Children.Add(_toolbarItems[id]);
+        }
+
+        ActionBar.Visibility = split && !_toolbarsHidden ? Visibility.Visible : Visibility.Collapsed;
+        ApplyToolbarPosition();
+    }
+
+    private List<string> MergeToolbarOrder(IReadOnlyList<string> saved, IReadOnlyList<string> defaults)
+    {
+        List<string> order = saved.Where(_toolbarItems.ContainsKey).Distinct().ToList();

        // Items die nog niet in de opgeslagen volgorde staan (zoals nieuwe knoppen) komen na hun standaardvoorganger.
-        for (int i = 0; i < _defaultToolbarOrder.Count; i++)
+        for (int i = 0; i < defaults.Count; i++)
        {
-            string id = _defaultToolbarOrder[i];
+            string id = defaults[i];
            if (!order.Contains(id))
            {
-                order.Insert(i == 0 ? 0 : order.IndexOf(_defaultToolbarOrder[i - 1]) + 1, id);
+                order.Insert(i == 0 ? 0 : order.IndexOf(defaults[i - 1]) + 1, id);
            }
        }

-        ToolbarItems.Children.Clear();
-        foreach (string id in order)
-        {
-            ToolbarItems.Children.Add(byId[id]);
-        }
+        return order;
    }

    private void ApplyToolbarPosition()
    {
-        Dock dock = _settings.ToolbarPosition;
+        Dock dock = IsSplitLayout ? Dock.Top : _settings.ToolbarPosition;
        bool vertical = dock is Dock.Left or Dock.Right;
        DockPanel.SetDock(Toolbar, dock);
        ToolbarItems.Orientation = vertical ? Orientation.Vertical : Orientation.Horizontal;
@@ -186,8 +244,11 @@ public partial class EditorWindow : Window
    private void ApplyToolbarLock()
    {
        bool locked = _settings.ToolbarLocked;
+        Brush background = locked ? (Brush)FindResource("ToolbarBrush") : new SolidColorBrush(Color.FromRgb(0xEA, 0xF2, 0xFB));
        ToolbarItems.IsLocked = locked;
-        Toolbar.Background = locked ? (Brush)FindResource("ToolbarBrush") : new SolidColorBrush(Color.FromRgb(0xEA, 0xF2, 0xFB));
+        ActionItems.IsLocked = locked;
+        Toolbar.Background = background;
+        ActionBar.Background = background;
        UpdateHint();
    }

@@ -199,73 +260,136 @@ public partial class EditorWindow : Window
        }
    }

-    // Labels alleen tonen als alles op één regel past; staat de werkbalk opzij, dan altijd alleen iconen.
    private void UpdateToolbarLayout()
    {
-        if (ToolbarItems.Orientation == Orientation.Vertical)
+        UpdateActionLabels(Toolbar, ToolbarItems);
+        UpdateActionLabels(ActionBar, ActionItems);
+    }
+
+    // Labels alleen tonen als alles op één regel past; staat de werkbalk opzij, dan altijd alleen iconen.
+    private void UpdateActionLabels(Border bar, ToolbarPanel panel)
+    {
+        List<TextBlock> labels = new[] { NewLabel, ClearLabel, ScreencastLabel, SaveLabel, UploadLabel, CopyLabel }
+            .Where(label => PanelOf(label) == panel).ToList();
+        if (labels.Count == 0)
        {
-            SetActionLabelsVisible(false);
            return;
        }

-        double available = Toolbar.ActualWidth - Toolbar.Padding.Left - Toolbar.Padding.Right
-                           - Toolbar.BorderThickness.Left - Toolbar.BorderThickness.Right;
-        SetActionLabelsVisible(true);
-        ToolbarItems.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
-        SetActionLabelsVisible(ToolbarItems.SingleLineLength <= available);
+        if (panel.Orientation == Orientation.Vertical)
+        {
+            SetActionLabelsVisible(panel, labels, false);
+            return;
+        }
+
+        double available = bar.ActualWidth - bar.Padding.Left - bar.Padding.Right
+                           - bar.BorderThickness.Left - bar.BorderThickness.Right;
+        SetActionLabelsVisible(panel, labels, true);
+        panel.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
+        SetActionLabelsVisible(panel, labels, panel.SingleLineLength <= available);
    }

-    private void SetActionLabelsVisible(bool visible)
+    private static ToolbarPanel? PanelOf(DependencyObject element)
+    {
+        for (DependencyObject? d = element; d != null; d = VisualTreeHelper.GetParent(d))
+        {
+            if (d is ToolbarPanel panel)
+            {
+                return panel;
+            }
+        }
+
+        return null;
+    }
+
+    private static void SetActionLabelsVisible(ToolbarPanel panel, IEnumerable<TextBlock> labels, bool visible)
    {
        Visibility visibility = visible ? Visibility.Visible : Visibility.Collapsed;
-        foreach (TextBlock label in new[] { NewLabel, ClearLabel, ScreencastLabel, SaveLabel, UploadLabel, CopyLabel })
+        foreach (TextBlock label in labels)
        {
            label.Visibility = visibility;

            // Anders geeft een directe Measure() van het paneel nog de gecachete knopbreedtes terug.
-            for (DependencyObject? d = label; d != null && d != ToolbarItems; d = VisualTreeHelper.GetParent(d))
+            for (DependencyObject? d = label; d != null && d != panel; d = VisualTreeHelper.GetParent(d))
            {
                (d as UIElement)?.InvalidateMeasure();
            }
        }

-        ToolbarItems.InvalidateMeasure();
+        panel.InvalidateMeasure();
    }

    private void ToolbarItems_OrderChanged(object? sender, EventArgs e)
    {
-        _settings.ToolbarOrder = ToolbarItems.Items.Select(ItemId).ToList();
+        if (IsSplitLayout)
+        {
+            _settings.SplitToolbarOrder = AllToolbarItems.Select(ItemId).ToList();
+        }
+        else
+        {
+            _settings.ToolbarOrder = ToolbarItems.Items.Select(ItemId).ToList();
+        }
+
        UpdateToolbarLayout();
    }

+    private void SetEditorLayout(EditorLayout layout)
+    {
+        _settings.EditorLayout = layout;
+        ApplyToolbarLayout();
+    }
+
    private void Toolbar_ContextMenuOpening(object sender, ContextMenuEventArgs e)
    {
-        ToolbarMenu.Items.Clear();
+        var bar = (Border)sender;
+        ToolbarPanel panel = bar == ActionBar ? ActionItems : ToolbarItems;
+        ContextMenu menu = bar.ContextMenu;
+        menu.Items.Clear();

        var lockItem = new MenuItem { Header = "Werkbalk vergrendelen", IsCheckable = true, IsChecked = _settings.ToolbarLocked };
        lockItem.Click += (_, _) => SetToolbarLocked(lockItem.IsChecked);
-        ToolbarMenu.Items.Add(lockItem);
+        menu.Items.Add(lockItem);

-        var position = new MenuItem { Header = "Positie" };
-        foreach ((Dock dock, string label) in new[] { (Dock.Top, "Boven"), (Dock.Bottom, "Onder"), (Dock.Left, "Links"), (Dock.Right, "Rechts") })
+        var layout = new MenuItem { Header = "Indeling" };
+        foreach ((EditorLayout value, string label) in new[]
+                 {
+                     (EditorLayout.Split, "Split-weergave: gereedschappen boven, opslaan onder"),
+                     (EditorLayout.Single, "Eén werkbalk")
+                 })
        {
-            var item = new MenuItem { Header = label, IsCheckable = true, IsChecked = _settings.ToolbarPosition == dock };
-            item.Click += (_, _) =>
-            {
-                _settings.ToolbarPosition = dock;
-                ApplyToolbarPosition();
-            };
-            position.Items.Add(item);
+            var item = new MenuItem { Header = label, IsCheckable = true, IsChecked = _settings.EditorLayout == value };
+            item.Click += (_, _) => SetEditorLayout(value);
+            layout.Items.Add(item);
        }

-        ToolbarMenu.Items.Add(position);
+        menu.Items.Add(layout);

-        var swap = new MenuItem { Header = "Groepen omwisselen" };
-        swap.Click += (_, _) => SwapToolbarGroups();
-        ToolbarMenu.Items.Add(swap);
+        if (!IsSplitLayout)
+        {
+            var position = new MenuItem { Header = "Positie" };
+            foreach ((Dock dock, string label) in new[] { (Dock.Top, "Boven"), (Dock.Bottom, "Onder"), (Dock.Left, "Links"), (Dock.Right, "Rechts") })
+            {
+                var item = new MenuItem { Header = label, IsCheckable = true, IsChecked = _settings.ToolbarPosition == dock };
+                item.Click += (_, _) =>
+                {
+                    _settings.ToolbarPosition = dock;
+                    ApplyToolbarPosition();
+                };
+                position.Items.Add(item);
+            }
+
+            menu.Items.Add(position);
+        }
+
+        if (panel.Items.Any(i => i is ToolbarSpacer))
+        {
+            var swap = new MenuItem { Header = "Groepen omwisselen" };
+            swap.Click += (_, _) => SwapToolbarGroups(panel);
+            menu.Items.Add(swap);
+        }

        var buttons = new MenuItem { Header = "Knoppen tonen" };
-        foreach (UIElement element in ToolbarItems.Items)
+        foreach (UIElement element in AllToolbarItems)
        {
            if (ToolbarPanel.GetTitle(element) is not { } title || (element == UploadButton && !CanUpload))
            {
@@ -277,12 +401,12 @@ public partial class EditorWindow : Window
            buttons.Items.Add(item);
        }

-        ToolbarMenu.Items.Add(buttons);
-        ToolbarMenu.Items.Add(new Separator());
+        menu.Items.Add(buttons);
+        menu.Items.Add(new Separator());

        var reset = new MenuItem { Header = "Standaard herstellen" };
        reset.Click += (_, _) => ResetToolbar();
-        ToolbarMenu.Items.Add(reset);
+        menu.Items.Add(reset);
    }

    private void SetToolbarLocked(bool locked)
@@ -305,49 +429,50 @@ public partial class EditorWindow : Window
    }

    /// <summary>De groepen tussen de flexibele ruimtes in omgekeerde volgorde zetten; een middengroep blijft in het midden.</summary>
-    private void SwapToolbarGroups()
+    private void SwapToolbarGroups(ToolbarPanel panel)
    {
-        var groups = new List<List<string>> { new() };
-        var spacers = new List<string>();
-        foreach (UIElement item in ToolbarItems.Items)
+        var groups = new List<List<UIElement>> { new() };
+        var spacers = new List<UIElement>();
+        foreach (UIElement item in panel.Items)
        {
            if (item is ToolbarSpacer)
            {
-                spacers.Add(ItemId(item));
-                groups.Add(new List<string>());
+                spacers.Add(item);
+                groups.Add(new List<UIElement>());
            }
            else
            {
-                groups[^1].Add(ItemId(item));
+                groups[^1].Add(item);
            }
        }

        groups.Reverse();
-        var order = new List<string>(groups[0]);
+        var order = new List<UIElement>(groups[0]);
        for (int i = 0; i < spacers.Count; i++)
        {
            order.Add(spacers[i]);
            order.AddRange(groups[i + 1]);
        }

-        ApplyToolbarOrder(order);
+        panel.Children.Clear();
+        order.ForEach(item => panel.Children.Add(item));
        ToolbarItems_OrderChanged(this, EventArgs.Empty);
    }

    private void ResetToolbar()
    {
        _settings.ToolbarOrder = new List<string>();
+        _settings.SplitToolbarOrder = new List<string>();
        _settings.ToolbarHidden = new List<string>();
        _settings.ToolbarPosition = Dock.Top;
        _settings.ToolbarLocked = true;
-        ApplyToolbarOrder(_defaultToolbarOrder);
-        foreach (UIElement item in ToolbarItems.Items)
+        ApplyToolbarLayout();
+        foreach (UIElement item in _toolbarItems.Values)
        {
            item.Visibility = Visibility.Visible;
        }

        ApplyUploadButton();
-        ApplyToolbarPosition();
        ApplyToolbarLock();
    }

@@ -355,7 +480,7 @@ public partial class EditorWindow : Window

    private void SelectTool(ToolKind tool)
    {
-        foreach (RadioButton button in ToolbarItems.Items.OfType<RadioButton>())
+        foreach (RadioButton button in _toolbarItems.Values.OfType<RadioButton>())
        {
            if ((string)button.Tag == tool.ToString())
            {
@@ -449,6 +574,14 @@ public partial class EditorWindow : Window
        if (_selected != null)
        {
            int handle = Surface.HitHandle(_selected, p);
+            if (handle >= 0 && e.ClickCount == 2 && _selected.RemoveHandle(handle))
+            {
+                Commit(_pending);
+                _pending = null;
+                Surface.InvalidateVisual();
+                return;
+            }
+
            if (handle >= 0)
            {
                _handleIndex = handle;
@@ -720,26 +853,53 @@ public partial class EditorWindow : Window
    private void Surface_MouseRightButtonUp(object sender, MouseButtonEventArgs e)
    {
        CommitTextEdit();
-        Annotation? hit = HitTest(e.GetPosition(Surface));
-        if (hit == null)
-        {
-            return;
-        }
-
+        Point point = e.GetPosition(Surface);
+        Annotation? hit = HitTest(point);
        SetSelected(hit);
+        bool has = hit != null;
+        int index = hit != null ? _doc.Items.IndexOf(hit) : -1;
+        int last = _doc.Items.Count - 1;
+
        var menu = new ContextMenu { PlacementTarget = Surface };
-        menu.Items.Add(MenuItem("Naar voren", () => Reorder(hit, toFront: true)));
-        menu.Items.Add(MenuItem("Naar achteren", () => Reorder(hit, toFront: false)));
-        menu.Items.Add(MenuItem("Dupliceren", () => Duplicate(hit)));
+        menu.Items.Add(MenuItem("Ongedaan maken", "\uE7A7", "Ctrl+Z", Undo, _undo.CanUndo));
+        menu.Items.Add(MenuItem("Opnieuw", "\uE7A6", "Ctrl+Y", Redo, _undo.CanRedo));
        menu.Items.Add(new Separator());
-        menu.Items.Add(MenuItem("Verwijderen", DeleteSelected));
+        menu.Items.Add(MenuItem("Verwijder", "\uE74D", "Delete", DeleteSelected, has));
+        menu.Items.Add(MenuItem("Verwijder alles", "\uE894", "Shift+Delete", DeleteAll, last >= 0));
+        menu.Items.Add(MenuItem("Samenvoegen", "\uE81E", "Ctrl+Shift+F", Flatten, last >= 0));
+        menu.Items.Add(new Separator());
+        menu.Items.Add(MenuItem("Knip", "\uE8C6", "Ctrl+X", () => CutAnnotation(hit!), has));
+        menu.Items.Add(MenuItem("Kopieer", "\uE8C8", "Ctrl+Shift+C", () => CopyAnnotation(hit!), has));
+        menu.Items.Add(MenuItem("Plak", "\uE77F", "Ctrl+V", () => Paste(point), CanPaste()));
+        menu.Items.Add(MenuItem("Dupliceren", "\uE710", "Ctrl+D", () => Duplicate(hit!), has));
+        menu.Items.Add(new Separator());
+        menu.Items.Add(MenuItem("Naar voorgrond", "\uE898", "Home", () => Reorder(hit!, ZOrder.Front), has && index < last));
+        menu.Items.Add(MenuItem("Naar voren", "\uE74A", "PageUp", () => Reorder(hit!, ZOrder.Forward), has && index < last));
+        menu.Items.Add(MenuItem("Naar achteren", "\uE74B", "PageDown", () => Reorder(hit!, ZOrder.Backward), has && index > 0));
+        menu.Items.Add(MenuItem("Naar achtergrond", "\uE896", "End", () => Reorder(hit!, ZOrder.Back), has && index > 0));
+        menu.Items.Add(new Separator());
+        menu.Items.Add(_toolbarsHidden
+            ? MenuItem("Werkbalken tonen", "\uE7B3", "Ctrl+H", ToggleToolbars)
+            : MenuItem("Werkbalken verbergen", "\uED1A", "Ctrl+H", ToggleToolbars));
        menu.IsOpen = true;
        e.Handled = true;
    }

-    private static MenuItem MenuItem(string header, Action action)
+    private static MenuItem MenuItem(string header, string glyph, string gesture, Action action, bool isEnabled = true)
    {
-        var item = new MenuItem { Header = header };
+        var item = new MenuItem
+        {
+            Header = header,
+            InputGestureText = gesture,
+            IsEnabled = isEnabled,
+            Icon = new TextBlock
+            {
+                Text = glyph,
+                FontFamily = (FontFamily)Application.Current.FindResource("IconFont"),
+                FontSize = 14,
+                VerticalAlignment = VerticalAlignment.Center
+            }
+        };
        item.Click += (_, _) => action();
        return item;
    }
@@ -778,20 +938,122 @@ public partial class EditorWindow : Window
        SetSelected(null);
    }

-    private void Reorder(Annotation item, bool toFront)
+    private void DeleteAll()
    {
-        Commit(_doc.CaptureState());
-        _doc.Items.Remove(item);
-        if (toFront)
+        if (_doc.Items.Count == 0)
        {
-            _doc.Items.Add(item);
+            return;
+        }
+
+        Commit(_doc.CaptureState());
+        _doc.Items.Clear();
+        SetSelected(null);
+    }
+
+    private void Flatten()
+    {
+        CommitTextEdit();
+        if (_doc.Items.Count == 0)
+        {
+            return;
+        }
+
+        Commit(_doc.CaptureState());
+        _doc.Flatten(DocumentRenderer.Export(_doc));
+        SetSelected(null);
+        ShowTemporaryHint("Annotaties samengevoegd met de afbeelding.");
+    }
+
+    private void Reorder(Annotation item, ZOrder order)
+    {
+        int index = _doc.Items.IndexOf(item);
+        int last = _doc.Items.Count - 1;
+        int target = order switch
+        {
+            ZOrder.Front => last,
+            ZOrder.Forward => Math.Min(index + 1, last),
+            ZOrder.Backward => Math.Max(index - 1, 0),
+            _ => 0
+        };
+        if (index < 0 || target == index)
+        {
+            return;
+        }
+
+        Commit(_doc.CaptureState());
+        _doc.Items.RemoveAt(index);
+        _doc.Items.Insert(target, item);
+        Surface.InvalidateVisual();
+    }
+
+    private void CopyAnnotation(Annotation item)
+    {
+        if (!AnnotationClipboard.Set(item))
+        {
+            ShowTemporaryHint("Kopiëren mislukt: het klembord is bezet. Probeer het opnieuw.");
+        }
+    }
+
+    private void CutAnnotation(Annotation item)
+    {
+        if (AnnotationClipboard.Set(item))
+        {
+            SetSelected(item);
+            DeleteSelected();
        }
        else
        {
-            _doc.Items.Insert(0, item);
+            ShowTemporaryHint("Knippen mislukt: het klembord is bezet. Probeer het opnieuw.");
+        }
+    }
+
+    /// <param name="at">Middelpunt voor de geplakte annotatie; zonder punt een kleine verschuiving.</param>
+    private void Paste(Point? at = null)
+    {
+        if (AnnotationClipboard.Get() is not { } copy)
+        {
+            PasteImage();
+            return;
        }

-        Surface.InvalidateVisual();
+        Commit(_doc.CaptureState());
+        Rect bounds = copy.Bounds;
+        Vector offset = at is { } point
+            ? point - new Point(bounds.X + bounds.Width / 2, bounds.Y + bounds.Height / 2)
+            : new Vector(12 / Surface.ViewScale, 12 / Surface.ViewScale);
+        copy.Move(offset);
+        _doc.Items.Add(copy);
+        SetSelected(copy);
+    }
+
+    private static bool CanPaste()
+    {
+        if (AnnotationClipboard.Get() != null)
+        {
+            return true;
+        }
+
+        try
+        {
+            return Clipboard.ContainsImage() || Clipboard.ContainsData("PNG") || Clipboard.ContainsFileDropList();
+        }
+        catch (System.Runtime.InteropServices.ExternalException)
+        {
+            return false;
+        }
+    }
+
+    private void ToggleToolbars()
+    {
+        _toolbarsHidden = !_toolbarsHidden;
+        Visibility visibility = _toolbarsHidden ? Visibility.Collapsed : Visibility.Visible;
+        Toolbar.Visibility = visibility;
+        PropsBar.Visibility = visibility;
+        ActionBar.Visibility = IsSplitLayout ? visibility : Visibility.Collapsed;
+        if (_toolbarsHidden)
+        {
+            ShowTemporaryHint("Werkbalken verborgen. Ctrl+H of rechtsklik op het canvas om ze terug te halen.");
+        }
    }

    private void Duplicate(Annotation item)
@@ -1362,6 +1624,11 @@ public partial class EditorWindow : Window
    protected override void OnActivated(EventArgs e)
    {
        base.OnActivated(e);
+        if (_appliedLayout != _settings.EditorLayout)
+        {
+            ApplyToolbarLayout();
+        }
+
        ApplySaveButton();
        ApplyUploadButton();
    }
@@ -1395,6 +1662,7 @@ public partial class EditorWindow : Window
        {
            using System.IO.MemoryStream png = ImageExporter.EncodePng(image);
            string url = await ZiplineUploader.UploadAsync(config, png, $"Knipsel {DateTime.Now:yyyy-MM-dd HHmmss}.png", "image/png");
+            Kniip.History.HistoryStore.Add(Kniip.History.HistoryKind.Snip, null, url, image);
            _dirty = false;
            _exported = true;
            ShowTemporaryHint(ClipboardWriter.SetText(url)
@@ -1430,6 +1698,8 @@ public partial class EditorWindow : Window
        }
    }

+    private static string DefaultName => $"Knipsel {DateTime.Now:yyyy-MM-dd HHmmss}";
+
    private bool Save()
    {
        if (_settings.SnipSaveFolder is not { Length: > 0 } target)
@@ -1441,8 +1711,7 @@ public partial class EditorWindow : Window
        string path;
        try
        {
-            System.IO.Directory.CreateDirectory(target);
-            path = SaveLocation.UniquePath(target, $"Knipsel {DateTime.Now:yyyy-MM-dd HHmmss}.png");
+            path = FileNameTemplate.Resolve(target, _settings.SnipFileNameTemplate, _windowName ?? "Knipsel", DefaultName, ".png");
        }
        catch (Exception ex)
        {
@@ -1464,7 +1733,7 @@ public partial class EditorWindow : Window
        {
            Title = "Knipsel opslaan",
            Filter = "PNG-afbeelding (*.png)|*.png|JPEG-afbeelding (*.jpg)|*.jpg",
-            FileName = $"Knipsel {DateTime.Now:yyyy-MM-dd HHmmss}",
+            FileName = FileNameTemplate.SuggestedName(_settings.SnipFileNameTemplate, _windowName ?? "Knipsel", DefaultName),
            DefaultExt = ".png",
            InitialDirectory = folder,
            AddExtension = true
@@ -1490,6 +1759,7 @@ public partial class EditorWindow : Window
            App.Instance.Capture.IgnorePath(path);
            BitmapSource image = DocumentRenderer.Export(_doc);
            ImageExporter.Save(image, path);
+            Kniip.History.HistoryStore.Add(Kniip.History.HistoryKind.Snip, path, null, image);
            _dirty = false;
            _exported = true;
            string name = System.IO.Path.GetFileName(path);
@@ -1535,6 +1805,15 @@ public partial class EditorWindow : Window

    private void Settings_Click(object sender, RoutedEventArgs e) => App.Instance.ShowSettings();

+    private void OnUpdateAvailabilityChanged(object? sender, EventArgs e) => ShowUpdateBadge();
+
+    private void ShowUpdateBadge()
+    {
+        bool available = App.Instance.Updates.IsUpdateAvailable;
+        SettingsBadge.Visibility = available ? Visibility.Visible : Visibility.Collapsed;
+        SettingsButton.ToolTip = available ? "Instellingen - nieuwe versie beschikbaar" : "Instellingen";
+    }
+
    private void NewSnip_Click(object sender, RoutedEventArgs e) => DiscardAndStartNewSnip();

    private void Clear_Click(object sender, RoutedEventArgs e) => DiscardAndStartBlank();
@@ -1591,6 +1870,36 @@ public partial class EditorWindow : Window
        ReplaceWith(image, "Wil je doorgaan en de afbeelding van het klembord openen?");
    }

+    private void Window_PreviewDragOver(object sender, DragEventArgs e)
+    {
+        if (!ClipboardImageReader.CanDrop(e.Data))
+        {
+            return;
+        }
+
+        e.Effects = DragDropEffects.Copy;
+        e.Handled = true;
+    }
+
+    private void Window_PreviewDrop(object sender, DragEventArgs e)
+    {
+        if (!ClipboardImageReader.CanDrop(e.Data))
+        {
+            return;
+        }
+
+        e.Handled = true;
+        BitmapSource? image = ClipboardImageReader.FromDrop(e.Data);
+        if (image == null)
+        {
+            ShowTemporaryHint("Deze afbeelding kon niet worden geopend.");
+            return;
+        }
+
+        // Pas na het slepen vragen: een dialoog tijdens Drop blokkeert Verkenner.
+        Dispatcher.BeginInvoke(() => ReplaceWith(image, "Wil je doorgaan en deze afbeelding openen?"));
+    }
+
    private void OpenImageFile()
    {
        CommitTextEdit();
@@ -1694,10 +2003,26 @@ public partial class EditorWindow : Window
                    break;
                case Key.Z:
                    Undo();
+                    break;
+                case Key.C when shift:
+                    if (_selected != null)
+                    {
+                        CopyAnnotation(_selected);
+                    }
+
                    break;
                case Key.C:
                    CopyToClipboard();
                    break;
+                case Key.X when _selected != null:
+                    CutAnnotation(_selected);
+                    break;
+                case Key.F when shift:
+                    Flatten();
+                    break;
+                case Key.H:
+                    ToggleToolbars();
+                    break;
                case Key.S when shift:
                    SaveAs();
                    break;
@@ -1714,7 +2039,7 @@ public partial class EditorWindow : Window
                    DiscardAndStartBlank();
                    break;
                case Key.V:
-                    PasteImage();
+                    Paste();
                    break;
                case Key.O:
                    OpenImageFile();
@@ -1754,10 +2079,25 @@ public partial class EditorWindow : Window
        double step = shift ? 10 : 1;
        switch (key)
        {
+            case Key.Delete when shift:
+                DeleteAll();
+                break;
            case Key.Delete:
            case Key.Back:
                DeleteSelected();
                break;
+            case Key.Home when _selected != null:
+                Reorder(_selected, ZOrder.Front);
+                break;
+            case Key.PageUp when _selected != null:
+                Reorder(_selected, ZOrder.Forward);
+                break;
+            case Key.PageDown when _selected != null:
+                Reorder(_selected, ZOrder.Backward);
+                break;
+            case Key.End when _selected != null:
+                Reorder(_selected, ZOrder.Back);
+                break;
            case Key.Escape:
                if (_drag != DragMode.None)
                {
@@ -1843,8 +2183,8 @@ public partial class EditorWindow : Window
            ToolKind.Select => "Klik om te selecteren, sleep om te verplaatsen. Dubbelklik op tekst om te bewerken. Pijltoetsen verschuiven.",
            ToolKind.Rectangle => "Sleep om een rechthoek te tekenen. Shift = vierkant.",
            ToolKind.Ellipse => "Sleep om een ellips te tekenen. Shift = cirkel.",
-            ToolKind.Line => "Sleep om een lijn te tekenen. Shift = hoeken van 45°.",
-            ToolKind.Arrow => "Sleep om een pijl te tekenen. Shift = hoeken van 45°.",
+            ToolKind.Line => "Sleep om een lijn te tekenen. Shift = hoeken van 45°. Sleep een middenpunt om te buigen; dubbelklik op een buigpunt om het te verwijderen.",
+            ToolKind.Arrow => "Sleep om een pijl te tekenen. Shift = hoeken van 45°. Sleep een middenpunt om te buigen; dubbelklik op een buigpunt om het te verwijderen.",
            ToolKind.Text => "Klik om een tekstkader te plaatsen, of klik op bestaande tekst om die te bewerken.",
            ToolKind.Step => "Klik om een genummerde stap te plaatsen. De nummering loopt automatisch door.",
            ToolKind.Cursor => "Klik om een cursor te plaatsen; de punt komt precies op de klikplek.",
@@ -4,9 +4,11 @@ using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Windows;
+using System.Windows.Interop;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 using Kniip.Capture;
+using Kniip.Interop;

 namespace Kniip.Editor;

@@ -68,13 +70,103 @@ internal static class ClipboardWriter
        return TrySet(data);
    }

+    /// <summary>Alleen een eigen markering op het klembord, zonder afbeelding of tekst.</summary>
+    public static bool SetMarker(string format, string value)
+    {
+        var data = new DataObject();
+        data.SetData(format, value);
+        return TrySet(data);
+    }
+
+    /// <summary>
+    /// Tekst gaat rechtstreeks via Win32 op het klembord. De OLE-route van WPF moet het klembord
+    /// daarna nog leegspoelen, en dat mislukt zodra een klembordbeheerder het meteen opent.
+    /// </summary>
    public static bool SetText(string text)
    {
+        if (TrySetUnicodeText(text))
+        {
+            return true;
+        }
+
        var data = new DataObject();
        data.SetText(text);
        return TrySet(data);
    }

+    private static HwndSource? _owner;
+
+    private static IntPtr OwnerHandle
+    {
+        get
+        {
+            // Een venster als eigenaar is verplicht: zonder eigenaar weigert SetClipboardData na EmptyClipboard.
+            _owner ??= new HwndSource(new HwndSourceParameters("KniipClipboardWriter")
+            {
+                ParentWindow = NativeMethods.HWND_MESSAGE,
+                WindowStyle = 0
+            });
+            return _owner.Handle;
+        }
+    }
+
+    private static bool TrySetUnicodeText(string text)
+    {
+        IntPtr owner = OwnerHandle;
+        for (int attempt = 0; attempt < 20; attempt++)
+        {
+            if (NativeMethods.OpenClipboard(owner))
+            {
+                try
+                {
+                    return NativeMethods.EmptyClipboard() && PutUnicodeText(text);
+                }
+                finally
+                {
+                    NativeMethods.CloseClipboard();
+                }
+            }
+
+            Thread.Sleep(50);
+        }
+
+        return false;
+    }
+
+    private static bool PutUnicodeText(string text)
+    {
+        IntPtr handle = NativeMethods.GlobalAlloc(NativeMethods.GMEM_MOVEABLE, (UIntPtr)((text.Length + 1) * 2));
+        if (handle == IntPtr.Zero)
+        {
+            return false;
+        }
+
+        IntPtr target = NativeMethods.GlobalLock(handle);
+        if (target == IntPtr.Zero)
+        {
+            NativeMethods.GlobalFree(handle);
+            return false;
+        }
+
+        try
+        {
+            Marshal.Copy(text.ToCharArray(), 0, target, text.Length);
+            Marshal.WriteInt16(target, text.Length * 2, 0);
+        }
+        finally
+        {
+            NativeMethods.GlobalUnlock(handle);
+        }
+
+        if (NativeMethods.SetClipboardData(NativeMethods.CF_UNICODETEXT, handle) == IntPtr.Zero)
+        {
+            NativeMethods.GlobalFree(handle);
+            return false;
+        }
+
+        return true;
+    }
+
    private static bool TrySet(DataObject data)
    {
        for (int attempt = 0; attempt < 5; attempt++)
@@ -0,0 +1,102 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Windows;
+using Kniip.Editor;
+using Kniip.Infrastructure;
+
+namespace Kniip.History;
+
+/// <param name="Glyph">Teken uit Segoe Fluent Icons.</param>
+public sealed record HistoryCommand(string Label, string Glyph, bool Enabled, Action Run);
+
+/// <summary>Wat je met een item uit de geschiedenis kunt doen, gedeeld door het systeemvakmenu en het geschiedenisvenster.</summary>
+public static class HistoryActions
+{
+    /// <summary>De acties voor een item; null staat voor een scheidingslijn.</summary>
+    public static IReadOnlyList<HistoryCommand?> CommandsFor(HistoryEntry entry)
+    {
+        bool file = entry.FileExists;
+        bool url = entry.Url is { Length: > 0 };
+        bool image = file && entry.Kind == HistoryKind.Snip;
+        return new HistoryCommand?[]
+        {
+            new("Openen", "\uE8E5", file || url, () => Open(entry)),
+            new("Openen in de editor", "\uE70F", image, () => App.Instance.OpenFile(entry.FilePath!)),
+            new("Link openen", "\uE774", url, () => Launch(entry.Url!)),
+            null,
+            new("Link kopiëren", "\uE71B", url, () => Copy(entry.Url!)),
+            new("Afbeelding kopiëren", "\uE8C8", image, () => CopyImage(entry.FilePath!)),
+            new("Pad kopiëren", "\uE8C8", file, () => Copy(entry.FilePath!)),
+            new("Tonen in map", "\uE838", file, () => ShowInFolder(entry.FilePath!))
+        };
+    }
+
+    /// <summary>Bestand in het standaardprogramma, anders de link in de browser.</summary>
+    public static void Open(HistoryEntry entry)
+    {
+        if (entry.FileExists)
+        {
+            Launch(entry.FilePath!);
+        }
+        else if (entry.Url is { Length: > 0 } url)
+        {
+            Launch(url);
+        }
+        else
+        {
+            MessageBox.Show($"Het bestand bestaat niet meer:\n{entry.FilePath}", "kniip", MessageBoxButton.OK, MessageBoxImage.Information);
+        }
+    }
+
+    public static void OpenFolder(string folder)
+    {
+        Directory.CreateDirectory(folder);
+        Launch(folder);
+    }
+
+    private static void ShowInFolder(string path) =>
+        Run(() => Process.Start("explorer.exe", $"/select,\"{path}\""));
+
+    private static void Launch(string target) =>
+        Run(() => Process.Start(new ProcessStartInfo(target) { UseShellExecute = true }));
+
+    private static void Copy(string text)
+    {
+        if (!ClipboardWriter.SetText(text))
+        {
+            ClipboardBusy();
+        }
+    }
+
+    private static void CopyImage(string path)
+    {
+        try
+        {
+            if (!ClipboardWriter.SetImage(PixelUtil.LoadFile(path), path))
+            {
+                ClipboardBusy();
+            }
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show($"Kan '{Path.GetFileName(path)}' niet kopiëren.\n\n{ex.Message}", "kniip", MessageBoxButton.OK, MessageBoxImage.Warning);
+        }
+    }
+
+    private static void ClipboardBusy() =>
+        MessageBox.Show("Kopiëren is mislukt: het klembord is bezet. Probeer het opnieuw.", "kniip", MessageBoxButton.OK, MessageBoxImage.Warning);
+
+    private static void Run(Action action)
+    {
+        try
+        {
+            action();
+        }
+        catch (Exception ex)
+        {
+            MessageBox.Show($"Openen is mislukt.\n\n{ex.Message}", "kniip", MessageBoxButton.OK, MessageBoxImage.Warning);
+        }
+    }
+}
@@ -0,0 +1,47 @@
+using System;
+using System.IO;
+using System.Text.Json.Serialization;
+
+namespace Kniip.History;
+
+public enum HistoryKind
+{
+    Snip,
+    Mp4,
+    Gif
+}
+
+public sealed class HistoryEntry
+{
+    public string Id { get; set; } = Guid.NewGuid().ToString("N");
+    public DateTime Time { get; set; } = DateTime.Now;
+    public HistoryKind Kind { get; set; }
+
+    /// <summary>Opgeslagen bestand; leeg als het alleen is geüpload.</summary>
+    public string? FilePath { get; set; }
+
+    /// <summary>Link na het uploaden; leeg als het alleen is opgeslagen.</summary>
+    public string? Url { get; set; }
+
+    /// <summary>Bestandsnaam van de miniatuur in <see cref="HistoryStore.ThumbnailFolder"/>.</summary>
+    public string? Thumbnail { get; set; }
+
+    public int Width { get; set; }
+    public int Height { get; set; }
+
+    [JsonIgnore]
+    public string Name => FilePath is { Length: > 0 }
+        ? Path.GetFileName(FilePath)
+        : Url is { Length: > 0 } ? Url[(Url.TrimEnd('/').LastIndexOf('/') + 1)..] : "";
+
+    [JsonIgnore]
+    public string KindText => Kind switch
+    {
+        HistoryKind.Mp4 => "Screencast (MP4)",
+        HistoryKind.Gif => "Screencast (GIF)",
+        _ => "Knipsel"
+    };
+
+    [JsonIgnore]
+    public bool FileExists => FilePath is { Length: > 0 } && File.Exists(FilePath);
+}
@@ -0,0 +1,169 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using Kniip.Infrastructure;
+using Kniip.Settings;
+
+namespace Kniip.History;
+
+/// <summary>Wat er in kniip is opgeslagen of geüpload, nieuwste eerst.</summary>
+public static class HistoryStore
+{
+    private const int MaxEntries = 500;
+    private const int ThumbnailSize = 240;
+
+    private static readonly JsonSerializerOptions Options = new()
+    {
+        Converters = { new JsonStringEnumConverter() }
+    };
+
+    private static List<HistoryEntry>? _entries;
+
+    private static string FilePath => Path.Combine(SettingsStore.Folder, "history.json");
+
+    public static string ThumbnailFolder => Path.Combine(SettingsStore.Folder, "history");
+
+    public static event Action? Changed;
+
+    public static IReadOnlyList<HistoryEntry> Entries => Load();
+
+    public static void Add(HistoryKind kind, string? filePath, string? url, BitmapSource? preview)
+    {
+        var entry = new HistoryEntry { Kind = kind, FilePath = filePath, Url = url };
+        if (preview != null)
+        {
+            entry.Width = preview.PixelWidth;
+            entry.Height = preview.PixelHeight;
+            entry.Thumbnail = SaveThumbnail(entry.Id, preview);
+        }
+
+        List<HistoryEntry> entries = Load();
+        entries.Insert(0, entry);
+        while (entries.Count > MaxEntries)
+        {
+            DeleteThumbnail(entries[^1]);
+            entries.RemoveAt(entries.Count - 1);
+        }
+
+        Save();
+    }
+
+    public static void Remove(HistoryEntry entry)
+    {
+        if (Load().Remove(entry))
+        {
+            DeleteThumbnail(entry);
+            Save();
+        }
+    }
+
+    public static void Clear()
+    {
+        foreach (HistoryEntry entry in Load())
+        {
+            DeleteThumbnail(entry);
+        }
+
+        Load().Clear();
+        Save();
+    }
+
+    public static string? ThumbnailPath(HistoryEntry entry) =>
+        entry.Thumbnail is { Length: > 0 } name ? Path.Combine(ThumbnailFolder, name) : null;
+
+    /// <summary>Eerste beeld van een afbeelding of GIF, of null als dat niet lukt.</summary>
+    public static BitmapSource? PreviewOf(string file)
+    {
+        try
+        {
+            return PixelUtil.LoadFile(file);
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+    }
+
+    private static List<HistoryEntry> Load()
+    {
+        if (_entries != null)
+        {
+            return _entries;
+        }
+
+        try
+        {
+            if (File.Exists(FilePath))
+            {
+                _entries = JsonSerializer.Deserialize<List<HistoryEntry>>(File.ReadAllText(FilePath), Options);
+            }
+        }
+        catch (Exception)
+        {
+            // Beschadigd bestand: met een lege geschiedenis verder.
+        }
+
+        _entries ??= new List<HistoryEntry>();
+        _entries.RemoveAll(entry => entry == null!);
+        return _entries;
+    }
+
+    private static void Save()
+    {
+        try
+        {
+            Directory.CreateDirectory(SettingsStore.Folder);
+            File.WriteAllText(FilePath, JsonSerializer.Serialize(Load(), Options));
+        }
+        catch (Exception)
+        {
+            // De geschiedenis bijwerken mag opslaan of uploaden nooit laten mislukken.
+        }
+
+        Changed?.Invoke();
+    }
+
+    private static string? SaveThumbnail(string id, BitmapSource image)
+    {
+        try
+        {
+            double scale = Math.Min(1.0, (double)ThumbnailSize / Math.Max(image.PixelWidth, image.PixelHeight));
+            BitmapSource thumb = scale < 1 ? new TransformedBitmap(image, new ScaleTransform(scale, scale)) : image;
+            var encoder = new PngBitmapEncoder();
+            encoder.Frames.Add(BitmapFrame.Create(thumb));
+            Directory.CreateDirectory(ThumbnailFolder);
+            string name = id + ".png";
+            using var stream = new FileStream(Path.Combine(ThumbnailFolder, name), FileMode.Create, FileAccess.Write);
+            encoder.Save(stream);
+            return name;
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+    }
+
+    private static void DeleteThumbnail(HistoryEntry entry)
+    {
+        if (ThumbnailPath(entry) is not { } path)
+        {
+            return;
+        }
+
+        try
+        {
+            File.Delete(path);
+        }
+        catch (Exception)
+        {
+            // Blijft staan; een losse miniatuur kan geen kwaad.
+        }
+    }
+
+    public static IEnumerable<HistoryEntry> Recent(int count) => Load().Take(count);
+}
@@ -0,0 +1,135 @@
+<Window x:Class="Kniip.History.HistoryWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="kniip geschiedenis" Width="980" Height="620" MinWidth="560" MinHeight="360"
+        WindowStartupLocation="CenterScreen" Background="{StaticResource WindowBrush}"
+        FontFamily="Segoe UI" FontSize="13" Icon="pack://application:,,,/AppIcon.ico">
+    <Window.Resources>
+        <Style x:Key="ViewToggle" TargetType="RadioButton" BasedOn="{StaticResource ToolToggle}">
+            <Setter Property="Padding" Value="10,4" />
+        </Style>
+        <Style x:Key="RowStyle" TargetType="ListViewItem">
+            <Setter Property="HorizontalContentAlignment" Value="Stretch" />
+            <EventSetter Event="MouseDoubleClick" Handler="Item_DoubleClick" />
+            <Style.Triggers>
+                <DataTrigger Binding="{Binding IsAvailable}" Value="False">
+                    <Setter Property="Opacity" Value="0.5" />
+                </DataTrigger>
+            </Style.Triggers>
+        </Style>
+        <Style x:Key="TileStyle" TargetType="ListBoxItem">
+            <Setter Property="Padding" Value="0" />
+            <Setter Property="Margin" Value="4" />
+            <EventSetter Event="MouseDoubleClick" Handler="Item_DoubleClick" />
+            <Setter Property="Template">
+                <Setter.Value>
+                    <ControlTemplate TargetType="ListBoxItem">
+                        <Border x:Name="Bd" Background="White" BorderBrush="#E0E0E0" BorderThickness="1" CornerRadius="6" Padding="6">
+                            <ContentPresenter />
+                        </Border>
+                        <ControlTemplate.Triggers>
+                            <Trigger Property="IsMouseOver" Value="True">
+                                <Setter TargetName="Bd" Property="Background" Value="#F5F5F5" />
+                            </Trigger>
+                            <Trigger Property="IsSelected" Value="True">
+                                <Setter TargetName="Bd" Property="Background" Value="#1A0067C0" />
+                                <Setter TargetName="Bd" Property="BorderBrush" Value="{StaticResource AccentBrush}" />
+                            </Trigger>
+                            <DataTrigger Binding="{Binding IsAvailable}" Value="False">
+                                <Setter Property="Opacity" Value="0.5" />
+                            </DataTrigger>
+                        </ControlTemplate.Triggers>
+                    </ControlTemplate>
+                </Setter.Value>
+            </Setter>
+        </Style>
+        <DataTemplate x:Key="SmallThumb">
+            <Grid Width="40" Height="28">
+                <Image Source="{Binding Thumbnail}" Stretch="Uniform" RenderOptions.BitmapScalingMode="HighQuality" />
+                <TextBlock Text="&#xE714;" Style="{StaticResource IconText}" Foreground="{StaticResource SubtleTextBrush}"
+                           Visibility="{Binding NoThumbnailVisibility}" />
+            </Grid>
+        </DataTemplate>
+    </Window.Resources>
+
+    <DockPanel Margin="12">
+        <DockPanel DockPanel.Dock="Top" Margin="0,0,0,10" LastChildFill="False">
+            <RadioButton x:Name="ListToggle" Style="{StaticResource ViewToggle}" GroupName="View" Checked="View_Checked">
+                <StackPanel Orientation="Horizontal">
+                    <TextBlock Text="&#xE8FD;" Style="{StaticResource IconText}" Margin="0,0,6,0" />
+                    <TextBlock Text="Lijst" VerticalAlignment="Center" />
+                </StackPanel>
+            </RadioButton>
+            <RadioButton x:Name="GridToggle" Style="{StaticResource ViewToggle}" GroupName="View" Checked="View_Checked">
+                <StackPanel Orientation="Horizontal">
+                    <TextBlock Text="&#xE91B;" Style="{StaticResource IconText}" Margin="0,0,6,0" />
+                    <TextBlock Text="Miniaturen" VerticalAlignment="Center" />
+                </StackPanel>
+            </RadioButton>
+            <Grid DockPanel.Dock="Right" Width="260" VerticalAlignment="Center">
+                <TextBox x:Name="SearchBox" Height="30" Padding="26,0,6,0" VerticalContentAlignment="Center"
+                         TextChanged="SearchBox_TextChanged" />
+                <TextBlock Text="&#xE721;" Style="{StaticResource IconText}" FontSize="13" HorizontalAlignment="Left" Margin="8,0,0,0"
+                           Foreground="{StaticResource SubtleTextBrush}" IsHitTestVisible="False" />
+                <TextBlock x:Name="SearchHint" Text="Zoeken op naam of link" Margin="27,0,0,0" VerticalAlignment="Center"
+                           Foreground="{StaticResource SubtleTextBrush}" IsHitTestVisible="False" />
+            </Grid>
+        </DockPanel>
+
+        <DockPanel DockPanel.Dock="Bottom" Margin="0,10,0,0" LastChildFill="False">
+            <TextBlock x:Name="CountText" VerticalAlignment="Center" Foreground="{StaticResource SubtleTextBrush}" />
+            <Button DockPanel.Dock="Right" Content="Sluiten" Style="{StaticResource SecondaryButton}" IsCancel="True" Click="Close_Click" />
+            <Button x:Name="ClearButton" DockPanel.Dock="Right" Content="Geschiedenis wissen..." Style="{StaticResource SecondaryButton}"
+                    Click="Clear_Click" />
+        </DockPanel>
+
+        <Grid>
+            <ListView x:Name="ListItems" ItemContainerStyle="{StaticResource RowStyle}" SelectionMode="Single"
+                      BorderBrush="#E0E0E0" ContextMenuOpening="Items_ContextMenuOpening">
+                <ListView.ContextMenu>
+                    <ContextMenu />
+                </ListView.ContextMenu>
+                <ListView.View>
+                    <GridView>
+                        <GridViewColumn Width="56" CellTemplate="{StaticResource SmallThumb}" />
+                        <GridViewColumn Header="Datum" Width="140" DisplayMemberBinding="{Binding TimeText}" />
+                        <GridViewColumn Header="Soort" Width="120" DisplayMemberBinding="{Binding Entry.KindText}" />
+                        <GridViewColumn Header="Naam" Width="200" DisplayMemberBinding="{Binding Entry.Name}" />
+                        <GridViewColumn Header="Map" Width="200" DisplayMemberBinding="{Binding Folder}" />
+                        <GridViewColumn Header="Link" Width="220" DisplayMemberBinding="{Binding Entry.Url}" />
+                    </GridView>
+                </ListView.View>
+            </ListView>
+
+            <ListBox x:Name="GridItems" ItemContainerStyle="{StaticResource TileStyle}" SelectionMode="Single" Visibility="Collapsed"
+                     Background="Transparent" BorderThickness="0" ScrollViewer.HorizontalScrollBarVisibility="Disabled"
+                     ContextMenuOpening="Items_ContextMenuOpening">
+                <ListBox.ContextMenu>
+                    <ContextMenu />
+                </ListBox.ContextMenu>
+                <ListBox.ItemsPanel>
+                    <ItemsPanelTemplate>
+                        <WrapPanel />
+                    </ItemsPanelTemplate>
+                </ListBox.ItemsPanel>
+                <ListBox.ItemTemplate>
+                    <DataTemplate>
+                        <StackPanel Width="180" ToolTip="{Binding ToolTip}">
+                            <Grid Height="120" Background="#F3F3F3">
+                                <Image Source="{Binding Thumbnail}" Stretch="Uniform" RenderOptions.BitmapScalingMode="HighQuality" />
+                                <TextBlock Text="&#xE714;" Style="{StaticResource IconText}" FontSize="32"
+                                           Foreground="{StaticResource SubtleTextBrush}" Visibility="{Binding NoThumbnailVisibility}" />
+                            </Grid>
+                            <TextBlock Text="{Binding Entry.Name}" Margin="0,6,0,0" TextTrimming="CharacterEllipsis" />
+                            <TextBlock Text="{Binding TimeText}" FontSize="12" Foreground="{StaticResource SubtleTextBrush}" />
+                        </StackPanel>
+                    </DataTemplate>
+                </ListBox.ItemTemplate>
+            </ListBox>
+
+            <TextBlock x:Name="EmptyText" HorizontalAlignment="Center" VerticalAlignment="Center" TextAlignment="Center"
+                       Foreground="{StaticResource SubtleTextBrush}" Visibility="Collapsed"
+                       Text="Nog niets in de geschiedenis.&#x0a;Wat je in kniip opslaat of uploadt, komt hier te staan." />
+        </Grid>
+    </DockPanel>
+</Window>
@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+
+namespace Kniip.History;
+
+public partial class HistoryWindow : Window
+{
+    private List<HistoryRow> _rows = new();
+
+    public HistoryWindow(bool images)
+    {
+        InitializeComponent();
+        Reload();
+        ShowImages(images);
+        HistoryStore.Changed += Reload;
+        Closed += (_, _) => HistoryStore.Changed -= Reload;
+    }
+
+    public void ShowImages(bool images)
+    {
+        (images ? GridToggle : ListToggle).IsChecked = true;
+    }
+
+    private void Reload()
+    {
+        _rows = HistoryStore.Entries.Select(entry => new HistoryRow(entry)).ToList();
+        ListItems.ItemsSource = _rows;
+        GridItems.ItemsSource = _rows;
+        ApplyFilter();
+    }
+
+    private void ApplyFilter()
+    {
+        string query = SearchBox.Text.Trim();
+        ICollectionView view = System.Windows.Data.CollectionViewSource.GetDefaultView(_rows);
+        view.Filter = query.Length == 0 ? null : item => ((HistoryRow)item).Matches(query);
+        int shown = view.Cast<object>().Count();
+        CountText.Text = query.Length == 0 ? $"{_rows.Count} items" : $"{shown} van {_rows.Count} items";
+        EmptyText.Visibility = _rows.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
+        ClearButton.IsEnabled = _rows.Count > 0;
+    }
+
+    private void View_Checked(object sender, RoutedEventArgs e)
+    {
+        bool images = GridToggle.IsChecked == true;
+        GridItems.Visibility = images ? Visibility.Visible : Visibility.Collapsed;
+        ListItems.Visibility = images ? Visibility.Collapsed : Visibility.Visible;
+        Title = images ? "kniip afbeeldingsgeschiedenis" : "kniip geschiedenis";
+    }
+
+    private void SearchBox_TextChanged(object sender, TextChangedEventArgs e)
+    {
+        SearchHint.Visibility = SearchBox.Text.Length == 0 ? Visibility.Visible : Visibility.Collapsed;
+        ApplyFilter();
+    }
+
+    private void Item_DoubleClick(object sender, MouseButtonEventArgs e)
+    {
+        if (sender is FrameworkElement { DataContext: HistoryRow row })
+        {
+            HistoryActions.Open(row.Entry);
+        }
+    }
+
+    private void Items_ContextMenuOpening(object sender, ContextMenuEventArgs e)
+    {
+        var list = (Selector)sender;
+        if (e.OriginalSource is DependencyObject source
+            && ItemsControl.ContainerFromElement(list, source) is FrameworkElement { DataContext: HistoryRow clicked })
+        {
+            list.SelectedItem = clicked;
+        }
+
+        if (list.SelectedItem is not HistoryRow row || list.ContextMenu is not { } menu)
+        {
+            e.Handled = true;
+            return;
+        }
+
+        menu.Items.Clear();
+        foreach (HistoryCommand? command in HistoryActions.CommandsFor(row.Entry))
+        {
+            menu.Items.Add(command == null ? new Separator() : MenuItemFor(command.Label, command.Glyph, command.Enabled, command.Run));
+        }
+
+        menu.Items.Add(new Separator());
+        menu.Items.Add(MenuItemFor("Uit geschiedenis verwijderen", "\uE74D", true, () => HistoryStore.Remove(row.Entry)));
+    }
+
+    private static MenuItem MenuItemFor(string label, string glyph, bool enabled, Action run)
+    {
+        var item = new MenuItem
+        {
+            Header = label,
+            IsEnabled = enabled,
+            Icon = new TextBlock { Text = glyph, Style = (Style)Application.Current.FindResource("IconText"), FontSize = 14 }
+        };
+        item.Click += (_, _) => run();
+        return item;
+    }
+
+    private void Clear_Click(object sender, RoutedEventArgs e)
+    {
+        if (MessageBox.Show(this, "De hele geschiedenis wissen? Je opgeslagen bestanden en uploads blijven gewoon bestaan.", "kniip",
+                MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.Yes)
+        {
+            HistoryStore.Clear();
+        }
+    }
+
+    private void Close_Click(object sender, RoutedEventArgs e) => Close();
+
+    private sealed class HistoryRow
+    {
+        public HistoryRow(HistoryEntry entry)
+        {
+            Entry = entry;
+            IsAvailable = entry.FileExists || entry.Url is { Length: > 0 };
+            Thumbnail = LoadThumbnail(entry);
+        }
+
+        public HistoryEntry Entry { get; }
+        public bool IsAvailable { get; }
+        public ImageSource? Thumbnail { get; }
+        public Visibility NoThumbnailVisibility => Thumbnail == null ? Visibility.Visible : Visibility.Collapsed;
+        public string TimeText => Entry.Time.ToString("dd-MM-yyyy HH:mm:ss");
+        public string? Folder => Entry.FilePath is { Length: > 0 } path ? Path.GetDirectoryName(path) : null;
+
+        public string ToolTip => string.Join("\n", new[]
+        {
+            Entry.KindText + (Entry.Width > 0 ? $", {Entry.Width} x {Entry.Height}" : ""),
+            Entry.FilePath,
+            Entry.Url
+        }.Where(line => !string.IsNullOrEmpty(line)));
+
+        public bool Matches(string query) =>
+            Entry.Name.Contains(query, StringComparison.OrdinalIgnoreCase)
+            || (Entry.FilePath?.Contains(query, StringComparison.OrdinalIgnoreCase) ?? false)
+            || (Entry.Url?.Contains(query, StringComparison.OrdinalIgnoreCase) ?? false);
+
+        private static ImageSource? LoadThumbnail(HistoryEntry entry)
+        {
+            if (HistoryStore.ThumbnailPath(entry) is not { } path || !File.Exists(path))
+            {
+                return null;
+            }
+
+            try
+            {
+                var image = new BitmapImage();
+                image.BeginInit();
+                image.CacheOption = BitmapCacheOption.OnLoad;
+                image.StreamSource = new MemoryStream(File.ReadAllBytes(path));
+                image.EndInit();
+                image.Freeze();
+                return image;
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+    }
+}
@@ -0,0 +1,19 @@
+namespace Kniip.Infrastructure;
+
+/// <summary>
+/// Namen waaronder kniip zich in Windows inschrijft. De testbuild (<c>-p:KniipTest=true</c>) gebruikt eigen
+/// namen voor register, instellingen, mutex en tijdelijke bestanden, zodat hij naast de geïnstalleerde
+/// kniip kan draaien en die nooit overschrijft.
+/// </summary>
+internal static class AppIdentity
+{
+#if KNIIP_TEST
+    public static bool IsTest => true;
+    public const string Key = "KniipTest";
+    public const string DisplayName = "kniip test";
+#else
+    public static bool IsTest => false;
+    public const string Key = "Kniip";
+    public const string DisplayName = "kniip";
+#endif
+}
@@ -9,10 +9,10 @@ namespace Kniip.Infrastructure;
 /// </summary>
 internal static class ShellIntegration
 {
-    private const string ProgId = "Kniip.Image";
-    private const string AppKeyName = "Kniip.exe";
+    private const string ProgId = AppIdentity.Key + ".Image";
+    private const string AppKeyName = AppIdentity.Key + ".exe";
    private const string RunKeyPath = @"Software\Microsoft\Windows\CurrentVersion\Run";
-    private const string RunValueName = "Kniip";
+    private const string RunValueName = AppIdentity.Key;

    public static readonly string[] ImageExtensions = { ".png", ".jpg", ".jpeg", ".bmp", ".gif" };

@@ -32,8 +32,8 @@ internal static class ShellIntegration
    {
        using (var prog = Registry.CurrentUser.CreateSubKey($@"Software\Classes\{ProgId}"))
        {
-            prog.SetValue(null, "kniip afbeelding");
-            prog.SetValue("FriendlyTypeName", "kniip afbeelding");
+            prog.SetValue(null, $"{AppIdentity.DisplayName} afbeelding");
+            prog.SetValue("FriendlyTypeName", $"{AppIdentity.DisplayName} afbeelding");
        }
        using (var icon = Registry.CurrentUser.CreateSubKey($@"Software\Classes\{ProgId}\DefaultIcon"))
        {
@@ -46,7 +46,7 @@ internal static class ShellIntegration

        using (var app = Registry.CurrentUser.CreateSubKey($@"Software\Classes\Applications\{AppKeyName}"))
        {
-            app.SetValue("FriendlyAppName", "kniip editor");
+            app.SetValue("FriendlyAppName", $"{AppIdentity.DisplayName} editor");
        }
        using (var appCmd = Registry.CurrentUser.CreateSubKey($@"Software\Classes\Applications\{AppKeyName}\shell\open\command"))
        {
@@ -89,6 +89,11 @@ internal static class ShellIntegration
    /// </summary>
    public static void MigrateLegacyRegistration()
    {
+        if (AppIdentity.IsTest)
+        {
+            return;
+        }
+
        const string legacyProgId = "KnipPlus.Image";
        const string legacyAppKeyName = "KnipPlus.exe";
        const string legacyRunValueName = "KnipPlus";
@@ -13,7 +13,7 @@ namespace Kniip.Infrastructure;
 /// </summary>
 internal sealed class SingleInstance : IDisposable
 {
-    private static readonly string BaseName = "Kniip-" + Environment.UserName;
+    private static readonly string BaseName = AppIdentity.Key + "-" + Environment.UserName;
    private static readonly string PipeName = BaseName + "-pipe";

    private readonly CancellationTokenSource _cts = new();
@@ -1,6 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.Drawing;
+using System.IO;
+using System.Linq;
 using System.Windows.Forms;
+using Kniip.History;

 namespace Kniip.Infrastructure;

@@ -9,11 +13,22 @@ internal sealed class TrayIcon : IDisposable
    private readonly NotifyIcon _icon;
    private const string RecordText = "Screencast opnemen (MP4)...";

+    private readonly ToolStripMenuItem _clipboardItem;
    private readonly ToolStripMenuItem _pauseItem;
    private readonly ToolStripMenuItem _snipItem;
    private readonly ToolStripMenuItem _windowItem;
    private readonly ToolStripMenuItem _recordItem;
    private readonly ToolStripMenuItem _gifItem;
+    private readonly ToolStripMenuItem _foldersItem;
+    private readonly ToolStripMenuItem _recentItem;
+    private readonly ToolStripMenuItem _delayItem;
+    private TrackBar _delaySlider = null!;
+    private NumericUpDown _delayNumber = null!;
+    private int _delaySeconds;
+    private int _savedDelaySeconds;
+
+    /// <summary>Nieuwe vertraging in seconden, afgevuurd bij het sluiten van het submenu als de waarde is gewijzigd.</summary>
+    public event Action<int>? CaptureDelayChanged;

    public event Action? OpenFromClipboardRequested;
    public event Action? SnipRequested;
@@ -25,26 +40,46 @@ internal sealed class TrayIcon : IDisposable
    public event Action? ExitRequested;
    public event Action<bool>? PauseChanged;

+    /// <summary>Geschiedenisvenster openen; true = met miniaturen.</summary>
+    public event Action<bool>? HistoryRequested;
+
+    /// <summary>Mappen voor het submenu Map openen, opgevraagd bij het openen; een pad van null staat grijs.</summary>
+    public Func<IReadOnlyList<(string Label, string? Path)>>? FoldersProvider { get; set; }
+
    public TrayIcon()
    {
        var menu = new ContextMenuStrip();
-        var openClipboard = new ToolStripMenuItem("Bewerken vanaf klembord", null, (_, _) => OpenFromClipboardRequested?.Invoke())
+        _clipboardItem = new ToolStripMenuItem("Bewerken vanaf klembord", null, (_, _) => OpenFromClipboardRequested?.Invoke())
        {
            Font = new Font(SystemFonts.MenuFont ?? Control.DefaultFont, FontStyle.Bold)
        };
-        menu.Items.Add(openClipboard);
+        menu.Items.Add(_clipboardItem);
        menu.Items.Add("Afbeelding openen...", null, (_, _) => OpenFileRequested?.Invoke());
        menu.Items.Add(new ToolStripSeparator());
        _snipItem = new ToolStripMenuItem("Rechthoek knippen", null, (_, _) => SnipRequested?.Invoke());
        menu.Items.Add(_snipItem);
        _windowItem = new ToolStripMenuItem("Venster knippen", null, (_, _) => WindowSnipRequested?.Invoke());
        menu.Items.Add(_windowItem);
+        _delayItem = BuildDelayItem();
+        menu.Items.Add(_delayItem);
        _recordItem = new ToolStripMenuItem(RecordText, null, (_, _) => RecordRequested?.Invoke());
        menu.Items.Add(_recordItem);
        _gifItem = new ToolStripMenuItem("Screencast opnemen (GIF)...", null, (_, _) => GifRequested?.Invoke());
        menu.Items.Add(_gifItem);
        menu.Items.Add(new ToolStripSeparator());

+        _foldersItem = new ToolStripMenuItem("Map openen");
+        _foldersItem.DropDownItems.Add(new ToolStripMenuItem("..."));
+        _foldersItem.DropDownOpening += (_, _) => BuildFolders();
+        menu.Items.Add(_foldersItem);
+        menu.Items.Add("Geschiedenis...", null, (_, _) => HistoryRequested?.Invoke(false));
+        menu.Items.Add("Afbeeldingsgeschiedenis...", null, (_, _) => HistoryRequested?.Invoke(true));
+        _recentItem = new ToolStripMenuItem("Recente items");
+        _recentItem.DropDownItems.Add(new ToolStripMenuItem("..."));
+        _recentItem.DropDownOpening += (_, _) => BuildRecent();
+        menu.Items.Add(_recentItem);
+        menu.Items.Add(new ToolStripSeparator());
+
        _pauseItem = new ToolStripMenuItem("Knipsels niet automatisch oppikken") { CheckOnClick = true };
        _pauseItem.CheckedChanged += (_, _) => PauseChanged?.Invoke(_pauseItem.Checked);
        menu.Items.Add(_pauseItem);
@@ -55,7 +90,7 @@ internal sealed class TrayIcon : IDisposable
        _icon = new NotifyIcon
        {
            Icon = LoadIcon(),
-            Text = "kniip - annotaties voor het Knipprogramma",
+            Text = IdleText,
            ContextMenuStrip = menu,
            Visible = true
        };
@@ -71,8 +106,9 @@ internal sealed class TrayIcon : IDisposable
    public bool IsPaused => _pauseItem.Checked;

    /// <summary>Toont de sneltoetsen naast de menu-items; null = geen sneltoets.</summary>
-    public void SetHotkeys(string? snip, string? window, string? record, string? gif)
+    public void SetHotkeys(string? snip, string? window, string? record, string? gif, string? clipboard)
    {
+        _clipboardItem.ShortcutKeyDisplayString = clipboard;
        _snipItem.ShortcutKeyDisplayString = snip;
        _windowItem.ShortcutKeyDisplayString = window;
        _recordItem.ShortcutKeyDisplayString = record;
@@ -84,7 +120,179 @@ internal sealed class TrayIcon : IDisposable
    {
        _recordItem.Text = text ?? RecordText;
        _gifItem.Visible = text == null;
-        _icon.Text = recording ? "kniip - opname loopt" : "kniip - annotaties voor het Knipprogramma";
+        _icon.Text = recording ? $"{AppIdentity.DisplayName} - opname loopt" : IdleText;
+    }
+
+    public void SetCaptureDelay(int seconds)
+    {
+        _savedDelaySeconds = seconds;
+        ShowCaptureDelay(seconds);
+    }
+
+    private ToolStripMenuItem BuildDelayItem()
+    {
+        var item = new ToolStripMenuItem();
+        _delaySlider = new TrackBar
+        {
+            Minimum = 0,
+            Maximum = Kniip.Settings.AppSettings.MaxCaptureDelaySeconds,
+            TickFrequency = 5,
+            LargeChange = 5,
+            SmallChange = 1,
+            AutoSize = false,
+            Width = 200,
+            Height = 32,
+            Location = new Point(4, 6)
+        };
+        _delayNumber = new NumericUpDown
+        {
+            Minimum = 0,
+            Maximum = Kniip.Settings.AppSettings.MaxCaptureDelaySeconds,
+            Width = 52,
+            Location = new Point(_delaySlider.Right + 6, 10),
+            TextAlign = HorizontalAlignment.Right
+        };
+        var unit = new Label
+        {
+            Text = "seconden",
+            AutoSize = true,
+            Location = new Point(_delayNumber.Right + 4, 13)
+        };
+        var panel = new Panel
+        {
+            Size = new Size(unit.Left + unit.PreferredWidth + 10, 44),
+            BackColor = ProfessionalColors.ToolStripDropDownBackground
+        };
+        _delaySlider.BackColor = panel.BackColor;
+        panel.Controls.AddRange(new Control[] { _delaySlider, _delayNumber, unit });
+
+        _delaySlider.ValueChanged += (_, _) => ShowCaptureDelay(_delaySlider.Value);
+        _delayNumber.ValueChanged += (_, _) => ShowCaptureDelay((int)_delayNumber.Value);
+        _delayNumber.KeyDown += (_, e) =>
+        {
+            if (e.KeyCode is Keys.Enter or Keys.Escape)
+            {
+                e.SuppressKeyPress = true;
+                _icon.ContextMenuStrip?.Close();
+            }
+        };
+
+        item.DropDownItems.Add(new ToolStripControlHost(panel) { AutoSize = false, Size = panel.Size, Margin = Padding.Empty });
+        item.DropDownClosed += (_, _) =>
+        {
+            ShowCaptureDelay((int)_delayNumber.Value);
+            if (_delaySeconds != _savedDelaySeconds)
+            {
+                _savedDelaySeconds = _delaySeconds;
+                CaptureDelayChanged?.Invoke(_delaySeconds);
+            }
+        };
+        item.Text = "Schermafdruk vertraging: 0s";
+        return item;
+    }
+
+    private void ShowCaptureDelay(int seconds)
+    {
+        _delaySeconds = seconds;
+        if (_delaySlider.Value != seconds)
+        {
+            _delaySlider.Value = seconds;
+        }
+
+        if ((int)_delayNumber.Value != seconds)
+        {
+            _delayNumber.Value = seconds;
+        }
+
+        _delayItem.Text = $"Schermafdruk vertraging: {seconds}s";
+    }
+
+    private static string IdleText => AppIdentity.IsTest
+        ? $"{AppIdentity.DisplayName} {Kniip.Update.UpdateChecker.CurrentVersion}"
+        : "kniip - annotaties voor het Knipprogramma";
+
+    private void BuildFolders()
+    {
+        _foldersItem.DropDownItems.Clear();
+        foreach ((string label, string? path) in FoldersProvider?.Invoke() ?? Array.Empty<(string, string?)>())
+        {
+            var item = new ToolStripMenuItem(label) { Enabled = path != null, ToolTipText = path };
+            if (path != null)
+            {
+                item.Click += (_, _) => HistoryActions.OpenFolder(path);
+            }
+
+            _foldersItem.DropDownItems.Add(item);
+        }
+    }
+
+    private void BuildRecent()
+    {
+        foreach (ToolStripItem old in _recentItem.DropDownItems)
+        {
+            old.Image?.Dispose();
+        }
+
+        _recentItem.DropDownItems.Clear();
+        List<HistoryEntry> entries = HistoryStore.Recent(10).ToList();
+        if (entries.Count == 0)
+        {
+            _recentItem.DropDownItems.Add(new ToolStripMenuItem("Nog niets opgeslagen") { Enabled = false });
+            return;
+        }
+
+        foreach (HistoryEntry entry in entries)
+        {
+            var item = new ToolStripMenuItem($"[{entry.Time:HH:mm:ss}] {entry.Url ?? entry.Name}")
+            {
+                Image = LoadThumbnail(entry),
+                ToolTipText = entry.FilePath
+            };
+            item.Click += (_, _) =>
+            {
+                _icon.ContextMenuStrip?.Close();
+                HistoryActions.Open(entry);
+            };
+            foreach (HistoryCommand? command in HistoryActions.CommandsFor(entry))
+            {
+                if (command == null)
+                {
+                    item.DropDownItems.Add(new ToolStripSeparator());
+                }
+                else
+                {
+                    item.DropDownItems.Add(new ToolStripMenuItem(command.Label, null, (_, _) => command.Run()) { Enabled = command.Enabled });
+                }
+            }
+
+            _recentItem.DropDownItems.Add(item);
+        }
+    }
+
+    private static Image? LoadThumbnail(HistoryEntry entry)
+    {
+        if (HistoryStore.ThumbnailPath(entry) is not { } path || !File.Exists(path))
+        {
+            return null;
+        }
+
+        try
+        {
+            using var stream = new MemoryStream(File.ReadAllBytes(path));
+            using var image = Image.FromStream(stream);
+            Size size = SystemInformation.SmallIconSize;
+            double scale = Math.Min((double)size.Width / image.Width, (double)size.Height / image.Height);
+            var thumb = new Bitmap(size.Width, size.Height);
+            using Graphics g = Graphics.FromImage(thumb);
+            g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
+            int w = Math.Max(1, (int)(image.Width * scale)), h = Math.Max(1, (int)(image.Height * scale));
+            g.DrawImage(image, (size.Width - w) / 2, (size.Height - h) / 2, w, h);
+            return thumb;
+        }
+        catch (Exception)
+        {
+            return null;
+        }
    }

    public void ShowBalloon(string title, string text) =>
@@ -26,6 +26,37 @@ internal static class NativeMethods
    [DllImport("user32.dll")]
    public static extern uint GetClipboardSequenceNumber();

+    public const uint CF_UNICODETEXT = 13;
+    public const uint GMEM_MOVEABLE = 0x0002;
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool OpenClipboard(IntPtr hWndNewOwner);
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool CloseClipboard();
+
+    [DllImport("user32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool EmptyClipboard();
+
+    [DllImport("user32.dll", SetLastError = true)]
+    public static extern IntPtr SetClipboardData(uint format, IntPtr hMem);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern IntPtr GlobalAlloc(uint flags, UIntPtr bytes);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern IntPtr GlobalLock(IntPtr hMem);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    public static extern bool GlobalUnlock(IntPtr hMem);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern IntPtr GlobalFree(IntPtr hMem);
+
    [DllImport("user32.dll")]
    public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint processId);

@@ -18,7 +18,7 @@
    <ApplicationManifest>app.manifest</ApplicationManifest>
    <Product>kniip</Product>
    <Description>Annotatie-editor naast het Windows Knipprogramma</Description>
-    <Version>1.0.0</Version>
+    <Version>1.1.5</Version>
    <SatelliteResourceLanguages>nl;en</SatelliteResourceLanguages>
    <!-- WPF regelt DPI via app.manifest; de WinForms-analyzer is hier niet van toepassing. -->
    <NoWarn>$(NoWarn);WFAC010</NoWarn>
@@ -26,12 +26,19 @@
    <AllowedReferenceRelatedFileExtensions>.none</AllowedReferenceRelatedFileExtensions>
  </PropertyGroup>

+  <!-- Testbuild (build.ps1, -p:KniipTest=true): eigen register- en instellingennamen, zie AppIdentity. -->
+  <PropertyGroup Condition="'$(KniipTest)' == 'true'">
+    <DefineConstants>$(DefineConstants);KNIIP_TEST</DefineConstants>
+    <Product>kniip test</Product>
+  </PropertyGroup>
+
  <ItemGroup>
    <Resource Include="AppIcon.ico" />
    <Resource Include="Assets\Emoji\emoji.json;Assets\Emoji\twemoji-64.png" />
  </ItemGroup>

  <ItemGroup>
+    <PackageReference Include="Markdig" Version="1.6.0" />
    <PackageReference Include="ScreenRecorderLib" Version="7.0.1" />
    <PackageReference Include="System.Security.Cryptography.ProtectedData" Version="8.0.0" />
  </ItemGroup>
@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Drawing;
+using System.Linq;
 using System.Text;
 using System.Windows;
 using System.Windows.Interop;
@@ -39,9 +41,37 @@ internal static class PhysicalWindow
        NativeMethods.SetWindowDisplayAffinity(Handle(window), NativeMethods.WDA_EXCLUDEFROMCAPTURE);

    /// <summary>Zichtbare topniveauvensters, van boven naar onder; die van kniip zelf alleen met <paramref name="includeOwn"/>.</summary>
-    public static List<Rectangle> SnapshotWindows(bool includeOwn = false)
+    public static List<Rectangle> SnapshotWindows(bool includeOwn = false) =>
+        Snapshot(includeOwn).Select(w => w.Bounds).ToList();
+
+    /// <summary>Programmanaam van het bovenste venster uit <paramref name="windows"/> onder het midden van <paramref name="area"/>.</summary>
+    public static string? ProgramNameAt(IEnumerable<SnappedWindow> windows, Rectangle area)
    {
-        var result = new List<Rectangle>();
+        var point = new System.Drawing.Point(area.X + area.Width / 2, area.Y + area.Height / 2);
+        foreach (SnappedWindow window in windows)
+        {
+            if (!window.Bounds.Contains(point))
+            {
+                continue;
+            }
+
+            try
+            {
+                using Process process = Process.GetProcessById((int)window.ProcessId);
+                return process.ProcessName;
+            }
+            catch (Exception)
+            {
+                return null;
+            }
+        }
+
+        return null;
+    }
+
+    public static List<SnappedWindow> Snapshot(bool includeOwn = false)
+    {
+        var result = new List<SnappedWindow>();
        int ownPid = Environment.ProcessId;
        var className = new StringBuilder(64);
        NativeMethods.EnumWindows((hwnd, _) =>
@@ -69,7 +99,7 @@ internal static class PhysicalWindow
            NativeMethods.RECT rect = NativeMethods.GetVisibleWindowRect(hwnd);
            if (rect.Width > 8 && rect.Height > 8)
            {
-                result.Add(new Rectangle(rect.Left, rect.Top, rect.Width, rect.Height));
+                result.Add(new SnappedWindow(new Rectangle(rect.Left, rect.Top, rect.Width, rect.Height), pid));
            }

            return true;
@@ -78,3 +108,5 @@ internal static class PhysicalWindow
        return result;
    }
 }
+
+internal sealed record SnappedWindow(Rectangle Bounds, uint ProcessId);
@@ -52,8 +52,11 @@ internal sealed class RecordingController

    public event Action<RecordingStage>? StageChanged;

-    /// <summary>Pad van een geslaagde opname (tijdelijk MP4-bestand) en het voorgestelde formaat.</summary>
-    public event Action<string, ScreencastFormat?>? RecordingFinished;
+    /// <summary>Pad van een geslaagde opname (tijdelijk MP4-bestand), het voorgestelde formaat en de programmanaam van het opgenomen venster.</summary>
+    public event Action<string, ScreencastFormat?, string?>? RecordingFinished;
+
+    private List<SnappedWindow> _snapshot = new();
+    private string? _windowName;

    public event Action<string, string>? Notify;

@@ -124,13 +127,18 @@ internal sealed class RecordingController
    {
        _format = format;
        SetStage(RecordingStage.Selecting);
-        List<System.Drawing.Rectangle> windows = PhysicalWindow.SnapshotWindows();
+        _snapshot = PhysicalWindow.Snapshot();
+        List<System.Drawing.Rectangle> windows = _snapshot.Select(w => w.Bounds).ToList();
        NativeMethods.GetCursorPos(out NativeMethods.POINT cursor);
        var cursorPoint = new System.Drawing.Point(cursor.X, cursor.Y);

-        foreach (Screen screen in Screen.AllScreens)
+        // Vastleggen voordat de overlays er staan, anders zit hun grijze laag in het vergrootglas.
+        var frozen = Screen.AllScreens
+            .Select(screen => (screen, image: _settings.ShowMagnifier ? Kniip.Capture.ScreenGrabber.Capture(screen.Bounds) : null))
+            .ToList();
+        foreach ((Screen screen, System.Windows.Media.Imaging.BitmapSource? image) in frozen)
        {
-            var selector = new RegionSelectorWindow(screen, windows);
+            var selector = new RegionSelectorWindow(screen, windows, image);
            selector.Finished += OnRegionChosen;
            _selectors.Add(selector);
            selector.Show();
@@ -150,6 +158,8 @@ internal sealed class RecordingController
        }

        _selectors.Clear();
+        List<SnappedWindow> snapshot = _snapshot;
+        _snapshot = new();
        if (region == null)
        {
            SetStage(RecordingStage.Idle);
@@ -157,6 +167,7 @@ internal sealed class RecordingController
        }

        _region = region;
+        _windowName = PhysicalWindow.ProgramNameAt(snapshot, region.Bounds);
        Screen screen = Screen.AllScreens.FirstOrDefault(s => s.DeviceName == region.DeviceName) ?? Screen.PrimaryScreen!;

        _frame = new RegionFrameWindow(region.Bounds);
@@ -299,6 +310,7 @@ internal sealed class RecordingController
    {
        bool discard = _discard;
        ScreencastFormat? format = _format;
+        string? windowName = _windowName;
        EndAll();
        if (discard)
        {
@@ -306,7 +318,7 @@ internal sealed class RecordingController
            return;
        }

-        RecordingFinished?.Invoke(path, format);
+        RecordingFinished?.Invoke(path, format, windowName);
    }

    private void OnFailed(string error, bool started)
@@ -360,6 +372,7 @@ internal sealed class RecordingController
        _frame?.Close();
        _frame = null;
        _region = null;
+        _windowName = null;
        _format = null;
        _discard = false;
        _retriedWithoutAudio = false;
@@ -15,7 +15,7 @@ internal sealed record RecordingOptions(bool SystemAudio, bool Microphone, bool
 /// <summary>Eén opname naar een tijdelijk MP4-bestand. Gebeurtenissen komen binnen op de UI-thread.</summary>
 internal sealed class RecordingSession : IDisposable
 {
-    public static string TempFolder { get; } = Path.Combine(Path.GetTempPath(), "Kniip");
+    public static string TempFolder { get; } = Path.Combine(Path.GetTempPath(), Infrastructure.AppIdentity.Key);

    private readonly Dispatcher _dispatcher;
    private readonly RecordingRegion _region;
@@ -1,6 +1,7 @@
 <Window x:Class="Kniip.Recording.RegionSelectorWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:capture="clr-namespace:Kniip.Capture"
        Title="kniip opnamegebied kiezen" WindowStyle="None" AllowsTransparency="True" ResizeMode="NoResize"
        ShowInTaskbar="False" Topmost="True" Cursor="Cross" FontFamily="Segoe UI" FontSize="13"
        Background="#01000000">
@@ -12,6 +13,7 @@
                CornerRadius="4" Padding="6,2" Visibility="Collapsed" IsHitTestVisible="False">
            <TextBlock x:Name="SizeText" Foreground="White" FontSize="12" />
        </Border>
+        <capture:MagnifierControl x:Name="Magnifier" />
        <Border x:Name="Hint" HorizontalAlignment="Center" VerticalAlignment="Top" Margin="0,28,0,0" Background="#F2FFFFFF"
                CornerRadius="6" Padding="16,9" IsHitTestVisible="False">
            <Border.Effect>
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Windows;
 using System.Windows.Input;
 using System.Windows.Media;
+using System.Windows.Media.Imaging;
 using Rectangle = System.Drawing.Rectangle;
 using Screen = System.Windows.Forms.Screen;

@@ -19,6 +20,7 @@ public partial class RegionSelectorWindow : Window

    private readonly Screen _screen;
    private readonly IReadOnlyList<Rectangle> _windows;
+    private readonly BitmapSource? _frozen;
    private Point? _dragStart;
    private bool _dragging;
    private Rectangle? _hover;
@@ -26,15 +28,18 @@ public partial class RegionSelectorWindow : Window
    /// <summary>Gekozen gebied, of null bij annuleren.</summary>
    internal event Action<RecordingRegion?>? Finished;

-    internal RegionSelectorWindow(Screen screen, IReadOnlyList<Rectangle> windows)
+    /// <param name="frozen">Beeld van het scherm voor het vergrootglas; null betekent geen vergrootglas.</param>
+    internal RegionSelectorWindow(Screen screen, IReadOnlyList<Rectangle> windows, BitmapSource? frozen = null)
    {
        InitializeComponent();
        _screen = screen;
        _windows = windows;
+        _frozen = frozen;
        SourceInitialized += (_, _) => PhysicalWindow.Place(this, screen.Bounds);
        Loaded += (_, _) => ShowSelection(null);
        MouseLeave += (_, _) =>
        {
+            Magnifier.Hide();
            if (!_dragging)
            {
                _hover = null;
@@ -49,6 +54,13 @@ public partial class RegionSelectorWindow : Window
    {
        base.OnMouseMove(e);
        Point position = e.GetPosition(this);
+        if (_frozen != null)
+        {
+            System.Drawing.Point physical = ToPhysical(position);
+            var relative = new System.Drawing.Point(physical.X - _screen.Bounds.X, physical.Y - _screen.Bounds.Y);
+            Magnifier.Show(_frozen, relative, physical, position, new Size(ActualWidth, ActualHeight));
+        }
+
        if (_dragStart is Point start && e.LeftButton == MouseButtonState.Pressed)
        {
            if (!_dragging && (position - start).Length >= DragThreshold)
@@ -34,6 +34,7 @@ public partial class ScreencastWindow : Window

    private readonly string _path;
    private readonly AppSettings _settings;
+    private readonly string? _windowName;
    private readonly DispatcherTimer _playTimer = new() { Interval = TimeSpan.FromMilliseconds(40) };
    private TimeSpan _duration;
    private TimeSpan _start;
@@ -45,11 +46,13 @@ public partial class ScreencastWindow : Window
    private bool _kept;
    private string? _lastSaved;

-    internal ScreencastWindow(string path, AppSettings settings, ScreencastFormat? format = null)
+    /// <param name="windowName">Programmanaam van het opgenomen venster, voor %V in het naamsjabloon.</param>
+    internal ScreencastWindow(string path, AppSettings settings, ScreencastFormat? format = null, string? windowName = null)
    {
        InitializeComponent();
        _path = path;
        _settings = settings;
+        _windowName = windowName;

        int[] fpsChoices = FpsChoices.Contains(settings.GifFps) ? FpsChoices : FpsChoices.Append(settings.GifFps).Order().ToArray();
        foreach (int fps in fpsChoices)
@@ -382,8 +385,11 @@ public partial class ScreencastWindow : Window
        }
    }

-    private string DefaultFileName =>
-        $"Screencast {DateTime.Now:yyyy-MM-dd HHmmss}{(Format == ScreencastFormat.Gif ? ".gif" : ".mp4")}";
+    private string Extension => Format == ScreencastFormat.Gif ? ".gif" : ".mp4";
+
+    private static string DefaultName => $"Screencast {DateTime.Now:yyyy-MM-dd HHmmss}";
+
+    private string DefaultFileName => DefaultName + Extension;

    private static string DefaultFolder =>
        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyVideos), "kniip");
@@ -413,6 +419,7 @@ public partial class ScreencastWindow : Window
        {
            _kept = true;
            RememberChoices();
+            AddToHistory(target, null, target);
            bool copy = _settings.SaveButton == SaveButtonChoice.SaveAndCopy;
            bool copied = !copy || ClipboardWriter.SetFile(target);
            App.Instance.ShowBalloon(copy && copied ? "Screencast opgeslagen en gekopieerd" : "Screencast opgeslagen", target);
@@ -435,8 +442,7 @@ public partial class ScreencastWindow : Window

        try
        {
-            Directory.CreateDirectory(folder);
-            return SaveLocation.UniquePath(folder, DefaultFileName);
+            return FileNameTemplate.Resolve(folder, _settings.VideoFileNameTemplate, _windowName ?? "Screencast", DefaultName, Extension);
        }
        catch (Exception ex)
        {
@@ -455,7 +461,7 @@ public partial class ScreencastWindow : Window
        {
            Title = "Screencast opslaan",
            Filter = gif ? "GIF-animatie (*.gif)|*.gif" : "MP4-video (*.mp4)|*.mp4",
-            FileName = DefaultFileName,
+            FileName = FileNameTemplate.SuggestedName(_settings.VideoFileNameTemplate, _windowName ?? "Screencast", DefaultName) + Extension,
            InitialDirectory = folder,
            AddExtension = true
        };
@@ -519,6 +525,7 @@ public partial class ScreencastWindow : Window

            _kept = true;
            RememberChoices();
+            AddToHistory(null, url, target);
            bool copied = ClipboardWriter.SetText(url);
            SavedRun.Text = copied ? $"Geüpload; de link staat op het klembord: {url}  " : $"Geüpload: {url}  ";
            OpenRun.Text = "Link openen";
@@ -548,6 +555,14 @@ public partial class ScreencastWindow : Window
        }
    }

+    /// <param name="exported">Het geëxporteerde bestand, voor de miniatuur van een GIF.</param>
+    private void AddToHistory(string? file, string? url, string exported)
+    {
+        bool gif = Format == ScreencastFormat.Gif;
+        Kniip.History.HistoryStore.Add(gif ? Kniip.History.HistoryKind.Gif : Kniip.History.HistoryKind.Mp4, file, url,
+            gif ? Kniip.History.HistoryStore.PreviewOf(exported) : null);
+    }
+
    private void RememberChoices()
    {
        _settings.LastScreencastFormat = Format;
@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Windows.Controls;
 using Kniip.Editor;
@@ -32,6 +33,15 @@ public enum SaveButtonChoice
    SaveAndCopy
 }

+public enum EditorLayout
+{
+    /// <summary>Eén werkbalk met gereedschappen en acties.</summary>
+    Single,
+
+    /// <summary>Split-weergave: gereedschappen boven, opslaan/kopiëren en zoom onder.</summary>
+    Split
+}
+
 public sealed class AppSettings
 {
    public bool WatchClipboard { get; set; } = true;
@@ -44,6 +54,9 @@ public sealed class AppSettings

    /// <summary>Map waarin knipsels zonder te vragen worden opgeslagen; leeg betekent elke keer vragen.</summary>
    public string? SnipSaveFolder { get; set; }
+
+    /// <summary>Naamsjabloon voor knipsels (zie FileNameTemplate); leeg betekent "Knipsel" met datum en tijd.</summary>
+    public string? SnipFileNameTemplate { get; set; }
    public Dictionary<ToolKind, StyleSet> ToolStyles { get; set; } = new();

    /// <summary>Recent gekozen emoji (codepunten), nieuwste eerst.</summary>
@@ -60,6 +73,9 @@ public sealed class AppSettings

    /// <summary>Sneltoets voor een screencast die als GIF wordt aangeboden.</summary>
    public string GifHotkey { get; set; } = "Ctrl+Shift+G";
+
+    /// <summary>Sneltoets om de afbeelding op het klembord in de editor te openen; standaard geen.</summary>
+    public string ClipboardHotkey { get; set; } = "";
    public bool RecordSystemAudio { get; set; } = true;
    public bool RecordMicrophone { get; set; }
    public bool RecordShowCursor { get; set; } = true;
@@ -73,6 +89,9 @@ public sealed class AppSettings
    /// <summary>Map waarin screencasts zonder te vragen worden opgeslagen; leeg betekent elke keer vragen.</summary>
    public string? VideoSaveFolder { get; set; }

+    /// <summary>Naamsjabloon voor screencasts (zie FileNameTemplate); leeg betekent "Screencast" met datum en tijd.</summary>
+    public string? VideoFileNameTemplate { get; set; }
+
    /// <summary>Gedrag van de knop Opslaan in de editor en de screencast.</summary>
    public SaveButtonChoice SaveButton { get; set; } = SaveButtonChoice.SaveOnly;

@@ -85,11 +104,34 @@ public sealed class AppSettings
    /// <summary>Volgorde van de werkbalkitems (ItemId's); leeg betekent de standaardvolgorde.</summary>
    public List<string> ToolbarOrder { get; set; } = new();

+    /// <summary>Indeling van de werkbalk(en) in de editor.</summary>
+    public EditorLayout EditorLayout { get; set; } = EditorLayout.Split;
+
+    /// <summary>Volgorde van de werkbalkitems in de gesplitste indeling (boven, dan onder); leeg betekent de standaardvolgorde.</summary>
+    public List<string> SplitToolbarOrder { get; set; } = new();
+
    public List<string> ToolbarHidden { get; set; } = new();

    /// <summary>Zipline-server waar Uploaden naartoe gaat; leeg betekent geen uploadknop.</summary>
    public UploaderConfig? Uploader { get; set; }

+    /// <summary>Bij het starten en daarna dagelijks op de achtergrond kijken of er een nieuwere versie is.</summary>
+    public bool CheckForUpdates { get; set; } = true;
+
+    /// <summary>Vergrootglas met kruisdraad en coördinaten tonen bij het kiezen van een gebied (knipsel en screencast).</summary>
+    public bool ShowMagnifier { get; set; } = true;
+
+    private int _captureDelaySeconds;
+
+    /// <summary>Seconden wachten voordat een rechthoek- of vensterknipsel het scherm bevriest (0-60); 0 is direct.</summary>
+    public int CaptureDelaySeconds
+    {
+        get => _captureDelaySeconds;
+        set => _captureDelaySeconds = Math.Clamp(value, 0, MaxCaptureDelaySeconds);
+    }
+
+    public const int MaxCaptureDelaySeconds = 60;
+
    public StyleSet StyleFor(ToolKind tool)
    {
        if (!ToolStyles.TryGetValue(tool, out StyleSet? style))
@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text.RegularExpressions;
+
+namespace Kniip.Settings;
+
+/// <summary>
+/// Naamsjabloon voor opslaan: %J jaar, %M maand, %D dag, %V programmanaam van het venster,
+/// %Rn n willekeurige tekens, %Nn eerste vrije nummer in de map met n cijfers. / of \ maakt submappen.
+/// </summary>
+public static class FileNameTemplate
+{
+    private const int MaxWidth = 32;
+    private const string RandomChars = "abcdefghijklmnopqrstuvwxyz0123456789";
+
+    private static readonly Regex Token = new(@"%(?:(?<k>[JMDV])|(?<k>[RN])(?<n>\d{1,2}))",
+        RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+
+    public const string Help =
+        "%J jaar, %M maand, %D dag, %V programmanaam van het venster, %R6 zes willekeurige tekens, %N3 oplopend nummer met drie cijfers (001). " +
+        "Met / maak je submappen. De extensie kiest kniip zelf.";
+
+    /// <summary>
+    /// Volledig pad in <paramref name="folder"/> dat nog niet bestaat; de submappen worden aangemaakt.
+    /// Een leeg sjabloon geeft <paramref name="defaultName"/>.
+    /// </summary>
+    public static string Resolve(string folder, string? template, string windowName, string defaultName, string extension)
+    {
+        var randoms = new Dictionary<int, string>();
+        DateTime now = DateTime.Now;
+        bool counts = HasCounter(template);
+        for (int number = 1; ; number++)
+        {
+            List<string> parts = Parts(template, windowName, defaultName, now, number, randoms);
+            string directory = Path.Combine(new[] { folder }.Concat(parts.SkipLast(1)).ToArray());
+            Directory.CreateDirectory(directory);
+            string fileName = parts[^1] + extension;
+            if (!counts)
+            {
+                return SaveLocation.UniquePath(directory, fileName);
+            }
+
+            string path = Path.Combine(directory, fileName);
+            if (!File.Exists(path))
+            {
+                return path;
+            }
+        }
+    }
+
+    /// <summary>Voorbeeld van het pad onder de opslagmap, zonder naar bestaande bestanden te kijken.</summary>
+    public static string Preview(string? template, string windowName, string defaultName, string extension) =>
+        string.Join(Path.DirectorySeparatorChar, Parts(template, windowName, defaultName, DateTime.Now, 1, new Dictionary<int, string>())) + extension;
+
+    /// <summary>Alleen de bestandsnaam zonder extensie, als voorstel in een opslagvenster.</summary>
+    public static string SuggestedName(string? template, string windowName, string defaultName) =>
+        Parts(template, windowName, defaultName, DateTime.Now, 1, new Dictionary<int, string>())[^1];
+
+    private static bool HasCounter(string? template) =>
+        !string.IsNullOrWhiteSpace(template)
+        && Token.Matches(template).Any(m => char.ToUpperInvariant(m.Groups["k"].Value[0]) == 'N');
+
+    /// <summary>Opgeschoonde mapnamen gevolgd door de bestandsnaam zonder extensie.</summary>
+    private static List<string> Parts(string? template, string windowName, string defaultName, DateTime now, int number, Dictionary<int, string> randoms)
+    {
+        var parts = new List<string>();
+        if (!string.IsNullOrWhiteSpace(template))
+        {
+            string expanded = Token.Replace(template, m => Value(m, windowName, now, number, randoms));
+            parts.AddRange(expanded.Split('/', '\\').Select(Clean).Where(p => p.Length > 0));
+        }
+
+        if (parts.Count == 0 || template!.TrimEnd().EndsWith('/') || template.TrimEnd().EndsWith('\\'))
+        {
+            parts.Add(Clean(defaultName));
+        }
+
+        return parts;
+    }
+
+    private static string Value(Match match, string windowName, DateTime now, int number, Dictionary<int, string> randoms)
+    {
+        int width = match.Groups["n"].Success ? Math.Min(int.Parse(match.Groups["n"].Value, CultureInfo.InvariantCulture), MaxWidth) : 0;
+        switch (char.ToUpperInvariant(match.Groups["k"].Value[0]))
+        {
+            case 'J':
+                return now.Year.ToString(CultureInfo.InvariantCulture);
+            case 'M':
+                return now.Month.ToString("00", CultureInfo.InvariantCulture);
+            case 'D':
+                return now.Day.ToString("00", CultureInfo.InvariantCulture);
+            case 'V':
+                return windowName.Replace('/', '_').Replace('\\', '_');
+            case 'R':
+                if (!randoms.TryGetValue(match.Index, out string? random))
+                {
+                    random = new string(Enumerable.Range(0, width).Select(_ => RandomChars[RandomNumberGenerator.GetInt32(RandomChars.Length)]).ToArray());
+                    randoms[match.Index] = random;
+                }
+
+                return random;
+            default:
+                return number.ToString(CultureInfo.InvariantCulture).PadLeft(width, '0');
+        }
+    }
+
+    private static string Clean(string segment)
+    {
+        char[] invalid = Path.GetInvalidFileNameChars();
+        string cleaned = new(segment.Select(c => invalid.Contains(c) ? '_' : c).ToArray());
+        return cleaned.Trim().TrimEnd('.').Trim();
+    }
+}
@@ -7,19 +7,24 @@ using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using System.Windows.Media;
+using Kniip.Infrastructure;

 namespace Kniip.Settings;

 public static class SettingsStore
 {
    public static string Folder { get; } =
-        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "Kniip");
+        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), AppIdentity.Key);

    private static string FilePath => Path.Combine(Folder, "settings.json");

-    /// <summary>Instellingen van voor de hernoeming van Knip+ naar kniip.</summary>
+    /// <summary>
+    /// Startpunt als er nog geen instellingen zijn: voor kniip die van voor de hernoeming van Knip+,
+    /// voor de testbuild een kopie van die van de gewone kniip.
+    /// </summary>
    private static string LegacyFilePath =>
-        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "KnipPlus", "settings.json");
+        Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
+            AppIdentity.IsTest ? "Kniip" : "KnipPlus", "settings.json");

    private static readonly JsonSerializerOptions Options = new()
    {
@@ -1,7 +1,7 @@
 <Window x:Class="Kniip.Settings.SettingsWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-        Title="kniip instellingen" Width="720" Height="540" ResizeMode="NoResize"
+        Title="kniip instellingen" Width="720" Height="600" ResizeMode="NoResize"
        WindowStartupLocation="CenterScreen" Background="{StaticResource WindowBrush}"
        FontFamily="Segoe UI" FontSize="13" Icon="pack://application:,,,/AppIcon.ico">
    <Window.Resources>
@@ -70,11 +70,8 @@
                            </Grid.ColumnDefinitions>
                            <TabPanel Grid.Column="0" IsItemsHost="True" VerticalAlignment="Top" Background="Transparent" />
                            <Border Grid.Column="1" Background="White" BorderBrush="#E5E5E5" BorderThickness="1"
-                                    CornerRadius="6" SnapsToDevicePixels="True">
-                                <ScrollViewer VerticalScrollBarVisibility="Auto" HorizontalScrollBarVisibility="Disabled"
-                                              Padding="16,14">
-                                    <ContentPresenter ContentSource="SelectedContent" />
-                                </ScrollViewer>
+                                    CornerRadius="6" SnapsToDevicePixels="True" Padding="16,14">
+                                <ContentPresenter ContentSource="SelectedContent" />
                            </Border>
                        </Grid>
                    </ControlTemplate>
@@ -130,14 +127,23 @@
                        <Button Tag="Record" Style="{StaticResource FlatButton}" Content="Geen" Click="ClearHotkey_Click" Margin="6,0,0,0"
                                ToolTip="Geen sneltoets gebruiken" />
                    </StackPanel>
-                    <StackPanel Orientation="Horizontal" Margin="0,0,0,6">
+                    <StackPanel Orientation="Horizontal" Margin="0,0,0,4">
                        <TextBlock Text="Screencast (GIF)" VerticalAlignment="Center" Width="150" />
                        <Button x:Name="GifHotkeyButton" Tag="Gif" Style="{StaticResource SecondaryButton}" Width="170" Margin="0"
                                Click="HotkeyButton_Click" ToolTip="Klik en druk daarna de gewenste toetscombinatie in" />
                        <Button Tag="Gif" Style="{StaticResource FlatButton}" Content="Geen" Click="ClearHotkey_Click" Margin="6,0,0,0"
                                ToolTip="Geen sneltoets gebruiken" />
                    </StackPanel>
+                    <StackPanel Orientation="Horizontal" Margin="0,0,0,6">
+                        <TextBlock Text="Vanaf klembord" VerticalAlignment="Center" Width="150" />
+                        <Button x:Name="ClipboardHotkeyButton" Tag="Clipboard" Style="{StaticResource SecondaryButton}" Width="170" Margin="0"
+                                Click="HotkeyButton_Click" ToolTip="Klik en druk daarna de gewenste toetscombinatie in; opent de afbeelding op het klembord" />
+                        <Button Tag="Clipboard" Style="{StaticResource FlatButton}" Content="Geen" Click="ClearHotkey_Click" Margin="6,0,0,0"
+                                ToolTip="Geen sneltoets gebruiken" />
+                    </StackPanel>
                    <TextBlock x:Name="HotkeyHint" Style="{StaticResource Hint}" Margin="0,0,0,4" />
+                    <TextBlock Text="Gebied kiezen" Style="{StaticResource CardTitle}" Margin="0,12,0,8" />
+                    <CheckBox x:Name="MagnifierBox" Content="Vergrootglas tonen bij het kiezen van een gebied (knipsel en screencast)" />
                </StackPanel>
            </TabItem>

@@ -163,6 +169,12 @@
                                Margin="6,0,0,0" />
                        <TextBlock x:Name="SnipFolderText" VerticalAlignment="Center" TextTrimming="CharacterEllipsis" />
                    </DockPanel>
+                    <DockPanel Margin="0,0,0,2">
+                        <TextBlock Text="Naam" VerticalAlignment="Center" Width="110" Padding="12,0,0,0" />
+                        <TextBox x:Name="SnipTemplateBox" Height="26" VerticalContentAlignment="Center" TextChanged="Template_TextChanged"
+                                 ToolTip="Leeg: Knipsel met datum en tijd" />
+                    </DockPanel>
+                    <TextBlock x:Name="SnipTemplatePreview" Style="{StaticResource Hint}" Margin="110,0,0,8" TextTrimming="CharacterEllipsis" />
                    <DockPanel Margin="0,0,0,4">
                        <TextBlock Text="Screencasts" VerticalAlignment="Center" Width="110" />
                        <Button Tag="Video" DockPanel.Dock="Right" Style="{StaticResource FlatButton}" Content="Vragen" Click="ClearSaveFolder_Click"
@@ -171,8 +183,15 @@
                                Margin="6,0,0,0" />
                        <TextBlock x:Name="VideoFolderText" VerticalAlignment="Center" TextTrimming="CharacterEllipsis" />
                    </DockPanel>
+                    <DockPanel Margin="0,0,0,2">
+                        <TextBlock Text="Naam" VerticalAlignment="Center" Width="110" Padding="12,0,0,0" />
+                        <TextBox x:Name="VideoTemplateBox" Height="26" VerticalContentAlignment="Center" TextChanged="Template_TextChanged"
+                                 ToolTip="Leeg: Screencast met datum en tijd" />
+                    </DockPanel>
+                    <TextBlock x:Name="VideoTemplatePreview" Style="{StaticResource Hint}" Margin="110,0,0,8" TextTrimming="CharacterEllipsis" />
+                    <TextBlock x:Name="TemplateHelp" Style="{StaticResource Hint}" Margin="0,0,0,4" />
                    <TextBlock Style="{StaticResource Hint}" Margin="0,4,0,8"
-                               Text="Met een map ingesteld slaat Opslaan (Ctrl+S) direct op, met datum en tijd in de naam. Shift+klik of Ctrl+Shift+S vraagt toch waar het bestand moet komen." />
+                               Text="Met een map ingesteld slaat Opslaan (Ctrl+S) direct op, met de naam hierboven. Shift+klik of Ctrl+Shift+S vraagt toch waar het bestand moet komen." />
                    <RadioButton x:Name="SaveOnlyRadio" GroupName="SaveButton" Content="Opslaan" />
                    <RadioButton x:Name="SaveAndCopyRadio" GroupName="SaveButton" Content="Opslaan en kopiëren" />
                    <TextBlock Style="{StaticResource Hint}"
@@ -236,6 +255,43 @@
                <StackPanel>
                    <TextBlock Text="Editor" Style="{StaticResource CardTitle}" />
                    <CheckBox x:Name="StraightHighlightBox" Content="Markeerstift trekt standaard een rechte horizontale streep (Shift wisselt)" />
+                    <TextBlock Text="Werkbalk" Style="{StaticResource CardTitle}" Margin="0,16,0,6" />
+                    <RadioButton x:Name="LayoutSplitRadio" GroupName="EditorLayout" Content="Split-weergave: gereedschappen boven, opslaan onder" />
+                    <RadioButton x:Name="LayoutSingleRadio" GroupName="EditorLayout" Content="Eén werkbalk met gereedschappen en acties" />
+                    <TextBlock Style="{StaticResource Hint}"
+                               Text="Ook te wisselen via rechtsklik op de werkbalk in de editor. Daar kun je knoppen ook verslepen of verbergen." />
+                </StackPanel>
+            </TabItem>
+
+            <TabItem x:Name="UpdateTab">
+                <TabItem.Header>
+                    <StackPanel Orientation="Horizontal">
+                        <TextBlock Text="Update" />
+                        <Ellipse x:Name="UpdateTabBadge" Width="8" Height="8" Fill="{StaticResource AccentBrush}" Stroke="White"
+                                 StrokeThickness="1" Margin="6,0,0,0" VerticalAlignment="Center" Visibility="Collapsed"
+                                 ToolTip="Er is een nieuwe versie beschikbaar" />
+                    </StackPanel>
+                </TabItem.Header>
+                <StackPanel>
+                    <TextBlock Text="Update" Style="{StaticResource CardTitle}" />
+                    <TextBlock x:Name="CurrentVersionText" Margin="0,0,0,2" />
+                    <CheckBox x:Name="AutoUpdateCheckBox" Content="Automatisch controleren op nieuwe versies (bij starten en dagelijks)" />
+                    <TextBlock x:Name="UpdateStatus" Style="{StaticResource Hint}" Margin="0,0,0,8" />
+                    <StackPanel Orientation="Horizontal" Margin="0,0,0,8">
+                        <Button x:Name="UpdateButton" Style="{StaticResource AccentButton}" Click="Update_Click" Margin="0,0,6,0"
+                                Visibility="Collapsed" ToolTip="Installer downloaden; kniip sluit, wordt bijgewerkt en start opnieuw" />
+                        <Button x:Name="CheckUpdateButton" Style="{StaticResource SecondaryButton}" Content="Opnieuw controleren"
+                                Click="CheckUpdate_Click" Margin="0,0,6,0" />
+                        <Button Style="{StaticResource FlatButton}" Content="Releasepagina" Click="ReleasePage_Click"
+                                ToolTip="https://git.hibbit.net/rogier/kniip/releases" />
+                    </StackPanel>
+                    <ProgressBar x:Name="DownloadProgress" Height="4" Minimum="0" Maximum="1" Margin="0,0,0,8"
+                                 Foreground="{StaticResource AccentBrush}" Visibility="Collapsed" />
+                    <Border BorderBrush="{StaticResource DividerBrush}" BorderThickness="1" CornerRadius="4" Height="300">
+                        <FlowDocumentScrollViewer x:Name="ChangelogViewer" VerticalScrollBarVisibility="Auto"
+                                                  HorizontalScrollBarVisibility="Disabled" IsToolBarVisible="False"
+                                                  Zoom="100" MinZoom="100" MaxZoom="100" Focusable="False" />
+                    </Border>
                </StackPanel>
            </TabItem>
        </TabControl>
@@ -10,6 +10,7 @@ using System.Windows.Media.Imaging;
 using Kniip.Capture;
 using Kniip.Editor;
 using Kniip.Infrastructure;
+using Kniip.Update;
 using Kniip.Upload;

 namespace Kniip.Settings;
@@ -25,6 +26,7 @@ public partial class SettingsWindow : Window
        ["Window"] = "venster knippen",
        ["Record"] = "screencast (MP4)",
        ["Gif"] = "screencast (GIF)",
+        ["Clipboard"] = "bewerken vanaf klembord",
    };

    private readonly AppSettings _settings;
@@ -35,11 +37,15 @@ public partial class SettingsWindow : Window
    private string? _videoFolder;
    private UploaderConfig? _uploader;
    private bool _resetEditor;
+    private bool _updateChecked;
+    private ReleaseInfo? _update;
+    private System.Threading.CancellationTokenSource? _updateCts;

    public SettingsWindow(AppSettings settings)
    {
        InitializeComponent();
        _settings = settings;
+        Title = $"{AppIdentity.DisplayName} instellingen";

        FolderText.Text = CaptureCoordinator.ScreenshotsFolder ?? "Map Schermafbeeldingen niet gevonden.";
        AutostartBox.IsChecked = ShellIntegration.IsAutostartEnabled();
@@ -58,14 +64,23 @@ public partial class SettingsWindow : Window
            ["Window"] = WindowHotkeyButton,
            ["Record"] = RecordHotkeyButton,
            ["Gif"] = GifHotkeyButton,
+            ["Clipboard"] = ClipboardHotkeyButton,
        };

        HotkeyHint.Text = App.Instance.HotkeyHook?.IsActive == true
            ? HotkeyHintText
            : "De toetsenbordhaak kon niet worden gestart; de sneltoetsen werken nu niet.";
        Deactivated += (_, _) => StopListening();
-        Closed += (_, _) => StopListening();
+        App.Instance.Updates.AvailabilityChanged += OnUpdateAvailabilityChanged;
+        Closed += (_, _) =>
+        {
+            StopListening();
+            _updateCts?.Cancel();
+            App.Instance.Updates.AvailabilityChanged -= OnUpdateAvailabilityChanged;
+        };
+        ShowUpdateBadge();

+        CurrentVersionText.Text = $"Geïnstalleerde versie: {UpdateChecker.CurrentVersion}";
        LoadFrom(settings);

        MaxHeight = SystemParameters.WorkArea.Height;
@@ -82,10 +97,17 @@ public partial class SettingsWindow : Window
        ActionOpenRadio.IsChecked = settings.Action == CaptureAction.OpenEditor;
        ActionNothingRadio.IsChecked = settings.Action == CaptureAction.Nothing;
        StraightHighlightBox.IsChecked = settings.StraightHighlight;
+        LayoutSplitRadio.IsChecked = settings.EditorLayout == EditorLayout.Split;
+        LayoutSingleRadio.IsChecked = settings.EditorLayout != EditorLayout.Split;
+        AutoUpdateCheckBox.IsChecked = settings.CheckForUpdates;
+        MagnifierBox.IsChecked = settings.ShowMagnifier;

        _snipFolder = settings.SnipSaveFolder;
        _videoFolder = settings.VideoSaveFolder;
        ShowSaveFolders();
+        SnipTemplateBox.Text = settings.SnipFileNameTemplate ?? string.Empty;
+        VideoTemplateBox.Text = settings.VideoFileNameTemplate ?? string.Empty;
+        ShowTemplatePreviews();
        SaveAndCopyRadio.IsChecked = settings.SaveButton == SaveButtonChoice.SaveAndCopy;
        SaveOnlyRadio.IsChecked = settings.SaveButton != SaveButtonChoice.SaveAndCopy;

@@ -93,6 +115,7 @@ public partial class SettingsWindow : Window
        _hotkeys["Window"] = settings.WindowHotkey;
        _hotkeys["Record"] = settings.RecordHotkey;
        _hotkeys["Gif"] = settings.GifHotkey;
+        _hotkeys["Clipboard"] = settings.ClipboardHotkey;
        foreach (string id in _hotkeys.Keys)
        {
            ShowHotkey(id);
@@ -233,6 +256,19 @@ public partial class SettingsWindow : Window
        text.Foreground = string.IsNullOrEmpty(folder) ? (Brush)Application.Current.Resources["SubtleTextBrush"] : SystemColors.ControlTextBrush;
    }

+    private void Template_TextChanged(object sender, TextChangedEventArgs e) => ShowTemplatePreviews();
+
+    private void ShowTemplatePreviews()
+    {
+        TemplateHelp.Text = FileNameTemplate.Help;
+        SnipTemplatePreview.Text = "Voorbeeld: " + FileNameTemplate.Preview(NullIfBlank(SnipTemplateBox.Text), "Cursor",
+            $"Knipsel {DateTime.Now:yyyy-MM-dd HHmmss}", ".png");
+        VideoTemplatePreview.Text = "Voorbeeld: " + FileNameTemplate.Preview(NullIfBlank(VideoTemplateBox.Text), "Cursor",
+            $"Screencast {DateTime.Now:yyyy-MM-dd HHmmss}", ".mp4");
+    }
+
+    private static string? NullIfBlank(string text) => string.IsNullOrWhiteSpace(text) ? null : text.Trim();
+
    private void BrowseSaveFolder_Click(object sender, RoutedEventArgs e)
    {
        bool snip = sender is FrameworkElement { Tag: "Snip" };
@@ -396,6 +432,8 @@ public partial class SettingsWindow : Window
        _settings.Uploader = _uploader;
        _settings.SnipSaveFolder = _snipFolder;
        _settings.VideoSaveFolder = _videoFolder;
+        _settings.SnipFileNameTemplate = NullIfBlank(SnipTemplateBox.Text);
+        _settings.VideoFileNameTemplate = NullIfBlank(VideoTemplateBox.Text);
        _settings.SaveButton = SaveAndCopyRadio.IsChecked == true
            ? SaveButtonChoice.SaveAndCopy
            : SaveButtonChoice.SaveOnly;
@@ -406,11 +444,15 @@ public partial class SettingsWindow : Window
            : ActionNothingRadio.IsChecked == true ? CaptureAction.Nothing
            : CaptureAction.Notify;
        _settings.StraightHighlight = StraightHighlightBox.IsChecked == true;
+        _settings.EditorLayout = LayoutSplitRadio.IsChecked == true ? EditorLayout.Split : EditorLayout.Single;
+        _settings.CheckForUpdates = AutoUpdateCheckBox.IsChecked == true;
+        _settings.ShowMagnifier = MagnifierBox.IsChecked == true;
        StopListening();
        _settings.SnipHotkey = _hotkeys["Snip"];
        _settings.WindowHotkey = _hotkeys["Window"];
        _settings.RecordHotkey = _hotkeys["Record"];
        _settings.GifHotkey = _hotkeys["Gif"];
+        _settings.ClipboardHotkey = _hotkeys["Clipboard"];
        _settings.RecordSystemAudio = SystemAudioBox.IsChecked == true;
        _settings.RecordMicrophone = MicrophoneBox.IsChecked == true;
        _settings.RecordShowCursor = ShowCursorBox.IsChecked == true;
@@ -429,6 +471,7 @@ public partial class SettingsWindow : Window
            _settings.ToolbarPosition = defaults.ToolbarPosition;
            _settings.ToolbarLocked = defaults.ToolbarLocked;
            _settings.ToolbarOrder = defaults.ToolbarOrder;
+            _settings.SplitToolbarOrder = defaults.SplitToolbarOrder;
            _settings.ToolbarHidden = defaults.ToolbarHidden;
        }

@@ -464,6 +507,204 @@ public partial class SettingsWindow : Window
        if (e.OriginalSource is TabControl)
        {
            StopListening();
+            if (UpdateTab.IsSelected && !_updateChecked)
+            {
+                _ = CheckForUpdatesAsync();
+            }
        }
    }
+
+    private void CheckUpdate_Click(object sender, RoutedEventArgs e) => _ = CheckForUpdatesAsync();
+
+    private void OnUpdateAvailabilityChanged(object? sender, EventArgs e) => ShowUpdateBadge();
+
+    private void ShowUpdateBadge() =>
+        UpdateTabBadge.Visibility = App.Instance.Updates.IsUpdateAvailable ? Visibility.Visible : Visibility.Collapsed;
+
+    private void ReleasePage_Click(object sender, RoutedEventArgs e) => OpenUrl(UpdateChecker.ReleasesPage);
+
+    private async System.Threading.Tasks.Task CheckForUpdatesAsync()
+    {
+        _updateChecked = true;
+        _updateCts?.Cancel();
+        var cts = new System.Threading.CancellationTokenSource();
+        _updateCts = cts;
+
+        _update = null;
+        UpdateButton.Visibility = Visibility.Collapsed;
+        CheckUpdateButton.IsEnabled = false;
+        UpdateStatus.Text = "Controleren op updates...";
+        try
+        {
+            IReadOnlyList<ReleaseInfo> releases = await UpdateChecker.GetReleasesAsync(cts.Token);
+            ShowReleases(releases);
+        }
+        catch (UpdateException ex)
+        {
+            UpdateStatus.Text = ex.Message;
+            ShowChangelog(Array.Empty<ReleaseInfo>(), "Geen changelog beschikbaar.");
+        }
+        catch (OperationCanceledException)
+        {
+            return;
+        }
+        finally
+        {
+            if (_updateCts == cts)
+            {
+                _updateCts = null;
+                CheckUpdateButton.IsEnabled = true;
+            }
+
+            cts.Dispose();
+        }
+    }
+
+    private void ShowReleases(IReadOnlyList<ReleaseInfo> releases)
+    {
+        Version current = UpdateChecker.CurrentVersion;
+        List<ReleaseInfo> newer = releases.Where(r => r.Version > current).ToList();
+        App.Instance.Updates.Report(newer.FirstOrDefault());
+        if (newer.Count == 0)
+        {
+            UpdateStatus.Text = releases.Count == 0
+                ? "Er zijn nog geen releases gepubliceerd."
+                : $"Je gebruikt de nieuwste versie ({current}).";
+            ReleaseInfo? notes = releases.FirstOrDefault(r => r.Version == current) ?? releases.FirstOrDefault();
+            ShowChangelog(notes == null ? Array.Empty<ReleaseInfo>() : new[] { notes }, "Geen changelog beschikbaar.");
+            return;
+        }
+
+        if (AppIdentity.IsTest)
+        {
+            UpdateStatus.Text = $"Versie {newer[0].Version} is beschikbaar. Deze testversie werkt zichzelf niet bij; " +
+                                "de installer zou de gewone kniip overschrijven.";
+            ShowChangelog(newer, null);
+            return;
+        }
+
+        _update = newer.FirstOrDefault(r => r.InstallerUrl != null);
+        if (_update != null)
+        {
+            UpdateStatus.Text = $"Versie {_update.Version} is beschikbaar.";
+            UpdateButton.Content = $"Updaten naar {_update.Version}";
+            UpdateButton.Visibility = Visibility.Visible;
+        }
+        else
+        {
+            UpdateStatus.Text = $"Versie {newer[0].Version} is beschikbaar, maar zonder installer. Download die via de releasepagina.";
+        }
+
+        ShowChangelog(newer, null);
+    }
+
+    private void ShowChangelog(IReadOnlyList<ReleaseInfo> releases, string? emptyText)
+    {
+        FlowDocument document = MarkdownRenderer.CreateDocument();
+        var culture = System.Globalization.CultureInfo.GetCultureInfo("nl-NL");
+        var baseUri = new Uri(UpdateChecker.RepositoryUrl);
+        foreach (ReleaseInfo release in releases)
+        {
+            Paragraph heading = MarkdownRenderer.Heading($"Versie {release.Version}", 17,
+                new Thickness(0, document.Blocks.Count == 0 ? 0 : 14, 0, 0));
+            document.Blocks.Add(heading);
+            if (release.Date is DateTimeOffset date)
+            {
+                document.Blocks.Add(new Paragraph(new Run(date.ToLocalTime().ToString("d MMMM yyyy", culture)))
+                {
+                    Foreground = (Brush)Application.Current.Resources["SubtleTextBrush"],
+                    FontSize = 12,
+                    Margin = new Thickness(0, 0, 0, 8),
+                });
+            }
+
+            if (string.IsNullOrWhiteSpace(release.Body))
+            {
+                document.Blocks.Add(new Paragraph(new Run("Geen beschrijving."))
+                {
+                    Foreground = (Brush)Application.Current.Resources["SubtleTextBrush"],
+                });
+            }
+            else
+            {
+                MarkdownRenderer.Append(document, release.Body, baseUri);
+            }
+        }
+
+        if (releases.Count == 0 && emptyText != null)
+        {
+            document.Blocks.Add(new Paragraph(new Run(emptyText))
+            {
+                Foreground = (Brush)Application.Current.Resources["SubtleTextBrush"],
+            });
+        }
+
+        ChangelogViewer.Document = document;
+    }
+
+    private async void Update_Click(object sender, RoutedEventArgs e)
+    {
+        if (_update is not { } release)
+        {
+            return;
+        }
+
+        string installFolder = System.IO.Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Programs", "Kniip");
+        bool installed = Environment.ProcessPath is { } exe
+                         && string.Equals(System.IO.Path.GetDirectoryName(exe), installFolder, StringComparison.OrdinalIgnoreCase);
+        string message = $"kniip wordt afgesloten, bijgewerkt naar versie {release.Version} en daarna opnieuw gestart. " +
+                         "Open editors en screencasts worden eerst gesloten.";
+        if (!installed)
+        {
+            message += $"\n\nDeze kniip is niet via de installer gestart; de nieuwe versie wordt geïnstalleerd in {installFolder}.";
+        }
+
+        if (MessageBox.Show(this, message, "kniip bijwerken", MessageBoxButton.OKCancel, MessageBoxImage.Information) != MessageBoxResult.OK)
+        {
+            return;
+        }
+
+        var cts = new System.Threading.CancellationTokenSource();
+        _updateCts = cts;
+        UpdateButton.IsEnabled = false;
+        CheckUpdateButton.IsEnabled = false;
+        DownloadProgress.Value = 0;
+        DownloadProgress.Visibility = Visibility.Visible;
+        UpdateStatus.Text = $"Versie {release.Version} downloaden...";
+        string path;
+        try
+        {
+            path = await UpdateInstaller.DownloadAsync(release, new Progress<double>(p => DownloadProgress.Value = p), cts.Token);
+        }
+        catch (OperationCanceledException)
+        {
+            return;
+        }
+        catch (Exception ex) when (ex is UpdateException or System.IO.IOException or UnauthorizedAccessException)
+        {
+            UpdateStatus.Text = $"Versie {release.Version} is beschikbaar.";
+            MessageBox.Show(this, $"De update kon niet worden gedownload.\n\n{ex.Message}", "kniip",
+                MessageBoxButton.OK, MessageBoxImage.Warning);
+            return;
+        }
+        finally
+        {
+            if (_updateCts == cts)
+            {
+                _updateCts = null;
+            }
+
+            cts.Dispose();
+            if (IsLoaded)
+            {
+                DownloadProgress.Visibility = Visibility.Collapsed;
+                UpdateButton.IsEnabled = true;
+                CheckUpdateButton.IsEnabled = true;
+            }
+        }
+
+        UpdateStatus.Text = "Installer starten...";
+        App.Instance.InstallUpdate(path);
+    }
 }
@@ -0,0 +1,351 @@
+using System;
+using System.Linq;
+using System.Windows;
+using System.Windows.Documents;
+using System.Windows.Media;
+using Markdig;
+using Markdig.Extensions.TaskLists;
+using Markdig.Syntax;
+using Markdig.Syntax.Inlines;
+using MdBlock = Markdig.Syntax.Block;
+using MdInline = Markdig.Syntax.Inlines.Inline;
+using WpfBlock = System.Windows.Documents.Block;
+using WpfInline = System.Windows.Documents.Inline;
+using WpfList = System.Windows.Documents.List;
+
+namespace Kniip.Update;
+
+/// <summary>Zet markdown (releasenotes) om naar een WPF <see cref="FlowDocument"/>.</summary>
+public static class MarkdownRenderer
+{
+    private static readonly MarkdownPipeline Pipeline = new MarkdownPipelineBuilder()
+        .UseEmphasisExtras()
+        .UseAutoLinks()
+        .UseTaskLists()
+        .Build();
+
+    private static readonly FontFamily CodeFont = new("Cascadia Mono, Consolas");
+    private static readonly Brush CodeBackground = Freeze(new SolidColorBrush(Color.FromRgb(0xF3, 0xF3, 0xF3)));
+    private static readonly Brush QuoteBorder = Freeze(new SolidColorBrush(Color.FromRgb(0xD0, 0xD0, 0xD0)));
+
+    private static Brush Accent => Resource("AccentBrush", Brushes.SteelBlue);
+
+    private static Brush Subtle => Resource("SubtleTextBrush", Brushes.Gray);
+
+    public static FlowDocument CreateDocument() => new()
+    {
+        FontFamily = new FontFamily("Segoe UI"),
+        FontSize = 13,
+        PagePadding = new Thickness(14, 10, 14, 10),
+        TextAlignment = TextAlignment.Left,
+        Background = Brushes.White,
+    };
+
+    /// <summary>Voegt de blokken van <paramref name="markdown"/> toe; relatieve links wijzen naar <paramref name="baseUri"/>.</summary>
+    public static void Append(FlowDocument document, string markdown, Uri? baseUri = null)
+    {
+        MarkdownDocument parsed = Markdown.Parse(markdown ?? string.Empty, Pipeline);
+        foreach (MdBlock block in parsed)
+        {
+            if (RenderBlock(block, baseUri) is { } rendered)
+            {
+                document.Blocks.Add(rendered);
+            }
+        }
+    }
+
+    public static Paragraph Heading(string text, double fontSize, Thickness margin) => new(new Run(text))
+    {
+        FontSize = fontSize,
+        FontWeight = FontWeights.SemiBold,
+        Margin = margin,
+    };
+
+    private static WpfBlock? RenderBlock(MdBlock block, Uri? baseUri)
+    {
+        switch (block)
+        {
+            case HeadingBlock heading:
+            {
+                var paragraph = new Paragraph
+                {
+                    FontSize = heading.Level switch { 1 => 19, 2 => 16.5, 3 => 14.5, _ => 13 },
+                    FontWeight = FontWeights.SemiBold,
+                    Margin = new Thickness(0, heading.Level <= 2 ? 12 : 8, 0, 4),
+                };
+                AddInlines(paragraph.Inlines, heading.Inline, baseUri);
+                return paragraph;
+            }
+
+            case ParagraphBlock paragraphBlock:
+            {
+                var paragraph = new Paragraph { Margin = new Thickness(0, 0, 0, 8) };
+                AddInlines(paragraph.Inlines, paragraphBlock.Inline, baseUri);
+                return paragraph;
+            }
+
+            case ListBlock listBlock:
+            {
+                var list = new WpfList
+                {
+                    MarkerStyle = listBlock.IsOrdered ? TextMarkerStyle.Decimal : TextMarkerStyle.Disc,
+                    Margin = new Thickness(0, 0, 0, 8),
+                    Padding = new Thickness(20, 0, 0, 0),
+                };
+                if (listBlock.IsOrdered && int.TryParse(listBlock.OrderedStart, out int start) && start > 0)
+                {
+                    list.StartIndex = start;
+                }
+
+                foreach (ListItemBlock itemBlock in listBlock.OfType<ListItemBlock>())
+                {
+                    var item = new ListItem();
+                    foreach (MdBlock child in itemBlock)
+                    {
+                        if (RenderBlock(child, baseUri) is { } rendered)
+                        {
+                            rendered.Margin = new Thickness(0, 0, 0, 2);
+                            item.Blocks.Add(rendered);
+                        }
+                    }
+
+                    list.ListItems.Add(item);
+                }
+
+                return list;
+            }
+
+            case QuoteBlock quote:
+            {
+                var section = new Section
+                {
+                    BorderBrush = QuoteBorder,
+                    BorderThickness = new Thickness(3, 0, 0, 0),
+                    Padding = new Thickness(10, 0, 0, 0),
+                    Margin = new Thickness(0, 0, 0, 8),
+                    Foreground = Subtle,
+                };
+                foreach (MdBlock child in quote)
+                {
+                    if (RenderBlock(child, baseUri) is { } rendered)
+                    {
+                        section.Blocks.Add(rendered);
+                    }
+                }
+
+                return section;
+            }
+
+            case CodeBlock code:
+            {
+                var paragraph = new Paragraph
+                {
+                    FontFamily = CodeFont,
+                    FontSize = 12,
+                    Background = CodeBackground,
+                    Padding = new Thickness(8, 6, 8, 6),
+                    Margin = new Thickness(0, 0, 0, 8),
+                };
+                string[] lines = code.Lines.ToString().Replace("\r\n", "\n").TrimEnd('\n').Split('\n');
+                for (int i = 0; i < lines.Length; i++)
+                {
+                    if (i > 0)
+                    {
+                        paragraph.Inlines.Add(new LineBreak());
+                    }
+
+                    paragraph.Inlines.Add(new Run(lines[i]));
+                }
+
+                return paragraph;
+            }
+
+            case ThematicBreakBlock:
+                return new Paragraph
+                {
+                    BorderBrush = QuoteBorder,
+                    BorderThickness = new Thickness(0, 0, 0, 1),
+                    FontSize = 1,
+                    Margin = new Thickness(0, 4, 0, 10),
+                };
+
+            case HtmlBlock:
+                return null;
+
+            case ContainerBlock container:
+            {
+                var section = new Section();
+                foreach (MdBlock child in container)
+                {
+                    if (RenderBlock(child, baseUri) is { } rendered)
+                    {
+                        section.Blocks.Add(rendered);
+                    }
+                }
+
+                return section.Blocks.Count > 0 ? section : null;
+            }
+
+            case LeafBlock leaf when leaf.Inline != null:
+            {
+                var paragraph = new Paragraph { Margin = new Thickness(0, 0, 0, 8) };
+                AddInlines(paragraph.Inlines, leaf.Inline, baseUri);
+                return paragraph;
+            }
+
+            default:
+                return null;
+        }
+    }
+
+    private static void AddInlines(InlineCollection target, ContainerInline? container, Uri? baseUri)
+    {
+        if (container == null)
+        {
+            return;
+        }
+
+        foreach (MdInline inline in container)
+        {
+            if (RenderInline(inline, baseUri) is { } rendered)
+            {
+                target.Add(rendered);
+            }
+        }
+    }
+
+    private static WpfInline? RenderInline(MdInline inline, Uri? baseUri)
+    {
+        switch (inline)
+        {
+            case LiteralInline literal:
+                return new Run(literal.Content.ToString());
+
+            case CodeInline code:
+                return new Run(code.Content)
+                {
+                    FontFamily = CodeFont,
+                    FontSize = 12,
+                    Background = CodeBackground,
+                };
+
+            case LineBreakInline lineBreak:
+                return lineBreak.IsHard ? new LineBreak() : new Run(" ");
+
+            case TaskList task:
+                return new Run(task.Checked ? "\u2611 " : "\u2610 ");
+
+            case AutolinkInline autolink:
+                return CreateLink(new Span(new Run(autolink.Url)), autolink.IsEmail ? "mailto:" + autolink.Url : autolink.Url, baseUri);
+
+            case LinkInline link:
+            {
+                var span = new Span();
+                AddInlines(span.Inlines, link, baseUri);
+                if (span.Inlines.Count == 0)
+                {
+                    span.Inlines.Add(new Run(link.Url ?? string.Empty));
+                }
+
+                return CreateLink(span, link.Url, baseUri);
+            }
+
+            case EmphasisInline emphasis:
+            {
+                var span = new Span();
+                AddInlines(span.Inlines, emphasis, baseUri);
+                if (emphasis.DelimiterChar == '~')
+                {
+                    span.TextDecorations = TextDecorations.Strikethrough;
+                }
+                else if (emphasis.DelimiterCount >= 2)
+                {
+                    span.FontWeight = FontWeights.SemiBold;
+                }
+                else
+                {
+                    span.FontStyle = FontStyles.Italic;
+                }
+
+                return span;
+            }
+
+            case HtmlInline html when html.Tag.StartsWith("<br", StringComparison.OrdinalIgnoreCase):
+                return new LineBreak();
+
+            case HtmlEntityInline entity:
+                return new Run(entity.Transcoded.ToString());
+
+            case HtmlInline:
+                return null;
+
+            case ContainerInline container:
+            {
+                var span = new Span();
+                AddInlines(span.Inlines, container, baseUri);
+                return span;
+            }
+
+            default:
+                return null;
+        }
+    }
+
+    private static WpfInline CreateLink(Span content, string? url, Uri? baseUri)
+    {
+        Uri? target = ResolveUrl(url, baseUri);
+        if (target == null)
+        {
+            return content;
+        }
+
+        var link = new Hyperlink(content)
+        {
+            Foreground = Accent,
+            ToolTip = target.ToString(),
+            NavigateUri = target,
+        };
+        link.RequestNavigate += (_, e) =>
+        {
+            OpenUrl(e.Uri);
+            e.Handled = true;
+        };
+        return link;
+    }
+
+    private static Uri? ResolveUrl(string? url, Uri? baseUri)
+    {
+        if (string.IsNullOrWhiteSpace(url))
+        {
+            return null;
+        }
+
+        Uri? uri = Uri.TryCreate(url, UriKind.Absolute, out Uri? absolute) ? absolute
+            : baseUri != null && Uri.TryCreate(baseUri, url, out Uri? relative) ? relative
+            : null;
+        return uri != null && (uri.Scheme == Uri.UriSchemeHttps || uri.Scheme == Uri.UriSchemeHttp || uri.Scheme == Uri.UriSchemeMailto)
+            ? uri
+            : null;
+    }
+
+    public static void OpenUrl(Uri uri)
+    {
+        try
+        {
+            System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(uri.AbsoluteUri) { UseShellExecute = true });
+        }
+        catch (Exception)
+        {
+            // Zonder standaardbrowser gebeurt er niets; de link staat in de tooltip.
+        }
+    }
+
+    private static Brush Resource(string key, Brush fallback) =>
+        Application.Current?.TryFindResource(key) as Brush ?? fallback;
+
+    private static Brush Freeze(SolidColorBrush brush)
+    {
+        brush.Freeze();
+        return brush;
+    }
+}
@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Reflection;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Kniip.Update;
+
+public sealed class UpdateException : Exception
+{
+    public UpdateException(string message, Exception? inner = null) : base(message, inner)
+    {
+    }
+}
+
+public sealed record ReleaseInfo(
+    Version Version,
+    string Tag,
+    string Title,
+    DateTimeOffset? Date,
+    string Body,
+    string HtmlUrl,
+    string? InstallerUrl,
+    long InstallerSize);
+
+/// <summary>Leest de releases van kniip uit de Gitea/Forgejo-API van git.hibbit.net.</summary>
+public static class UpdateChecker
+{
+    public const string RepositoryUrl = "https://git.hibbit.net/rogier/kniip/";
+    public const string ReleasesPage = "https://git.hibbit.net/rogier/kniip/releases";
+    private const string ReleasesApi = "https://git.hibbit.net/api/v1/repos/rogier/kniip/releases?limit=20";
+
+    internal static readonly HttpClient Client = new() { Timeout = TimeSpan.FromMinutes(10) };
+
+    static UpdateChecker()
+    {
+        Client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("kniip", CurrentVersion.ToString()));
+    }
+
+    /// <summary>Versie van deze exe, altijd in drie delen (1.2.0).</summary>
+    public static Version CurrentVersion { get; } = Normalize(Assembly.GetEntryAssembly()?.GetName().Version ?? new Version(1, 0, 0));
+
+    /// <summary>Gepubliceerde releases, nieuwste eerst; concepten en voorversies vallen af.</summary>
+    public static async Task<IReadOnlyList<ReleaseInfo>> GetReleasesAsync(CancellationToken cancellationToken = default)
+    {
+        string body;
+        try
+        {
+            using var request = new HttpRequestMessage(HttpMethod.Get, ReleasesApi);
+            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
+            using var timeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            timeout.CancelAfter(TimeSpan.FromSeconds(20));
+            using HttpResponseMessage response = await Client.SendAsync(request, timeout.Token).ConfigureAwait(false);
+            if (response.StatusCode == HttpStatusCode.NotFound)
+            {
+                throw new UpdateException("De releases van kniip zijn niet gevonden op git.hibbit.net.");
+            }
+
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new UpdateException($"git.hibbit.net gaf een fout ({(int)response.StatusCode}).");
+            }
+
+            body = await response.Content.ReadAsStringAsync(timeout.Token).ConfigureAwait(false);
+        }
+        catch (TaskCanceledException ex) when (!cancellationToken.IsCancellationRequested)
+        {
+            throw new UpdateException("git.hibbit.net reageert niet (time-out).", ex);
+        }
+        catch (HttpRequestException ex)
+        {
+            throw new UpdateException("Kan git.hibbit.net niet bereiken. Controleer de internetverbinding.", ex);
+        }
+
+        try
+        {
+            return Parse(body);
+        }
+        catch (Exception ex) when (ex is JsonException or InvalidOperationException or KeyNotFoundException)
+        {
+            throw new UpdateException("Het antwoord van git.hibbit.net is niet te lezen.", ex);
+        }
+    }
+
+    private static List<ReleaseInfo> Parse(string json)
+    {
+        using JsonDocument document = JsonDocument.Parse(json);
+        var releases = new List<ReleaseInfo>();
+        foreach (JsonElement item in document.RootElement.EnumerateArray())
+        {
+            if (Bool(item, "draft") || Bool(item, "prerelease") || !TryParseVersion(String(item, "tag_name"), out Version version))
+            {
+                continue;
+            }
+
+            string? installerUrl = null;
+            long installerSize = 0;
+            if (item.TryGetProperty("assets", out JsonElement assets) && assets.ValueKind == JsonValueKind.Array)
+            {
+                foreach (JsonElement asset in assets.EnumerateArray())
+                {
+                    string name = String(asset, "name");
+                    if (name.StartsWith("Kniip-Setup-", StringComparison.OrdinalIgnoreCase)
+                        && name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
+                    {
+                        installerUrl = String(asset, "browser_download_url");
+                        installerSize = asset.TryGetProperty("size", out JsonElement size) && size.TryGetInt64(out long bytes) ? bytes : 0;
+                        break;
+                    }
+                }
+            }
+
+            DateTimeOffset? date = DateTimeOffset.TryParse(String(item, "published_at"), CultureInfo.InvariantCulture,
+                DateTimeStyles.None, out DateTimeOffset published) ? published : null;
+            string tag = String(item, "tag_name");
+            string title = String(item, "name");
+            releases.Add(new ReleaseInfo(version, tag, title.Length > 0 ? title : tag, date, String(item, "body"),
+                String(item, "html_url") is { Length: > 0 } url ? url : ReleasesPage,
+                string.IsNullOrEmpty(installerUrl) ? null : installerUrl, installerSize));
+        }
+
+        return releases.OrderByDescending(r => r.Version).ToList();
+    }
+
+    internal static bool TryParseVersion(string? tag, out Version version)
+    {
+        version = new Version(0, 0, 0);
+        string text = (tag ?? string.Empty).Trim().TrimStart('v', 'V');
+        int suffix = text.IndexOfAny(new[] { '-', '+' });
+        if (suffix >= 0)
+        {
+            text = text[..suffix];
+        }
+
+        if (!Version.TryParse(text.Contains('.') ? text : text + ".0", out Version? parsed))
+        {
+            return false;
+        }
+
+        version = Normalize(parsed);
+        return true;
+    }
+
+    private static Version Normalize(Version version) =>
+        new(version.Major, Math.Max(version.Minor, 0), Math.Max(version.Build, 0));
+
+    private static string String(JsonElement element, string name) =>
+        element.TryGetProperty(name, out JsonElement value) && value.ValueKind == JsonValueKind.String ? value.GetString() ?? string.Empty : string.Empty;
+
+    private static bool Bool(JsonElement element, string name) =>
+        element.TryGetProperty(name, out JsonElement value) && value.ValueKind == JsonValueKind.True;
+}
@@ -0,0 +1,100 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Kniip.Update;
+
+/// <summary>Downloadt de installer van een release en start die stil.</summary>
+public static class UpdateInstaller
+{
+    public static string DownloadFolder => Path.Combine(Path.GetTempPath(), "kniip-update");
+
+    public static async Task<string> DownloadAsync(ReleaseInfo release, IProgress<double>? progress = null,
+        CancellationToken cancellationToken = default)
+    {
+        if (release.InstallerUrl is not { } url)
+        {
+            throw new UpdateException($"Release {release.Tag} heeft geen installer.");
+        }
+
+        Directory.CreateDirectory(DownloadFolder);
+        string path = Path.Combine(DownloadFolder, $"Kniip-Setup-{release.Version}.exe");
+        string partial = path + ".download";
+        try
+        {
+            using (HttpResponseMessage response = await UpdateChecker.Client
+                       .GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false))
+            {
+                if (!response.IsSuccessStatusCode)
+                {
+                    throw new UpdateException($"Downloaden is mislukt ({(int)response.StatusCode}).");
+                }
+
+                long total = response.Content.Headers.ContentLength ?? release.InstallerSize;
+                await using Stream source = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
+                await using var target = new FileStream(partial, FileMode.Create, FileAccess.Write, FileShare.None, 81920, useAsync: true);
+                var buffer = new byte[81920];
+                long received = 0;
+                int read;
+                while ((read = await source.ReadAsync(buffer, cancellationToken).ConfigureAwait(false)) > 0)
+                {
+                    await target.WriteAsync(buffer.AsMemory(0, read), cancellationToken).ConfigureAwait(false);
+                    received += read;
+                    if (total > 0)
+                    {
+                        progress?.Report(Math.Min(1, (double)received / total));
+                    }
+                }
+
+                if (release.InstallerSize > 0 && received != release.InstallerSize)
+                {
+                    throw new UpdateException("De download is onvolledig; probeer het opnieuw.");
+                }
+            }
+
+            File.Move(partial, path, overwrite: true);
+            return path;
+        }
+        catch (TaskCanceledException ex) when (!cancellationToken.IsCancellationRequested)
+        {
+            throw new UpdateException("git.hibbit.net reageert niet (time-out).", ex);
+        }
+        catch (HttpRequestException ex)
+        {
+            throw new UpdateException("Downloaden is mislukt. Controleer de internetverbinding.", ex);
+        }
+        finally
+        {
+            TryDelete(partial);
+        }
+    }
+
+    /// <summary>Start de installer zonder vensters; die sluit kniip en start het daarna opnieuw.</summary>
+    public static void Start(string installerPath) =>
+        Process.Start(new ProcessStartInfo(installerPath)
+        {
+            Arguments = "/VERYSILENT /SUPPRESSMSGBOXES /NORESTART /CLOSEAPPLICATIONS",
+            UseShellExecute = true,
+            WorkingDirectory = Path.GetDirectoryName(installerPath) ?? string.Empty,
+        });
+
+    private static void TryDelete(string path)
+    {
+        try
+        {
+            if (File.Exists(path))
+            {
+                File.Delete(path);
+            }
+        }
+        catch (IOException)
+        {
+        }
+        catch (UnauthorizedAccessException)
+        {
+        }
+    }
+}
@@ -0,0 +1,97 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows.Threading;
+
+namespace Kniip.Update;
+
+/// <summary>Kijkt op de achtergrond of er een nieuwere versie is en meldt dat aan de vensters.</summary>
+public sealed class UpdateNotifier
+{
+    private static readonly TimeSpan FirstCheckDelay = TimeSpan.FromSeconds(10);
+    private static readonly TimeSpan CheckInterval = TimeSpan.FromHours(24);
+
+    private readonly DispatcherTimer _timer = new();
+    private bool _enabled;
+    private bool _checking;
+
+    public UpdateNotifier()
+    {
+        _timer.Tick += async (_, _) =>
+        {
+            _timer.Interval = CheckInterval;
+            await CheckAsync();
+        };
+    }
+
+    /// <summary>Nieuwste versie die nieuwer is dan deze exe; null als er niets nieuws is.</summary>
+    public ReleaseInfo? Available { get; private set; }
+
+    public bool IsUpdateAvailable => Available != null;
+
+    /// <summary>Wordt op de UI-thread afgevuurd als <see cref="Available"/> verandert.</summary>
+    public event EventHandler? AvailabilityChanged;
+
+    public void Apply(bool enabled)
+    {
+        if (enabled == _enabled)
+        {
+            return;
+        }
+
+        _enabled = enabled;
+        _timer.Stop();
+        if (enabled)
+        {
+            _timer.Interval = FirstCheckDelay;
+            _timer.Start();
+        }
+        else
+        {
+            Report(null);
+        }
+    }
+
+    /// <summary>Resultaat van een controle elders (de tab Update), zodat de melding gelijkloopt.</summary>
+    public void Report(ReleaseInfo? newest)
+    {
+        if (newest != null && newest.Version <= UpdateChecker.CurrentVersion)
+        {
+            newest = null;
+        }
+
+        bool changed = Available?.Version != newest?.Version;
+        Available = newest;
+        if (changed)
+        {
+            AvailabilityChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+
+    private async Task CheckAsync()
+    {
+        if (_checking)
+        {
+            return;
+        }
+
+        _checking = true;
+        try
+        {
+            IReadOnlyList<ReleaseInfo> releases = await UpdateChecker.GetReleasesAsync();
+            if (_enabled)
+            {
+                Report(releases.FirstOrDefault(r => r.Version > UpdateChecker.CurrentVersion));
+            }
+        }
+        catch (UpdateException)
+        {
+            // Een mislukte achtergrondcontrole is geen melding waard; de volgende poging komt vanzelf.
+        }
+        finally
+        {
+            _checking = false;
+        }
+    }
+}
@@ -0,0 +1,4 @@
+@echo off
+powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0remove-autostart.ps1"
+echo.
+pause
@@ -0,0 +1,75 @@
+# Haalt kniip uit Windows Opstart-apps voor de aangemelde gebruiker.
+# Bedoeld voor wie alleen Kniip.exe heeft gedraaid (geen installer): het pad van de exe
+# maakt niet uit, en het bestand hoeft er niet meer te staan.
+#
+# Elke Windows-account heeft een eigen opstartlijst. Draai dit script in de account
+# waarin kniip een keer is gestart. Beheerdersrechten zijn niet nodig.
+#
+#   powershell -NoProfile -ExecutionPolicy Bypass -File .\tools\remove-autostart.ps1
+#   of dubbelklik op remove-autostart.cmd
+
+$ErrorActionPreference = "Stop"
+
+$knownNames = @("Kniip", "KniipTest", "KnipPlus")
+$exePattern = '(?i)(^|[\\/"])(Kniip(Test)?(-[\d.]+)?|KnipPlus)\.exe(\b|")'
+
+function Test-KniipCommand([string]$text) {
+    return [bool]($text -match $exePattern)
+}
+
+function Remove-NamedValue([string]$keyPath, [string]$name) {
+    if (-not (Test-Path -LiteralPath $keyPath)) { return $false }
+    $key = Get-Item -LiteralPath $keyPath
+    if ($key.GetValueNames() -notcontains $name) { return $false }
+    Remove-ItemProperty -LiteralPath $keyPath -Name $name
+    return $true
+}
+
+$removed = New-Object System.Collections.Generic.List[string]
+$runKey = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run"
+$approvedRunKey = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run"
+$names = New-Object System.Collections.Generic.HashSet[string]
+
+foreach ($name in $knownNames) { [void]$names.Add($name) }
+
+if (Test-Path -LiteralPath $runKey) {
+    $run = Get-Item -LiteralPath $runKey
+    foreach ($name in @($run.GetValueNames())) {
+        $data = [string]$run.GetValue($name)
+        if ($names.Contains($name) -or (Test-KniipCommand $data)) {
+            Remove-ItemProperty -LiteralPath $runKey -Name $name
+            $removed.Add("Run\$name  ($data)")
+            [void]$names.Add($name)
+        }
+    }
+}
+
+foreach ($name in $names) {
+    if (Remove-NamedValue $approvedRunKey $name) {
+        $removed.Add("StartupApproved\Run\$name")
+    }
+}
+
+$startup = [Environment]::GetFolderPath("Startup")
+$approvedStartupKey = "HKCU:\Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\StartupFolder"
+$wsh = New-Object -ComObject WScript.Shell
+Get-ChildItem -LiteralPath $startup -Filter "*.lnk" -ErrorAction SilentlyContinue | ForEach-Object {
+    $shortcut = $wsh.CreateShortcut($_.FullName)
+    $hit = (Test-KniipCommand $shortcut.TargetPath) -or (Test-KniipCommand $shortcut.Arguments) -or ($knownNames -contains $_.BaseName)
+    if (-not $hit) { return }
+    Remove-Item -LiteralPath $_.FullName -Force
+    $removed.Add("Opstartmap\$($_.Name)")
+    if (Remove-NamedValue $approvedStartupKey $_.Name) {
+        $removed.Add("StartupApproved\StartupFolder\$($_.Name)")
+    }
+}
+
+if ($removed.Count -eq 0) {
+    Write-Host "Geen kniip-opstartregistratie gevonden voor $env:USERNAME."
+    exit 0
+}
+
+Write-Host "Verwijderd voor ${env:USERNAME}:"
+foreach ($line in $removed) { Write-Host "  $line" }
+Write-Host ""
+Write-Host "kniip staat niet meer in Opstart-apps. Staat de regel er nog, log dan een keer uit en weer in."
Author	SHA1	Message	Date
rogier	2f5c434623	Update README.md	2026-11-09 18:14:33 +01:00
rogier	89b84d8479	1.1.5	2026-11-09 17:57:31 +01:00
rogierandCursor	6d19b91963	1.1.5 Co-authored-by: Cursor <cursoragent@cursor.com>	2026-11-09 17:32:50 +01:00
rogier	43a2c4f57b	plans	2026-11-09 17:06:35 +01:00
rogierandCursor	b780c6a116	1.1.4 Update-melding, rechtermuisknopmenu in de editor. Co-authored-by: Cursor <cursoragent@cursor.com>	2026-11-09 17:00:58 +01:00
rogierandCursor	67c98c7c0a	1.1.4 Co-authored-by: Cursor <cursoragent@cursor.com>	2026-11-09 16:36:28 +01:00
rogier	5bdc851fa0	1.1.3	2026-11-09 13:02:24 +01:00
rogierandCursor	9b9ac36261	1.1.2 Co-authored-by: Cursor <cursoragent@cursor.com>	2026-11-09 00:38:41 +01:00
rogier	ceec9ecdc0	Toon alleen de laatste versie.	2026-11-09 00:26:57 +01:00
rogierandCursor	eb1fc40534	1.1.1 Co-authored-by: Cursor <cursoragent@cursor.com>	2026-11-09 00:18:46 +01:00
rogier	cc08b00e3b	1.1.0	2026-11-09 00:07:44 +01:00
rogier	e7ed05922e	remove-autostart	2026-11-07 12:41:54 +01:00
rogier	2d80538377	screenshot knipp app	2026-11-07 12:31:12 +01:00
rogier	c2673493dc	screenshot app	2026-11-07 12:27:10 +01:00